Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "finish", "(", ")", "override", "{", "for", "(", "auto", "*", "Sym", ":", "UpdateOther", ")", "if", "(", "Sym", "->", "isVariable", "(", ")", ")", "copyLocalEntry", "(", "Sym", ",", "Sym", "->", "getVariableValue", "(", ")", ")", ";", "UpdateOther", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "PowerPC" ]

[]

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

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MF", ".", "hasEHFunclets", "(", ")", ")", "return", "true", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "return", "true", ";", "if", "(", "!", "MFI", ".", "isMaxCallFrameSizeComputed", "(", ")", "||", "MFI", ".", "getMaxCallFrameSize", "(", ")", ">", "DefaultSafeSPDisplacement", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "SIC" ]

[]

[ "<s>", "static", "bool", "v850_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "10", ")", ";", "}", "</s>" ]

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

[ "v850", "10" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "MOSTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'a'", ":", "case", "'x'", ":", "case", "'y'", ":", "case", "'d'", ":", "return", "C_Register", ";", "case", "'R'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "MOS", "MOS", "1", "0" ]

[]

[ "<s>", "static", "void", "mips_expand_to_rtl_hook", "(", "void", ")", "{", "mips_set_tuning_info", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_TO_RTL_HOOK", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "!", "TargetSupported", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "selectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "selectStore", "(", "I", ")", ";", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "return", "selectLogicalOp", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "selectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "selectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "selectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "selectIntExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "selectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "selectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPToSI", ":", "return", "selectFPToInt", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "selectFPToInt", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "selectCmp", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "const", "MCExpr", "*", "X86_64MachoTargetObjectFile", "::", "getTTypeGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "Mangler", "*", "Mang", ",", "MachineModuleInfo", "*", "MMI", ",", "unsigned", "Encoding", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "if", "(", "Encoding", "&", "(", "DW_EH_PE_indirect", "|", "DW_EH_PE_pcrel", ")", ")", "{", "const", "MCSymbol", "*", "Sym", "=", "Mang", "->", "getSymbol", "(", "GV", ")", ";", "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOTPCREL", ",", "getContext", "(", ")", ")", ";", "const", "MCExpr", "*", "Four", "=", "MCConstantExpr", "::", "Create", "(", "4", ",", "getContext", "(", ")", ")", ";", "return", "MCBinaryExpr", "::", "CreateAdd", "(", "Res", ",", "Four", ",", "getContext", "(", ")", ")", ";", "}", "return", "TargetLoweringObjectFileMachO", "::", "getTTypeGlobalReference", "(", "GV", ",", "Mang", ",", "MMI", ",", "Encoding", ",", "Streamer", ")", ";", "}", "</s>" ]

[ "The", "mach-o", "version", "of", "this", "method", "defaults", "to", "returning", "a", "stub", "reference", "." ]

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

[]

[ "<s>", "int", "getOffset", "(", ")", "const", "{", "return", "Offset", ";", "}", "</s>" ]

[ "Get", "the", "offest", "of", "a", "string", "in", "the", "string", "table", "." ]

[ "Mips" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "&", "Op", "=", "static_cast", "<", "ARMOperand", "&", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__35_0", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ModImm", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", ".", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "EvaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "INT32_MIN", "&&", "Value", "<=", "UINT32_MAX", ")", "&&", "\"expression value must be representable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", ".", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "\"expression value must be representable in 32 bits\"", "ARM::GPRRegClassID" ]

[]

[ "<s>", "bool", "enableMachineScheduler", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "SystemZ" ]

[]

[ "<s>", "unsigned", "TPCInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "!", "FBB", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "NewTBB", ",", "*", "NewFBB", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "aCond", ";", "auto", "Term", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "Term", "!=", "MBB", ".", "end", "(", ")", "&&", "isPredicated", "(", "*", "Term", ")", "&&", "!", "analyzeBranch", "(", "MBB", ",", "NewTBB", ",", "NewFBB", ",", "aCond", ",", "false", ")", "&&", "MachineFunction", "::", "iterator", "(", "NewTBB", ")", "==", "++", "MBB", ".", "getIterator", "(", ")", ")", "{", "reverseBranchCondition", "(", "aCond", ")", ";", "removeBranch", "(", "MBB", ")", ";", "return", "insertBranch", "(", "MBB", ",", "TBB", ",", "nullptr", ",", "aCond", ",", "DL", ")", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "TPC", "::", "JMPR_u", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", "&&", "\"Malformed cond vector\"", ")", ";", "const", "MachineOperand", "&", "RO", "=", "Cond", "[", "0", "]", ";", "unsigned", "Flags", "=", "getUndefRegState", "(", "RO", ".", "isUndef", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "TPC", "::", "JMPR", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addReg", "(", "RO", ".", "getReg", "(", ")", ",", "Flags", ")", ".", "addImm", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ")", ";", "}", "return", "1", ";", "}", "assert", "(", "(", "!", "Cond", ".", "empty", "(", ")", ")", "&&", "\"Cond. cannot be empty when multiple branchings are required\"", ")", ";", "const", "MachineOperand", "&", "RO", "=", "Cond", "[", "0", "]", ";", "unsigned", "Flags", "=", "getUndefRegState", "(", "RO", ".", "isUndef", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "TPC", "::", "JMPR", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addReg", "(", "RO", ".", "getReg", "(", ")", ",", "Flags", ")", ".", "addImm", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "TPC", "::", "JMPR_u", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "TPC", "TPC", "\"insertBranch must not be told to insert a fallthrough\"", "\"code size not handled\"", "4", "TPC::JMPR_u", "2", "\"Malformed cond vector\"", "0", "TPC::JMPR", "1", "1", "\"Cond. cannot be empty when multiple branchings are required\"", "0", "TPC::JMPR", "1", "TPC::JMPR_u", "2" ]

[]

[ "<s>", "unsigned", "GCNHazardRecognizer", "::", "PreEmitNoops", "(", "MachineInstr", "*", "MI", ")", "{", "IsHazardRecognizerMode", "=", "true", ";", "CurrCycleInstr", "=", "MI", ";", "unsigned", "W", "=", "PreEmitNoopsCommon", "(", "MI", ")", ";", "fixHazards", "(", "MI", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "return", "W", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "ia64_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "sdiv_optab", ",", "SImode", ",", "\"__divsi3\"", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "SImode", ",", "\"__udivsi3\"", ")", ";", "set_optab_libfunc", "(", "smod_optab", ",", "SImode", ",", "\"__modsi3\"", ")", ";", "set_optab_libfunc", "(", "umod_optab", ",", "SImode", ",", "\"__umodsi3\"", ")", ";", "set_optab_libfunc", "(", "add_optab", ",", "TFmode", ",", "\"_U_Qfadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "TFmode", ",", "\"_U_Qfsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "TFmode", ",", "\"_U_Qfmpy\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "TFmode", ",", "\"_U_Qfdiv\"", ")", ";", "set_optab_libfunc", "(", "neg_optab", ",", "TFmode", ",", "\"_U_Qfneg\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "SFmode", ",", "\"_U_Qfcnvff_sgl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "DFmode", ",", "\"_U_Qfcnvff_dbl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TFmode", ",", "XFmode", ",", "\"_U_Qfcnvff_f80_to_quad\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "TFmode", ",", "\"_U_Qfcnvff_quad_to_sgl\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DFmode", ",", "TFmode", ",", "\"_U_Qfcnvff_quad_to_dbl\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "XFmode", ",", "TFmode", ",", "\"_U_Qfcnvff_quad_to_f80\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "TFmode", ",", "\"_U_Qfcnvfxt_quad_to_sgl\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "DImode", ",", "TFmode", ",", "\"_U_Qfcnvfxt_quad_to_dbl\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "TImode", ",", "TFmode", ",", "\"_U_Qfcnvfxt_quad_to_quad\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "SImode", ",", "TFmode", ",", "\"_U_Qfcnvfxut_quad_to_sgl\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "DImode", ",", "TFmode", ",", "\"_U_Qfcnvfxut_quad_to_dbl\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "SImode", ",", "\"_U_Qfcnvxf_sgl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "DImode", ",", "\"_U_Qfcnvxf_dbl_to_quad\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "TFmode", ",", "TImode", ",", "\"_U_Qfcnvxf_quad_to_quad\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "TFmode", ",", "DImode", ",", "\"_U_Qfcnvxuf_dbl_to_quad\"", ")", ";", "}", "</s>" ]

[ "Set", "SImode", "div/mod", "functions", ",", "init_integral_libfuncs", "only", "initializes", "modes", "of", "word_mode", "and", "larger", ".", "Rename", "the", "TFmode", "libfuncs", "using", "the", "HPUX", "conventions", ".", "__divtf3", "is", "used", "for", "XFmode", ".", "We", "need", "to", "keep", "it", "for", "backward", "compatibility", "." ]

[ "ia64", "\"__divsi3\"", "\"__udivsi3\"", "\"__modsi3\"", "\"__umodsi3\"", "\"_U_Qfadd\"", "\"_U_Qfsub\"", "\"_U_Qfmpy\"", "\"_U_Qfdiv\"", "\"_U_Qfneg\"", "\"_U_Qfcnvff_sgl_to_quad\"", "\"_U_Qfcnvff_dbl_to_quad\"", "\"_U_Qfcnvff_f80_to_quad\"", "\"_U_Qfcnvff_quad_to_sgl\"", "\"_U_Qfcnvff_quad_to_dbl\"", "\"_U_Qfcnvff_quad_to_f80\"", "\"_U_Qfcnvfxt_quad_to_sgl\"", "\"_U_Qfcnvfxt_quad_to_dbl\"", "\"_U_Qfcnvfxt_quad_to_quad\"", "\"_U_Qfcnvfxut_quad_to_sgl\"", "\"_U_Qfcnvfxut_quad_to_dbl\"", "\"_U_Qfcnvxf_sgl_to_quad\"", "\"_U_Qfcnvxf_dbl_to_quad\"", "\"_U_Qfcnvxf_quad_to_quad\"", "\"_U_Qfcnvxuf_dbl_to_quad\"" ]

