Datasets:

---

docz1105

/

ComBack

like 9

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "X86" ]

[]

[ "<s>", "Optional", "<", "ExtAddrMode", ">", "AArch64InstrInfo", "::", "getAddrModeFromMemoryOp", "(", "const", "MachineInstr", "&", "MemI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineOperand", "*", "Base", ";", "int64_t", "Offset", ";", "bool", "OffsetIsScalable", ";", "if", "(", "!", "getMemOperandWithOffset", "(", "MemI", ",", "Base", ",", "Offset", ",", "OffsetIsScalable", ",", "TRI", ")", ")", "return", "None", ";", "if", "(", "!", "Base", "->", "isReg", "(", ")", ")", "return", "None", ";", "ExtAddrMode", "AM", ";", "AM", ".", "BaseReg", "=", "Base", "->", "getReg", "(", ")", ";", "AM", ".", "Displacement", "=", "Offset", ";", "AM", ".", "ScaledReg", "=", "0", ";", "return", "AM", ";", "}", "</s>" ]

[ "Target", "dependent", "implementation", "to", "get", "the", "values", "constituting", "the", "address", "MachineInstr", "that", "is", "accessing", "memory", "." ]

[ "AArch64", "AArch64", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPARC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"SPARC DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", ".", "hasAVX512", "(", ")", "?", "MVT", "::", "i1", ":", "MVT", "::", "i8", ";", "if", "(", "VT", ".", "isSimple", "(", ")", ")", "{", "MVT", "VVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "const", "unsigned", "NumElts", "=", "VVT", ".", "getVectorNumElements", "(", ")", ";", "const", "MVT", "EltVT", "=", "VVT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VVT", ".", "is512BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "32", ":", "return", "MVT", "::", "v32i1", ";", "case", "64", ":", "return", "MVT", "::", "v64i1", ";", "}", "}", "if", "(", "VVT", ".", "is256BitVector", "(", ")", "||", "VVT", ".", "is128BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "2", ":", "return", "MVT", "::", "v2i1", ";", "case", "4", ":", "return", "MVT", "::", "v4i1", ";", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "case", "32", ":", "return", "MVT", "::", "v32i1", ";", "}", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::i1", "MVT::i8", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "8", "MVT::v8i1", "16", "MVT::v16i1", "MVT::i8", "MVT::i16", "32", "MVT::v32i1", "64", "MVT::v64i1", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "2", "MVT::v2i1", "4", "MVT::v4i1", "8", "MVT::v8i1", "MVT::i8", "MVT::i16", "8", "MVT::v8i1", "16", "MVT::v16i1", "32", "MVT::v32i1" ]

[]

