Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_riscv_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_pcrel_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_i\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_s\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_jal\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_branch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_jump\"", ",", "2", ",", "11", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_branch\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_relax\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "RISCV", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "RISCV", "\"fixup_riscv_hi20\"", "12", "20", "0", "\"fixup_riscv_lo12_i\"", "20", "12", "0", "\"fixup_riscv_lo12_s\"", "0", "32", "0", "\"fixup_riscv_pcrel_hi20\"", "12", "20", "\"fixup_riscv_pcrel_lo12_i\"", "20", "12", "\"fixup_riscv_pcrel_lo12_s\"", "0", "32", "\"fixup_riscv_jal\"", "12", "20", "\"fixup_riscv_branch\"", "0", "32", "\"fixup_riscv_rvc_jump\"", "2", "11", "\"fixup_riscv_rvc_branch\"", "0", "16", "\"fixup_riscv_call\"", "0", "64", "\"fixup_riscv_relax\"", "0", "0", "0", "RISCV::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "PTXMCAsmStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ")", "{", "assert", "(", "getCurrentSection", "(", ")", "&&", "\"Cannot emit contents before setting section!\"", ")", ";", "if", "(", "Emitter", ")", "AddEncodingComment", "(", "Inst", ")", ";", "if", "(", "ShowInst", ")", "{", "Inst", ".", "dump_pretty", "(", "GetCommentOS", "(", ")", ",", "&", "MAI", ",", "InstPrinter", ".", "get", "(", ")", ",", "\"\\n \"", ")", ";", "GetCommentOS", "(", ")", "<<", "\"\\n\"", ";", "}", "if", "(", "InstPrinter", ")", "InstPrinter", "->", "printInst", "(", "&", "Inst", ",", "OS", ",", "\"\"", ")", ";", "else", "Inst", ".", "print", "(", "OS", ",", "&", "MAI", ")", ";", "EmitEOL", "(", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "\"Cannot emit contents before setting section!\"", "\"\\n \"", "\"\\n\"", "\"\"" ]

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "const", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "TII", ",", "MRI", ",", "TRI", ",", "RBI", ")", ";", "return", "true", ";", "}", "assert", "(", "I", ".", "getNumOperands", "(", ")", "==", "I", ".", "getNumExplicitOperands", "(", ")", "&&", "\"Generic instruction has unexpected implicit operands\\n\"", ")", ";", "if", "(", "selectImpl", "(", "I", ")", ")", "return", "true", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" C++ instruction selection: \"", ";", "I", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "if", "(", "selectLoadStoreOp", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectFrameIndexOrGep", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectConstant", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectTrunc", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectZext", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectCmp", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectUadde", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "X86", "X86", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "\"Generic instruction has unexpected implicit operands\\n\"", "\" C++ instruction selection: \"" ]

[]

[ "<s>", "static", "void", "mips_74k_agen_init", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", ")", "mips_last_74k_agen_insn", "=", "TYPE_UNKNOWN", ";", "else", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "type", "==", "TYPE_LOAD", "||", "type", "==", "TYPE_STORE", ")", "mips_last_74k_agen_insn", "=", "type", ";", "}", "}", "</s>" ]

[ "Initialize", "mips_last_74k_agen_insn", "from", "INSN", ".", "A", "null", "argument", "resets", "to", "TYPE_UNKNOWN", "state", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "OpKind_Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "M88k" ]

[]

[ "<s>", "bool", "TVMRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TVMFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "TVMFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", ".", "initTVMRegs", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "TVM", "::", "isArgument", "(", "MI", ")", ")", "break", ";", "int64_t", "Imm", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg VReg \"", "<<", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "<<", "\" -> TVMReg \"", "<<", "Imm", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setTVMReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "Imm", ")", ";", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "0", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> TVMReg \"", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setTVMReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getTVMReg", "(", "VReg", ")", "==", "TVMFunctionInfo", "::", "UnusedReg", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> TVMReg \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setTVMReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "TVM", "TVM", "TVM", "TVM::isArgument", "1", "\"Arg VReg \"", "0", "\" -> TVMReg \"", "\"\\n\"", "TVM", "0", "0", "0", "\"VReg \"", "\" -> TVMReg \"", "\"\\n\"", "TVM", "TVM", "TVM", "\"VReg \"", "\" -> TVMReg \"", "\"\\n\"", "TVM" ]

[]

[ "<s>", "const", "char", "*", "XCoreTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "XCoreISD", "::", "BL", ":", "return", "\"XCoreISD::BL\"", ";", "case", "XCoreISD", "::", "PCRelativeWrapper", ":", "return", "\"XCoreISD::PCRelativeWrapper\"", ";", "case", "XCoreISD", "::", "DPRelativeWrapper", ":", "return", "\"XCoreISD::DPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "CPRelativeWrapper", ":", "return", "\"XCoreISD::CPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "LDWSP", ":", "return", "\"XCoreISD::LDWSP\"", ";", "case", "XCoreISD", "::", "STWSP", ":", "return", "\"XCoreISD::STWSP\"", ";", "case", "XCoreISD", "::", "RETSP", ":", "return", "\"XCoreISD::RETSP\"", ";", "case", "XCoreISD", "::", "LADD", ":", "return", "\"XCoreISD::LADD\"", ";", "case", "XCoreISD", "::", "LSUB", ":", "return", "\"XCoreISD::LSUB\"", ";", "case", "XCoreISD", "::", "LMUL", ":", "return", "\"XCoreISD::LMUL\"", ";", "case", "XCoreISD", "::", "MACCU", ":", "return", "\"XCoreISD::MACCU\"", ";", "case", "XCoreISD", "::", "MACCS", ":", "return", "\"XCoreISD::MACCS\"", ";", "case", "XCoreISD", "::", "CRC8", ":", "return", "\"XCoreISD::CRC8\"", ";", "case", "XCoreISD", "::", "BR_JT", ":", "return", "\"XCoreISD::BR_JT\"", ";", "case", "XCoreISD", "::", "BR_JT32", ":", "return", "\"XCoreISD::BR_JT32\"", ";", "case", "XCoreISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "\"XCoreISD::FRAME_TO_ARGS_OFFSET\"", ";", "case", "XCoreISD", "::", "EH_RETURN", ":", "return", "\"XCoreISD::EH_RETURN\"", ";", "case", "XCoreISD", "::", "MEMBARRIER", ":", "return", "\"XCoreISD::MEMBARRIER\"", ";", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "XCore", "XCore", "XCoreISD::BL", "\"XCoreISD::BL\"", "XCoreISD::PCRelativeWrapper", "\"XCoreISD::PCRelativeWrapper\"", "XCoreISD::DPRelativeWrapper", "\"XCoreISD::DPRelativeWrapper\"", "XCoreISD::CPRelativeWrapper", "\"XCoreISD::CPRelativeWrapper\"", "XCoreISD::LDWSP", "\"XCoreISD::LDWSP\"", "XCoreISD::STWSP", "\"XCoreISD::STWSP\"", "XCoreISD::RETSP", "\"XCoreISD::RETSP\"", "XCoreISD::LADD", "\"XCoreISD::LADD\"", "XCoreISD::LSUB", "\"XCoreISD::LSUB\"", "XCoreISD::LMUL", "\"XCoreISD::LMUL\"", "XCoreISD::MACCU", "\"XCoreISD::MACCU\"", "XCoreISD::MACCS", "\"XCoreISD::MACCS\"", "XCoreISD::CRC8", "\"XCoreISD::CRC8\"", "XCoreISD::BR_JT", "\"XCoreISD::BR_JT\"", "XCoreISD::BR_JT32", "\"XCoreISD::BR_JT32\"", "XCoreISD::FRAME_TO_ARGS_OFFSET", "\"XCoreISD::FRAME_TO_ARGS_OFFSET\"", "XCoreISD::EH_RETURN", "\"XCoreISD::EH_RETURN\"", "XCoreISD::MEMBARRIER", "\"XCoreISD::MEMBARRIER\"" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "Mips", "0", "0" ]

[]