[]

[ "<s>", "StringRef", "HexagonMCInstrInfo", "::", "getName", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "return", "MCII", ".", "getName", "(", "MCI", ".", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "ARMDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_Um", ":", "case", "InlineAsm", "::", "Constraint_Un", ":", "case", "InlineAsm", "::", "Constraint_Uq", ":", "case", "InlineAsm", "::", "Constraint_Us", ":", "case", "InlineAsm", "::", "Constraint_Ut", ":", "case", "InlineAsm", "::", "Constraint_Uv", ":", "case", "InlineAsm", "::", "Constraint_Uy", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FPTOSI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_FPTOUI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SHUFFLE_VECTOR", ":", "return", "legalizeShuffleVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "MI", ",", "MRI", ",", "B", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "legalizeFDIV", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "return", "legalizeAtomicCmpXChg", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FLOG", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "1.0f", "/", "numbers", "::", "log2ef", ")", ";", "case", "TargetOpcode", "::", "G_FLOG10", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "numbers", "::", "ln2f", "/", "numbers", "::", "ln10f", ")", ";", "case", "TargetOpcode", "::", "G_FEXP", ":", "return", "legalizeFExp", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FFLOOR", ":", "return", "legalizeFFloor", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "return", "legalizeBuildVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "SI", "1.0f", "\"expected switch to return\"" ]

[]

[ "<s>", "bool", "ix86_expand_pinsr", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "3", "]", ";", "unsigned", "int", "size", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "unsigned", "int", "pos", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "GET_CODE", "(", "dst", ")", "==", "SUBREG", ")", "{", "pos", "+=", "SUBREG_BYTE", "(", "dst", ")", "*", "BITS_PER_UNIT", ";", "dst", "=", "SUBREG_REG", "(", "dst", ")", ";", "}", "if", "(", "GET_CODE", "(", "src", ")", "==", "SUBREG", ")", "src", "=", "SUBREG_REG", "(", "src", ")", ";", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "V16QImode", ":", "case", "V8HImode", ":", "case", "V4SImode", ":", "case", "V2DImode", ":", "{", "machine_mode", "srcmode", ",", "dstmode", ";", "rtx", "(", "*", "pinsr", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "srcmode", "=", "mode_for_size", "(", "size", ",", "MODE_INT", ",", "0", ")", ";", "switch", "(", "srcmode", ")", "{", "case", "QImode", ":", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "dstmode", "=", "V16QImode", ";", "pinsr", "=", "gen_sse4_1_pinsrb", ";", "break", ";", "case", "HImode", ":", "if", "(", "!", "TARGET_SSE2", ")", "return", "false", ";", "dstmode", "=", "V8HImode", ";", "pinsr", "=", "gen_sse2_pinsrw", ";", "break", ";", "case", "SImode", ":", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "dstmode", "=", "V4SImode", ";", "pinsr", "=", "gen_sse4_1_pinsrd", ";", "break", ";", "case", "DImode", ":", "gcc_assert", "(", "TARGET_64BIT", ")", ";", "if", "(", "!", "TARGET_SSE4_1", ")", "return", "false", ";", "dstmode", "=", "V2DImode", ";", "pinsr", "=", "gen_sse4_1_pinsrq", ";", "break", ";", "default", ":", "return", "false", ";", "}", "rtx", "d", "=", "dst", ";", "if", "(", "GET_MODE", "(", "dst", ")", "!=", "dstmode", ")", "d", "=", "gen_reg_rtx", "(", "dstmode", ")", ";", "src", "=", "gen_lowpart", "(", "srcmode", ",", "src", ")", ";", "pos", "/=", "size", ";", "emit_insn", "(", "pinsr", "(", "d", ",", "gen_lowpart", "(", "dstmode", ",", "dst", ")", ",", "src", ",", "GEN_INT", "(", "1", "<<", "pos", ")", ")", ")", ";", "if", "(", "d", "!=", "dst", ")", "emit_move_insn", "(", "dst", ",", "gen_lowpart", "(", "GET_MODE", "(", "dst", ")", ",", "d", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Expand", "an", "insert", "into", "a", "vector", "register", "through", "pinsr", "insn", ".", "Return", "true", "if", "successful", "." ]

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

[]

[ "<s>", "static", "bool", "cmse_func_args_or_return_in_stack", "(", "tree", "fndecl", ",", "tree", "name", ",", "tree", "fntype", ")", "{", "function_args_iterator", "args_iter", ";", "CUMULATIVE_ARGS", "args_so_far_v", ";", "cumulative_args_t", "args_so_far", ";", "bool", "first_param", "=", "true", ";", "tree", "arg_type", ",", "prev_arg_type", "=", "NULL_TREE", ",", "ret_type", ";", "arm_init_cumulative_args", "(", "&", "args_so_far_v", ",", "fntype", ",", "NULL_RTX", ",", "fndecl", ")", ";", "args_so_far", "=", "pack_cumulative_args", "(", "&", "args_so_far_v", ")", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "arg_type", ",", "args_iter", ")", "{", "rtx", "arg_rtx", ";", "prev_arg_type", "=", "arg_type", ";", "if", "(", "VOID_TYPE_P", "(", "arg_type", ")", ")", "continue", ";", "function_arg_info", "arg", "(", "arg_type", ",", "true", ")", ";", "if", "(", "!", "first_param", ")", "arm_function_arg_advance", "(", "args_so_far", ",", "arg", ")", ";", "arg_rtx", "=", "arm_function_arg", "(", "args_so_far", ",", "arg", ")", ";", "if", "(", "!", "arg_rtx", "||", "arm_arg_partial_bytes", "(", "args_so_far", ",", "arg", ")", ")", "{", "error", "(", "\"%qE attribute not available to functions with arguments \"", "\"passed on the stack\"", ",", "name", ")", ";", "return", "true", ";", "}", "first_param", "=", "false", ";", "}", "if", "(", "prev_arg_type", "!=", "NULL_TREE", "&&", "!", "VOID_TYPE_P", "(", "prev_arg_type", ")", ")", "{", "error", "(", "\"%qE attribute not available to functions with variable number \"", "\"of arguments\"", ",", "name", ")", ";", "return", "true", ";", "}", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "if", "(", "arm_return_in_memory", "(", "ret_type", ",", "fntype", ")", ")", "{", "error", "(", "\"%qE attribute not available to functions that return value on \"", "\"the stack\"", ",", "name", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "a", "function", "with", "declaration", "FNDECL", "and", "type", "FNTYPE", "uses", "the", "stack", "to", "pass", "arguments", "or", "return", "variables", "and", "false", "otherwise", ".", "This", "is", "used", "for", "functions", "with", "the", "attributes", "'cmse_nonsecure_call", "'", "or", "'cmse_nonsecure_entry", "'", "and", "this", "function", "will", "issue", "diagnostic", "messages", "if", "the", "stack", "is", "used", ".", "NAME", "is", "the", "name", "of", "the", "attribute", "used", "." ]

[ "arm", "\"%qE attribute not available to functions with arguments \"", "\"passed on the stack\"", "\"%qE attribute not available to functions with variable number \"", "\"of arguments\"", "\"%qE attribute not available to functions that return value on \"", "\"the stack\"" ]

[]

[ "<s>", "DecodeStatus", "AMDGPUDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes_", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "WS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "CommentStream", "=", "&", "CS", ";", "bool", "IsSDWA", "=", "false", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "AMDGPU", "::", "FeatureGCN3Encoding", "]", ")", "report_fatal_error", "(", "\"Disassembly not yet supported for subtarget\"", ")", ";", "const", "unsigned", "MaxInstBytesNum", "=", "(", "std", "::", "min", ")", "(", "(", "size_t", ")", "8", ",", "Bytes_", ".", "size", "(", ")", ")", ";", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "DecodeStatus", "Res", "=", "MCDisassembler", "::", "Fail", ";", "do", "{", "if", "(", "Bytes", ".", "size", "(", ")", ">=", "8", ")", "{", "const", "uint64_t", "QW", "=", "eatBytes", "<", "uint64_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableDPP64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "{", "IsSDWA", "=", "true", ";", "break", ";", "}", "Res", "=", "tryDecodeInst", "(", "DecoderTableSDWA964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "{", "IsSDWA", "=", "true", ";", "break", ";", "}", "}", "Bytes", "=", "Bytes_", ".", "slice", "(", "0", ",", "MaxInstBytesNum", ")", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint32_t", "DW", "=", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU32", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableGFX932", ",", "MI", ",", "DW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "break", ";", "const", "uint64_t", "QW", "=", "(", "(", "uint64_t", ")", "eatBytes", "<", "uint32_t", ">", "(", "Bytes", ")", "<<", "32", ")", "|", "DW", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableVI64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableAMDGPU64", ",", "MI", ",", "QW", ",", "Address", ")", ";", "if", "(", "Res", ")", "break", ";", "Res", "=", "tryDecodeInst", "(", "DecoderTableGFX964", ",", "MI", ",", "QW", ",", "Address", ")", ";", "}", "while", "(", "false", ")", ";", "if", "(", "Res", "&&", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_vi", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F32_e64_si", "||", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MAC_F16_e64_vi", ")", ")", "{", "insertNamedMCOperand", "(", "MI", ",", "MCOperand", "::", "createImm", "(", "0", ")", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "}", "if", "(", "Res", "&&", "IsSDWA", ")", "Res", "=", "convertSDWAInst", "(", "MI", ")", ";", "Size", "=", "Res", "?", "(", "MaxInstBytesNum", "-", "Bytes", ".", "size", "(", ")", ")", ":", "0", ";", "return", "Res", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::FeatureGCN3Encoding", "\"Disassembly not yet supported for subtarget\"", "8", "0", "8", "0", "4", "AMDGPU", "4", "32", "AMDGPU", "AMDGPU::V_MAC_F32_e64_vi", "AMDGPU::V_MAC_F32_e64_si", "AMDGPU::V_MAC_F16_e64_vi", "0", "AMDGPU::OpName", "0" ]