[ "<s>", "static", "opt_scalar_float_mode", "arm_floatn_mode", "(", "int", "n", ",", "bool", "extended", ")", "{", "if", "(", "!", "extended", "&&", "n", "==", "16", ")", "{", "if", "(", "arm_fp16_format", "==", "ARM_FP16_FORMAT_IEEE", ")", "return", "HFmode", ";", "return", "opt_scalar_float_mode", "(", ")", ";", "}", "return", "default_floatn_mode", "(", "n", ",", "extended", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FLOATN_MODE", ".", "Make", "very", "sure", "that", "we", "do", "n't", "provide", "_Float16", "if", "we", "are", "using", "anything", "other", "than", "ieee", "format", "for", "16-bit", "floating", "point", ".", "Otherwise", ",", "punt", "to", "the", "default", "implementation", "." ]

[ "arm", "16" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "unsigned", "DefaultSafety", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "PPC", "::", "G8RC_NOX0RegClassID", ":", "case", "PPC", "::", "GPRC_NOR0RegClassID", ":", "case", "PPC", "::", "G8RCRegClassID", ":", "case", "PPC", "::", "GPRCRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "32", "-", "FP", "-", "DefaultSafety", ";", "}", "case", "PPC", "::", "F8RCRegClassID", ":", "case", "PPC", "::", "F4RCRegClassID", ":", "case", "PPC", "::", "VRRCRegClassID", ":", "case", "PPC", "::", "VFRCRegClassID", ":", "case", "PPC", "::", "VSLRCRegClassID", ":", "case", "PPC", "::", "VSHRCRegClassID", ":", "return", "32", "-", "DefaultSafety", ";", "case", "PPC", "::", "VSRCRegClassID", ":", "case", "PPC", "::", "VSFRCRegClassID", ":", "return", "64", "-", "DefaultSafety", ";", "case", "PPC", "::", "CRRCRegClassID", ":", "return", "8", "-", "DefaultSafety", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "PowerPC", "PPC", "1", "0", "PPC::G8RC_NOX0RegClassID", "PPC::GPRC_NOR0RegClassID", "PPC::G8RCRegClassID", "PPC::GPRCRegClassID", "1", "0", "32", "PPC::F8RCRegClassID", "PPC::F4RCRegClassID", "PPC::VRRCRegClassID", "PPC::VFRCRegClassID", "PPC::VSLRCRegClassID", "PPC::VSHRCRegClassID", "32", "PPC::VSRCRegClassID", "PPC::VSFRCRegClassID", "64", "PPC::CRRCRegClassID", "8" ]

[]

[ "<s>", "SUnit", "*", "SIScheduleBlock", "::", "pickNode", "(", ")", "{", "SISchedCandidate", "TopCand", ";", "for", "(", "SUnit", "*", "SU", ":", "TopReadySUs", ")", "{", "SISchedCandidate", "TryCand", ";", "std", "::", "vector", "<", "unsigned", ">", "pressure", ";", "std", "::", "vector", "<", "unsigned", ">", "MaxPressure", ";", "TryCand", ".", "SU", "=", "SU", ";", "TopRPTracker", ".", "getDownwardPressure", "(", "SU", "->", "getInstr", "(", ")", ",", "pressure", ",", "MaxPressure", ")", ";", "TryCand", ".", "SGPRUsage", "=", "pressure", "[", "AMDGPU", "::", "RegisterPressureSets", "::", "SReg_32", "]", ";", "TryCand", ".", "VGPRUsage", "=", "pressure", "[", "AMDGPU", "::", "RegisterPressureSets", "::", "VGPR_32", "]", ";", "TryCand", ".", "IsLowLatency", "=", "DAG", "->", "IsLowLatencySU", "[", "SU", "->", "NodeNum", "]", ";", "TryCand", ".", "LowLatencyOffset", "=", "DAG", "->", "LowLatencyOffset", "[", "SU", "->", "NodeNum", "]", ";", "TryCand", ".", "HasLowLatencyNonWaitedParent", "=", "HasLowLatencyNonWaitedParent", "[", "NodeNum2Index", "[", "SU", "->", "NodeNum", "]", "]", ";", "tryCandidateTopDown", "(", "TopCand", ",", "TryCand", ")", ";", "if", "(", "TryCand", ".", "Reason", "!=", "NoCand", ")", "TopCand", ".", "setBest", "(", "TryCand", ")", ";", "}", "return", "TopCand", ".", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::RegisterPressureSets", "AMDGPU::RegisterPressureSets" ]

[]

[ "<s>", "static", "int", "cr16_addr_reg_p", "(", "rtx", "addr_reg", ")", "{", "rtx", "reg", ";", "if", "(", "REG_P", "(", "addr_reg", ")", ")", "reg", "=", "addr_reg", ";", "else", "if", "(", "(", "GET_CODE", "(", "addr_reg", ")", "==", "SUBREG", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "addr_reg", ")", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "addr_reg", ")", ")", ")", "<=", "UNITS_PER_WORD", ")", ")", "reg", "=", "SUBREG_REG", "(", "addr_reg", ")", ";", "else", "return", "FALSE", ";", "if", "(", "GET_MODE", "(", "reg", ")", "!=", "Pmode", ")", "return", "FALSE", ";", "return", "TRUE", ";", "}", "</s>" ]

[ "Helper", "function", "to", "check", "if", "is", "a", "valid", "base", "register", "that", "can", "hold", "address", "." ]

[ "cr16" ]

[]

[ "<s>", "const", "uint16_t", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "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", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_MostRegs_64_SaveList", ";", "break", ";", "default", ":", "break", ";", "}", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "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" ]

[]

[ "<s>", "bool", "Mips16DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "return", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "EVT", "MipsTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Subtarget", "->", "hasMips64", "(", ")", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "Mips", "Mips", "Mips", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "isCall", "(", "const", "MCInst", "&", "MI", ",", "bool", "*", "IsIndirectCall", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "*", "IsIndirectCall", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "JAL", ":", "case", "Mips", "::", "BAL", ":", "case", "Mips", "::", "BAL_BR", ":", "case", "Mips", "::", "BLTZAL", ":", "case", "Mips", "::", "BGEZAL", ":", "return", "true", ";", "case", "Mips", "::", "JALR", ":", "assert", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO", ")", "return", "false", ";", "*", "IsIndirectCall", "=", "true", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Is", "a", "function", "call", "." ]

[ "Mips", "Mips::JAL", "Mips::BAL", "Mips::BAL_BR", "Mips::BLTZAL", "Mips::BGEZAL", "Mips::JALR", "0", "0", "Mips::ZERO" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "HexagonTargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "unsigned", "VecLen", "=", "VT", ".", "getVectorMinNumElements", "(", ")", ";", "MVT", "ElemTy", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VecLen", "==", "1", "||", "VT", ".", "isScalableVector", "(", ")", ")", "return", "TargetLoweringBase", "::", "TypeScalarizeVector", ";", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "{", "unsigned", "Action", "=", "getPreferredHvxVectorAction", "(", "VT", ")", ";", "if", "(", "Action", "!=", "~", "0u", ")", "return", "static_cast", "<", "TargetLoweringBase", "::", "LegalizeTypeAction", ">", "(", "Action", ")", ";", "}", "if", "(", "ElemTy", "==", "MVT", "::", "i1", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "if", "(", "!", "isPowerOf2_32", "(", "VecLen", ")", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "TypeSplitVector", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "Hexagon", "Hexagon", "1", "0u", "MVT::i1" ]

[]

[ "<s>", "static", "void", "flow_dependent_p_1", "(", "rtx", "x", ",", "const_rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx", "*", "pinsn", "=", "(", "rtx", "*", ")", "data", ";", "if", "(", "*", "pinsn", "&&", "reg_referenced_p", "(", "x", ",", "*", "pinsn", ")", ")", "*", "pinsn", "=", "NULL_RTX", ";", "}", "</s>" ]

[ "A", "helper", "function", "for", "flow_dependent_p", "called", "through", "note_stores", "." ]

[ "sh" ]

[]

[ "<s>", "static", "bool", "zero_call_used_regno_p", "(", "const", "unsigned", "int", "regno", ",", "bool", "all_sse_zeroed", ",", "bool", "need_zero_mmx", ")", "{", "return", "GENERAL_REGNO_P", "(", "regno", ")", "||", "(", "!", "all_sse_zeroed", "&&", "SSE_REGNO_P", "(", "regno", ")", ")", "||", "MASK_REGNO_P", "(", "regno", ")", "||", "(", "need_zero_mmx", "&&", "MMX_REGNO_P", "(", "regno", ")", ")", ";", "}", "</s>" ]

[ "Check", "whether", "the", "register", "REGNO", "should", "be", "zeroed", "on", "X86", ".", "When", "ALL_SSE_ZEROED", "is", "true", ",", "all", "SSE", "registers", "have", "been", "zeroed", "together", ",", "no", "need", "to", "zero", "it", "again", ".", "When", "NEED_ZERO_MMX", "is", "true", ",", "MMX", "registers", "should", "be", "cleared", "." ]

[ "i386" ]

[]

[ "<s>", "BitVector", "PatmosRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "P0", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S0", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S1", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SL", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SH", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S4", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SS", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "ST", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SRO", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SXB", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "SXO", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S11", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S12", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S13", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S14", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "S15", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "RSP", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "RFP", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "RTR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "Patmos", "::", "RFP", ")", ";", "if", "(", "PatmosSinglePathInfo", "::", "isEnabled", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "Patmos", "::", "R26", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "P6", ")", ";", "Reserved", ".", "set", "(", "Patmos", "::", "P7", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::R0", "Patmos::P0", "Patmos::S0", "Patmos::S1", "Patmos::SL", "Patmos::SH", "Patmos::S4", "Patmos::SS", "Patmos::ST", "Patmos::SRB", "Patmos::SRO", "Patmos::SXB", "Patmos::SXO", "Patmos::S11", "Patmos::S12", "Patmos::S13", "Patmos::S14", "Patmos::S15", "Patmos::RSP", "Patmos::RFP", "Patmos::RTR", "Patmos::RFP", "Patmos", "Patmos::R26", "Patmos::P6", "Patmos::P7" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "}", "</s>" ]

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

[ "GBZ80" ]

[]

[ "<s>", "Instruction", "*", "llvm", "::", "getInst", "(", "Value", "*", "base", ",", "char", "*", "instName", ")", "{", "Function", "*", "F", "=", "getParentFunction", "(", "base", ")", ";", "if", "(", "F", "==", "0", ")", "return", "0", ";", "for", "(", "inst_iterator", "it", "=", "inst_begin", "(", "F", ")", ",", "ie", "=", "inst_end", "(", "F", ")", ";", "it", "!=", "ie", ";", "++", "it", ")", "{", "Instruction", "*", "I", "=", "&", "*", "it", ";", "if", "(", "strcmp", "(", "I", "->", "getName", "(", ")", ".", "data", "(", ")", ",", "instName", ")", "==", "0", ")", "{", "return", "I", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "If", "this", "is", "a", "normal", "dependency", ",", "returns", "the", "instruction", "that", "is", "depended", "on", "." ]

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

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "8" ]

[]

[ "<s>", "static", "int", "n_regs_saved_by_prologue", "(", "void", ")", "{", "e_funkind", "fkind", "=", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "bool", "is_inthandler", "=", "fkind", "!=", "SUBROUTINE", ";", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "bool", "all", "=", "(", "lookup_attribute", "(", "\"saveall\"", ",", "attrs", ")", "!=", "NULL_TREE", "||", "(", "is_inthandler", "&&", "!", "crtl", "->", "is_leaf", ")", ")", ";", "int", "ndregs", "=", "all", "?", "8", ":", "n_dregs_to_save", "(", "is_inthandler", ",", "false", ")", ";", "int", "npregs", "=", "all", "?", "6", ":", "n_pregs_to_save", "(", "is_inthandler", ",", "false", ")", ";", "int", "n", "=", "ndregs", "+", "npregs", ";", "int", "i", ";", "if", "(", "all", "||", "stack_frame_needed_p", "(", ")", ")", "n", "+=", "2", ";", "else", "{", "if", "(", "must_save_fp_p", "(", ")", ")", "n", "++", ";", "if", "(", "must_save_rets_p", "(", ")", ")", "n", "++", ";", "}", "if", "(", "fkind", "!=", "SUBROUTINE", "||", "all", ")", "{", "n", "++", ";", "if", "(", "!", "crtl", "->", "is_leaf", "||", "cfun", "->", "machine", "->", "has_hardware_loops", "||", "cfun", "->", "machine", "->", "has_loopreg_clobber", ")", "{", "n", "+=", "6", ";", "}", "}", "if", "(", "fkind", "!=", "SUBROUTINE", ")", "{", "if", "(", "lookup_attribute", "(", "\"nesting\"", ",", "attrs", ")", ")", "n", "++", ";", "}", "for", "(", "i", "=", "REG_P7", "+", "1", ";", "i", "<", "REG_CC", ";", "i", "++", ")", "if", "(", "all", "||", "(", "fkind", "!=", "SUBROUTINE", "&&", "(", "df_regs_ever_live_p", "(", "i", ")", "||", "(", "!", "leaf_function_p", "(", ")", "&&", "call_used_regs", "[", "i", "]", ")", ")", ")", ")", "n", "+=", "i", "==", "REG_A0", "||", "i", "==", "REG_A1", "?", "2", ":", "1", ";", "return", "n", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "registers", "pushed", "during", "the", "prologue", "." ]

[ "bfin", "\"saveall\"", "8", "6", "2", "6", "\"nesting\"", "1", "2", "1" ]

[]

[ "<s>", "void", "TriCoreInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "\"%\"", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "TriCore", "TriCore", "\"%\"" ]

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM EXPAND PSEUDO INSTRUCTIONS **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "if", "(", "VerifyARMPseudo", ")", "MF", ".", "verify", "(", "this", ",", "\"After expanding ARM pseudo instructions.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***************************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"********** ARM EXPAND PSEUDO INSTRUCTIONS **********\\n\"", "\"********** Function: \"", "ARM", "\"After expanding ARM pseudo instructions.\"", "\"***************************************************\\n\"" ]

[]

[ "<s>", "bool", "WebAssemblyPeephole", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "unsigned", "OldReg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "OldReg", "==", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "&&", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ")", ")", "{", "Changed", "=", "true", ";", "unsigned", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "MRI", ".", "getRegClass", "(", "OldReg", ")", ")", ";", "MO", ".", "setReg", "(", "NewReg", ")", ";", "MO", ".", "setIsDead", "(", ")", ";", "MFI", ".", "stackifyVReg", "(", "NewReg", ")", ";", "MFI", ".", "addWAReg", "(", "NewReg", ",", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "0", "3", "3", "WebAssembly" ]

[]

[ "<s>", "rtx", "legitimize_reload_address", "(", "rtx", "ad", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ")", "{", "if", "(", "!", "optimize", "||", "TARGET_LONG_DISPLACEMENT", ")", "return", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "ad", ")", "==", "PLUS", ")", "{", "rtx", "tem", "=", "simplify_binary_operation", "(", "PLUS", ",", "Pmode", ",", "XEXP", "(", "ad", ",", "0", ")", ",", "XEXP", "(", "ad", ",", "1", ")", ")", ";", "if", "(", "tem", ")", "ad", "=", "tem", ";", "}", "if", "(", "GET_CODE", "(", "ad", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "ad", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "DISP_IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "ad", ",", "1", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "lower", "=", "INTVAL", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "&", "0xfff", ";", "HOST_WIDE_INT", "upper", "=", "INTVAL", "(", "XEXP", "(", "ad", ",", "1", ")", ")", "^", "lower", ";", "rtx", "cst", ",", "tem", ",", "new", ";", "cst", "=", "GEN_INT", "(", "upper", ")", ";", "if", "(", "!", "legitimate_reload_constant_p", "(", "cst", ")", ")", "cst", "=", "force_const_mem", "(", "Pmode", ",", "cst", ")", ";", "tem", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "ad", ",", "0", ")", ",", "cst", ")", ";", "new", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "GEN_INT", "(", "lower", ")", ")", ";", "push_reload", "(", "XEXP", "(", "tem", ",", "1", ")", ",", "0", ",", "&", "XEXP", "(", "tem", ",", "1", ")", ",", "0", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "new", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Try", "a", "machine-dependent", "way", "of", "reloading", "an", "illegitimate", "address", "AD", "operand", ".", "If", "we", "find", "one", ",", "push", "the", "reload", "and", "and", "return", "the", "new", "address", ".", "MODE", "is", "the", "mode", "of", "the", "enclosing", "MEM", ".", "OPNUM", "is", "the", "operand", "number", "and", "TYPE", "is", "the", "reload", "type", "of", "the", "current", "reload", "." ]

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

