Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "AVRFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "bool", "isHandler", "=", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", "||", "CallConv", "==", "CallingConv", "::", "AVR_SIGNAL", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "!", "isHandler", ")", "{", "return", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "isHandler", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPRd", ")", ",", "AVR", "::", "R0", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "OUTARr", ")", ")", ".", "addImm", "(", "0x3f", ")", ".", "addReg", "(", "AVR", "::", "R0", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "POPWRd", ")", ",", "AVR", "::", "R1R0", ")", ";", "}", "if", "(", "!", "FrameSize", ")", "{", "return", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "int", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "AVR", "::", "POPRd", "&&", "Opc", "!=", "AVR", "::", "POPWRd", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "break", ";", "}", "--", "MBBI", ";", "}", "unsigned", "Opcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "FrameSize", ")", ")", "{", "Opcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "Opcode", "=", "AVR", "::", "SUBIWRdK", ";", "FrameSize", "=", "-", "FrameSize", ";", "}", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "AVR", "::", "R29R28", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "AVR", "AVR", "AVR", "AVR", "\"Can only insert epilog into returning blocks\"", "AVR", "AVR", "AVR", "AVR", "AVR", "AVR::POPRd", "AVR::R0", "AVR::OUTARr", "0x3f", "AVR::R0", "AVR::POPWRd", "AVR::R1R0", "AVR::POPRd", "AVR::POPWRd", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::R29R28", "AVR::R29R28", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R29R28" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "AssumptionCacheTracker", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "fusion_gpr_load_p", "(", "rtx", "addis_reg", ",", "rtx", "addis_value", ",", "rtx", "target", ",", "rtx", "mem", ")", "{", "rtx", "addr", ";", "rtx", "base_reg", ";", "if", "(", "!", "base_reg_operand", "(", "addis_reg", ",", "GET_MODE", "(", "addis_reg", ")", ")", ")", "return", "false", ";", "if", "(", "!", "base_reg_operand", "(", "target", ",", "GET_MODE", "(", "target", ")", ")", ")", "return", "false", ";", "if", "(", "!", "fusion_gpr_addis", "(", "addis_value", ",", "GET_MODE", "(", "addis_value", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "ZERO_EXTEND", "||", "(", "GET_CODE", "(", "mem", ")", "==", "SIGN_EXTEND", "&&", "TARGET_P8_FUSION_SIGN", ")", ")", "mem", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "!", "fusion_gpr_mem_load", "(", "mem", ",", "GET_MODE", "(", "mem", ")", ")", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", "&&", "GET_CODE", "(", "addr", ")", "!=", "LO_SUM", ")", "return", "false", ";", "if", "(", "REGNO", "(", "addis_reg", ")", "!=", "REGNO", "(", "target", ")", ")", "{", "if", "(", "reg_mentioned_p", "(", "target", ",", "mem", ")", ")", "return", "false", ";", "if", "(", "!", "peep2_reg_dead_p", "(", "2", ",", "addis_reg", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "target", ")", "&&", "REGNO", "(", "target", ")", "==", "STACK_POINTER_REGNUM", ")", "return", "false", ";", "}", "base_reg", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "return", "REGNO", "(", "addis_reg", ")", "==", "REGNO", "(", "base_reg", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "peephole2", "can", "combine", "a", "load", "involving", "a", "combination", "of", "an", "addis", "instruction", "and", "a", "load", "with", "an", "offset", "that", "can", "be", "fused", "together", "on", "a", "power8", "." ]

[ "powerpcspe", "0", "0", "2", "0" ]

[]

[ "<s>", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "RISCV" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Mips", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Mips", "Mips", "ISD::InputArg", "16", "Mips", "0", "1", "2", "0" ]

[]

[ "<s>", "bool", "NVPTXPassConfig", "::", "addInstSelector", "(", ")", "{", "const", "NVPTXSubtarget", "&", "ST", "=", "getTM", "<", "NVPTXTargetMachine", ">", "(", ")", ".", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ";", "addPass", "(", "createLowerAggrCopies", "(", ")", ")", ";", "addPass", "(", "createAllocaHoisting", "(", ")", ")", ";", "addPass", "(", "createNVPTXISelDag", "(", "getNVPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "ST", ".", "hasImageHandles", "(", ")", ")", "addPass", "(", "createNVPTXReplaceImageHandlesPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "TII", ".", "adjustStackPtr", "(", "Mips", "::", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "Mips", "Mips", "0", "Mips::ADJCALLSTACKDOWN", "Mips", "Mips", "Mips::SP" ]

[]

[ "<s>", "static", "bool", "ia64_vectorize_vec_perm_const_ok", "(", "machine_mode", "vmode", ",", "const", "unsigned", "char", "*", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "unsigned", "int", "i", ",", "nelt", ",", "which", ";", "bool", "ret", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "true", ";", "memcpy", "(", "d", ".", "perm", ",", "sel", ",", "nelt", ")", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "char", "e", "=", "d", ".", "perm", "[", "i", "]", ";", "gcc_assert", "(", "e", "<", "2", "*", "nelt", ")", ";", "which", "|=", "(", "e", "<", "nelt", "?", "1", ":", "2", ")", ";", "}", "if", "(", "which", "==", "2", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "d", ".", "one_operand_p", "=", "(", "which", "!=", "3", ")", ";", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "if", "(", "!", "d", ".", "one_operand_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "3", ")", ";", "start_sequence", "(", ")", ";", "ret", "=", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.vec_perm_const_ok", "." ]

[ "ia64", "0", "2", "1", "2", "2", "0", "3", "1", "2", "3" ]

[]

[ "<s>", "bool", "FPGATTIImpl", "::", "hasBranchDivergence", "(", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "FPGA", "FPGA" ]

[]

[ "<s>", "void", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "override", "{", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "TRI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "AAP" ]

[]

[ "<s>", "unsigned", "F2003fInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "F2003f", "F2003f", "\"code size not handled\"", "0" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addGCPasses", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "addGCPasses", "-", "Add", "late", "codegen", "passes", "that", "analyze", "code", "for", "garbage", "collection", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "Res", "=", "ExpandVectorExtension", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMADD64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMNAND64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSUB64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMXOR64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMSWAP64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMCMPXCHG64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMMIN64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMUMIN64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMMAX64_DAG", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ",", "ARMISD", "::", "ATOMUMAX64_DAG", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BITCAST", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::SRL", "ISD::SRA", "ISD::READCYCLECOUNTER", "ISD::ATOMIC_LOAD_ADD", "ARMISD::ATOMADD64_DAG", "ISD::ATOMIC_LOAD_AND", "ARMISD::ATOMAND64_DAG", "ISD::ATOMIC_LOAD_NAND", "ARMISD::ATOMNAND64_DAG", "ISD::ATOMIC_LOAD_OR", "ARMISD::ATOMOR64_DAG", "ISD::ATOMIC_LOAD_SUB", "ARMISD::ATOMSUB64_DAG", "ISD::ATOMIC_LOAD_XOR", "ARMISD::ATOMXOR64_DAG", "ISD::ATOMIC_SWAP", "ARMISD::ATOMSWAP64_DAG", "ISD::ATOMIC_CMP_SWAP", "ARMISD::ATOMCMPXCHG64_DAG", "ISD::ATOMIC_LOAD_MIN", "ARMISD::ATOMMIN64_DAG", "ISD::ATOMIC_LOAD_UMIN", "ARMISD::ATOMUMIN64_DAG", "ISD::ATOMIC_LOAD_MAX", "ARMISD::ATOMMAX64_DAG", "ISD::ATOMIC_LOAD_UMAX", "ARMISD::ATOMUMAX64_DAG" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "immediateExtend", "(", "MachineInstr", "&", "MI", ")", "const", "{", "assert", "(", "(", "isExtendable", "(", "MI", ")", "||", "isConstExtended", "(", "MI", ")", ")", "&&", "\"Instruction must be extendable\"", ")", ";", "short", "ExtOpNum", "=", "getCExtOpNum", "(", "MI", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "ExtOpNum", ")", ";", "assert", "(", "(", "MO", ".", "isMBB", "(", ")", "||", "MO", ".", "isImm", "(", ")", ")", "&&", "\"Branch with unknown extendable field type\"", ")", ";", "MO", ".", "addTargetFlag", "(", "HexagonII", "::", "HMOTF_ConstExtended", ")", ";", "}", "</s>" ]

[ "immediateExtend", "-", "Changes", "the", "instruction", "in", "place", "to", "one", "using", "an", "immediate", "extender", "." ]

[ "Hexagon", "Hexagon", "\"Instruction must be extendable\"", "\"Branch with unknown extendable field type\"", "HexagonII::HMOTF_ConstExtended" ]

[]

[ "<s>", "MCSymbol", "*", "AArch64AsmPrinter", "::", "GetCPISymbol", "(", "unsigned", "CPID", ")", "const", "{", "if", "(", "getDataLayout", "(", ")", ".", "getLinkerPrivateGlobalPrefix", "(", ")", "[", "0", "]", ")", "return", "OutContext", ".", "GetOrCreateSymbol", "(", "Twine", "(", "getDataLayout", "(", ")", ".", "getLinkerPrivateGlobalPrefix", "(", ")", ")", "+", "\"CPI\"", "+", "Twine", "(", "getFunctionNumber", "(", ")", ")", "+", "\"_\"", "+", "Twine", "(", "CPID", ")", ")", ";", "return", "OutContext", ".", "GetOrCreateSymbol", "(", "Twine", "(", "getDataLayout", "(", ")", ".", "getPrivateGlobalPrefix", "(", ")", ")", "+", "\"CPI\"", "+", "Twine", "(", "getFunctionNumber", "(", ")", ")", "+", "\"_\"", "+", "Twine", "(", "CPID", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "symbol", "for", "the", "specified", "constant", "pool", "entry", "." ]

[ "AArch64", "AArch64", "0", "\"CPI\"", "\"_\"", "\"CPI\"", "\"_\"" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "addPass", "(", "createSIModeRegisterPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "SIInsertHardClausesID", ")", ";", "addPass", "(", "&", "SILateBranchLoweringPassID", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "SIPreEmitPeepholeID", ")", ";", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "bool", "isMicroMips", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "STI", ".", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureMicroMips", ";", "}", "</s>" ]

[ "Check", "whether", "a", "given", "symbol", "has", "been", "flagged", "with", "MICROMIPS", "flag", "." ]

[ "Mips", "Mips", "Mips::FeatureMicroMips" ]

[]

[ "<s>", "bool", "Z80PassConfig", "::", "addPreISel", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "Z80", "Z80" ]

[]

[ "<s>", "unsigned", "MBlazeRegisterInfo", "::", "getPICCallReg", "(", ")", "{", "return", "MBlaze", "::", "R20", ";", "}", "</s>" ]

[ "Get", "PIC", "indirect", "call", "register", "." ]