[]

[ "<s>", "static", "int", "frv_registers_conflict_p_1", "(", "rtx", "*", "x", ",", "void", "*", "data", ")", "{", "unsigned", "int", "regno", ",", "i", ";", "regstate_t", "cond", ";", "cond", "=", "*", "(", "regstate_t", "*", ")", "data", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "REG", ")", "FOR_EACH_REGNO", "(", "regno", ",", "*", "x", ")", "if", "(", "(", "frv_packet", ".", "regstate", "[", "regno", "]", "&", "REGSTATE_MODIFIED", ")", "!=", "0", ")", "if", "(", "frv_regstate_conflict_p", "(", "frv_packet", ".", "regstate", "[", "regno", "]", ",", "cond", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "MEM", ")", "{", "if", "(", "frv_packet", ".", "num_mems", ">", "ARRAY_SIZE", "(", "frv_packet", ".", "mems", ")", ")", "return", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "frv_packet", ".", "num_mems", ";", "i", "++", ")", "if", "(", "frv_regstate_conflict_p", "(", "frv_packet", ".", "mems", "[", "i", "]", ".", "cond", ",", "cond", ")", ")", "{", "if", "(", "true_dependence", "(", "frv_packet", ".", "mems", "[", "i", "]", ".", "mem", ",", "VOIDmode", ",", "*", "x", ",", "rtx_varies_p", ")", ")", "return", "1", ";", "if", "(", "output_dependence", "(", "frv_packet", ".", "mems", "[", "i", "]", ".", "mem", ",", "*", "x", ")", ")", "return", "1", ";", "}", "}", "if", "(", "GET_CODE", "(", "*", "x", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "*", "x", ")", ")", "==", "CALL", ")", "{", "if", "(", "for_each_rtx", "(", "&", "SET_SRC", "(", "*", "x", ")", ",", "frv_registers_conflict_p_1", ",", "data", ")", ")", "return", "1", ";", "return", "-", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "A", "for_each_rtx", "callback", ".", "Return", "1", "if", "*", "X", "depends", "on", "an", "instruction", "in", "the", "current", "packet", ".", "DATA", "points", "to", "a", "regstate_t", "that", "describes", "the", "condition", "under", "which", "*", "X", "might", "be", "set", "or", "used", "." ]

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

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"RISCV branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoBR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Opc", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "MachineInstr", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "if", "(", "!", "FBB", ")", "return", "1", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoBR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "RI5CY", "RISCV", "0", "\"insertBranch must not be told to insert a fallthrough\"", "3", "0", "\"RISCV branch conditions have two components!\"", "RISCV::PseudoBR", "1", "0", "1", "2", "1", "RISCV::PseudoBR", "2" ]

[]

[ "<s>", "InstructionCost", "RISCVTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "auto", "*", "RetTy", "=", "ICA", ".", "getReturnType", "(", ")", ";", "switch", "(", "ICA", ".", "getID", "(", ")", ")", "{", "case", "Intrinsic", "::", "experimental_stepvector", ":", "{", "unsigned", "Cost", "=", "1", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "RetTy", ")", ";", "return", "Cost", "+", "(", "LT", ".", "first", "-", "1", ")", ";", "}", "default", ":", "break", ";", "}", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "RISCV", "RISCV", "Intrinsic::experimental_stepvector", "1", "1" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "&&", "\"X86-64 PIC uses RIP relative addressing\"", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "X86FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MBBI", "!=", "FirstMBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "PC", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOVPC32r", ")", ",", "PC", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "{", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "X86", "::", "GR32RegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "ADD32ri", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "PC", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "0", ",", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", ";", "}", "else", "{", "GlobalBaseReg", "=", "PC", ";", "}", "X86FI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"X86-64 PIC uses RIP relative addressing\"", "X86", "X86", "X86", "X86", "0", "X86::GR32RegisterClass", "X86::MOVPC32r", "0", "X86", "X86::GR32RegisterClass", "X86::ADD32ri", "\"_GLOBAL_OFFSET_TABLE_\"", "0", "X86II::MO_GOT_ABSOLUTE_ADDRESS", "X86" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "fnmask", ";", "if", "(", "code", ">=", "RS6000_BUILTIN_COUNT", ")", "return", "error_mark_node", ";", "fnmask", "=", "rs6000_builtin_info", "[", "code", "]", ".", "mask", ";", "if", "(", "(", "fnmask", "&", "rs6000_builtin_mask", ")", "!=", "fnmask", ")", "{", "rs6000_invalid_builtin", "(", "(", "enum", "rs6000_builtins", ")", "code", ")", ";", "return", "error_mark_node", ";", "}", "return", "rs6000_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Returns", "the", "rs6000", "builtin", "decl", "for", "CODE", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "shouldScheduleLoadsNear", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "Offset1", ",", "int64_t", "Offset2", ",", "unsigned", "NumLoads", ")", "const", "{", "assert", "(", "Offset2", ">", "Offset1", "&&", "\"Second offset should be larger than first offset!\"", ")", ";", "return", "(", "NumLoads", "<", "16", "&&", "(", "Offset2", "-", "Offset1", ")", "<", "16", ")", ";", "}", "</s>" ]

[ "shouldScheduleLoadsNear", "-", "This", "is", "a", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "(", "in", "conjunction", "with", "areLoadsFromSameBasePtr", ")", "if", "two", "loads", "should", "be", "scheduled", "togther", "." ]

[ "R600", "\"Second offset should be larger than first offset!\"", "16", "16" ]

[]

[ "<s>", "AliasResult", "AMDGPUAAResult", "::", "alias", "(", "const", "MemoryLocation", "&", "LocA", ",", "const", "MemoryLocation", "&", "LocB", ",", "AAQueryInfo", "&", "AAQI", ")", "{", "unsigned", "asA", "=", "LocA", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "unsigned", "asB", "=", "LocB", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "AliasResult", "Result", "=", "getAliasResult", "(", "asA", ",", "asB", ")", ";", "if", "(", "Result", "==", "NoAlias", ")", "return", "Result", ";", "MemoryLocation", "A", "=", "LocA", ";", "MemoryLocation", "B", "=", "LocB", ";", "if", "(", "asA", "!=", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "{", "std", "::", "swap", "(", "asA", ",", "asB", ")", ";", "std", "::", "swap", "(", "A", ",", "B", ")", ";", "}", "if", "(", "asA", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", "&&", "(", "asB", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "asB", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", ")", "{", "const", "auto", "*", "ObjA", "=", "getUnderlyingObject", "(", "A", ".", "Ptr", "->", "stripPointerCastsAndInvariantGroups", "(", ")", ")", ";", "if", "(", "const", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "ObjA", ")", ")", "{", "if", "(", "LI", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", "return", "NoAlias", ";", "}", "else", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "ObjA", ")", ")", "{", "const", "Function", "*", "F", "=", "Arg", "->", "getParent", "(", ")", ";", "switch", "(", "F", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "return", "NoAlias", ";", "default", ":", "break", ";", "}", "}", "}", "return", "AAResultBase", "::", "alias", "(", "LocA", ",", "LocB", ",", "AAQI", ")", ";", "}", "</s>" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

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

[]

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

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

[ "SNES", "SNES" ]

[]

