Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "const", "char", "packetPadding", "[", "]", "=", "\" \"", ";", "const", "char", "startPacket", "=", "'{'", ",", "endPacket", "=", "'}'", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "MCInst", "Nop", ";", "O", "<<", "packetPadding", "<<", "startPacket", "<<", "'\\n'", ";", "Nop", ".", "setOpcode", "(", "Hexagon", "::", "NOP", ")", ";", "printInstruction", "(", "&", "Nop", ",", "O", ")", ";", "O", "<<", "packetPadding", "<<", "endPacket", ";", "}", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\" \"", "Hexagon::ENDLOOP0", "Hexagon::NOP" ]

[]

[ "<s>", "static", "void", "arm_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "if", "(", "TARGET_ARM", ")", "{", "asm_fprintf", "(", "f", ",", "\"\\tldr\\t%r, [%r, #0]\\n\"", ",", "STATIC_CHAIN_REGNUM", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\t%r, [%r, #0]\\n\"", ",", "PC_REGNUM", ",", "PC_REGNUM", ")", ";", "}", "else", "if", "(", "TARGET_THUMB2", ")", "{", "asm_fprintf", "(", "f", ",", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", ",", "STATIC_CHAIN_REGNUM", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", ",", "PC_REGNUM", ",", "PC_REGNUM", ")", ";", "}", "else", "{", "ASM_OUTPUT_ALIGN", "(", "f", ",", "2", ")", ";", "fprintf", "(", "f", ",", "\"\\t.code\\t16\\n\"", ")", ";", "fprintf", "(", "f", ",", "\".Ltrampoline_start:\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tpush\\t{r0, r1}\\n\"", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\tr0, [%r, #8]\\n\"", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tmov\\t%r, r0\\n\"", ",", "STATIC_CHAIN_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tldr\\tr0, [%r, #8]\\n\"", ",", "PC_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tstr\\tr0, [%r, #4]\\n\"", ",", "SP_REGNUM", ")", ";", "asm_fprintf", "(", "f", ",", "\"\\tpop\\t{r0, %r}\\n\"", ",", "PC_REGNUM", ")", ";", "}", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "for", "a", "block", "containing", "the", "constant", "parts", "of", "a", "trampoline", ",", "leaving", "space", "for", "the", "variable", "parts", ".", "On", "the", "ARM", ",", "(", "if", "r8", "is", "the", "static", "chain", "regnum", ",", "and", "remembering", "that", "referencing", "pc", "adds", "an", "offset", "of", "8", ")", "the", "trampoline", "looks", "like", ":", "ldr", "r8", ",", "[", "pc", ",", "#", "0", "]", "ldr", "pc", ",", "[", "pc", "]", ".word", "static", "chain", "value", ".word", "function", "'s", "address", "XXX", "FIXME", ":", "When", "the", "trampoline", "returns", ",", "r8", "will", "be", "clobbered", "." ]

[ "arm", "\"\\tldr\\t%r, [%r, #0]\\n\"", "\"\\tldr\\t%r, [%r, #0]\\n\"", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", "\"\\tldr.w\\t%r, [%r, #4]\\n\"", "2", "\"\\t.code\\t16\\n\"", "\".Ltrampoline_start:\\n\"", "\"\\tpush\\t{r0, r1}\\n\"", "\"\\tldr\\tr0, [%r, #8]\\n\"", "\"\\tmov\\t%r, r0\\n\"", "\"\\tldr\\tr0, [%r, #8]\\n\"", "\"\\tstr\\tr0, [%r, #4]\\n\"", "\"\\tpop\\t{r0, %r}\\n\"" ]

[]

[ "<s>", "int", "const_ok_for_dimode_op", "(", "HOST_WIDE_INT", "i", ",", "enum", "rtx_code", "code", ")", "{", "HOST_WIDE_INT", "hi_val", "=", "(", "i", ">>", "32", ")", "&", "0xFFFFFFFF", ";", "HOST_WIDE_INT", "lo_val", "=", "i", "&", "0xFFFFFFFF", ";", "rtx", "hi", "=", "GEN_INT", "(", "hi_val", ")", ";", "rtx", "lo", "=", "GEN_INT", "(", "lo_val", ")", ";", "if", "(", "TARGET_THUMB1", ")", "return", "0", ";", "switch", "(", "code", ")", "{", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "return", "const_ok_for_op", "(", "hi_val", ",", "code", ")", "||", "hi_val", "==", "0xFFFFFFFF", "||", "const_ok_for_op", "(", "lo_val", ",", "code", ")", "||", "lo_val", "==", "0xFFFFFFFF", ";", "case", "PLUS", ":", "return", "arm_not_operand", "(", "hi", ",", "SImode", ")", "&&", "arm_add_operand", "(", "lo", ",", "SImode", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "I", "is", "a", "valid", "di", "mode", "constant", "for", "the", "operation", "CODE", "." ]

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

[]

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

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

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

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "TM", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "RetValue", "=", "convertValVTToLocVT", "(", "DAG", ",", "DL", ",", "VA", ",", "RetValue", ")", ";", "unsigned", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RetValue", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "BitVector", "R600RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "HALF", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ONE", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ONE_INT", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "NEG_HALF", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "NEG_ONE", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PV_X", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ALU_LITERAL_X", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ALU_CONST", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PREDICATE_BIT", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PRED_SEL_OFF", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PRED_SEL_ZERO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PRED_SEL_ONE", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "begin", "(", ")", ",", "E", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "const", "R600InstrInfo", "*", "RII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "std", "::", "vector", "<", "unsigned", ">", "IndirectRegs", "=", "RII", "->", "getIndirectReservedRegs", "(", "MF", ")", ";", "for", "(", "std", "::", "vector", "<", "unsigned", ">", "::", "iterator", "I", "=", "IndirectRegs", ".", "begin", "(", ")", ",", "E", "=", "IndirectRegs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "static", "void", "aarch64_emit_sve_or_fp_conds", "(", "rtx", "target", ",", "rtx_code", "code1", ",", "rtx_code", "code2", ",", "rtx", "pred", ",", "bool", "known_ptrue_p", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "pred_mode", "=", "GET_MODE", "(", "pred", ")", ";", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_sve_fp_cond", "(", "tmp1", ",", "code1", ",", "pred", ",", "known_ptrue_p", ",", "op0", ",", "op1", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_sve_fp_cond", "(", "tmp2", ",", "code2", ",", "pred", ",", "known_ptrue_p", ",", "op0", ",", "op1", ")", ";", "aarch64_emit_binop", "(", "target", ",", "ior_optab", ",", "tmp1", ",", "tmp2", ")", ";", "}", "</s>" ]

[ "Emit", "the", "SVE", "equivalent", "of", ":", "(", "set", "TMP1", "(", "unspec", "[", "PRED", "KNOWN_PTRUE_P", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X1", ">", ")", ")", "(", "set", "TMP2", "(", "unspec", "[", "PRED", "KNOWN_PTRUE_P", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X2", ">", ")", ")", "(", "set", "TARGET", "(", "ior", ":", "PRED_MODE", "TMP1", "TMP2", ")", ")", "where", "<", "Xi", ">", "is", "the", "operation", "associated", "with", "comparison", "CODEi", ".", "KNOWN_PTRUE_P", "is", "true", "if", "PRED", "is", "known", "to", "be", "a", "PTRUE", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ")", "const", "override", "{", "return", "Ty", "->", "isArrayTy", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC" ]

[]

[ "<s>", "enum", "reg_class", "mmix_preferred_output_reload_class", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "enum", "reg_class", "class", ")", "{", "return", "GET_CODE", "(", "x", ")", "==", "MOD", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", "?", "REMAINDER_REG", ":", "class", ";", "}", "</s>" ]

[ "PREFERRED_OUTPUT_RELOAD_CLASS", ".", "We", "need", "to", "extend", "the", "reload", "class", "of", "REMAINDER_REG", "and", "HIMULT_REG", "." ]

[ "mmix" ]

[]

[ "<s>", "rtx", "function_arg", "(", "const", "struct", "sparc_args", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ",", "int", "incoming_p", ")", "{", "int", "regbase", "=", "(", "incoming_p", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "int", "slotno", ",", "regno", ",", "padding", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "rtx", "reg", ";", "slotno", "=", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "incoming_p", ",", "&", "regno", ",", "&", "padding", ")", ";", "if", "(", "slotno", "==", "-", "1", ")", "return", "0", ";", "if", "(", "TARGET_ARCH32", ")", "{", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "return", "reg", ";", "}", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "gcc_assert", "(", "int_size_in_bytes", "(", "type", ")", "<=", "16", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "slotno", ",", "named", ",", "regbase", ")", ";", "}", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "slotno", ",", "regno", ")", ";", "}", "else", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "16", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_vector_value", "(", "size", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ",", "SPARC_FP_ARG_FIRST", "+", "2", "*", "slotno", ")", ";", "else", "mclass", "=", "MODE_FLOAT", ";", "}", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "SPARC_FP_REG_P", "(", "regno", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "cum", "->", "prototype_p", "||", "cum", "->", "libcall_p", ")", "{", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", ">=", "SPARC_INT_ARG_MAX", "*", "2", ")", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ")", ")", ";", "else", "return", "reg", ";", "}", "else", "{", "rtx", "v0", ",", "v1", ";", "if", "(", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "<", "SPARC_INT_ARG_MAX", "*", "2", ")", "{", "int", "intreg", ";", "if", "(", "incoming_p", ")", "return", "reg", ";", "intreg", "=", "(", "SPARC_OUTGOING_INT_ARG_FIRST", "+", "(", "regno", "-", "SPARC_FP_ARG_FIRST", ")", "/", "2", ")", ";", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "intreg", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "else", "{", "v0", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "v1", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "v0", ",", "v1", ")", ")", ";", "}", "}", "}", "else", "{", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "return", "reg", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "." ]

[ "sparc", "1", "0", "16", "16", "16", "2", "2", "2", "2", "2", "2", "2" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "XCore", "XCore", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "RC", "==", "ARM", "::", "tGPRRegisterClass", ")", "RC", "=", "ARM", "::", "GPRRegisterClass", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "LDR", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", "||", "RC", "==", "ARM", "::", "DPR_VFP2RegisterClass", "||", "RC", "==", "ARM", "::", "DPR_8RegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VLDRD", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VLDRS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "{", "assert", "(", "(", "RC", "==", "ARM", "::", "QPRRegisterClass", "||", "RC", "==", "ARM", "::", "QPR_VFP2RegisterClass", "||", "RC", "==", "ARM", "::", "QPR_8RegisterClass", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "Align", ">=", "16", "&&", "(", "getRegisterInfo", "(", ")", ".", "canRealignStack", "(", "MF", ")", ")", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VLD1q64", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "128", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "else", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VLDRQ", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "ARM::tGPRRegisterClass", "ARM::GPRRegisterClass", "ARM::GPRRegisterClass", "ARM::LDR", "0", "0", "ARM::DPRRegisterClass", "ARM::DPR_VFP2RegisterClass", "ARM::DPR_8RegisterClass", "ARM::VLDRD", "0", "ARM::SPRRegisterClass", "ARM::VLDRS", "0", "ARM::QPRRegisterClass", "ARM::QPR_VFP2RegisterClass", "ARM::QPR_8RegisterClass", "\"Unknown regclass!\"", "16", "ARM::VLD1q64", "0", "0", "128", "ARM::VLDRQ", "0" ]

[]

[ "<s>", "bool", "MipsSETargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "CCState", "&", "CCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "MipsFunctionInfo", "&", "FI", ")", "const", "{", "if", "(", "!", "EnableMipsTailCalls", ")", "return", "false", ";", "if", "(", "FI", ".", "isISR", "(", ")", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getInRegsParamsCount", "(", ")", ">", "0", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "getIncomingArgSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

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

[]

[ "<s>", "static", "int", "must_parenthesize", "(", "rtx", "op", ")", "{", "const", "char", "*", "name", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "name", "=", "XSTR", "(", "op", ",", "0", ")", ";", "return", "(", "strcasecmp", "(", "name", ",", "\"a\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"b\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"d\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"x\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"y\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"ix\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"iy\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"pc\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"sp\"", ")", "==", "0", "||", "strcasecmp", "(", "name", ",", "\"ccr\"", ")", "==", "0", ")", "?", "1", ":", "0", ";", "case", "PLUS", ":", "case", "MINUS", ":", "return", "must_parenthesize", "(", "XEXP", "(", "op", ",", "0", ")", ")", "||", "must_parenthesize", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "case", "MEM", ":", "case", "CONST", ":", "case", "ZERO_EXTEND", ":", "case", "SIGN_EXTEND", ":", "return", "must_parenthesize", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "case", "CONST_DOUBLE", ":", "case", "CONST_INT", ":", "case", "LABEL_REF", ":", "case", "CODE_LABEL", ":", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "operand", "'op", "'", "must", "be", "printed", "with", "parenthesis", "around", "it", ".", "This", "must", "be", "done", "only", "if", "there", "is", "a", "symbol", "whose", "name", "is", "a", "processor", "register", "." ]

[ "m68hc11", "0", "\"a\"", "0", "\"b\"", "0", "\"d\"", "0", "\"x\"", "0", "\"y\"", "0", "\"ix\"", "0", "\"iy\"", "0", "\"pc\"", "0", "\"sp\"", "0", "\"ccr\"", "0", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "Tile64FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Tile64InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Tile64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "Tile64RegisterInfo", "&", "TRI", "=", "*", "static_cast", "<", "const", "Tile64RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "maxCallFrameSize", "=", "(", "int", ")", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "NumBytes", "+=", "maxCallFrameSize", ";", "NumBytes", "+=", "abs", "(", "getOffsetOfLocalArea", "(", ")", ")", ";", "NumBytes", "=", "-", "(", "(", "NumBytes", "+", "7", ")", "&", "~", "7", ")", ";", "int", "StackOffset", "=", "(", "int", ")", "MFI", "->", "hasCalls", "(", ")", "?", "MF", ".", "getInfo", "<", "Tile64MachineFunctionInfo", ">", "(", ")", "->", "getArgAreaOffset", "(", ")", ":", "0", ";", "NumBytes", "+=", "(", "-", "StackOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "T64", "::", "SW", ")", ")", ".", "addReg", "(", "T64", "::", "StackPointer", ")", ".", "addReg", "(", "T64", "::", "LinkRegister", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "T64", "::", "MOVE", ")", ",", "T64", "::", "FramePointer", ")", ".", "addReg", "(", "T64", "::", "StackPointer", ")", ";", "TRI", ".", "addOffset", "(", "MBB", ",", "MBBI", ",", "DL", ",", "T64", "::", "StackPointer", ",", "T64", "::", "StackPointer", ",", "NumBytes", ")", ";", "unsigned", "TmpReg", "=", "T64", "::", "R10", ";", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "T64", "::", "ADDI", ")", ",", "TmpReg", ")", ".", "addReg", "(", "T64", "::", "StackPointer", ")", ".", "addImm", "(", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "T64", "::", "SW", ")", ")", ".", "addReg", "(", "TmpReg", ")", ".", "addReg", "(", "T64", "::", "FramePointer", ")", ";", "}", "}", "</s>" ]

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

[ "Tile64", "7", "7", "0", "T64::SW", "T64::StackPointer", "T64::LinkRegister", "T64::MOVE", "T64::FramePointer", "T64::StackPointer", "T64::StackPointer", "T64::StackPointer", "T64::R10", "T64::ADDI", "T64::StackPointer", "4", "T64::SW", "T64::FramePointer" ]

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_v", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_X", ":", "if", "(", "!", "selectAddr", "(", "nullptr", ",", "Op", ",", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "Op2", ")", ";", "OutOps", ".", "push_back", "(", "Op3", ")", ";", "OutOps", ".", "push_back", "(", "Op4", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "WebAssemblySelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "IsVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "!", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "hasBulkMemory", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "MemIdx", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "MEMORY_COPY", ",", "DL", ",", "MVT", "::", "Other", ",", "{", "Chain", ",", "MemIdx", ",", "MemIdx", ",", "Dst", ",", "Src", ",", "DAG", ".", "getZExtOrTrunc", "(", "Size", ",", "DL", ",", "MVT", "::", "i32", ")", "}", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "MVT::i32", "WebAssemblyISD::MEMORY_COPY", "MVT::Other", "MVT::i32" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WSP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WZR", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Mono", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W15", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W29", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isX18Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W18", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W19", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64::WSP", "AArch64::WZR", "AArch64::W15", "AArch64::W29", "AArch64", "AArch64::W18", "AArch64::W19" ]

[]

[ "<s>", "const", "char", "*", "output_move_double", "(", "rtx", "*", "operands", ")", "{", "handle_move_double", "(", "operands", ",", "output_reg_adjust", ",", "output_compadr", ",", "output_movsi", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "appropriate", "code", "to", "load", "up", "an", "8", "byte", "integer", "or", "floating", "point", "value" ]

[ "m68k", "\"\"" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "bool", "ret", "=", "rs6000_cannot_change_mode_class", "(", "from", ",", "to", ",", "rclass", ")", ";", "fprintf", "(", "stderr", ",", "\"rs6000_cannot_change_mode_class, return %s, from = %s, \"", "\"to = %s, rclass = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ",", "GET_MODE_NAME", "(", "from", ")", ",", "GET_MODE_NAME", "(", "to", ")", ",", "reg_class_names", "[", "rclass", "]", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_cannot_change_mode_class", "." ]

[ "rs6000", "\"rs6000_cannot_change_mode_class, return %s, from = %s, \"", "\"to = %s, rclass = %s\\n\"", "\"true\"", "\"false\"" ]

[]

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

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

[ "Teak" ]

[]

[ "<s>", "unsigned", "DCPU16RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "DCPU16", "::", "J", ":", "DCPU16", "::", "SP", ";", "}", "</s>" ]

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

[ "Dcpu16", "DCPU16", "DCPU16::J", "DCPU16::SP" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "MipsFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "unsigned", "SP", "=", "STI", ".", "getABI", "(", ")", ".", "IsN64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "STI", ".", "getInstrInfo", "(", ")", "->", "adjustStackPtr", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "epilogue_renumber", "(", "register", "rtx", "*", "where", ",", "int", "test", ")", "{", "register", "const", "char", "*", "fmt", ";", "register", "int", "i", ";", "register", "enum", "rtx_code", "code", ";", "if", "(", "*", "where", "==", "0", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "*", "where", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "*", "where", ")", ">=", "8", "&&", "REGNO", "(", "*", "where", ")", "<", "24", ")", "return", "1", ";", "if", "(", "!", "test", "&&", "REGNO", "(", "*", "where", ")", ">=", "24", "&&", "REGNO", "(", "*", "where", ")", "<", "32", ")", "*", "where", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "*", "where", ")", ",", "OUTGOING_REGNO", "(", "REGNO", "(", "*", "where", ")", ")", ")", ";", "case", "SCRATCH", ":", "case", "CC0", ":", "case", "PC", ":", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "0", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "*", "where", ",", "1", ")", ")", "<", "SPARC_STACK_BIAS", ")", ")", "return", "1", ";", "break", ";", "case", "MEM", ":", "if", "(", "SPARC_STACK_BIAS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "register", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "*", "where", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "epilogue_renumber", "(", "&", "(", "XVECEXP", "(", "*", "where", ",", "i", ",", "j", ")", ")", ",", "test", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "epilogue_renumber", "(", "&", "(", "XEXP", "(", "*", "where", ",", "i", ")", ")", ",", "test", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", ",", "if", "any", "of", "the", "registers", "of", "the", "instruction", "are", "%", "l", "[", "0-7", "]", "or", "%", "o", "[", "0-7", "]", ".", "Such", "instructions", "can", "not", "be", "used", "in", "the", "delay", "slot", "of", "return", "insn", "on", "v9", ".", "If", "TEST", "is", "0", ",", "also", "rename", "all", "%", "i", "[", "0-7", "]", "registers", "to", "their", "%", "o", "[", "0-7", "]", "counterparts", "." ]

[ "sparc", "0", "0", "8", "24", "1", "24", "32", "0", "0", "0", "1", "1", "1", "0", "0", "1", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "return", "LowerCTTZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "return", "LowerCTTZ_ZERO_UNDEF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "OR1K", "OR1K", "ISD::BR_CC", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::CTTZ", "ISD::CTTZ_ZERO_UNDEF", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::RETURNADDR", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]

[ "<s>", "void", "OpenRISCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "0", "&&", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "0", "\"Unimplemented\"" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "Move32R16", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "S0", ")", ";", "TII", ".", "restoreFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips::Move32R16", "Mips::SP", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "static", "void", "frv_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\\n\"", ",", "*", "cum", ",", "GET_MODE_NAME", "(", "arg", ".", "mode", ")", ",", "*", "pretend_size", ",", "second_time", ")", ";", "}", "</s>" ]

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

[ "frv", "\"setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\\n\"" ]

[]

[ "<s>", "void", "AArch64InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "Align", ")", ";", "unsigned", "LoadOp", "=", "0", ";", "if", "(", "RC", "->", "hasType", "(", "MVT", "::", "i64", ")", "||", "RC", "->", "hasType", "(", "MVT", "::", "i32", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", ")", "{", "case", "4", ":", "LoadOp", "=", "AArch64", "::", "LS32_LDR", ";", "break", ";", "case", "8", ":", "LoadOp", "=", "AArch64", "::", "LS64_LDR", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown size for regclass\"", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "RC", "->", "hasType", "(", "MVT", "::", "f32", ")", "||", "RC", "->", "hasType", "(", "MVT", "::", "f64", ")", "||", "RC", "->", "hasType", "(", "MVT", "::", "f128", ")", ")", "&&", "\"Expected integer or floating type for store\"", ")", ";", "switch", "(", "RC", "->", "getSize", "(", ")", ")", "{", "case", "4", ":", "LoadOp", "=", "AArch64", "::", "LSFP32_LDR", ";", "break", ";", "case", "8", ":", "LoadOp", "=", "AArch64", "::", "LSFP64_LDR", ";", "break", ";", "case", "16", ":", "LoadOp", "=", "AArch64", "::", "LSFP128_LDR", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unknown size for regclass\"", ")", ";", "}", "}", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "LoadOp", ")", ",", "DestReg", ")", ";", "NewMI", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "MVT::i64", "MVT::i32", "4", "AArch64::LS32_LDR", "8", "AArch64::LS64_LDR", "\"Unknown size for regclass\"", "MVT::f32", "MVT::f64", "MVT::f128", "\"Expected integer or floating type for store\"", "4", "AArch64::LSFP32_LDR", "8", "AArch64::LSFP64_LDR", "16", "AArch64::LSFP128_LDR", "\"Unknown size for regclass\"", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isEligibleForTailCallOptimization", "(", "CCState", "&", "CCInfo", ",", "CallLoweringInfo", "&", "CLI", ",", "MachineFunction", "&", "MF", ",", "const", "SmallVector", "<", "CCValAssign", ",", "16", ">", "&", "ArgLocs", ")", "const", "{", "auto", "&", "Callee", "=", "CLI", ".", "Callee", ";", "auto", "CalleeCC", "=", "CLI", ".", "CallConv", ";", "auto", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "auto", "&", "Outs", "=", "CLI", ".", "Outs", ";", "auto", "&", "Caller", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "CallerCC", "=", "Caller", ".", "getCallingConv", "(", ")", ";", "if", "(", "Caller", ".", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "if", "(", "Caller", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "return", "false", ";", "auto", "IsCallerStructRet", "=", "Caller", ".", "hasStructRetAttr", "(", ")", ";", "auto", "IsCalleeStructRet", "=", "Outs", ".", "empty", "(", ")", "?", "false", ":", "Outs", "[", "0", "]", ".", "Flags", ".", "isSRet", "(", ")", ";", "if", "(", "IsCallerStructRet", "||", "IsCalleeStructRet", ")", "return", "false", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "if", "(", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "false", ";", "}", "const", "RISCVRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "CalleeCC", "!=", "CallerCC", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "Outs", ")", "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "RISCV", "RISCV", "16", "\"disable-tail-calls\"", "\"true\"", "\"interrupt\"", "0", "0", "RISCV" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "isGVIndirectSymbol", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "if", "(", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "true", ";", "if", "(", "isTargetDarwin", "(", ")", "&&", "TM", ".", "isPositionIndependent", "(", ")", "&&", "(", "GV", "->", "isDeclarationForLinker", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "True", "if", "the", "GV", "will", "be", "accessed", "via", "an", "indirect", "symbol", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "parsePrimaryExpr", "(", "const", "MCExpr", "*", "&", "Res", ",", "SMLoc", "&", "EndLoc", ")", "override", "{", "return", "MCTargetAsmParser", "::", "parsePrimaryExpr", "(", "Res", ",", "EndLoc", ")", ";", "}", "</s>" ]

[ "Parse", "a", "primary", "expression", "." ]

[ "MOS" ]

[]

[ "<s>", "void", "BPFMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "support", "::", "endian", "::", "Writer", "OSE", "(", "OS", ",", "IsLittleEndian", "?", "support", "::", "little", ":", "support", "::", "big", ")", ";", "if", "(", "Opcode", "==", "BPF", "::", "LD_imm64", "||", "Opcode", "==", "BPF", "::", "LD_pseudo", ")", "{", "uint64_t", "Value", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "OS", "<<", "char", "(", "Value", ">>", "56", ")", ";", "if", "(", "IsLittleEndian", ")", "OS", "<<", "char", "(", "(", "Value", ">>", "48", ")", "&", "0xff", ")", ";", "else", "OS", "<<", "char", "(", "SwapBits", "(", "(", "Value", ">>", "48", ")", "&", "0xff", ")", ")", ";", "OSE", ".", "write", "<", "uint16_t", ">", "(", "0", ")", ";", "OSE", ".", "write", "<", "uint32_t", ">", "(", "Value", "&", "0xffffFFFF", ")", ";", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "uint64_t", "Imm", "=", "MO", ".", "isImm", "(", ")", "?", "MO", ".", "getImm", "(", ")", ":", "0", ";", "OSE", ".", "write", "<", "uint8_t", ">", "(", "0", ")", ";", "OSE", ".", "write", "<", "uint8_t", ">", "(", "0", ")", ";", "OSE", ".", "write", "<", "uint16_t", ">", "(", "0", ")", ";", "OSE", ".", "write", "<", "uint32_t", ">", "(", "Imm", ">>", "32", ")", ";", "}", "else", "{", "uint64_t", "Value", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "OS", "<<", "char", "(", "Value", ">>", "56", ")", ";", "if", "(", "IsLittleEndian", ")", "OS", "<<", "char", "(", "(", "Value", ">>", "48", ")", "&", "0xff", ")", ";", "else", "OS", "<<", "char", "(", "SwapBits", "(", "(", "Value", ">>", "48", ")", "&", "0xff", ")", ")", ";", "OSE", ".", "write", "<", "uint16_t", ">", "(", "(", "Value", ">>", "32", ")", "&", "0xffff", ")", ";", "OSE", ".", "write", "<", "uint32_t", ">", "(", "Value", "&", "0xffffFFFF", ")", ";", "}", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "BPF", "BPF", "support::endian", "support::little", "support::big", "BPF::LD_imm64", "BPF::LD_pseudo", "56", "48", "0xff", "48", "0xff", "0", "0xffffFFFF", "1", "0", "0", "0", "0", "32", "56", "48", "0xff", "48", "0xff", "32", "0xffff", "0xffffFFFF" ]

[]

[ "<s>", "static", "void", "arm_override_options_after_change", "(", "void", ")", "{", "arm_override_options_after_change_1", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "</s>" ]

[ "Implement", "targetm.override_options_after_change", "." ]

[ "arm" ]

[]

[ "<s>", "static", "rtx_insn", "*", "find_next_insn_start", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "GET_MODE", "(", "insn", ")", "==", "SImode", ")", "{", "while", "(", "GET_MODE", "(", "insn", ")", "!=", "QImode", ")", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "return", "NEXT_INSN", "(", "insn", ")", ";", "}", "</s>" ]

[ "This", "function", "acts", "like", "NEXT_INSN", ",", "but", "is", "aware", "of", "three-insn", "bundles", "and", "skips", "all", "subsequent", "parallel", "instructions", "if", "INSN", "is", "the", "start", "of", "such", "a", "group", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "auto", "&", "Args", "=", "F", ".", "getArgumentList", "(", ")", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "1", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "MIRBuilder", ".", "buildSequence", "(", "VRegs", "[", "i", "]", ",", "Regs", ",", "Offsets", ")", ";", "}", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "AssignFn", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "8", "0", "1", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Alpha", "::", "F4RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "STS", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "F8RCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "STT", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "if", "(", "RC", "==", "Alpha", "::", "GPRCRegisterClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "STQ", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "else", "abort", "(", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::F4RCRegisterClass", "Alpha::STS", "Alpha::F31", "Alpha::F8RCRegisterClass", "Alpha::STT", "Alpha::F31", "Alpha::GPRCRegisterClass", "Alpha::STQ", "Alpha::F31" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "STI", ".", "is64Bit", "(", ")", "||", "!", "MF", ".", "getMMI", "(", ")", ".", "hasEHFunclets", "(", ")", "||", "classifyEHPersonality", "(", "Fn", "->", "getPersonalityFn", "(", ")", ")", "!=", "EHPersonality", "::", "MSVC_CXX", ")", "return", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int64_t", "MinFixedObjOffset", "=", "-", "SlotSize", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "I", "<", "0", ";", "++", "I", ")", "MinFixedObjOffset", "=", "std", "::", "min", "(", "MinFixedObjOffset", ",", "MFI", "->", "getObjectOffset", "(", "I", ")", ")", ";", "int64_t", "UnwindHelpOffset", "=", "MinFixedObjOffset", "-", "SlotSize", ";", "int", "UnwindHelpFI", "=", "MFI", "->", "CreateFixedObject", "(", "SlotSize", ",", "UnwindHelpOffset", ",", "false", ")", ";", "MF", ".", "getWinEHFuncInfo", "(", ")", "->", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64mi32", ")", ")", ",", "UnwindHelpFI", ")", ".", "addImm", "(", "-", "2", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "X86::MOV64mi32", "2" ]

[]

[ "<s>", "unsigned", "RISCVTTIImpl", "::", "getRegUsageForType", "(", "Type", "*", "Ty", ")", "{", "TypeSize", "Size", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", ")", "{", "if", "(", "Size", ".", "isScalable", "(", ")", "&&", "ST", "->", "hasVInstructions", "(", ")", ")", "return", "divideCeil", "(", "Size", ".", "getKnownMinValue", "(", ")", ",", "RISCV", "::", "RVVBitsPerBlock", ")", ";", "if", "(", "ST", "->", "useRVVForFixedLengthVectors", "(", ")", ")", "return", "divideCeil", "(", "Size", ",", "ST", "->", "getMinRVVVectorSizeInBits", "(", ")", ")", ";", "}", "return", "BaseT", "::", "getRegUsageForType", "(", "Ty", ")", ";", "}", "</s>" ]

[ "Returns", "the", "estimated", "number", "of", "registers", "required", "to", "represent", "Ty", "." ]

[ "RISCV", "RISCV", "RISCV::RVVBitsPerBlock" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "MachineBasicBlock", "*", "PrologB", "=", "&", "MF", ".", "front", "(", ")", ",", "*", "EpilogB", "=", "nullptr", ";", "if", "(", "EnableShrinkWrapping", ")", "findShrunkPrologEpilog", "(", "MF", ",", "PrologB", ",", "EpilogB", ")", ";", "bool", "PrologueStubs", "=", "false", ";", "insertCSRSpillsInBlock", "(", "*", "PrologB", ",", "CSI", ",", "HRI", ",", "PrologueStubs", ")", ";", "insertPrologueInBlock", "(", "*", "PrologB", ",", "PrologueStubs", ")", ";", "updateEntryPaths", "(", "MF", ",", "*", "PrologB", ")", ";", "if", "(", "EpilogB", ")", "{", "insertCSRRestoresInBlock", "(", "*", "EpilogB", ",", "CSI", ",", "HRI", ")", ";", "insertEpilogueInBlock", "(", "*", "EpilogB", ")", ";", "}", "else", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "isReturnBlock", "(", ")", ")", "insertCSRRestoresInBlock", "(", "B", ",", "CSI", ",", "HRI", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "isReturnBlock", "(", ")", ")", "insertEpilogueInBlock", "(", "B", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "{", "if", "(", "B", ".", "empty", "(", ")", ")", "continue", ";", "MachineInstr", "*", "RetI", "=", "getReturn", "(", "B", ")", ";", "if", "(", "!", "RetI", "||", "isRestoreCall", "(", "RetI", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "&", "R", ":", "CSI", ")", "RetI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "R", ".", "getReg", "(", ")", ",", "false", ",", "true", ")", ")", ";", "}", "}", "if", "(", "EpilogB", ")", "{", "unsigned", "MaxBN", "=", "MF", ".", "getNumBlockIDs", "(", ")", ";", "BitVector", "DoneT", "(", "MaxBN", "+", "1", ")", ",", "DoneF", "(", "MaxBN", "+", "1", ")", ",", "Path", "(", "MaxBN", "+", "1", ")", ";", "updateExitPaths", "(", "*", "EpilogB", ",", "*", "EpilogB", ",", "DoneT", ",", "DoneF", ",", "Path", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "VEFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "void", "ix86_move_vector_high_sse_to_mmx", "(", "rtx", "op", ")", "{", "rtx", "mask", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "4", ",", "GEN_INT", "(", "0", ")", ",", "GEN_INT", "(", "2", ")", ",", "GEN_INT", "(", "0", ")", ",", "GEN_INT", "(", "0", ")", ")", ")", ";", "rtx", "dest", "=", "lowpart_subreg", "(", "V4SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", ")", ";", "op", "=", "gen_rtx_VEC_SELECT", "(", "V4SImode", ",", "dest", ",", "mask", ")", ";", "rtx", "insn", "=", "gen_rtx_SET", "(", "dest", ",", "op", ")", ";", "emit_insn", "(", "insn", ")", ";", "}", "</s>" ]

[ "Move", "bits", "64:95", "to", "bits", "32:63", "." ]

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

[]

[ "<s>", "void", "h8300_expand_store", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "2", "]", ";", "rtx", "op1", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_COMPARE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc0_rtx", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "dest", ")", ",", "cc0_rtx", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "tmp", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "conditional", "store", "." ]

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

[]

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

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

[ "epiphany" ]

[]

[ "<s>", "static", "rtx", "ia64_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "machine_mode", "hfa_mode", ";", "int", "unsignedp", ";", "const_tree", "func", "=", "fn_decl_or_type", ";", "if", "(", "fn_decl_or_type", "&&", "!", "DECL_P", "(", "fn_decl_or_type", ")", ")", "func", "=", "NULL", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "hfa_mode", "=", "hfa_element_mode", "(", "valtype", ",", "0", ")", ";", "if", "(", "hfa_mode", "!=", "VOIDmode", ")", "{", "rtx", "loc", "[", "8", "]", ";", "int", "i", ";", "int", "hfa_size", ";", "int", "byte_size", ";", "int", "offset", ";", "hfa_size", "=", "GET_MODE_SIZE", "(", "hfa_mode", ")", ";", "byte_size", "=", "(", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "valtype", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "offset", "=", "0", ";", "for", "(", "i", "=", "0", ";", "offset", "<", "byte_size", ";", "i", "++", ")", "{", "loc", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "hfa_mode", ",", "FR_ARG_FIRST", "+", "i", ")", ",", "GEN_INT", "(", "offset", ")", ")", ";", "offset", "+=", "hfa_size", ";", "}", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "i", ",", "loc", ")", ")", ";", "}", "else", "if", "(", "FLOAT_TYPE_P", "(", "valtype", ")", "&&", "mode", "!=", "TFmode", "&&", "mode", "!=", "TCmode", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FR_ARG_FIRST", ")", ";", "else", "{", "bool", "need_parallel", "=", "false", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "(", "mode", "==", "BLKmode", "||", "(", "valtype", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", ")", ")", ")", "need_parallel", "=", "true", ";", "else", "if", "(", "mode", "==", "XFmode", "||", "mode", "==", "XCmode", "||", "mode", "==", "RFmode", ")", "need_parallel", "=", "true", ";", "if", "(", "need_parallel", ")", "{", "rtx", "loc", "[", "8", "]", ";", "int", "offset", ";", "int", "bytesize", ";", "int", "i", ";", "offset", "=", "0", ";", "bytesize", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "bytesize", "==", "0", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GR_RET_FIRST", ")", ";", "for", "(", "i", "=", "0", ";", "offset", "<", "bytesize", ";", "i", "++", ")", "{", "loc", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "DImode", ",", "GR_RET_FIRST", "+", "i", ")", ",", "GEN_INT", "(", "offset", ")", ")", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "i", ",", "loc", ")", ")", ";", "}", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsignedp", ",", "func", "?", "TREE_TYPE", "(", "func", ")", ":", "NULL_TREE", ",", "true", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "GR_RET_FIRST", ")", ";", "}", "}", "</s>" ]

[ "Return", "rtx", "for", "register", "that", "holds", "the", "function", "return", "value", "." ]

[ "ia64", "0", "8", "0", "0", "8", "0", "0", "0" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "DL", ",", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "MVT::Other" ]

[]

[ "<s>", "void", "M680x0FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "M680x0MachineFunctionInfo", "*", "M680x0FI", "=", "MF", ".", "getInfo", "<", "M680x0MachineFunctionInfo", ">", "(", ")", ";", "int64_t", "TailCallReturnAddrDelta", "=", "M680x0FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "TailCallReturnAddrDelta", ",", "TailCallReturnAddrDelta", "-", "SlotSize", ",", "true", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "TRI", "->", "getBaseRegister", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

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

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "aarch64_and_bitmask_imm", "(", "unsigned", "HOST_WIDE_INT", "val_in", ",", "machine_mode", "mode", ")", "{", "scalar_int_mode", "int_mode", ";", "if", "(", "!", "is_a", "<", "scalar_int_mode", ">", "(", "mode", ",", "&", "int_mode", ")", ")", "return", "false", ";", "if", "(", "aarch64_bitmask_imm", "(", "val_in", ",", "int_mode", ")", ")", "return", "false", ";", "if", "(", "aarch64_move_imm", "(", "val_in", ",", "int_mode", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "imm2", "=", "aarch64_and_split_imm2", "(", "val_in", ")", ";", "return", "aarch64_bitmask_imm", "(", "imm2", ",", "int_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "VAL_IN", "is", "a", "valid", "'and", "'", "bitmask", "immediate", "." ]

[ "aarch64" ]

[]

[ "<s>", "const", "uint32_t", "*", "getRegMaskBits", "(", "RegisterId", "R", ")", "const", "{", "return", "RegMasks", ".", "get", "(", "TargetRegisterInfo", "::", "stackSlot2Index", "(", "R", ")", ")", ";", "}", "</s>" ]

[ "Returns", "an", "array", "of", "register", "mask", "pointers", "corresponding", "to", "getRegMaskSlots", "(", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "P2TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "P2ISD", "::", "RET", ":", "return", "\"P2RET\"", ";", "case", "P2ISD", "::", "CALL", ":", "return", "\"P2CALL\"", ";", "case", "P2ISD", "::", "GAWRAPPER", ":", "return", "\"P2GAWRAPPER\"", ";", "default", ":", "return", "nullptr", ";", "}", "}", "</s>" ]

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

[ "P2", "P2", "P2ISD::RET", "\"P2RET\"", "P2ISD::CALL", "\"P2CALL\"", "P2ISD::GAWRAPPER", "\"P2GAWRAPPER\"" ]

[]

[ "<s>", "void", "aarch64_simd_lane_bounds", "(", "rtx", "operand", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ",", "const_tree", "exp", ")", "{", "HOST_WIDE_INT", "lane", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operand", ")", ")", ";", "lane", "=", "INTVAL", "(", "operand", ")", ";", "if", "(", "lane", "<", "low", "||", "lane", ">=", "high", ")", "{", "if", "(", "exp", ")", "error", "(", "\"%Klane %wd out of range %wd - %wd\"", ",", "exp", ",", "lane", ",", "low", ",", "high", "-", "1", ")", ";", "else", "error", "(", "\"lane %wd out of range %wd - %wd\"", ",", "lane", ",", "low", ",", "high", "-", "1", ")", ";", "}", "}", "</s>" ]

[ "Bounds-check", "lanes", ".", "Ensure", "OPERAND", "lies", "between", "LOW", "(", "inclusive", ")", "and", "HIGH", "(", "exclusive", ")", "." ]

[ "aarch64", "\"%Klane %wd out of range %wd - %wd\"", "1", "\"lane %wd out of range %wd - %wd\"", "1" ]

[]

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

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "Blackfin", "MVT::i16" ]

[]

[ "<s>", "static", "void", "store_reg", "(", "int", "reg", ",", "HOST_WIDE_INT", "disp", ",", "int", "base", ")", "{", "rtx", "dest", ",", "src", ",", "basereg", ";", "rtx_insn", "*", "insn", ";", "src", "=", "gen_rtx_REG", "(", "word_mode", ",", "reg", ")", ";", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "if", "(", "VAL_14_BITS_P", "(", "disp", ")", ")", "{", "dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "Pmode", ",", "basereg", ",", "disp", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "}", "else", "if", "(", "TARGET_64BIT", "&&", "!", "VAL_32_BITS_P", "(", "disp", ")", ")", "{", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "delta", ")", ";", "insn", "=", "emit_move_insn", "(", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "tmpreg", ",", "basereg", ")", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "{", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "delta", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "tmpreg", ")", ";", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "}", "else", "{", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "high", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "delta", ")", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "high", ")", ";", "dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmpreg", ",", "delta", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_PLUS", "(", "word_mode", ",", "basereg", ",", "delta", ")", ")", ",", "src", ")", ")", ";", "}", "if", "(", "DO_FRAME_NOTES", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "store", "REG", "at", "the", "memory", "location", "specified", "by", "BASE+DISP", ".", "Handle", "case", "where", "DISP", ">", "8k", "by", "using", "the", "add_high_const", "patterns", ".", "Note", "in", "DISP", ">", "8k", "case", ",", "we", "will", "leave", "the", "high", "part", "of", "the", "address", "in", "%", "r1", ".", "There", "is", "code", "in", "expand_hppa_", "{", "prologue", ",", "epilogue", "}", "that", "knows", "this", "." ]

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