[ "MBlaze", "MBlaze", "MBlaze::R20" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "if", "(", "isUInt", "<", "12", ">", "(", "NewOffset", ")", ")", "{", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "return", ";", "}", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "assert", "(", "Offset", "!=", "0", "&&", "\"Non-zero offset expected\"", ")", ";", "unsigned", "UnusedCarry", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "NewReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "BaseReg", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "NewReg", ",", "false", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU::OpName", "12", "AMDGPU::VGPR_32RegClass", "0", "\"Non-zero offset expected\"", "AMDGPU::SReg_64RegClass", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "xtensa_emit_move_sequence", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "CONSTANT_P", "(", "src", ")", "&&", "(", "GET_CODE", "(", "src", ")", "!=", "CONST_INT", "||", "!", "xtensa_simm12b", "(", "INTVAL", "(", "src", ")", ")", ")", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "if", "(", "xtensa_tls_referenced_p", "(", "src", ")", ")", "{", "rtx", "addend", "=", "NULL", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "==", "PLUS", ")", "{", "addend", "=", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ";", "src", "=", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ";", "}", "src", "=", "xtensa_legitimize_tls_address", "(", "src", ")", ";", "if", "(", "addend", ")", "{", "src", "=", "gen_rtx_PLUS", "(", "mode", ",", "src", ",", "addend", ")", ";", "src", "=", "force_operand", "(", "src", ",", "dst", ")", ";", "}", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "return", "1", ";", "}", "if", "(", "!", "TARGET_CONST16", ")", "{", "src", "=", "force_const_mem", "(", "SImode", ",", "src", ")", ";", "operands", "[", "1", "]", "=", "src", ";", "}", "if", "(", "mode", "!=", "SImode", ")", "{", "if", "(", "register_operand", "(", "dst", ",", "mode", ")", ")", "{", "emit_move_insn", "(", "simplify_gen_subreg", "(", "SImode", ",", "dst", ",", "mode", ",", "0", ")", ",", "src", ")", ";", "return", "1", ";", "}", "else", "{", "src", "=", "force_reg", "(", "SImode", ",", "src", ")", ";", "src", "=", "gen_lowpart_SUBREG", "(", "mode", ",", "src", ")", ";", "operands", "[", "1", "]", "=", "src", ";", "}", "}", "}", "if", "(", "!", "(", "reload_in_progress", "|", "reload_completed", ")", "&&", "!", "xtensa_valid_move", "(", "mode", ",", "operands", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "xtensa_copy_incoming_a7", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reload_in_progress", ")", "{", "operands", "[", "0", "]", "=", "fixup_subreg_mem", "(", "operands", "[", "0", "]", ")", ";", "operands", "[", "1", "]", "=", "fixup_subreg_mem", "(", "operands", "[", "1", "]", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", ".", "Return", "1", "if", "we", "have", "written", "out", "everything", "that", "needs", "to", "be", "done", "to", "do", "the", "move", ".", "Otherwise", ",", "return", "0", "and", "the", "caller", "will", "emit", "the", "move", "normally", "." ]

[ "xtensa", "1", "0", "0", "0", "1", "0", "0", "1", "1", "0", "1", "1", "1", "1", "1", "1", "0", "0", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "AlphaCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "{", "unsigned", "rv", "=", "0", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "rv", "=", "getAlphaRegNumber", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "rv", "=", "MO", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isCPI", "(", ")", ")", "{", "DOUT", "<<", "MO", "<<", "\" is a relocated op for \"", "<<", "MI", "<<", "\"\\n\"", ";", "unsigned", "Reloc", "=", "0", ";", "int", "Offset", "=", "0", ";", "bool", "useGOT", "=", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Alpha", "::", "BSR", ":", "Reloc", "=", "Alpha", "::", "reloc_bsr", ";", "break", ";", "case", "Alpha", "::", "LDLr", ":", "case", "Alpha", "::", "LDQr", ":", "case", "Alpha", "::", "LDBUr", ":", "case", "Alpha", "::", "LDWUr", ":", "case", "Alpha", "::", "LDSr", ":", "case", "Alpha", "::", "LDTr", ":", "case", "Alpha", "::", "LDAr", ":", "case", "Alpha", "::", "STQr", ":", "case", "Alpha", "::", "STLr", ":", "case", "Alpha", "::", "STWr", ":", "case", "Alpha", "::", "STBr", ":", "case", "Alpha", "::", "STSr", ":", "case", "Alpha", "::", "STTr", ":", "Reloc", "=", "Alpha", "::", "reloc_gprellow", ";", "break", ";", "case", "Alpha", "::", "LDAHr", ":", "Reloc", "=", "Alpha", "::", "reloc_gprelhigh", ";", "break", ";", "case", "Alpha", "::", "LDQl", ":", "Reloc", "=", "Alpha", "::", "reloc_literal", ";", "useGOT", "=", "true", ";", "break", ";", "case", "Alpha", "::", "LDAg", ":", "case", "Alpha", "::", "LDAHg", ":", "Reloc", "=", "Alpha", "::", "reloc_gpdist", ";", "Offset", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown relocatable instruction\"", ")", ";", "}", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getGV", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Reloc", ",", "MO", ".", "getGlobal", "(", ")", ",", "Offset", ",", "isa", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "useGOT", ")", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getExtSym", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Reloc", ",", "MO", ".", "getSymbolName", "(", ")", ",", "Offset", ",", "true", ")", ")", ";", "else", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getConstPool", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Reloc", ",", "MO", ".", "getIndex", "(", ")", ",", "Offset", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getBB", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Alpha", "::", "reloc_bsr", ",", "MO", ".", "getMBB", "(", ")", ")", ")", ";", "}", "else", "{", "cerr", "<<", "\"ERROR: Unknown type of MachineOperand: \"", "<<", "MO", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "return", "rv", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Alpha", "Alpha", "0", "Alpha", "\" is a relocated op for \"", "\"\\n\"", "0", "0", "Alpha::BSR", "Alpha::reloc_bsr", "Alpha::LDLr", "Alpha::LDQr", "Alpha::LDBUr", "Alpha::LDWUr", "Alpha::LDSr", "Alpha::LDTr", "Alpha::LDAr", "Alpha::STQr", "Alpha::STLr", "Alpha::STWr", "Alpha::STBr", "Alpha::STSr", "Alpha::STTr", "Alpha::reloc_gprellow", "Alpha::LDAHr", "Alpha::reloc_gprelhigh", "Alpha::LDQl", "Alpha::reloc_literal", "Alpha::LDAg", "Alpha::LDAHg", "Alpha::reloc_gpdist", "3", "\"unknown relocatable instruction\"", "Alpha::reloc_bsr", "\"ERROR: Unknown type of MachineOperand: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "static", "rtx", "mips16e_build_save_restore", "(", "bool", "restore_p", ",", "unsigned", "int", "*", "mask_ptr", ",", "HOST_WIDE_INT", "*", "offset_ptr", ",", "unsigned", "int", "nargs", ",", "HOST_WIDE_INT", "size", ")", "{", "rtx", "pattern", ",", "set", ";", "HOST_WIDE_INT", "offset", ",", "top_offset", ";", "unsigned", "int", "i", ",", "regno", ";", "int", "n", ";", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame", ".", "num_fp", "==", "0", ")", ";", "n", "=", "1", "+", "nargs", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mips16e_save_restore_regs", ")", ";", "i", "++", ")", "if", "(", "BITSET_P", "(", "*", "mask_ptr", ",", "mips16e_save_restore_regs", "[", "i", "]", ")", ")", "n", "++", ";", "pattern", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "n", ")", ")", ";", "n", "=", "0", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "restore_p", "?", "size", ":", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "XVECEXP", "(", "pattern", ",", "0", ",", "n", "++", ")", "=", "set", ";", "top_offset", "=", "restore_p", "?", "size", ":", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nargs", ";", "i", "++", ")", "{", "offset", "=", "top_offset", "+", "i", "*", "UNITS_PER_WORD", ";", "set", "=", "mips16e_save_restore_reg", "(", "restore_p", ",", "true", ",", "offset", ",", "GP_ARG_FIRST", "+", "i", ")", ";", "XVECEXP", "(", "pattern", ",", "0", ",", "n", "++", ")", "=", "set", ";", "}", "offset", "=", "top_offset", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mips16e_save_restore_regs", ")", ";", "i", "++", ")", "{", "regno", "=", "mips16e_save_restore_regs", "[", "i", "]", ";", "if", "(", "BITSET_P", "(", "*", "mask_ptr", ",", "regno", ")", ")", "{", "offset", "-=", "UNITS_PER_WORD", ";", "set", "=", "mips16e_save_restore_reg", "(", "restore_p", ",", "false", ",", "offset", ",", "regno", ")", ";", "XVECEXP", "(", "pattern", ",", "0", ",", "n", "++", ")", "=", "set", ";", "*", "mask_ptr", "&=", "~", "(", "1", "<<", "regno", ")", ";", "}", "}", "*", "offset_ptr", "=", "size", "+", "(", "offset", "-", "top_offset", ")", ";", "gcc_assert", "(", "n", "==", "XVECLEN", "(", "pattern", ",", "0", ")", ")", ";", "return", "pattern", ";", "}", "</s>" ]

[ "Return", "RTL", "for", "a", "MIPS16e", "SAVE", "or", "RESTORE", "instruction", ";", "RESTORE_P", "says", "which", ".", "The", "instruction", "must", ":", "-", "Allocate", "or", "deallocate", "SIZE", "bytes", "in", "total", ";", "SIZE", "is", "known", "to", "be", "nonzero", ".", "-", "Save", "or", "restore", "as", "many", "registers", "in", "*", "MASK_PTR", "as", "possible", ".", "The", "instruction", "saves", "the", "first", "registers", "at", "the", "top", "of", "the", "allocated", "area", ",", "with", "the", "other", "registers", "below", "it", ".", "-", "Save", "NARGS", "argument", "registers", "above", "the", "allocated", "area", ".", "(", "NARGS", "is", "always", "zero", "if", "RESTORE_P", ".", ")", "The", "SAVE", "and", "RESTORE", "instructions", "can", "not", "save", "and", "restore", "all", "general", "registers", ",", "so", "there", "may", "be", "some", "registers", "left", "over", "for", "the", "caller", "to", "handle", ".", "Destructively", "modify", "*", "MASK_PTR", "so", "that", "it", "contains", "the", "registers", "that", "still", "need", "to", "be", "saved", "or", "restored", ".", "The", "caller", "can", "save", "these", "registers", "in", "the", "memory", "immediately", "below", "*", "OFFSET_PTR", ",", "which", "is", "a", "byte", "offset", "from", "the", "bottom", "of", "the", "allocated", "stack", "area", "." ]

[ "mips", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "unsigned", "getEUsPerCU", "(", ")", "const", "{", "return", "AMDGPU", "::", "IsaInfo", "::", "getEUsPerCU", "(", "this", ")", ";", "}", "</s>" ]