[ "<s>", "void", "BPFRegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "void", "arm_emit_eabi_attribute", "(", "const", "char", "*", "name", ",", "int", "num", ",", "int", "val", ")", "{", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.eabi_attribute %d, %d\"", ",", "num", ",", "val", ")", ";", "if", "(", "flag_verbose_asm", "||", "flag_debug_asm", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t%s %s\"", ",", "ASM_COMMENT_START", ",", "name", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "emit", "an", "EABI", "tag", "and", "its", "associated", "value", ".", "We", "emit", "the", "numerical", "value", "of", "the", "tag", "in", "case", "the", "assembler", "does", "not", "support", "textual", "tags", ".", "(", "Eg", "gas", "prior", "to", "2.20", ")", ".", "If", "requested", "we", "include", "the", "tag", "name", "in", "a", "comment", "so", "that", "anyone", "reading", "the", "assembler", "output", "will", "know", "which", "tag", "is", "being", "set", ".", "This", "function", "is", "not", "static", "because", "arm-c.cc", "needs", "it", "too", "." ]

[ "arm", "\"\\t.eabi_attribute %d, %d\"", "\"\\t%s %s\"", "\"\\n\"" ]

[]

[ "<s>", "int", "xtensa_expand_block_move", "(", "rtx", "*", "operands", ")", "{", "static", "const", "machine_mode", "mode_from_align", "[", "]", "=", "{", "VOIDmode", ",", "QImode", ",", "HImode", ",", "VOIDmode", ",", "SImode", ",", "}", ";", "rtx", "dst_mem", "=", "operands", "[", "0", "]", ";", "rtx", "src_mem", "=", "operands", "[", "1", "]", ";", "HOST_WIDE_INT", "bytes", ",", "align", ";", "int", "num_pieces", ",", "move_ratio", ";", "rtx", "temp", "[", "2", "]", ";", "machine_mode", "mode", "[", "2", "]", ";", "int", "amount", "[", "2", "]", ";", "bool", "active", "[", "2", "]", ";", "int", "phase", "=", "0", ";", "int", "next", ";", "int", "offset_ld", "=", "0", ";", "int", "offset_st", "=", "0", ";", "rtx", "x", ";", "if", "(", "!", "optimize", "||", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", ")", "return", "0", ";", "bytes", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "if", "(", "bytes", "<=", "0", ")", "return", "0", ";", "if", "(", "align", ">", "MOVE_MAX", ")", "align", "=", "MOVE_MAX", ";", "move_ratio", "=", "4", ";", "if", "(", "optimize", ">", "2", ")", "move_ratio", "=", "LARGEST_MOVE_RATIO", ";", "num_pieces", "=", "(", "bytes", "/", "align", ")", "+", "(", "(", "bytes", "%", "align", "+", "1", ")", "/", "2", ")", ";", "if", "(", "num_pieces", ">", "move_ratio", ")", "return", "0", ";", "x", "=", "XEXP", "(", "dst_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "dst_mem", "=", "replace_equiv_address", "(", "dst_mem", ",", "x", ")", ";", "}", "x", "=", "XEXP", "(", "src_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "src_mem", "=", "replace_equiv_address", "(", "src_mem", ",", "x", ")", ";", "}", "active", "[", "0", "]", "=", "active", "[", "1", "]", "=", "false", ";", "do", "{", "next", "=", "phase", ";", "phase", "^=", "1", ";", "if", "(", "bytes", ">", "0", ")", "{", "int", "next_amount", ";", "next_amount", "=", "(", "bytes", ">=", "4", "?", "4", ":", "(", "bytes", ">=", "2", "?", "2", ":", "1", ")", ")", ";", "next_amount", "=", "MIN", "(", "next_amount", ",", "align", ")", ";", "amount", "[", "next", "]", "=", "next_amount", ";", "mode", "[", "next", "]", "=", "mode_from_align", "[", "next_amount", "]", ";", "temp", "[", "next", "]", "=", "gen_reg_rtx", "(", "mode", "[", "next", "]", ")", ";", "x", "=", "adjust_address", "(", "src_mem", ",", "mode", "[", "next", "]", ",", "offset_ld", ")", ";", "emit_move_insn", "(", "temp", "[", "next", "]", ",", "x", ")", ";", "offset_ld", "+=", "next_amount", ";", "bytes", "-=", "next_amount", ";", "active", "[", "next", "]", "=", "true", ";", "}", "if", "(", "active", "[", "phase", "]", ")", "{", "active", "[", "phase", "]", "=", "false", ";", "x", "=", "adjust_address", "(", "dst_mem", ",", "mode", "[", "phase", "]", ",", "offset_st", ")", ";", "emit_move_insn", "(", "x", ",", "temp", "[", "phase", "]", ")", ";", "offset_st", "+=", "amount", "[", "phase", "]", ";", "}", "}", "while", "(", "active", "[", "next", "]", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Try", "to", "expand", "a", "block", "move", "operation", "to", "an", "RTL", "block", "move", "instruction", ".", "If", "not", "optimizing", "or", "if", "the", "block", "size", "is", "not", "a", "constant", "or", "if", "the", "block", "is", "small", ",", "the", "expansion", "fails", "and", "GCC", "falls", "back", "to", "calling", "memcpy", "(", ")", ".", "operands", "[", "0", "]", "is", "the", "destination", "operands", "[", "1", "]", "is", "the", "source", "operands", "[", "2", "]", "is", "the", "length", "operands", "[", "3", "]", "is", "the", "alignment" ]

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

[]

[ "<s>", "int", "ARMBaseInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "SDNode", "*", "Node", ")", "const", "{", "if", "(", "!", "Node", "->", "isMachineOpcode", "(", ")", ")", "return", "1", ";", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "1", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "ItinData", "->", "getStageLatency", "(", "get", "(", "Opcode", ")", ".", "getSchedClass", "(", ")", ")", ";", "case", "ARM", "::", "VLDMQIA", ":", "case", "ARM", "::", "VSTMQIA", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "ARM", "ARM", "1", "1", "ARM::VLDMQIA", "ARM::VSTMQIA", "2" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "M680x0FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "&&", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "auto", "&", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "DwarfCFI", "=", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", ".", "needsUnwindTableEntry", "(", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "}", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "0", "0", "1", "0", "M680x0", "0" ]

[]

[ "<s>", "static", "bool", "sparc_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "sparc_pic_register_p", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "symbolic_operand", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "VOIDmode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", ".", "In", "PIC", "mode", ",", "(", "mem", ":", "HI", "[", "%", "l7+a", "]", ")", "is", "not", "equivalent", "to", "(", "mem", ":", "QI", "[", "%", "l7+a", "]", ")", "(", "mem", ":", "QI", "[", "%", "l7+a+1", "]", ")", "because", "[", "%", "l7+a+1", "]", "is", "interpreted", "as", "the", "address", "of", "(", "a+1", ")", "." ]

[ "sparc", "0", "1" ]

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "Hexagon", "::", "ArchEnum", ">", "CpuTable", "{", "{", "\"generic\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv5\"", ",", "Hexagon", "::", "ArchEnum", "::", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "Hexagon", "::", "ArchEnum", "::", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "Hexagon", "::", "ArchEnum", "::", "V62", "}", ",", "{", "\"hexagonv65\"", ",", "Hexagon", "::", "ArchEnum", "::", "V65", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "set", "(", "Hexagon", "::", "FeatureDuplex", ",", "false", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ArchEnum", "\"generic\"", "Hexagon::ArchEnum", "\"hexagonv5\"", "Hexagon::ArchEnum", "\"hexagonv55\"", "Hexagon::ArchEnum", "\"hexagonv60\"", "Hexagon::ArchEnum", "\"hexagonv62\"", "Hexagon::ArchEnum", "\"hexagonv65\"", "Hexagon::ArchEnum", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon::FeatureDuplex", "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "getName", "(", "unsigned", "RegNo", ")", "const", "{", "std", "::", "stringstream", "O", ";", "O", "<<", "\"reg\"", "<<", "RegNo", ";", "return", "getStrPool", "(", ")", "->", "getManagedString", "(", "O", ".", "str", "(", ")", ".", "c_str", "(", ")", ")", "->", "c_str", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "NVPTX", "\"reg\"" ]

[]

[ "<s>", "static", "void", "mips16_split_long_branches", "(", "void", ")", "{", "bool", "something_changed", ";", "if", "(", "!", "TARGET_MIPS16", ")", "return", ";", "do", "{", "rtx_insn", "*", "insn", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "something_changed", "=", "false", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "get_attr_length", "(", "insn", ")", ">", "4", "&&", "(", "any_condjump_p", "(", "insn", ")", "||", "any_uncondjump_p", "(", "insn", ")", ")", ")", "{", "rtx", "old_label", ",", "temp", ",", "saved_temp", ";", "rtx_code_label", "*", "new_label", ";", "rtx", "target", ";", "rtx_insn", "*", "jump", ",", "*", "jump_sequence", ";", "start_sequence", "(", ")", ";", "saved_temp", "=", "gen_rtx_REG", "(", "Pmode", ",", "AT_REGNUM", ")", ";", "temp", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_REG_FIRST", "+", "2", ")", ";", "emit_move_insn", "(", "saved_temp", ",", "temp", ")", ";", "old_label", "=", "JUMP_LABEL", "(", "insn", ")", ";", "target", "=", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "old_label", ")", ";", "mips16_load_branch_target", "(", "temp", ",", "target", ")", ";", "jump", "=", "emit_jump_insn", "(", "PMODE_INSN", "(", "gen_indirect_jump_and_restore", ",", "(", "temp", ",", "temp", ",", "saved_temp", ")", ")", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "old_label", ";", "LABEL_NUSES", "(", "old_label", ")", "++", ";", "mips16_lay_out_constants", "(", "false", ")", ";", "if", "(", "simplejump_p", "(", "insn", ")", ")", "new_label", "=", "NULL", ";", "else", "{", "new_label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "new_label", ")", ";", "}", "jump_sequence", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_after", "(", "jump_sequence", ",", "insn", ")", ";", "if", "(", "new_label", ")", "invert_jump", "(", "insn", ",", "new_label", ",", "false", ")", ";", "else", "delete_insn", "(", "insn", ")", ";", "something_changed", "=", "true", ";", "}", "}", "while", "(", "something_changed", ")", ";", "}", "</s>" ]

[ "If", "we", "'re", "compiling", "a", "MIPS16", "function", ",", "look", "for", "and", "split", "any", "long", "branches", ".", "This", "must", "be", "called", "after", "all", "other", "instruction", "modifications", "in", "mips_reorg", "." ]

[ "mips", "4", "2" ]

[]

[ "<s>", "void", "ix86_option_override", "(", "void", ")", "{", "ix86_option_override_internal", "(", "true", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "</s>" ]

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

[ "i386" ]

[]

[ "<s>", "bool", "SICAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "SIC", "SIC" ]

[]

[ "<s>", "int", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "(", "LAST_CALLEE_SAVED_REG", "+", "1", ")", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>" ]

[ "Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "." ]

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

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "X86", "X86", "0", "\"Unexpected\"", "X86::TAILJMPm64", "X86::TAILJMPm", "0", "0", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "static", "section", "*", "avr_asm_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "section", "*", "sect", "=", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "if", "(", "sect", "->", "common", ".", "flags", "&", "SECTION_NAMED", ")", "{", "const", "char", "*", "name", "=", "sect", "->", "named", ".", "name", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "STR_PREFIX_P", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "return", "get_section", "(", "sname", ",", "sect", "->", "common", ".", "flags", ",", "sect", "->", "named", ".", "decl", ")", ";", "}", "}", "if", "(", "!", "progmem_section", "[", "as", "]", ")", "{", "progmem_section", "[", "as", "]", "=", "get_unnamed_section", "(", "0", ",", "avr_output_progmem_section_asm_op", ",", "avr_addrspace", "[", "as", "]", ".", "section_name", ")", ";", "}", "return", "progmem_section", "[", "as", "]", ";", "}", "return", "sect", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ASM_SELECT_SECTION", "'" ]

