Datasets:

---

docz1105

/

ComBack

like 9

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

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

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

[]

[ "<s>", "void", "SIScheduleBlock", "::", "addUnit", "(", "SUnit", "*", "SU", ")", "{", "NodeNum2Index", "[", "SU", "->", "NodeNum", "]", "=", "SUnits", ".", "size", "(", ")", ";", "SUnits", ".", "push_back", "(", "SU", ")", ";", "}", "</s>" ]

[ "Functions", "for", "Block", "construction", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "PPCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "const", "DebugLoc", "&", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "16", "0xFFFF" ]

[]

[ "<s>", "void", "HexagonTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SDLoc", "&", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "return", ";", "case", "ISD", "::", "BITCAST", ":", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i8", ")", "{", "SDValue", "P", "=", "getNode", "(", "Hexagon", "::", "C2_tfrpr", ",", "dl", ",", "MVT", "::", "i32", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "P", ")", ";", "}", "break", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::SRL", "ISD::SRA", "ISD::SHL", "ISD::BITCAST", "0", "MVT::i8", "Hexagon::C2_tfrpr", "MVT::i32", "0" ]

[]

[ "<s>", "bool", "MCS51AsmParser", "::", "emit", "(", "MCInst", "&", "Inst", ",", "SMLoc", "const", "&", "Loc", ",", "MCStreamer", "&", "Out", ")", "const", "{", "Inst", ".", "setLoc", "(", "Loc", ")", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Output", "the", "remark", "via", "the", "diagnostic", "handler", "and", "to", "the", "optimization", "record", "file", "." ]

[ "MCS51", "MCS51" ]

[]

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

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

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

[]

[ "<s>", "bool", "OR1KFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "CSKY" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "LW", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FLW", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::LW", "RISCV::FPR32RegClass", "RISCV::FLW", "\"Can't load this register from stack slot\"", "0" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "}", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "useConstIslands", "(", ")", ")", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createARMNaClRewritePass", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "aarch64_test_loading_full_dump", "(", ")", "{", "rtl_dump_test", "t", "(", "SELFTEST_LOCATION", ",", "locate_file", "(", "\"aarch64/times-two.rtl\"", ")", ")", ";", "ASSERT_STREQ", "(", "\"times_two\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "cfun", "->", "decl", ")", ")", ")", ";", "rtx_insn", "*", "insn_1", "=", "get_insn_by_uid", "(", "1", ")", ";", "ASSERT_EQ", "(", "NOTE", ",", "GET_CODE", "(", "insn_1", ")", ")", ";", "rtx_insn", "*", "insn_15", "=", "get_insn_by_uid", "(", "15", ")", ";", "ASSERT_EQ", "(", "INSN", ",", "GET_CODE", "(", "insn_15", ")", ")", ";", "ASSERT_EQ", "(", "USE", ",", "GET_CODE", "(", "PATTERN", "(", "insn_15", ")", ")", ")", ";", "ASSERT_EQ", "(", "REG", ",", "GET_CODE", "(", "crtl", "->", "return_rtx", ")", ")", ";", "ASSERT_EQ", "(", "0", ",", "REGNO", "(", "crtl", "->", "return_rtx", ")", ")", ";", "ASSERT_EQ", "(", "SImode", ",", "GET_MODE", "(", "crtl", "->", "return_rtx", ")", ")", ";", "}", "</s>" ]

[ "Selftest", "for", "the", "RTL", "loader", ".", "Verify", "that", "the", "RTL", "loader", "copes", "with", "a", "dump", "from", "print_rtx_function", ".", "This", "is", "essentially", "just", "a", "test", "that", "class", "function_reader", "can", "handle", "a", "real", "dump", ",", "but", "it", "also", "verifies", "that", "lookup_reg_by_dump_name", "correctly", "handles", "hard", "regs", ".", "The", "presence", "of", "hard", "reg", "names", "in", "the", "dump", "means", "that", "the", "test", "is", "target-specific", ",", "hence", "it", "is", "in", "this", "file", "." ]

[ "aarch64", "\"aarch64/times-two.rtl\"", "\"times_two\"", "1", "15", "0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createX86FloatingPointStackifierPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "X86TargetLowering", "::", "LowerXConstraint", "(", "EVT", "ConstraintVT", ")", "const", "{", "if", "(", "ConstraintVT", ".", "isFloatingPoint", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasXMMInt", "(", ")", ")", "return", "\"Y\"", ";", "if", "(", "Subtarget", "->", "hasXMM", "(", ")", ")", "return", "\"x\"", ";", "}", "return", "TargetLowering", "::", "LowerXConstraint", "(", "ConstraintVT", ")", ";", "}", "</s>" ]

[ "Try", "to", "replace", "an", "X", "constraint", ",", "which", "matches", "anything", ",", "with", "another", "that", "has", "more", "specific", "requirements", "based", "on", "the", "type", "of", "the", "corresponding", "operand", "." ]

[ "X86", "X86", "\"Y\"", "\"x\"" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "override", "{", "return", "End", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "AVR" ]

[]

[ "<s>", "static", "bool", "riscv_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "return", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "get_attr_cannot_copy", "(", "insn", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_COPY_INSN_P", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createAMDGPUCFGStructurizerPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createR600ExpandSpecialInstrsPass", "(", "*", "TM", ")", ",", "false", ")", ";", "addPass", "(", "&", "FinalizeMachineBundlesID", ",", "false", ")", ";", "addPass", "(", "createR600Packetizer", "(", "*", "TM", ")", ",", "false", ")", ";", "addPass", "(", "createR600ControlFlowFinalizer", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "else", "{", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "TailCall", ":", "return", "\"MipsISD::TailCall\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "ThreadPointer", ":", "return", "\"MipsISD::ThreadPointer\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "\"MipsISD::CMovFP_T\"", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "return", "\"MipsISD::CMovFP_F\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "case", "MipsISD", "::", "MAdd", ":", "return", "\"MipsISD::MAdd\"", ";", "case", "MipsISD", "::", "MAddu", ":", "return", "\"MipsISD::MAddu\"", ";", "case", "MipsISD", "::", "MSub", ":", "return", "\"MipsISD::MSub\"", ";", "case", "MipsISD", "::", "MSubu", ":", "return", "\"MipsISD::MSubu\"", ";", "case", "MipsISD", "::", "DivRem", ":", "return", "\"MipsISD::DivRem\"", ";", "case", "MipsISD", "::", "DivRemU", ":", "return", "\"MipsISD::DivRemU\"", ";", "case", "MipsISD", "::", "BuildPairF64", ":", "return", "\"MipsISD::BuildPairF64\"", ";", "case", "MipsISD", "::", "ExtractElementF64", ":", "return", "\"MipsISD::ExtractElementF64\"", ";", "case", "MipsISD", "::", "Wrapper", ":", "return", "\"MipsISD::Wrapper\"", ";", "case", "MipsISD", "::", "DynAlloc", ":", "return", "\"MipsISD::DynAlloc\"", ";", "case", "MipsISD", "::", "Sync", ":", "return", "\"MipsISD::Sync\"", ";", "case", "MipsISD", "::", "Ext", ":", "return", "\"MipsISD::Ext\"", ";", "case", "MipsISD", "::", "Ins", ":", "return", "\"MipsISD::Ins\"", ";", "case", "MipsISD", "::", "LWL", ":", "return", "\"MipsISD::LWL\"", ";", "case", "MipsISD", "::", "LWR", ":", "return", "\"MipsISD::LWR\"", ";", "case", "MipsISD", "::", "SWL", ":", "return", "\"MipsISD::SWL\"", ";", "case", "MipsISD", "::", "SWR", ":", "return", "\"MipsISD::SWR\"", ";", "case", "MipsISD", "::", "LDL", ":", "return", "\"MipsISD::LDL\"", ";", "case", "MipsISD", "::", "LDR", ":", "return", "\"MipsISD::LDR\"", ";", "case", "MipsISD", "::", "SDL", ":", "return", "\"MipsISD::SDL\"", ";", "case", "MipsISD", "::", "SDR", ":", "return", "\"MipsISD::SDR\"", ";", "case", "MipsISD", "::", "EXTP", ":", "return", "\"MipsISD::EXTP\"", ";", "case", "MipsISD", "::", "EXTPDP", ":", "return", "\"MipsISD::EXTPDP\"", ";", "case", "MipsISD", "::", "EXTR_S_H", ":", "return", "\"MipsISD::EXTR_S_H\"", ";", "case", "MipsISD", "::", "EXTR_W", ":", "return", "\"MipsISD::EXTR_W\"", ";", "case", "MipsISD", "::", "EXTR_R_W", ":", "return", "\"MipsISD::EXTR_R_W\"", ";", "case", "MipsISD", "::", "EXTR_RS_W", ":", "return", "\"MipsISD::EXTR_RS_W\"", ";", "case", "MipsISD", "::", "SHILO", ":", "return", "\"MipsISD::SHILO\"", ";", "case", "MipsISD", "::", "MTHLIP", ":", "return", "\"MipsISD::MTHLIP\"", ";", "case", "MipsISD", "::", "MULT", ":", "return", "\"MipsISD::MULT\"", ";", "case", "MipsISD", "::", "MULTU", ":", "return", "\"MipsISD::MULTU\"", ";", "case", "MipsISD", "::", "MADD_DSP", ":", "return", "\"MipsISD::MADD_DSPDSP\"", ";", "case", "MipsISD", "::", "MADDU_DSP", ":", "return", "\"MipsISD::MADDU_DSP\"", ";", "case", "MipsISD", "::", "MSUB_DSP", ":", "return", "\"MipsISD::MSUB_DSP\"", ";", "case", "MipsISD", "::", "MSUBU_DSP", ":", "return", "\"MipsISD::MSUBU_DSP\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::TailCall", "\"MipsISD::TailCall\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::ThreadPointer", "\"MipsISD::ThreadPointer\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::CMovFP_T", "\"MipsISD::CMovFP_T\"", "MipsISD::CMovFP_F", "\"MipsISD::CMovFP_F\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"", "MipsISD::MAdd", "\"MipsISD::MAdd\"", "MipsISD::MAddu", "\"MipsISD::MAddu\"", "MipsISD::MSub", "\"MipsISD::MSub\"", "MipsISD::MSubu", "\"MipsISD::MSubu\"", "MipsISD::DivRem", "\"MipsISD::DivRem\"", "MipsISD::DivRemU", "\"MipsISD::DivRemU\"", "MipsISD::BuildPairF64", "\"MipsISD::BuildPairF64\"", "MipsISD::ExtractElementF64", "\"MipsISD::ExtractElementF64\"", "MipsISD::Wrapper", "\"MipsISD::Wrapper\"", "MipsISD::DynAlloc", "\"MipsISD::DynAlloc\"", "MipsISD::Sync", "\"MipsISD::Sync\"", "MipsISD::Ext", "\"MipsISD::Ext\"", "MipsISD::Ins", "\"MipsISD::Ins\"", "MipsISD::LWL", "\"MipsISD::LWL\"", "MipsISD::LWR", "\"MipsISD::LWR\"", "MipsISD::SWL", "\"MipsISD::SWL\"", "MipsISD::SWR", "\"MipsISD::SWR\"", "MipsISD::LDL", "\"MipsISD::LDL\"", "MipsISD::LDR", "\"MipsISD::LDR\"", "MipsISD::SDL", "\"MipsISD::SDL\"", "MipsISD::SDR", "\"MipsISD::SDR\"", "MipsISD::EXTP", "\"MipsISD::EXTP\"", "MipsISD::EXTPDP", "\"MipsISD::EXTPDP\"", "MipsISD::EXTR_S_H", "\"MipsISD::EXTR_S_H\"", "MipsISD::EXTR_W", "\"MipsISD::EXTR_W\"", "MipsISD::EXTR_R_W", "\"MipsISD::EXTR_R_W\"", "MipsISD::EXTR_RS_W", "\"MipsISD::EXTR_RS_W\"", "MipsISD::SHILO", "\"MipsISD::SHILO\"", "MipsISD::MTHLIP", "\"MipsISD::MTHLIP\"", "MipsISD::MULT", "\"MipsISD::MULT\"", "MipsISD::MULTU", "\"MipsISD::MULTU\"", "MipsISD::MADD_DSP", "\"MipsISD::MADD_DSPDSP\"", "MipsISD::MADDU_DSP", "\"MipsISD::MADDU_DSP\"", "MipsISD::MSUB_DSP", "\"MipsISD::MSUB_DSP\"", "MipsISD::MSUBU_DSP", "\"MipsISD::MSUBU_DSP\"" ]

[]

[ "<s>", "void", "Cpu0TargetObjectFile", "::", "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", "Cpu0TargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "TeakInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "{", "printInstruction", "(", "MI", ",", "Address", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "static", "unsigned", "int", "ix86_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "XFmode", ")", "return", "TARGET_64BIT", "?", "2", ":", "3", ";", "if", "(", "mode", "==", "XCmode", ")", "return", "TARGET_64BIT", "?", "4", ":", "6", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "return", "2", ";", "if", "(", "mode", "==", "V64SFmode", "||", "mode", "==", "V64SImode", ")", "return", "4", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", ".", "This", "is", "ordinarily", "the", "length", "in", "words", "of", "a", "value", "of", "mode", "MODE", "but", "can", "be", "less", "for", "certain", "modes", "in", "special", "long", "registers", ".", "Actually", "there", "are", "no", "two", "word", "move", "instructions", "for", "consecutive", "registers", ".", "And", "only", "registers", "0-3", "may", "have", "mov", "byte", "instructions", "applied", "to", "them", "." ]

[ "i386", "2", "3", "4", "6", "2", "4", "1" ]

[]

[ "<s>", "void", "AMDGPURegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "MachineInstr", "&", "MI", "=", "OpdMapper", ".", "getMI", "(", ")", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "OpdMapper", ".", "getMRI", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "AMDGPU", "::", "G_AND", ":", "case", "AMDGPU", "::", "G_OR", ":", "case", "AMDGPU", "::", "G_XOR", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getType", "(", "DstReg", ")", ".", "getSizeInBits", "(", ")", "!=", "64", ")", "break", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "DefRegs", "(", "OpdMapper", ".", "getVRegs", "(", "0", ")", ")", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "Src0Regs", "(", "OpdMapper", ".", "getVRegs", "(", "1", ")", ")", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "Src1Regs", "(", "OpdMapper", ".", "getVRegs", "(", "2", ")", ")", ";", "if", "(", "DefRegs", ".", "empty", "(", ")", ")", "{", "assert", "(", "Src0Regs", ".", "empty", "(", ")", "&&", "Src1Regs", ".", "empty", "(", ")", ")", ";", "break", ";", "}", "assert", "(", "DefRegs", ".", "size", "(", ")", "==", "2", ")", ";", "assert", "(", "Src0Regs", ".", "size", "(", ")", "==", "Src1Regs", ".", "size", "(", ")", "&&", "(", "Src0Regs", ".", "empty", "(", ")", "||", "Src0Regs", ".", "size", "(", ")", "==", "2", ")", ")", ";", "MachineIRBuilder", "B", "(", "MI", ")", ";", "if", "(", "Src0Regs", ".", "empty", "(", ")", ")", "split64BitValueForMapping", "(", "B", ",", "Src0Regs", ",", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "Src1Regs", ".", "empty", "(", ")", ")", "split64BitValueForMapping", "(", "B", ",", "Src1Regs", ",", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "B", ".", "buildInstr", "(", "Opc", ")", ".", "addDef", "(", "DefRegs", "[", "0", "]", ")", ".", "addUse", "(", "Src0Regs", "[", "0", "]", ")", ".", "addUse", "(", "Src1Regs", "[", "0", "]", ")", ";", "B", ".", "buildInstr", "(", "Opc", ")", ".", "addDef", "(", "DefRegs", "[", "1", "]", ")", ".", "addUse", "(", "Src0Regs", "[", "1", "]", ")", ".", "addUse", "(", "Src1Regs", "[", "1", "]", ")", ";", "MRI", ".", "setRegBank", "(", "DstReg", ",", "getRegBank", "(", "AMDGPU", "::", "VGPRRegBankID", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::G_AND", "AMDGPU::G_OR", "AMDGPU::G_XOR", "0", "64", "2", "0", "2", "1", "2", "2", "2", "2", "1", "2", "0", "0", "0", "1", "1", "1", "AMDGPU::VGPRRegBankID" ]

[]

[ "<s>", "static", "section", "*", "pa_elf_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "function_label_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "if", "(", "!", "decl", "||", "(", "DECL_P", "(", "decl", ")", "&&", "DECL_COMDAT_GROUP", "(", "decl", ")", ")", ")", "return", "get_named_section", "(", "NULL", ",", "\".data.rel.ro.local\"", ",", "1", ")", ";", "}", "return", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>" ]

[ "Implement", "pa_elf_select_rtx_section", ".", "If", "X", "is", "a", "function", "label", "operand", "and", "the", "function", "is", "in", "a", "COMDAT", "group", ",", "place", "the", "plabel", "reference", "in", "the", ".data.rel.ro.local", "section", ".", "The", "linker", "ignores", "references", "to", "symbols", "in", "discarded", "sections", "from", "this", "section", "." ]

[ "pa", "\".data.rel.ro.local\"", "1" ]

[]

[ "<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "LLVM_OVERRIDE", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "SystemZ", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "arc_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "8", ")", ";", "}", "}", "</s>" ]

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

[ "arc", "1", "8" ]

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "isResourceAvailable", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "!", "SU", "||", "!", "SU", "->", "getInstr", "(", ")", ")", "return", "false", ";", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "!", "ResourcesModel", "->", "canReserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ")", "return", "false", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "*", "SU", "->", "getInstr", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "&", "QII", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "Packet", "[", "i", "]", "->", "Succs", ".", "size", "(", ")", "==", "0", ")", "continue", ";", "if", "(", "QII", ".", "mayBeCurLoad", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", ")", ")", "continue", ";", "for", "(", "SUnit", "::", "const_succ_iterator", "I", "=", "Packet", "[", "i", "]", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "Packet", "[", "i", "]", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCtrl", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getSUnit", "(", ")", "==", "SU", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "scheduling", "of", "this", "SU", "is", "possible", "in", "the", "current", "packet", "." ]

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "(", "MIa", ".", "mayLoad", "(", ")", "||", "MIa", ".", "mayStore", "(", ")", ")", "&&", "\"MIa must load from or modify a memory location\"", ")", ";", "assert", "(", "(", "MIb", ".", "mayLoad", "(", ")", "||", "MIb", ".", "mayStore", "(", ")", ")", "&&", "\"MIb must load from or modify a memory location\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "isDS", "(", "MIa", ")", ")", "{", "if", "(", "isDS", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", ";", "}", "if", "(", "isMUBUF", "(", "MIa", ")", "||", "isMTBUF", "(", "MIa", ")", ")", "{", "if", "(", "isMUBUF", "(", "MIb", ")", "||", "isMTBUF", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isSMRD", "(", "MIb", ")", ";", "}", "if", "(", "isSMRD", "(", "MIa", ")", ")", "{", "if", "(", "isSMRD", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isMUBUF", "(", "MIa", ")", "&&", "!", "isMTBUF", "(", "MIa", ")", ";", "}", "if", "(", "isFLAT", "(", "MIa", ")", ")", "{", "if", "(", "isFLAT", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AMDGPU", "SI", "\"MIa must load from or modify a memory location\"", "\"MIb must load from or modify a memory location\"" ]

[]

[ "<s>", "virtual", "const", "OR1KRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "const", "char", "*", "ARMTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "ARMISD", "::", "Wrapper", ":", "return", "\"ARMISD::Wrapper\"", ";", "case", "ARMISD", "::", "WrapperJT", ":", "return", "\"ARMISD::WrapperJT\"", ";", "case", "ARMISD", "::", "CALL", ":", "return", "\"ARMISD::CALL\"", ";", "case", "ARMISD", "::", "CALL_PRED", ":", "return", "\"ARMISD::CALL_PRED\"", ";", "case", "ARMISD", "::", "CALL_NOLINK", ":", "return", "\"ARMISD::CALL_NOLINK\"", ";", "case", "ARMISD", "::", "tCALL", ":", "return", "\"ARMISD::tCALL\"", ";", "case", "ARMISD", "::", "BRCOND", ":", "return", "\"ARMISD::BRCOND\"", ";", "case", "ARMISD", "::", "BR_JT", ":", "return", "\"ARMISD::BR_JT\"", ";", "case", "ARMISD", "::", "RET_FLAG", ":", "return", "\"ARMISD::RET_FLAG\"", ";", "case", "ARMISD", "::", "PIC_ADD", ":", "return", "\"ARMISD::PIC_ADD\"", ";", "case", "ARMISD", "::", "CMP", ":", "return", "\"ARMISD::CMP\"", ";", "case", "ARMISD", "::", "CMPNZ", ":", "return", "\"ARMISD::CMPNZ\"", ";", "case", "ARMISD", "::", "CMPFP", ":", "return", "\"ARMISD::CMPFP\"", ";", "case", "ARMISD", "::", "CMPFPw0", ":", "return", "\"ARMISD::CMPFPw0\"", ";", "case", "ARMISD", "::", "FMSTAT", ":", "return", "\"ARMISD::FMSTAT\"", ";", "case", "ARMISD", "::", "CMOV", ":", "return", "\"ARMISD::CMOV\"", ";", "case", "ARMISD", "::", "CNEG", ":", "return", "\"ARMISD::CNEG\"", ";", "case", "ARMISD", "::", "FTOSI", ":", "return", "\"ARMISD::FTOSI\"", ";", "case", "ARMISD", "::", "FTOUI", ":", "return", "\"ARMISD::FTOUI\"", ";", "case", "ARMISD", "::", "SITOF", ":", "return", "\"ARMISD::SITOF\"", ";", "case", "ARMISD", "::", "UITOF", ":", "return", "\"ARMISD::UITOF\"", ";", "case", "ARMISD", "::", "SRL_FLAG", ":", "return", "\"ARMISD::SRL_FLAG\"", ";", "case", "ARMISD", "::", "SRA_FLAG", ":", "return", "\"ARMISD::SRA_FLAG\"", ";", "case", "ARMISD", "::", "RRX", ":", "return", "\"ARMISD::RRX\"", ";", "case", "ARMISD", "::", "FMRRD", ":", "return", "\"ARMISD::FMRRD\"", ";", "case", "ARMISD", "::", "FMDRR", ":", "return", "\"ARMISD::FMDRR\"", ";", "case", "ARMISD", "::", "THREAD_POINTER", ":", "return", "\"ARMISD::THREAD_POINTER\"", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "ARMISD::Wrapper", "\"ARMISD::Wrapper\"", "ARMISD::WrapperJT", "\"ARMISD::WrapperJT\"", "ARMISD::CALL", "\"ARMISD::CALL\"", "ARMISD::CALL_PRED", "\"ARMISD::CALL_PRED\"", "ARMISD::CALL_NOLINK", "\"ARMISD::CALL_NOLINK\"", "ARMISD::tCALL", "\"ARMISD::tCALL\"", "ARMISD::BRCOND", "\"ARMISD::BRCOND\"", "ARMISD::BR_JT", "\"ARMISD::BR_JT\"", "ARMISD::RET_FLAG", "\"ARMISD::RET_FLAG\"", "ARMISD::PIC_ADD", "\"ARMISD::PIC_ADD\"", "ARMISD::CMP", "\"ARMISD::CMP\"", "ARMISD::CMPNZ", "\"ARMISD::CMPNZ\"", "ARMISD::CMPFP", "\"ARMISD::CMPFP\"", "ARMISD::CMPFPw0", "\"ARMISD::CMPFPw0\"", "ARMISD::FMSTAT", "\"ARMISD::FMSTAT\"", "ARMISD::CMOV", "\"ARMISD::CMOV\"", "ARMISD::CNEG", "\"ARMISD::CNEG\"", "ARMISD::FTOSI", "\"ARMISD::FTOSI\"", "ARMISD::FTOUI", "\"ARMISD::FTOUI\"", "ARMISD::SITOF", "\"ARMISD::SITOF\"", "ARMISD::UITOF", "\"ARMISD::UITOF\"", "ARMISD::SRL_FLAG", "\"ARMISD::SRL_FLAG\"", "ARMISD::SRA_FLAG", "\"ARMISD::SRA_FLAG\"", "ARMISD::RRX", "\"ARMISD::RRX\"", "ARMISD::FMRRD", "\"ARMISD::FMRRD\"", "ARMISD::FMDRR", "\"ARMISD::FMDRR\"", "ARMISD::THREAD_POINTER", "\"ARMISD::THREAD_POINTER\"" ]

[]

[ "<s>", "TargetIRAnalysis", "SystemZTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "SystemZTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AMDGPUOperand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "const", "MCRegisterInfo", "*", "TRI", ",", "const", "MCSubtargetInfo", "*", "STI", ",", "bool", "ForceVOP3", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "TRI", "=", "TRI", ";", "Op", "->", "Reg", ".", "STI", "=", "STI", ";", "Op", "->", "Reg", ".", "Modifiers", "=", "-", "1", ";", "Op", "->", "Reg", ".", "IsForcedVOP3", "=", "ForceVOP3", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "1" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "Sparc" ]

[]

[ "<s>", "void", "ix86_emit_i387_log1p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx_code_label", "*", "label1", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "label2", "=", "gen_label_rtx", "(", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "res", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "cst", ",", "cstln2", ",", "cst1", ";", "rtx_insn", "*", "insn", ";", "do_pending_stack_adjust", "(", ")", ";", "cst", "=", "const_double_from_real_value", "(", "REAL_VALUE_ATOF", "(", "\"0.29289321881345247561810596348408353\"", ",", "XFmode", ")", ",", "XFmode", ")", ";", "cstln2", "=", "force_reg", "(", "XFmode", ",", "standard_80387_constant_rtx", "(", "4", ")", ")", ";", "emit_insn", "(", "gen_absxf2", "(", "tmp", ",", "op1", ")", ")", ";", "cst", "=", "force_reg", "(", "XFmode", ",", "cst", ")", ";", "ix86_expand_branch", "(", "GE", ",", "tmp", ",", "cst", ",", "label1", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "10", "/", "100", ")", ";", "insn", "=", "get_last_insn", "(", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "label1", ";", "emit_insn", "(", "gen_fyl2xp1xf3_i387", "(", "res", ",", "op1", ",", "cstln2", ")", ")", ";", "emit_jump", "(", "label2", ")", ";", "emit_label", "(", "label1", ")", ";", "LABEL_NUSES", "(", "label1", ")", "=", "1", ";", "cst1", "=", "force_reg", "(", "XFmode", ",", "CONST1_RTX", "(", "XFmode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_PLUS", "(", "XFmode", ",", "op1", ",", "cst1", ")", ")", ")", ";", "emit_insn", "(", "gen_fyl2xxf3_i387", "(", "res", ",", "tmp", ",", "cstln2", ")", ")", ";", "emit_label", "(", "label2", ")", ";", "LABEL_NUSES", "(", "label2", ")", "=", "1", ";", "emit_move_insn", "(", "op0", ",", "res", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "log1p", "XFmode", "calculation", "." ]

[ "i386", "\"0.29289321881345247561810596348408353\"", "4", "10", "100", "1", "1" ]

[]

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

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

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

[]

[ "<s>", "void", "AArch64TargetStreamer", "::", "emitInst", "(", "uint32_t", "Inst", ")", "{", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "int", "stackSlotSize", "(", ")", "{", "return", "4", ";", "}", "</s>" ]

[ "Stack", "slot", "size", "(", "4", "bytes", ")" ]

[ "LC3", "4" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MI", ";", "while", "(", "++", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isDebugInstr", "(", ")", ")", ";", "if", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isCall", "(", ")", "&&", "MI", ".", "definesRegister", "(", "ARM", "::", "SP", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "ARM", "ARM", "ARM::t2IT", "ARM::SP" ]

[]

[ "<s>", "const", "SICInstrInfo", "*", "SICInstrInfo", "::", "create", "(", "SICSubtarget", "&", "STI", ")", "{", "return", "new", "SICInstrInfo", "(", "STI", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "AttributeSet", "FnAttrs", "=", "F", ".", "getAttributes", "(", ")", ";", "Attribute", "CPUAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "FnAttrs", ".", "getAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "AArch64" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "M88kMCAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "static", "const", "MCFixupKindInfo", "Infos", "[", "M88k", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FK_88K_NONE\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"FK_88K_DISP16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FK_88K_DISP26\"", ",", "6", ",", "26", ",", "0", "}", ",", "{", "\"FK_88K_HI\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"FK_88K_LO\"", ",", "16", ",", "16", ",", "0", "}", "}", ";", "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", "." ]

[ "M88k", "M88k", "M88k::NumTargetFixupKinds", "\"FK_88K_NONE\"", "0", "32", "0", "\"FK_88K_DISP16\"", "16", "16", "0", "\"FK_88K_DISP26\"", "6", "26", "0", "\"FK_88K_HI\"", "16", "16", "0", "\"FK_88K_LO\"", "16", "16", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "bool", "arc_lra_p", "(", "void", ")", "{", "return", "!", "TARGET_NO_LRA", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "." ]

[ "arc" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "*", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8rm", ":", "case", "X86", "::", "MOV16rm", ":", "case", "X86", "::", "MOV32rm", ":", "case", "X86", "::", "MOV64rm", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "MOVSSrm", ":", "case", "X86", "::", "MOVSDrm", ":", "case", "X86", "::", "MOVAPSrm", ":", "case", "X86", "::", "MOVUPSrm", ":", "case", "X86", "::", "MOVAPDrm", ":", "case", "X86", "::", "MOVDQArm", ":", "case", "X86", "::", "VMOVSSrm", ":", "case", "X86", "::", "VMOVSDrm", ":", "case", "X86", "::", "VMOVAPSrm", ":", "case", "X86", "::", "VMOVUPSrm", ":", "case", "X86", "::", "VMOVAPDrm", ":", "case", "X86", "::", "VMOVDQArm", ":", "case", "X86", "::", "VMOVAPSYrm", ":", "case", "X86", "::", "VMOVUPSYrm", ":", "case", "X86", "::", "VMOVAPDYrm", ":", "case", "X86", "::", "VMOVDQAYrm", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "case", "X86", "::", "FsVMOVAPSrm", ":", "case", "X86", "::", "FsVMOVAPDrm", ":", "case", "X86", "::", "FsMOVAPSrm", ":", "case", "X86", "::", "FsMOVAPDrm", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "isInvariantLoad", "(", "AA", ")", ")", "{", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", "||", "BaseReg", "==", "X86", "::", "RIP", ")", "return", "true", ";", "if", "(", "!", "ReMatPICStubLoad", "&&", "MI", "->", "getOperand", "(", "4", ")", ".", "isGlobal", "(", ")", ")", "return", "false", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "LEA32r", ":", "case", "X86", "::", "LEA64r", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "0", "&&", "!", "MI", "->", "getOperand", "(", "4", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "0", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";", "}", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::MOV8rm", "X86::MOV16rm", "X86::MOV32rm", "X86::MOV64rm", "X86::LD_Fp64m", "X86::MOVSSrm", "X86::MOVSDrm", "X86::MOVAPSrm", "X86::MOVUPSrm", "X86::MOVAPDrm", "X86::MOVDQArm", "X86::VMOVSSrm", "X86::VMOVSDrm", "X86::VMOVAPSrm", "X86::VMOVUPSrm", "X86::VMOVAPDrm", "X86::VMOVDQArm", "X86::VMOVAPSYrm", "X86::VMOVUPSYrm", "X86::VMOVAPDYrm", "X86::VMOVDQAYrm", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "X86::FsVMOVAPSrm", "X86::FsVMOVAPDrm", "X86::FsMOVAPSrm", "X86::FsMOVAPDrm", "1", "2", "3", "3", "0", "1", "0", "X86::RIP", "4", "X86::LEA32r", "X86::LEA64r", "2", "3", "3", "0", "4", "1", "1", "0" ]

[]

[ "<s>", "virtual", "const", "MandarinRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "Mandarin" ]

[]

[ "<s>", "bool", "cris_valid_pic_const", "(", "const_rtx", "x", ",", "bool", "any_operand", ")", "{", "gcc_assert", "(", "flag_pic", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "true", ";", "default", ":", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", "==", "CRIS_UNSPEC_GOTREL", "||", "XINT", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", "==", "CRIS_UNSPEC_PCREL", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "CRIS_UNSPEC_PLT_PCREL", ":", "case", "CRIS_UNSPEC_PCREL", ":", "return", "!", "any_operand", ";", "case", "CRIS_UNSPEC_PLT_GOTREL", ":", "case", "CRIS_UNSPEC_PLTGOTREAD", ":", "case", "CRIS_UNSPEC_GOTREAD", ":", "case", "CRIS_UNSPEC_GOTREL", ":", "return", "true", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "cris_symbol_type_of", "(", "x", ")", "==", "cris_no_symbol", ";", "}", "</s>" ]

[ "Return", "TRUE", "iff", "X", "is", "a", "CONST", "valid", "for", "e.g", ".", "indexing", "." ]

[ "cris", "0", "0", "0", "1", "0", "1", "1", "0", "1" ]

[]

[ "<s>", "static", "unsigned", "addLiveIn", "(", "MachineFunction", "&", "MF", ",", "unsigned", "PReg", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "unsigned", "VReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "PReg", ",", "VReg", ")", ";", "return", "VReg", ";", "}", "</s>" ]

[ "addLiveIn", "-", "Add", "the", "specified", "register", "as", "a", "live-in", "." ]

[ "Mips" ]

[]

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

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

[ "VE", "VE", "VE" ]

[]

[ "<s>", "unsigned", "int", "vectors_per_tuple", "(", ")", "const", "override", "{", "return", "m_vectors_per_tuple", ";", "}", "</s>" ]

[ "If", "the", "function", "operates", "on", "tuples", "of", "vectors", ",", "return", "the", "number", "of", "vectors", "in", "the", "tuples", ",", "otherwise", "return", "1", "." ]

[ "aarch64" ]

[]

[ "<s>", "ISD", "::", "NodeType", "getExtendForAtomicOps", "(", ")", "const", "override", "{", "return", "ISD", "::", "ANY_EXTEND", ";", "}", "</s>" ]

[ "Returns", "how", "the", "platform", "'s", "atomic", "operations", "are", "extended", "(", "ZERO_EXTEND", ",", "SIGN_EXTEND", ",", "or", "ANY_EXTEND", ")", "." ]

[ "VE", "ISD::NodeType", "ISD::ANY_EXTEND" ]

[]

[ "<s>", "const", "LM32InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "LM32", "LM32" ]

[]

[ "<s>", "EVT", "RISCVTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "getConst", "(", "const", "BitTracker", "::", "RegisterCell", "&", "RC", ",", "uint16_t", "B", ",", "uint16_t", "W", ",", "uint64_t", "&", "U", ")", "{", "assert", "(", "B", "<", "RC", ".", "width", "(", ")", "&&", "B", "+", "W", "<=", "RC", ".", "width", "(", ")", ")", ";", "int64_t", "T", "=", "0", ";", "for", "(", "uint16_t", "i", "=", "B", "+", "W", ";", "i", ">", "B", ";", "--", "i", ")", "{", "const", "BitTracker", "::", "BitValue", "&", "BV", "=", "RC", "[", "i", "-", "1", "]", ";", "T", "<<=", "1", ";", "if", "(", "BV", ".", "is", "(", "1", ")", ")", "T", "|=", "1", ";", "else", "if", "(", "!", "BV", ".", "is", "(", "0", ")", ")", "return", "false", ";", "}", "U", "=", "T", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "the", "Value", "*", "for", "a", "constant", "." ]

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

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "const", "MipsCC", "&", "MipsCCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "MipsFunctionInfo", "&", "FI", ")", "const", "{", "if", "(", "!", "EnableMipsTailCalls", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "if", "(", "MipsCCInfo", ".", "hasByValArg", "(", ")", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "nextStackOffset", "(", ")", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

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

[]

[ "<s>", "bool", "X86AsmBackend", "::", "allowEnhancedRelaxation", "(", ")", "const", "{", "return", "allowAutoPadding", "(", ")", "&&", "TargetPrefixMax", "!=", "0", "&&", "X86PadForBranchAlign", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "target", "allows", "an", "unrelaxable", "instruction", "to", "be", "emitted", "into", "RelaxableFragment", "and", "then", "we", "can", "increase", "its", "size", "in", "a", "tricky", "way", "for", "optimization", "." ]

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

[]

[ "<s>", "ShapeKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "aarch64_return_address_signing_enabled", "(", "void", ")", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "frame", ".", "laid_out", ")", ";", "return", "(", "aarch64_ra_sign_scope", "==", "AARCH64_FUNCTION_ALL", "||", "(", "aarch64_ra_sign_scope", "==", "AARCH64_FUNCTION_NON_LEAF", "&&", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "LR_REGNUM", "]", ">=", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "return", "address", "signing", "should", "be", "enabled", "for", "the", "current", "function", ",", "otherwise", "return", "FALSE", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "isUnconditionalBranch", "(", "MCInst", "const", "&", "Inst", ")", "const", "override", "{", "return", "MCInstrAnalysis", "::", "isUnconditionalBranch", "(", "Inst", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "branch", "which", "always", "transfers", "control", "flow", "to", "some", "other", "block", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "tree", "aarch64_builtin_reciprocal", "(", "tree", "fndecl", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "if", "(", "!", "use_rsqrt_p", "(", "mode", ")", ")", "return", "NULL_TREE", ";", "return", "aarch64_builtin_rsqrt", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "decide", "when", "to", "use", "the", "approximate", "reciprocal", "square", "root", "builtin", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "s390_can_use_return_insn", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "reload_completed", ")", "return", "false", ";", "if", "(", "crtl", "->", "profile", ")", "return", "false", ";", "if", "(", "TARGET_TPF_PROFILING", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "cfun_gpr_save_slot", "(", "i", ")", ")", "return", "false", ";", "if", "(", "!", "TARGET_64BIT", "&&", "(", "cfun_fpr_save_p", "(", "FPR4_REGNUM", ")", "||", "cfun_fpr_save_p", "(", "FPR6_REGNUM", ")", ")", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "base_reg", "&&", "!", "call_really_used_regs", "[", "REGNO", "(", "cfun", "->", "machine", "->", "base_reg", ")", "]", ")", "return", "false", ";", "return", "cfun_frame_layout", ".", "frame_size", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "epilogue", "is", "guaranteed", "to", "contain", "only", "a", "return", "instruction", "and", "if", "a", "direct", "return", "can", "therefore", "be", "used", "instead", ".", "One", "of", "the", "main", "advantages", "of", "using", "direct", "return", "instructions", "is", "that", "we", "can", "then", "use", "conditional", "returns", "." ]

[ "s390", "0", "16", "0" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "ISD::OutputArg", "AMDGPUISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "void", "ix86_emit_binop", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "src", ")", "{", "rtx", "op", ",", "clob", ";", "op", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "dst", ",", "src", ")", ")", ";", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "x86", "binary", "operand", "CODE", "in", "mode", "MODE", ",", "where", "the", "first", "operand", "matches", "destination", ".", "RTX", "includes", "clobber", "of", "FLAGS_REG", "." ]

[ "i386", "2" ]

[]

[ "<s>", "bool", "check", "(", "function_checker", "&", "c", ")", "const", "OVERRIDE", "{", "return", "c", ".", "require_immediate_range", "(", "2", ",", "0", ",", "7", ")", ";", "}", "</s>" ]

[ "Perform", "semantic", "checks", "on", "the", "call", ".", "Return", "true", "if", "the", "call", "is", "valid", ",", "otherwise", "report", "a", "suitable", "error", "." ]

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

[]

[ "<s>", "rtx", "mips_subword_at_byte", "(", "rtx", "op", ",", "unsigned", "int", "byte", ")", "{", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "TImode", ";", "gcc_assert", "(", "!", "FP_REG_RTX_P", "(", "op", ")", ")", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "mips_rewrite_small_data", "(", "adjust_address", "(", "op", ",", "word_mode", ",", "byte", ")", ")", ";", "return", "simplify_gen_subreg", "(", "word_mode", ",", "op", ",", "mode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Return", "one", "word", "of", "128-bit", "value", "OP", ",", "taking", "into", "account", "the", "fixed", "endianness", "of", "certain", "registers", ".", "BYTE", "selects", "from", "the", "byte", "address", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "X86AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "if", "(", "getRelaxedOpcodeBranch", "(", "Inst", ",", "false", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ")", "return", "true", ";", "if", "(", "getRelaxedOpcodeArith", "(", "Inst", ")", "==", "Inst", ".", "getOpcode", "(", ")", ")", "return", "false", ";", "unsigned", "RelaxableOp", "=", "Inst", ".", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "Inst", ".", "getOperand", "(", "RelaxableOp", ")", ".", "isExpr", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

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

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "PTXFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "PTX", "PTX" ]

[]

[ "<s>", "static", "bool", "rs6000_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "else", "if", "(", "TARGET_FLOAT128_TYPE", "&&", "(", "mode", "==", "KFmode", "||", "mode", "==", "IFmode", ")", ")", "return", "true", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "scalar_mode_supported_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "MCSubtargetInfo", "const", "&", "HexagonMCCodeEmitter", "::", "getSubtargetInfo", "(", ")", "const", "{", "return", "MST", ";", "}", "</s>" ]

[ "TargetSubtargetInfo", "getter", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "enum", "arc_function_type", "arc_compute_function_type", "(", "tree", "decl", ")", "{", "tree", "a", ";", "static", "enum", "arc_function_type", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "static", "tree", "last_fn", "=", "NULL_TREE", ";", "if", "(", "decl", "==", "NULL_TREE", ")", "{", "fn_type", "=", "ARC_FUNCTION_UNKNOWN", ";", "last_fn", "=", "NULL_TREE", ";", "return", "fn_type", ";", "}", "if", "(", "decl", "==", "last_fn", "&&", "fn_type", "!=", "ARC_FUNCTION_UNKNOWN", ")", "return", "fn_type", ";", "fn_type", "=", "ARC_FUNCTION_NORMAL", ";", "for", "(", "a", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "a", ";", "a", "=", "TREE_CHAIN", "(", "a", ")", ")", "{", "tree", "name", "=", "TREE_PURPOSE", "(", "a", ")", ",", "args", "=", "TREE_VALUE", "(", "a", ")", ";", "if", "(", "name", "==", "get_identifier", "(", "\"__interrupt__\"", ")", "&&", "list_length", "(", "args", ")", "==", "1", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK1", ";", "else", "if", "(", "!", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "fn_type", "=", "ARC_FUNCTION_ILINK2", ";", "else", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "last_fn", "=", "decl", ";", "return", "fn_type", ";", "}", "</s>" ]

[ "Type", "of", "function", "DECL", ".", "The", "result", "is", "cached", ".", "To", "reset", "the", "cache", "at", "the", "end", "of", "a", "function", ",", "call", "with", "DECL", "=", "NULL_TREE", "." ]

[ "arc", "\"__interrupt__\"", "1", "\"ilink1\"", "\"ilink2\"" ]

[]

[ "<s>", "static", "unsigned", "getHashValue", "(", "const", "CSKYTargetStreamer", "::", "SymbolIndex", "&", "V", ")", "{", "return", "hash_combine", "(", "DenseMapInfo", "<", "const", "MCSymbol", "*", ">", "::", "getHashValue", "(", "V", ".", "sym", ")", ",", "DenseMapInfo", "<", "int", ">", "::", "getHashValue", "(", "V", ".", "kind", ")", ")", ";", "}", "</s>" ]

[ "Using", "name", "and", "line", "to", "get", "hash", "value", ".", "It", "should", "already", "be", "mostly", "unique", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "void", "OrderedRegisterList", "::", "remove", "(", "unsigned", "VR", ")", "{", "iterator", "L", "=", "std", "::", "lower_bound", "(", "Seq", ".", "begin", "(", ")", ",", "Seq", ".", "end", "(", ")", ",", "VR", ",", "Ord", ")", ";", "if", "(", "L", "!=", "Seq", ".", "end", "(", ")", ")", "Seq", ".", "erase", "(", "L", ")", ";", "}", "</s>" ]

[ "remove", "-", "Remove", "the", "specified", "key/value", "pair", "from", "the", "map", ",", "but", "do", "not", "erase", "it", "." ]

[ "Hexagon" ]

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "MMIX" ]

[]

[ "<s>", "Register", "RISCVRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "RISCV", "::", "X8", ":", "RISCV", "::", "X2", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV::X8", "RISCV::X2" ]

[]

[ "<s>", "bool", "AMDGPUInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "{", "if", "(", "I", ".", "isPHI", "(", ")", ")", "return", "selectPHI", "(", "I", ")", ";", "if", "(", "!", "I", ".", "isPreISelOpcode", "(", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCOPY", "(", "I", ")", ";", "return", "true", ";", "}", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_AND", ":", "case", "TargetOpcode", "::", "G_OR", ":", "case", "TargetOpcode", "::", "G_XOR", ":", "if", "(", "selectG_AND_OR_XOR", "(", "I", ")", ")", "return", "true", ";", "return", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "if", "(", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ")", "return", "true", ";", "return", "selectG_ADD_SUB", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_UADDO", ":", "case", "TargetOpcode", "::", "G_USUBO", ":", "case", "TargetOpcode", "::", "G_UADDE", ":", "case", "TargetOpcode", "::", "G_USUBE", ":", "return", "selectG_UADDO_USUBO_UADDE_USUBE", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "case", "TargetOpcode", "::", "G_PTRTOINT", ":", "return", "selectCOPY", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectG_EXTRACT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_MERGE_VALUES", ":", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "case", "TargetOpcode", "::", "G_CONCAT_VECTORS", ":", "return", "selectG_MERGE_VALUES", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "return", "selectG_UNMERGE_VALUES", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_PTR_ADD", ":", "return", "selectG_PTR_ADD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "return", "selectG_IMPLICIT_DEF", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectG_INSERT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC", ":", "return", "selectG_INTRINSIC", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ":", "return", "selectG_INTRINSIC_W_SIDE_EFFECTS", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "if", "(", "selectG_ICMP", "(", "I", ")", ")", "return", "true", ";", "return", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_XCHG", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_ADD", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_SUB", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_AND", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_OR", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_XOR", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_MIN", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_MAX", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_UMIN", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_UMAX", ":", "case", "TargetOpcode", "::", "G_ATOMICRMW_FADD", ":", "return", "selectG_LOAD_ATOMICRMW", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SELECT", ":", "return", "selectG_SELECT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "selectG_STORE", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "selectG_TRUNC", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_SEXT", ":", "case", "TargetOpcode", "::", "G_ZEXT", ":", "case", "TargetOpcode", "::", "G_ANYEXT", ":", "if", "(", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ")", "return", "true", ";", "return", "selectG_SZA_EXT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_BRCOND", ":", "return", "selectG_BRCOND", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_FRAME_INDEX", ":", "return", "selectG_FRAME_INDEX", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_PTR_MASK", ":", "return", "selectG_PTR_MASK", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "selectG_EXTRACT_VECTOR_ELT", "(", "I", ")", ";", "default", ":", "return", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "intersects", "(", "const", "RegisterSet", "&", "Rs", ")", "const", "{", "return", "BitVector", "::", "anyCommon", "(", "Rs", ")", ";", "}", "</s>" ]

[ "Checks", "whether", "intervals", "intersect", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "aarch64_asm_preferred_eh_data_format", "(", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "global", ")", "{", "int", "type", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_SMALL", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "type", "=", "DW_EH_PE_sdata4", ";", "break", ";", "default", ":", "type", "=", "DW_EH_PE_sdata8", ";", "break", ";", "}", "return", "(", "global", "?", "DW_EH_PE_indirect", ":", "0", ")", "|", "DW_EH_PE_pcrel", "|", "type", ";", "}", "</s>" ]

[ "Select", "a", "format", "to", "encode", "pointers", "in", "exception", "handling", "data", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "hasSection", "(", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumb1OnlyFunction", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "find_constant_pool_ref", "(", "rtx", "x", ",", "rtx", "*", "ref", ")", "{", "int", "i", ",", "j", ";", "const", "char", "*", "fmt", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_LTREL_BASE", ")", "return", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPECV_POOL_ENTRY", ")", "return", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_LTREF", ")", "{", "rtx", "sym", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "sym", ")", ")", ";", "if", "(", "*", "ref", "==", "NULL_RTX", ")", "*", "ref", "=", "sym", ";", "else", "gcc_assert", "(", "*", "ref", "==", "sym", ")", ";", "return", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "find_constant_pool_ref", "(", "XEXP", "(", "x", ",", "i", ")", ",", "ref", ")", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "x", ",", "i", ")", ";", "j", "++", ")", "find_constant_pool_ref", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ",", "ref", ")", ";", "}", "}", "}", "</s>" ]

[ "Find", "an", "annotated", "literal", "pool", "symbol", "referenced", "in", "RTX", "X", ",", "and", "store", "it", "at", "REF", ".", "Will", "abort", "if", "X", "contains", "references", "to", "more", "than", "one", "such", "pool", "symbol", ";", "multiple", "references", "to", "the", "same", "symbol", "are", "allowed", ",", "however", ".", "The", "rtx", "pointed", "to", "by", "REF", "must", "be", "initialized", "to", "NULL_RTX", "by", "the", "caller", "before", "calling", "this", "routine", "." ]

[ "s390", "1", "1", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "SystemZRegisterInfo", "::", "getRegAllocationHints", "(", "unsigned", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "BaseImplRetVal", "=", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ",", "Matrix", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "VirtReg", ")", "==", "&", "SystemZ", "::", "GRX32BitRegClass", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "Worklist", ";", "SmallSet", "<", "unsigned", ",", "4", ">", "DoneRegs", ";", "Worklist", ".", "push_back", "(", "VirtReg", ")", ";", "while", "(", "Worklist", ".", "size", "(", ")", ")", "{", "unsigned", "Reg", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "if", "(", "!", "DoneRegs", ".", "insert", "(", "Reg", ")", ".", "second", ")", "continue", ";", "for", "(", "auto", "&", "Use", ":", "MRI", "->", "use_instructions", "(", "Reg", ")", ")", "if", "(", "Use", ".", "getOpcode", "(", ")", "==", "SystemZ", "::", "LOCRMux", ")", "{", "MachineOperand", "&", "TrueMO", "=", "Use", ".", "getOperand", "(", "1", ")", ";", "MachineOperand", "&", "FalseMO", "=", "Use", ".", "getOperand", "(", "2", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getCommonSubClass", "(", "getRC32", "(", "FalseMO", ",", "VRM", ",", "MRI", ")", ",", "getRC32", "(", "TrueMO", ",", "VRM", ",", "MRI", ")", ")", ";", "if", "(", "RC", "&&", "RC", "!=", "&", "SystemZ", "::", "GRX32BitRegClass", ")", "{", "SmallSet", "<", "unsigned", ",", "4", ">", "CopyHints", ";", "CopyHints", ".", "insert", "(", "Hints", ".", "begin", "(", ")", ",", "Hints", ".", "end", "(", ")", ")", ";", "Hints", ".", "clear", "(", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "Order", ")", "if", "(", "CopyHints", ".", "count", "(", "Reg", ")", "&&", "RC", "->", "contains", "(", "Reg", ")", "&&", "!", "MRI", "->", "isReserved", "(", "Reg", ")", ")", "Hints", ".", "push_back", "(", "Reg", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "Order", ")", "if", "(", "!", "CopyHints", ".", "count", "(", "Reg", ")", "&&", "RC", "->", "contains", "(", "Reg", ")", "&&", "!", "MRI", "->", "isReserved", "(", "Reg", ")", ")", "Hints", ".", "push_back", "(", "Reg", ")", ";", "return", "true", ";", "}", "unsigned", "OtherReg", "=", "(", "TrueMO", ".", "getReg", "(", ")", "==", "Reg", "?", "FalseMO", ".", "getReg", "(", ")", ":", "TrueMO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "OtherReg", ")", "==", "&", "SystemZ", "::", "GRX32BitRegClass", ")", "Worklist", ".", "push_back", "(", "OtherReg", ")", ";", "}", "}", "}", "return", "BaseImplRetVal", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "SystemZ", "SystemZ", "SystemZ::GRX32BitRegClass", "8", "4", "SystemZ::LOCRMux", "1", "2", "SystemZ::GRX32BitRegClass", "4", "SystemZ::GRX32BitRegClass" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_SaveList", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"MachineFunction required\"", "X86", "X86" ]

[]

[ "<s>", "void", "VEInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "VE", "::", "I64RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "I32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDLSXrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "F32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDUrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "VE", "::", "F128RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LDQrii", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "report_fatal_error", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::I64RegClass", "VE::LDrii", "0", "0", "VE::I32RegClass", "VE::LDLSXrii", "0", "0", "VE::F32RegClass", "VE::LDUrii", "0", "0", "VE::F128RegClass", "VE::LDQrii", "0", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "static", "tree", "arm_extract_valist_ptr", "(", "tree", "valist", ")", "{", "if", "(", "TREE_TYPE", "(", "valist", ")", "==", "error_mark_node", ")", "return", "error_mark_node", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "tree", "ap_field", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "valist", ")", ")", ";", "valist", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "ap_field", ")", ",", "valist", ",", "ap_field", ",", "NULL_TREE", ")", ";", "}", "return", "valist", ";", "}", "</s>" ]

[ "Return", "an", "expression", "of", "type", "``", "void", "*", "''", "pointing", "to", "the", "next", "available", "argument", "in", "a", "variable-argument", "list", ".", "VALIST", "is", "the", "user-level", "va_list", "object", ",", "of", "type", "__builtin_va_list", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "s390_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "if", "(", "TARGET_TPF_PROFILING", ")", "return", "false", ";", "if", "(", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "decl", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_INDIRECT_BRANCH_NOBP_CALL", "&&", "!", "TARGET_CPU_Z10", "&&", "!", "decl", ")", "return", "false", ";", "return", "!", "s390_call_saved_register_used", "(", "exp", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "call", "expression", "can", "be", "turned", "into", "a", "sibling", "call", ".", "DECL", "holds", "the", "declaration", "of", "the", "function", "to", "be", "called", "whereas", "EXP", "is", "the", "call", "expression", "itself", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "MOSInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "MOS", "::", "LDImm16", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "MOS", "MOS", "MOS::LDImm16" ]

[]

[ "<s>", "SDValue", "MandarinTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Mandarin", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MDISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "&", "RetOps", "[", "0", "]", ",", "RetOps", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "PPCMaterializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "PPCMaterializeGV", "(", "GV", ",", "VT", ")", ";", "else", "if", "(", "isa", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "PPCMaterializeInt", "(", "C", ",", "VT", ",", "VT", "!=", "MVT", "::", "i1", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "PowerPC", "PPC", "0", "PPC", "PPC", "PPC", "MVT::i1", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "s390_mangle_type", "(", "const_tree", "type", ")", "{", "if", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MANGLE_TYPE", "." ]

[ "s390", "\"g\"" ]

[]

[ "<s>", "const", "MCSection", "*", "getSectionForConstant", "(", "SectionKind", "Kind", ")", "const", "override", "{", "return", "ReadOnlySection", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "NVPTX" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "J2" ]

[]

[ "<s>", "bool", "CSKYAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "CSKYSubtarget", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCPhysReg", "*", "Cpu0RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_O32_SaveList", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "mayReadEXEC", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCopyLike", "(", ")", ")", "{", "if", "(", "!", "RI", ".", "isSGPRReg", "(", "MRI", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "true", ";", "return", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", ";", "}", "if", "(", "!", "isTargetSpecificOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "return", "!", "isSALU", "(", "MI", ")", "||", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "could", "potentially", "depend", "on", "the", "value", "of", "exec", "." ]

[ "AMDGPU", "SI", "0", "AMDGPU::EXEC", "AMDGPU::EXEC" ]

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "*", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "}", "return", "Changes", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "riscv_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "return", ";", "tree", "frflags", "=", "GET_BUILTIN_DECL", "(", "CODE_FOR_riscv_frflags", ")", ";", "tree", "fsflags", "=", "GET_BUILTIN_DECL", "(", "CODE_FOR_riscv_fsflags", ")", ";", "tree", "old_flags", "=", "create_tmp_var_raw", "(", "RISCV_ATYPE_USI", ")", ";", "*", "hold", "=", "build4", "(", "TARGET_EXPR", ",", "RISCV_ATYPE_USI", ",", "old_flags", ",", "build_call_expr", "(", "frflags", ",", "0", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "*", "clear", "=", "build_call_expr", "(", "fsflags", ",", "1", ",", "old_flags", ")", ";", "*", "update", "=", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

[ "riscv", "0", "1" ]

[]

[ "<s>", "bool", "Cpu0FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFrameDirective", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "O", "<<", "\"\\t.frame\\t\"", "<<", "'$'", "<<", "LowercaseString", "(", "RI", ".", "get", "(", "stackReg", ")", ".", "AsmName", ")", "<<", "','", "<<", "stackSize", "<<", "','", "<<", "'$'", "<<", "LowercaseString", "(", "RI", ".", "get", "(", "returnReg", ")", ".", "AsmName", ")", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Mips", "Mips", "\"\\t.frame\\t\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "if", "(", "!", "Ty", "->", "isArrayTy", "(", ")", ")", "{", "const", "TypeSize", "&", "TySize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "TySize", ".", "isScalable", "(", ")", "&&", "TySize", ".", "getKnownMinSize", "(", ")", ">", "128", ";", "}", "SmallVector", "<", "EVT", ">", "ValueVTs", ";", "ComputeValueVTs", "(", "*", "this", ",", "DL", ",", "Ty", ",", "ValueVTs", ")", ";", "return", "is_splat", "(", "ValueVTs", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

[ "AArch64", "AArch64", "128" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "ABI", ".", "GetStackPtr", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "ZERO", "=", "ABI", ".", "GetNullPtr", "(", ")", ";", "unsigned", "ADDu", "=", "ABI", ".", "GetPtrAdduOp", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<", "4", ";", "++", "J", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "ABI", ".", "GetEhDataReg", "(", "J", ")", ",", "MipsFI", "->", "getEhDataRegFI", "(", "J", ")", ",", "RC", ",", "&", "RegInfo", ")", ";", "}", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "0", "0", "4", "Mips" ]

[]

[ "<s>", "static", "bool", "isEqual", "(", "const", "MemOpKey", "&", "LHS", ",", "const", "MemOpKey", "&", "RHS", ")", "{", "if", "(", "RHS", ".", "Disp", "==", "PtrInfo", "::", "getEmptyKey", "(", ")", ")", "return", "LHS", ".", "Disp", "==", "PtrInfo", "::", "getEmptyKey", "(", ")", ";", "if", "(", "RHS", ".", "Disp", "==", "PtrInfo", "::", "getTombstoneKey", "(", ")", ")", "return", "LHS", ".", "Disp", "==", "PtrInfo", "::", "getTombstoneKey", "(", ")", ";", "return", "LHS", "==", "RHS", ";", "}", "</s>" ]

[ "isEqual", "-", "Compares", "two", "trees", "for", "structural", "equality", "and", "returns", "true", "if", "they", "are", "equal", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "ix86_sched_init_global", "(", "FILE", "*", ",", "int", ",", "int", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "case", "PROCESSOR_TREMONT", ":", "case", "PROCESSOR_ALDERLAKE", ":", "case", "PROCESSOR_GENERIC", ":", "if", "(", "reload_completed", ")", "{", "ix86_core2i7_init_hooks", "(", ")", ";", "break", ";", "}", "default", ":", "targetm", ".", "sched", ".", "dfa_post_advance_cycle", "=", "NULL", ";", "targetm", ".", "sched", ".", "first_cycle_multipass_init", "=", "NULL", ";", "targetm", ".", "sched", ".", "first_cycle_multipass_begin", "=", "NULL", ";", "targetm", ".", "sched", ".", "first_cycle_multipass_issue", "=", "NULL", ";", "targetm", ".", "sched", ".", "first_cycle_multipass_backtrack", "=", "NULL", ";", "targetm", ".", "sched", ".", "first_cycle_multipass_end", "=", "NULL", ";", "targetm", ".", "sched", ".", "first_cycle_multipass_fini", "=", "NULL", ";", "break", ";", "}", "}", "</s>" ]

[ "Prepare", "for", "scheduling", "pass", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "isIndirectCall", "(", "const", "SDValue", "&", "Callee", ",", "SelectionDAG", "&", "DAG", ",", "const", "PPCSubtarget", "&", "Subtarget", ",", "bool", "isPatchPoint", ")", "{", "if", "(", "isPatchPoint", ")", "return", "false", ";", "if", "(", "isFunctionGlobalAddress", "(", "Callee", ")", "||", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "return", "false", ";", "if", "(", "!", "Subtarget", ".", "usesFunctionDescriptors", "(", ")", "&&", "!", "Subtarget", ".", "isELFv2ABI", "(", ")", "&&", "isBLACompatibleAddress", "(", "Callee", ",", "DAG", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "callsite", "is", "an", "indirect", "call", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "bool", "isThisReturn", ",", "SDValue", "ThisVal", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "i", "==", "0", "&&", "isThisReturn", ")", "{", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", "&&", "\"unexpected return calling convention register assignment\"", ")", ";", "InVals", ".", "push_back", "(", "ThisVal", ")", ";", "continue", ";", "}", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::InputArg", "AArch64", "AArch64", "16", "0", "0", "MVT::i64", "\"unexpected return calling convention register assignment\"", "1", "2", "\"Unknown loc info!\"", "ISD::BITCAST" ]

[]