[ "Number", "of", "SIMDs/EUs", "(", "execution", "units", ")", "per", "``", "CU", "''", "(", "``", "compute", "unit", "''", ")", ",", "where", "the", "``", "CU", "''", "is", "the", "unit", "onto", "which", "workgroups", "are", "mapped", "." ]

[ "AMDGPU", "AMDGPU::IsaInfo" ]

[]

[ "<s>", "bool", "SystemZPostRewrite", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "selectMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyNullifyDebugValueLists", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "Wasm", ")", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMemIntrinsicResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyDebugFixup", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "aarch64_mov128_immediate", "(", "rtx", "imm", ")", "{", "if", "(", "CONST_INT_P", "(", "imm", ")", ")", "return", "true", ";", "gcc_assert", "(", "CONST_WIDE_INT_NUNITS", "(", "imm", ")", "==", "2", ")", ";", "rtx", "lo", "=", "GEN_INT", "(", "CONST_WIDE_INT_ELT", "(", "imm", ",", "0", ")", ")", ";", "rtx", "hi", "=", "GEN_INT", "(", "CONST_WIDE_INT_ELT", "(", "imm", ",", "1", ")", ")", ";", "return", "aarch64_internal_mov_immediate", "(", "NULL_RTX", ",", "lo", ",", "false", ",", "DImode", ")", "+", "aarch64_internal_mov_immediate", "(", "NULL_RTX", ",", "hi", ",", "false", ",", "DImode", ")", "<=", "4", ";", "}", "</s>" ]

[ "Return", "whether", "imm", "is", "a", "128-bit", "immediate", "which", "is", "simple", "enough", "to", "expand", "inline", "." ]

[ "aarch64", "2", "0", "1", "4" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "llvm_unreachable", "(", "\"RelaxInstruction() unimplemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "SNES", "\"RelaxInstruction() unimplemented\"" ]

[]

[ "<s>", "static", "reg_class_t", "mips_ira_change_pseudo_allocno_class", "(", "int", "regno", ",", "reg_class_t", "allocno_class", ",", "reg_class_t", "best_class", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "INTEGRAL_MODE_P", "(", "PSEUDO_REGNO_MODE", "(", "regno", ")", ")", "&&", "allocno_class", "==", "ALL_REGS", ")", "return", "GR_REGS", ";", "return", "allocno_class", ";", "}", "</s>" ]

[ "Implement", "TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS", "." ]

[ "mips" ]

[]

[ "<s>", "static", "unsigned", "int", "ix86_minimum_incoming_stack_boundary", "(", "bool", "sibcall", ")", "{", "unsigned", "int", "incoming_stack_boundary", ";", "if", "(", "ix86_user_incoming_stack_boundary", ")", "incoming_stack_boundary", "=", "ix86_user_incoming_stack_boundary", ";", "else", "if", "(", "!", "sibcall", "&&", "ix86_force_align_arg_pointer", "&&", "crtl", "->", "stack_alignment_estimated", "==", "128", ")", "incoming_stack_boundary", "=", "MIN_STACK_BOUNDARY", ";", "else", "incoming_stack_boundary", "=", "ix86_default_incoming_stack_boundary", ";", "if", "(", "incoming_stack_boundary", ">", "MIN_STACK_BOUNDARY", "&&", "lookup_attribute", "(", "ix86_force_align_arg_pointer_string", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", ")", "incoming_stack_boundary", "=", "MIN_STACK_BOUNDARY", ";", "if", "(", "incoming_stack_boundary", "<", "crtl", "->", "parm_stack_boundary", ")", "incoming_stack_boundary", "=", "crtl", "->", "parm_stack_boundary", ";", "if", "(", "incoming_stack_boundary", ">", "MAIN_STACK_BOUNDARY", "&&", "DECL_NAME", "(", "current_function_decl", ")", "&&", "MAIN_NAME_P", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", "&&", "DECL_FILE_SCOPE_P", "(", "current_function_decl", ")", ")", "incoming_stack_boundary", "=", "MAIN_STACK_BOUNDARY", ";", "return", "incoming_stack_boundary", ";", "}", "</s>" ]

[ "Return", "minimum", "incoming", "stack", "alignment", "." ]

[ "i386", "128" ]

[]

[ "<s>", "static", "bool", "ix86_addr_space_zero_address_valid", "(", "addr_space_t", "as", ")", "{", "return", "as", "!=", "ADDR_SPACE_GENERIC", ";", "}", "</s>" ]

[ "All", "use", "of", "segmentation", "is", "assumed", "to", "make", "address", "0", "valid", "." ]

[ "i386" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "visium_reorg", "(", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "visium" ]

[]

[ "<s>", "MCObjectWriter", "*", "RISCVAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createRISCVELFObjectWriter", "(", "OS", ",", "OSABI", ",", "Is64Bit", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "AMDGPUCtorDtorLowering", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Modified", "=", "false", ";", "Modified", "|=", "createInitOrFiniKernel", "(", "M", ",", "M", ".", "getGlobalVariable", "(", "\"llvm.global_ctors\"", ")", ",", "true", ")", ";", "Modified", "|=", "createInitOrFiniKernel", "(", "M", ",", "M", ".", "getGlobalVariable", "(", "\"llvm.global_dtors\"", ")", ",", "false", ")", ";", "return", "Modified", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "AMDGPU", "\"llvm.global_ctors\"", "\"llvm.global_dtors\"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", "->", "getFeatureBits", "(", ")", ";", "return", "(", "CallerBits", "&", "CalleeBits", ")", "==", "CalleeBits", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "VideoCore4FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "VideoCore4InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "VideoCore4InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "VideoCore4RegisterInfo", "&", "RI", "=", "*", "static_cast", "<", "const", "VideoCore4RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "!=", "VideoCore4", "::", "RET", ")", "llvm_unreachable", "(", "\"can only insert epilog into returning blocks\"", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "}", "int", "stacksize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "stacksize", "+=", "4", ";", "TII", ".", "adjustStackPtr", "(", "stacksize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4::RET", "\"can only insert epilog into returning blocks\"", "4" ]

[]

[ "<s>", "void", "ix86_split_copysign_var", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "scratch", ",", "op0", ",", "op1", ",", "mask", ",", "nmask", ",", "x", ";", "dest", "=", "operands", "[", "0", "]", ";", "scratch", "=", "operands", "[", "1", "]", ";", "op0", "=", "operands", "[", "2", "]", ";", "op1", "=", "operands", "[", "3", "]", ";", "nmask", "=", "operands", "[", "4", "]", ";", "mask", "=", "operands", "[", "5", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "vmode", "=", "GET_MODE", "(", "mask", ")", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "{", "emit_move_insn", "(", "dest", ",", "op0", ")", ";", "return", ";", "}", "if", "(", "REG_P", "(", "mask", ")", "&&", "REGNO", "(", "dest", ")", "==", "REGNO", "(", "mask", ")", ")", "{", "gcc_assert", "(", "REGNO", "(", "op1", ")", "==", "REGNO", "(", "scratch", ")", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "scratch", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "x", ")", ")", ";", "dest", "=", "mask", ";", "op0", "=", "simplify_gen_subreg", "(", "vmode", ",", "op0", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_NOT", "(", "vmode", ",", "dest", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "x", ",", "op0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "}", "else", "{", "if", "(", "REGNO", "(", "op1", ")", "==", "REGNO", "(", "scratch", ")", ")", "{", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "scratch", ",", "mask", ")", ";", "}", "else", "{", "gcc_assert", "(", "REGNO", "(", "mask", ")", "==", "REGNO", "(", "scratch", ")", ")", ";", "op1", "=", "simplify_gen_subreg", "(", "vmode", ",", "op1", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "scratch", ",", "op1", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "x", ")", ")", ";", "if", "(", "REGNO", "(", "op0", ")", "==", "REGNO", "(", "dest", ")", ")", "{", "dest", "=", "simplify_gen_subreg", "(", "vmode", ",", "op0", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "nmask", ")", ";", "}", "else", "{", "gcc_assert", "(", "REGNO", "(", "nmask", ")", "==", "REGNO", "(", "dest", ")", ")", ";", "dest", "=", "nmask", ";", "op0", "=", "simplify_gen_subreg", "(", "vmode", ",", "op0", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "op0", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "}", "x", "=", "gen_rtx_IOR", "(", "vmode", ",", "dest", ",", "scratch", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Deconstruct", "a", "copysign", "operation", "into", "bit", "masks", ".", "Operand", "0", "is", "variable", ",", "so", "we", "have", "to", "do", "two", "masks", "." ]

[ "i386", "0", "1", "2", "3", "4", "5", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "BPFTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "char", "*", "err_msg", ";", "uint32_t", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unhandled custom legalization\"", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "case", "ISD", "::", "ATOMIC_SWAP", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP_WITH_SUCCESS", ":", "if", "(", "HasAlu32", "||", "Opcode", "==", "ISD", "::", "ATOMIC_LOAD_ADD", ")", "err_msg", "=", "\"Unsupported atomic operations, please use 32/64 bit version\"", ";", "else", "err_msg", "=", "\"Unsupported atomic operations, please use 64 bit version\"", ";", "break", ";", "}", "SDLoc", "DL", "(", "N", ")", ";", "fail", "(", "DL", ",", "DAG", ",", "err_msg", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "BPF", "BPF", "\"Unhandled custom legalization\"", "ISD::ATOMIC_LOAD_ADD", "ISD::ATOMIC_LOAD_AND", "ISD::ATOMIC_LOAD_OR", "ISD::ATOMIC_LOAD_XOR", "ISD::ATOMIC_SWAP", "ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS", "ISD::ATOMIC_LOAD_ADD", "\"Unsupported atomic operations, please use 32/64 bit version\"", "\"Unsupported atomic operations, please use 64 bit version\"" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "ignore", ")", "{", "tree", "fndecl", ";", "unsigned", "int", "fcode", ",", "avail", ";", "const", "struct", "mips_builtin_description", "*", "d", ";", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "gcc_assert", "(", "fcode", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ")", ";", "d", "=", "&", "mips_builtins", "[", "fcode", "]", ";", "avail", "=", "d", "->", "avail", "(", ")", ";", "gcc_assert", "(", "avail", "!=", "0", ")", ";", "if", "(", "TARGET_MIPS16", "&&", "!", "(", "avail", "&", "BUILTIN_AVAIL_MIPS16", ")", ")", "{", "error", "(", "\"built-in function %qE not supported for MIPS16\"", ",", "DECL_NAME", "(", "fndecl", ")", ")", ";", "return", "ignore", "?", "const0_rtx", ":", "CONST0_RTX", "(", "mode", ")", ";", "}", "switch", "(", "d", "->", "builtin_type", ")", "{", "case", "MIPS_BUILTIN_DIRECT", ":", "return", "mips_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "true", ")", ";", "case", "MIPS_BUILTIN_DIRECT_NO_TARGET", ":", "return", "mips_expand_builtin_direct", "(", "d", "->", "icode", ",", "target", ",", "exp", ",", "false", ")", ";", "case", "MIPS_BUILTIN_MOVT", ":", "case", "MIPS_BUILTIN_MOVF", ":", "return", "mips_expand_builtin_movtf", "(", "d", "->", "builtin_type", ",", "d", "->", "icode", ",", "d", "->", "cond", ",", "target", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_CMP_ANY", ":", "case", "MIPS_BUILTIN_CMP_ALL", ":", "case", "MIPS_BUILTIN_CMP_UPPER", ":", "case", "MIPS_BUILTIN_CMP_LOWER", ":", "case", "MIPS_BUILTIN_CMP_SINGLE", ":", "return", "mips_expand_builtin_compare", "(", "d", "->", "builtin_type", ",", "d", "->", "icode", ",", "d", "->", "cond", ",", "target", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_MSA_TEST_BRANCH", ":", "return", "mips_expand_builtin_msa_test_branch", "(", "d", "->", "icode", ",", "exp", ")", ";", "case", "MIPS_BUILTIN_BPOSGE32", ":", "return", "mips_expand_builtin_bposge", "(", "d", "->", "builtin_type", ",", "target", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Expand", "builtin", "functions", ".", "This", "is", "called", "from", "TARGET_EXPAND_BUILTIN", "." ]

[ "mips", "0", "0", "\"built-in function %qE not supported for MIPS16\"" ]

[]

[ "<s>", "static", "rtx", "Fpa", "(", "rtx", "par", ")", "{", "int", "len", "=", "XVECLEN", "(", "par", ",", "0", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", ")", "=", "1", ";", "return", "par", ";", "}", "</s>" ]

[ "Mark", "all", "the", "subexpressions", "of", "the", "PARALLEL", "rtx", "PAR", "as", "frame-related", ".", "Return", "PAR", ".", "dwarf2out.cc", ":", "dwarf2out_frame_debug_expr", "ignores", "sub-expressions", "of", "a", "PARALLEL", "rtx", "other", "than", "the", "first", "if", "they", "do", "not", "have", "the", "FRAME_RELATED", "flag", "set", "on", "them", "." ]

[ "h8300", "0", "0", "0", "1" ]

[]

[ "<s>", "TargetTransformInfo", "BPFTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "BPFTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "bool", "AArch64AddressTypePromotion", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "return", "false", ";", "Func", "=", "&", "F", ";", "ConsideredSExtType", "=", "Type", "::", "getInt64Ty", "(", "Func", "->", "getContext", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "Func", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Instructions", "SExtInsts", ";", "analyzeSExtension", "(", "SExtInsts", ")", ";", "return", "propagateSignExtension", "(", "SExtInsts", ")", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AArch64", "AArch64", "\"*** \"", "\": \"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "AVRRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "AVR", "::", "PTRDISPREGSRegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "AVR", "AVR", "AVR::PTRDISPREGSRegClass" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "TII", ".", "getFrameSize", "(", "*", "I", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "TII", ".", "getFrameAdjustment", "(", "*", "I", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "auto", "InsertPos", "=", "skipDebugInstructionsForward", "(", "I", ",", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "F", ".", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "if", "(", "!", "(", "F", ".", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "X86", "X86", "0", "0", "X86", "0" ]

[]

[ "<s>", "bool", "XCoreInstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "bool", "AtStart", "=", "MI", "==", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "BeforeI", "=", "MI", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "it", "->", "getReg", "(", ")", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "&", "RI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "if", "(", "AtStart", ")", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "MI", "=", "BeforeI", ";", "++", "MI", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "XCore", "XCore", "\"loadRegFromStackSlot didn't insert any code!\"" ]

[]

[ "<s>", "bool", "TVMMoveMaterializable", "::", "processInstruction", "(", "MachineInstr", "&", "MI", ")", "{", "bool", "Changed", "=", "false", ";", "auto", "Uses", "=", "reverse", "(", "MI", ".", "uses", "(", ")", ")", ";", "MachineInstr", "*", "InsertBefore", "=", "&", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "for", "(", "MachineOperand", "&", "Use", ":", "Uses", ")", "{", "if", "(", "Use", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "Use", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "Def", "=", "GetVRegDef", "(", "Reg", ",", "&", "MI", ",", "*", "MRI", ",", "*", "LIS", ")", ";", "if", "(", "Def", ")", "{", "if", "(", "HasOneUse", "(", "Reg", ",", "Def", ",", "*", "MRI", ",", "*", "MDT", ",", "*", "LIS", ")", "&&", "Def", "->", "getParent", "(", ")", "==", "MBB", "&&", "Def", "->", "getDesc", "(", ")", ".", "isRematerializable", "(", ")", "&&", "!", "TVM", "::", "isArgument", "(", "*", "Def", ")", "&&", "!", "TVM", "::", "isArgument", "(", "*", "InsertBefore", ")", ")", "{", "MBB", "->", "splice", "(", "InsertBefore", ",", "MBB", ",", "Def", ")", ";", "InsertBefore", "=", "Def", ";", "}", "Changed", "=", "true", ";", "}", "else", "if", "(", "Use", ".", "isUndef", "(", ")", ")", "{", "const", "ConstantInt", "*", "Value", ";", "if", "(", "TVM", "::", "isConstInt", "(", "*", "InsertBefore", ")", ")", "Value", "=", "InsertBefore", "->", "getOperand", "(", "1", ")", ".", "getCImm", "(", ")", ";", "else", "Value", "=", "cimm", "(", "*", "C", ",", "0", ")", ";", "unsigned", "RegConst", "=", "MRI", "->", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "InsertBefore", "=", "BuildMI", "(", "*", "MBB", ",", "*", "InsertBefore", ",", "InsertBefore", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TVM", "::", "CONST_I257", ")", ",", "RegConst", ")", ".", "addCImm", "(", "Value", ")", ";", "Use", ".", "ChangeToRegister", "(", "RegConst", ",", "false", ",", "false", ",", "true", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "TVM", "TVM", "TVM::isArgument", "TVM::isArgument", "TVM::isConstInt", "1", "0", "TVM::I257RegClass", "TVM::CONST_I257" ]

[]

[ "<s>", "static", "rtx", "sh_function_arg", "(", "cumulative_args_t", "ca_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "ca", "->", "renesas_abi", "?", "const1_rtx", ":", "const0_rtx", ";", "if", "(", "sh_pass_in_reg_p", "(", "*", "ca", ",", "mode", ",", "type", ")", "&&", "(", "named", "||", "!", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", ")", ")", "{", "int", "regno", ";", "if", "(", "mode", "==", "SCmode", "&&", "TARGET_SH4", "&&", "TARGET_LITTLE_ENDIAN", "&&", "(", "!", "FUNCTION_ARG_SCmode_WART", "||", "(", "sh_round_reg", "(", "*", "ca", ",", "mode", ")", "&", "1", ")", ")", ")", "{", "rtx", "r1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SFmode", ",", "BASE_ARG_REG", "(", "mode", ")", "+", "(", "sh_round_reg", "(", "*", "ca", ",", "mode", ")", "^", "1", ")", ")", ",", "const0_rtx", ")", ";", "rtx", "r2", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SFmode", ",", "BASE_ARG_REG", "(", "mode", ")", "+", "(", "(", "sh_round_reg", "(", "*", "ca", ",", "mode", ")", "+", "1", ")", "^", "1", ")", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "SCmode", ",", "gen_rtvec", "(", "2", ",", "r1", ",", "r2", ")", ")", ";", "}", "if", "(", "(", "TARGET_HITACHI", "||", "ca", "->", "renesas_abi", ")", "&&", "ca", "->", "free_single_fp_reg", "&&", "mode", "==", "SFmode", ")", "return", "gen_rtx_REG", "(", "mode", ",", "ca", "->", "free_single_fp_reg", ")", ";", "regno", "=", "(", "BASE_ARG_REG", "(", "mode", ")", "+", "sh_round_reg", "(", "*", "ca", ",", "mode", ")", ")", "^", "(", "mode", "==", "SFmode", "&&", "TARGET_SH4", "&&", "TARGET_LITTLE_ENDIAN", "&&", "!", "TARGET_HITACHI", "&&", "!", "ca", "->", "renesas_abi", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "SH", "the", "first", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", ".", "Any", "arg", "that", "starts", "within", "the", "first", "NPARM_REGS", "words", "is", "at", "least", "partially", "passed", "in", "a", "register", "unless", "its", "data", "type", "forbids", "." ]

[ "sh", "1", "1", "1", "1", "4", "2" ]

[]

[ "<s>", "static", "void", "pa_output_function_epilogue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "insn", "=", "get_last_insn", "(", ")", ";", "last_address", "=", "0", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "NOTE", ")", "insn", "=", "prev_real_insn", "(", "insn", ")", ";", "if", "(", "insn", "&&", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "insn", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ";", "if", "(", "insn", "&&", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "{", "fputs", "(", "\"\\tnop\\n\"", ",", "file", ")", ";", "last_address", "+=", "4", ";", "}", "fputs", "(", "\"\\t.EXIT\\n\\t.PROCEND\\n\"", ",", "file", ")", ";", "if", "(", "TARGET_SOM", "&&", "TARGET_GAS", ")", "{", "forget_section", "(", ")", ";", "}", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "insn", "=", "get_last_nonnote_insn", "(", ")", ";", "last_address", "+=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "last_address", "+=", "insn_default_length", "(", "insn", ")", ";", "last_address", "=", "(", "(", "last_address", "+", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", "&", "~", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", ")", ";", "}", "update_total_code_bytes", "(", "last_address", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "exit", ".", "Args", "are", "as", "for", "output_function_prologue", "(", ")", ".", "The", "function", "epilogue", "should", "not", "depend", "on", "the", "current", "stack", "pointer", "!", "It", "should", "use", "the", "frame", "pointer", "only", ".", "This", "is", "mandatory", "because", "of", "alloca", ";", "we", "also", "take", "advantage", "of", "it", "to", "omit", "stack", "adjustments", "before", "returning", "." ]

[ "pa", "0", "0", "0", "\"\\tnop\\n\"", "4", "\"\\t.EXIT\\n\\t.PROCEND\\n\"", "1", "1" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "RegisterVT", "=", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "VT", ".", "getFixedSizeInBits", "(", ")", "<", "RegisterVT", ".", "getFixedSizeInBits", "(", ")", "?", "VT", ".", "getVectorNumElements", "(", ")", ":", "divideCeil", "(", "VT", ".", "getSizeInBits", "(", ")", ",", "RegisterVT", ".", "getSizeInBits", "(", ")", ")", ";", "return", "NumIntermediates", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "bool", "rs6000_expand_vec_perm_const_1", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "unsigned", "char", "perm0", ",", "unsigned", "char", "perm1", ")", "{", "rtx", "x", ";", "if", "(", "(", "perm0", "&", "2", ")", "==", "(", "perm1", "&", "2", ")", ")", "{", "if", "(", "perm0", "&", "2", ")", "op0", "=", "op1", ";", "else", "op1", "=", "op0", ";", "}", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "{", "perm0", "=", "perm0", "&", "1", ";", "perm1", "=", "(", "perm1", "&", "1", ")", "+", "2", ";", "}", "else", "if", "(", "perm0", "&", "2", ")", "{", "if", "(", "perm1", "&", "2", ")", "return", "false", ";", "perm0", "-=", "2", ";", "perm1", "+=", "2", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "}", "else", "if", "(", "(", "perm1", "&", "2", ")", "==", "0", ")", "return", "false", ";", "if", "(", "target", "!=", "NULL", ")", "{", "machine_mode", "vmode", ",", "dmode", ";", "rtvec", "v", ";", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "gcc_assert", "(", "GET_MODE_NUNITS", "(", "vmode", ")", "==", "2", ")", ";", "dmode", "=", "mode_for_vector", "(", "GET_MODE_INNER", "(", "vmode", ")", ",", "4", ")", ".", "require", "(", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "dmode", ",", "op0", ",", "op1", ")", ";", "v", "=", "gen_rtvec", "(", "2", ",", "GEN_INT", "(", "perm0", ")", ",", "GEN_INT", "(", "perm1", ")", ")", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "vmode", ",", "x", ",", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "v", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "x", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "Paired", "Single", "or", "VSX", "Permute", "Doubleword", "constant", "permutation", ".", "Return", "true", "if", "we", "match", "an", "efficient", "implementation", "." ]

[ "rs6000", "2", "2", "2", "1", "1", "2", "2", "2", "2", "2", "2", "0", "2", "4", "2" ]

[]

[ "<s>", "void", "dimode_scalar_chain", "::", "convert_registers", "(", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "defs", ",", "0", ",", "id", ",", "bi", ")", "convert_reg", "(", "id", ")", ";", "EXECUTE_IF_AND_COMPL_IN_BITMAP", "(", "defs_conv", ",", "defs", ",", "0", ",", "id", ",", "bi", ")", "make_vector_copies", "(", "id", ")", ";", "}", "</s>" ]

[ "Generate", "copies", "from", "defs", "used", "by", "the", "chain", "but", "not", "defined", "therein", ".", "Also", "populates", "defs_map", "which", "is", "used", "later", "by", "convert_insn", "." ]

[ "i386", "0", "0" ]

[]

[ "<s>", "void", "spu_expand_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "orig_before", ",", "rtx", "orig_after", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "before", "=", "orig_before", ",", "after", "=", "orig_after", ";", "if", "(", "before", "==", "NULL_RTX", ")", "before", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "before", ",", "mem", ")", ";", "if", "(", "code", "==", "MULT", ")", "{", "rtx", "x", "=", "expand_simple_binop", "(", "mode", ",", "AND", ",", "before", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "after", "=", "expand_simple_unop", "(", "mode", ",", "NOT", ",", "x", ",", "after", ",", "1", ")", ";", "}", "else", "{", "after", "=", "expand_simple_binop", "(", "mode", ",", "code", ",", "before", ",", "val", ",", "after", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "}", "emit_move_insn", "(", "mem", ",", "after", ")", ";", "if", "(", "orig_after", "&&", "after", "!=", "orig_after", ")", "emit_move_insn", "(", "orig_after", ",", "after", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "fetch-and-operate", "pattern", ".", "CODE", "is", "the", "binary", "operation", "to", "perform", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "VAL", "is", "the", "second", "operand", "of", "the", "binary", "operator", ".", "BEFORE", "and", "AFTER", "are", "optional", "locations", "to", "return", "the", "value", "of", "MEM", "either", "before", "of", "after", "the", "operation", "." ]

[ "spu", "1", "1", "1" ]

[]

[ "<s>", "int", "VEFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "VESubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "VESubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "VERegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "VEMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "VEMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", "=", "true", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FrameOffset", ";", "}", "FrameReg", "=", "VE", "::", "SX11", ";", "return", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "VE", "VE", "VE", "VE", "VE", "VE", "VE", "VE::SX11" ]

[]

[ "<s>", "BitVector", "MOSRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "=", "this", "->", "Reserved", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "reserveAllSubregs", "(", "&", "Reserved", ",", "getFrameRegister", "(", "MF", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "void", "predict_jump", "(", "int", "prob", ")", "{", "rtx", "insn", "=", "get_last_insn", "(", ")", ";", "gcc_assert", "(", "JUMP_P", "(", "insn", ")", ")", ";", "add_int_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "prob", ")", ";", "}", "</s>" ]

[ "Predict", "just", "emitted", "jump", "instruction", "to", "be", "taken", "with", "probability", "PROB", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "avr_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "2", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "0", ",", "\"pointer offset from symbol maybe incorrect\"", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>" ]

[ "Output", "ADDR", "to", "FILE", "as", "address", "." ]

[ "avr", "\"-%s\"", "0", "\"%s+\"", "0", "0", "1", "\"gs(\"", "0", "\"+\"", "\")\"", "2", "1", "0", "\"pointer offset from symbol maybe incorrect\"", "\"\\n\"", "\"gs(\"", "\")\"" ]

[]

[ "<s>", "int", "ix86_data_alignment", "(", "tree", "type", ",", "int", "align", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "(", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ">=", "256", "||", "TREE_INT_CST_HIGH", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "&&", "align", "<", "256", ")", "return", "256", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "(", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ">=", "128", "||", "TREE_INT_CST_HIGH", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{", "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "for", "a", "static", "variable", ".", "TYPE", "is", "the", "data", "type", ",", "and", "ALIGN", "is", "the", "alignment", "that", "the", "object", "would", "ordinarily", "have", ".", "The", "value", "of", "this", "function", "is", "used", "instead", "of", "that", "alignment", "to", "align", "the", "object", "." ]

[ "i386", "256", "256", "256", "128", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Mips" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV4TOps", "(", "false", ")", ",", "HasV5TOps", "(", "false", ")", ",", "HasV5TEOps", "(", "false", ")", ",", "HasV6Ops", "(", "false", ")", ",", "HasV6T2Ops", "(", "false", ")", ",", "HasV7Ops", "(", "false", ")", ",", "HasVFPv2", "(", "false", ")", ",", "HasVFPv3", "(", "false", ")", ",", "HasVFPv4", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "UseNEONForSinglePrecisionFP", "(", "false", ")", ",", "SlowFPVMLx", "(", "false", ")", ",", "HasVMLxForwarding", "(", "false", ")", ",", "SlowFPBrcc", "(", "false", ")", ",", "InThumbMode", "(", "false", ")", ",", "HasThumb2", "(", "false", ")", ",", "IsMClass", "(", "false", ")", ",", "NoARM", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "IsR9Reserved", "(", "ReserveR9", ")", ",", "UseMovt", "(", "false", ")", ",", "SupportsTailCall", "(", "false", ")", ",", "HasFP16", "(", "false", ")", ",", "HasD16", "(", "false", ")", ",", "HasHardwareDivide", "(", "false", ")", ",", "HasT2ExtractPack", "(", "false", ")", ",", "HasDataBarrier", "(", "false", ")", ",", "Pref32BitThumb", "(", "false", ")", ",", "AvoidCPSRPartialUpdate", "(", "false", ")", ",", "HasMPExtension", "(", "false", ")", ",", "FPOnlySP", "(", "false", ")", ",", "AllowsUnalignedMem", "(", "false", ")", ",", "Thumb2DSP", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "std", "::", "string", "ArchFS", "=", "ARM_MC", "::", "ParseARMTriple", "(", "TT", ")", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "ArchFS", ".", "empty", "(", ")", ")", "ArchFS", "=", "ArchFS", "+", "\",\"", "+", "FS", ";", "else", "ArchFS", "=", "FS", ";", "}", "ParseSubtargetFeatures", "(", "CPUString", ",", "ArchFS", ")", ";", "if", "(", "!", "HasV6T2Ops", "&&", "hasThumb2", "(", ")", ")", "HasV4TOps", "=", "HasV5TOps", "=", "HasV5TEOps", "=", "HasV6Ops", "=", "HasV6T2Ops", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUString", ")", ";", "computeIssueWidth", "(", ")", ";", "if", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "!", "isTargetIOS", "(", ")", ")", "UseMovt", "=", "hasV6T2Ops", "(", ")", ";", "else", "{", "IsR9Reserved", "=", "ReserveR9", "|", "!", "HasV6Ops", ";", "UseMovt", "=", "DarwinUseMOVT", "&&", "hasV6T2Ops", "(", ")", ";", "SupportsTailCall", "=", "!", "getTargetTriple", "(", ")", ".", "isOSVersionLT", "(", "5", ",", "0", ")", ";", "}", "if", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", "PostRAScheduler", "=", "true", ";", "if", "(", "!", "StrictAlign", "&&", "hasV6Ops", "(", ")", "&&", "isTargetDarwin", "(", ")", ")", "AllowsUnalignedMem", "=", "true", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "4", "ARM", "\"generic\"", "ARM", "ARM", "\",\"", "\"eabi\"", "ARM", "8", "5", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DstReg", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Cond array\"", ")", ";", "unsigned", "Opc", "=", "getCMovFromCond", "(", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ",", "MRI", ".", "getRegClass", "(", "DstReg", ")", "->", "getSize", "(", ")", "/", "8", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "X86", "X86", "1", "\"Invalid Cond array\"", "X86::CondCode", "0", "8" ]

[]

[ "<s>", "static", "const", "char", "*", "shift_op", "(", "rtx", "op", ",", "HOST_WIDE_INT", "*", "amountp", ")", "{", "const", "char", "*", "mnem", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "switch", "(", "code", ")", "{", "case", "ROTATE", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "code", "=", "ROTATERT", ";", "*", "amountp", "=", "32", "-", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "mnem", "=", "\"ror\"", ";", "break", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ROTATERT", ":", "mnem", "=", "arm_shift_nmem", "(", "code", ")", ";", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "*", "amountp", "=", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "*", "amountp", "=", "-", "1", ";", "return", "mnem", ";", "}", "else", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "break", ";", "case", "MULT", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "*", "amountp", "=", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&", "0xFFFFFFFF", ";", "if", "(", "*", "amountp", "&", "(", "*", "amountp", "-", "1", ")", ")", "{", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "*", "amountp", "=", "exact_log2", "(", "*", "amountp", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "*", "amountp", ",", "0", ",", "31", ")", ")", ";", "return", "ARM_LSL_NAME", ";", "default", ":", "output_operand_lossage", "(", "\"invalid shift operand\"", ")", ";", "return", "NULL", ";", "}", "if", "(", "code", "==", "ROTATERT", ")", "*", "amountp", "&=", "31", ";", "else", "if", "(", "*", "amountp", "!=", "(", "*", "amountp", "&", "31", ")", ")", "{", "if", "(", "code", "==", "ASHIFT", ")", "mnem", "=", "\"lsr\"", ";", "*", "amountp", "=", "32", ";", "}", "if", "(", "*", "amountp", "==", "0", ")", "return", "NULL", ";", "return", "mnem", ";", "}", "</s>" ]

[ "Ensure", "valid", "constant", "shifts", "and", "return", "the", "appropriate", "shift", "mnemonic", "for", "the", "operation", "code", ".", "The", "returned", "result", "should", "not", "be", "overwritten", ".", "OP", "is", "the", "rtx", "code", "of", "the", "shift", ".", "On", "exit", ",", "*", "AMOUNTP", "will", "be", "-1", "if", "the", "shift", "is", "by", "a", "register", ",", "or", "a", "constant", "shift", "." ]

[ "arm", "1", "\"invalid shift operand\"", "32", "1", "\"ror\"", "1", "1", "1", "1", "\"invalid shift operand\"", "1", "\"invalid shift operand\"", "1", "0xFFFFFFFF", "1", "\"invalid shift operand\"", "0", "31", "\"invalid shift operand\"", "31", "31", "\"lsr\"", "32", "0" ]

[]

[ "<s>", "static", "bool", "ix86_expand_vector_init_duplicate", "(", "bool", "mmx_ok", ",", "enum", "machine_mode", "mode", ",", "rtx", "target", ",", "rtx", "val", ")", "{", "enum", "machine_mode", "smode", ",", "wsmode", ",", "wvmode", ";", "rtx", "x", ";", "switch", "(", "mode", ")", "{", "case", "V2SImode", ":", "case", "V2SFmode", ":", "if", "(", "!", "mmx_ok", "&&", "!", "TARGET_SSE", ")", "return", "false", ";", "case", "V2DFmode", ":", "case", "V2DImode", ":", "case", "V4SFmode", ":", "case", "V4SImode", ":", "val", "=", "force_reg", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "val", ")", ";", "x", "=", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "return", "true", ";", "case", "V4HImode", ":", "if", "(", "!", "mmx_ok", ")", "return", "false", ";", "if", "(", "TARGET_SSE", "||", "TARGET_3DNOW_A", ")", "{", "val", "=", "gen_lowpart", "(", "SImode", ",", "val", ")", ";", "x", "=", "gen_rtx_TRUNCATE", "(", "HImode", ",", "val", ")", ";", "x", "=", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "return", "true", ";", "}", "else", "{", "smode", "=", "HImode", ";", "wsmode", "=", "SImode", ";", "wvmode", "=", "V2SImode", ";", "goto", "widen", ";", "}", "case", "V8QImode", ":", "if", "(", "!", "mmx_ok", ")", "return", "false", ";", "smode", "=", "QImode", ";", "wsmode", "=", "HImode", ";", "wvmode", "=", "V4HImode", ";", "goto", "widen", ";", "case", "V8HImode", ":", "smode", "=", "HImode", ";", "wsmode", "=", "SImode", ";", "wvmode", "=", "V4SImode", ";", "goto", "widen", ";", "case", "V16QImode", ":", "smode", "=", "QImode", ";", "wsmode", "=", "HImode", ";", "wvmode", "=", "V8HImode", ";", "goto", "widen", ";", "widen", ":", "val", "=", "convert_modes", "(", "wsmode", ",", "smode", ",", "val", ",", "true", ")", ";", "x", "=", "expand_simple_binop", "(", "wsmode", ",", "ASHIFT", ",", "val", ",", "GEN_INT", "(", "GET_MODE_BITSIZE", "(", "smode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "val", "=", "expand_simple_binop", "(", "wsmode", ",", "IOR", ",", "val", ",", "x", ",", "x", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "x", "=", "gen_reg_rtx", "(", "wvmode", ")", ";", "if", "(", "!", "ix86_expand_vector_init_duplicate", "(", "mmx_ok", ",", "wvmode", ",", "x", ",", "val", ")", ")", "gcc_unreachable", "(", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "x", ")", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vector_init", ".", "Store", "into", "TARGET", "a", "vector", "with", "all", "elements", "equal", "to", "VAR", ".", "Return", "true", "if", "successful", "." ]

[ "i386", "1", "1" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "Z80", "MVT::i8" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "PPCInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "PPCII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PLT", ",", "\"ppc-plt\"", "}", ",", "{", "MO_PIC_FLAG", ",", "\"ppc-pic\"", "}", ",", "{", "MO_PCREL_FLAG", ",", "\"ppc-pcrel\"", "}", ",", "{", "MO_GOT_FLAG", ",", "\"ppc-got\"", "}", ",", "{", "MO_PCREL_OPT_FLAG", ",", "\"ppc-opt-pcrel\"", "}", ",", "{", "MO_TLSGD_FLAG", ",", "\"ppc-tlsgd\"", "}", ",", "{", "MO_TLSLD_FLAG", ",", "\"ppc-tlsld\"", "}", ",", "{", "MO_TPREL_FLAG", ",", "\"ppc-tprel\"", "}", ",", "{", "MO_TLSGDM_FLAG", ",", "\"ppc-tlsgdm\"", "}", ",", "{", "MO_GOT_TLSGD_PCREL_FLAG", ",", "\"ppc-got-tlsgd-pcrel\"", "}", ",", "{", "MO_GOT_TLSLD_PCREL_FLAG", ",", "\"ppc-got-tlsld-pcrel\"", "}", ",", "{", "MO_GOT_TPREL_PCREL_FLAG", ",", "\"ppc-got-tprel-pcrel\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "PowerPC", "PPC", "PPC", "\"ppc-plt\"", "\"ppc-pic\"", "\"ppc-pcrel\"", "\"ppc-got\"", "\"ppc-opt-pcrel\"", "\"ppc-tlsgd\"", "\"ppc-tlsld\"", "\"ppc-tprel\"", "\"ppc-tlsgdm\"", "\"ppc-got-tlsgd-pcrel\"", "\"ppc-got-tlsld-pcrel\"", "\"ppc-got-tprel-pcrel\"" ]

[]

[ "<s>", "static", "int", "symbolic_expression_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "return", "symbolic_expression_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "UNARY_P", "(", "x", ")", ")", "return", "symbolic_expression_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "ARITHMETIC_P", "(", "x", ")", ")", "return", "(", "symbolic_expression_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "symbolic_expression_p", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "X", "contains", "a", "symbolic", "expression", ".", "We", "know", "these", "expressions", "will", "have", "one", "of", "a", "few", "well", "defined", "forms", ",", "so", "we", "need", "only", "check", "those", "forms", "." ]

[ "iq2000", "1", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "DXILTranslateMetadata", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "MDNode", "*", "ValVerMD", "=", "cast_or_null", "<", "MDNode", ">", "(", "M", ".", "getModuleFlag", "(", "ValVerKey", ")", ")", ")", "{", "auto", "ValVer", "=", "loadDXILValidatorVersion", "(", "ValVerMD", ")", ";", "if", "(", "!", "ValVer", ".", "empty", "(", ")", ")", "ValidatorVer", "=", "ValVer", ";", "}", "emitDXILValidatorVersion", "(", "M", ",", "ValidatorVer", ")", ";", "cleanModule", "(", "M", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "DirectX", "DXIL", "DXIL", "DXIL" ]

[]

[ "<s>", "int", "NVPTXTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "if", "(", "LT", ".", "second", ".", "SimpleTy", "==", "MVT", "::", "i64", ")", "return", "2", "*", "LT", ".", "first", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "MVT::i64", "2" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Sparc32", ")", ";", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "RetAddrOffset", "=", "8", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "SparcMachineFunctionInfo", "*", "SFI", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "SFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "SP", "::", "I0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "SP", "::", "I0", ")", ";", "RetAddrOffset", "=", "12", ";", "}", "SDValue", "RetAddrOffsetNode", "=", "DAG", ".", "getConstant", "(", "RetAddrOffset", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetAddrOffsetNode", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SPISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "RetAddrOffsetNode", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Sparc", "Sparc", "ISD::OutputArg", "16", "Sparc", "0", "0", "\"Can only return in registers!\"", "1", "8", "Sparc", "Sparc", "\"sret virtual register not created in the entry block\"", "SP::I0", "1", "SP::I0", "12", "MVT::i32", "SPISD::RET_FLAG", "MVT::Other", "SPISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FPReg", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "bool", "isWin64", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "if", "(", "!", "X86", "::", "VR128RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "isWin64", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "&", "RI", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "X86", "X86", "X86", "X86", "X86::POP64r", "X86::POP32r", "0", "X86::VR128RegClass" ]

[]

[ "<s>", "static", "int", "sh_round_reg", "(", "const", "CUMULATIVE_ARGS", "&", "cum", ",", "machine_mode", "mode", ")", "{", "return", "(", "(", "(", "TARGET_ALIGN_DOUBLE", "||", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DCmode", ")", "&&", "cum", ".", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "<", "NPARM_REGS", "(", "mode", ")", ")", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "?", "(", "cum", ".", "arg_count", "[", "(", "int", ")", "GET_SH_ARG_CLASS", "(", "mode", ")", "]", "+", "(", "cum", ".", "arg_count", "[", "(", "int", ")", "GET_SH_ARG_CLASS", "(", "mode", ")", "]", "&", "1", ")", ")", ":", "cum", ".", "arg_count", "[", "(", "int", ")", "GET_SH_ARG_CLASS", "(", "mode", ")", "]", ")", ";", "}", "</s>" ]

[ "Round", "a", "register", "number", "up", "to", "a", "proper", "boundary", "for", "an", "arg", "of", "mode", "MODE", ".", "The", "SH", "does", "n't", "care", "about", "double", "alignment", ",", "so", "we", "only", "round", "doubles", "to", "even", "regs", "when", "asked", "to", "explicitly", "." ]

[ "sh", "1" ]

[]

[ "<s>", "int", "mmix_valid_comparison", "(", "RTX_CODE", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "mode", "==", "VOIDmode", "&&", "op", "!=", "NULL_RTX", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "CCmode", "||", "mode", "==", "CC_UNSmode", "||", "mode", "==", "DImode", ")", "return", "1", ";", "if", "(", "(", "mode", "==", "CC_FPmode", "||", "mode", "==", "DFmode", ")", "&&", "(", "code", "==", "GT", "||", "code", "==", "LT", ")", ")", "return", "1", ";", "if", "(", "(", "mode", "==", "CC_FPEQmode", "||", "mode", "==", "DFmode", ")", "&&", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", ")", "return", "1", ";", "if", "(", "(", "mode", "==", "CC_FUNmode", "||", "mode", "==", "DFmode", ")", "&&", "(", "code", "==", "ORDERED", "||", "code", "==", "UNORDERED", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "zero", "if", "code", "and", "mode", "is", "not", "a", "valid", "condition", "from", "a", "compare-type", "insn", ".", "Nonzero", "if", "it", "is", ".", "The", "parameter", "op", ",", "if", "non-NULL", ",", "is", "the", "comparison", "of", "mode", "is", "CC-somethingmode", "." ]

[ "mmix", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\" mods: \"", "<<", "Reg", ".", "Modifiers", "<<", "'>'", ";", "break", ";", "case", "Immediate", ":", "OS", "<<", "'<'", "<<", "getImm", "(", ")", ";", "if", "(", "getImmTy", "(", ")", "!=", "ImmTyNone", ")", "{", "OS", "<<", "\" type: \"", ";", "printImmTy", "(", "OS", ",", "getImmTy", "(", ")", ")", ";", "}", "OS", "<<", "\" mods: \"", "<<", "Imm", ".", "Modifiers", "<<", "'>'", ";", "break", ";", "case", "Token", ":", "OS", "<<", "'\\''", "<<", "getToken", "(", ")", "<<", "'\\''", ";", "break", ";", "case", "Expression", ":", "OS", "<<", "\"<expr \"", "<<", "*", "Expr", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AMDGPU", "\"<register \"", "\" mods: \"", "\" type: \"", "\" mods: \"", "\"<expr \"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "MCOI", "::", "OPERAND_FIRST_TARGET", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "operandBitWidth", "(", "OperandType", ")", ")", "{", "case", "32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "Trunc", "==", "Imm", "&&", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "64", ":", "{", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "32", "AMDGPU::isInlinableLiteral32", "64", "AMDGPU::isInlinableLiteral64", "16", "16", "16", "AMDGPU::isInlinableLiteral16", "\"invalid bitwidth\"" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "(", "unsigned", ")", "Kind", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "Mips", "::", "fixup_Mips_16", ":", "FullSize", "=", "2", ";", "break", ";", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "Mips", "7", "8", "Mips::fixup_Mips_16", "2", "Mips::fixup_Mips_64", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", "&&", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", ")", "return", "CSR_SRV464_TLS_PE_SaveList", ";", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", "&&", "!", "Subtarget", ".", "isUsingPCRelativeCalls", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Cold", ")", "{", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_Altivec_SaveList", ":", "CSR_SVR64_ColdCC_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_SaveList", ":", "CSR_SVR64_ColdCC_SaveList", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR32_ColdCC_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR32_ColdCC_SPE_SaveList", ";", "return", "CSR_SVR32_ColdCC_SaveList", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_PPC64_R2_Altivec_SaveList", ":", "CSR_PPC64_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_PPC64_R2_SaveList", ":", "CSR_PPC64_SaveList", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR432_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR432_SPE_SaveList", ";", "return", "CSR_SVR432_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC::X2", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "isIntrinsic", "(", ")", "const", "{", "return", "(", "Attributes", "&", "Intrinsic", ")", "!=", "0", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "group", "of", "FMA", "opcodes", "holds", "intrinsic", "opcodes", "." ]

[ "X86", "0" ]

[]

[ "<s>", "bool", "WebAssemblySetP2AlignOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Set p2align Operands **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "LOAD_I32", ":", "case", "WebAssembly", "::", "LOAD_I64", ":", "case", "WebAssembly", "::", "LOAD_F32", ":", "case", "WebAssembly", "::", "LOAD_F64", ":", "case", "WebAssembly", "::", "LOAD8_S_I32", ":", "case", "WebAssembly", "::", "LOAD8_U_I32", ":", "case", "WebAssembly", "::", "LOAD16_S_I32", ":", "case", "WebAssembly", "::", "LOAD16_U_I32", ":", "case", "WebAssembly", "::", "LOAD8_S_I64", ":", "case", "WebAssembly", "::", "LOAD8_U_I64", ":", "case", "WebAssembly", "::", "LOAD16_S_I64", ":", "case", "WebAssembly", "::", "LOAD16_U_I64", ":", "case", "WebAssembly", "::", "LOAD32_S_I64", ":", "case", "WebAssembly", "::", "LOAD32_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD32_U_I64", ":", "RewriteP2Align", "(", "MI", ",", "WebAssembly", "::", "LoadP2AlignOperandNo", ")", ";", "break", ";", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "RewriteP2Align", "(", "MI", ",", "WebAssembly", "::", "StoreP2AlignOperandNo", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Set p2align Operands **********\\n\"", "\"********** Function: \"", "WebAssembly::LOAD_I32", "WebAssembly::LOAD_I64", "WebAssembly::LOAD_F32", "WebAssembly::LOAD_F64", "WebAssembly::LOAD8_S_I32", "WebAssembly::LOAD8_U_I32", "WebAssembly::LOAD16_S_I32", "WebAssembly::LOAD16_U_I32", "WebAssembly::LOAD8_S_I64", "WebAssembly::LOAD8_U_I64", "WebAssembly::LOAD16_S_I64", "WebAssembly::LOAD16_U_I64", "WebAssembly::LOAD32_S_I64", "WebAssembly::LOAD32_U_I64", "WebAssembly::ATOMIC_LOAD_I32", "WebAssembly::ATOMIC_LOAD8_U_I32", "WebAssembly::ATOMIC_LOAD16_U_I32", "WebAssembly::ATOMIC_LOAD_I64", "WebAssembly::ATOMIC_LOAD8_U_I64", "WebAssembly::ATOMIC_LOAD16_U_I64", "WebAssembly::ATOMIC_LOAD32_U_I64", "WebAssembly::LoadP2AlignOperandNo", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::StoreP2AlignOperandNo" ]

[]

[ "<s>", "bool", "PPCLowerMASSVEntries", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "Changed", "=", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "Changed", ";", "auto", "&", "TM", "=", "TPC", "->", "getTM", "<", "PPCTargetMachine", ">", "(", ")", ";", "const", "PPCSubtarget", "*", "Subtarget", ";", "for", "(", "Function", "&", "Func", ":", "M", ")", "{", "if", "(", "!", "Func", ".", "isDeclaration", "(", ")", ")", "continue", ";", "if", "(", "!", "isMASSVFunc", "(", "Func", ".", "getName", "(", ")", ")", ")", "continue", ";", "SmallVector", "<", "User", "*", ",", "4", ">", "MASSVUsers", ";", "for", "(", "auto", "*", "User", ":", "Func", ".", "users", "(", ")", ")", "MASSVUsers", ".", "push_back", "(", "User", ")", ";", "for", "(", "auto", "*", "User", ":", "MASSVUsers", ")", "{", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "User", ")", ";", "if", "(", "!", "CI", ")", "continue", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", "*", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "|=", "lowerMASSVCall", "(", "CI", ",", "Func", ",", "M", ",", "Subtarget", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "4", "PPC" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isSimpleMove", "(", "MI", ",", "FrameIndex", ",", "RISCVII", "::", "SimpleStore", ")", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "RISCV", "RISCV", "RISCVII::SimpleStore" ]

[]

[ "<s>", "static", "void", "aarch64_option_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "const", "struct", "processor", "*", "cpu", "=", "aarch64_get_tune_cpu", "(", "ptr", "->", "x_explicit_tune_core", ")", ";", "uint64_t", "isa_flags", "=", "ptr", "->", "x_aarch64_isa_flags", ";", "const", "struct", "processor", "*", "arch", "=", "aarch64_get_arch", "(", "ptr", "->", "x_explicit_arch", ")", ";", "std", "::", "string", "extension", "=", "aarch64_get_extension_string_for_isa_flags", "(", "isa_flags", ",", "arch", "->", "flags", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected tune = %s\\n\"", ",", "indent", ",", "\"\"", ",", "cpu", "->", "name", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected arch = %s%s\\n\"", ",", "indent", ",", "\"\"", ",", "arch", "->", "name", ",", "extension", ".", "c_str", "(", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_PRINT", "." ]

[ "aarch64", "\"%*sselected tune = %s\\n\"", "\"\"", "\"%*sselected arch = %s%s\\n\"", "\"\"" ]

[]

[ "<s>", "static", "rtx", "frame_emit_store", "(", "int", "regno", ",", "int", "regno_note", ",", "rtx", "addr", ",", "rtx", "cfa", ",", "int", "cfa_offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ";", "rtx", "mov", "=", "gen_movsi", "(", "mem", ",", "reg", ")", ";", "rtx", "reg_note", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno_note", ")", ";", "rtx", "cfa_relative_addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "cfa", ",", "gen_int_si", "(", "cfa_offset", ")", ")", ";", "rtx", "cfa_relative_mem", "=", "gen_frame_mem", "(", "Pmode", ",", "cfa_relative_addr", ")", ";", "rtx", "real", "=", "gen_rtx_SET", "(", "cfa_relative_mem", ",", "reg_note", ")", ";", "add_reg_note", "(", "mov", ",", "REG_CFA_OFFSET", ",", "real", ")", ";", "return", "emit_insn", "(", "mov", ")", ";", "}", "</s>" ]

[ "Emit", "a", "store", "in", "the", "stack", "frame", "to", "save", "REGNO", "at", "address", "ADDR", ",", "and", "emit", "the", "corresponding", "REG_CFA_OFFSET", "note", "described", "by", "CFA", "and", "CFA_OFFSET", ".", "Return", "the", "emitted", "insn", "." ]

[ "tilepro" ]

[]

[ "<s>", "Value", "*", "PPCTargetLowering", "::", "emitMaskedAtomicRMWIntrinsic", "(", "IRBuilderBase", "&", "Builder", ",", "AtomicRMWInst", "*", "AI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "Incr", ",", "Value", "*", "Mask", ",", "Value", "*", "ShiftAmt", ",", "AtomicOrdering", "Ord", ")", "const", "{", "assert", "(", "shouldInlineQuadwordAtomics", "(", ")", "&&", "\"Only support quadword now\"", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "Incr", "->", "getType", "(", ")", ";", "assert", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", ";", "Function", "*", "RMW", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "getIntrinsicForAtomicRMWBinOp128", "(", "AI", "->", "getOperation", "(", ")", ")", ")", ";", "Type", "*", "Int64Ty", "=", "Type", "::", "getInt64Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "IncrLo", "=", "Builder", ".", "CreateTrunc", "(", "Incr", ",", "Int64Ty", ",", "\"incr_lo\"", ")", ";", "Value", "*", "IncrHi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Incr", ",", "64", ")", ",", "Int64Ty", ",", "\"incr_hi\"", ")", ";", "Value", "*", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "AlignedAddr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "RMW", ",", "{", "Addr", ",", "IncrLo", ",", "IncrHi", "}", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "atomicrmw", "using", "a", "target-specific", "intrinsic", "." ]

[ "PowerPC", "PPC", "\"Only support quadword now\"", "128", "Intrinsic::getDeclaration", "\"incr_lo\"", "64", "\"incr_hi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"" ]

[]

[ "<s>", "inline", "bool", "function_base", "::", "apply_tail_policy_p", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "We", "choose", "to", "apply", "tail", "policy", "operand", "by", "default", "since", "most", "of", "the", "intrinsics", "has", "tail", "policy", "operand", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "void", "pru_elf_asm_constructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "char", "buf", "[", "23", "]", ";", "section", "*", "s", ";", "if", "(", "priority", "==", "DEFAULT_INIT_PRIORITY", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\".init_array\"", ")", ";", "else", "{", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\".init_array.%.5u\"", ",", "priority", ")", ";", "}", "s", "=", "get_section", "(", "buf", ",", "SECTION_WRITE", "|", "SECTION_NOTYPE", ",", "NULL", ")", ";", "switch_to_section", "(", "s", ")", ";", "assemble_aligned_integer", "(", "INIT_ARRAY_ENTRY_BYTES", ",", "symbol", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_CONSTRUCTOR", "." ]

[ "pru", "23", "\".init_array\"", "\".init_array.%.5u\"" ]

[]

[ "<s>", "static", "rtx", "s390_emit_ccraw_jump", "(", "HOST_WIDE_INT", "mask", ",", "enum", "rtx_code", "comparison", ",", "rtx", "label", ")", "{", "rtx", "temp", ";", "gcc_assert", "(", "comparison", "==", "EQ", "||", "comparison", "==", "NE", ")", ";", "gcc_assert", "(", "mask", ">", "0", "&&", "mask", "<", "15", ")", ";", "temp", "=", "gen_rtx_fmt_ee", "(", "comparison", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "CCRAWmode", ",", "CC_REGNUM", ")", ",", "GEN_INT", "(", "mask", ")", ")", ";", "temp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "temp", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "temp", ")", ";", "return", "emit_jump_insn", "(", "temp", ")", ";", "}", "</s>" ]

[ "Emit", "a", "conditional", "jump", "to", "LABEL", "for", "condition", "code", "mask", "MASK", "using", "comparsion", "operator", "COMPARISON", ".", "Return", "the", "emitted", "jump", "insn", "." ]

[ "s390", "0", "15" ]

[]

[ "<s>", "Register", "ARCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "ARC", "::", "FP", ":", "ARC", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "ARC", "ARC", "ARC", "ARC::FP", "ARC::SP" ]

[]

[ "<s>", "rtx", "expand", "(", "function_expander", "&", "e", ")", "const", "OVERRIDE", "{", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "2", ";", "++", "i", ")", "e", ".", "args", "[", "i", "]", "=", "e", ".", "convert_to_pmode", "(", "e", ".", "args", "[", "i", "]", ")", ";", "return", "e", ".", "use_exact_insn", "(", "code_for_while", "(", "m_unspec", ",", "Pmode", ",", "e", ".", "gp_mode", "(", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]

[ "aarch64", "0", "2", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeList", "Attr", ")", "const", "{", "bool", "OptSize", "=", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ";", "return", "OptSize", "&&", "!", "VT", ".", "isVector", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "X86AsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MII", ".", "get", "(", "Opc", ")", ";", "if", "(", "ForcedVEXEncoding", "==", "VEXEncoding_EVEX", "&&", "(", "MCID", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "!=", "X86II", "::", "EVEX", ")", "return", "Match_Unsupported", ";", "if", "(", "(", "ForcedVEXEncoding", "==", "VEXEncoding_VEX2", "||", "ForcedVEXEncoding", "==", "VEXEncoding_VEX3", ")", "&&", "(", "MCID", ".", "TSFlags", "&", "X86II", "::", "EncodingMask", ")", "!=", "X86II", "::", "VEX", ")", "return", "Match_Unsupported", ";", "switch", "(", "Opc", ")", "{", "case", "X86", "::", "VCVTSD2SIZrm_Int", ":", "case", "X86", "::", "VCVTSD2SI64Zrm_Int", ":", "case", "X86", "::", "VCVTSS2SIZrm_Int", ":", "case", "X86", "::", "VCVTSS2SI64Zrm_Int", ":", "case", "X86", "::", "VCVTTSD2SIZrm", ":", "case", "X86", "::", "VCVTTSD2SIZrm_Int", ":", "case", "X86", "::", "VCVTTSD2SI64Zrm", ":", "case", "X86", "::", "VCVTTSD2SI64Zrm_Int", ":", "case", "X86", "::", "VCVTTSS2SIZrm", ":", "case", "X86", "::", "VCVTTSS2SIZrm_Int", ":", "case", "X86", "::", "VCVTTSS2SI64Zrm", ":", "case", "X86", "::", "VCVTTSS2SI64Zrm_Int", ":", "if", "(", "ForcedVEXEncoding", "!=", "VEXEncoding_EVEX", ")", "return", "Match_Unsupported", ";", "}", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "X86", "X86", "X86II::EncodingMask", "X86II::EVEX", "X86II::EncodingMask", "X86II::VEX", "X86::VCVTSD2SIZrm_Int", "X86::VCVTSD2SI64Zrm_Int", "X86::VCVTSS2SIZrm_Int", "X86::VCVTSS2SI64Zrm_Int", "X86::VCVTTSD2SIZrm", "X86::VCVTTSD2SIZrm_Int", "X86::VCVTTSD2SI64Zrm", "X86::VCVTTSD2SI64Zrm_Int", "X86::VCVTTSS2SIZrm", "X86::VCVTTSS2SIZrm_Int", "X86::VCVTTSS2SI64Zrm", "X86::VCVTTSS2SI64Zrm_Int" ]

[]

[ "<s>", "static", "void", "avr_output_bss_section_asm_op", "(", "const", "char", "*", "data", ")", "{", "avr_need_clear_bss_p", "=", "true", ";", "output_section_asm_op", "(", "data", ")", ";", "}", "</s>" ]

[ "Unnamed", "section", "callback", "for", "bss_section", "to", "track", "need", "of", "__do_clear_bss", "." ]

[ "avr" ]

[]

[ "<s>", "static", "bool", "riscv_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "const_arith_operand", "(", "x", ",", "Pmode", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "!", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", ",", "for", "every", "base", "register", "BASE_REG", ",", "(", "plus", "BASE_REG", "X", ")", "can", "address", "a", "value", "of", "mode", "MODE", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "AMDGPUHSATargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "TextSection", "=", "AMDGPU", "::", "getHSATextSection", "(", "Ctx", ")", ";", "DataGlobalAgentSection", "=", "AMDGPU", "::", "getHSADataGlobalAgentSection", "(", "Ctx", ")", ";", "DataGlobalProgramSection", "=", "AMDGPU", "::", "getHSADataGlobalProgramSection", "(", "Ctx", ")", ";", "RodataReadonlyAgentSection", "=", "AMDGPU", "::", "getHSARodataReadonlyAgentSection", "(", "Ctx", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::getHSATextSection", "AMDGPU::getHSADataGlobalAgentSection", "AMDGPU::getHSADataGlobalProgramSection", "AMDGPU::getHSARodataReadonlyAgentSection" ]

[]

[ "<s>", "const", "NVPTXSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "int", "HexagonMCInstrInfo", "::", "getMinValue", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isExtendable", "(", "MCII", ",", "MCI", ")", "||", "HexagonMCInstrInfo", "::", "isExtended", "(", "MCII", ",", "MCI", ")", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "isExtentSigned", "(", "MCII", ",", "MCI", ")", ")", "return", "-", "(", "1", "<<", "(", "HexagonMCInstrInfo", "::", "getExtentBits", "(", "MCII", ",", "MCI", ")", "-", "1", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "minimal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "Hexagon", "1", "0" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "duplicate", "(", "MachineInstr", "*", "Orig", ",", "MachineFunction", "&", "MF", ")", "const", "{", "MachineInstr", "*", "MI", "=", "TargetInstrInfo", "::", "duplicate", "(", "Orig", ",", "MF", ")", ";", "switch", "(", "Orig", "->", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "unsigned", "CPI", "=", "Orig", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "Orig", "->", "getOperand", "(", "1", ")", ".", "setIndex", "(", "CPI", ")", ";", "Orig", "->", "getOperand", "(", "2", ")", ".", "setImm", "(", "PCLabelId", ")", ";", "break", ";", "}", "}", "return", "MI", ";", "}", "</s>" ]

[ "Clones", "instruction", "or", "the", "whole", "instruction", "bundle", "Orig", "and", "insert", "into", "MBB", "before", "InsertBefore", "." ]

[ "ARM", "ARM", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1", "1", "2" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "V_MOV_B32_e32", ":", "case", "AMDGPU", "::", "V_MOV_B32_e64", ":", "case", "AMDGPU", "::", "V_MOV_B64_PSEUDO", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MOV_B32_e32", "AMDGPU::V_MOV_B32_e64", "AMDGPU::V_MOV_B64_PSEUDO" ]

[]

[ "<s>", "bool", "alpha_emit_setcc", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "enum", "rtx_code", "cmp_code", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ",", "op1", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", ";", "if", "(", "cmp_mode", "==", "TFmode", ")", "{", "op0", "=", "alpha_emit_xfloating_compare", "(", "&", "code", ",", "op0", ",", "op1", ")", ";", "op1", "=", "const0_rtx", ";", "cmp_mode", "=", "DImode", ";", "}", "if", "(", "cmp_mode", "==", "DFmode", "&&", "!", "TARGET_FIX", ")", "return", "0", ";", "cmp_code", "=", "UNKNOWN", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "case", "UNORDERED", ":", "if", "(", "cmp_mode", "==", "DFmode", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "break", ";", "case", "NE", ":", "if", "(", "cmp_mode", "==", "DImode", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "case", "ORDERED", ":", "cmp_code", "=", "reverse_condition", "(", "code", ")", ";", "code", "=", "EQ", ";", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "if", "(", "cmp_mode", "==", "DImode", "&&", "op1", "==", "const0_rtx", ")", "break", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "if", "(", "cmp_mode", "==", "DFmode", ")", "cmp_code", "=", "code", ",", "code", "=", "NE", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "cmp_mode", "==", "DImode", ")", "{", "if", "(", "!", "register_operand", "(", "op0", ",", "DImode", ")", ")", "op0", "=", "force_reg", "(", "DImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_8bit_operand", "(", "op1", ",", "DImode", ")", ")", "op1", "=", "force_reg", "(", "DImode", ",", "op1", ")", ";", "}", "if", "(", "cmp_code", "!=", "UNKNOWN", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "cmp_mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_fmt_ee", "(", "cmp_code", ",", "cmp_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "op0", "=", "cmp_mode", "!=", "DImode", "?", "gen_lowpart", "(", "DImode", ",", "tmp", ")", ":", "tmp", ";", "op1", "=", "const0_rtx", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_fmt_ee", "(", "code", ",", "DImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "." ]

[ "alpha", "1", "2", "3", "0", "0" ]

[]

[ "<s>", "int", "dimode_scalar_chain", "::", "vector_const_cost", "(", "rtx", "exp", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "exp", ")", ")", ";", "if", "(", "standard_sse_constant_p", "(", "exp", ",", "V2DImode", ")", ")", "return", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "ix86_cost", "->", "sse_load", "[", "1", "]", ";", "}", "</s>" ]

[ "Return", "a", "cost", "of", "building", "a", "vector", "costant", "instead", "of", "using", "a", "scalar", "one", "." ]

[ "i386", "1", "1" ]

[]