[ "avr", "\".rodata\"", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"NVPTX Replace Image Handles\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"NVPTX Replace Image Handles\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "MipsTargetMachine", "&", "TM", "=", "getMipsTargetMachine", "(", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", "TM", ")", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "hasStandardEncoding", "(", ")", ")", "addPass", "(", "createMipsLongBranchPass", "(", "TM", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "expand_block_set_4", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "4", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "long_int_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "2", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "bytes", "-=", "rem", ";", "if", "(", "rem", ">", "1", ")", "{", "if", "(", "CONST_INT_P", "(", "value_rtx", ")", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "value", "=", "UINTVAL", "(", "value_rtx", ")", "&", "0xff", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "HImode", ",", "bytes", ")", ",", "gen_int_mode", "(", "(", "value", "<<", "8", ")", "|", "value", ",", "HImode", ")", ")", ";", "}", "else", "{", "rtx", "temp", "=", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "temp", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", "+", "1", ")", ",", "temp", ")", ";", "}", "bytes", "+=", "2", ";", "rem", "-=", "2", ";", "}", "if", "(", "rem", ">", "0", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "of", "DST", "with", "address", "DST_REG", "to", "VALUE_RTX", "in", "4-byte", "chunks", "." ]

[ "visium", "4", "1", "3", "2", "0", "1", "0xff", "8", "1", "1", "2", "2", "0", "1" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayoutAndUpdate", "(", "MachineFunction", "&", "MF", ",", "bool", "UseEstimate", ")", "const", "{", "unsigned", "NewMaxCallFrameSize", "=", "0", ";", "unsigned", "FrameSize", "=", "determineFrameLayout", "(", "MF", ",", "UseEstimate", ",", "&", "NewMaxCallFrameSize", ")", ";", "MF", ".", "getFrameInfo", "(", ")", ".", "setStackSize", "(", "FrameSize", ")", ";", "MF", ".", "getFrameInfo", "(", ")", ".", "setMaxCallFrameSize", "(", "NewMaxCallFrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "and", "update", "the", "machine", "function", "." ]

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

[]

[ "<s>", "bool", "arm_frame_pointer_required", "(", "void", ")", "{", "if", "(", "SUBTARGET_FRAME_POINTER_REQUIRED", ")", "return", "true", ";", "if", "(", "cfun", "->", "has_nonlocal_label", ")", "return", "true", ";", "if", "(", "TARGET_ARM", "&&", "TARGET_APCS_FRAME", "&&", "!", "crtl", "->", "is_leaf", ")", "return", "true", ";", "if", "(", "!", "IS_INTERRUPT", "(", "arm_current_func_type", "(", ")", ")", "&&", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "&&", "arm_except_unwind_info", "(", "&", "global_options", ")", "==", "UI_TARGET", "&&", "cfun", "->", "can_throw_non_call_exceptions", ")", "{", "HOST_WIDE_INT", "size", "=", "get_frame_size", "(", ")", ";", "if", "(", "size", "<=", "0", ")", "return", "false", ";", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "size", "+=", "32", "*", "UNITS_PER_WORD", ";", "if", "(", "size", ">", "PROBE_INTERVAL", "&&", "size", ">", "STACK_CHECK_PROTECT", ")", "return", "true", ";", "}", "else", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_FRAME_POINTER_REQUIRED", "." ]

[ "arm", "0", "32" ]

[]

[ "<s>", "void", "LC2200FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "LC2200InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "report_fatal_error", "(", "\"RISC-V backend can't currently handle functions that need stack \"", "\"realignment and have variable sized objects\"", ")", ";", "}", "Register", "FPReg", "=", "LC2200", "::", "fp", ";", "Register", "SPReg", "=", "LC2200", "::", "sp", ";", "DebugLoc", "DL", ";", "determineFrameLayout", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "std", "::", "advance", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "Entry", ".", "getFrameIdx", "(", ")", ")", ";", "Register", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "FPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfa", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "FPReg", ",", "true", ")", ",", "0", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "llvm_unreachable", "(", "\"cannot realign\"", ")", ";", "}", "}", "}", "</s>" ]

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

[ "LC2200", "LC2200", "\"Shrink-wrapping not yet supported\"", "LC2200", "LC2200", "\"RISC-V backend can't currently handle functions that need stack \"", "\"realignment and have variable sized objects\"", "LC2200::fp", "LC2200::sp", "0", "0", "LC2200", "\"cannot realign\"" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Shrink-wrapping not yet supported\"", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", ">", "&", "Patterns", ",", "bool", "DoRegPressureReduce", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "Aggressive", ")", "return", "false", ";", "if", "(", "getFMAPatterns", "(", "Root", ",", "Patterns", ")", ")", "return", "true", ";", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ",", "DoRegPressureReduce", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "unsigned", "getBase", "(", ")", "const", "{", "assert", "(", "Base", ")", ";", "return", "Base", ";", "}", "</s>" ]

[ "Returns", "the", "base", "of", "this", "range", "." ]

[ "M68k" ]

[]

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

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "TPCHazardRecognizer", "::", "canReserveResources", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isPseudo", "(", ")", ")", "{", "return", "(", "CurrentPacket", ".", "size", "(", ")", "<", "2", ")", ";", "}", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "return", "false", ";", "}", "for", "(", "auto", "SUJ", ":", "CurrentPacket", ")", "{", "if", "(", "!", "isLegalToPacketizeTogether", "(", "SU", ",", "SUJ", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "if", "the", "resources", "occupied", "by", "a", "machine", "instruction", "are", "available", "in", "the", "current", "state", "." ]

[ "TPC", "TPC", "2" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getOpcodeAfterMemoryUnfold", "(", "unsigned", "Opc", ",", "bool", "UnfoldLoad", ",", "bool", "UnfoldStore", ",", "unsigned", "*", "LoadRegIndex", ")", "const", "{", "const", "X86MemoryFoldTableEntry", "*", "I", "=", "lookupUnfoldTable", "(", "Opc", ")", ";", "if", "(", "I", "==", "nullptr", ")", "return", "0", ";", "bool", "FoldedLoad", "=", "I", "->", "Flags", "&", "TB_FOLDED_LOAD", ";", "bool", "FoldedStore", "=", "I", "->", "Flags", "&", "TB_FOLDED_STORE", ";", "if", "(", "UnfoldLoad", "&&", "!", "FoldedLoad", ")", "return", "0", ";", "if", "(", "UnfoldStore", "&&", "!", "FoldedStore", ")", "return", "0", ";", "if", "(", "LoadRegIndex", ")", "*", "LoadRegIndex", "=", "I", "->", "Flags", "&", "TB_INDEX_MASK", ";", "return", "I", "->", "DstOp", ";", "}", "</s>" ]

[ "getOpcodeAfterMemoryUnfold", "-", "Returns", "the", "opcode", "of", "the", "would", "be", "new", "instruction", "after", "load", "/", "store", "are", "unfolded", "from", "an", "instruction", "of", "the", "specified", "opcode", "." ]

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

[]

[ "<s>", "static", "rtx", "tilegx_delegitimize_address", "(", "rtx", "x", ")", "{", "x", "=", "delegitimize_mem_from_attrs", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "switch", "(", "XINT", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "{", "case", "UNSPEC_HW0", ":", "case", "UNSPEC_HW1", ":", "case", "UNSPEC_HW2", ":", "case", "UNSPEC_HW3", ":", "case", "UNSPEC_HW0_LAST", ":", "case", "UNSPEC_HW1_LAST", ":", "case", "UNSPEC_HW2_LAST", ":", "case", "UNSPEC_HW0_PCREL", ":", "case", "UNSPEC_HW1_PCREL", ":", "case", "UNSPEC_HW1_LAST_PCREL", ":", "case", "UNSPEC_HW2_LAST_PCREL", ":", "case", "UNSPEC_HW0_PLT_PCREL", ":", "case", "UNSPEC_HW1_PLT_PCREL", ":", "case", "UNSPEC_HW1_LAST_PLT_PCREL", ":", "case", "UNSPEC_HW2_LAST_PLT_PCREL", ":", "case", "UNSPEC_HW0_GOT", ":", "case", "UNSPEC_HW0_LAST_GOT", ":", "case", "UNSPEC_HW1_LAST_GOT", ":", "case", "UNSPEC_HW0_TLS_GD", ":", "case", "UNSPEC_HW1_LAST_TLS_GD", ":", "case", "UNSPEC_HW0_TLS_IE", ":", "case", "UNSPEC_HW1_LAST_TLS_IE", ":", "case", "UNSPEC_HW0_TLS_LE", ":", "case", "UNSPEC_HW1_LAST_TLS_LE", ":", "x", "=", "XVECEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ",", "0", ")", ";", "break", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Implement", "TARGET_DELEGITIMIZE_ADDRESS", "." ]

[ "tilegx", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "void", "PatmosFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "if", "(", "TM", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Patmos", "::", "ADJCALLSTACKDOWN", ")", "{", "Opcode", "=", "(", "Size", "<=", "0xFFF", ")", "?", "Patmos", "::", "SUBi", ":", "Patmos", "::", "SUBl", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Patmos", "::", "ADJCALLSTACKUP", ")", "{", "Opcode", "=", "(", "Size", "<=", "0xFFF", ")", "?", "Patmos", "::", "ADDi", ":", "Patmos", "::", "ADDl", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unsupported pseudo instruction.\"", ")", ";", "}", "if", "(", "Size", ")", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RSP", ")", ".", "addImm", "(", "Size", ")", ";", "}", "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", ")", "." ]

[ "Patmos", "Patmos", "0", "Patmos::ADJCALLSTACKDOWN", "0xFFF", "Patmos::SUBi", "Patmos::SUBl", "Patmos::ADJCALLSTACKUP", "0xFFF", "Patmos::ADDi", "Patmos::ADDl", "\"Unsupported pseudo instruction.\"", "Patmos::RSP", "Patmos::RSP" ]

[]

[ "<s>", "static", "machine_mode", "ix86_promote_function_mode", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", ",", "const_tree", "fntype", ",", "int", "for_return", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_NORMAL", "&&", "type", "!=", "NULL_TREE", "&&", "POINTER_TYPE_P", "(", "type", ")", ")", "{", "*", "punsignedp", "=", "POINTERS_EXTEND_UNSIGNED", ";", "return", "word_mode", ";", "}", "return", "default_promote_function_mode", "(", "type", ",", "mode", ",", "punsignedp", ",", "fntype", ",", "for_return", ")", ";", "}", "</s>" ]

[ "Pointer", "function", "arguments", "and", "return", "values", "are", "promoted", "to", "word_mode", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "ix86_pass_by_reference", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "TARGET_64BIT", "&&", "(", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ")", "==", "MS_ABI", ")", "{", "int", "msize", "=", "(", "int", ")", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "true", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "msize", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "}", "switch", "(", "msize", ")", "{", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "break", ";", "default", ":", "return", "true", ";", "}", "}", "else", "if", "(", "TARGET_64BIT", "&&", "type", "&&", "int_size_in_bytes", "(", "type", ")", "==", "-", "1", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "A", "C", "expression", "that", "indicates", "when", "an", "argument", "must", "be", "passed", "by", "reference", ".", "If", "nonzero", "for", "an", "argument", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", ".", "The", "pointer", "is", "passed", "in", "whatever", "way", "is", "appropriate", "for", "passing", "a", "pointer", "to", "that", "type", "." ]

[ "i386", "1", "2", "4", "8", "1", "1", "0" ]

[]

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "Z80old" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SIRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "CallingConv", "::", "ID", "CC", "=", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "case", "CallingConv", "::", "AMDGPU_Gfx", ":", "return", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "hasGFX90AInsts", "(", ")", "?", "CSR_AMDGPU_HighRegs_With_AGPRs_SaveList", ":", "CSR_AMDGPU_HighRegs_SaveList", ";", "default", ":", "{", "static", "const", "MCPhysReg", "NoCalleeSavedReg", "=", "AMDGPU", "::", "NoRegister", ";", "return", "&", "NoCalleeSavedReg", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::NoRegister" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Mips" ]

[]

[ "<s>", "MachineBasicBlock", "*", "WebAssemblyTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I32_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "false", ",", "false", ",", "WebAssembly", "::", "I32_TRUNC_S_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I32_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "false", ",", "false", ",", "WebAssembly", "::", "I32_TRUNC_U_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I64_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "true", ",", "false", ",", "WebAssembly", "::", "I64_TRUNC_S_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I64_F32", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "true", ",", "false", ",", "WebAssembly", "::", "I64_TRUNC_U_F32", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I32_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "false", ",", "true", ",", "WebAssembly", "::", "I32_TRUNC_S_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I32_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "false", ",", "true", ",", "WebAssembly", "::", "I32_TRUNC_U_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_SINT_I64_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "false", ",", "true", ",", "true", ",", "WebAssembly", "::", "I64_TRUNC_S_F64", ")", ";", "case", "WebAssembly", "::", "FP_TO_UINT_I64_F64", ":", "return", "LowerFPToInt", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ",", "true", ",", "true", ",", "true", ",", "WebAssembly", "::", "I64_TRUNC_U_F64", ")", ";", "case", "WebAssembly", "::", "CALL_RESULTS", ":", "return", "LowerCallResults", "(", "MI", ",", "DL", ",", "BB", ",", "TII", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"Unexpected instr type to insert\"", "WebAssembly::FP_TO_SINT_I32_F32", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::FP_TO_UINT_I32_F32", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::FP_TO_SINT_I64_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::FP_TO_UINT_I64_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::FP_TO_SINT_I32_F64", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::FP_TO_UINT_I32_F64", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::FP_TO_SINT_I64_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::FP_TO_UINT_I64_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::CALL_RESULTS" ]

[]

[ "<s>", "bool", "ResourceAssignment", "::", "isPseudo", "(", "SUnit", "*", "SU", ")", "const", "{", "return", "(", "!", "SU", "->", "getInstr", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "pseudo", "instruction", "that", "does", "n't", "correspond", "to", "a", "real", "machine", "instruction", "." ]

[ "TMS320C64X" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "isTypeLegal", "(", "const", "Type", "*", "Ty", ",", "EVT", "&", "VT", ",", "bool", "AllowI1", ")", "{", "VT", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "VT", "==", "MVT", "::", "Other", "||", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "X86ScalarSSEf64", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "X86ScalarSSEf32", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f80", ")", "return", "false", ";", "return", "(", "AllowI1", "&&", "VT", "==", "MVT", "::", "i1", ")", "||", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "X86", "X86", "MVT::Other", "MVT::f64", "X86", "MVT::f32", "X86", "MVT::f80", "MVT::i1" ]

[]

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

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

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

[]

[ "<s>", "static", "machine_mode", "sparc_preferred_simd_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_VIS", ")", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "return", "V2SImode", ";", "case", "HImode", ":", "return", "V4HImode", ";", "case", "QImode", ":", "return", "V8QImode", ";", "default", ":", ";", "}", "return", "word_mode", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "target", "hook", "." ]

[ "sparc" ]

[]

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

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

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

[]

[ "<s>", "inline", "static", "rtx", "next_consecutive_mem", "(", "rtx", "mem", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "HOST_WIDE_INT", "offset", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "offset", ")", ";", "return", "adjust_automodify_address", "(", "mem", ",", "mode", ",", "addr", ",", "offset", ")", ";", "}", "</s>" ]

[ "Helper", "for", "gen_movmem_ldrd_strd", ".", "Increase", "the", "address", "of", "memory", "rtxby", "mode", "size", "." ]

[ "arm", "0" ]

[]

[ "<s>", "void", "SICFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SICFunctionInfo", "*", "SICFI", "=", "MF", ".", "getInfo", "<", "SICFunctionInfo", ">", "(", ")", ";", "const", "SICInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "SICInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SICRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "SICRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "SICABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "SIC", "::", "X", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC", "SIC::X" ]

[]

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

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

[ "SPIRV", "SPIRV", "0" ]

[]

[ "<s>", "rtx_insn", "*", "s390_load_got", "(", "void", ")", "{", "rtx_insn", "*", "insns", ";", "rtx", "got_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "start_sequence", "(", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "s390_got_symbol", "(", ")", ")", ";", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insns", ";", "}", "</s>" ]

[ "Return", "insn", "sequence", "to", "load", "the", "GOT", "register", "." ]

[ "s390", "12" ]

[]

[ "<s>", "bool", "HexagonDCE", "::", "run", "(", ")", "{", "bool", "Collected", "=", "collect", "(", ")", ";", "if", "(", "!", "Collected", ")", "return", "false", ";", "const", "SetVector", "<", "NodeId", ">", "&", "DeadNodes", "=", "getDeadNodes", "(", ")", ";", "const", "SetVector", "<", "NodeId", ">", "&", "DeadInstrs", "=", "getDeadInstrs", "(", ")", ";", "typedef", "DenseMap", "<", "NodeId", ",", "NodeId", ">", "RefToInstrMap", ";", "RefToInstrMap", "R2I", ";", "SetVector", "<", "NodeId", ">", "PartlyDead", ";", "DataFlowGraph", "&", "DFG", "=", "getDFG", "(", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "DFG", ".", "getFunc", "(", ")", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "{", "for", "(", "auto", "TA", ":", "BA", ".", "Addr", "->", "members_if", "(", "DFG", ".", "IsCode", "<", "NodeAttrs", "::", "Stmt", ">", ",", "DFG", ")", ")", "{", "NodeAddr", "<", "StmtNode", "*", ">", "SA", "=", "TA", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "SA", ".", "Addr", "->", "members", "(", "DFG", ")", ")", "{", "R2I", ".", "insert", "(", "std", "::", "make_pair", "(", "RA", ".", "Id", ",", "SA", ".", "Id", ")", ")", ";", "if", "(", "DFG", ".", "IsDef", "(", "RA", ")", "&&", "DeadNodes", ".", "count", "(", "RA", ".", "Id", ")", ")", "if", "(", "!", "DeadInstrs", ".", "count", "(", "SA", ".", "Id", ")", ")", "PartlyDead", ".", "insert", "(", "SA", ".", "Id", ")", ";", "}", "}", "}", "SetVector", "<", "NodeId", ">", "Remove", "=", "DeadInstrs", ";", "bool", "Changed", "=", "false", ";", "for", "(", "NodeId", "N", ":", "PartlyDead", ")", "{", "auto", "SA", "=", "DFG", ".", "addr", "<", "StmtNode", "*", ">", "(", "N", ")", ";", "if", "(", "trace", "(", ")", ")", "dbgs", "(", ")", "<<", "\"Partly dead: \"", "<<", "*", "SA", ".", "Addr", "->", "getCode", "(", ")", ";", "Changed", "|=", "rewrite", "(", "SA", ",", "Remove", ")", ";", "}", "return", "erase", "(", "Remove", ")", "||", "Changed", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "Hexagon", "Hexagon", "\"Partly dead: \"" ]

[]

[ "<s>", "unsigned", "SPUTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "1", ";", "case", "ISD", "::", "SETCC", ":", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i32", ")", "{", "VT", "=", "MVT", "::", "i32", ";", "}", "return", "VT", ".", "getSizeInBits", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "CellSPU", "SPU", "1", "ISD::SETCC", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "bool", "ARMLowOverheadLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "const", "ARMSubtarget", "&", "ST", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "mf", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "ST", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "MF", "=", "&", "mf", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops on \"", "<<", "MF", "->", "getName", "(", ")", "<<", "\" ------------- \\n\"", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "RDA", "=", "&", "getAnalysis", "<", "ReachingDefAnalysis", ">", "(", ")", ";", "MF", "->", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "*", "MF", ")", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "BBUtils", "->", "adjustBBOffsetsAfter", "(", "&", "MF", "->", "front", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "ML", ":", "*", "MLI", ")", "{", "if", "(", "ML", "->", "isOutermost", "(", ")", ")", "Changed", "|=", "ProcessLoop", "(", "ML", ")", ";", "}", "Changed", "|=", "RevertNonLoops", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"ARM Loops on \"", "\" ------------- \\n\"", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "s390_short_displacement", "(", "rtx", "disp", ")", "{", "if", "(", "!", "disp", ")", "return", "true", ";", "if", "(", "!", "TARGET_LONG_DISPLACEMENT", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "disp", ")", "==", "CONST_INT", ")", "return", "INTVAL", "(", "disp", ")", ">=", "0", "&&", "INTVAL", "(", "disp", ")", "<", "4096", ";", "if", "(", "GET_CODE", "(", "disp", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "disp", ",", "0", ")", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "XEXP", "(", "disp", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_GOT", "||", "XINT", "(", "XEXP", "(", "disp", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_GOTNTPOFF", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "disp", ")", "==", "CONST", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "DISP", "is", "a", "valid", "short", "displacement", "." ]

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

[]

[ "<s>", "int", "msp430_hard_regno_nregs_with_padding", "(", "int", "regno", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "PSImode", ")", "return", "2", ";", "if", "(", "mode", "==", "CPSImode", ")", "return", "4", ";", "return", "msp430_hard_regno_nregs", "(", "regno", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS_WITH_PADDING", "." ]

[ "msp430", "2", "4" ]

[]

[ "<s>", "void", "GBZ80MCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "const", "uint16_t", "*", "Words", "=", "reinterpret_cast", "<", "uint16_t", "const", "*", ">", "(", "&", "Val", ")", ";", "size_t", "WordCount", "=", "Size", "/", "2", ";", "for", "(", "int64_t", "i", "=", "WordCount", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "uint16_t", "Word", "=", "Words", "[", "i", "]", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0x00ff", ")", ">>", "0", ")", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0xff00", ")", ">>", "8", ")", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "GBZ80", "GB", "2", "1", "0", "0x00ff", "0", "0xff00", "8" ]

[]

[ "<s>", "static", "bool", "rs6000_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "fntype", ";", "if", "(", "decl", ")", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "else", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "if", "(", "TARGET_ALTIVEC_ABI", "&&", "TARGET_ALTIVEC_VRSAVE", "&&", "!", "(", "decl", "&&", "decl", "==", "current_function_decl", ")", ")", "{", "function_args_iterator", "args_iter", ";", "tree", "type", ";", "int", "nvreg", "=", "0", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "++", ";", "FOREACH_FUNCTION_ARGS", "(", "TREE_TYPE", "(", "current_function_decl", ")", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "--", ";", "if", "(", "nvreg", ">", "0", ")", "return", "false", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "||", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "decl", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "!", "DECL_WEAK", "(", "decl", ")", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "!", "TARGET_SECURE_PLT", "||", "!", "flag_pic", "||", "(", "decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", ")", ")", ")", "{", "tree", "attr_list", "=", "TYPE_ATTRIBUTES", "(", "fntype", ")", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "attr_list", ")", "||", "lookup_attribute", "(", "\"shortcall\"", ",", "attr_list", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Say", "whether", "a", "function", "is", "a", "candidate", "for", "sibcall", "handling", "or", "not", ".", "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ".", "Also", ",", "we", "ca", "n't", "do", "it", "if", "there", "are", "any", "vector", "parameters", ";", "there", "'s", "nowhere", "to", "put", "the", "VRsave", "code", "so", "it", "works", ";", "note", "that", "functions", "with", "vector", "parameters", "are", "required", "to", "have", "a", "prototype", ",", "so", "the", "argument", "type", "info", "must", "be", "available", "here", ".", "(", "The", "tail", "recursion", "case", "can", "work", "with", "vector", "parameters", ",", "but", "there", "'s", "no", "way", "to", "distinguish", "here", ".", ")" ]

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"" ]

[]

[ "<s>", "void", "mprocInstPrinter", "::", "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", "." ]

[ "mproc", "mproc" ]

[]

[ "<s>", "bool", "WebAssemblyInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "CONST_I32", ":", "case", "WebAssembly", "::", "CONST_I64", ":", "case", "WebAssembly", "::", "CONST_F32", ":", "case", "WebAssembly", "::", "CONST_F64", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::CONST_I32", "WebAssembly::CONST_I64", "WebAssembly::CONST_F32", "WebAssembly::CONST_F64" ]

[]

[ "<s>", "static", "tree", "tilepro_gimplify_va_arg_expr", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_args", ",", "f_skip", ";", "tree", "args", ",", "skip", ";", "HOST_WIDE_INT", "size", ",", "rsize", ";", "tree", "addr", ",", "tmp", ";", "bool", "pass_by_reference_p", ";", "f_args", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_skip", "=", "TREE_CHAIN", "(", "f_args", ")", ";", "args", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_args", ")", ",", "valist", ",", "f_args", ",", "NULL_TREE", ")", ";", "skip", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_skip", ")", ",", "valist", ",", "f_skip", ",", "NULL_TREE", ")", ";", "addr", "=", "create_tmp_var", "(", "ptr_type_node", ",", "\"va_arg\"", ")", ";", "pass_by_reference_p", "=", "pass_va_arg_by_reference", "(", "type", ")", ";", "if", "(", "pass_by_reference_p", ")", "type", "=", "build_pointer_type", "(", "type", ")", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "(", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", "*", "UNITS_PER_WORD", ";", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">", "PARM_BOUNDARY", ")", "{", "gcc_assert", "(", "STACK_BOUNDARY", "==", "PARM_BOUNDARY", "*", "2", ")", ";", "tmp", "=", "build2", "(", "BIT_AND_EXPR", ",", "sizetype", ",", "fold_convert", "(", "sizetype", ",", "unshare_expr", "(", "args", ")", ")", ",", "size_int", "(", "PARM_BOUNDARY", "/", "8", ")", ")", ";", "tmp", "=", "build2", "(", "POINTER_PLUS_EXPR", ",", "ptr_type_node", ",", "unshare_expr", "(", "args", ")", ",", "tmp", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "args", ")", ",", "tmp", ",", "pre_p", ")", ";", "}", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "unshare_expr", "(", "args", ")", ",", "rsize", ")", ";", "tmp", "=", "build2", "(", "TRUTH_AND_EXPR", ",", "boolean_type_node", ",", "build2", "(", "GT_EXPR", ",", "boolean_type_node", ",", "tmp", ",", "unshare_expr", "(", "skip", ")", ")", ",", "build2", "(", "LE_EXPR", ",", "boolean_type_node", ",", "unshare_expr", "(", "args", ")", ",", "unshare_expr", "(", "skip", ")", ")", ")", ";", "tmp", "=", "build3", "(", "COND_EXPR", ",", "ptr_type_node", ",", "tmp", ",", "build2", "(", "POINTER_PLUS_EXPR", ",", "ptr_type_node", ",", "unshare_expr", "(", "skip", ")", ",", "size_int", "(", "STACK_POINTER_OFFSET", ")", ")", ",", "unshare_expr", "(", "args", ")", ")", ";", "gimplify_assign", "(", "addr", ",", "tmp", ",", "pre_p", ")", ";", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "addr", ",", "rsize", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "args", ")", ",", "tmp", ",", "pre_p", ")", ";", "addr", "=", "fold_convert", "(", "build_pointer_type", "(", "type", ")", ",", "addr", ")", ";", "if", "(", "pass_by_reference_p", ")", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_GIMPLIFY_VA_ARG_EXPR", ".", "Gimplify", "va_arg", "by", "updating", "the", "va_list", "structure", "VALIST", "as", "required", "to", "retrieve", "an", "argument", "of", "type", "TYPE", ",", "and", "returning", "that", "argument", ".", "ret", "=", "va_arg", "(", "VALIST", ",", "TYPE", ")", ";", "generates", "code", "equivalent", "to", ":", "paddedsize", "=", "(", "sizeof", "(", "TYPE", ")", "+", "3", ")", "&", "-4", ";", "if", "(", "(", "VALIST.__args", "+", "paddedsize", ">", "VALIST.__skip", ")", "&", "(", "VALIST.__args", "<", "=", "VALIST.__skip", ")", ")", "addr", "=", "VALIST.__skip", "+", "STACK_POINTER_OFFSET", ";", "else", "addr", "=", "VALIST.__args", ";", "VALIST.__args", "=", "addr", "+", "paddedsize", ";", "ret", "=", "*", "(", "TYPE", "*", ")", "addr", ";" ]