[ "<s>", "bool", "XtensaInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "std", "::", "cout", "<<", "\"XtensaInstrInfo::analyzeBranch not yet implemented\"", "<<", "std", "::", "endl", ";", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "Xtensa", "Xtensa", "\"XtensaInstrInfo::analyzeBranch not yet implemented\"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "SDNode", "*", "LM32DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "assert", "(", "0", "&&", "\"getGlobalBaseReg() not supported.\"", ")", ";", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "LM32", "LM32", "0", "\"getGlobalBaseReg() not supported.\"" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAG", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAGp", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDQ", ")", ",", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "{", "if", "(", "NumBytes", "<=", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", "<=", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "std", "::", "string", "msg", ";", "raw_string_ostream", "Msg", "(", "msg", ")", ";", "Msg", "<<", "\"Too big a stack frame at \"", "+", "NumBytes", ";", "llvm_report_error", "(", "Msg", ".", "str", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::RETDAG", "Alpha::RETDAGp", "\"Can only insert epilog into returning blocks\"", "Alpha::BISr", "Alpha::R30", "Alpha::R15", "Alpha::R15", "Alpha::LDQ", "Alpha::R15", "0", "Alpha::R15", "0", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"" ]

[]

[ "<s>", "bool", "splitFramePushPop", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "(", "useR7AsFramePointer", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "||", "isThumb1Only", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "frame", "setup", "is", "split", "into", "two", "separate", "pushes", "(", "first", "r0-r7", ",", "lr", "then", "r8-r11", ")", ",", "principally", "so", "that", "the", "frame", "pointer", "is", "adjacent", "to", "lr", "." ]

[ "ARM" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "TargetTriple", "(", "TT", ")", "{", "initializeEnvironment", "(", ")", ";", "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ")", "{", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "\"+crbits,\"", "+", "FullFS", ";", "else", "FullFS", "=", "\"+crbits\"", ";", "}", "resetSubtargetFeatures", "(", "CPU", ",", "FullFS", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"+crbits,\"", "\"+crbits\"" ]

[]

[ "<s>", "void", "TOYAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createELFObjectWriter", "(", "createELFObjectTargetWriter", "(", ")", ",", "OS", ",", "true", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "static", "reg_class_t", "pa_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "int", "regno", ";", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "rclass", "==", "R1_REGS", ")", "return", "NO_REGS", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "rclass", "==", "BASE_REG_CLASS", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", ")", "return", "NO_REGS", ";", "}", "else", "regno", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MEM", ")", "return", "NO_REGS", ";", "if", "(", "flag_pic", "&&", "FP_REG_CLASS_P", "(", "rclass", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insi_r1", ";", "break", ";", "case", "DImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indi_r1", ";", "break", ";", "case", "SFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insf_r1", ";", "break", ";", "case", "DFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indf_r1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "pa_symbolic_expression_p", "(", "x", ")", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "flag_pic", "||", "!", "read_only_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insi_r1", ";", "break", ";", "case", "DImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indi_r1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NO_REGS", ";", "}", "}", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "-", "1", ")", "&&", "FP_REG_CLASS_P", "(", "rclass", ")", ")", "{", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "IS_INDEX_ADDR_P", "(", "x", ")", ")", "return", "NO_REGS", ";", "}", "sri", "->", "icode", "=", "(", "in_p", "?", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ":", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "rclass", "==", "SHIFT_REGS", ")", "{", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "<", "0", ")", "{", "sri", "->", "icode", "=", "(", "in_p", "?", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ":", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "FP_REG_CLASS_P", "(", "REGNO_REG_CLASS", "(", "regno", ")", ")", ")", "return", "GENERAL_REGS", ";", "}", "if", "(", "regno", ">=", "0", "&&", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_REG_CLASS", "(", "regno", ")", "==", "SHIFT_REGS", "&&", "FP_REG_CLASS_P", "(", "rclass", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Inform", "reload", "about", "cases", "where", "moving", "X", "with", "a", "mode", "MODE", "to", "or", "from", "a", "register", "in", "RCLASS", "requires", "an", "extra", "scratch", "or", "immediate", "register", ".", "Return", "the", "class", "needed", "for", "the", "immediate", "register", "." ]

[ "pa", "1", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "rtx", "frv_emit_comparison", "(", "enum", "rtx_code", "test", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "cc_mode", ";", "rtx", "cc_reg", ";", "if", "(", "GET_MODE", "(", "op0", ")", "==", "CC_FPmode", "&&", "GET_CODE", "(", "op1", ")", "!=", "REG", ")", "op1", "=", "force_reg", "(", "GET_MODE", "(", "op0", ")", ",", "op1", ")", ";", "cc_mode", "=", "SELECT_CC_MODE", "(", "test", ",", "op0", ",", "op1", ")", ";", "cc_reg", "=", "(", "(", "TARGET_ALLOC_CC", ")", "?", "gen_reg_rtx", "(", "cc_mode", ")", ":", "gen_rtx_REG", "(", "cc_mode", ",", "(", "cc_mode", "==", "CC_FPmode", ")", "?", "FCC_FIRST", ":", "ICC_FIRST", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "cc_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "Emit", "the", "appropriate", "code", "to", "do", "a", "comparison", ",", "returning", "the", "register", "the", "comparison", "was", "done", "it", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "Ty", "->", "getTypeID", "(", ")", "==", "Type", "::", "VoidTyID", ")", "return", "AM", ".", "Scale", "==", "0", "&&", "isImmUs", "(", "AM", ".", "BaseOffs", ")", "&&", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "Size", "=", "TD", "->", "getTypeAllocSize", "(", "Ty", ")", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "Size", ">=", "4", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "%", "4", "==", "0", ";", "}", "switch", "(", "Size", ")", "{", "case", "1", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "case", "2", ":", "case", "3", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs2", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "2", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "default", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "4", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "}", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "XCore", "XCore", "0", "4", "0", "4", "0", "1", "0", "1", "0", "2", "3", "0", "2", "0", "0", "4", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_if_then_else_costs", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ",", "int", "*", "cost", ",", "bool", "speed", ")", "{", "rtx", "inner", ";", "rtx", "comparator", ";", "enum", "rtx_code", "cmpcode", ";", "const", "struct", "cpu_cost_table", "*", "extra_cost", "=", "aarch64_tune_params", ".", "insn_extra_cost", ";", "if", "(", "COMPARISON_P", "(", "op0", ")", ")", "{", "inner", "=", "XEXP", "(", "op0", ",", "0", ")", ";", "comparator", "=", "XEXP", "(", "op0", ",", "1", ")", ";", "cmpcode", "=", "GET_CODE", "(", "op0", ")", ";", "}", "else", "{", "inner", "=", "op0", ";", "comparator", "=", "const0_rtx", ";", "cmpcode", "=", "NE", ";", "}", "if", "(", "GET_CODE", "(", "op1", ")", "==", "PC", "||", "GET_CODE", "(", "op2", ")", "==", "PC", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "inner", ")", ")", "==", "MODE_CC", ")", "return", "true", ";", "else", "{", "if", "(", "cmpcode", "==", "NE", "||", "cmpcode", "==", "EQ", ")", "{", "if", "(", "comparator", "==", "const0_rtx", ")", "{", "if", "(", "GET_CODE", "(", "inner", ")", "==", "ZERO_EXTRACT", ")", "*", "cost", "+=", "rtx_cost", "(", "XEXP", "(", "inner", ",", "0", ")", ",", "VOIDmode", ",", "ZERO_EXTRACT", ",", "0", ",", "speed", ")", ";", "else", "*", "cost", "+=", "rtx_cost", "(", "inner", ",", "VOIDmode", ",", "cmpcode", ",", "0", ",", "speed", ")", ";", "return", "true", ";", "}", "if", "(", "register_operand", "(", "inner", ",", "VOIDmode", ")", "&&", "aarch64_imm24", "(", "comparator", ",", "VOIDmode", ")", ")", "{", "*", "cost", "+=", "COSTS_N_INSNS", "(", "2", ")", ";", "if", "(", "speed", ")", "*", "cost", "+=", "extra_cost", "->", "alu", ".", "arith", "*", "2", ";", "return", "true", ";", "}", "}", "else", "if", "(", "cmpcode", "==", "LT", "||", "cmpcode", "==", "GE", ")", "{", "if", "(", "comparator", "==", "const0_rtx", ")", "return", "true", ";", "}", "}", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "inner", ")", ")", "==", "MODE_CC", ")", "{", "if", "(", "GET_CODE", "(", "op1", ")", "==", "COMPARE", ")", "{", "if", "(", "XEXP", "(", "op1", ",", "1", ")", "==", "const0_rtx", ")", "*", "cost", "+=", "1", ";", "if", "(", "speed", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "op1", ",", "0", ")", ")", ";", "const", "struct", "cpu_cost_table", "*", "extra_cost", "=", "aarch64_tune_params", ".", "insn_extra_cost", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "*", "cost", "+=", "extra_cost", "->", "alu", ".", "arith", ";", "else", "*", "cost", "+=", "extra_cost", "->", "fp", "[", "mode", "==", "DFmode", "]", ".", "compare", ";", "}", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "op1", ")", "==", "NEG", "||", "GET_CODE", "(", "op1", ")", "==", "NOT", "||", "(", "GET_CODE", "(", "op1", ")", "==", "PLUS", "&&", "XEXP", "(", "op1", ",", "1", ")", "==", "const1_rtx", ")", ")", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "op1", ")", "==", "ZERO_EXTEND", "&&", "GET_CODE", "(", "op2", ")", "==", "ZERO_EXTEND", ")", "{", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "op2", "=", "XEXP", "(", "op2", ",", "0", ")", ";", "}", "*", "cost", "+=", "rtx_cost", "(", "op1", ",", "VOIDmode", ",", "IF_THEN_ELSE", ",", "1", ",", "speed", ")", ";", "*", "cost", "+=", "rtx_cost", "(", "op2", ",", "VOIDmode", ",", "IF_THEN_ELSE", ",", "2", ",", "speed", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "calculating", "(", "if_then_else", "(", "OP0", ")", "(", "OP1", ")", "(", "OP2", ")", ")", ",", "storing", "it", "in", "*", "COST", ".", "Result", "is", "true", "if", "the", "total", "cost", "of", "the", "operation", "has", "now", "been", "calculated", "." ]

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

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "auto", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ".", "lower", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".arch\"", ")", "parseDirectiveArch", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cpu\"", ")", "parseDirectiveCPU", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "parseDirectiveLtorg", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".unreq\"", ")", "parseDirectiveUnreq", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".inst\"", ")", "parseDirectiveInst", "(", "Loc", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_negate_ra_state\"", ")", "parseDirectiveCFINegateRAState", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".cfi_b_key_frame\"", ")", "parseDirectiveCFIBKeyFrame", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".arch_extension\"", ")", "parseDirectiveArchExtension", "(", "Loc", ")", ";", "else", "if", "(", "IsMachO", ")", "{", "if", "(", "IDVal", "==", "MCLOHDirectiveName", "(", ")", ")", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "else", "return", "true", ";", "}", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "AArch64", "AArch64", "\".arch\"", "\".cpu\"", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"", "\".cfi_negate_ra_state\"", "\".cfi_b_key_frame\"", "\".arch_extension\"" ]

[]

[ "<s>", "bool", "nios2_fpu_insn_enabled", "(", "enum", "n2fpu_code", "code", ")", "{", "return", "N2FPU_ENABLED_P", "(", "code", ")", ";", "}", "</s>" ]

[ "Export", "the", "FPU", "insn", "enabled", "predicate", "to", "nios2.md", "." ]

[ "nios2" ]

[]