[]

[ "<s>", "const", "TOYRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "HexagonInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "if", "(", "UseDFAHazardRec", ")", "return", "new", "HexagonHazardRecognizer", "(", "II", ",", "this", ",", "Subtarget", ")", ";", "return", "TargetInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

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

[]

[ "<s>", "int", "arx_reg_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "mode", "!=", "VOIDmode", "&&", "mode", "!=", "GET_MODE", "(", "op", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", ")", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "return", "REG_P", "(", "op", ")", "&&", "(", "!", "reload_completed", "||", "IS_ADDR_REG", "(", "op", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "any", "one", "of", "the", "address", "registers", "." ]

[ "c4x", "0" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "static", "bool", "loongarch_rtx_constant_in_small_data_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "g_switch_value", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "rtx", "constants", "of", "mode", "MODE", "should", "be", "put", "into", "a", "small", "data", "section", "." ]

[ "loongarch" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttr", "(", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "||", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "NULL", ",", "0", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "DstVT", ",", "dl", ",", "Store", ",", "MemTmp", ",", "NULL", ",", "0", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "0", "ISD::EXTLOAD", "0", "0", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "bool", "is64", "=", "getPointerSize", "(", ")", "==", "8", ";", "return", "createPPCELFObjectWriter", "(", "OS", ",", "is64", ",", "isLittleEndian", "(", ")", ",", "OSABI", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "8", "PPC" ]

[]

[ "<s>", "unsigned", "MBlazeIntrinsicInfo", "::", "lookupName", "(", "const", "char", "*", "Name", ",", "unsigned", "Len", ")", "const", "{", "if", "(", "!", "StringRef", "(", "Name", ",", "Len", ")", ".", "startswith", "(", "\"llvm.\"", ")", ")", "return", "0", ";", "return", "0", ";", "}", "</s>" ]

[ "Look", "up", "target", "intrinsic", "by", "name", "." ]

[ "MBlaze", "MBlaze", "\"llvm.\"", "0", "0" ]

[]

[ "<s>", "static", "bool", "v850_reg_ok_for_base_p", "(", "const_rtx", "reg", ",", "bool", "strict_p", ")", "{", "if", "(", "strict_p", ")", "{", "return", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "reg", ")", ")", ";", "}", "else", "{", "return", "true", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "`", "v850_legitimate_address_p", "'", "." ]

[ "v850" ]

[]

[ "<s>", "std", "::", "string", "getNodeLabel", "(", "const", "ablock", "*", "AB", ",", "const", "agraph", "&", "G", ")", "{", "std", "::", "stringstream", "s", ";", "s", "<<", "AB", "->", "getName", "(", ")", "<<", "\" (\"", "<<", "AB", "->", "NumPreds", "<<", "\")\"", ";", "s", "<<", "\"\\n\"", "<<", "AB", "->", "Size", "<<", "\" (\"", "<<", "AB", "->", "SCCSize", "<<", "\")\"", ";", "if", "(", "AB", "->", "Region", ")", "s", "<<", "\"\\n\"", "<<", "AB", "->", "Region", "->", "getName", "(", ")", ";", "return", "s", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Print", "a", "DDG", "node", "either", "in", "concise", "form", "(", "-ddg-dot-only", ")", "or", "verbose", "mode", "(", "-ddg-dot", ")", "." ]

[ "Patmos", "\" (\"", "\")\"", "\"\\n\"", "\" (\"", "\")\"", "\"\\n\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MSP430FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "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", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "0", "0", "1", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "1", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3", "1", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "void", "TOYFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "unsigned", "StackReg", "=", "TOY", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TOY", "::", "ADDrr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TOY", "::", "ADDri", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::SP", "TOY::ADDrr", "TOY::ADDri" ]

[]

[ "<s>", "bool", "isTarget64BitILP32", "(", ")", "const", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", "||", "TargetTriple", ".", "getOS", "(", ")", "==", "Triple", "::", "NaCl", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "ILP32", "programming", "model", "(", "x32", "ABI", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "unsigned", "AArch64MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "{", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"did not expect relocated expression\"", ")", ";", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "assert", "(", "0", "&&", "\"Unable to encode MCOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"did not expect relocated expression\"", "0", "\"Unable to encode MCOperand!\"", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "aarch64_simd_vector_alignment", "(", "const_tree", "type", ")", "{", "HOST_WIDE_INT", "align", "=", "tree_to_shwi", "(", "TYPE_SIZE", "(", "type", ")", ")", ";", "return", "MIN", "(", "align", ",", "128", ")", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_VECTOR_ALIGNMENT", ".", "The", "AAPCS64", "sets", "the", "maximum", "alignment", "of", "a", "vector", "to", "128", "bits", "." ]

[ "aarch64", "128" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", "||", "isNewValueJump", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "||", "isEndLoopN", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCannot predicate:\"", ";", "MI", ".", "dump", "(", ")", ";", ")", ";", "return", "false", ";", "}", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "bool", "invertJump", "=", "predOpcodeHasNot", "(", "Cond", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "PredOpc", "=", "getCondOpcode", "(", "Opc", ",", "invertJump", ")", ";", "MachineInstrBuilder", "T", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "get", "(", "PredOpc", ")", ")", ";", "unsigned", "NOp", "=", "0", ",", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "NOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "break", ";", "T", ".", "addOperand", "(", "Op", ")", ";", "NOp", "++", ";", "}", "unsigned", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ";", "bool", "GotPredReg", "=", "getPredReg", "(", "Cond", ",", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ")", ";", "(", "void", ")", "GotPredReg", ";", "assert", "(", "GotPredReg", ")", ";", "T", ".", "addReg", "(", "PredReg", ",", "PredRegFlags", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "T", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "NOp", "++", ")", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "PredOpc", ")", ")", ";", "while", "(", "unsigned", "n", "=", "MI", ".", "getNumOperands", "(", ")", ")", "MI", ".", "RemoveOperand", "(", "n", "-", "1", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "T", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "MI", ".", "addOperand", "(", "T", "->", "getOperand", "(", "i", ")", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "TI", "=", "T", "->", "getIterator", "(", ")", ";", "B", ".", "erase", "(", "TI", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "B", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "clearKillFlags", "(", "PredReg", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "0", "\"\\nCannot predicate:\"", "\"Expected predicable instruction\"", "0", "1", "0" ]

[]

[ "<s>", "void", "Z80oldInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "TRC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "Opc", ";", "switch", "(", "TRI", "->", "getSpillSize", "(", "*", "TRC", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected regclass size\"", ")", ";", "case", "1", ":", "Opc", "=", "Z80old", "::", "LD8or", ";", "break", ";", "case", "2", ":", "Opc", "=", "Z80old", "::", "LD88or", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "Opc", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ";", "return", ";", "unsigned", "RC", ",", "LoOpc", ",", "LoIdx", ",", "HiOpc", ",", "HiIdx", ",", "HiOff", ";", "bool", "Split", "=", "Z80old", "::", "splitReg", "(", "TRI", "->", "getSpillSize", "(", "*", "TRC", ")", ",", "Z80old", "::", "LD8or", ",", "RC", ",", "LoOpc", ",", "LoIdx", ",", "HiOpc", ",", "HiIdx", ",", "HiOff", ")", ";", "MachineInstrBuilder", "LoMIB", "=", "addSubReg", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "LoOpc", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ",", "SrcReg", ",", "LoIdx", ",", "TRI", ",", "getKillRegState", "(", "IsKill", ")", ")", ";", "if", "(", "Split", ")", "{", "MachineInstrBuilder", "HiMIB", "=", "addSubReg", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "HiOpc", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "HiOff", ")", ",", "SrcReg", ",", "HiIdx", ",", "TRI", ",", "getKillRegState", "(", "IsKill", ")", ")", ";", "if", "(", "IsKill", ")", "{", "HiMIB", "->", "addRegisterKilled", "(", "SrcReg", ",", "TRI", ",", "true", ")", ";", "}", "}", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "Z80old", "Z80old", "\"Unexpected regclass size\"", "1", "Z80old::LD8or", "2", "Z80old::LD88or", "0", "Z80old::splitReg", "Z80old::LD8or", "0" ]

[]

[ "<s>", "bool", "GBZ80InstrInfo", "::", "analyzeBranchPredicate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBranchPredicate", "&", "MBP", ",", "bool", "AllowModify", ")", "const", "{", "SmallVector", "<", "MachineOperand", ",", "4", ">", "Cond", ";", "MachineBasicBlock", "*", "FBB", "=", "nullptr", ",", "*", "TBB", "=", "nullptr", ";", "if", "(", "analyzeBranch", "(", "MBB", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", "and", "parse", "it", "into", "the", "MachineBranchPredicate", "structure", "if", "possible", "." ]

[ "GBZ80", "GB", "4" ]

[]

[ "<s>", "unsigned", "LanaiRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", ")", "const", "{", "return", "Lanai", "::", "FP", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::FP" ]

[]

[ "<s>", "bool", "SparcDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "return", "true", ";", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "!", "SelectADDRrr", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "SelectADDRri", "(", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "MCInst", "M88kInstrInfo", "::", "getNop", "(", ")", "const", "{", "return", "MCInstBuilder", "(", "M88k", "::", "ORrr", ")", ".", "addReg", "(", "M88k", "::", "R0", ")", ".", "addReg", "(", "M88k", "::", "R0", ")", ".", "addReg", "(", "M88k", "::", "R0", ")", ";", "}", "</s>" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

[ "M88k", "M88k", "M88k::ORrr", "M88k::R0", "M88k::R0", "M88k::R0" ]

[]

[ "<s>", "void", "thumb2_final_prescan_insn", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "first_insn", "=", "insn", ";", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "predicate", ";", "enum", "arm_cond_code", "code", ";", "int", "n", ";", "int", "mask", ";", "int", "max", ";", "max", "=", "MAX_INSN_PER_IT_BLOCK", ";", "if", "(", "arm_condexec_count", ")", "arm_condexec_count", "--", ";", "if", "(", "arm_condexec_count", ")", "return", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "COND_EXEC", ")", "return", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "return", ";", "predicate", "=", "COND_EXEC_TEST", "(", "body", ")", ";", "arm_current_cc", "=", "get_arm_condition_code", "(", "predicate", ")", ";", "n", "=", "get_attr_ce_count", "(", "insn", ")", ";", "arm_condexec_count", "=", "1", ";", "arm_condexec_mask", "=", "(", "1", "<<", "n", ")", "-", "1", ";", "arm_condexec_masklen", "=", "n", ";", "for", "(", ";", ";", ")", "{", "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "!", "JUMP_P", "(", "insn", ")", ")", "break", ";", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "USE", "||", "GET_CODE", "(", "body", ")", "==", "CLOBBER", ")", "continue", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "COND_EXEC", ")", "break", ";", "n", "=", "get_attr_ce_count", "(", "insn", ")", ";", "if", "(", "arm_condexec_masklen", "+", "n", ">", "max", ")", "break", ";", "predicate", "=", "COND_EXEC_TEST", "(", "body", ")", ";", "code", "=", "get_arm_condition_code", "(", "predicate", ")", ";", "mask", "=", "(", "1", "<<", "n", ")", "-", "1", ";", "if", "(", "arm_current_cc", "==", "code", ")", "arm_condexec_mask", "|=", "(", "mask", "<<", "arm_condexec_masklen", ")", ";", "else", "if", "(", "arm_current_cc", "!=", "ARM_INVERSE_CONDITION_CODE", "(", "code", ")", ")", "break", ";", "arm_condexec_count", "++", ";", "arm_condexec_masklen", "+=", "n", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "break", ";", "}", "extract_constrain_insn_cached", "(", "first_insn", ")", ";", "}", "</s>" ]

[ "Tell", "arm_asm_output_opcode", "to", "output", "IT", "blocks", "for", "conditionally", "executed", "instructions", "." ]

[ "arm", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "int", "legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "rtx", "xfoo0", ",", "xfoo1", ";", "if", "(", "nonindexed_address_p", "(", "x", ",", "strict", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "0", ";", "xfoo0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "xfoo1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "index_term_p", "(", "xfoo0", ",", "mode", ",", "strict", ")", "&&", "nonindexed_address_p", "(", "xfoo1", ",", "strict", ")", ")", "return", "1", ";", "if", "(", "index_term_p", "(", "xfoo1", ",", "mode", ",", "strict", ")", "&&", "nonindexed_address_p", "(", "xfoo0", ",", "strict", ")", ")", "return", "1", ";", "if", "(", "indirectable_constant_address_p", "(", "xfoo0", ")", "&&", "(", "BASE_REGISTER_P", "(", "xfoo1", ",", "strict", ")", "||", "reg_plus_index_p", "(", "xfoo1", ",", "mode", ",", "strict", ")", ")", ")", "return", "1", ";", "if", "(", "indirectable_constant_address_p", "(", "xfoo1", ")", "&&", "(", "BASE_REGISTER_P", "(", "xfoo0", ",", "strict", ")", "||", "reg_plus_index_p", "(", "xfoo0", ",", "mode", ",", "strict", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "legitimate_address_p", "returns", "1", "if", "it", "recognizes", "an", "RTL", "expression", "``", "x", "''", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", "." ]

[ "vax", "1", "0", "0", "1", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ")", ";", "for", "(", "auto", "*", "I", ":", "depth_first", "(", "DomTree", ")", ")", "if", "(", "tryConvert", "(", "I", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Compares **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "unsigned", "getCacheLineSize", "(", ")", "const", "override", "{", "return", "CacheLineSize", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "AArch64" ]

[]

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

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

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

[]

[ "<s>", "bool", "TOYPreRegAlloc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* TOY PreRegAlloc *********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "Changed", "|=", "peepholeOpt", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"********* TOY PreRegAlloc *********\\n\"" ]

[]

[ "<s>", "bool", "aarch64_emit_approx_sqrt", "(", "rtx", "dst", ",", "rtx", "src", ",", "bool", "recp", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "if", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "HFmode", ")", "{", "gcc_assert", "(", "!", "recp", ")", ";", "return", "false", ";", "}", "if", "(", "!", "recp", ")", "{", "if", "(", "!", "(", "flag_mlow_precision_sqrt", "||", "(", "aarch64_tune_params", ".", "approx_modes", "->", "sqrt", "&", "AARCH64_APPROX_MODE", "(", "mode", ")", ")", ")", ")", "return", "false", ";", "if", "(", "flag_finite_math_only", "||", "flag_trapping_math", "||", "!", "flag_unsafe_math_optimizations", "||", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "false", ";", "}", "else", "gcc_assert", "(", "use_rsqrt_p", "(", "mode", ")", ")", ";", "machine_mode", "mmsk", "=", "mode_for_int_vector", "(", "mode", ")", ".", "require", "(", ")", ";", "rtx", "xmsk", "=", "gen_reg_rtx", "(", "mmsk", ")", ";", "if", "(", "!", "recp", ")", "emit_insn", "(", "gen_rtx_SET", "(", "xmsk", ",", "gen_rtx_NEG", "(", "mmsk", ",", "gen_rtx_EQ", "(", "mmsk", ",", "src", ",", "CONST0_RTX", "(", "mode", ")", ")", ")", ")", ")", ";", "rtx", "xdst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "(", "*", "get_rsqrte_type", "(", "mode", ")", ")", "(", "xdst", ",", "src", ")", ")", ";", "int", "iterations", "=", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "DFmode", ")", "?", "3", ":", "2", ";", "if", "(", "(", "recp", "&&", "flag_mrecip_low_precision_sqrt", ")", "||", "(", "!", "recp", "&&", "flag_mlow_precision_sqrt", ")", ")", "iterations", "--", ";", "rtx", "x1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "while", "(", "iterations", "--", ")", "{", "rtx", "x2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_set_insn", "(", "x2", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "xdst", ")", ")", ";", "emit_insn", "(", "(", "*", "get_rsqrts_type", "(", "mode", ")", ")", "(", "x1", ",", "src", ",", "x2", ")", ")", ";", "if", "(", "iterations", ">", "0", ")", "emit_set_insn", "(", "xdst", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "x1", ")", ")", ";", "}", "if", "(", "!", "recp", ")", "{", "rtx", "xtmp", "=", "gen_reg_rtx", "(", "mmsk", ")", ";", "emit_set_insn", "(", "xtmp", ",", "gen_rtx_AND", "(", "mmsk", ",", "gen_rtx_NOT", "(", "mmsk", ",", "xmsk", ")", ",", "gen_rtx_SUBREG", "(", "mmsk", ",", "xdst", ",", "0", ")", ")", ")", ";", "emit_move_insn", "(", "xdst", ",", "gen_rtx_SUBREG", "(", "mode", ",", "xtmp", ",", "0", ")", ")", ";", "emit_set_insn", "(", "xdst", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "src", ")", ")", ";", "}", "emit_set_insn", "(", "dst", ",", "gen_rtx_MULT", "(", "mode", ",", "xdst", ",", "x1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "instruction", "sequence", "to", "compute", "either", "the", "approximate", "square", "root", "or", "its", "approximate", "reciprocal", ",", "depending", "on", "the", "flag", "RECP", ",", "and", "return", "whether", "the", "sequence", "was", "emitted", "or", "not", "." ]

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

[]

[ "<s>", "bool", "TPCAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "int", "rs6000_psave_function_arg", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "align_words", ",", "rtx", "*", "rvec", ")", "{", "int", "k", "=", "0", ";", "if", "(", "align_words", "<", "GP_ARG_NUM_REG", ")", "{", "int", "n_words", "=", "rs6000_arg_size", "(", "mode", ",", "type", ")", ";", "if", "(", "align_words", "+", "n_words", ">", "GP_ARG_NUM_REG", "||", "mode", "==", "BLKmode", "||", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", ")", ")", "{", "machine_mode", "rmode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "int", "i", "=", "0", ";", "if", "(", "align_words", "+", "n_words", ">", "GP_ARG_NUM_REG", ")", "{", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "}", "do", "{", "rtx", "r", "=", "gen_rtx_REG", "(", "rmode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "rtx", "off", "=", "GEN_INT", "(", "i", "++", "*", "GET_MODE_SIZE", "(", "rmode", ")", ")", ";", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "r", ",", "off", ")", ";", "}", "while", "(", "++", "align_words", "<", "GP_ARG_NUM_REG", "&&", "--", "n_words", "!=", "0", ")", ";", "}", "else", "{", "rtx", "r", "=", "gen_rtx_REG", "(", "mode", ",", "GP_ARG_MIN_REG", "+", "align_words", ")", ";", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "r", ",", "const0_rtx", ")", ";", "}", "}", "else", "{", "rvec", "[", "k", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "}", "return", "k", ";", "}", "</s>" ]

[ "We", "have", "an", "argument", "of", "MODE", "and", "TYPE", "that", "goes", "into", "FPRs", "or", "VRs", ",", "but", "must", "also", "be", "copied", "into", "the", "parameter", "save", "area", "starting", "at", "offset", "ALIGN_WORDS", ".", "Fill", "in", "RVEC", "with", "the", "elements", "corresponding", "to", "the", "GPRs", "and/or", "memory", ".", "Return", "the", "number", "of", "elements", "used", "." ]

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

[]

[ "<s>", "static", "int", "rs6000_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "int", "ret", "=", "0", ";", "int", "align_words", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", ")", "return", "0", ";", "if", "(", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "type", ",", "named", ")", "&&", "cum", "->", "nargs_prototype", ">=", "0", ")", "return", "0", ";", "if", "(", "rs6000_darwin64_abi", "&&", "mode", "==", "BLKmode", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "0", ")", "return", "0", ";", "align_words", "=", "rs6000_parm_start", "(", "mode", ",", "type", ",", "cum", "->", "words", ")", ";", "if", "(", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ",", "type", ")", "&&", "!", "(", "type", "&&", "(", "cum", "->", "nargs_prototype", "<=", "0", "||", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "TARGET_XL_COMPAT", "&&", "align_words", ">=", "GP_ARG_NUM_REG", ")", ")", ")", ")", "{", "if", "(", "cum", "->", "fregno", "+", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", ">>", "3", ")", ">", "FP_ARG_MAX_REG", "+", "1", ")", "ret", "=", "(", "FP_ARG_MAX_REG", "+", "1", "-", "cum", "->", "fregno", ")", "*", "8", ";", "else", "if", "(", "cum", "->", "nargs_prototype", ">=", "0", ")", "return", "0", ";", "}", "if", "(", "align_words", "<", "GP_ARG_NUM_REG", "&&", "GP_ARG_NUM_REG", "<", "align_words", "+", "rs6000_arg_size", "(", "mode", ",", "type", ")", ")", "ret", "=", "(", "GP_ARG_NUM_REG", "-", "align_words", ")", "*", "(", "TARGET_32BIT", "?", "4", ":", "8", ")", ";", "if", "(", "ret", "!=", "0", "&&", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"rs6000_arg_partial_bytes: %d\\n\"", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "passed", "in", "registers", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "When", "an", "arg", "is", "described", "by", "a", "PARALLEL", ",", "perhaps", "using", "more", "than", "one", "register", "type", ",", "this", "function", "returns", "the", "number", "of", "bytes", "used", "by", "the", "first", "element", "of", "the", "PARALLEL", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "0", "7", "3", "1", "1", "8", "0", "0", "4", "8", "0", "\"rs6000_arg_partial_bytes: %d\\n\"" ]

[]

[ "<s>", "int", "call_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "call_address_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Call", "insn", "on", "SPARC", "can", "take", "a", "PC-relative", "constant", "address", ",", "or", "any", "regular", "memory", "address", "." ]

[ "arc", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "Register", "OutgoingValueHandler", "::", "extendRegister", "(", "Register", "ValReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "LLT", "LocTy", "{", "VA", ".", "getLocVT", "(", ")", "}", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "SExt", ":", "{", "return", "MIRBuilder", ".", "buildSExt", "(", "LocTy", ",", "ValReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "case", "CCValAssign", "::", "ZExt", ":", "{", "return", "MIRBuilder", ".", "buildZExt", "(", "LocTy", ",", "ValReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "case", "CCValAssign", "::", "AExt", ":", "{", "return", "MIRBuilder", ".", "buildAnyExt", "(", "LocTy", ",", "ValReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "case", "CCValAssign", "::", "Full", ":", "return", "ValReg", ";", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"unable to extend register\"", ")", ";", "}", "</s>" ]

[ "Extend", "a", "register", "to", "the", "location", "type", "given", "in", "VA", ",", "capped", "at", "extending", "to", "at", "most", "MaxSize", "bits", "." ]

[ "Mips", "0", "0", "0", "\"unable to extend register\"" ]

[]

[ "<s>", "void", "mips_conditional_register_usage", "(", "void", ")", "{", "if", "(", "!", "TARGET_DSP", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "DSP_ACC_REG_FIRST", ";", "regno", "<=", "DSP_ACC_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "for", "(", "regno", "=", "ST_REG_FIRST", ";", "regno", "<=", "ST_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "else", "if", "(", "!", "ISA_HAS_8CC", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "ST_REG_FIRST", ";", "regno", "<=", "ST_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "TARGET_MIPS16", ")", "{", "fixed_regs", "[", "18", "]", "=", "call_used_regs", "[", "18", "]", "=", "1", ";", "fixed_regs", "[", "19", "]", "=", "call_used_regs", "[", "19", "]", "=", "1", ";", "fixed_regs", "[", "20", "]", "=", "call_used_regs", "[", "20", "]", "=", "1", ";", "fixed_regs", "[", "21", "]", "=", "call_used_regs", "[", "21", "]", "=", "1", ";", "fixed_regs", "[", "22", "]", "=", "call_used_regs", "[", "22", "]", "=", "1", ";", "fixed_regs", "[", "23", "]", "=", "call_used_regs", "[", "23", "]", "=", "1", ";", "fixed_regs", "[", "26", "]", "=", "call_used_regs", "[", "26", "]", "=", "1", ";", "fixed_regs", "[", "27", "]", "=", "call_used_regs", "[", "27", "]", "=", "1", ";", "fixed_regs", "[", "30", "]", "=", "call_used_regs", "[", "30", "]", "=", "1", ";", "}", "if", "(", "mips_abi", "==", "ABI_64", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "FP_REG_FIRST", "+", "20", ";", "regno", "<", "FP_REG_FIRST", "+", "24", ";", "regno", "++", ")", "call_really_used_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "mips_abi", "==", "ABI_N32", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "FP_REG_FIRST", "+", "21", ";", "regno", "<=", "FP_REG_FIRST", "+", "31", ";", "regno", "+=", "2", ")", "call_really_used_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implement", "CONDITIONAL_REGISTER_USAGE", "." ]

[ "mips", "1", "1", "1", "1", "18", "18", "1", "19", "19", "1", "20", "20", "1", "21", "21", "1", "22", "22", "1", "23", "23", "1", "26", "26", "1", "27", "27", "1", "30", "30", "1", "20", "24", "1", "21", "31", "2", "1" ]

[]

[ "<s>", "const", "char", "*", "output_move_single", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "REG_P", "(", "dst", ")", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "\"mov %1,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "src", ")", ";", "if", "(", "CONST_OK_FOR_J", "(", "value", ")", ")", "return", "\"mov %1,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_K", "(", "value", ")", ")", "return", "\"movea lo(%1),%.,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_L", "(", "value", ")", ")", "return", "\"movhi hi(%1),%.,%0\"", ";", "else", "if", "(", "TARGET_V850E", ")", "return", "\"mov %1,%0\"", ";", "else", "return", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "src", ")", "==", "SFmode", ")", "{", "HOST_WIDE_INT", "high", ",", "low", ";", "const_double_split", "(", "src", ",", "&", "high", ",", "&", "low", ")", ";", "if", "(", "CONST_OK_FOR_J", "(", "high", ")", ")", "return", "\"mov %F1,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_K", "(", "high", ")", ")", "return", "\"movea lo(%F1),%.,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_L", "(", "high", ")", ")", "return", "\"movhi hi(%F1),%.,%0\"", ";", "else", "if", "(", "TARGET_V850E", ")", "return", "\"mov %F1,%0\"", ";", "else", "return", "\"movhi hi(%F1),%.,%0\\n\\tmovea lo(%F1),%0,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "return", "\"%S1ld%W1 %1,%0\"", ";", "else", "if", "(", "special_symbolref_operand", "(", "src", ",", "VOIDmode", ")", ")", "return", "\"movea %O1(%P1),%Q1,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "src", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "src", ")", "==", "CONST", ")", "{", "if", "(", "TARGET_V850E", ")", "return", "\"mov hilo(%1),%0\"", ";", "else", "return", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "HIGH", ")", "return", "\"movhi hi(%1),%.,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "LO_SUM", ")", "{", "operands", "[", "2", "]", "=", "XEXP", "(", "src", ",", "0", ")", ";", "operands", "[", "3", "]", "=", "XEXP", "(", "src", ",", "1", ")", ";", "return", "\"movea lo(%3),%2,%0\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "\"%S0st%W0 %1,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src", ")", "==", "0", ")", "return", "\"%S0st%W0 %.,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "CONST0_RTX", "(", "GET_MODE", "(", "dst", ")", ")", "==", "src", ")", "return", "\"%S0st%W0 %.,%0\"", ";", "}", "fatal_insn", "(", "\"output_move_single:\"", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "src", ")", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "appropriate", "code", "to", "load", "up", "a", "1", ",", "2", ",", "or", "4", "integer/floating", "point", "value", "." ]

[ "v850", "0", "1", "\"mov %1,%0\"", "\"mov %1,%0\"", "\"movea lo(%1),%.,%0\"", "\"movhi hi(%1),%.,%0\"", "\"mov %1,%0\"", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", "\"mov %F1,%0\"", "\"movea lo(%F1),%.,%0\"", "\"movhi hi(%F1),%.,%0\"", "\"mov %F1,%0\"", "\"movhi hi(%F1),%.,%0\\n\\tmovea lo(%F1),%0,%0\"", "\"%S1ld%W1 %1,%0\"", "\"movea %O1(%P1),%Q1,%0\"", "\"mov hilo(%1),%0\"", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", "\"movhi hi(%1),%.,%0\"", "2", "0", "3", "1", "\"movea lo(%3),%2,%0\"", "\"%S0st%W0 %1,%0\"", "0", "\"%S0st%W0 %.,%0\"", "\"%S0st%W0 %.,%0\"", "\"output_move_single:\"", "\"\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "TriCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "0" ]

[]

[ "<s>", "static", "unsigned", "selectBinaryOp", "(", "unsigned", "GenericOpc", ",", "unsigned", "RegBankID", ",", "unsigned", "OpSize", ")", "{", "switch", "(", "RegBankID", ")", "{", "case", "AArch64", "::", "GPRRegBankID", ":", "if", "(", "OpSize", "==", "32", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVWr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVWr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVWr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "else", "if", "(", "OpSize", "==", "64", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "AArch64", "::", "ADDXrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVXr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVXr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVXr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "break", ";", "case", "AArch64", "::", "FPRRegBankID", ":", "switch", "(", "OpSize", ")", "{", "case", "32", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDSrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBSrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULSrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVSrr", ";", "default", ":", "return", "GenericOpc", ";", "}", "case", "64", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDDrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBDrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULDrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVDrr", ";", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRv8i8", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "break", ";", "}", "return", "GenericOpc", ";", "}", "</s>" ]

[ "Select", "and", "emit", "code", "for", "a", "binary", "operator", "instruction", ",", "which", "has", "an", "opcode", "which", "directly", "corresponds", "to", "the", "given", "ISD", "opcode", "." ]

[ "AArch64", "AArch64::GPRRegBankID", "32", "AArch64::LSLVWr", "AArch64::LSRVWr", "AArch64::ASRVWr", "64", "AArch64::ADDXrr", "AArch64::LSLVXr", "AArch64::LSRVXr", "AArch64::ASRVXr", "AArch64::FPRRegBankID", "32", "AArch64::FADDSrr", "AArch64::FSUBSrr", "AArch64::FMULSrr", "AArch64::FDIVSrr", "64", "AArch64::FADDDrr", "AArch64::FSUBDrr", "AArch64::FMULDrr", "AArch64::FDIVDrr", "AArch64::ORRv8i8" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Opcode", ")", "&&", "!", "TII", "->", "get", "(", "Opcode", ")", ".", "mayStore", "(", ")", "&&", "!", "TII", "->", "isGather4", "(", "Opcode", ")", "&&", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "dmask", ")", "!=", "-", "1", ")", "{", "return", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "}", "if", "(", "Opcode", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Opcode", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "switch", "(", "Opcode", ")", "{", "case", "AMDGPU", "::", "V_DIV_SCALE_F32", ":", "case", "AMDGPU", "::", "V_DIV_SCALE_F64", ":", "{", "SDValue", "Src0", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Src1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ",", "Src0", ".", "getNode", "(", ")", "->", "isDivergent", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "Ops", "=", "{", "Src0", ",", "Src1", ",", "Src2", "}", ";", "for", "(", "unsigned", "I", "=", "3", ",", "N", "=", "Node", "->", "getNumOperands", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "I", ")", ")", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "1", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";", "}", "default", ":", "break", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::INSERT_SUBREG", "AMDGPU::REG_SEQUENCE", "AMDGPU::V_DIV_SCALE_F32", "AMDGPU::V_DIV_SCALE_F64", "0", "1", "2", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "AMDGPU::IMPLICIT_DEF", "4", "3", "1" ]

[]

[ "<s>", "bool", "mips_pad_reg_upward", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "type", "!=", "0", "?", "FLOAT_TYPE_P", "(", "type", ")", ":", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "!", "BYTES_BIG_ENDIAN", ";", "return", "mips_pad_arg_upward", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Likewise", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "...", ")", ".", "Return", "!", "BYTES_BIG_ENDIAN", "if", "the", "least", "significant", "byte", "of", "the", "register", "has", "useful", "data", ".", "Return", "the", "opposite", "if", "the", "most", "significant", "byte", "does", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "inline", "machine_mode", "get_mode_wider_vector", "(", "machine_mode", "o", ")", "{", "machine_mode", "n", "=", "GET_MODE_WIDER_MODE", "(", "o", ")", ".", "require", "(", ")", ";", "gcc_assert", "(", "GET_MODE_NUNITS", "(", "o", ")", "==", "GET_MODE_NUNITS", "(", "n", ")", "*", "2", ")", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "o", ")", "==", "GET_MODE_SIZE", "(", "n", ")", ")", ";", "return", "n", ";", "}", "</s>" ]

[ "Get", "a", "vector", "mode", "of", "the", "same", "size", "as", "the", "original", "but", "with", "elements", "twice", "as", "wide", ".", "This", "is", "only", "guaranteed", "to", "apply", "to", "integral", "vectors", "." ]

[ "i386", "2" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "bool", "Is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", ")", "{", "report_fatal_error", "(", "\"SSE register return with SSE disabled\"", ")", ";", "}", "if", "(", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP1", ")", "&&", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "CopyVT", "=", "MVT", "::", "f80", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "if", "(", "CopyVT", "!=", "VA", ".", "getValVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ")", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "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", "." ]

[ "X86", "X86", "ISD::InputArg", "16", "X86", "0", "MVT::f32", "MVT::f64", "\"SSE register return with SSE disabled\"", "X86::FP0", "X86::FP1", "MVT::f80", "1", "0", "ISD::FP_ROUND", "1", "2" ]

[]

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

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "CPUName", "=", "selectMipsCPU", "(", "TT", ",", "CPUName", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "TM", "->", "Options", ".", "UseSoftFloat", ")", "{", "TM", "->", "Options", ".", "UseSoftFloat", "=", "true", ";", "TM", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "InMips16HardFloat", "=", "true", ";", "}", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "assert", "(", "MipsABI", "!=", "UnknownABI", ")", ";", "assert", "(", "(", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureO32", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureEABI", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN32", ")", "!=", "0", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN64", ")", "!=", "0", ")", ")", "==", "1", ")", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "if", "(", "inMips16Mode", "(", ")", ")", "HasBitCount", "=", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::FeatureO32", "0", "Mips::FeatureEABI", "0", "Mips::FeatureN32", "0", "Mips::FeatureN64", "0", "1", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"linux\"", "Mips" ]

[]

[ "<s>", "bool", "addRegAssignmentFast", "(", ")", "override", "{", "llvm_unreachable", "(", "\"should not be used\"", ")", ";", "}", "</s>" ]

[ "Add", "core", "register", "alloator", "passes", "which", "do", "the", "actual", "register", "assignment", "and", "rewriting", "." ]

[ "NVPTX", "\"should not be used\"" ]

[]

[ "<s>", "void", "MipsTargetMachine", "::", "resetSubtarget", "(", "MachineFunction", "*", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"resetSubtarget\\n\"", ")", ";", "AttributeSet", "FnAttrs", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "bool", "Mips16Attr", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"mips16\"", ")", ";", "bool", "NoMips16Attr", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "\"nomips16\"", ")", ";", "assert", "(", "!", "(", "Mips16Attr", "&&", "NoMips16Attr", ")", "&&", "\"mips16 and nomips16 specified on the same function\"", ")", ";", "if", "(", "Mips16Attr", ")", "Subtarget", "=", "&", "Mips16Subtarget", ";", "else", "if", "(", "NoMips16Attr", ")", "Subtarget", "=", "&", "NoMips16Subtarget", ";", "else", "Subtarget", "=", "&", "DefaultSubtarget", ";", "return", ";", "}", "</s>" ]

[ "Reset", "the", "subtarget", "for", "the", "Mips", "target", "." ]

[ "Mips", "Mips", "\"resetSubtarget\\n\"", "Mips", "\"mips16\"", "Mips", "\"nomips16\"", "Mips", "Mips", "\"mips16 and nomips16 specified on the same function\"", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "ok_for_simple_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "visium_flags_exposed", "&&", "gpc_reg_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "gpc_reg_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "operands", "are", "valid", "for", "a", "simple", "move", "insn", "." ]

[ "visium", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "rtx", "frv_expand_int_void2arg", "(", "enum", "insn_code", "icode", ",", "tree", "call", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "long", "operands", "and", "return", "void", "." ]

[ "frv", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPUCFGStructurizer", "::", "isReturnBlock", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineInstr", "*", "MI", "=", "getReturnInstr", "(", "MBB", ")", ";", "bool", "IsReturn", "=", "(", "MBB", "->", "succ_size", "(", ")", "==", "0", ")", ";", "if", "(", "MI", ")", "assert", "(", "IsReturn", ")", ";", "else", "if", "(", "IsReturn", ")", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"BB\"", "<<", "MBB", "->", "getNumber", "(", ")", "<<", "\" is return block without RETURN instr\\n\"", ";", ")", ";", "return", "IsReturn", ";", "}", "</s>" ]

[ "Convenience", "function", "that", "returns", "true", "if", "the", "block", "ends", "in", "a", "return", "instruction", "." ]

[ "R600", "0", "\"BB\"", "\" is return block without RETURN instr\\n\"" ]

[]

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

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

[ "Sparc", "0" ]

[]

[ "<s>", "Optional", "<", "DestSourcePair", ">", "RISCVInstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCV", "::", "ADDI", ":", "if", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "break", ";", "case", "RISCV", "::", "FSGNJ_D", ":", "case", "RISCV", "::", "FSGNJ_S", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "break", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "RISCV", "RISCV", "0", "1", "RISCV::ADDI", "2", "2", "0", "0", "1", "RISCV::FSGNJ_D", "RISCV::FSGNJ_S", "1", "2", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugValue", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitPrologue\"", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "auto", "Store", "=", "MI", ";", "--", "Store", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "Store", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitPrologue\"" ]

[]

[ "<s>", "bool", "TMS320C64XAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "this", "->", "MF", "=", "&", "MF", ";", "Twine", "NewLine", "(", "\"\\n\"", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "EmitConstantPool", "(", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "\"\\n\\n\"", ")", ")", ";", "EmitAlignment", "(", "F", "->", "getAlignment", "(", ")", ",", "F", ")", ";", "EmitFunctionBodyStart", "(", ")", ";", "EmitFunctionHeader", "(", ")", ";", "MachineFunction", "::", "const_iterator", "MBB", ";", "for", "(", "MBB", "=", "MF", ".", "begin", "(", ")", ";", "MBB", "!=", "MF", ".", "end", "(", ")", ";", "++", "MBB", ")", "{", "OutStreamer", ".", "EmitRawText", "(", "NewLine", ")", ";", "printMBBInfo", "(", "MBB", ")", ";", "if", "(", "MBB", "!=", "MF", ".", "begin", "(", ")", ")", "{", "EmitBasicBlockStart", "(", "MBB", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "NewLine", ")", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ",", "ME", "=", "MBB", "->", "end", "(", ")", ";", "MI", "!=", "ME", ";", "++", "MI", ")", "{", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "case", "TMS320C64X", "::", "prolog", ":", "emit_prolog", "(", "MI", ")", ";", "break", ";", "case", "TMS320C64X", "::", "epilog", ":", "emit_epilog", "(", "MI", ")", ";", "break", ";", "default", ":", "MI", "=", "emit_instructions", "(", "std", "::", "make_pair", "(", "MI", ",", "MBB", "->", "end", "(", ")", ")", ")", ";", "break", ";", "}", "}", "}", "EmitJumpTableInfo", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "\"\\n\"", "\"\\n\\n\"", "TMS320C64X::prolog", "TMS320C64X::epilog" ]

[]

[ "<s>", "void", "TVMPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createTVMLowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createLowerSwitchPass", "(", ")", ")", ";", "addPass", "(", "createTVMLoopPrepare", "(", ")", ")", ";", "addPass", "(", "createTVMControlFlowPrepare", "(", ")", ")", ";", "addPass", "(", "createTVMDefineUndef", "(", ")", ")", ";", "addPass", "(", "createTVMReFuncPass", "(", ")", ")", ";", "addPass", "(", "createTVMStoreCombine", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "TVM", "TVM", "TVM", "TVM", "TVM", "TVM", "TVM", "TVM" ]

[]

[ "<s>", "static", "rtx_insn", "*", "mep_insert_repeat_label_last", "(", "rtx_insn", "*", "last_insn", ",", "rtx_code_label", "*", "label", ",", "bool", "including", ",", "bool", "shared", ")", "{", "rtx_insn", "*", "next", ",", "*", "prev", ";", "int", "count", "=", "0", ",", "code", ",", "icode", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"considering end of repeat loop at insn %d\\n\"", ",", "INSN_UID", "(", "last_insn", ")", ")", ";", "prev", "=", "last_insn", ";", "if", "(", "!", "including", ")", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "next", "=", "last_insn", ";", "if", "(", "!", "shared", ")", "while", "(", "prev", "!=", "0", ")", "{", "code", "=", "GET_CODE", "(", "prev", ")", ";", "if", "(", "code", "==", "CALL_INSN", "||", "code", "==", "CODE_LABEL", "||", "code", "==", "BARRIER", ")", "break", ";", "if", "(", "INSN_P", "(", "prev", ")", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "prev", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "PATTERN", "(", "prev", ")", ",", "0", ",", "1", ")", ")", ";", "icode", "=", "recog_memoized", "(", "prev", ")", ";", "if", "(", "icode", "<", "0", "||", "icode", "==", "CODE_FOR_repeat", "||", "icode", "==", "CODE_FOR_erepeat", "||", "get_attr_may_trap", "(", "prev", ")", "==", "MAY_TRAP_YES", ")", "break", ";", "if", "(", "GET_MODE", "(", "prev", ")", "!=", "BImode", ")", "{", "count", "++", ";", "next", "=", "prev", ";", "if", "(", "dump_file", ")", "print_rtl_single", "(", "dump_file", ",", "next", ")", ";", "if", "(", "count", "==", "2", ")", "break", ";", "}", "}", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "}", "prev", "=", "prev_real_insn", "(", "next", ")", ";", "if", "(", "prev", ")", "switch", "(", "recog_memoized", "(", "prev", ")", ")", "{", "case", "CODE_FOR_repeat", ":", "case", "CODE_FOR_erepeat", ":", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Adding nop inside loop\\n\"", ")", ";", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "next", ")", ";", "break", ";", "default", ":", "break", ";", "}", "emit_label_before", "(", "label", ",", "next", ")", ";", "if", "(", "dump_file", "&&", "count", "<", "2", ")", "fprintf", "(", "dump_file", ",", "\"Adding %d nop%s\\n\\n\"", ",", "2", "-", "count", ",", "count", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "for", "(", ";", "count", "<", "2", ";", "count", "++", ")", "if", "(", "including", ")", "last_insn", "=", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "last_insn", ")", ";", "else", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "last_insn", ")", ";", "return", "last_insn", ";", "}", "</s>" ]

[ "Figure", "out", "where", "to", "put", "LABEL", ",", "which", "is", "the", "label", "for", "a", "repeat", "loop", ".", "If", "INCLUDING", ",", "LAST_INSN", "is", "the", "last", "instruction", "in", "the", "loop", ",", "otherwise", "the", "loop", "ends", "just", "before", "LAST_INSN", ".", "If", "SHARED", ",", "insns", "other", "than", "the", "``", "repeat", "''", "might", "use", "LABEL", "to", "jump", "to", "the", "loop", "'s", "continuation", "point", ".", "Return", "the", "last", "instruction", "in", "the", "adjusted", "loop", "." ]

[ "mep", "0", "\"considering end of repeat loop at insn %d\\n\"", "0", "0", "1", "0", "2", "\"Adding nop inside loop\\n\"", "2", "\"Adding %d nop%s\\n\\n\"", "2", "1", "\"\"", "\"s\"", "2" ]

[]

[ "<s>", "MCGNode", "*", "getNode", "(", "const", "char", "*", "name", ")", "const", "{", "for", "(", "MCGNodes", "::", "const_iterator", "i", "(", "Nodes", ".", "begin", "(", ")", ")", ",", "ie", "(", "Nodes", ".", "end", "(", ")", ")", ";", "i", "!=", "ie", ";", "i", "++", ")", "{", "if", "(", "!", "(", "*", "i", ")", "->", "isUnknown", "(", ")", "&&", "(", "*", "i", ")", "->", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getName", "(", ")", "==", "name", ")", "return", "*", "i", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "getNode", "{" ]

[ "Patmos" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "char", "*", "SpillLibCall", "=", "getSpillLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "SpillLibCall", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoCALLReg", ")", ",", "RISCV", "::", "X5", ")", ".", "addExternalSymbol", "(", "SpillLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "MBB", ".", "addLiveIn", "(", "CS", ".", "getReg", "(", ")", ")", ";", "}", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "NonLibcallCSI", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV::PseudoCALLReg", "RISCV::X5", "RISCVII::MO_CALL" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isLdStPairSuppressed", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "llvm", "::", "any_of", "(", "MI", ".", "memoperands", "(", ")", ",", "[", "]", "(", "MachineMemOperand", "*", "MMO", ")", "{", "return", "MMO", "->", "getFlags", "(", ")", "&", "MOSuppressPair", ";", "}", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "is", "hinted", "to", "be", "unprofitable", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "InstructionCost", "PPCTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCostInst", "(", "Opcode", ",", "Idx", ",", "Imm", ",", "Ty", ",", "CostKind", ",", "Inst", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "bool", "ShiftedFree", "=", "false", ",", "RunFree", "=", "false", ",", "UnsignedFree", "=", "false", ",", "ZeroFree", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "RunFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ShiftedFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "UnsignedFree", "=", "true", ";", "ImmIdx", "=", "1", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Select", ":", "ZeroFree", "=", "true", ";", "break", ";", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "case", "Instruction", "::", "Store", ":", "break", ";", "}", "if", "(", "ZeroFree", "&&", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Idx", "==", "ImmIdx", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "RunFree", ")", "{", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "32", "&&", "(", "isShiftedMask_32", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_32", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ST", "->", "isPPC64", "(", ")", "&&", "(", "isShiftedMask_64", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_64", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "if", "(", "UnsignedFree", "&&", "isUInt", "<", "16", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ShiftedFree", "&&", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "PPCTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "PowerPC", "PPC", "PPC", "0", "0U", "0U", "0", "2", "1", "1", "0", "64", "16", "32", "PPC", "16", "0xFFFF", "0", "PPC" ]

[]

[ "<s>", "void", "Cpu0InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "bool", "isNodeHidden", "(", "const", "MCGNode", "*", "N", ",", "const", "MCallSubGraph", "G", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Do", "not", "print", "nodes", "that", "are", "part", "of", "a", "pi-block", "separately", "." ]

[ "Patmos" ]

[]

[ "<s>", "const", "MipsTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "MachineBasicBlock", "*", "HexagonHardwareLoops", "::", "findLoopPreheader", "(", "MachineLoop", "*", "L", ")", "const", "{", "if", "(", "MachineBasicBlock", "*", "PB", "=", "L", "->", "getLoopPreheader", "(", ")", ")", "return", "PB", ";", "if", "(", "!", "SpecPreheader", ")", "return", "nullptr", ";", "MachineBasicBlock", "*", "HB", "=", "L", "->", "getHeader", "(", ")", ",", "*", "LB", "=", "L", "->", "getLoopLatch", "(", ")", ";", "if", "(", "HB", "->", "pred_size", "(", ")", "!=", "2", "||", "HB", "->", "hasAddressTaken", "(", ")", ")", "return", "nullptr", ";", "MachineBasicBlock", "*", "Preheader", "=", "nullptr", ";", "for", "(", "MachineBasicBlock", "*", "P", ":", "HB", "->", "predecessors", "(", ")", ")", "{", "if", "(", "P", "==", "LB", ")", "continue", ";", "if", "(", "Preheader", ")", "return", "nullptr", ";", "Preheader", "=", "P", ";", "}", "for", "(", "MachineBasicBlock", "*", "S", ":", "Preheader", "->", "successors", "(", ")", ")", "{", "if", "(", "S", "==", "HB", ")", "continue", ";", "MachineLoop", "*", "T", "=", "MLI", "->", "getLoopFor", "(", "S", ")", ";", "if", "(", "T", "&&", "T", "->", "getHeader", "(", ")", "==", "S", ")", "return", "nullptr", ";", "}", "return", "Preheader", ";", "}", "</s>" ]

[ "Find", "the", "block", "that", "either", "is", "the", "loop", "preheader", ",", "or", "could", "speculatively", "be", "used", "as", "the", "preheader", "." ]

[ "Hexagon", "Hexagon", "2" ]

[]

[ "<s>", "void", "Finish", "(", ")", "{", "const", "size_t", "VendorHeaderSize", "=", "4", "+", "CurrentVendor", ".", "size", "(", ")", "+", "1", ";", "const", "size_t", "TagHeaderSize", "=", "1", "+", "4", ";", "Streamer", ".", "EmitIntValue", "(", "VendorHeaderSize", "+", "TagHeaderSize", "+", "ContentsSize", ",", "4", ")", ";", "Streamer", ".", "EmitBytes", "(", "CurrentVendor", ")", ";", "Streamer", ".", "EmitIntValue", "(", "0", ",", "1", ")", ";", "Streamer", ".", "EmitIntValue", "(", "ARMBuildAttrs", "::", "File", ",", "1", ")", ";", "Streamer", ".", "EmitIntValue", "(", "TagHeaderSize", "+", "ContentsSize", ",", "4", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "Contents", ".", "size", "(", ")", ";", "++", "i", ")", "{", "AttributeItemType", "item", "=", "Contents", "[", "i", "]", ";", "Streamer", ".", "EmitULEB128IntValue", "(", "item", ".", "Tag", ")", ";", "switch", "(", "item", ".", "Type", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid attribute type\"", ")", ";", "case", "AttributeItemType", "::", "NumericAttribute", ":", "Streamer", ".", "EmitULEB128IntValue", "(", "item", ".", "IntValue", ")", ";", "break", ";", "case", "AttributeItemType", "::", "TextAttribute", ":", "Streamer", ".", "EmitBytes", "(", "item", ".", "StringValue", ".", "upper", "(", ")", ")", ";", "Streamer", ".", "EmitIntValue", "(", "0", ",", "1", ")", ";", "break", ";", "}", "}", "Contents", ".", "clear", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "4", "1", "1", "4", "4", "0", "1", "ARMBuildAttrs::File", "1", "4", "0", "\"Invalid attribute type\"", "0", "1" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Z80", ")", ";", "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", "(", "Z80ISD", "::", "RET", ",", "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", "." ]

[ "Z80", "Z80", "ISD::OutputArg", "16", "Z80", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "Z80ISD::RET", "MVT::Other", "0" ]

[]

[ "<s>", "const", "Cpu0RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "!=", "-", "1", ")", "{", "AArch64CC", "::", "CondCode", "CC", "=", "(", "AArch64CC", "::", "CondCode", ")", "(", "int", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "AArch64CC", "::", "getInvertedCondCode", "(", "CC", ")", ")", ";", "}", "else", "{", "switch", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown conditional branch!\"", ")", ";", "case", "AArch64", "::", "CBZW", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "CBNZW", ")", ";", "break", ";", "case", "AArch64", "::", "CBNZW", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "CBZW", ")", ";", "break", ";", "case", "AArch64", "::", "CBZX", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "CBNZX", ")", ";", "break", ";", "case", "AArch64", "::", "CBNZX", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "CBZX", ")", ";", "break", ";", "case", "AArch64", "::", "TBZW", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "TBNZW", ")", ";", "break", ";", "case", "AArch64", "::", "TBNZW", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "TBZW", ")", ";", "break", ";", "case", "AArch64", "::", "TBZX", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "TBNZX", ")", ";", "break", ";", "case", "AArch64", "::", "TBNZX", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "AArch64", "::", "TBZX", ")", ";", "break", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "AArch64", "AArch64", "0", "1", "AArch64CC::CondCode", "AArch64CC::CondCode", "0", "0", "AArch64CC::getInvertedCondCode", "1", "\"Unknown conditional branch!\"", "AArch64::CBZW", "1", "AArch64::CBNZW", "AArch64::CBNZW", "1", "AArch64::CBZW", "AArch64::CBZX", "1", "AArch64::CBNZX", "AArch64::CBNZX", "1", "AArch64::CBZX", "AArch64::TBZW", "1", "AArch64::TBNZW", "AArch64::TBNZW", "1", "AArch64::TBZW", "AArch64::TBZX", "1", "AArch64::TBNZX", "AArch64::TBNZX", "1", "AArch64::TBZX" ]

[]

[ "<s>", "void", "dump", "(", "const", "GCNRegBankReassign", "*", "P", ")", "const", "{", "dbgs", "(", ")", "<<", "\"\\nCandidates:\\n\\n\"", ";", "for", "(", "auto", "&", "B", ":", "*", "this", ")", "{", "dbgs", "(", ")", "<<", "\" Weight \"", "<<", "B", ".", "first", "<<", "\":\\n\"", ";", "for", "(", "auto", "&", "C", ":", "B", ".", "second", ")", "C", ".", "dump", "(", "P", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\\n\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"\\nCandidates:\\n\\n\"", "\" Weight \"", "\":\\n\"", "\"\\n\\n\"" ]

[]

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

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

[ "TOY", "TOY" ]

[]

[ "<s>", "rtx", "function_expander", "::", "map_to_unspecs", "(", "int", "unspec_for_sint", ",", "int", "unspec_for_uint", ",", "int", "unspec_for_fp", ",", "unsigned", "int", "merge_argno", ")", "{", "machine_mode", "mode", "=", "vector_mode", "(", "0", ")", ";", "int", "unspec", "=", "(", "!", "type_suffix", "(", "0", ")", ".", "integer_p", "?", "unspec_for_fp", ":", "type_suffix", "(", "0", ")", ".", "unsigned_p", "?", "unspec_for_uint", ":", "unspec_for_sint", ")", ";", "if", "(", "pred", "==", "PRED_x", ")", "{", "insn_code", "icode", "=", "maybe_code_for_aarch64_pred", "(", "unspec", ",", "mode", ")", ";", "if", "(", "icode", "!=", "CODE_FOR_nothing", ")", "return", "use_pred_x_insn", "(", "icode", ")", ";", "}", "if", "(", "pred", "==", "PRED_none", "||", "pred", "==", "PRED_x", ")", "{", "insn_code", "icode", "=", "maybe_code_for_aarch64_sve", "(", "unspec", ",", "mode", ")", ";", "if", "(", "icode", "!=", "CODE_FOR_nothing", ")", "return", "use_unpred_insn", "(", "icode", ")", ";", "}", "insn_code", "icode", "=", "code_for_cond", "(", "unspec", ",", "vector_mode", "(", "0", ")", ")", ";", "return", "use_cond_insn", "(", "icode", ",", "merge_argno", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "one", "of", "the", "following", "strategies", ",", "chosen", "in", "order", ":", "(", "1", ")", "``", "aarch64_pred_", "<", "optab", ">", "<", "mode", ">", "''", "for", "PRED_x", "functions", ";", "this", "is", "a", "predicated", "pattern", "(", "2", ")", "``", "aarch64_sve_", "<", "optab", ">", "<", "mode", ">", "''", "for", "PRED_none", "and", "PRED_x", "functions", ";", "this", "is", "an", "unpredicated", "pattern", "(", "3", ")", "``", "cond_", "<", "optab", ">", "<", "mode", ">", "''", "otherwise", "where", "<", "optab", ">", "corresponds", "to", ":", "-", "UNSPEC_FOR_SINT", "for", "signed", "integers", "-", "UNSPEC_FOR_UINT", "for", "unsigned", "integers", "-", "UNSPEC_FOR_FP", "for", "floating-point", "values", "MERGE_ARGNO", "is", "the", "argument", "that", "provides", "the", "values", "of", "inactive", "lanes", "for", "_m", "functions", ",", "or", "DEFAULT_MERGE_ARGNO", "if", "we", "should", "apply", "the", "usual", "rules", "." ]

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

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "AArch64RegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AArch64", "::", "GPR64RegClass", ";", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Entry", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "\"Function should be nounwind in insertCopiesSplitCSR!\"", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Unexpected register class in CSRsViaCopy!\"", "\"Function should be nounwind in insertCopiesSplitCSR!\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "SystemZTargetLowering", "::", "getRepRegClassFor", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "Untyped", ")", "return", "&", "SystemZ", "::", "ADDR128BitRegClass", ";", "return", "TargetLowering", "::", "getRepRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "'representative", "'", "register", "class", "for", "the", "specified", "value", "type", "." ]

[ "SystemZ", "SystemZ", "MVT::Untyped", "SystemZ::ADDR128BitRegClass" ]

[]

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

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "SNESAsmParser", "::", "ParseDirective", "(", "llvm", "::", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "SNES", "SNES" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"NIOS2 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Nios2", "\"NIOS2 DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableRDFOpt", ")", "addPass", "(", "createHexagonRDFOpt", "(", ")", ")", ";", "if", "(", "!", "DisableHexagonCFGOpt", ")", "addPass", "(", "createHexagonCFGOptimizer", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

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

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

[]