[ "tilepro", "\"va_arg\"", "1", "2", "8" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "0", "1", "MSP430::PUSH16r" ]

[]

[ "<s>", "static", "void", "register_svpattern", "(", ")", "{", "auto_vec", "<", "string_int_pair", ",", "32", ">", "values", ";", "values", ".", "quick_push", "(", "string_int_pair", "(", "\"SV_\"", "#", "UPPER", ",", "VALUE", ")", ")", ";", "AARCH64_FOR_SVPATTERN", "(", "PUSH", ")", "acle_svpattern", "=", "lang_hooks", ".", "types", ".", "simulate_enum_decl", "(", "input_location", ",", "\"svpattern\"", ",", "&", "values", ")", ";", "}", "</s>" ]

[ "Register", "the", "svpattern", "enum", "." ]

[ "aarch64", "32", "\"SV_\"", "\"svpattern\"" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MachineInstr", "*", "Return", "=", "MIRBuilder", ".", "buildInstr", "(", "AArch64", "::", "RET_ReallyLR", ")", ";", "assert", "(", "Return", "&&", "\"Unable to build a return instruction?!\"", ")", ";", "assert", "(", "(", "(", "Val", "&&", "VReg", ")", "||", "(", "!", "Val", "&&", "!", "VReg", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "if", "(", "VReg", ")", "{", "assert", "(", "(", "Val", "->", "getType", "(", ")", "->", "isIntegerTy", "(", ")", "||", "Val", "->", "getType", "(", ")", "->", "isPointerTy", "(", ")", ")", "&&", "\"Type not supported yet\"", ")", ";", "const", "Function", "&", "F", "=", "*", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "Size", "=", "DL", ".", "getTypeSizeInBits", "(", "Val", "->", "getType", "(", ")", ")", ";", "assert", "(", "(", "Size", "==", "64", "||", "Size", "==", "32", ")", "&&", "\"Size not supported yet\"", ")", ";", "unsigned", "ResReg", "=", "(", "Size", "==", "32", ")", "?", "AArch64", "::", "W0", ":", "AArch64", "::", "X0", ";", "MIRBuilder", ".", "setInstr", "(", "*", "Return", ",", "true", ")", ";", "MachineInstr", "*", "Copy", "=", "MIRBuilder", ".", "buildCopy", "(", "ResReg", ",", "VReg", ")", ";", "(", "void", ")", "Copy", ";", "assert", "(", "Copy", "->", "getNextNode", "(", ")", "==", "Return", "&&", "\"The insertion did not happen where we expected\"", ")", ";", "MachineInstrBuilder", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Return", ")", ".", "addReg", "(", "ResReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AArch64", "AArch64", "AArch64::RET_ReallyLR", "\"Unable to build a return instruction?!\"", "\"Return value without a vreg\"", "\"Type not supported yet\"", "64", "32", "\"Size not supported yet\"", "32", "AArch64::W0", "AArch64::X0", "\"The insertion did not happen where we expected\"" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_movqi_r_mr_reg_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "x", "=", "XEXP", "(", "src", ",", "0", ")", ";", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld %0,%b1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_overlap_mentioned_p", "(", "dest", ",", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Same", "as", "out_movqi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", "or", "SBIW" ]

[ "avr", "0", "1", "0", "\"ld %0,%b1\"", "3", "0", "0", "2", "\"\"" ]

[]

[ "<s>", "int", "bfin_frame_pointer_required", "(", "void", ")", "{", "e_funkind", "fkind", "=", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "if", "(", "fkind", "!=", "SUBROUTINE", ")", "return", "1", ";", "if", "(", "TARGET_OMIT_LEAF_FRAME_POINTER", "&&", "!", "current_function_is_leaf", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Value", "should", "be", "nonzero", "if", "functions", "must", "have", "frame", "pointers", ".", "Zero", "means", "the", "frame", "pointer", "need", "not", "be", "set", "up", "(", "and", "parms", "may", "be", "accessed", "via", "the", "stack", "pointer", ")", "in", "functions", "that", "seem", "suitable", "." ]

[ "bfin", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "cris_file_start", "(", "void", ")", "{", "targetm", ".", "asm_file_start_app_off", "=", "!", "(", "TARGET_PDEBUG", "||", "flag_print_asm_name", ")", ";", "default_file_start", "(", ")", ";", "}", "</s>" ]

[ "Boilerplate", "emitted", "at", "start", "of", "file", ".", "NO_APP", "*", "only", "at", "file", "start", "*", "means", "faster", "assembly", ".", "It", "also", "means", "comments", "are", "not", "allowed", ".", "In", "some", "cases", "comments", "will", "be", "output", "for", "debugging", "purposes", ".", "Make", "sure", "they", "are", "allowed", "then", ".", "We", "want", "a", ".file", "directive", "only", "if", "TARGET_ELF", "." ]

[ "cris" ]

[]

[ "<s>", "static", "const", "char", "*", "output_multi_immediate", "(", "rtx", "*", "operands", ",", "const", "char", "*", "instr1", ",", "const", "char", "*", "instr2", ",", "int", "immed_op", ",", "HOST_WIDE_INT", "n", ")", "{", "n", "&=", "0xffffffff", ";", "if", "(", "n", "==", "0", ")", "{", "operands", "[", "immed_op", "]", "=", "const0_rtx", ";", "output_asm_insn", "(", "instr1", ",", "operands", ")", ";", "}", "else", "{", "int", "i", ";", "const", "char", "*", "instr", "=", "instr1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "+=", "2", ")", "{", "if", "(", "n", "&", "(", "3", "<<", "i", ")", ")", "{", "operands", "[", "immed_op", "]", "=", "GEN_INT", "(", "n", "&", "(", "255", "<<", "i", ")", ")", ";", "output_asm_insn", "(", "instr", ",", "operands", ")", ";", "instr", "=", "instr2", ";", "i", "+=", "6", ";", "}", "}", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "multiple", "immediate", "operation", ".", "OPERANDS", "is", "the", "vector", "of", "operands", "referred", "to", "in", "the", "output", "patterns", ".", "INSTR1", "is", "the", "output", "pattern", "to", "use", "for", "the", "first", "constant", ".", "INSTR2", "is", "the", "output", "pattern", "to", "use", "for", "subsequent", "constants", ".", "IMMED_OP", "is", "the", "index", "of", "the", "constant", "slot", "in", "OPERANDS", ".", "N", "is", "the", "constant", "value", "." ]

[ "arm", "0xffffffff", "0", "0", "32", "2", "3", "255", "6", "\"\"" ]

[]

[ "<s>", "void", "GBZ80InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "GBZ80", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "unsigned", "DestSubReg", ",", "SrcSubReg", ";", "DestSubReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "GBZ80", "::", "subreg_hi", ")", ";", "SrcSubReg", "=", "RI", ".", "getSubReg", "(", "SrcReg", ",", "GBZ80", "::", "subreg_hi", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestSubReg", ")", ".", "addReg", "(", "SrcSubReg", ")", ";", "DestSubReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "GBZ80", "::", "subreg_lo", ")", ";", "SrcSubReg", "=", "RI", ".", "getSubReg", "(", "SrcReg", ",", "GBZ80", "::", "subreg_lo", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "LD8rr", ")", ",", "DestSubReg", ")", ".", "addReg", "(", "SrcSubReg", ")", ";", "if", "(", "KillSrc", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "else", "if", "(", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ")", "||", "GBZ80", "::", "GR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "GBZ80", "::", "POP16r", ")", ",", "DestReg", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Imposible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "GBZ80", "GB", "GBZ80::GR8RegClass", "GBZ80::LD8rr", "GBZ80::GR16RegClass", "GBZ80::subreg_hi", "GBZ80::subreg_hi", "GBZ80::LD8rr", "GBZ80::subreg_lo", "GBZ80::subreg_lo", "GBZ80::LD8rr", "GBZ80::KILL", "GBZ80::GR16RegClass", "GBZ80::GR16RegClass", "GBZ80::PUSH16r", "GBZ80::POP16r", "\"Imposible reg-to-reg copy\"" ]

[]

[ "<s>", "int", "m32c_class_likely_spilled_p", "(", "int", "regclass", ")", "{", "if", "(", "regclass", "==", "A_REGS", ")", "return", "1", ";", "return", "reg_class_size", "[", "regclass", "]", "==", "1", ";", "}", "</s>" ]

[ "Implements", "CLASS_LIKELY_SPILLED_P", ".", "A_REGS", "is", "needed", "for", "address", "reloads", "." ]

[ "m32c", "1", "1" ]

[]

[ "<s>", "static", "void", "vector_init_fpmerge", "(", "rtx", "target", ",", "rtx", "elt", ")", "{", "rtx", "t1", ",", "t2", ",", "t2_low", ",", "t3", ",", "t3_low", ";", "t1", "=", "gen_reg_rtx", "(", "V4QImode", ")", ";", "elt", "=", "convert_modes", "(", "SImode", ",", "QImode", ",", "elt", ",", "true", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "t1", ")", ",", "elt", ")", ";", "t2", "=", "gen_reg_rtx", "(", "V8QImode", ")", ";", "t2_low", "=", "gen_lowpart", "(", "V4QImode", ",", "t2", ")", ";", "emit_insn", "(", "gen_fpmerge_vis", "(", "t2", ",", "t1", ",", "t1", ")", ")", ";", "t3", "=", "gen_reg_rtx", "(", "V8QImode", ")", ";", "t3_low", "=", "gen_lowpart", "(", "V4QImode", ",", "t3", ")", ";", "emit_insn", "(", "gen_fpmerge_vis", "(", "t3", ",", "t2_low", ",", "t2_low", ")", ")", ";", "emit_insn", "(", "gen_fpmerge_vis", "(", "target", ",", "t3_low", ",", "t3_low", ")", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "sparc_expand_vector_init", ".", "Emit", "code", "to", "initialize", "all", "fields", "of", "TARGET", "to", "ELT", "in", "V8QI", "by", "means", "of", "VIS", "FPMERGE", "insn", "." ]

[ "sparc" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCAssignFnForNode", "(", "CallConv", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Only register-returns should be created by PCS\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "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", "(", "AArch64ISD", "::", "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", "." ]

[ "AArch64", "AArch64", "ISD::OutputArg", "16", "4", "1", "0", "\"Only register-returns should be created by PCS\"", "\"Unknown loc info\"", "ISD::ANY_EXTEND", "ISD::BITCAST", "1", "0", "AArch64ISD::Ret", "MVT::Other", "0" ]

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "if", "(", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]

[ "Keep", "track", "of", "available", "resources", "." ]

[ "Hexagon", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "callsEHReturn", "=", "false", ";", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "callsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "if", "(", "ghcCall", ")", "return", "CSR_Ghc_SaveList", ";", "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" ]

[]

[ "<s>", "void", "print_address_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "PLUS", ":", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_address", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"--\"", ")", ";", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"++\"", ")", ";", "break", ";", "case", "POST_DEC", ":", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"--\"", ")", ";", "break", ";", "default", ":", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", ";", "print_operand", "(", "file", ",", "x", ",", "0", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Subroutine", "of", "print_operand", ";", "used", "to", "print", "a", "memory", "reference", "X", "to", "FILE", "." ]

[ "bfin", "0", "\"+\"", "1", "\"--\"", "0", "0", "\"++\"", "0", "\"--\"", "0" ]

[]

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

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

[ "Cpu0", "0", "\"RelaxInstruction() unimplemented\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "cris_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "CRIS_FIRST_ARG_REG", ")", ";", "}", "</s>" ]

[ "Let", "'s", "assume", "all", "functions", "return", "in", "r", "[", "CRIS_FIRST_ARG_REG", "]", "for", "the", "time", "being", "." ]

[ "cris" ]

[]