[ "<s>", "virtual", "const", "TargetFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "PTX" ]

[]

[ "<s>", "void", "Stack", "::", "dump", "(", ")", "const", "{", "print", "(", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "dbgs", "(", ")", ".", "flush", "(", ")", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "TVM", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "visium_save_regs", "(", "int", "alloc", ",", "int", "offset", ",", "int", "low_regno", ",", "int", "high_regno", ")", "{", "const", "int", "volatile_p", "=", "current_frame_info", ".", "interrupt", ";", "int", "regno", ";", "emit_frame_insn", "(", "gen_addsi3_flags", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "alloc", ")", ")", ")", ";", "for", "(", "regno", "=", "low_regno", ";", "regno", "<=", "high_regno", ";", "regno", "++", ")", "{", "enum", "reg_type", "reg_type", "=", "GET_REG_TYPE", "(", "regno", ")", ";", "int", "mask_bit", "=", "1", "<<", "(", "regno", "-", "first_regno", "[", "reg_type", "]", ")", ";", "rtx", "insn", ";", "if", "(", "current_frame_info", ".", "mask", "[", "reg_type", "]", "&", "mask_bit", ")", "{", "offset", "-=", "reg_type_size", "[", "reg_type", "]", ";", "switch", "(", "reg_type", ")", "{", "case", "general", ":", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_frame_insn", "(", "gen_movsi", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ")", ")", ";", "}", "break", ";", "case", "mdb", ":", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "DImode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_insn", "(", "gen_movdi", "(", "tmp", ",", "reg", ")", ")", ";", "if", "(", "volatile_p", ")", "emit_insn", "(", "gen_movdi", "(", "mem", ",", "tmp", ")", ")", ";", "else", "{", "insn", "=", "emit_frame_insn", "(", "gen_movdi", "(", "mem", ",", "tmp", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "}", "}", "break", ";", "case", "mdc", ":", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "reg", ")", ")", ";", "insn", "=", "emit_frame_insn", "(", "gen_movsi", "(", "mem", ",", "tmp", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "}", "break", ";", "case", "floating", ":", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SFmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "SFmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SFmode", ",", "regno", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_insn", "(", "gen_movsf", "(", "tmp", ",", "reg", ")", ")", ";", "insn", "=", "emit_frame_insn", "(", "gen_movsf", "(", "mem", ",", "tmp", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Allocate", "ALLOC", "bytes", "on", "the", "stack", "and", "save", "the", "registers", "LOW_REGNO", "to", "HIGH_REGNO", "at", "OFFSET", "from", "the", "stack", "pointer", "." ]

[ "visium", "1" ]

[]

[ "<s>", "int", "frame_pointer_required_p", "(", "void", ")", "{", "return", "(", "current_function_calls_alloca", "||", "current_function_args_info", ".", "nregs", "==", "0", "||", "get_frame_size", "(", ")", ">", "0", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "frame", "pointer", "for", "current", "function", "required", "." ]

[ "avr", "0", "0" ]

[]

[ "<s>", "static", "void", "aarch64_restore_callee_saves", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "start_offset", ",", "unsigned", "start", ",", "unsigned", "limit", ",", "bool", "skip_wb", ",", "rtx", "*", "cfi_ops", ")", "{", "rtx", "base_rtx", "=", "stack_pointer_rtx", ";", "rtx", "(", "*", "gen_mem_ref", ")", "(", "machine_mode", ",", "rtx", ")", "=", "(", "frame_pointer_needed", "?", "gen_frame_mem", ":", "gen_rtx_MEM", ")", ";", "unsigned", "regno", ";", "unsigned", "regno2", ";", "HOST_WIDE_INT", "offset", ";", "for", "(", "regno", "=", "aarch64_next_callee_save", "(", "start", ",", "limit", ")", ";", "regno", "<=", "limit", ";", "regno", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno", "]", ")", "continue", ";", "rtx", "reg", ",", "mem", ";", "if", "(", "skip_wb", "&&", "(", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "||", "regno", "==", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ")", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "mem", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "regno2", "=", "aarch64_next_callee_save", "(", "regno", "+", "1", ",", "limit", ")", ";", "if", "(", "regno2", "<=", "limit", "&&", "!", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno2", "]", "&&", "(", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "+", "UNITS_PER_WORD", ")", "==", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ")", ")", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "rtx", "mem2", ";", "offset", "=", "start_offset", "+", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "mem2", "=", "gen_mem_ref", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "offset", ")", ")", ";", "emit_insn", "(", "aarch64_gen_load_pair", "(", "mode", ",", "reg", ",", "mem", ",", "reg2", ",", "mem2", ")", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "regno", "=", "regno2", ";", "}", "else", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "*", "cfi_ops", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "the", "callee", "registers", "of", "mode", "MODE", "from", "register", "number", "START", "up", "to", "and", "including", "LIMIT", ".", "Restore", "from", "the", "stack", "offset", "START_OFFSET", ",", "skipping", "any", "write-back", "candidates", "if", "SKIP_WB", "is", "true", ".", "Write", "the", "appropriate", "REG_CFA_RESTORE", "notes", "into", "CFI_OPS", "." ]

[ "aarch64", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "device", "(", ")", "->", "getGeneration", "(", ")", ">", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "addPass", "(", "createSIInsertWaits", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "R600", "AMDGPUDeviceInfo::HD6XXX", "SI" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "ReplaceBITCASTResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i128", "&&", "\"unexpected illegal conversion\"", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom expand this\"", "ISD::BITCAST", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "0", "MVT::i128", "\"unexpected illegal conversion\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isNarrowingProfitable", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "return", "!", "(", "VT1", "==", "MVT", "::", "i32", "&&", "VT2", "==", "MVT", "::", "i16", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "to", "narrow", "operations", "of", "type", "SrcVT", "to", "DestVT", "." ]

[ "X86", "X86", "MVT::i32", "MVT::i16" ]

[]

[ "<s>", "void", "rs6000_cost_data", "::", "adjust_vect_cost_per_loop", "(", "loop_vec_info", "loop_vinfo", ")", "{", "if", "(", "LOOP_VINFO_FULLY_WITH_LENGTH_P", "(", "loop_vinfo", ")", ")", "{", "rgroup_controls", "*", "rgc", ";", "unsigned", "int", "num_vectors_m1", ";", "unsigned", "int", "shift_cnt", "=", "0", ";", "FOR_EACH_VEC_ELT", "(", "LOOP_VINFO_LENS", "(", "loop_vinfo", ")", ",", "num_vectors_m1", ",", "rgc", ")", "if", "(", "rgc", "->", "type", ")", "shift_cnt", "+=", "num_vectors_m1", "+", "1", ";", "add_stmt_cost", "(", "shift_cnt", ",", "scalar_stmt", ",", "NULL", ",", "NULL", ",", "NULL_TREE", ",", "0", ",", "vect_body", ")", ";", "}", "}", "</s>" ]

[ "For", "some", "target", "specific", "vectorization", "cost", "which", "ca", "n't", "be", "handled", "per", "stmt", ",", "we", "check", "the", "requisite", "conditions", "and", "adjust", "the", "vectorization", "cost", "accordingly", "if", "satisfied", ".", "One", "typical", "example", "is", "to", "model", "shift", "cost", "for", "vector", "with", "length", "by", "counting", "number", "of", "required", "lengths", "under", "condition", "LOOP_VINFO_FULLY_WITH_LENGTH_P", "." ]

[ "rs6000", "0", "1", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Register Numbering\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "WebAssembly", "\"WebAssembly Register Numbering\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "SI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "i386_pe_dllimport_p", "(", "tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"dllimport\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "return", "true", ";", "if", "(", "associated_type", "(", "decl", ")", "&&", "lookup_attribute", "(", "\"dllimport\"", ",", "TYPE_ATTRIBUTES", "(", "associated_type", "(", "decl", ")", ")", ")", ")", "return", "i386_pe_type_dllimport_p", "(", "decl", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "DECL", "is", "a", "dllimport", "'d", "object", "." ]

[ "i386", "\"dllimport\"", "\"dllimport\"" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "CI", ",", "unsigned", "IntrID", ")", "const", "{", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "align", "=", "0", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "4", ")", ")", ";", "Info", ".", "vol", "=", "!", "Vol", "||", "!", "Vol", "->", "isNullValue", "(", ")", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "true", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "static", "bool", "ix86_legitimate_combined_insn", "(", "rtx_insn", "*", "insn", ")", "{", "int", "i", ";", "gcc_assert", "(", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", ";", "extract_insn", "(", "insn", ")", ";", "preprocess_constraints", "(", "insn", ")", ";", "int", "n_operands", "=", "recog_data", ".", "n_operands", ";", "int", "n_alternatives", "=", "recog_data", ".", "n_alternatives", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_operands", ";", "i", "++", ")", "{", "rtx", "op", "=", "recog_data", ".", "operand", "[", "i", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "const", "operand_alternative", "*", "op_alt", ";", "int", "offset", "=", "0", ";", "bool", "win", ";", "int", "j", ";", "if", "(", "UNARY_P", "(", "op", ")", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "SUBREG_P", "(", "op", ")", ")", "{", "if", "(", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "REGNO", "(", "SUBREG_REG", "(", "op", ")", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "offset", "=", "subreg_regno_offset", "(", "REGNO", "(", "SUBREG_REG", "(", "op", ")", ")", ",", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ",", "SUBREG_BYTE", "(", "op", ")", ",", "GET_MODE", "(", "op", ")", ")", ";", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "}", "if", "(", "!", "(", "REG_P", "(", "op", ")", "&&", "HARD_REGISTER_P", "(", "op", ")", ")", ")", "continue", ";", "op_alt", "=", "recog_op_alt", ";", "win", "=", "!", "n_alternatives", ";", "alternative_mask", "preferred", "=", "get_preferred_alternatives", "(", "insn", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "n_alternatives", ";", "j", "++", ",", "op_alt", "+=", "n_operands", ")", "{", "if", "(", "!", "TEST_BIT", "(", "preferred", ",", "j", ")", ")", "continue", ";", "if", "(", "op_alt", "[", "i", "]", ".", "anything_ok", "||", "(", "op_alt", "[", "i", "]", ".", "matches", "!=", "-", "1", "&&", "operands_match_p", "(", "recog_data", ".", "operand", "[", "i", "]", ",", "recog_data", ".", "operand", "[", "op_alt", "[", "i", "]", ".", "matches", "]", ")", ")", "||", "reg_fits_class_p", "(", "op", ",", "op_alt", "[", "i", "]", ".", "cl", ",", "offset", ",", "mode", ")", ")", "{", "win", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "win", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_LEGITIMATE_COMBINED_INSN", "hook", "." ]

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

[]

[ "<s>", "bool", "XCoreInstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "true", ";", "}", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "MBB", ".", "addLiveIn", "(", "it", "->", "getReg", "(", ")", ")", ";", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "&", "RI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "SaveLabel", "=", "MF", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "XCore", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "SaveLabel", ")", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "SaveLabel", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::PROLOG_LABEL" ]

[]

[ "<s>", "void", "XCoreAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "O", "(", "Str", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "XCore", "::", "DBG_VALUE", ":", "llvm_unreachable", "(", "\"Should be handled target independently\"", ")", ";", "case", "XCore", "::", "ADD_2rus", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "O", "<<", "\"\\tmov \"", "<<", "XCoreInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "<<", "\", \"", "<<", "XCoreInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "OutStreamer", "->", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "break", ";", "case", "XCore", "::", "BR_JT", ":", "case", "XCore", "::", "BR_JT32", ":", "O", "<<", "\"\\tbru \"", "<<", "XCoreInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "<<", "'\\n'", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "BR_JT", ")", "printInlineJT", "(", "MI", ",", "0", ",", "O", ")", ";", "else", "printInlineJT32", "(", "MI", ",", "0", ",", "O", ")", ";", "O", "<<", "'\\n'", ";", "OutStreamer", "->", "EmitRawText", "(", "O", ".", "str", "(", ")", ")", ";", "return", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "128", "XCore::DBG_VALUE", "\"Should be handled target independently\"", "XCore::ADD_2rus", "2", "0", "\"\\tmov \"", "XCore", "0", "\", \"", "XCore", "1", "XCore::BR_JT", "XCore::BR_JT32", "\"\\tbru \"", "XCore", "1", "XCore::BR_JT", "0", "0" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "allocateSpecialInputVGPRs", "(", "CCState", "&", "CCInfo", ",", "MachineFunction", "&", "MF", ",", "const", "SIRegisterInfo", "&", "TRI", ",", "SIMachineFunctionInfo", "&", "Info", ")", "const", "{", "const", "unsigned", "Mask", "=", "0x3ff", ";", "ArgDescriptor", "Arg", ";", "if", "(", "Info", ".", "hasWorkItemIDX", "(", ")", ")", "{", "Arg", "=", "allocateVGPR32Input", "(", "CCInfo", ",", "Mask", ")", ";", "Info", ".", "setWorkItemIDX", "(", "Arg", ")", ";", "}", "if", "(", "Info", ".", "hasWorkItemIDY", "(", ")", ")", "{", "Arg", "=", "allocateVGPR32Input", "(", "CCInfo", ",", "Mask", "<<", "10", ",", "Arg", ")", ";", "Info", ".", "setWorkItemIDY", "(", "Arg", ")", ";", "}", "if", "(", "Info", ".", "hasWorkItemIDZ", "(", ")", ")", "Info", ".", "setWorkItemIDZ", "(", "allocateVGPR32Input", "(", "CCInfo", ",", "Mask", "<<", "20", ",", "Arg", ")", ")", ";", "}", "</s>" ]

[ "Allocate", "implicit", "function", "VGPR", "arguments", "at", "the", "end", "of", "allocated", "user", "arguments", "." ]

[ "AMDGPU", "SI", "SI", "SI", "0x3ff", "10", "20" ]

[]

[ "<s>", "static", "unsigned", "int", "sh_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "XD_REGISTER_P", "(", "regno", ")", ")", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "2", "*", "UNITS_PER_WORD", ")", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", ".", "On", "the", "SH", "all", "but", "the", "XD", "regs", "are", "UNITS_PER_WORD", "bits", "wide", "." ]

[ "sh", "2" ]

[]

[ "<s>", "static", "rtx", "m32r_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_FUNCTION_VALUE", "." ]

[ "m32r", "0" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "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", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "static", "bool", "ix86_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SSE", "&&", "VALID_SSE_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_SSE2", "&&", "VALID_SSE2_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_MMX", "&&", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_3DNOW", "&&", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "i386" ]

[]

[ "<s>", "MachineRegisterInfo", "&", "getRegInfo", "(", "Block", "&", "MBB", ")", "{", "return", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegInfo", "-", "Return", "information", "about", "the", "registers", "currently", "in", "use", "." ]

[ "AVR" ]

[]

[ "<s>", "void", "PIC16InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "PIC16TargetLowering", "*", "PTLI", "=", "TM", ".", "getTargetLowering", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "const", "std", "::", "string", "FuncName", "=", "Func", "->", "getName", "(", ")", ";", "const", "char", "*", "tmpName", "=", "ESNames", "::", "createESName", "(", "PAN", "::", "getTempdataLabel", "(", "FuncName", ")", ")", ";", "if", "(", "RC", "==", "PIC16", "::", "GPRRegisterClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "PIC16", "::", "movf", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "1", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "if", "(", "RC", "==", "PIC16", "::", "FSR16RegisterClass", ")", "{", "unsigned", "opcode", "=", "(", "DestReg", "==", "PIC16", "::", "FSR0", ")", "?", "PIC16", "::", "restore_fsr0", ":", "PIC16", "::", "restore_fsr1", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opcode", ")", ",", "DestReg", ")", ".", "addImm", "(", "PTLI", "->", "GetTmpOffsetForFI", "(", "FI", ",", "3", ")", ")", ".", "addExternalSymbol", "(", "tmpName", ")", ".", "addImm", "(", "1", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "PIC16", "PIC16", "PIC16", "PIC16::GPRRegisterClass", "PIC16::movf", "1", "1", "PIC16::FSR16RegisterClass", "PIC16::FSR0", "PIC16::restore_fsr0", "PIC16::restore_fsr1", "3", "1", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "unsigned", "HexagonMCCodeEmitter", "::", "getMachineOpValue", "(", "MCInst", "const", "&", "MI", ",", "MCOperand", "const", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MCT", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MI", ",", "MO", ",", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "expand_a_shift", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "operands", "[", "]", ")", "{", "switch", "(", "h8sx_classify_shift", "(", "mode", ",", "code", ",", "operands", "[", "2", "]", ")", ")", "{", "case", "H8SX_SHIFT_BINARY", ":", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "return", "false", ";", "case", "H8SX_SHIFT_UNARY", ":", "return", "false", ";", "case", "H8SX_SHIFT_NONE", ":", "break", ";", "}", "emit_move_insn", "(", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "operands", "[", "2", "]", "==", "CONST0_RTX", "(", "QImode", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "!", "h8300_shift_needs_scratch_p", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ",", "mode", ",", "code", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "copy_rtx", "(", "operands", "[", "1", "]", ")", ",", "operands", "[", "2", "]", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "2", "]", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "QImode", ")", ")", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Called", "from", "the", ".md", "file", "to", "emit", "code", "to", "do", "shifts", ".", "Returns", "a", "boolean", "indicating", "success", "(", "currently", "this", "is", "always", "TRUE", ")", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "TM", "=", "static_cast", "<", "const", "PPCTargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "TII", "=", "TM", "->", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "size", "(", ")", "<", "2", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "2" ]

[]

[ "<s>", "bool", "SystemZDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SystemZAddressingMode", "::", "AddrForm", "Form", ";", "SystemZAddressingMode", "::", "DispRange", "DispRange", ";", "SDValue", "Base", ",", "Disp", ",", "Index", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_ZQ", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_R", ":", "case", "InlineAsm", "::", "Constraint_ZR", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp12Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_S", ":", "case", "InlineAsm", "::", "Constraint_ZS", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBD", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "case", "InlineAsm", "::", "Constraint_T", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_p", ":", "case", "InlineAsm", "::", "Constraint_ZT", ":", "Form", "=", "SystemZAddressingMode", "::", "FormBDXNormal", ";", "DispRange", "=", "SystemZAddressingMode", "::", "Disp20Only", ";", "break", ";", "}", "if", "(", "selectBDXAddr", "(", "Form", ",", "DispRange", ",", "Op", ",", "Base", ",", "Disp", ",", "Index", ")", ")", "{", "const", "TargetRegisterClass", "*", "TRC", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "*", "MF", ")", ";", "SDLoc", "DL", "(", "Base", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Base", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetFrameIndex", "&&", "Base", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "Register", ")", "{", "Base", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "DL", ",", "Base", ".", "getValueType", "(", ")", ",", "Base", ",", "RC", ")", ",", "0", ")", ";", "}", "if", "(", "Index", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "Register", ")", "{", "Index", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "DL", ",", "Index", ".", "getValueType", "(", ")", ",", "Index", ",", "RC", ")", ",", "0", ")", ";", "}", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Disp", ")", ";", "OutOps", ".", "push_back", "(", "Index", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "SystemZ", "SystemZ", "SystemZAddressingMode::AddrForm", "SystemZAddressingMode::DispRange", "\"Unexpected asm memory constraint\"", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp12Only", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp20Only", "SystemZAddressingMode::FormBDXNormal", "SystemZAddressingMode::Disp20Only", "MVT::i32", "ISD::TargetFrameIndex", "ISD::Register", "0", "ISD::Register", "0" ]