[]

[ "<s>", "static", "bool", "riscv_valid_lo_sum_p", "(", "enum", "riscv_symbol_type", "sym_type", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "int", "align", ",", "size", ";", "if", "(", "riscv_symbol_insns", "(", "sym_type", ")", "==", "0", ")", "return", "false", ";", "if", "(", "!", "riscv_split_symbol_type", "(", "sym_type", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "!", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "false", ";", "align", "=", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "DECL_ALIGN", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "1", ")", ";", "size", "=", "(", "SYMBOL_REF_DECL", "(", "x", ")", "&&", "DECL_SIZE", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", "?", "tree_to_uhwi", "(", "DECL_SIZE", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ")", ":", "2", "*", "BITS_PER_WORD", ")", ";", "}", "else", "{", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "size", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "}", "if", "(", "size", ">", "BITS_PER_WORD", "&&", "(", "!", "TARGET_STRICT_ALIGN", "||", "size", ">", "align", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "LO_SUM", "can", "address", "a", "value", "of", "mode", "MODE", "when", "the", "LO_SUM", "symbol", "has", "type", "SYM_TYPE", "." ]

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

[]

[ "<s>", "void", "GBZ80MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "assert", "(", "Size", ">", "0", "&&", "\"Instruction size cannot be zero\"", ")", ";", "uint64_t", "BinaryOpCode", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "emitInstruction", "(", "BinaryOpCode", ",", "Size", ",", "STI", ",", "OS", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "GBZ80", "GB", "0", "\"Instruction size cannot be zero\"" ]

[]

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

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

[ "SHUXI" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "ExpandRetRA", "(", "MBB", ",", "MI", ",", "Mips", "::", "RET", ")", ";", "break", ";", "case", "Mips", "::", "RetRA16", ":", "ExpandRetRA", "(", "MBB", ",", "MI", ",", "Mips", "::", "RET16", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "ExpandBuildPairF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "ExpandExtractElementF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips::RET", "Mips::RetRA16", "Mips::RET16", "Mips::BuildPairF64", "Mips::ExtractElementF64" ]

[]

[ "<s>", "bool", "MipsTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createMipsDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "fma_node", "::", "rename", "(", "fma_forest", "*", "forest", ")", "{", "int", "cur_parity", ",", "target_parity", ";", "if", "(", "!", "this", "->", "m_head", ")", "return", ";", "target_parity", "=", "forest", "->", "get_target_parity", "(", ")", ";", "if", "(", "this", "->", "m_parent", ")", "target_parity", "=", "this", "->", "m_parent", "->", "get_parity", "(", ")", ";", "cur_parity", "=", "this", "->", "get_parity", "(", ")", ";", "if", "(", "cur_parity", "!=", "target_parity", ")", "{", "rtx_insn", "*", "insn", "=", "this", "->", "m_insn", ";", "HARD_REG_SET", "unavailable", ";", "machine_mode", "mode", ";", "int", "reg", ";", "if", "(", "dump_file", ")", "{", "unsigned", "cur_dest_reg", "=", "this", "->", "m_head", "->", "regno", ";", "fprintf", "(", "dump_file", ",", "\"FMA or FMUL at insn %d but destination \"", "\"register (%s) has different parity from expected to \"", "\"maximize FPU pipeline utilization\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "reg_names", "[", "cur_dest_reg", "]", ")", ";", "}", "CLEAR_HARD_REG_SET", "(", "unavailable", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "add_to_hard_reg_set", "(", "&", "unavailable", ",", "Pmode", ",", "FRAME_POINTER_REGNUM", ")", ";", "add_to_hard_reg_set", "(", "&", "unavailable", ",", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "mode", "=", "GET_MODE", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ")", ";", "for", "(", "reg", "=", "cur_parity", ";", "reg", "<", "FIRST_PSEUDO_REGISTER", ";", "reg", "+=", "2", ")", "add_to_hard_reg_set", "(", "&", "unavailable", ",", "mode", ",", "reg", ")", ";", "if", "(", "!", "rename_single_chain", "(", "this", "->", "m_head", ",", "&", "unavailable", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Destination register of insn %d could not be \"", "\"renamed. Dependent FMA insns will use this parity from \"", "\"there on.\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "else", "cur_parity", "=", "target_parity", ";", "}", "forest", "->", "get_globals", "(", ")", "->", "update_balance", "(", "cur_parity", ")", ";", "}", "</s>" ]

[ "Rename", "the", "destination", "register", "of", "a", "single", "FMUL", "or", "FMADD/FMSUB", "instruction", "represented", "by", "FMA_NODE", "to", "a", "register", "that", "respect", "the", "target", "parity", "for", "FOREST", "or", "with", "same", "parity", "of", "the", "instruction", "represented", "by", "its", "parent", "node", "if", "it", "has", "one", "." ]

[ "aarch64", "\"FMA or FMUL at insn %d but destination \"", "\"register (%s) has different parity from expected to \"", "\"maximize FPU pipeline utilization\\n\"", "2", "\"Destination register of insn %d could not be \"", "\"renamed. Dependent FMA insns will use this parity from \"", "\"there on.\\n\"" ]

[]

[ "<s>", "void", "SystemZDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "if", "(", "Subtarget", "->", "hasLoadStoreOnCond2", "(", ")", ")", "return", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "N", "->", "use_empty", "(", ")", ")", "continue", ";", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "Res", "=", "expandSelectBoolean", "(", "N", ")", ";", "break", ";", "}", "if", "(", "Res", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"SystemZ DAG preprocessing replacing:\\nOld: \"", ")", ";", "DEBUG", "(", "N", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nNew: \"", ")", ";", "DEBUG", "(", "Res", ".", "getNode", "(", ")", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Res", ")", ";", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "MadeChange", ")", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZISD::SELECT_CCMASK", "\"SystemZ DAG preprocessing replacing:\\nOld: \"", "\"\\nNew: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "int", "avr_io_address_p", "(", "rtx", "x", ",", "int", "size", ")", "{", "return", "(", "optimize", ">", "0", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "x", ")", ">=", "0x20", "&&", "INTVAL", "(", "x", ")", "<=", "0x60", "-", "size", ")", ";", "}", "</s>" ]

[ "Returns", "1", "if", "X", "is", "a", "valid", "address", "for", "an", "I/O", "register", "of", "size", "SIZE", "(", "1", "or", "2", ")", ".", "Used", "for", "lds/sts", "-", ">", "in/out", "optimization", ".", "Add", "0x20", "to", "SIZE", "to", "check", "for", "the", "lower", "half", "of", "I/O", "space", "(", "for", "cbi/sbi/sbic/sbis", ")", "." ]

[ "avr", "0", "0x20", "0x60" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "DiagnosticInfo", "*", "DI", ")", "{", "return", "DI", "->", "getKind", "(", ")", "==", "getKindID", "(", ")", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "BPF" ]

[]

[ "<s>", "static", "rtx", "rx_function_arg", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "unsigned", "int", "next_reg", ";", "unsigned", "int", "bytes_so_far", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "unsigned", "int", "size", ";", "unsigned", "int", "rounded_size", ";", "size", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "if", "(", "size", "<", "1", ")", "return", "NULL_RTX", ";", "rounded_size", "=", "rx_round_up", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "rounded_size", "+", "bytes_so_far", ">", "MAX_NUM_ARG_BYTES", ")", "return", "NULL_RTX", ";", "if", "(", "!", "arg", ".", "named", ")", "return", "NULL_RTX", ";", "if", "(", "(", "arg", ".", "type", "==", "NULL", "||", "AGGREGATE_TYPE_P", "(", "arg", ".", "type", ")", ")", "&&", "(", "size", "%", "UNITS_PER_WORD", ")", "!=", "0", ")", "return", "NULL_RTX", ";", "next_reg", "=", "(", "bytes_so_far", "/", "UNITS_PER_WORD", ")", "+", "1", ";", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "next_reg", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "describing", "the", "register", "holding", "a", "function", "parameter", "of", "mode", "MODE", "and", "type", "TYPE", "or", "NULL_RTX", "if", "the", "parameter", "should", "be", "passed", "on", "the", "stack", ".", "CUM", "describes", "the", "previous", "parameters", "to", "the", "function", "and", "NAMED", "is", "false", "if", "the", "parameter", "is", "part", "of", "a", "variable", "parameter", "list", ",", "or", "the", "last", "named", "parameter", "before", "the", "start", "of", "a", "variable", "parameter", "list", "." ]

[ "rx", "1", "0", "1" ]

[]

[ "<s>", "bool", "EquivSubstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "RNG", ")", "RNG", ".", "reset", "(", "Fn", ".", "getFunction", "(", ")", "->", "getParent", "(", ")", "->", "createRNG", "(", "this", ")", ")", ";", "bool", "Changed", "=", "false", ";", "std", "::", "vector", "<", "const", "EquivInsnFilter", "*", ">", "Candidates", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", ")", "{", "++", "PreEquivSubstInstructionCount", ";", "Candidates", ".", "clear", "(", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "array_lengthof", "(", "Filters", ")", ";", "i", "++", ")", "if", "(", "Filters", "[", "i", "]", "->", "check", "(", "*", "BB", ",", "*", "I", ")", ")", "Candidates", ".", "push_back", "(", "Filters", "[", "i", "]", ")", ";", "if", "(", "Candidates", ".", "empty", "(", ")", ")", "{", "++", "I", ";", "continue", ";", "}", "unsigned", "int", "Roll", "=", "RNG", "->", "Random", "(", "100", ")", ";", "++", "EquivSubstCandidates", ";", "if", "(", "Roll", ">=", "multicompiler", "::", "EquivSubstPercentage", ")", "{", "++", "I", ";", "continue", ";", "}", "unsigned", "int", "Pick", "=", "RNG", "->", "Random", "(", "Candidates", ".", "size", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "J", "=", "I", ";", "++", "I", ";", "Candidates", "[", "Pick", "]", "->", "subst", "(", "*", "BB", ",", "TII", ",", "J", ")", ";", "Changed", "=", "true", ";", "++", "EquivSubstituted", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* Hexagon Hardware Loops *********\\n\"", ")", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "HexagonSubtarget", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "L", ":", "*", "MLI", ")", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "{", "bool", "L0Used", "=", "false", ";", "bool", "L1Used", "=", "false", ";", "Changed", "|=", "convertToHardwareLoop", "(", "L", ",", "L0Used", ",", "L1Used", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"********* Hexagon Hardware Loops *********\\n\"", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ")", "{", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "isa", "<", "PointerType", ">", "(", "ScalarTy", ")", "?", "DL", ".", "getPointerSizeInBits", "(", ")", ":", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "DataWidth", ">=", "32", "&&", "ST", "->", "hasAVX", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

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

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP12_TTMP13", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP14_TTMP15", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::TTMP12_TTMP13", "AMDGPU::TTMP14_TTMP15", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "static", "bool", "is_fmac_op", "(", "enum", "attr_type", "t", ")", "{", "return", "(", "t", "==", "TYPE_FMACS", ")", "||", "(", "t", "==", "TYPE_FMACD", ")", "||", "(", "t", "==", "TYPE_NEON_FP_MLA_S", ")", ";", "}", "</s>" ]

[ "Return", "whether", "T", "is", "the", "attribute", "of", "a", "FMADD/FMSUB-like", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "Cpu0SETargetLowering", "::", "isEligibleForTailCallOptimization", "(", "const", "Cpu0CC", "&", "Cpu0CCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "Cpu0MachineFunctionInfo", "&", "FI", ")", "const", "{", "if", "(", "!", "EnableCpu0TailCalls", ")", "return", "false", ";", "if", "(", "Cpu0CCInfo", ".", "hasByValArg", "(", ")", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "getIncomingArgSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "unsigned", "LowGPR", "=", "0", ";", "unsigned", "HighGPR", "=", "SystemZ", "::", "R15D", ";", "int", "StartSPOffset", "=", "SystemZMC", "::", "CallFrameSize", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "int", "Offset", "=", "getRegSpillOffset", "(", "MF", ",", "Reg", ")", ";", "if", "(", "Offset", ")", "{", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", "&&", "StartSPOffset", ">", "Offset", ")", "{", "LowGPR", "=", "Reg", ";", "StartSPOffset", "=", "Offset", ";", "}", "Offset", "-=", "SystemZMC", "::", "CallFrameSize", ";", "int", "FrameIdx", "=", "MFFrame", ".", "CreateFixedSpillStackObject", "(", "8", ",", "Offset", ")", ";", "CS", ".", "setFrameIdx", "(", "FrameIdx", ")", ";", "}", "else", "CS", ".", "setFrameIdx", "(", "INT32_MAX", ")", ";", "}", "ZFI", "->", "setRestoreGPRRegs", "(", "LowGPR", ",", "HighGPR", ",", "StartSPOffset", ")", ";", "if", "(", "IsVarArg", ")", "{", "unsigned", "FirstGPR", "=", "ZFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "if", "(", "FirstGPR", "<", "SystemZ", "::", "NumArgGPRs", ")", "{", "unsigned", "Reg", "=", "SystemZ", "::", "ArgGPRs", "[", "FirstGPR", "]", ";", "int", "Offset", "=", "getRegSpillOffset", "(", "MF", ",", "Reg", ")", ";", "if", "(", "StartSPOffset", ">", "Offset", ")", "{", "LowGPR", "=", "Reg", ";", "StartSPOffset", "=", "Offset", ";", "}", "}", "}", "ZFI", "->", "setSpillGPRRegs", "(", "LowGPR", ",", "HighGPR", ",", "StartSPOffset", ")", ";", "int", "CurrOffset", "=", "-", "SystemZMC", "::", "CallFrameSize", ";", "if", "(", "usePackedStack", "(", "MF", ")", ")", "CurrOffset", "+=", "StartSPOffset", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "if", "(", "CS", ".", "getFrameIdx", "(", ")", "!=", "INT32_MAX", ")", "continue", ";", "unsigned", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "Size", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "CurrOffset", "-=", "Size", ";", "assert", "(", "CurrOffset", "%", "8", "==", "0", "&&", "\"8-byte alignment required for for all register save slots\"", ")", ";", "int", "FrameIdx", "=", "MFFrame", ".", "CreateFixedSpillStackObject", "(", "Size", ",", "CurrOffset", ")", ";", "CS", ".", "setFrameIdx", "(", "FrameIdx", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::R15D", "SystemZMC::CallFrameSize", "SystemZ::GR64BitRegClass", "SystemZMC::CallFrameSize", "8", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "SystemZMC::CallFrameSize", "8", "0", "\"8-byte alignment required for for all register save slots\"" ]

[]

[ "<s>", "static", "tree", "aarch64_promoted_type", "(", "const_tree", "t", ")", "{", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "&&", "TYPE_PRECISION", "(", "t", ")", "==", "16", ")", "return", "float_type_node", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_PROMOTED_TYPE", "to", "promote", "__fp16", "to", "float", "." ]

[ "aarch64", "16" ]

[]

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

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

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

[]

[ "<s>", "bool", "WebAssemblySetP2AlignOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Set p2align Operands **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "LOAD_I32", ":", "case", "WebAssembly", "::", "LOAD_I64", ":", "case", "WebAssembly", "::", "LOAD_F32", ":", "case", "WebAssembly", "::", "LOAD_F64", ":", "case", "WebAssembly", "::", "LOAD8_S_I32", ":", "case", "WebAssembly", "::", "LOAD8_U_I32", ":", "case", "WebAssembly", "::", "LOAD16_S_I32", ":", "case", "WebAssembly", "::", "LOAD16_U_I32", ":", "case", "WebAssembly", "::", "LOAD8_S_I64", ":", "case", "WebAssembly", "::", "LOAD8_U_I64", ":", "case", "WebAssembly", "::", "LOAD16_S_I64", ":", "case", "WebAssembly", "::", "LOAD16_U_I64", ":", "case", "WebAssembly", "::", "LOAD32_S_I64", ":", "case", "WebAssembly", "::", "LOAD32_U_I64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "assert", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"ISel should set p2align operands to 0\"", ")", ";", "assert", "(", "MI", ".", "hasOneMemOperand", "(", ")", "&&", "\"Load and store instructions have exactly one mem operand\"", ")", ";", "assert", "(", "(", "*", "MI", ".", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", "==", "(", "UINT64_C", "(", "1", ")", "<<", "WebAssembly", "::", "GetDefaultP2Align", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "&&", "\"Default p2align value should be natural\"", ")", ";", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "OpInfo", "[", "3", "]", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_P2ALIGN", "&&", "\"Load and store instructions should have a p2align operand\"", ")", ";", "MI", ".", "getOperand", "(", "3", ")", ".", "setImm", "(", "Log2_64", "(", "(", "*", "MI", ".", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Set p2align Operands **********\\n\"", "\"********** Function: \"", "WebAssembly::LOAD_I32", "WebAssembly::LOAD_I64", "WebAssembly::LOAD_F32", "WebAssembly::LOAD_F64", "WebAssembly::LOAD8_S_I32", "WebAssembly::LOAD8_U_I32", "WebAssembly::LOAD16_S_I32", "WebAssembly::LOAD16_U_I32", "WebAssembly::LOAD8_S_I64", "WebAssembly::LOAD8_U_I64", "WebAssembly::LOAD16_S_I64", "WebAssembly::LOAD16_U_I64", "WebAssembly::LOAD32_S_I64", "WebAssembly::LOAD32_U_I64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "3", "0", "\"ISel should set p2align operands to 0\"", "\"Load and store instructions have exactly one mem operand\"", "1", "WebAssembly::GetDefaultP2Align", "\"Default p2align value should be natural\"", "3", "WebAssembly::OPERAND_P2ALIGN", "\"Load and store instructions should have a p2align operand\"", "3" ]

[]

[ "<s>", "const", "char", "*", "tilegx_output_cbranch_with_opcode", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "const", "char", "*", "opcode", ",", "const", "char", "*", "rev_opcode", ",", "int", "regop", ")", "{", "const", "char", "*", "branch_if_false", ";", "rtx", "taken", ",", "not_taken", ";", "bool", "is_simple_branch", ";", "gcc_assert", "(", "LABEL_P", "(", "operands", "[", "0", "]", ")", ")", ";", "is_simple_branch", "=", "true", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "int", "from_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "to_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "operands", "[", "0", "]", ")", ")", ";", "int", "delta", "=", "to_addr", "-", "from_addr", ";", "is_simple_branch", "=", "IN_RANGE", "(", "delta", ",", "-", "524288", ",", "524280", ")", ";", "}", "if", "(", "is_simple_branch", ")", "{", "return", "tilegx_output_simple_cbranch_with_opcode", "(", "insn", ",", "opcode", ",", "regop", ",", "false", ")", ";", "}", "not_taken", "=", "gen_label_rtx", "(", ")", ";", "taken", "=", "operands", "[", "0", "]", ";", "operands", "[", "0", "]", "=", "not_taken", ";", "branch_if_false", "=", "tilegx_output_simple_cbranch_with_opcode", "(", "insn", ",", "rev_opcode", ",", "regop", ",", "true", ")", ";", "output_asm_insn", "(", "branch_if_false", ",", "operands", ")", ";", "output_asm_insn", "(", "\"j\\t%l0\"", ",", "&", "taken", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "not_taken", ")", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "assembly", "code", "for", "a", "specific", "branch", "instruction", ",", "appending", "the", "branch", "prediction", "flag", "to", "the", "opcode", "if", "appropriate", "." ]

[ "tilegx", "0", "0", "524288", "524280", "0", "0", "\"j\\t%l0\"", "\"L\"", "\"\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "assert", "(", "isUInt", "<", "32", ">", "(", "Amount", ")", "&&", "\"exceeded stack address space size\"", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Register", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "Op", "=", "IsDestroy", "?", "AMDGPU", "::", "S_SUB_U32", ":", "AMDGPU", "::", "S_ADD_U32", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", "*", "getScratchScaleFactor", "(", "ST", ")", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "llvm_unreachable", "(", "\"is this used?\"", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "0", "SI", "1", "0", "32", "\"exceeded stack address space size\"", "SI", "SI", "AMDGPU::S_SUB_U32", "AMDGPU::S_ADD_U32", "0", "\"is this used?\"" ]

[]

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

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "mproc", "MVT::i8" ]

[]

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

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

[ "AArch64", "AArch64", "AArch64::GPR64RegClass" ]

[]

[ "<s>", "bool", "WebAssemblyAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "AsmVariant", "!=", "0", ")", "report_fatal_error", "(", "\"There are no defined alternate asm variants\"", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "assert", "(", "MI", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "INLINEASM", ")", ";", "OS", "<<", "regToString", "(", "MO", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "WebAssembly", "WebAssembly", "0", "\"There are no defined alternate asm variants\"", "WebAssembly::INLINEASM" ]

[]

[ "<s>", "void", "M68kAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "OutStreamer", "->", "emitSyntaxDirective", "(", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "void", "nds32_emit_isr_vector_section", "(", "int", "vector_id", ")", "{", "unsigned", "int", "vector_number_offset", "=", "0", ";", "const", "char", "*", "c_str", "=", "\"CATEGORY\"", ";", "const", "char", "*", "sr_str", "=", "\"SR\"", ";", "const", "char", "*", "nt_str", "=", "\"NT\"", ";", "char", "first_level_handler_name", "[", "100", "]", ";", "char", "section_name", "[", "100", "]", ";", "char", "symbol_name", "[", "100", "]", ";", "switch", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "category", ")", "{", "case", "NDS32_ISR_INTERRUPT", ":", "vector_number_offset", "=", "9", ";", "c_str", "=", "\"i\"", ";", "break", ";", "case", "NDS32_ISR_EXCEPTION", ":", "vector_number_offset", "=", "0", ";", "c_str", "=", "\"e\"", ";", "break", ";", "case", "NDS32_ISR_NONE", ":", "case", "NDS32_ISR_RESET", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "switch", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "save_reg", ")", "{", "case", "NDS32_SAVE_ALL", ":", "sr_str", "=", "\"sa\"", ";", "break", ";", "case", "NDS32_PARTIAL_SAVE", ":", "sr_str", "=", "\"ps\"", ";", "break", ";", "}", "switch", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "nested_type", ")", "{", "case", "NDS32_NESTED", ":", "nt_str", "=", "\"ns\"", ";", "break", ";", "case", "NDS32_NOT_NESTED", ":", "nt_str", "=", "\"nn\"", ";", "break", ";", "case", "NDS32_NESTED_READY", ":", "nt_str", "=", "\"nr\"", ";", "break", ";", "case", "NDS32_CRITICAL", ":", "nt_str", "=", "\"\"", ";", "break", ";", "}", "if", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "security_level", "==", "0", ")", "{", "snprintf", "(", "first_level_handler_name", ",", "sizeof", "(", "first_level_handler_name", ")", ",", "\"_nds32_%s_%s_%s\"", ",", "c_str", ",", "sr_str", ",", "nt_str", ")", ";", "}", "else", "{", "snprintf", "(", "first_level_handler_name", ",", "sizeof", "(", "first_level_handler_name", ")", ",", "\"_nds32_spl_%d\"", ",", "nds32_isr_vectors", "[", "vector_id", "]", ".", "security_level", ")", ";", "}", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_vector.%02d\"", ",", "vector_id", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_vector_%02d\"", ",", "vector_id", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "floor_log2", "(", "nds32_isr_vector_size", ")", ",", "false", ")", ";", "if", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "nested_type", "==", "NDS32_CRITICAL", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tj\\t%s ! jump to user handler directly\\n\"", ",", "nds32_isr_vectors", "[", "vector_id", "]", ".", "func_name", ")", ";", "}", "else", "if", "(", "nds32_isr_vector_size", "==", "4", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tj\\t%s ! jump to first level handler\\n\"", ",", "first_level_handler_name", ")", ";", "}", "else", "{", "if", "(", "TARGET_REDUCED_REGS", ")", "{", "if", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "save_reg", "==", "NDS32_SAVE_ALL", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! reduced set regs + save_all\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0xf\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r10, 0x0\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! reduced set regs + partial_save\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0x2\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", ")", ";", "}", "}", "else", "{", "if", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "save_reg", "==", "NDS32_SAVE_ALL", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! full set regs + save_all\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r27, 0xf\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! full set regs + partial_save\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r15, [$sp], $r27, 0x2\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", ")", ";", "}", "}", "fprintf", "(", "asm_out_file", ",", "\"\\tmovi\\t$r0, %d ! preparing software vid\\n\"", ",", "vector_id", "-", "vector_number_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tj\\t%s ! jump to first level handler\\n\"", ",", "first_level_handler_name", ")", ";", "}", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "}", "</s>" ]

[ "Function", "to", "emit", "isr", "vector", "section", "." ]

[ "nds32", "0", "\"CATEGORY\"", "\"SR\"", "\"NT\"", "100", "100", "100", "9", "\"i\"", "0", "\"e\"", "\"sa\"", "\"ps\"", "\"ns\"", "\"nn\"", "\"nr\"", "\"\"", "0", "\"_nds32_%s_%s_%s\"", "\"_nds32_spl_%d\"", "\".nds32_vector.%02d\"", "\"_nds32_vector_%02d\"", "\"\\tj\\t%s ! jump to user handler directly\\n\"", "4", "\"\\tj\\t%s ! jump to first level handler\\n\"", "\"\\t! reduced set regs + save_all\\n\"", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0xf\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r10, 0x0\\n\"", "\"\\t! reduced set regs + partial_save\\n\"", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0x2\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", "\"\\t! full set regs + save_all\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r27, 0xf\\n\"", "\"\\t! full set regs + partial_save\\n\"", "\"\\tsmw.adm\\t$r15, [$sp], $r27, 0x2\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", "\"\\tmovi\\t$r0, %d ! preparing software vid\\n\"", "\"\\tj\\t%s ! jump to first level handler\\n\"" ]

[]

[ "<s>", "void", "aarch64_expand_sve_vec_perm", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "sel", ")", "{", "machine_mode", "data_mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "sel_mode", "=", "GET_MODE", "(", "sel", ")", ";", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "sel_mode", ")", ".", "to_constant", "(", ")", ";", "rtx", "sel_reg", "=", "force_reg", "(", "sel_mode", ",", "sel", ")", ";", "if", "(", "GET_CODE", "(", "sel", ")", "==", "CONST_VECTOR", "&&", "aarch64_const_vec_all_in_range_p", "(", "sel", ",", "0", ",", "nunits", "-", "1", ")", ")", "{", "emit_unspec2", "(", "target", ",", "UNSPEC_TBL", ",", "op0", ",", "sel_reg", ")", ";", "return", ";", "}", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "{", "rtx", "max_sel", "=", "aarch64_simd_gen_const_vector_dup", "(", "sel_mode", ",", "nunits", "-", "1", ")", ";", "rtx", "sel_mod", "=", "expand_simple_binop", "(", "sel_mode", ",", "AND", ",", "sel_reg", ",", "max_sel", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "emit_unspec2", "(", "target", ",", "UNSPEC_TBL", ",", "op0", ",", "sel_mod", ")", ";", "return", ";", "}", "rtx", "res0", "=", "gen_reg_rtx", "(", "data_mode", ")", ";", "rtx", "res1", "=", "gen_reg_rtx", "(", "data_mode", ")", ";", "rtx", "neg_num_elems", "=", "aarch64_simd_gen_const_vector_dup", "(", "sel_mode", ",", "-", "nunits", ")", ";", "if", "(", "GET_CODE", "(", "sel", ")", "!=", "CONST_VECTOR", "||", "!", "aarch64_const_vec_all_in_range_p", "(", "sel", ",", "0", ",", "2", "*", "nunits", "-", "1", ")", ")", "{", "rtx", "max_sel", "=", "aarch64_simd_gen_const_vector_dup", "(", "sel_mode", ",", "2", "*", "nunits", "-", "1", ")", ";", "sel_reg", "=", "expand_simple_binop", "(", "sel_mode", ",", "AND", ",", "sel_reg", ",", "max_sel", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "emit_unspec2", "(", "res0", ",", "UNSPEC_TBL", ",", "op0", ",", "sel_reg", ")", ";", "rtx", "sel_sub", "=", "expand_simple_binop", "(", "sel_mode", ",", "PLUS", ",", "sel_reg", ",", "neg_num_elems", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "emit_unspec2", "(", "res1", ",", "UNSPEC_TBL", ",", "op1", ",", "sel_sub", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "data_mode", ")", "==", "MODE_VECTOR_INT", ")", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_IOR", "(", "data_mode", ",", "res0", ",", "res1", ")", ")", ")", ";", "else", "emit_unspec2", "(", "target", ",", "UNSPEC_IORF", ",", "res0", ",", "res1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "SVE", "vec_perm", "with", "the", "given", "operands", "." ]

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

[]

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

[ "Returns", "true", "if", "the", "target", "wants", "the", "LocalStackAllocation", "pass", "to", "be", "run", "and", "virtual", "base", "registers", "used", "for", "more", "efficient", "stack", "access", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "static", "rtx", "sparc_struct_value_rtx", "(", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "int", "incoming", ")", "{", "if", "(", "TARGET_ARCH64", ")", "return", "0", ";", "else", "{", "rtx", "mem", ";", "if", "(", "incoming", ")", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "frame_pointer_rtx", ",", "STRUCT_VALUE_OFFSET", ")", ")", ";", "else", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "STRUCT_VALUE_OFFSET", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "struct_value_alias_set", ")", ";", "return", "mem", ";", "}", "}", "</s>" ]

[ "Handle", "the", "TARGET_STRUCT_VALUE", "target", "hook", ".", "Return", "where", "to", "find", "the", "structure", "return", "value", "address", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "bool", "HexagonTargetMachine", "::", "addPreSched2", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createIfConverterPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

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

[ "Teak", "\"Invalid type access!\"" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "ValidateGV", "(", "GV", ")", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "SectionKind", "GVKind", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "GV", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "GV", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ",", "TM", ")", ")", ";", "GVSym", "->", "setContainingCsect", "(", "Csect", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", ")", "return", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "unsigned", "Align", "=", "GV", "->", "getAlignment", "(", ")", "?", "GV", "->", "getAlignment", "(", ")", ":", "DL", ".", "getPreferredAlignment", "(", "GV", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "GVSym", ",", "Size", ",", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Align", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Size", ",", "Align", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "PowerPC", "PPC", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"" ]

[]

[ "<s>", "static", "inline", "ChildIteratorType", "child_begin", "(", "NodeRef", "N", ")", "{", "return", "N", "->", "Sites", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "nodes_iterator/begin/end", "-", "Allow", "iteration", "over", "all", "nodes", "in", "the", "graph" ]

[ "Patmos" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "isFuncletReturnInstr", "(", "*", "MI", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "STI", ".", "is32Bit", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "{", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "bool", "IsSEH", "=", "isAsynchronousEHPersonality", "(", "classifyEHPersonality", "(", "Func", "->", "getPersonalityFn", "(", ")", ")", ")", ";", "if", "(", "IsSEH", ")", "return", "true", ";", "}", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::CATCHRET", "0", "X86::GR64RegClass", "X86::GR32RegClass", "X86::POP64r", "X86::POP32r", "0", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "static", "void", "aarch64_push_regs", "(", "unsigned", "regno1", ",", "unsigned", "regno2", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "rtx_insn", "*", "insn", ";", "machine_mode", "mode", "=", "(", "regno1", "<=", "R30_REGNUM", ")", "?", "E_DImode", ":", "E_DFmode", ";", "if", "(", "regno2", "==", "INVALID_REGNUM", ")", "return", "aarch64_pushwb_single_reg", "(", "mode", ",", "regno1", ",", "adjustment", ")", ";", "rtx", "reg1", "=", "gen_rtx_REG", "(", "mode", ",", "regno1", ")", ";", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "insn", "=", "emit_insn", "(", "aarch64_gen_storewb_pair", "(", "mode", ",", "stack_pointer_rtx", ",", "reg1", ",", "reg2", ",", "adjustment", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "2", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Push", "registers", "numbered", "REGNO1", "and", "REGNO2", "to", "the", "stack", ",", "adjusting", "the", "stack", "pointer", "by", "ADJUSTMENT", "." ]

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

[]

[ "<s>", "static", "rtx", "tilegx_tls_got", "(", "void", ")", "{", "rtx", "temp", ";", "if", "(", "flag_pic", ")", "{", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "tilegx_got_rtx", "(", ")", ";", "}", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "temp", ",", "tilegx_got_symbol", "(", ")", ")", ";", "return", "temp", ";", "}", "</s>" ]

[ "Return", "a", "reference", "to", "the", "got", "to", "be", "used", "by", "tls", "references", "." ]

[ "tilegx", "1" ]

[]

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

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

[ "CJG" ]

[]

[ "<s>", "i960_print_operand_addr", "(", "FILE", ",", "ADDR", ")", "{", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "GEN_INT", "(", "0x8C203000", ")", ")", ";", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "GEN_INT", "(", "0x00000000", ")", ")", ";", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "GEN_INT", "(", "0x8CE03000", ")", ")", ";", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "GEN_INT", "(", "0x00000000", ")", ")", ";", "\\", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "GEN_INT", "(", "0x84212000", ")", ")", ";", "\\", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", ".", "This", "is", "exactly", "the", "same", "as", "legitimate_address_p", ",", "except", "that", "it", "the", "prints", "addresses", "instead", "of", "recognizing", "them", "." ]

[ "i960", "0x8C203000", "0x00000000", "0x8CE03000", "0x00000000", "0x84212000" ]

[]

[ "<s>", "void", "sh_set_return_address", "(", "rtx", "ra", ",", "rtx", "tmp", ")", "{", "HARD_REG_SET", "live_regs_mask", ";", "int", "d", ";", "int", "pr_reg", "=", "TARGET_SHMEDIA", "?", "PR_MEDIA_REG", ":", "PR_REG", ";", "int", "pr_offset", ";", "d", "=", "calc_live_regs", "(", "&", "live_regs_mask", ")", ";", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "pr_reg", ")", ")", "{", "rtx", "rr", ";", "if", "(", "TARGET_SHMEDIA", ")", "{", "int", "rr_regno", "=", "sh_media_register_for_return", "(", ")", ";", "if", "(", "rr_regno", "<", "0", ")", "rr_regno", "=", "pr_reg", ";", "rr", "=", "gen_rtx_REG", "(", "DImode", ",", "rr_regno", ")", ";", "}", "else", "rr", "=", "gen_rtx_REG", "(", "SImode", ",", "pr_reg", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "rr", ",", "ra", ")", ")", ";", "emit_insn", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "rr", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SH5", ")", "{", "int", "offset", ";", "save_schedule", "schedule", ";", "save_entry", "*", "entry", ";", "entry", "=", "sh5_schedule_saves", "(", "&", "live_regs_mask", ",", "&", "schedule", ",", "0", ")", ";", "offset", "=", "entry", "[", "1", "]", ".", "offset", ";", "for", "(", ";", "entry", "->", "mode", "!=", "VOIDmode", ";", "entry", "--", ")", "if", "(", "entry", "->", "reg", "==", "pr_reg", ")", "goto", "found", ";", "gcc_unreachable", "(", ")", ";", "found", ":", "offset", "=", "entry", "->", "offset", "-", "offset", ";", "pr_offset", "=", "(", "rounded_frame_size", "(", "d", ")", "+", "offset", "+", "SHMEDIA_REGS_STACK_ADJUST", "(", ")", ")", ";", "}", "else", "pr_offset", "=", "rounded_frame_size", "(", "d", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "tmp", ",", "GEN_INT", "(", "pr_offset", ")", ")", ")", ";", "emit_insn", "(", "GEN_ADD3", "(", "tmp", ",", "tmp", ",", "hard_frame_pointer_rtx", ")", ")", ";", "tmp", "=", "gen_frame_mem", "(", "Pmode", ",", "tmp", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "tmp", ",", "ra", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "change", "the", "current", "function", "'s", "return", "address", "to", "RA", ".", "TEMP", "is", "available", "as", "a", "scratch", "register", ",", "if", "needed", "." ]

[ "sh", "0", "0", "1" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Explicit Locals\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MCS51 dynalloca stack pointer save/restore\"", ";", "}", "</s>" ]

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

[ "MCS51", "\"MCS51 dynalloca stack pointer save/restore\"" ]

[]

[ "<s>", "void", "VEInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "VE", "::", "I64RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "I32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STLrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "VE", "::", "F32RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STUrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "VE", "::", "F128RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "STQrii", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "report_fatal_error", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::I64RegClass", "VE::STrii", "0", "0", "VE::I32RegClass", "VE::STLrii", "0", "0", "VE::F32RegClass", "VE::STUrii", "0", "0", "VE::F128RegClass", "VE::STQrii", "0", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "const", "SpillSlot", "*", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "override", "{", "static", "const", "SpillSlot", "Offsets", "[", "]", "=", "{", "{", "Hexagon", "::", "R17", ",", "-", "4", "}", ",", "{", "Hexagon", "::", "R16", ",", "-", "8", "}", ",", "{", "Hexagon", "::", "D8", ",", "-", "8", "}", ",", "{", "Hexagon", "::", "R19", ",", "-", "12", "}", ",", "{", "Hexagon", "::", "R18", ",", "-", "16", "}", ",", "{", "Hexagon", "::", "D9", ",", "-", "16", "}", ",", "{", "Hexagon", "::", "R21", ",", "-", "20", "}", ",", "{", "Hexagon", "::", "R20", ",", "-", "24", "}", ",", "{", "Hexagon", "::", "D10", ",", "-", "24", "}", ",", "{", "Hexagon", "::", "R23", ",", "-", "28", "}", ",", "{", "Hexagon", "::", "R22", ",", "-", "32", "}", ",", "{", "Hexagon", "::", "D11", ",", "-", "32", "}", ",", "{", "Hexagon", "::", "R25", ",", "-", "36", "}", ",", "{", "Hexagon", "::", "R24", ",", "-", "40", "}", ",", "{", "Hexagon", "::", "D12", ",", "-", "40", "}", ",", "{", "Hexagon", "::", "R27", ",", "-", "44", ",", "{", "Hexagon", "::", "R26", ",", "-", "48", ",", "{", "Hexagon", "::", "D13", ",", "-", "48", "}", "}", ";", "NumEntries", "=", "array_lengthof", "(", "Offsets", ")", ";", "return", "Offsets", ";", "}", "bool", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "override", ";", "bool", "needsAligna", "(", "const", "MachineFunction", "&", "MF", ")", "const", ";", "const", "MachineInstr", "*", "getAlignaInstr", "(", "const", "MachineFunction", "&", "MF", ")", "const", ";", "void", "insertCFIInstructions", "(", "MachineFunction", "&", "MF", ")", "const", ";", "private", ":", "typedef", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "CSIVect", ";", "void", "expandAlloca", "(", "MachineInstr", "*", "AI", ",", "const", "HexagonInstrInfo", "&", "TII", ",", "unsigned", "SP", ",", "unsigned", "CF", ")", "const", ";", "void", "insertPrologueInBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "const", ";", "void", "insertEpilogueInBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "const", ";", "bool", "insertCSRSpillsInBlock", "(", "MachineBasicBlock", "&", "MBB", ",", "const", "CSIVect", "&", "CSI", ",", "const", "HexagonRegisterInfo", "&", "HRI", ")", "const", ";", "bool", "insertCSRRestoresInBlock", "(", "MachineBasicBlock", "&", "MBB", ",", "const", "CSIVect", "&", "CSI", ",", "const", "HexagonRegisterInfo", "&", "HRI", ")", "const", ";", "void", "insertCFIInstructionsAt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "At", ")", "const", ";", "void", "adjustForCalleeSavedRegsSpillCall", "(", "MachineFunction", "&", "MF", ")", "const", ";", "bool", "replacePredRegPseudoSpillCode", "(", "MachineFunction", "&", "MF", ")", "const", ";", "bool", "replaceVecPredRegPseudoSpillCode", "(", "MachineFunction", "&", "MF", ")", "const", ";", "void", "findShrunkPrologEpilog", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "*", "&", "PrologB", ",", "MachineBasicBlock", "*", "&", "EpilogB", ")", "const", ";", "bool", "shouldInlineCSR", "(", "llvm", "::", "MachineFunction", "&", "MF", ",", "const", "CSIVect", "&", "CSI", ")", "const", ";", "bool", "useSpillFunction", "(", "MachineFunction", "&", "MF", ",", "const", "CSIVect", "&", "CSI", ")", "const", ";", "bool", "useRestoreFunction", "(", "MachineFunction", "&", "MF", ",", "const", "CSIVect", "&", "CSI", ")", "const", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

[ "Hexagon", "Hexagon::R17", "4", "Hexagon::R16", "8", "Hexagon::D8", "8", "Hexagon::R19", "12", "Hexagon::R18", "16", "Hexagon::D9", "16", "Hexagon::R21", "20", "Hexagon::R20", "24", "Hexagon::D10", "24", "Hexagon::R23", "28", "Hexagon::R22", "32", "Hexagon::D11", "32", "Hexagon::R25", "36", "Hexagon::R24", "40", "Hexagon::D12", "40", "Hexagon::R27", "44", "Hexagon::R26", "48", "Hexagon::D13", "48", "Hexagon", "Hexagon", "Hexagon" ]

[]