[]

[ "<s>", "rtx", "tilegx_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "TILEGX_LINK_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "indicating", "where", "the", "return", "address", "to", "the", "calling", "function", "can", "be", "found", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "static", "inline", "bool", "offset_6bit_signed_scaled_p", "(", "machine_mode", "mode", ",", "poly_int64", "offset", ")", "{", "HOST_WIDE_INT", "multiple", ";", "return", "(", "constant_multiple_p", "(", "offset", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "&", "multiple", ")", "&&", "IN_RANGE", "(", "multiple", ",", "-", "32", ",", "31", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OFFSET", "is", "a", "signed", "6-bit", "value", "multiplied", "by", "the", "size", "of", "MODE", "." ]

[ "aarch64", "32", "31" ]

[]

[ "<s>", "static", "const", "char", "*", "output_inline_const", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "HOST_WIDE_INT", "x", "=", "0", ",", "y", "=", "0", ";", "int", "trick_no", ";", "rtx", "out_operands", "[", "3", "]", ";", "char", "buf", "[", "256", "]", ";", "char", "load_op", "[", "256", "]", ";", "const", "char", "*", "dst_fmt", ";", "HOST_WIDE_INT", "value", ";", "value", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "trick_no", "=", "try_constant_tricks", "(", "value", ",", "&", "x", ",", "&", "y", ")", ";", "gcc_assert", "(", "trick_no", "!=", "0", ")", ";", "if", "(", "trick_no", "==", "1", ")", "x", "=", "value", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "x", ")", ";", "if", "(", "trick_no", ">", "2", ")", "out_operands", "[", "2", "]", "=", "GEN_INT", "(", "y", ")", ";", "if", "(", "mode", "==", "DImode", "&&", "(", "!", "TARGET_LITTLE_END", ")", ")", "dst_fmt", "=", "\"%R0\"", ";", "else", "dst_fmt", "=", "\"%0\"", ";", "if", "(", "x", ">=", "0", "&&", "x", "<=", "127", ")", "sprintf", "(", "load_op", ",", "\"movi\\t%s,%%1\"", ",", "dst_fmt", ")", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "x", ")", ")", "sprintf", "(", "load_op", ",", "\"bgeni\\t%s,%%P1\"", ",", "dst_fmt", ")", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "x", ")", ")", "sprintf", "(", "load_op", ",", "\"bmaski\\t%s,%%N1\"", ",", "dst_fmt", ")", ";", "else", "{", "sprintf", "(", "load_op", ",", "\"BADMOVI-inline_const %s, %%1\"", ",", "dst_fmt", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "trick_no", ")", "{", "case", "1", ":", "strcpy", "(", "buf", ",", "load_op", ")", ";", "break", ";", "case", "2", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tnot\\t%s\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "3", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\taddi\\t%s,%%2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "4", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tsubi\\t%s,%%2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "5", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\trsubi\\t%s,%%2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "6", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tbseti\\t%s,%%P2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "7", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tbclri\\t%s,%%Q2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "8", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\trotli\\t%s,%%2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "9", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tlsli\\t%s,%%2\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "10", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tixh\\t%s,%s\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "11", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tixw\\t%s,%s\\t// %ld 0x%lx\"", ",", "load_op", ",", "dst_fmt", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "default", ":", "return", "\"\"", ";", "}", "output_asm_insn", "(", "buf", ",", "out_operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "an", "inline", "constant", "." ]

[ "mcore", "0", "0", "3", "256", "256", "1", "0", "1", "0", "0", "1", "2", "2", "\"%R0\"", "\"%0\"", "0", "127", "\"movi\\t%s,%%1\"", "\"bgeni\\t%s,%%P1\"", "\"bmaski\\t%s,%%N1\"", "\"BADMOVI-inline_const %s, %%1\"", "1", "2", "\"%s\\n\\tnot\\t%s\\t// %ld 0x%lx\"", "3", "\"%s\\n\\taddi\\t%s,%%2\\t// %ld 0x%lx\"", "4", "\"%s\\n\\tsubi\\t%s,%%2\\t// %ld 0x%lx\"", "5", "\"%s\\n\\trsubi\\t%s,%%2\\t// %ld 0x%lx\"", "6", "\"%s\\n\\tbseti\\t%s,%%P2\\t// %ld 0x%lx\"", "7", "\"%s\\n\\tbclri\\t%s,%%Q2\\t// %ld 0x%lx\"", "8", "\"%s\\n\\trotli\\t%s,%%2\\t// %ld 0x%lx\"", "9", "\"%s\\n\\tlsli\\t%s,%%2\\t// %ld 0x%lx\"", "10", "\"%s\\n\\tixh\\t%s,%s\\t// %ld 0x%lx\"", "11", "\"%s\\n\\tixw\\t%s,%s\\t// %ld 0x%lx\"", "\"\"", "\"\"" ]

[]

[ "<s>", "unsigned", "getMaxInlineSizeThreshold", "(", ")", "const", "{", "return", "64", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "memset", "/", "memcpy", "size", "that", "still", "makes", "it", "profitable", "to", "inline", "the", "call", "." ]

[ "ARM", "64" ]

[]

[ "<s>", "bool", "PatmosPMLProfileImport", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "PMLMachineFunctionImport", "&", "PI", "=", "getAnalysis", "<", "PMLMachineFunctionImport", ">", "(", ")", ";", "if", "(", "!", "PI", ".", "isAvailable", "(", ")", ")", "return", "false", ";", "PI", ".", "loadCriticalityMap", "(", ")", ";", "PatmosMachineFunctionInfo", "&", "PMFI", "=", "*", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "PatmosAnalysisInfo", "&", "PAI", "=", "PMFI", ".", "getAnalysisInfo", "(", ")", ";", "MachineBranchProbabilityInfo", "&", "MBPI", "=", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "it", "=", "MF", ".", "begin", "(", ")", ",", "ie", "=", "MF", ".", "end", "(", ")", ";", "it", "!=", "ie", ";", "it", "++", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "it", ";", "double", "Crit", "=", "PI", ".", "getCriticalty", "(", "MBB", ")", ";", "PAI", ".", "setCriticality", "(", "MBB", ",", "Crit", ")", ";", "uint64_t", "Freq", "=", "PI", ".", "getWCETFrequency", "(", "MBB", ")", ";", "PAI", ".", "setFrequency", "(", "MBB", ",", "Freq", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "succ", "=", "MBB", "->", "succ_begin", "(", ")", ",", "se", "=", "MBB", "->", "succ_end", "(", ")", ";", "succ", "!=", "se", ";", "succ", "++", ")", "{", "MachineBasicBlock", "*", "ToMBB", "=", "*", "succ", ";", "uint32_t", "Weight", ";", "if", "(", "UseCritEdgeWeight", ")", "{", "Weight", "=", "round", "(", "PI", ".", "getCriticalty", "(", "MBB", ",", "ToMBB", ",", "1.0", ")", "*", "10000.0", ")", ";", "}", "else", "{", "Weight", "=", "PI", ".", "getWCETFrequency", "(", "MBB", ",", "ToMBB", ",", "0", ")", ";", "}", "MBPI", ".", "setEdgeWeight", "(", "MBB", ",", "succ", ",", "Weight", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "1.0", "10000.0", "0" ]

[]

[ "<s>", "static", "bool", "mips_lx_address_p", "(", "rtx", "addr", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", "||", "!", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "||", "!", "REG_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "ISA_HAS_LBX", "&&", "mode", "==", "QImode", ")", "return", "true", ";", "if", "(", "ISA_HAS_LHX", "&&", "mode", "==", "HImode", ")", "return", "true", ";", "if", "(", "ISA_HAS_LWX", "&&", "mode", "==", "SImode", ")", "return", "true", ";", "if", "(", "ISA_HAS_LDX", "&&", "mode", "==", "DImode", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "matches", "the", "pattern", "for", "the", "L", "{", "B", ",", "H", ",", "W", ",", "D", "}", "{", ",", "U", "}", "X", "load", "indexed", "address", "instruction", ".", "Note", "that", "such", "addresses", "are", "not", "considered", "legitimate", "in", "the", "TARGET_LEGITIMATE_ADDRESS_P", "sense", ",", "because", "their", "use", "is", "so", "restricted", "." ]

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

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "KindReg", "&&", "\"Not a register\"", ")", ";", "return", "Reg", ".", "Num", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "RISCV", "\"Not a register\"" ]

[]

[ "<s>", "static", "void", "sh_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "if", "(", "TARGET_ELF", ")", "fprintf", "(", "asm_out_file", ",", "\"%s\\n\"", ",", "TEXT_SECTION_ASM_OP", ")", ";", "else", "switch_to_section", "(", "data_section", ")", ";", "if", "(", "TARGET_LITTLE_ENDIAN", ")", "fputs", "(", "\"\\t.little\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "!", "TARGET_ELF", ")", "{", "if", "(", "TARGET_SHCOMPACT", ")", "fputs", "(", "\"\\t.mode\\tSHcompact\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_SHMEDIA", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.mode\\tSHmedia\\n\\t.abi\\t%i\\n\"", ",", "TARGET_SHMEDIA64", "?", "64", ":", "32", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "start", "of", "the", "assembler", "file", "." ]

[ "sh", "\"%s\\n\"", "\"\\t.little\\n\"", "\"\\t.mode\\tSHcompact\\n\"", "\"\\t.mode\\tSHmedia\\n\\t.abi\\t%i\\n\"", "64", "32" ]

[]

[ "<s>", "static", "void", "output_indirect_thunk", "(", "enum", "indirect_thunk_prefix", "need_prefix", ",", "unsigned", "int", "regno", ")", "{", "char", "indirectlabel1", "[", "32", "]", ";", "char", "indirectlabel2", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel1", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "indirectlabel2", ",", "INDIRECT_LABEL", ",", "indirectlabelno", "++", ")", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fputs", "(", "\"\\tbnd call\\t\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tcall\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tpause\\n\\tlfence\\n\"", ")", ";", "fputs", "(", "\"\\tjmp\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "indirectlabel1", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "indirectlabel2", ")", ";", "if", "(", "regno", "!=", "INVALID_REGNUM", ")", "{", "rtx", "xops", "[", "2", "]", ";", "xops", "[", "0", "]", "=", "gen_rtx_MEM", "(", "word_mode", ",", "stack_pointer_rtx", ")", ";", "xops", "[", "1", "]", "=", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ";", "output_asm_insn", "(", "\"mov\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "}", "else", "{", "rtx", "xops", "[", "2", "]", ";", "xops", "[", "0", "]", "=", "stack_pointer_rtx", ";", "xops", "[", "1", "]", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";", "output_asm_insn", "(", "\"lea\\t{%E1, %0|%0, %E1}\"", ",", "xops", ")", ";", "}", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "fputs", "(", "\"\\tbnd ret\\n\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tret\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "a", "call", "and", "return", "thunk", "for", "indirect", "branch", ".", "If", "BND_P", "is", "true", ",", "the", "BND", "prefix", "is", "needed", ".", "If", "REGNO", "!", "=", "-1", ",", "the", "function", "address", "is", "in", "REGNO", "and", "the", "call", "and", "return", "thunk", "looks", "like", ":", "call", "L2", "L1", ":", "pause", "lfence", "jmp", "L1", "L2", ":", "mov", "%", "REG", ",", "(", "%", "sp", ")", "ret", "Otherwise", ",", "the", "function", "address", "is", "on", "the", "top", "of", "stack", "and", "the", "call", "and", "return", "thunk", "looks", "like", ":", "call", "L2", "L1", ":", "pause", "lfence", "jmp", "L1", "L2", ":", "lea", "WORD_SIZE", "(", "%", "sp", ")", ",", "%", "sp", "ret" ]

[ "i386", "32", "32", "\"\\tbnd call\\t\"", "\"\\tcall\\t\"", "\"\\tpause\\n\\tlfence\\n\"", "\"\\tjmp\\t\"", "2", "0", "1", "\"mov\\t{%1, %0|%0, %1}\"", "2", "0", "1", "\"lea\\t{%E1, %0|%0, %E1}\"", "\"\\tbnd ret\\n\"", "\"\\tret\\n\"" ]

[]

[ "<s>", "static", "type_suffix_index", "parse_element_type", "(", "const", "function_instance", "&", "instance", ",", "const", "char", "*", "&", "format", ")", "{", "int", "ch", "=", "*", "format", "++", ";", "if", "(", "ch", "==", "'f'", "||", "ch", "==", "'s'", "||", "ch", "==", "'u'", ")", "{", "type_class_index", "tclass", "=", "(", "ch", "==", "'f'", "?", "TYPE_float", ":", "ch", "==", "'s'", "?", "TYPE_signed", ":", "TYPE_unsigned", ")", ";", "char", "*", "end", ";", "unsigned", "int", "bits", "=", "strtol", "(", "format", ",", "&", "end", ",", "10", ")", ";", "format", "=", "end", ";", "if", "(", "bits", "==", "0", "||", "bits", "==", "1", ")", "bits", "=", "instance", ".", "type_suffix", "(", "bits", ")", ".", "element_bits", ";", "return", "find_type_suffix", "(", "tclass", ",", "bits", ")", ";", "}", "if", "(", "ch", "==", "'w'", ")", "{", "type_suffix_index", "suffix", "=", "parse_element_type", "(", "instance", ",", "format", ")", ";", "if", "(", "type_suffixes", "[", "suffix", "]", ".", "integer_p", ")", "return", "find_type_suffix", "(", "type_suffixes", "[", "suffix", "]", ".", "tclass", ",", "64", ")", ";", "return", "suffix", ";", "}", "if", "(", "ch", "==", "'p'", ")", "return", "TYPE_SUFFIX_b", ";", "if", "(", "ch", "==", "'B'", ")", "return", "TYPE_SUFFIX_bf16", ";", "if", "(", "ch", "==", "'q'", ")", "{", "type_suffix_index", "suffix", "=", "parse_element_type", "(", "instance", ",", "format", ")", ";", "return", "find_type_suffix", "(", "type_suffixes", "[", "suffix", "]", ".", "tclass", ",", "type_suffixes", "[", "suffix", "]", ".", "element_bits", "/", "4", ")", ";", "}", "if", "(", "ch", "==", "'h'", ")", "{", "type_suffix_index", "suffix", "=", "parse_element_type", "(", "instance", ",", "format", ")", ";", "if", "(", "suffix", "==", "TYPE_SUFFIX_b", ")", "return", "suffix", ";", "return", "find_type_suffix", "(", "type_suffixes", "[", "suffix", "]", ".", "tclass", ",", "type_suffixes", "[", "suffix", "]", ".", "element_bits", "/", "2", ")", ";", "}", "if", "(", "ch", "==", "'0'", "||", "ch", "==", "'1'", ")", "return", "instance", ".", "type_suffix_ids", "[", "ch", "-", "'0'", "]", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Parse", "and", "move", "past", "an", "element", "type", "in", "FORMAT", "and", "return", "it", "as", "a", "type", "suffix", ".", "The", "format", "is", ":", "[", "01", "]", "-", "the", "element", "type", "in", "type", "suffix", "0", "or", "1", "of", "INSTANCE", "f", "<", "bits", ">", "-", "a", "floating-point", "type", "with", "the", "given", "number", "of", "bits", "f", "[", "01", "]", "-", "a", "floating-point", "type", "with", "the", "same", "width", "as", "type", "suffix", "0", "or", "1", "B", "-", "bfloat16_t", "h", "<", "elt", ">", "-", "a", "half-sized", "version", "of", "<", "elt", ">", "p", "-", "a", "predicate", "(", "represented", "as", "TYPE_SUFFIX_b", ")", "q", "<", "elt", ">", "-", "a", "quarter-sized", "version", "of", "<", "elt", ">", "s", "<", "bits", ">", "-", "a", "signed", "type", "with", "the", "given", "number", "of", "bits", "s", "[", "01", "]", "-", "a", "signed", "type", "with", "the", "same", "width", "as", "type", "suffix", "0", "or", "1", "u", "<", "bits", ">", "-", "an", "unsigned", "type", "with", "the", "given", "number", "of", "bits", "u", "[", "01", "]", "-", "an", "unsigned", "type", "with", "the", "same", "width", "as", "type", "suffix", "0", "or", "1", "w", "<", "elt", ">", "-", "a", "64-bit", "version", "of", "<", "elt", ">", "if", "<", "elt", ">", "is", "integral", ",", "otherwise", "<", "elt", ">", "where", "<", "elt", ">", "is", "another", "element", "type", "." ]

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

[]

[ "<s>", "int", "GCNTTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "Ty", ",", "bool", "IsPairwise", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "Ty", ",", "IsPairwise", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getFullRateInstrCost", "(", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "AsmVariant", ")", "{", "printIntelMemReference", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "break", ";", "case", "'H'", ":", "printMemReference", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ",", "\"H\"", ")", ";", "return", "false", ";", "case", "'P'", ":", "printMemReference", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ",", "\"no-rip\"", ")", ";", "return", "false", ";", "}", "}", "printMemReference", "(", "*", "this", ",", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "X86", "X86", "0", "1", "0", "0", "\"H\"", "\"no-rip\"" ]

[]

[ "<s>", "void", "c6x_output_file_unwind", "(", "FILE", "*", "f", ")", "{", "if", "(", "done_cfi_sections", ")", "return", ";", "if", "(", "dwarf2out_do_frame", "(", ")", ")", "{", "if", "(", "flag_unwind_tables", "||", "flag_exceptions", ")", "{", "if", "(", "dwarf_debuginfo_p", "(", ")", ")", "asm_fprintf", "(", "f", ",", "\"\\t.cfi_sections .debug_frame, .c6xabi.exidx\\n\"", ")", ";", "else", "asm_fprintf", "(", "f", ",", "\"\\t.cfi_sections .c6xabi.exidx\\n\"", ")", ";", "}", "else", "asm_fprintf", "(", "f", ",", "\"\\t.cfi_sections .debug_frame\\n\"", ")", ";", "done_cfi_sections", "=", "true", ";", "}", "}", "</s>" ]

[ "The", "LTO", "frontend", "only", "enables", "exceptions", "when", "it", "sees", "a", "function", "that", "uses", "it", ".", "This", "changes", "the", "return", "value", "of", "dwarf2out_do_frame", ",", "so", "we", "have", "to", "check", "before", "every", "function", "." ]

[ "c6x", "\"\\t.cfi_sections .debug_frame, .c6xabi.exidx\\n\"", "\"\\t.cfi_sections .c6xabi.exidx\\n\"", "\"\\t.cfi_sections .debug_frame\\n\"" ]

[]

[ "<s>", "bool", "PIC16AsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "EmitAllAutos", "(", "M", ")", ";", "printLibcallDecls", "(", ")", ";", "DbgInfo", ".", "EndModule", "(", "M", ")", ";", "O", "<<", "\"\\n\\t\"", "<<", "\"END\\n\"", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "PIC16", "PIC16", "\"\\n\\t\"", "\"END\\n\"" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "finalizeInsInstrs", "(", "MachineInstr", "&", "Root", ",", "MachineCombinerPattern", "&", "P", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "InsInstrs", ")", "const", "{", "assert", "(", "!", "InsInstrs", ".", "empty", "(", ")", "&&", "\"Instructions set to be inserted is empty!\"", ")", ";", "MachineFunction", "*", "MF", "=", "Root", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineConstantPool", "*", "MCP", "=", "MF", "->", "getConstantPool", "(", ")", ";", "int16_t", "Idx", "=", "getFMAOpIdxInfo", "(", "Root", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Idx", "<", "0", ")", "return", ";", "uint16_t", "FirstMulOpIdx", "=", "FMAOpIdxInfo", "[", "Idx", "]", "[", "InfoArrayIdxMULOpIdx", "]", ";", "Register", "ConstReg", "=", "0", ";", "switch", "(", "P", ")", "{", "case", "MachineCombinerPattern", "::", "REASSOC_XY_BCA", ":", "ConstReg", "=", "TRI", "->", "lookThruCopyLike", "(", "Root", ".", "getOperand", "(", "FirstMulOpIdx", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "break", ";", "case", "MachineCombinerPattern", "::", "REASSOC_XY_BAC", ":", "ConstReg", "=", "TRI", "->", "lookThruCopyLike", "(", "Root", ".", "getOperand", "(", "FirstMulOpIdx", "+", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "break", ";", "default", ":", "return", ";", "}", "MachineInstr", "*", "ConstDefInstr", "=", "MRI", "->", "getVRegDef", "(", "ConstReg", ")", ";", "const", "Constant", "*", "C", "=", "getConstantFromConstantPool", "(", "ConstDefInstr", ")", ";", "assert", "(", "isa", "<", "llvm", "::", "ConstantFP", ">", "(", "C", ")", "&&", "\"not a valid constant!\"", ")", ";", "APFloat", "F1", "(", "(", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "->", "getValueAPF", "(", ")", ")", ";", "F1", ".", "changeSign", "(", ")", ";", "Constant", "*", "NegC", "=", "ConstantFP", "::", "get", "(", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", "->", "getContext", "(", ")", ",", "F1", ")", ";", "Align", "Alignment", "=", "MF", "->", "getDataLayout", "(", ")", ".", "getPrefTypeAlign", "(", "C", "->", "getType", "(", ")", ")", ";", "unsigned", "ConstPoolIdx", "=", "MCP", "->", "getConstantPoolIndex", "(", "NegC", ",", "Alignment", ")", ";", "MachineOperand", "*", "Placeholder", "=", "nullptr", ";", "for", "(", "auto", "*", "Inst", ":", "InsInstrs", ")", "{", "for", "(", "MachineOperand", "&", "Operand", ":", "Inst", "->", "explicit_operands", "(", ")", ")", "{", "assert", "(", "Operand", ".", "isReg", "(", ")", "&&", "\"Invalid instruction in InsInstrs!\"", ")", ";", "if", "(", "Operand", ".", "getReg", "(", ")", "==", "PPC", "::", "ZERO8", ")", "{", "Placeholder", "=", "&", "Operand", ";", "break", ";", "}", "}", "}", "assert", "(", "Placeholder", "&&", "\"Placeholder does not exist!\"", ")", ";", "Register", "LoadNewConst", "=", "generateLoadForNewConst", "(", "ConstPoolIdx", ",", "&", "Root", ",", "C", "->", "getType", "(", ")", ",", "InsInstrs", ")", ";", "Placeholder", "->", "setReg", "(", "LoadNewConst", ")", ";", "}", "</s>" ]

[ "Fix", "up", "the", "placeholder", "we", "may", "add", "in", "genAlternativeCodeSequence", "(", ")", "." ]

[ "PowerPC", "PPC", "\"Instructions set to be inserted is empty!\"", "0", "0", "1", "\"not a valid constant!\"", "\"Invalid instruction in InsInstrs!\"", "PPC::ZERO8", "\"Placeholder does not exist!\"" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "SetupMachineFunction", "(", "MF", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "'@'", ")", "+", "MF", ".", "getName", "(", ")", "+", "Twine", "(", "':'", ")", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "const", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "ConfigSection", ")", ";", "const", "AMDGPUSubtarget", "&", "STM", "=", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "SIProgramInfo", "KernelInfo", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "getSIProgramInfo", "(", "KernelInfo", ",", "MF", ")", ";", "EmitProgramInfoSI", "(", "MF", ",", "KernelInfo", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "DisasmLines", ".", "clear", "(", ")", ";", "HexLines", ".", "clear", "(", ")", ";", "DisasmLineMaxLen", "=", "0", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "const", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "CommentSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "OutStreamer", ".", "emitRawComment", "(", "\" Kernel info:\"", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" codeLenInByte = \"", "+", "Twine", "(", "KernelInfo", ".", "CodeLen", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" NumSgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumSGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" NumVgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumVGPR", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" FloatMode: \"", "+", "Twine", "(", "KernelInfo", ".", "FloatMode", ")", ",", "false", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "\" IeeeMode: \"", "+", "Twine", "(", "KernelInfo", ".", "IEEEMode", ")", ",", "false", ")", ";", "}", "else", "{", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", ".", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "StackSize", ")", ")", ")", ";", "}", "}", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "MF", ".", "dump", "(", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "Context", ".", "getELFSection", "(", "\".AMDGPU.disasm\"", ",", "ELF", "::", "SHT_NOTE", ",", "0", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "DisasmLines", ".", "size", "(", ")", ";", "++", "i", ")", "{", "std", "::", "string", "Comment", "(", "DisasmLineMaxLen", "-", "DisasmLines", "[", "i", "]", ".", "size", "(", ")", ",", "' '", ")", ";", "Comment", "+=", "\" ; \"", "+", "HexLines", "[", "i", "]", "+", "\"\\n\"", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "DisasmLines", "[", "i", "]", ")", ")", ";", "OutStreamer", ".", "EmitBytes", "(", "StringRef", "(", "Comment", ")", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "\".AMDGPU.config\"", "0", "SI", "SI", "SI", "0", "\".AMDGPU.csdata\"", "0", "\" Kernel info:\"", "\" codeLenInByte = \"", "\" NumSgprs: \"", "\" NumVgprs: \"", "\" FloatMode: \"", "\" IeeeMode: \"", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "\".AMDGPU.disasm\"", "0", "0", "\" ; \"", "\"\\n\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", ";", "OS", "<<", "*", "Imm", ".", "Val", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<\"", ";", "Mem", ".", "Base", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\", \"", ";", "OS", "<<", "*", "Mem", ".", "Off", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_PhysRegister", ":", "OS", "<<", "\"PhysReg<\"", "<<", "PhysReg", ".", "Num", "<<", "\">\"", ";", "break", ";", "case", "k_RegisterIndex", ":", "OS", "<<", "\"RegIdx<\"", "<<", "RegIdx", ".", "Index", "<<", "\":\"", "<<", "RegIdx", ".", "Kind", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "case", "k_RegList", ":", "OS", "<<", "\"RegList< \"", ";", "for", "(", "auto", "Reg", ":", "(", "*", "RegList", ".", "List", ")", ")", "OS", "<<", "Reg", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_RegPair", ":", "OS", "<<", "\"RegPair<\"", "<<", "RegIdx", ".", "Index", "<<", "\",\"", "<<", "RegIdx", ".", "Index", "+", "1", "<<", "\">\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Mips", "\"Imm<\"", "\">\"", "\"Mem<\"", "\", \"", "\">\"", "\"PhysReg<\"", "\">\"", "\"RegIdx<\"", "\":\"", "\">\"", "\"RegList< \"", "\" \"", "\">\"", "\"RegPair<\"", "\",\"", "1", "\">\"" ]

[]

[ "<s>", "void", "Finish", "(", ")", "{", "const", "size_t", "ContentsSize", "=", "Contents", ".", "size", "(", ")", ";", "const", "size_t", "VendorHeaderSize", "=", "4", "+", "CurrentVendor", ".", "size", "(", ")", "+", "1", ";", "const", "size_t", "TagHeaderSize", "=", "1", "+", "4", ";", "Streamer", ".", "EmitIntValue", "(", "VendorHeaderSize", "+", "TagHeaderSize", "+", "ContentsSize", ",", "4", ")", ";", "Streamer", ".", "EmitBytes", "(", "CurrentVendor", ",", "0", ")", ";", "Streamer", ".", "EmitIntValue", "(", "0", ",", "1", ")", ";", "Streamer", ".", "EmitIntValue", "(", "ARMBuildAttrs", "::", "File", ",", "1", ")", ";", "Streamer", ".", "EmitIntValue", "(", "TagHeaderSize", "+", "ContentsSize", ",", "4", ")", ";", "Streamer", ".", "EmitBytes", "(", "Contents", ",", "0", ")", ";", "Contents", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Finish", "-", "Do", "final", "processing", "and", "write", "the", "object", "to", "the", "output", "stream", "." ]

[ "ARM", "4", "1", "1", "4", "4", "0", "0", "1", "ARMBuildAttrs::File", "1", "4", "0" ]

[]

[ "<s>", "CCAssignFn", "*", "CSKYTargetLowering", "::", "CCAssignFnForReturn", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "if", "(", "IsVarArg", "||", "!", "Subtarget", ".", "useHardFloatABI", "(", ")", ")", "return", "RetCC_CSKY_ABIV2_SOFT", ";", "else", "return", "RetCC_CSKY_ABIV2_FP", ";", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "SI_RegisterStorePseudo", ":", "{", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "SI_RegisterStore", ")", ",", "Reg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "R600", "SI", "SI", "SI", "SI", "SI", "0" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "SICTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "SICTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "\".sdata\"", "\".sbss\"", "SIC" ]

[]

[ "<s>", "void", "setReg", "(", "unsigned", "Val", ")", "{", "Contents", ".", "RegNum", "=", "Val", ";", "}", "</s>" ]

[ "Assigns", "the", "associated", "register", "for", "this", "edge", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "arm_valid_target_attribute_rec", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ")", "{", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "bool", "ret", "=", "true", ";", "for", "(", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "!", "arm_valid_target_attribute_rec", "(", "TREE_VALUE", "(", "args", ")", ",", "opts", ")", ")", "ret", "=", "false", ";", "return", "ret", ";", "}", "else", "if", "(", "TREE_CODE", "(", "args", ")", "!=", "STRING_CST", ")", "{", "error", "(", "\"attribute %<target%> argument not a string\"", ")", ";", "return", "false", ";", "}", "char", "*", "argstr", "=", "ASTRDUP", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "q", ";", "while", "(", "(", "q", "=", "strtok", "(", "argstr", ",", "\",\"", ")", ")", "!=", "NULL", ")", "{", "argstr", "=", "NULL", ";", "if", "(", "!", "strcmp", "(", "q", ",", "\"thumb\"", ")", ")", "{", "opts", "->", "x_target_flags", "|=", "MASK_THUMB", ";", "if", "(", "TARGET_FDPIC", "&&", "!", "arm_arch_thumb2", ")", "sorry", "(", "\"FDPIC mode is not supported in Thumb-1 mode\"", ")", ";", "}", "else", "if", "(", "!", "strcmp", "(", "q", ",", "\"arm\"", ")", ")", "opts", "->", "x_target_flags", "&=", "~", "MASK_THUMB", ";", "else", "if", "(", "!", "strcmp", "(", "q", ",", "\"general-regs-only\"", ")", ")", "opts", "->", "x_target_flags", "|=", "MASK_GENERAL_REGS_ONLY", ";", "else", "if", "(", "startswith", "(", "q", ",", "\"fpu=\"", ")", ")", "{", "int", "fpu_index", ";", "if", "(", "!", "opt_enum_arg_to_value", "(", "OPT_mfpu_", ",", "q", "+", "4", ",", "&", "fpu_index", ",", "CL_TARGET", ")", ")", "{", "error", "(", "\"invalid fpu for target attribute or pragma %qs\"", ",", "q", ")", ";", "return", "false", ";", "}", "if", "(", "fpu_index", "==", "TARGET_FPU_auto", ")", "{", "sorry", "(", "\"auto fpu selection not currently permitted here\"", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_fpu_index", "=", "(", "enum", "fpu_type", ")", "fpu_index", ";", "}", "else", "if", "(", "startswith", "(", "q", ",", "\"arch=\"", ")", ")", "{", "char", "*", "arch", "=", "q", "+", "5", ";", "const", "arch_option", "*", "arm_selected_arch", "=", "arm_parse_arch_option_name", "(", "all_architectures", ",", "\"arch\"", ",", "arch", ")", ";", "if", "(", "!", "arm_selected_arch", ")", "{", "error", "(", "\"invalid architecture for target attribute or pragma %qs\"", ",", "q", ")", ";", "return", "false", ";", "}", "opts", "->", "x_arm_arch_string", "=", "xstrndup", "(", "arch", ",", "strlen", "(", "arch", ")", ")", ";", "}", "else", "if", "(", "q", "[", "0", "]", "==", "'+'", ")", "{", "opts", "->", "x_arm_arch_string", "=", "xasprintf", "(", "\"%s%s\"", ",", "opts", "->", "x_arm_arch_string", ",", "q", ")", ";", "}", "else", "{", "error", "(", "\"unknown target attribute or pragma %qs\"", ",", "q", ")", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Inner", "function", "to", "process", "the", "attribute", "(", "(", "target", "(", "...", ")", ")", ")", ",", "take", "an", "argument", "and", "set", "the", "current", "options", "from", "the", "argument", ".", "If", "we", "have", "a", "list", ",", "recursively", "go", "over", "the", "list", "." ]

[ "arm", "\"attribute %<target%> argument not a string\"", "\",\"", "\"thumb\"", "\"FDPIC mode is not supported in Thumb-1 mode\"", "\"arm\"", "\"general-regs-only\"", "\"fpu=\"", "4", "\"invalid fpu for target attribute or pragma %qs\"", "\"auto fpu selection not currently permitted here\"", "\"arch=\"", "5", "\"arch\"", "\"invalid architecture for target attribute or pragma %qs\"", "0", "\"%s%s\"", "\"unknown target attribute or pragma %qs\"" ]

[]

[ "<s>", "static", "poly_uint64", "aarch64_vectorize_preferred_vector_alignment", "(", "const_tree", "type", ")", "{", "if", "(", "aarch64_sve_data_mode_p", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "{", "HOST_WIDE_INT", "result", ";", "if", "(", "!", "BITS_PER_SVE_VECTOR", ".", "is_constant", "(", "&", "result", ")", ")", "result", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "return", "result", ";", "}", "return", "TYPE_ALIGN", "(", "type", ")", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "HSAILTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "static", "void", "tilegx_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "fnaddr", ",", "chaddr", ";", "rtx", "mem", ";", "rtx", "begin_addr", ",", "end_addr", ";", "int", "ptr_mode_size", "=", "GET_MODE_SIZE", "(", "ptr_mode", ")", ";", "fnaddr", "=", "copy_to_reg", "(", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ")", ";", "chaddr", "=", "copy_to_reg", "(", "static_chain", ")", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "TRAMPOLINE_SIZE", "-", "2", "*", "ptr_mode_size", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "TRAMPOLINE_SIZE", "-", "ptr_mode_size", ")", ";", "emit_move_insn", "(", "mem", ",", "chaddr", ")", ";", "begin_addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "end_addr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__clear_cache\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "2", ",", "begin_addr", ",", "Pmode", ",", "end_addr", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_TRAMPOLINE_INIT", "." ]

[ "tilegx", "0", "2", "0", "0", "\"__clear_cache\"", "2" ]

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "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", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "unsigned", "RetOpc", "=", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", "||", "CallConv", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "?", "AVRISD", "::", "RETI_FLAG", ":", "AVRISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "AVR", "AVR", "AVRISD::RETI_FLAG", "AVRISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "static", "int", "riscv_binary_cost", "(", "rtx", "x", ",", "int", "single_insns", ",", "int", "double_insns", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "==", "UNITS_PER_WORD", "*", "2", ")", "return", "COSTS_N_INSNS", "(", "double_insns", ")", ";", "return", "COSTS_N_INSNS", "(", "single_insns", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "binary", "operation", "X", ",", "given", "that", "the", "instruction", "sequence", "for", "a", "word-sized", "or", "smaller", "operation", "takes", "SIGNLE_INSNS", "instructions", "and", "that", "the", "sequence", "of", "a", "double-word", "operation", "takes", "DOUBLE_INSNS", "instructions", "." ]

[ "riscv", "2" ]

[]

[ "<s>", "static", "void", "iq2000_va_start", "(", "tree", "valist", ",", "rtx", "nextarg", ")", "{", "int", "int_arg_words", ";", "int", "gpr_save_area_size", ";", "int_arg_words", "=", "crtl", "->", "args", ".", "info", ".", "arg_words", ";", "if", "(", "int_arg_words", "<", "8", ")", "gpr_save_area_size", "=", "(", "8", "-", "int_arg_words", ")", "*", "UNITS_PER_WORD", ";", "else", "gpr_save_area_size", "=", "0", ";", "nextarg", "=", "plus_constant", "(", "Pmode", ",", "nextarg", ",", "-", "gpr_save_area_size", ")", ";", "std_expand_builtin_va_start", "(", "valist", ",", "nextarg", ")", ";", "}", "</s>" ]

[ "Implement", "va_start", "." ]

[ "iq2000", "8", "8", "0" ]

[]

[ "<s>", "static", "int", "vfp3_const_double_index", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "m", ";", "int", "sign", ",", "exponent", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mant_hi", ";", "unsigned", "HOST_WIDE_INT", "mask", ";", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "bool", "fail", ";", "if", "(", "!", "TARGET_VFP3", "||", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "-", "1", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ")", "return", "-", "1", ";", "sign", "=", "REAL_VALUE_NEGATIVE", "(", "r", ")", "?", "1", ":", "0", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "mantissa", "=", "w", ".", "elt", "(", "0", ")", ";", "mant_hi", "=", "w", ".", "elt", "(", "1", ")", ";", "if", "(", "mantissa", "!=", "0", ")", "return", "-", "1", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mantissa", "=", "mant_hi", ";", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "point_pos", "-", "5", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "-", "1", ";", "mantissa", ">>=", "point_pos", "-", "5", ";", "if", "(", "mantissa", "==", "0", ")", "return", "-", "1", ";", "gcc_assert", "(", "mantissa", ">=", "16", "&&", "mantissa", "<=", "31", ")", ";", "exponent", "=", "5", "-", "exponent", ";", "if", "(", "exponent", "<", "0", "||", "exponent", ">", "7", ")", "return", "-", "1", ";", "return", "(", "sign", "<<", "7", ")", "|", "(", "(", "exponent", "^", "3", ")", "<<", "4", ")", "|", "(", "mantissa", "-", "16", ")", ";", "}", "</s>" ]

[ "Return", "an", "integer", "index", "for", "a", "VFPv3", "immediate", "operand", "X", "suitable", "for", "the", "fconst", "[", "sd", "]", "instruction", ",", "or", "-1", "if", "X", "is", "n't", "suitable", "." ]

[ "arm", "2", "1", "1", "1", "1", "0", "2", "0", "1", "0", "1", "1", "5", "1", "0", "1", "5", "0", "1", "16", "31", "5", "0", "7", "1", "7", "3", "4", "16" ]

[]

[ "<s>", "Register", "HexagonTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "const", "MachineFunction", "&", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"r19\"", ",", "Hexagon", "::", "R19", ")", ".", "Default", "(", "Register", "(", ")", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Hexagon", "Hexagon", "\"r19\"", "Hexagon::R19", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "SIC" ]

[]

[ "<s>", "static", "bool", "mips_need_noat_wrapper_p", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", ",", "int", "noperands", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "noperands", ";", "i", "++", ")", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "opvec", "[", "i", "]", ",", "NONCONST", ")", "if", "(", "REG_P", "(", "*", "iter", ")", "&&", "REGNO", "(", "*", "iter", ")", "==", "AT_REGNUM", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "needs", "to", "be", "wrapped", "in", "``", ".set", "noat", "''", ".", "INSN", "has", "NOPERANDS", "operands", ",", "stored", "in", "OPVEC", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ",", "DenseMap", "<", "MachineBasicBlock", "*", ",", "MachineBasicBlock", "*", ">", "*", "EM", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "BROpcode", ";", "unsigned", "CC", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown SELECT_CC!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "BROpcode", "=", "SP", "::", "BCOND", ";", "break", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "BROpcode", "=", "SP", "::", "FBCOND", ";", "break", ";", "}", "CC", "=", "(", "SPCC", "::", "CondCodes", ")", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "BROpcode", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "I", "=", "BB", "->", "succ_begin", "(", ")", ",", "E", "=", "BB", "->", "succ_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "EM", "->", "insert", "(", "std", "::", "make_pair", "(", "*", "I", ",", "sinkMBB", ")", ")", ";", "sinkMBB", "->", "addSuccessor", "(", "*", "I", ")", ";", "}", "while", "(", "!", "BB", "->", "succ_empty", "(", ")", ")", "BB", "->", "removeSuccessor", "(", "BB", "->", "succ_begin", "(", ")", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Sparc", "Sparc", "\"Unknown SELECT_CC!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::FBCOND", "SPCC::CondCodes", "3", "SP::PHI", "0", "2", "1" ]

[]

[ "<s>", "static", "bool", "nios2_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "nios2_legitimate_constant_p", "(", "mode", ",", "x", ")", "==", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "nios2" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getPreferredSwitchConditionType", "(", "LLVMContext", "&", "Context", ",", "EVT", "ConditionVT", ")", "const", "{", "if", "(", "ConditionVT", ".", "getSizeInBits", "(", ")", "<", "32", ")", "return", "MVT", "::", "i32", ";", "return", "TargetLoweringBase", "::", "getPreferredSwitchConditionType", "(", "Context", ",", "ConditionVT", ")", ";", "}", "</s>" ]

[ "Returns", "preferred", "type", "for", "switch", "condition", "." ]

[ "X86", "X86", "32", "MVT::i32" ]

[]

[ "<s>", "bool", "AMDGPUAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "std", "::", "vector", "<", "GlobalAlias", "*", ">", "AliasesToRemove", ";", "SmallPtrSet", "<", "Function", "*", ",", "8", ">", "FuncsToAlwaysInline", ";", "SmallPtrSet", "<", "Function", "*", ",", "8", ">", "FuncsToNoInline", ";", "for", "(", "GlobalAlias", "&", "A", ":", "M", ".", "aliases", "(", ")", ")", "{", "if", "(", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "A", ".", "getAliasee", "(", ")", ")", ")", "{", "A", ".", "replaceAllUsesWith", "(", "F", ")", ";", "AliasesToRemove", ".", "push_back", "(", "&", "A", ")", ";", "}", "}", "if", "(", "GlobalOpt", ")", "{", "for", "(", "GlobalAlias", "*", "A", ":", "AliasesToRemove", ")", "{", "A", "->", "eraseFromParent", "(", ")", ";", "}", "}", "for", "(", "GlobalVariable", "&", "GV", ":", "M", ".", "globals", "(", ")", ")", "{", "unsigned", "AS", "=", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", ";", "if", "(", "AS", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "AS", "!=", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "continue", ";", "recursivelyVisitUsers", "(", "GV", ",", "FuncsToAlwaysInline", ")", ";", "}", "if", "(", "!", "AMDGPUTargetMachine", "::", "EnableFunctionCalls", "||", "StressCalls", ")", "{", "auto", "IncompatAttr", "=", "StressCalls", "?", "Attribute", "::", "AlwaysInline", ":", "Attribute", "::", "NoInline", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "use_empty", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "IncompatAttr", ")", ")", "{", "if", "(", "StressCalls", ")", "{", "if", "(", "!", "FuncsToAlwaysInline", ".", "count", "(", "&", "F", ")", ")", "FuncsToNoInline", ".", "insert", "(", "&", "F", ")", ";", "}", "else", "FuncsToAlwaysInline", ".", "insert", "(", "&", "F", ")", ";", "}", "}", "}", "for", "(", "Function", "*", "F", ":", "FuncsToAlwaysInline", ")", "F", "->", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "for", "(", "Function", "*", "F", ":", "FuncsToNoInline", ")", "F", "->", "addFnAttr", "(", "Attribute", "::", "NoInline", ")", ";", "return", "!", "FuncsToAlwaysInline", ".", "empty", "(", ")", "||", "!", "FuncsToNoInline", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "8", "8", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "TargetPassConfig", "*", "SICTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "SICPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "SIC", "SIC", "SIC" ]

[]

[ "<s>", "bool", "Z80AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Unimplemented\"" ]

[]

[ "<s>", "static", "void", "ix86_option_override", "(", "void", ")", "{", "opt_pass", "*", "pass_insert_vzeroupper", "=", "make_pass_insert_vzeroupper", "(", "g", ")", ";", "struct", "register_pass_info", "insert_vzeroupper_info", "=", "{", "pass_insert_vzeroupper", ",", "\"reload\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "opt_pass", "*", "pass_stv", "=", "make_pass_stv", "(", "g", ")", ";", "struct", "register_pass_info", "stv_info", "=", "{", "pass_stv", ",", "\"combine\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "ix86_option_override_internal", "(", "true", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "register_pass", "(", "&", "insert_vzeroupper_info", ")", ";", "register_pass", "(", "&", "stv_info", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTION_OVERRIDE", "hook", "." ]

[ "i386", "\"reload\"", "1", "\"combine\"", "1" ]

[]

[ "<s>", "void", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INLINEASM", ":", "{", "if", "(", "tryInlineAsm", "(", "N", ")", ")", "return", ";", "break", ";", "}", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "ReplaceNode", "(", "N", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "CurDAG", "->", "getCopyToReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "SP", "::", "Y", ",", "TopPart", ",", "SDValue", "(", ")", ")", ".", "getValue", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Sparc", "Sparc", "1", "ISD::INLINEASM", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::Y", "1", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "llvm_unreachable", "(", "\"relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "PowerPC", "\"relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "static", "inline", "int", "bpf_helper_code", "(", "const", "char", "*", "name", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "BPF_BUILTIN_HELPER_MAX", ";", "++", "i", ")", "if", "(", "strcmp", "(", "name", ",", "bpf_helper_names", "[", "i", "]", ")", "==", "0", ")", "return", "i", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "builtin", "code", "corresponding", "to", "the", "kernel", "helper", "builtin", "__builtin_NAME", ",", "or", "0", "if", "the", "name", "does", "n't", "correspond", "to", "a", "kernel", "helper", "builtin", "." ]

[ "bpf", "1", "0", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createAArch64ELFObjectWriter", "(", "OS", ",", "OSABI", ",", "IsLittle", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "notice_update_cc", "(", "rtx", "body", ",", "rtx", "insn", ")", "{", "rtx", "set", ";", "switch", "(", "get_attr_cc", "(", "insn", ")", ")", "{", "case", "CC_NONE", ":", "break", ";", "case", "CC_NONE_0HIT", ":", "if", "(", "cc_status", ".", "value1", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "cc_status", ".", "value1", ")", ")", "cc_status", ".", "value1", "=", "0", ";", "if", "(", "cc_status", ".", "value2", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "cc_status", ".", "value2", ")", ")", "cc_status", ".", "value2", "=", "0", ";", "break", ";", "case", "CC_SET_ZN", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", "|", "CC_NO_CARRY", ";", "set", "=", "single_set", "(", "insn", ")", ";", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "SET_DEST", "(", "set", ")", "!=", "cc0_rtx", ")", "cc_status", ".", "value2", "=", "SET_DEST", "(", "set", ")", ";", "break", ";", "case", "CC_SET_ZNV", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_NO_CARRY", ";", "set", "=", "single_set", "(", "insn", ")", ";", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "SET_DEST", "(", "set", ")", "!=", "cc0_rtx", ")", "{", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "STRICT_LOW_PART", ")", "cc_status", ".", "value2", "=", "XEXP", "(", "SET_DEST", "(", "set", ")", ",", "0", ")", ";", "else", "cc_status", ".", "value2", "=", "SET_DEST", "(", "set", ")", ";", "}", "break", ";", "case", "CC_COMPARE", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "value1", "=", "SET_SRC", "(", "body", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "}", "}", "</s>" ]

[ "On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "." ]

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

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "LiveRangeShrinkID", ")", ";", "addPass", "(", "createX86FixupSetCC", "(", ")", ")", ";", "addPass", "(", "createX86OptimizeLEAs", "(", ")", ")", ";", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "}", "addPass", "(", "createX86WinAllocaExpander", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "static", "void", "frv_frame_insn", "(", "rtx", "pattern", ",", "rtx", "dwarf_pattern", ")", "{", "rtx", "insn", "=", "emit_insn", "(", "pattern", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "dwarf_pattern", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "frame-related", "instruction", "whose", "pattern", "is", "PATTERN", ".", "The", "instruction", "is", "the", "last", "in", "a", "sequence", "that", "cumulatively", "performs", "the", "operation", "described", "by", "DWARF_PATTERN", ".", "The", "instruction", "is", "marked", "as", "frame-related", "and", "has", "a", "REG_FRAME_RELATED_EXPR", "note", "containing", "DWARF_PATTERN", "." ]

[ "frv", "1" ]

[]