Datasets:

---

docz1105

/

ComBack

like 9

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

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "CellSPU" ]

[]

[ "<s>", "static", "M68kRelType", "getType", "(", "unsigned", "Kind", ",", "MCSymbolRefExpr", "::", "VariantKind", "&", "Modifier", ",", "bool", "&", "IsPCRel", ")", "{", "switch", "(", "Kind", ")", "{", "case", "FK_Data_4", ":", "case", "FK_PCRel_4", ":", "return", "RT_32", ";", "case", "FK_PCRel_2", ":", "case", "FK_Data_2", ":", "return", "RT_16", ";", "case", "FK_PCRel_1", ":", "case", "FK_Data_1", ":", "return", "RT_8", ";", "}", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "M68k", "M68k", "\"Unimplemented\"" ]

[]

[ "<s>", "static", "bool", "mep_expand_setcc_1", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "tmp", ";", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GTU", ":", "tmp", "=", "op1", ",", "op1", "=", "op2", ",", "op2", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "case", "LT", ":", "case", "LTU", ":", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op1", ",", "op2", ")", ")", ")", ";", "return", "true", ";", "case", "EQ", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "const1_rtx", ")", ";", "return", "true", ";", "case", "NE", ":", "if", "(", "optimize_size", "&&", "op2", "!=", "const0_rtx", ")", "return", "false", ";", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "op2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "op2", ",", "op1", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_XOR", "(", "SImode", ",", "op2", ",", "const1_rtx", ")", ")", ")", ";", "return", "true", ";", "case", "LE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "0x7ffffff", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "+", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "LT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "LEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "-", "1", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "+", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "trunc_int_for_mode", "(", "0x80000000", ",", "SImode", ")", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "-", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "GT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "op2", "==", "const0_rtx", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "-", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "GTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "setcc", "instruction", "in", "its", "entirity", "." ]

[ "mep", "1", "1", "0x7ffffff", "1", "1", "1", "0x80000000", "1", "1" ]

[]

[ "<s>", "static", "rtx", "frv_alloc_temp_reg", "(", "frv_tmp_reg_t", "*", "info", ",", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "int", "mark_as_used", ",", "int", "no_abort", ")", "{", "int", "regno", "=", "info", "->", "next_reg", "[", "(", "int", ")", "rclass", "]", ";", "int", "orig_regno", "=", "regno", ";", "HARD_REG_SET", "*", "reg_in_class", "=", "&", "reg_class_contents", "[", "(", "int", ")", "rclass", "]", ";", "int", "i", ",", "nr", ";", "for", "(", ";", ";", ")", "{", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "reg_in_class", ",", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "info", "->", "regs", ",", "regno", ")", ")", "break", ";", "if", "(", "++", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "0", ";", "if", "(", "regno", "==", "orig_regno", ")", "{", "gcc_assert", "(", "no_abort", ")", ";", "return", "NULL_RTX", ";", "}", "}", "nr", "=", "HARD_REGNO_NREGS", "(", "regno", ",", "mode", ")", ";", "info", "->", "next_reg", "[", "(", "int", ")", "rclass", "]", "=", "regno", "+", "nr", ";", "if", "(", "mark_as_used", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nr", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "info", "->", "regs", ",", "regno", "+", "i", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Return", "the", "next", "available", "temporary", "register", "in", "a", "given", "class", "." ]

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

[]

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

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

[ "ARM", "0", "64" ]

[]

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

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

[ "Cpu0", "\"CPU0 DAG to DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "fastMaterializeFloatZero", "(", "const", "ConstantFP", "*", "CFP", ")", "{", "assert", "(", "CFP", "->", "isNullValue", "(", ")", "&&", "\"Floating-point constant is not a positive zero.\"", ")", ";", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "CFP", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "0", ";", "bool", "Is64Bit", "=", "(", "VT", "==", "MVT", "::", "f64", ")", ";", "unsigned", "ZReg", "=", "Is64Bit", "?", "AArch64", "::", "XZR", ":", "AArch64", "::", "WZR", ";", "unsigned", "Opc", "=", "Is64Bit", "?", "AArch64", "::", "FMOVXDr", ":", "AArch64", "::", "FMOVWSr", ";", "return", "fastEmitInst_r", "(", "Opc", ",", "TLI", ".", "getRegClassFor", "(", "VT", ")", ",", "ZReg", ")", ";", "}", "</s>" ]

[ "Emit", "the", "floating-point", "constant", "+0.0", "in", "a", "register", "using", "target-", "specific", "logic", "." ]

[ "AArch64", "AArch64", "\"Floating-point constant is not a positive zero.\"", "0", "MVT::f32", "MVT::f64", "0", "MVT::f64", "AArch64::XZR", "AArch64::WZR", "AArch64::FMOVXDr", "AArch64::FMOVWSr" ]

[]

[ "<s>", "static", "bool", "is_branch_slot_insn", "(", "rtx", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_sched_groups", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "type", "==", "TYPE_BRANCH", "||", "type", "==", "TYPE_JMPREG", ")", "return", "true", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "true", "if", "INSN", "can", "be", "issued", "only", "from", "the", "branch", "slot", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "ix86_expand_round_sse4", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "e1", ",", "e2", ",", "res", ",", "half", ";", "const", "struct", "real_format", "*", "fmt", ";", "REAL_VALUE_TYPE", "pred_half", ",", "half_minus_pred_half", ";", "rtx", "(", "*", "gen_copysign", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "gen_round", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "gen_copysign", "=", "gen_copysignsf3", ";", "gen_round", "=", "gen_sse4_1_roundsf2", ";", "break", ";", "case", "DFmode", ":", "gen_copysign", "=", "gen_copysigndf3", ";", "gen_round", "=", "gen_sse4_1_rounddf2", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fmt", "=", "REAL_MODE_FORMAT", "(", "mode", ")", ";", "real_2expN", "(", "&", "half_minus_pred_half", ",", "-", "(", "fmt", "->", "p", ")", "-", "1", ",", "mode", ")", ";", "real_arithmetic", "(", "&", "pred_half", ",", "MINUS_EXPR", ",", "&", "dconsthalf", ",", "&", "half_minus_pred_half", ")", ";", "half", "=", "const_double_from_real_value", "(", "pred_half", ",", "mode", ")", ";", "e1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_copysign", "(", "e1", ",", "half", ",", "op1", ")", ")", ";", "e2", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "op1", ",", "e1", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_round", "(", "res", ",", "e2", ",", "GEN_INT", "(", "ROUND_TRUNC", ")", ")", ")", ";", "emit_move_insn", "(", "op0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE", "sequence", "for", "computing", "round", "from", "OP1", "storing", "into", "OP0", "using", "sse4", "round", "insn", "." ]

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

[]

[ "<s>", "bool", "ARMBlockPlacement", "::", "processPostOrderLoops", "(", "MachineLoop", "*", "ML", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "InnerML", ":", "*", "ML", ")", "Changed", "|=", "processPostOrderLoops", "(", "InnerML", ")", ";", "return", "Changed", "|", "fixBackwardsWLS", "(", "ML", ")", ";", "}", "</s>" ]

[ "Updates", "ordering", "(", "of", "WLS", "BB", "and", "their", "loopExits", ")", "in", "inner", "loops", "first", "Returns", "true", "if", "any", "change", "was", "made", "in", "any", "of", "the", "loops", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "const", "char", "*", "avr_out_tsthi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"tst %B0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "if", "(", "reg_unused_after", "(", "insn", ",", "op", "[", "0", "]", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"or %A0,%B0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "{", "avr_out_compare", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "test", "instruction", "for", "HImode", "." ]

[ "avr", "\"tst %B0\"", "1", "0", "\"or %A0,%B0\"", "1", "\"\"" ]

[]

[ "<s>", "int", "nds32_can_use_bclr_p", "(", "int", "ival", ")", "{", "int", "one_bit_count", ";", "one_bit_count", "=", "popcount_hwi", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "~", "ival", ")", ")", ";", "return", "(", "TARGET_EXT_PERF", "&&", "(", "one_bit_count", "==", "1", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'bclr", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "static", "rtx", "alpha_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", ")", "{", "return", "alpha_function_value_1", "(", "NULL_TREE", ",", "NULL_TREE", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "MF", "=", "&", "Func", ";", "const", "X86Subtarget", "&", "ST", "=", "Func", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "OptIncDec", "=", "!", "ST", ".", "slowIncDec", "(", ")", "||", "Func", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "OptLEA", "=", "ST", ".", "LEAusesAG", "(", ")", "||", "ST", ".", "slowLEA", "(", ")", ";", "if", "(", "!", "OptLEA", "&&", "!", "OptIncDec", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "void", "aarch64_init_builtin_rsqrt", "(", "void", ")", "{", "tree", "fndecl", "=", "NULL", ";", "tree", "ftype", "=", "NULL", ";", "tree", "V2SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "2", ")", ";", "tree", "V2DF_type_node", "=", "build_vector_type", "(", "double_type_node", ",", "2", ")", ";", "tree", "V4SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "4", ")", ";", "struct", "builtin_decls_data", "{", "tree", "type_node", ";", "const", "char", "*", "builtin_name", ";", "int", "function_code", ";", "}", ";", "builtin_decls_data", "bdda", "[", "]", "=", "{", "{", "double_type_node", ",", "\"__builtin_aarch64_rsqrt_df\"", ",", "AARCH64_BUILTIN_RSQRT_DF", "}", ",", "{", "float_type_node", ",", "\"__builtin_aarch64_rsqrt_sf\"", ",", "AARCH64_BUILTIN_RSQRT_SF", "}", ",", "{", "V2DF_type_node", ",", "\"__builtin_aarch64_rsqrt_v2df\"", ",", "AARCH64_BUILTIN_RSQRT_V2DF", "}", ",", "{", "V2SF_type_node", ",", "\"__builtin_aarch64_rsqrt_v2sf\"", ",", "AARCH64_BUILTIN_RSQRT_V2SF", "}", ",", "{", "V4SF_type_node", ",", "\"__builtin_aarch64_rsqrt_v4sf\"", ",", "AARCH64_BUILTIN_RSQRT_V4SF", "}", "}", ";", "builtin_decls_data", "*", "bdd", "=", "bdda", ";", "builtin_decls_data", "*", "bdd_end", "=", "bdd", "+", "(", "ARRAY_SIZE", "(", "bdda", ")", ")", ";", "for", "(", ";", "bdd", "<", "bdd_end", ";", "bdd", "++", ")", "{", "ftype", "=", "build_function_type_list", "(", "bdd", "->", "type_node", ",", "bdd", "->", "type_node", ",", "NULL_TREE", ")", ";", "tree", "attrs", "=", "aarch64_get_attributes", "(", "FLAG_FP", ",", "TYPE_MODE", "(", "bdd", "->", "type_node", ")", ")", ";", "fndecl", "=", "aarch64_general_add_builtin", "(", "bdd", "->", "builtin_name", ",", "ftype", ",", "bdd", "->", "function_code", ",", "attrs", ")", ";", "aarch64_builtin_decls", "[", "bdd", "->", "function_code", "]", "=", "fndecl", ";", "}", "}", "</s>" ]

[ "Add", "builtins", "for", "reciprocal", "square", "root", "." ]

[ "aarch64", "2", "2", "4", "\"__builtin_aarch64_rsqrt_df\"", "\"__builtin_aarch64_rsqrt_sf\"", "\"__builtin_aarch64_rsqrt_v2df\"", "\"__builtin_aarch64_rsqrt_v2sf\"", "\"__builtin_aarch64_rsqrt_v4sf\"" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDValue", "Ptr", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "IsInc", ";", "if", "(", "!", "getIndexedAddressParts", "(", "Op", ",", "Base", ",", "Offset", ",", "AM", ",", "IsInc", ",", "DAG", ")", ")", "return", "false", ";", "if", "(", "Ptr", "!=", "Base", ")", "return", "false", ";", "AM", "=", "IsInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "ARM64", "ARM64", "ISD::MemIndexedMode", "ISD::POST_INC", "ISD::POST_DEC" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"RISCV Redundant Copy Elimination\"", ";", "}", "</s>" ]

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

[ "RISCV", "\"RISCV Redundant Copy Elimination\"" ]

[]

[ "<s>", "static", "void", "get_pc_thunk_name", "(", "char", "name", "[", "32", "]", ",", "unsigned", "int", "regno", ")", "{", "if", "(", "USE_HIDDEN_LINKONCE", ")", "sprintf", "(", "name", ",", "\"__i686.get_pc_thunk.%s\"", ",", "reg_names", "[", "regno", "]", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LPR\"", ",", "regno", ")", ";", "}", "</s>" ]

[ "Fills", "in", "the", "label", "name", "that", "should", "be", "used", "for", "a", "pc", "thunk", "for", "the", "given", "register", "." ]

[ "i386", "32", "\"__i686.get_pc_thunk.%s\"", "\"LPR\"" ]

[]

[ "<s>", "static", "tree", "arm_convert_to_type", "(", "tree", "type", ",", "tree", "expr", ")", "{", "tree", "fromtype", "=", "TREE_TYPE", "(", "expr", ")", ";", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "fromtype", ")", "||", "!", "SCALAR_FLOAT_TYPE_P", "(", "type", ")", ")", "return", "NULL_TREE", ";", "if", "(", "(", "TYPE_PRECISION", "(", "fromtype", ")", "==", "16", "&&", "TYPE_PRECISION", "(", "type", ")", ">", "32", ")", "||", "(", "TYPE_PRECISION", "(", "type", ")", "==", "16", "&&", "TYPE_PRECISION", "(", "fromtype", ")", ">", "32", ")", ")", "return", "convert", "(", "type", ",", "convert", "(", "float_type_node", ",", "expr", ")", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONVERT_TO_TYPE", ".", "Specifically", ",", "this", "hook", "implements", "the", "peculiarity", "of", "the", "ARM", "half-precision", "floating-point", "C", "semantics", "that", "requires", "conversions", "between", "__fp16", "to", "or", "from", "double", "to", "do", "an", "intermediate", "conversion", "to", "float", "." ]

[ "arm", "16", "32", "16", "32" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This resolveFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ",", "this", ")", ";", "}", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "0", "\"This resolveFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM", "\"Unable to resolve frame index!\"" ]

[]

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

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

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

[]

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

[ "Allow", "the", "target", "to", "override", "the", "cost", "of", "using", "a", "callee-saved", "register", "for", "the", "first", "time", "." ]

[ "AArch64", "5" ]

[]

[ "<s>", "void", "LoongArchDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "MVT", "GRLenVT", "=", "Subtarget", "->", "getGRLenVT", "(", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "Constant", ":", "{", "int64_t", "Imm", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", "->", "getSExtValue", "(", ")", ";", "SDNode", "*", "Result", "=", "nullptr", ";", "SDValue", "SrcReg", "=", "CurDAG", "->", "getRegister", "(", "LoongArch", "::", "R0", ",", "GRLenVT", ")", ";", "for", "(", "LoongArchMatInt", "::", "Inst", "&", "Inst", ":", "LoongArchMatInt", "::", "generateInstSeq", "(", "Imm", ")", ")", "{", "SDValue", "SDImm", "=", "CurDAG", "->", "getTargetConstant", "(", "Inst", ".", "Imm", ",", "DL", ",", "GRLenVT", ")", ";", "if", "(", "Inst", ".", "Opc", "==", "LoongArch", "::", "LU12I_W", ")", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "LoongArch", "::", "LU12I_W", ",", "DL", ",", "GRLenVT", ",", "SDImm", ")", ";", "else", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "Inst", ".", "Opc", ",", "DL", ",", "GRLenVT", ",", "SrcReg", ",", "SDImm", ")", ";", "SrcReg", "=", "SDValue", "(", "Result", ",", "0", ")", ";", "}", "ReplaceNode", "(", "Node", ",", "Result", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "\"== \"", "\"\\n\"", "1", "ISD::Constant", "LoongArch::R0", "LoongArchMatInt::Inst", "LoongArchMatInt::generateInstSeq", "LoongArch::LU12I_W", "LoongArch::LU12I_W", "0" ]

[]

[ "<s>", "const", "MachineOperand", "*", "SIInstrInfo", "::", "getNamedOperand", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OperandName", ")", "const", "{", "int", "Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "OperandName", ")", ";", "if", "(", "Idx", "==", "-", "1", ")", "return", "nullptr", ";", "return", "&", "MI", ".", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "operand", "named", "Op", "." ]

[ "R600", "SI", "1" ]

[]

[ "<s>", "static", "rtx", "get_next_active_insn", "(", "rtx", "insn", ",", "rtx", "tail", ")", "{", "if", "(", "insn", "==", "NULL_RTX", "||", "insn", "==", "tail", ")", "return", "NULL_RTX", ";", "while", "(", "1", ")", "{", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "insn", "==", "NULL_RTX", "||", "insn", "==", "tail", ")", "return", "NULL_RTX", ";", "if", "(", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", "||", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", "&&", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_stack_tie", ")", ")", "break", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "Return", "the", "next", "insn", "after", "INSN", "that", "is", "found", "before", "TAIL", "is", "reached", ",", "skipping", "any", "``", "non-active", "''", "insns", "-", "insns", "that", "will", "not", "actually", "occupy", "an", "issue", "slot", ".", "Return", "NULL_RTX", "if", "such", "an", "insn", "is", "not", "found", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "RISCVInstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "RISCV", "::", "PseudoCALLReg", ")", ",", "RISCV", "::", "X5", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ",", "0", ",", "RISCVII", "::", "MO_CALL", ")", ")", ";", "return", "It", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

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

[]

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

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

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

[]

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

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "CAHP" ]

[]

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

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

[ "RISCV" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.r600.read.local.size.x\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.r600.read.local.size.y\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.r600.read.local.size.z\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.r600.read.global.size.x\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.r600.read.global.size.y\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.r600.read.global.size.z\"", ",", "\"amdgpu-dispatch-ptr\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "2", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.r600.read.local.size.x\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.r600.read.local.size.y\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.r600.read.local.size.z\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.r600.read.global.size.x\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.r600.read.global.size.y\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.r600.read.global.size.z\"", "\"amdgpu-dispatch-ptr\"" ]

[]

[ "<s>", "static", "void", "write_func_decl_from_insn", "(", "std", "::", "stringstream", "&", "s", ",", "rtx", "result", ",", "rtx", "pat", ",", "rtx", "callee", ")", "{", "bool", "callprototype", "=", "register_operand", "(", "callee", ",", "Pmode", ")", ";", "const", "char", "*", "name", "=", "\"_\"", ";", "if", "(", "!", "callprototype", ")", "{", "name", "=", "XSTR", "(", "callee", ",", "0", ")", ";", "name", "=", "nvptx_name_replacement", "(", "name", ")", ";", "s", "<<", "\"// BEGIN GLOBAL FUNCTION DECL: \"", "<<", "name", "<<", "\"\\n\"", ";", "}", "s", "<<", "(", "callprototype", "?", "\"\\t.callprototype\\t\"", ":", "\"\\t.extern .func \"", ")", ";", "if", "(", "result", "!=", "NULL_RTX", ")", "{", "s", "<<", "\"(.param\"", ";", "s", "<<", "nvptx_ptx_type_from_mode", "(", "arg_promotion", "(", "GET_MODE", "(", "result", ")", ")", ",", "false", ")", ";", "s", "<<", "\" \"", ";", "if", "(", "callprototype", ")", "s", "<<", "\"_\"", ";", "else", "s", "<<", "\"%out_retval\"", ";", "s", "<<", "\")\"", ";", "}", "s", "<<", "name", ";", "int", "nargs", "=", "XVECLEN", "(", "pat", ",", "0", ")", "-", "1", ";", "if", "(", "nargs", ">", "0", ")", "{", "s", "<<", "\" (\"", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nargs", ";", "i", "++", ")", "{", "rtx", "t", "=", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", "+", "1", ")", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "t", ")", ";", "int", "count", "=", "maybe_split_mode", "(", "&", "mode", ")", ";", "while", "(", "count", "--", ">", "0", ")", "{", "s", "<<", "\".param\"", ";", "s", "<<", "nvptx_ptx_type_from_mode", "(", "mode", ",", "false", ")", ";", "s", "<<", "\" \"", ";", "if", "(", "callprototype", ")", "s", "<<", "\"_\"", ";", "else", "s", "<<", "\"%arg\"", "<<", "i", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "s", "<<", "\"[1]\"", ";", "if", "(", "i", "+", "1", "<", "nargs", "||", "count", ">", "0", ")", "s", "<<", "\", \"", ";", "}", "}", "s", "<<", "\")\"", ";", "}", "s", "<<", "\";\\n\"", ";", "}", "</s>" ]

[ "Construct", "a", "function", "declaration", "from", "a", "call", "insn", ".", "This", "can", "be", "necessary", "for", "two", "reasons", "-", "either", "we", "have", "an", "indirect", "call", "which", "requires", "a", ".callprototype", "declaration", ",", "or", "we", "have", "a", "libcall", "generated", "by", "emit_library_call", "for", "which", "no", "decl", "exists", "." ]

[ "nvptx", "\"_\"", "0", "\"// BEGIN GLOBAL FUNCTION DECL: \"", "\"\\n\"", "\"\\t.callprototype\\t\"", "\"\\t.extern .func \"", "\"(.param\"", "\" \"", "\"_\"", "\"%out_retval\"", "\")\"", "0", "1", "0", "\" (\"", "0", "0", "1", "0", "0", "\".param\"", "\" \"", "\"_\"", "\"%arg\"", "\"[1]\"", "1", "0", "\", \"", "\")\"", "\";\\n\"" ]

[]

[ "<s>", "static", "void", "write_type_node", "(", "char", "*", "tok", ",", "bool", "indent", ")", "{", "if", "(", "indent", ")", "fprintf", "(", "init_file", ",", "\" \"", ")", ";", "typemap", "*", "entry", "=", "(", "typemap", "*", ")", "bsearch", "(", "tok", ",", "type_map", ",", "sizeof", "type_map", "/", "sizeof", "type_map", "[", "0", "]", ",", "sizeof", "(", "typemap", ")", ",", "typemap_cmp", ")", ";", "if", "(", "!", "entry", ")", "fatal", "(", "\"Type map is inconsistent.\"", ")", ";", "fprintf", "(", "init_file", ",", "\"%s_type_node\"", ",", "entry", "->", "value", ")", ";", "}", "</s>" ]

[ "Write", "the", "type", "node", "corresponding", "to", "TOK", "." ]

[ "rs6000", "\" \"", "0", "\"Type map is inconsistent.\"", "\"%s_type_node\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "const", "TargetInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "if", "(", "AddrMode", "==", "ARMII", "::", "AddrMode4", "||", "AddrMode", "==", "ARMII", "::", "AddrMode6", ")", "return", "Offset", "==", "0", ";", "unsigned", "NumBits", "=", "0", ";", "unsigned", "Scale", "=", "1", ";", "bool", "isSigned", "=", "true", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "Scale", "=", "1", ";", "if", "(", "Offset", "<", "0", ")", "{", "NumBits", "=", "8", ";", "Offset", "=", "-", "Offset", ";", "}", "else", "{", "NumBits", "=", "12", ";", "}", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "NumBits", "=", "8", ";", "Scale", "=", "4", ";", "break", ";", "case", "ARMII", "::", "AddrMode_i12", ":", "case", "ARMII", "::", "AddrMode2", ":", "NumBits", "=", "12", ";", "break", ";", "case", "ARMII", "::", "AddrMode3", ":", "NumBits", "=", "8", ";", "break", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "NumBits", "=", "5", ";", "Scale", "=", "4", ";", "isSigned", "=", "false", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "break", ";", "}", "Offset", "+=", "getFrameIndexInstrOffset", "(", "MI", ",", "i", ")", ";", "if", "(", "(", "Offset", "&", "(", "Scale", "-", "1", ")", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "isSigned", "&&", "Offset", "<", "0", ")", "Offset", "=", "-", "Offset", ";", "unsigned", "Mask", "=", "(", "1", "<<", "NumBits", ")", "-", "1", ";", "if", "(", "(", "unsigned", ")", "Offset", "<=", "Mask", "*", "Scale", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARMII::AddrMode4", "ARMII::AddrMode6", "0", "0", "1", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i12", "1", "0", "8", "12", "ARMII::AddrMode5", "8", "4", "ARMII::AddrMode_i12", "ARMII::AddrMode2", "12", "ARMII::AddrMode3", "8", "ARMII::AddrModeT1_s", "5", "4", "\"Unsupported addressing mode!\"", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "void", "conditionalize_optimization", "(", "void", ")", "{", "rtx", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "conditionalize_block", "(", "insn", ")", ")", "continue", ";", "}", "</s>" ]

[ "Apply", "the", "conditionalization", "of", "blocks", "optimization", ".", "This", "is", "the", "outer", "loop", "that", "traverses", "through", "the", "insns", "scanning", "for", "a", "branch", "that", "signifies", "an", "opportunity", "to", "apply", "the", "optimization", ".", "Note", "that", "this", "optimization", "is", "applied", "late", ".", "If", "we", "could", "apply", "it", "earlier", ",", "say", "before", "cse", "2", ",", "it", "may", "expose", "more", "optimization", "opportunities", ".", "but", ",", "the", "pay", "back", "probably", "is", "n't", "really", "worth", "the", "effort", "(", "we", "'d", "have", "to", "update", "all", "reg/flow/notes/links/etc", "to", "make", "it", "work", "-", "and", "stick", "it", "in", "before", "cse", "2", ")", "." ]

[ "mcore" ]

[]

[ "<s>", "int", "RISCVTTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "bool", "Takes12BitImm", "=", "false", ";", "unsigned", "ImmArgIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "case", "Instruction", "::", "GetElementPtr", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "Mul", ":", "Takes12BitImm", "=", "true", ";", "break", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "Takes12BitImm", "=", "true", ";", "ImmArgIdx", "=", "1", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Takes12BitImm", ")", "{", "if", "(", "Instruction", "::", "isCommutative", "(", "Opcode", ")", "||", "Idx", "==", "ImmArgIdx", ")", "{", "if", "(", "getTLI", "(", ")", "->", "isLegalAddImmediate", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "return", "TTI", "::", "TCC_Free", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "0U", "1" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "ARM", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_arm_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_pcrel_10_unscaled\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_thumb_adr_pcrel_10\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_condbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_uncondbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_condbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_uncondbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_br\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_uncondbl\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_condbl\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_blx\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bl\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_blx\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cb\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cp\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_thumb_bcc\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "ARM", "ARM::NumTargetFixupKinds", "\"fixup_arm_ldst_pcrel_12\"", "0", "32", "\"fixup_t2_ldst_pcrel_12\"", "0", "32", "\"fixup_arm_pcrel_10_unscaled\"", "0", "32", "\"fixup_arm_pcrel_10\"", "0", "32", "\"fixup_t2_pcrel_10\"", "0", "32", "\"fixup_thumb_adr_pcrel_10\"", "0", "8", "\"fixup_arm_adr_pcrel_12\"", "0", "32", "\"fixup_t2_adr_pcrel_12\"", "0", "32", "\"fixup_arm_condbranch\"", "0", "24", "\"fixup_arm_uncondbranch\"", "0", "24", "\"fixup_t2_condbranch\"", "0", "32", "\"fixup_t2_uncondbranch\"", "0", "32", "\"fixup_arm_thumb_br\"", "0", "16", "\"fixup_arm_uncondbl\"", "0", "24", "\"fixup_arm_condbl\"", "0", "24", "\"fixup_arm_blx\"", "0", "24", "\"fixup_arm_thumb_bl\"", "0", "32", "\"fixup_arm_thumb_blx\"", "0", "32", "\"fixup_arm_thumb_cb\"", "0", "16", "\"fixup_arm_thumb_cp\"", "0", "8", "\"fixup_arm_thumb_bcc\"", "0", "8", "\"fixup_arm_movt_hi16\"", "0", "20", "0", "\"fixup_arm_movw_lo16\"", "0", "20", "0", "\"fixup_t2_movt_hi16\"", "0", "20", "0", "\"fixup_t2_movw_lo16\"", "0", "20", "0", "\"fixup_arm_movt_hi16_pcrel\"", "0", "20", "\"fixup_arm_movw_lo16_pcrel\"", "0", "20", "\"fixup_t2_movt_hi16_pcrel\"", "0", "20", "\"fixup_t2_movw_lo16_pcrel\"", "0", "20", "\"Invalid kind!\"" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "SparcMachineFunctionInfo", "*", "SparcFI", "=", "MF", "->", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "SparcFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "SP", "::", "IntRegsRegClass", ")", ";", "DebugLoc", "dl", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "get", "(", "SP", "::", "GETPCX", ")", ",", "GlobalBaseReg", ")", ";", "SparcFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "0", "SP::IntRegsRegClass", "SP::GETPCX", "Sparc" ]

[]

[ "<s>", "void", "A57ChainingConstraint", "::", "apply", "(", "PBQPRAGraph", "&", "G", ")", "{", "const", "MachineFunction", "&", "MF", "=", "G", ".", "getMetadata", "(", ")", ".", "MF", ";", "LiveIntervals", "&", "LIs", "=", "G", ".", "getMetadata", "(", ")", ".", "LIS", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "MBB", ":", "MF", ")", "{", "Chains", ".", "clear", "(", ")", ";", "for", "(", "const", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "auto", "r", ":", "Chains", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "toDel", ";", "if", "(", "regJustKilledBefore", "(", "LIs", ",", "r", ",", "MI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Killing chain \"", "<<", "PrintReg", "(", "r", ",", "TRI", ")", "<<", "\" at \"", ";", "MI", ".", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "FMSUBSrrr", ":", "case", "AArch64", "::", "FMADDSrrr", ":", "case", "AArch64", "::", "FNMSUBSrrr", ":", "case", "AArch64", "::", "FNMADDSrrr", ":", "case", "AArch64", "::", "FMSUBDrrr", ":", "case", "AArch64", "::", "FMADDDrrr", ":", "case", "AArch64", "::", "FNMSUBDrrr", ":", "case", "AArch64", "::", "FNMADDDrrr", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Ra", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "if", "(", "addIntraChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ")", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ";", "break", ";", "}", "case", "AArch64", "::", "FMLAv2f32", ":", "case", "AArch64", "::", "FMLSv2f32", ":", "{", "unsigned", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Rd", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AArch64", "8", "\"Killing chain \"", "\" at \"", "AArch64::FMSUBSrrr", "AArch64::FMADDSrrr", "AArch64::FNMSUBSrrr", "AArch64::FNMADDSrrr", "AArch64::FMSUBDrrr", "AArch64::FMADDDrrr", "AArch64::FNMSUBDrrr", "AArch64::FNMADDDrrr", "0", "3", "AArch64::FMLAv2f32", "AArch64::FMLSv2f32", "0" ]

[]

[ "<s>", "void", "msp430_output_labelref", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "helper_function_name_mappings", "[", "i", "]", ".", "gcc_name", ";", "i", "++", ")", "if", "(", "strcmp", "(", "helper_function_name_mappings", "[", "i", "]", ".", "gcc_name", ",", "name", ")", "==", "0", ")", "{", "name", "=", "helper_function_name_mappings", "[", "i", "]", ".", "ti_name", ";", "break", ";", "}", "if", "(", "user_label_prefix", "[", "0", "]", "!=", "0", ")", "fputs", "(", "user_label_prefix", ",", "file", ")", ";", "fputs", "(", "name", ",", "file", ")", ";", "}", "</s>" ]

[ "This", "function", "does", "the", "same", "as", "the", "default", ",", "but", "it", "will", "replace", "GCC", "function", "names", "with", "the", "MSPABI-specified", "ones", "." ]

[ "msp430", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "RegDefsUses", "::", "init", "(", "const", "MachineInstr", "&", "MI", ")", "{", "update", "(", "MI", ",", "0", ",", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ")", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "Defs", ".", "set", "(", "Mips", "::", "RA", ")", ";", "if", "(", "MI", ".", "isBranch", "(", ")", ")", "{", "update", "(", "MI", ",", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ",", "MI", ".", "getNumOperands", "(", ")", ")", ";", "Defs", ".", "reset", "(", "Mips", "::", "AT", ")", ";", "}", "}", "</s>" ]

[ "Initialize", "the", "machine", "model", "for", "instruction", "scheduling", "." ]

[ "Mips", "0", "Mips::RA", "Mips::AT" ]

[]

[ "<s>", "bool", "loongarch_do_optimize_block_move_p", "(", "void", ")", "{", "if", "(", "target_flags_explicit", "&", "MASK_MEMCPY", ")", "return", "!", "TARGET_MEMCPY", ";", "return", "!", "optimize_size", ";", "}", "</s>" ]

[ "Return", "true", "if", "loongarch_expand_block_move", "is", "the", "preferred", "implementation", "of", "the", "'cpymemsi", "'", "template", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "CodeEmitter", ".", "reset", "(", "TM", ".", "getTarget", "(", ")", ".", "createMCCodeEmitter", "(", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "MF", ".", "getContext", "(", ")", ")", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Intrn", "=", "MF", ".", "getFunction", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Intrn", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "ix86_local_alignment", "(", "tree", "type", ",", "int", "align", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "(", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ">=", "16", "||", "TREE_INT_CST_HIGH", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{", "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "for", "a", "local", "variable", ".", "TYPE", "is", "the", "data", "type", ",", "and", "ALIGN", "is", "the", "alignment", "that", "the", "object", "would", "ordinarily", "have", ".", "The", "value", "of", "this", "macro", "is", "used", "instead", "of", "that", "alignment", "to", "align", "the", "object", "." ]

[ "i386", "16", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128" ]

[]

[ "<s>", "static", "int", "distance_agu_use", "(", "unsigned", "int", "regno0", ",", "rtx_insn", "*", "insn", ")", "{", "basic_block", "bb", "=", "BLOCK_FOR_INSN", "(", "insn", ")", ";", "int", "distance", "=", "0", ";", "bool", "found", "=", "false", ";", "bool", "redefined", "=", "false", ";", "if", "(", "insn", "!=", "BB_END", "(", "bb", ")", ")", "distance", "=", "distance_agu_use_in_bb", "(", "regno0", ",", "insn", ",", "distance", ",", "NEXT_INSN", "(", "insn", ")", ",", "&", "found", ",", "&", "redefined", ")", ";", "if", "(", "!", "found", "&&", "!", "redefined", "&&", "distance", "<", "LEA_SEARCH_THRESHOLD", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "bool", "simple_loop", "=", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "succs", ")", "if", "(", "e", "->", "dest", "==", "bb", ")", "{", "simple_loop", "=", "true", ";", "break", ";", "}", "if", "(", "simple_loop", ")", "distance", "=", "distance_agu_use_in_bb", "(", "regno0", ",", "insn", ",", "distance", ",", "BB_HEAD", "(", "bb", ")", ",", "&", "found", ",", "&", "redefined", ")", ";", "else", "{", "int", "shortest_dist", "=", "-", "1", ";", "bool", "found_in_bb", "=", "false", ";", "bool", "redefined_in_bb", "=", "false", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "succs", ")", "{", "int", "bb_dist", "=", "distance_agu_use_in_bb", "(", "regno0", ",", "insn", ",", "distance", ",", "BB_HEAD", "(", "e", "->", "dest", ")", ",", "&", "found_in_bb", ",", "&", "redefined_in_bb", ")", ";", "if", "(", "found_in_bb", ")", "{", "if", "(", "shortest_dist", "<", "0", ")", "shortest_dist", "=", "bb_dist", ";", "else", "if", "(", "bb_dist", ">", "0", ")", "shortest_dist", "=", "MIN", "(", "bb_dist", ",", "shortest_dist", ")", ";", "found", "=", "true", ";", "}", "}", "distance", "=", "shortest_dist", ";", "}", "}", "if", "(", "!", "found", "||", "redefined", ")", "return", "-", "1", ";", "return", "distance", ">>", "1", ";", "}", "</s>" ]

[ "Return", "the", "distance", "between", "INSN", "and", "the", "next", "insn", "that", "uses", "register", "number", "REGNO0", "in", "memory", "address", ".", "Return", "-1", "if", "no", "such", "a", "use", "is", "found", "within", "LEA_SEARCH_THRESHOLD", "or", "REGNO0", "is", "set", "." ]

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

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ")", "const", "{", "unsigned", "SrcSize", "=", "getRegSizeInBits", "(", "*", "SrcRC", ")", ";", "unsigned", "DstSize", "=", "getRegSizeInBits", "(", "*", "DstRC", ")", ";", "unsigned", "NewSize", "=", "getRegSizeInBits", "(", "*", "NewRC", ")", ";", "if", "(", "SrcSize", "<=", "32", "||", "DstSize", "<=", "32", ")", "return", "true", ";", "return", "NewSize", "<=", "DstSize", "||", "NewSize", "<=", "SrcSize", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

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

[]

[ "<s>", "void", "s390_expand_movmem", "(", "rtx", "dst", ",", "rtx", "src", ",", "rtx", "len", ")", "{", "if", "(", "GET_CODE", "(", "len", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "len", ")", ">=", "0", "&&", "INTVAL", "(", "len", ")", "<=", "256", ")", "{", "if", "(", "INTVAL", "(", "len", ")", ">", "0", ")", "emit_insn", "(", "gen_movmem_short", "(", "dst", ",", "src", ",", "GEN_INT", "(", "INTVAL", "(", "len", ")", "-", "1", ")", ")", ")", ";", "}", "else", "if", "(", "TARGET_MVCLE", ")", "{", "emit_insn", "(", "gen_movmem_long", "(", "dst", ",", "src", ",", "convert_to_mode", "(", "Pmode", ",", "len", ",", "1", ")", ")", ")", ";", "}", "else", "{", "rtx", "dst_addr", ",", "src_addr", ",", "count", ",", "blocks", ",", "temp", ";", "rtx", "loop_start_label", "=", "gen_label_rtx", "(", ")", ";", "rtx", "loop_end_label", "=", "gen_label_rtx", "(", ")", ";", "rtx", "end_label", "=", "gen_label_rtx", "(", ")", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "len", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "Pmode", ";", "dst_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "src_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "count", "=", "gen_reg_rtx", "(", "mode", ")", ";", "blocks", "=", "gen_reg_rtx", "(", "mode", ")", ";", "convert_move", "(", "count", ",", "len", ",", "1", ")", ";", "emit_cmp_and_jump_insns", "(", "count", ",", "const0_rtx", ",", "EQ", ",", "NULL_RTX", ",", "mode", ",", "1", ",", "end_label", ")", ";", "emit_move_insn", "(", "dst_addr", ",", "force_operand", "(", "XEXP", "(", "dst", ",", "0", ")", ",", "NULL_RTX", ")", ")", ";", "emit_move_insn", "(", "src_addr", ",", "force_operand", "(", "XEXP", "(", "src", ",", "0", ")", ",", "NULL_RTX", ")", ")", ";", "dst", "=", "change_address", "(", "dst", ",", "VOIDmode", ",", "dst_addr", ")", ";", "src", "=", "change_address", "(", "src", ",", "VOIDmode", ",", "src_addr", ")", ";", "temp", "=", "expand_binop", "(", "mode", ",", "add_optab", ",", "count", ",", "constm1_rtx", ",", "count", ",", "1", ",", "0", ")", ";", "if", "(", "temp", "!=", "count", ")", "emit_move_insn", "(", "count", ",", "temp", ")", ";", "temp", "=", "expand_binop", "(", "mode", ",", "ashr_optab", ",", "count", ",", "GEN_INT", "(", "8", ")", ",", "blocks", ",", "1", ",", "0", ")", ";", "if", "(", "temp", "!=", "blocks", ")", "emit_move_insn", "(", "blocks", ",", "temp", ")", ";", "emit_cmp_and_jump_insns", "(", "blocks", ",", "const0_rtx", ",", "EQ", ",", "NULL_RTX", ",", "mode", ",", "1", ",", "loop_end_label", ")", ";", "emit_label", "(", "loop_start_label", ")", ";", "emit_insn", "(", "gen_movmem_short", "(", "dst", ",", "src", ",", "GEN_INT", "(", "255", ")", ")", ")", ";", "s390_load_address", "(", "dst_addr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "dst_addr", ",", "GEN_INT", "(", "256", ")", ")", ")", ";", "s390_load_address", "(", "src_addr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "src_addr", ",", "GEN_INT", "(", "256", ")", ")", ")", ";", "temp", "=", "expand_binop", "(", "mode", ",", "add_optab", ",", "blocks", ",", "constm1_rtx", ",", "blocks", ",", "1", ",", "0", ")", ";", "if", "(", "temp", "!=", "blocks", ")", "emit_move_insn", "(", "blocks", ",", "temp", ")", ";", "emit_cmp_and_jump_insns", "(", "blocks", ",", "const0_rtx", ",", "EQ", ",", "NULL_RTX", ",", "mode", ",", "1", ",", "loop_end_label", ")", ";", "emit_jump", "(", "loop_start_label", ")", ";", "emit_label", "(", "loop_end_label", ")", ";", "emit_insn", "(", "gen_movmem_short", "(", "dst", ",", "src", ",", "convert_to_mode", "(", "Pmode", ",", "count", ",", "1", ")", ")", ")", ";", "emit_label", "(", "end_label", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "move", "LEN", "bytes", "from", "DST", "to", "SRC", "." ]

[ "s390", "0", "256", "0", "1", "1", "1", "1", "0", "0", "1", "0", "8", "1", "0", "1", "255", "256", "256", "1", "0", "1", "1" ]

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "signExtend", "(", "unsigned", "Reg", ",", "const", "Value", "*", "V", ",", "MVT", "::", "SimpleValueType", "From", ",", "MVT", "::", "SimpleValueType", "To", ")", "{", "if", "(", "To", "==", "MVT", "::", "i64", ")", "{", "if", "(", "From", "==", "MVT", "::", "i64", ")", "return", "copyValue", "(", "Reg", ")", ";", "Reg", "=", "signExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "unsigned", "Result", "=", "createResultReg", "(", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "WebAssembly", "::", "I64_EXTEND_S_I32", ")", ",", "Result", ")", ".", "addReg", "(", "Reg", ")", ";", "return", "Result", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "return", "signExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "new", "range", "in", "the", "specified", "integer", "type", ",", "which", "must", "be", "strictly", "larger", "than", "the", "current", "type", "." ]

[ "WebAssembly", "WebAssembly", "MVT::SimpleValueType", "MVT::SimpleValueType", "MVT::i64", "MVT::i64", "WebAssembly::I64RegClass", "WebAssembly::I64_EXTEND_S_I32", "MVT::i32", "0" ]

[]

[ "<s>", "unsigned", "int", "s390_case_values_threshold", "(", "void", ")", "{", "if", "(", "TARGET_INDIRECT_BRANCH_NOBP_JUMP", ")", "return", "20", ";", "return", "default_case_values_threshold", "(", ")", ";", "}", "</s>" ]

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

[ "s390", "20" ]

[]

[ "<s>", "void", "recordRelocation", "(", "MachObjectWriter", "*", "Writer", ",", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFragment", "*", "Fragment", ",", "const", "MCFixup", "&", "Fixup", ",", "MCValue", "Target", ",", "uint64_t", "&", "FixedValue", ")", "override", "{", "if", "(", "Writer", "->", "is64Bit", "(", ")", ")", "{", "report_fatal_error", "(", "\"Relocation emission for MachO/PPC64 unimplemented.\"", ")", ";", "}", "else", "RecordPPCRelocation", "(", "Writer", ",", "Asm", ",", "Layout", ",", "Fragment", ",", "Fixup", ",", "Target", ",", "FixedValue", ")", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

[ "PowerPC", "\"Relocation emission for MachO/PPC64 unimplemented.\"", "PPC" ]

[]

[ "<s>", "unsigned", "AArch64FrameLowering", "::", "getWinEHParentFrameOffset", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "The", "parent", "frame", "offset", "(", "aka", "dispFrame", ")", "is", "only", "used", "on", "X86_64", "to", "retrieve", "the", "parent", "'s", "frame", "pointer", "." ]

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

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "joinRegisterPartsIntoValue", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "const", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "EVT", "ValueVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "bool", "IsABIRegCopy", "=", "CC", ".", "hasValue", "(", ")", ";", "if", "(", "IsABIRegCopy", "&&", "ValueVT", "==", "MVT", "::", "f16", "&&", "PartVT", "==", "MVT", "::", "f32", ")", "{", "SDValue", "Val", "=", "Parts", "[", "0", "]", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i16", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "f16", ",", "Val", ")", ";", "return", "Val", ";", "}", "if", "(", "ValueVT", ".", "isScalableVector", "(", ")", "&&", "PartVT", ".", "isScalableVector", "(", ")", ")", "{", "LLVMContext", "&", "Context", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "SDValue", "Val", "=", "Parts", "[", "0", "]", ";", "EVT", "ValueEltVT", "=", "ValueVT", ".", "getVectorElementType", "(", ")", ";", "EVT", "PartEltVT", "=", "PartVT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "ValueVTBitSize", "=", "ValueVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "unsigned", "PartVTBitSize", "=", "PartVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "if", "(", "PartVTBitSize", "%", "ValueVTBitSize", "==", "0", ")", "{", "assert", "(", "PartVTBitSize", ">=", "ValueVTBitSize", ")", ";", "EVT", "SameEltTypeVT", "=", "ValueVT", ";", "if", "(", "ValueEltVT", "!=", "PartEltVT", ")", "{", "unsigned", "Count", "=", "PartVTBitSize", "/", "ValueEltVT", ".", "getFixedSizeInBits", "(", ")", ";", "assert", "(", "Count", "!=", "0", "&&", "\"The number of element should not be zero.\"", ")", ";", "SameEltTypeVT", "=", "EVT", "::", "getVectorVT", "(", "Context", ",", "ValueEltVT", ",", "Count", ",", "true", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "SameEltTypeVT", ",", "Val", ")", ";", "}", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "ValueVT", ",", "Val", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "DL", ")", ")", ";", "return", "Val", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Target-specific", "combining", "of", "register", "parts", "into", "its", "original", "value", "." ]

[ "RISCV", "RISCV", "MVT::f16", "MVT::f32", "0", "ISD::BITCAST", "MVT::i32", "ISD::TRUNCATE", "MVT::i16", "ISD::BITCAST", "MVT::f16", "0", "0", "0", "\"The number of element should not be zero.\"", "ISD::BITCAST", "ISD::EXTRACT_SUBVECTOR", "0" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "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", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "assert", "(", "0", "&&", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::LDri", "0", "SP::FPRegsRegisterClass", "SP::LDFri", "0", "SP::DFPRegsRegisterClass", "SP::LDDFri", "0", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "static", "bool", "ia64_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "(", "regno", ">=", "GR_RET_FIRST", "&&", "regno", "<=", "GR_RET_LAST", ")", "||", "(", "regno", ">=", "FR_RET_FIRST", "&&", "regno", "<=", "FR_RET_LAST", ")", ")", ";", "}", "</s>" ]

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

[ "ia64" ]

[]

[ "<s>", "const", "char", "*", "SparcTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "SPISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "SPISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "SPISD", "::", "CMPICC", ":", "return", "\"SPISD::CMPICC\"", ";", "case", "SPISD", "::", "CMPFCC", ":", "return", "\"SPISD::CMPFCC\"", ";", "case", "SPISD", "::", "BRICC", ":", "return", "\"SPISD::BRICC\"", ";", "case", "SPISD", "::", "BRXCC", ":", "return", "\"SPISD::BRXCC\"", ";", "case", "SPISD", "::", "BRFCC", ":", "return", "\"SPISD::BRFCC\"", ";", "case", "SPISD", "::", "SELECT_ICC", ":", "return", "\"SPISD::SELECT_ICC\"", ";", "case", "SPISD", "::", "SELECT_XCC", ":", "return", "\"SPISD::SELECT_XCC\"", ";", "case", "SPISD", "::", "SELECT_FCC", ":", "return", "\"SPISD::SELECT_FCC\"", ";", "case", "SPISD", "::", "Hi", ":", "return", "\"SPISD::Hi\"", ";", "case", "SPISD", "::", "Lo", ":", "return", "\"SPISD::Lo\"", ";", "case", "SPISD", "::", "FTOI", ":", "return", "\"SPISD::FTOI\"", ";", "case", "SPISD", "::", "ITOF", ":", "return", "\"SPISD::ITOF\"", ";", "case", "SPISD", "::", "FTOX", ":", "return", "\"SPISD::FTOX\"", ";", "case", "SPISD", "::", "XTOF", ":", "return", "\"SPISD::XTOF\"", ";", "case", "SPISD", "::", "CALL", ":", "return", "\"SPISD::CALL\"", ";", "case", "SPISD", "::", "RET_FLAG", ":", "return", "\"SPISD::RET_FLAG\"", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "\"SPISD::GLOBAL_BASE_REG\"", ";", "case", "SPISD", "::", "FLUSHW", ":", "return", "\"SPISD::FLUSHW\"", ";", "case", "SPISD", "::", "TLS_ADD", ":", "return", "\"SPISD::TLS_ADD\"", ";", "case", "SPISD", "::", "TLS_LD", ":", "return", "\"SPISD::TLS_LD\"", ";", "case", "SPISD", "::", "TLS_CALL", ":", "return", "\"SPISD::TLS_CALL\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SPISD::NodeType", "SPISD::FIRST_NUMBER", "SPISD::CMPICC", "\"SPISD::CMPICC\"", "SPISD::CMPFCC", "\"SPISD::CMPFCC\"", "SPISD::BRICC", "\"SPISD::BRICC\"", "SPISD::BRXCC", "\"SPISD::BRXCC\"", "SPISD::BRFCC", "\"SPISD::BRFCC\"", "SPISD::SELECT_ICC", "\"SPISD::SELECT_ICC\"", "SPISD::SELECT_XCC", "\"SPISD::SELECT_XCC\"", "SPISD::SELECT_FCC", "\"SPISD::SELECT_FCC\"", "SPISD::Hi", "\"SPISD::Hi\"", "SPISD::Lo", "\"SPISD::Lo\"", "SPISD::FTOI", "\"SPISD::FTOI\"", "SPISD::ITOF", "\"SPISD::ITOF\"", "SPISD::FTOX", "\"SPISD::FTOX\"", "SPISD::XTOF", "\"SPISD::XTOF\"", "SPISD::CALL", "\"SPISD::CALL\"", "SPISD::RET_FLAG", "\"SPISD::RET_FLAG\"", "SPISD::GLOBAL_BASE_REG", "\"SPISD::GLOBAL_BASE_REG\"", "SPISD::FLUSHW", "\"SPISD::FLUSHW\"", "SPISD::TLS_ADD", "\"SPISD::TLS_ADD\"", "SPISD::TLS_LD", "\"SPISD::TLS_LD\"", "SPISD::TLS_CALL", "\"SPISD::TLS_CALL\"" ]

[]

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

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

[ "LC3" ]

[]

[ "<s>", "int", "first_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "13", ";", "first_reg", "<=", "31", ";", "first_reg", "++", ")", "if", "(", "save_reg_p", "(", "first_reg", ")", ")", "break", ";", "if", "(", "first_reg", ">", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "!=", "0", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "||", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", ")", "&&", "rs6000_reg_live_or_pic_offset_p", "(", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ")", "first_reg", "=", "RS6000_PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "flag_pic", "&&", "crtl", "->", "uses_pic_offset_table", "&&", "first_reg", ">", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", "return", "RS6000_PIC_OFFSET_TABLE_REGNUM", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Return", "the", "first", "register", "that", "is", "required", "to", "be", "saved", ".", "16", "if", "none", "." ]

[ "rs6000", "13", "31", "0" ]

[]

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

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

[ "VideoCore4", "VideoCore4", "VideoCore4" ]

[]

[ "<s>", "void", "ix86_expand_vector_move_misalign", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "op0", ",", "op1", ",", "m", ";", "op0", "=", "operands", "[", "0", "]", ";", "op1", "=", "operands", "[", "1", "]", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", "||", "optimize_insn_for_size_p", "(", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_AVX", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", ")", "ix86_avx256_split_vector_move_misalign", "(", "op0", ",", "op1", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SSE_UNALIGNED_LOAD_OPTIMAL", "||", "TARGET_SSE_PACKED_SINGLE_INSN_OPTIMAL", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SSE2", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "MEM_P", "(", "op1", ")", ")", "{", "if", "(", "TARGET_SSE2", "&&", "mode", "==", "V2DFmode", ")", "{", "rtx", "zero", ";", "if", "(", "TARGET_SSE_SPLIT_REGS", ")", "{", "emit_clobber", "(", "op0", ")", ";", "zero", "=", "op0", ";", "}", "else", "{", "zero", "=", "CONST0_RTX", "(", "V2DFmode", ")", ";", "}", "m", "=", "adjust_address", "(", "op1", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse2_loadlpd", "(", "op0", ",", "zero", ",", "m", ")", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "DFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse2_loadhpd", "(", "op0", ",", "op0", ",", "m", ")", ")", ";", "}", "else", "{", "rtx", "t", ";", "if", "(", "mode", "!=", "V4SFmode", ")", "t", "=", "gen_reg_rtx", "(", "V4SFmode", ")", ";", "else", "t", "=", "op0", ";", "if", "(", "TARGET_SSE_PARTIAL_REG_DEPENDENCY", ")", "emit_move_insn", "(", "t", ",", "CONST0_RTX", "(", "V4SFmode", ")", ")", ";", "else", "emit_clobber", "(", "t", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "V2SFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse_loadlps", "(", "t", ",", "t", ",", "m", ")", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "V2SFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse_loadhps", "(", "t", ",", "t", ",", "m", ")", ")", ";", "if", "(", "mode", "!=", "V4SFmode", ")", "emit_move_insn", "(", "op0", ",", "gen_lowpart", "(", "mode", ",", "t", ")", ")", ";", "}", "}", "else", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "if", "(", "TARGET_SSE2", "&&", "mode", "==", "V2DFmode", ")", "{", "m", "=", "adjust_address", "(", "op0", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse2_storelpd", "(", "m", ",", "op1", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "DFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse2_storehpd", "(", "m", ",", "op1", ")", ")", ";", "}", "else", "{", "if", "(", "mode", "!=", "V4SFmode", ")", "op1", "=", "gen_lowpart", "(", "V4SFmode", ",", "op1", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "V2SFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse_storelps", "(", "m", ",", "op1", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "V2SFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse_storehps", "(", "m", ",", "copy_rtx", "(", "op1", ")", ")", ")", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "movmisalign", "patterns", "for", "SSE", ".", "Non-SSE", "modes", "go", "straight", "to", "ix86_expand_vector_move", "." ]

[ "i386", "0", "1", "64", "32", "0", "8", "0", "8", "0", "8", "0", "8" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getMcpu", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "MCPU_PWR7", "||", "Directive", "==", "PPC", "::", "MCPU_PWR8", ")", "return", "new", "PPCDispatchGroupSBHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "if", "(", "Directive", "!=", "PPC", "::", "MCPU_440", "&&", "Directive", "!=", "PPC", "::", "MCPU_A2", "&&", "Directive", "!=", "PPC", "::", "MCPU_E500mc", "&&", "Directive", "!=", "PPC", "::", "MCPU_E5500", ")", "{", "assert", "(", "DAG", "->", "TII", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "DAG", ")", ";", "}", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::MCPU_PWR7", "PPC::MCPU_PWR8", "PPC", "PPC::MCPU_440", "PPC::MCPU_A2", "PPC::MCPU_E500mc", "PPC::MCPU_E5500", "\"No InstrInfo?\"", "PPC" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "RA", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "RA_64", ":", "Mips", "::", "RA", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "BP", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "S7_64", ":", "Mips", "::", "S7", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "RA", ")", ";", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "FP", ")", ";", "}", "if", "(", "hasBP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "BP", ")", ";", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "MipsFI", "->", "createEhDataRegsFI", "(", "MF", ")", ";", "if", "(", "MipsFI", "->", "isISR", "(", ")", ")", "MipsFI", "->", "createISRRegFI", "(", "MF", ")", ";", "if", "(", "ExpandPseudo", "(", "MF", ")", ".", "expand", "(", ")", ")", "{", "const", "TargetRegisterClass", "&", "RC", "=", "STI", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlign", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "uint64_t", "MaxSPOffset", "=", "estimateStackSize", "(", "MF", ")", ";", "if", "(", "isIntN", "(", "STI", ".", "hasMSA", "(", ")", "?", "10", ":", "16", ",", "MaxSPOffset", ")", "&&", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "return", ";", "const", "TargetRegisterClass", "&", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlign", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::RA_64", "Mips::RA", "Mips::S7_64", "Mips::S7", "Mips", "Mips", "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "10", "16", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "bool", "RedundantInstrElimination", "::", "processBlock", "(", "MachineBasicBlock", "&", "B", ",", "const", "RegisterSet", "&", ")", "{", "if", "(", "!", "BT", ".", "reached", "(", "&", "B", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ",", "NextI", "=", "I", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "NextI", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "*", "MI", "=", "&", "*", "I", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "COPY", ")", "continue", ";", "if", "(", "MI", "->", "isPHI", "(", ")", "||", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "isInlineAsm", "(", ")", ")", "continue", ";", "unsigned", "NumD", "=", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", ";", "if", "(", "NumD", "!=", "1", ")", "continue", ";", "BitTracker", "::", "RegisterRef", "RD", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "!", "BT", ".", "has", "(", "RD", ".", "Reg", ")", ")", "continue", ";", "const", "BitTracker", "::", "RegisterCell", "&", "DC", "=", "BT", ".", "lookup", "(", "RD", ".", "Reg", ")", ";", "auto", "At", "=", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "uses", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "BitTracker", "::", "RegisterRef", "RS", "=", "Op", ";", "if", "(", "!", "BT", ".", "has", "(", "RS", ".", "Reg", ")", ")", "continue", ";", "if", "(", "!", "HBS", "::", "isTransparentCopy", "(", "RD", ",", "RS", ",", "MRI", ")", ")", "continue", ";", "unsigned", "BN", ",", "BW", ";", "if", "(", "!", "HBS", "::", "getSubregMask", "(", "RS", ",", "BN", ",", "BW", ",", "MRI", ")", ")", "continue", ";", "const", "BitTracker", "::", "RegisterCell", "&", "SC", "=", "BT", ".", "lookup", "(", "RS", ".", "Reg", ")", ";", "if", "(", "!", "usedBitsEqual", "(", "RD", ",", "RS", ")", "&&", "!", "HBS", "::", "isEqual", "(", "DC", ",", "0", ",", "SC", ",", "BN", ",", "BW", ")", ")", "continue", ";", "const", "DebugLoc", "&", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "FRC", "=", "HBS", "::", "getFinalVRegClass", "(", "RD", ",", "MRI", ")", ";", "unsigned", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "FRC", ")", ";", "MachineInstr", "*", "CopyI", "=", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewR", ")", ".", "addReg", "(", "RS", ".", "Reg", ",", "0", ",", "RS", ".", "Sub", ")", ";", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "RD", ".", "Sub", ",", "NewR", ",", "0", ",", "MRI", ")", ";", "BT", ".", "visit", "(", "*", "CopyI", ")", ";", "Changed", "=", "true", ";", "break", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

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

[]

[ "<s>", "static", "bool", "is_end_basic_block", "(", "enum", "dispatch_group", "group", ")", "{", "return", "group", "==", "disp_branch", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "a", "branch", "is", "detected", ".", "End", "of", "a", "basic", "block", "does", "not", "have", "to", "be", "a", "branch", ",", "but", "here", "we", "assume", "only", "branches", "end", "a", "window", "." ]

[ "i386" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SystemZ Assembly Printer\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ Assembly Printer\"" ]

[]

[ "<s>", "int", "VESubtarget", "::", "getAdjustedFrameSize", "(", "int", "frameSize", ")", "const", "{", "frameSize", "+=", "176", ";", "frameSize", "=", "alignTo", "(", "frameSize", ",", "16", ")", ";", "return", "frameSize", ";", "}", "</s>" ]

[ "Given", "a", "actual", "stack", "size", "as", "determined", "by", "FrameInfo", ",", "this", "function", "returns", "adjusted", "framesize", "which", "includes", "space", "for", "RSA", ",", "return", "address", ",", "and", "frame", "poitner", "." ]

[ "VE", "VE", "176", "16" ]

[]

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

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

[ "CellSPU", "16" ]

[]

[ "<s>", "static", "const", "char", "*", "cond_name_x", "(", "int", "code", ")", "{", "if", "(", "cc_prev_status", ".", "flags", "&", "CC_NO_OVERFLOW", ")", "{", "switch", "(", "code", ")", "{", "case", "LT", ":", "return", "\"mi\"", ";", "case", "GE", ":", "return", "\"pl\"", ";", "}", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"eq\"", ";", "case", "NE", ":", "return", "\"ne\"", ";", "case", "LT", ":", "return", "\"lt\"", ";", "case", "LE", ":", "return", "\"le\"", ";", "case", "GT", ":", "return", "\"gt\"", ";", "case", "GE", ":", "return", "\"ge\"", ";", "case", "LTU", ":", "return", "\"ult\"", ";", "case", "LEU", ":", "return", "\"ule\"", ";", "case", "GTU", ":", "return", "\"ugt\"", ";", "case", "GEU", ":", "return", "\"uge\"", ";", "default", ":", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "Turn", "a", "condition", "code", "into", "a", "string" ]

[ "z8k", "\"mi\"", "\"pl\"", "\"eq\"", "\"ne\"", "\"lt\"", "\"le\"", "\"gt\"", "\"ge\"", "\"ult\"", "\"ule\"", "\"ugt\"", "\"uge\"" ]

[]

[ "<s>", "static", "tree", "spu_builtin_mask_for_load", "(", "void", ")", "{", "return", "spu_builtin_decls", "[", "SPU_MASK_FOR_LOAD", "]", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_mask_for_load", "." ]

[ "spu" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "FoldImmediate", "(", "MachineInstr", "&", "UseMI", ",", "MachineInstr", "&", "DefMI", ",", "Register", "Reg", ",", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "bool", "Changed", "=", "onlyFoldImmediate", "(", "UseMI", ",", "DefMI", ",", "Reg", ")", ";", "if", "(", "MRI", "->", "use_nodbg_empty", "(", "Reg", ")", ")", "DefMI", ".", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "Reg", "is", "known", "to", "be", "defined", "by", "a", "move", "immediate", "instruction", ",", "try", "to", "fold", "the", "immediate", "into", "the", "use", "instruction", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "MSP430AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".long\"", ")", "{", "ParseLiteralValues", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".word\"", "||", "IDVal", ".", "lower", "(", ")", "==", "\".short\"", ")", "{", "ParseLiteralValues", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".byte\"", ")", "{", "ParseLiteralValues", "(", "1", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".refsym\"", ")", "{", "return", "ParseDirectiveRefSym", "(", "DirectiveID", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\".long\"", "4", "\".word\"", "\".short\"", "2", "\".byte\"", "1", "\".refsym\"" ]

[]

[ "<s>", "MCSection", "*", "AMDGPUTargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "SK", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "StringRef", "SectionName", "=", "GO", "->", "getSection", "(", ")", ";", "if", "(", "SectionName", ".", "startswith", "(", "\".AMDGPU.comment.\"", ")", ")", "SK", "=", "SectionKind", "::", "getMetadata", "(", ")", ";", "return", "TargetLoweringObjectFileELF", "::", "getExplicitSectionGlobal", "(", "GO", ",", "SK", ",", "TM", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "AMDGPU", "AMDGPU", "\".AMDGPU.comment.\"" ]

[]

[ "<s>", "inline", "bool", "function_call_info", "::", "function_returns_void_p", "(", ")", "{", "return", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "==", "void_type_node", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "has", "no", "return", "value", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "OptimizeLEAPass", "::", "isReplaceable", "(", "const", "MachineInstr", "&", "First", ",", "const", "MachineInstr", "&", "Last", ",", "int64_t", "&", "AddrDispShift", ")", "const", "{", "assert", "(", "isLEA", "(", "First", ")", "&&", "isLEA", "(", "Last", ")", "&&", "\"The function works only with LEA instructions\"", ")", ";", "AddrDispShift", "=", "getAddrDispShift", "(", "Last", ",", "1", ",", "First", ",", "1", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "First", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "!=", "MRI", "->", "getRegClass", "(", "Last", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "MO", ":", "MRI", "->", "use_operands", "(", "Last", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MO", ".", "getParent", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "int", "MemOpNo", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemOpNo", "<", "0", ")", "return", "false", ";", "MemOpNo", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "if", "(", "!", "isIdenticalOp", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", ",", "MO", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MI", ".", "getNumOperands", "(", ")", ";", "i", "++", ")", "if", "(", "i", "!=", "(", "unsigned", ")", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", "&&", "isIdenticalOp", "(", "MI", ".", "getOperand", "(", "i", ")", ",", "MO", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "isImm", "(", ")", "&&", "!", "isInt", "<", "32", ">", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "getImm", "(", ")", "+", "AddrDispShift", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "metadata", "is", "replaceable", "." ]

[ "X86", "\"The function works only with LEA instructions\"", "1", "1", "0", "0", "0", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "0", "X86::AddrBaseReg", "X86::AddrDisp", "32", "X86::AddrDisp" ]

[]

[ "<s>", "iterator", "end", "(", ")", "{", "return", "Blocks", ".", "rend", "(", ")", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "JVM" ]

[]

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

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

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "printAndVerify", "(", "\"After ARM load / store optimizer\"", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "restrictIT", "(", ")", "&&", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM", "ARM", "\"After ARM load / store optimizer\"", "ARM", "ARM::DPRRegClass", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "int64_t", "getConstant", "(", "const", "MachineInstr", "*", "MI", ")", "{", "return", "MI", "->", "getOperand", "(", "1", ")", ".", "getCImm", "(", ")", "->", "getSExtValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "large", "constant", "at", "the", "given", "index", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "bool", "KudeyarPassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "{", "if", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "EABIHF", "||", "TargetTriple", ".", "isOSWindows", "(", ")", "||", "TargetABI", "==", "ARMBaseTargetMachine", "::", "ARM_ABI_AAPCS16", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "else", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "}", "if", "(", "Options", ".", "EABIVersion", "==", "EABI", "::", "Default", "||", "Options", ".", "EABIVersion", "==", "EABI", "::", "Unknown", ")", "{", "if", "(", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUEABIHF", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABI", "||", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "MuslEABIHF", ")", "&&", "!", "(", "TargetTriple", ".", "isOSWindows", "(", ")", "||", "TargetTriple", ".", "isOSDarwin", "(", ")", ")", ")", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "GNU", ";", "else", "this", "->", "Options", ".", "EABIVersion", "=", "EABI", "::", "EABI5", ";", "}", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "I", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "STWFI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::STWFI", "0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", "++", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "while", "(", "(", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SparcPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "swiftAsyncContextIsDynamicallySet", "(", ")", "const", "{", "const", "Triple", "&", "TT", "=", "getTargetTriple", "(", ")", ";", "unsigned", "Major", ",", "Minor", ",", "Micro", ";", "TT", ".", "getOSVersion", "(", "Major", ",", "Minor", ",", "Micro", ")", ";", "switch", "(", "TT", ".", "getOS", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Triple", "::", "IOS", ":", "case", "Triple", "::", "TvOS", ":", "return", "Major", "<", "15", ";", "case", "Triple", "::", "WatchOS", ":", "return", "Major", "<", "8", ";", "case", "Triple", "::", "MacOSX", ":", "case", "Triple", "::", "Darwin", ":", "return", "Major", "<", "12", ";", "}", "}", "</s>" ]

[ "Return", "whether", "FrameLowering", "should", "always", "set", "the", "``", "extended", "frame", "present", "''", "bit", "in", "FP", ",", "or", "set", "it", "based", "on", "a", "symbol", "in", "the", "runtime", "." ]

[ "AArch64", "15", "8", "12" ]

[]

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

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

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

[]

[ "<s>", "MCOperand", "SystemZMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Register", ":", "return", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "default", ":", "{", "MCSymbolRefExpr", "::", "VariantKind", "Kind", "=", "getVariantKind", "(", "MO", ".", "getTargetFlags", "(", ")", ")", ";", "return", "MCOperand", "::", "createExpr", "(", "getExpr", "(", "MO", ",", "Kind", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "rtx", "pa_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "valmode", ";", "if", "(", "AGGREGATE_TYPE_P", "(", "valtype", ")", "||", "TREE_CODE", "(", "valtype", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "valtype", ")", "==", "VECTOR_TYPE", ")", "{", "HOST_WIDE_INT", "valsize", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "(", "valsize", "&", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "==", "0", ")", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "28", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "rtx", "loc", "[", "2", "]", ";", "int", "i", ",", "offset", "=", "0", ";", "int", "ub", "=", "valsize", "<=", "UNITS_PER_WORD", "?", "1", ":", "2", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ub", ";", "i", "++", ")", "{", "loc", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "DImode", ",", "28", "+", "i", ")", ",", "GEN_INT", "(", "offset", ")", ")", ";", "offset", "+=", "8", ";", "}", "return", "gen_rtx_PARALLEL", "(", "BLKmode", ",", "gen_rtvec_v", "(", "ub", ",", "loc", ")", ")", ";", "}", "else", "if", "(", "valsize", ">", "UNITS_PER_WORD", ")", "{", "rtx", "loc", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "DImode", ",", "28", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "loc", ")", ")", ";", "}", "}", "if", "(", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "&&", "GET_MODE_BITSIZE", "(", "TYPE_MODE", "(", "valtype", ")", ")", "<", "BITS_PER_WORD", ")", "||", "POINTER_TYPE_P", "(", "valtype", ")", ")", "valmode", "=", "word_mode", ";", "else", "valmode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "TREE_CODE", "(", "valtype", ")", "==", "REAL_TYPE", "&&", "!", "AGGREGATE_TYPE_P", "(", "valtype", ")", "&&", "TYPE_MODE", "(", "valtype", ")", "!=", "TFmode", "&&", "!", "TARGET_SOFT_FLOAT", ")", "return", "gen_rtx_REG", "(", "valmode", ",", "32", ")", ";", "return", "gen_rtx_REG", "(", "valmode", ",", "28", ")", ";", "}", "</s>" ]

[ "On", "the", "HP-PA", "the", "value", "is", "found", "in", "register", "(", "s", ")", "28", "(", "-29", ")", ",", "unless", "the", "mode", "is", "SF", "or", "DF", ".", "Then", "the", "value", "is", "returned", "in", "fr4", "(", "32", ")", ".", "This", "must", "perform", "the", "same", "promotions", "as", "PROMOTE_MODE", ",", "else", "promoting", "return", "values", "in", "TARGET_PROMOTE_FUNCTION_MODE", "will", "not", "work", "correctly", ".", "Small", "structures", "must", "be", "returned", "in", "a", "PARALLEL", "on", "PA64", "in", "order", "to", "match", "the", "HP", "Compiler", "ABI", "." ]

[ "pa", "1", "0", "28", "2", "0", "1", "2", "0", "28", "8", "28", "1", "32", "28" ]

[]

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

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

[ "Comet2", "\"### getPassName\\n\"", "\"Comet2 DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "rtx_insn", "*", "sh_check_add_incdec_notes", "(", "rtx_insn", "*", "i", ")", "{", "struct", "for_each_inc_dec_clb", "{", "static", "int", "func", "(", "rtx", "mem", "ATTRIBUTE_UNUSED", ",", "rtx", "op", "ATTRIBUTE_UNUSED", ",", "rtx", "dest", ",", "rtx", "src", "ATTRIBUTE_UNUSED", ",", "rtx", "srcoff", "ATTRIBUTE_UNUSED", ",", "void", "*", "arg", ")", "{", "gcc_assert", "(", "REG_P", "(", "dest", ")", ")", ";", "rtx_insn", "*", "i", "=", "(", "rtx_insn", "*", ")", "arg", ";", "if", "(", "find_regno_note", "(", "i", ",", "REG_INC", ",", "REGNO", "(", "dest", ")", ")", "==", "NULL", ")", "add_reg_note", "(", "i", ",", "REG_INC", ",", "dest", ")", ";", "return", "0", ";", "}", "}", ";", "for_each_inc_dec", "(", "PATTERN", "(", "i", ")", ",", "for_each_inc_dec_clb", "::", "func", ",", "i", ")", ";", "return", "i", ";", "}", "</s>" ]

[ "Given", "an", "insn", "check", "if", "it", "contains", "any", "post/pre", "inc/dec", "mem", "operands", "and", "add", "the", "REG_INC", "notes", "accordingly", ".", "FIXME", ":", "This", "function", "is", "very", "similar", "to", "lra.cc", "(", "add_auto_inc_notes", ")", ".", "FIXME", ":", "This", "function", "is", "currently", "used", "by", "peephole2", "patterns", "because", "the", "peephole2", "pass", "does", "not", "preserve", "REG_INC", "notes", ".", "If", "the", "notes", "are", "dropped", "the", "following", "passes", "will", "do", "wrong", "things", "." ]

[ "sh", "0" ]

[]

[ "<s>", "void", "s390_indirect_branch_via_thunk", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "return_addr_regno", ",", "rtx", "comparison_operator", ",", "enum", "s390_indirect_branch_type", "type", ")", "{", "enum", "s390_indirect_branch_option", "option", ";", "if", "(", "type", "==", "s390_indirect_branch_type_return", ")", "{", "if", "(", "s390_return_addr_from_memory", "(", ")", ")", "option", "=", "s390_opt_function_return_mem", ";", "else", "option", "=", "s390_opt_function_return_reg", ";", "}", "else", "if", "(", "type", "==", "s390_indirect_branch_type_jump", ")", "option", "=", "s390_opt_indirect_branch_jump", ";", "else", "if", "(", "type", "==", "s390_indirect_branch_type_call", ")", "option", "=", "s390_opt_indirect_branch_call", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "TARGET_INDIRECT_BRANCH_TABLE", ")", "{", "char", "label", "[", "32", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "indirect_branch_table_label", "[", "option", "]", ",", "indirect_branch_table_label_no", "[", "option", "]", "++", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "label", ")", ";", "}", "if", "(", "return_addr_regno", "!=", "INVALID_REGNUM", ")", "{", "gcc_assert", "(", "comparison_operator", "==", "NULL_RTX", ")", ";", "fprintf", "(", "asm_out_file", ",", "\" \\tbrasl\\t%%r%d,\"", ",", "return_addr_regno", ")", ";", "}", "else", "{", "fputs", "(", "\" \\tjg\"", ",", "asm_out_file", ")", ";", "if", "(", "comparison_operator", "!=", "NULL_RTX", ")", "print_operand", "(", "asm_out_file", ",", "comparison_operator", ",", "'C'", ")", ";", "fputs", "(", "\"\\t\"", ",", "asm_out_file", ")", ";", "}", "if", "(", "TARGET_CPU_Z10", ")", "fprintf", "(", "asm_out_file", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EXRL", "\"\\n\"", ",", "regno", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EX", "\"\\n\"", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ",", "regno", ")", ";", "if", "(", "(", "option", "==", "s390_opt_indirect_branch_jump", "&&", "cfun", "->", "machine", "->", "indirect_branch_jump", "==", "indirect_branch_thunk", ")", "||", "(", "option", "==", "s390_opt_indirect_branch_call", "&&", "cfun", "->", "machine", "->", "indirect_branch_call", "==", "indirect_branch_thunk", ")", "||", "(", "option", "==", "s390_opt_function_return_reg", "&&", "cfun", "->", "machine", "->", "function_return_reg", "==", "indirect_branch_thunk", ")", "||", "(", "option", "==", "s390_opt_function_return_mem", "&&", "cfun", "->", "machine", "->", "function_return_mem", "==", "indirect_branch_thunk", ")", ")", "{", "if", "(", "TARGET_CPU_Z10", ")", "indirect_branch_z10thunk_mask", "|=", "(", "1", "<<", "regno", ")", ";", "else", "indirect_branch_prez10thunk_mask", "|=", "(", "1", "<<", "regno", ")", ";", "}", "}", "</s>" ]

[ "Output", "either", "an", "indirect", "jump", "or", "a", "an", "indirect", "call", "(", "RETURN_ADDR_REGNO", "!", "=", "INVALID_REGNUM", ")", "with", "target", "register", "REGNO", "using", "a", "branch", "trampoline", "disabling", "branch", "target", "prediction", "." ]

[ "s390", "32", "\" \\tbrasl\\t%%r%d,\"", "\" \\tjg\"", "\"\\t\"", "\"\\n\"", "\"\\n\"", "1", "1" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">>", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", "&&", "IsCallReloc", ")", "{", "unsigned", "GPReg", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "ABI", ".", "IsN64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "auto", "&", "R", ":", "RegsToPass", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "R", ".", "first", ",", "R", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "auto", "&", "R", ":", "RegsToPass", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "R", ".", "first", ",", "R", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "DAG", ".", "getMachineFunction", "(", ")", ",", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "1", "\"Missing call preserved mask for calling convention\"", "Mips", "\"__Mips16RetHelper\"", "Mips", "Mips" ]

[]

[ "<s>", "void", "print_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "int", "letter", ")", "{", "switch", "(", "letter", ")", "{", "case", "'#'", ":", "if", "(", "final_sequence", ")", "visium_indent_opcode", "=", "1", ";", "else", "fputs", "(", "\"\\n\\t nop\"", ",", "file", ")", ";", "return", ";", "case", "'b'", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "UINTVAL", "(", "op", ")", "&", "0xff", ")", ";", "return", ";", "case", "'w'", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "UINTVAL", "(", "op", ")", "&", "0xffff", ")", ";", "return", ";", "case", "'u'", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "(", "UINTVAL", "(", "op", ")", ">>", "16", ")", "&", "0xffff", ")", ";", "return", ";", "case", "'r'", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "]", ",", "file", ")", ";", "else", "fputs", "(", "reg_names", "[", "0", "]", ",", "file", ")", ";", "return", ";", "case", "'f'", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "]", ",", "file", ")", ";", "else", "fputs", "(", "reg_names", "[", "FP_FIRST_REGNUM", "]", ",", "file", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "if", "(", "letter", "==", "'d'", ")", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "+", "1", "]", ",", "file", ")", ";", "else", "fputs", "(", "reg_names", "[", "REGNO", "(", "op", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "break", ";", "case", "MEM", ":", "visium_output_address", "(", "file", ",", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "break", ";", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "op", ")", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "asm_fprintf", "(", "file", ",", "\"%LL%d\"", ",", "CODE_LABEL_NUMBER", "(", "op", ")", ")", ";", "break", ";", "case", "HIGH", ":", "print_operand", "(", "file", ",", "XEXP", "(", "op", ",", "1", ")", ",", "letter", ")", ";", "break", ";", "default", ":", "fatal_insn", "(", "\"illegal operand \"", ",", "op", ")", ";", "}", "}", "</s>" ]

[ "Use", "S", "for", "SI", "regsUse", "B", "&", "T", "for", "parts", "of", "DI", "regs", "X", "-", "stack", "pointer", "name", "Registers", "Q", "-", "byte", "sized", "register", "name", "U", "-", "high", "byte", "of", "word", "register", "V", "-", "low", "byte", "of", "word", "register", "H", "-", "word", "register", "name", "I", "-", "next", "word", "register", "name", "S", "&", "B", "-", "long", "register", "name", "T", "-", "next", "long", "register", "name", "D", "-", "quad", "register", "name", "P", "-", "register", "name", "in", "size", "of", "pointer", "Integers", "O", "-", "log", "two", "of", "value", "P", "-", "inverted", "log", "two", "H", "-", "bottom", "16", "bits", "I", "-", "top", "16", "bits", "N", "-", "negative", "B", "-", "high", "32", "bits", "of", "32bit", "number", ".", "default", ":", "value", "Memory", "I", "-", "adjusted", "upwards", "by", "two", "T", "-", "adjusted", "upwards", "by", "four", "default", ":", "value", "Address", "H", "-", "low", "16", "bits", "I", "-", "high", "16", "bits", "A", "-", "as", "long", "constant", "S", "-", "as", "A", "but", "with", "#", "default", ":", "error", "Misc", "C", "-", "conditional", "name", "D", "-", "reverse", "conditional", "name", "F", "-", "clear", "v", "flag", "if", "necessary" ]

[ "visium", "1", "\"\\n\\t nop\"", "0xff", "0xffff", "16", "0xffff", "0", "1", "0", "\"%LL%d\"", "1", "\"illegal operand \"" ]

[]

[ "<s>", "const", "rvexInstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex" ]

[]

[ "<s>", "static", "bool", "vsetvl_insn_p", "(", "rtx_insn", "*", "rinsn", ")", "{", "if", "(", "!", "vector_config_insn_p", "(", "rinsn", ")", ")", "return", "false", ";", "return", "(", "INSN_CODE", "(", "rinsn", ")", "==", "CODE_FOR_vsetvldi", "||", "INSN_CODE", "(", "rinsn", ")", "==", "CODE_FOR_vsetvlsi", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "vsetvldi", "or", "vsetvlsi", "." ]

[ "riscv" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "if", "(", "Kind", "==", "1", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "&", "PPC", "::", "G8RC_NOX0RegClass", ";", "return", "&", "PPC", "::", "GPRC_NOR0RegClass", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "&", "PPC", "::", "G8RCRegClass", ";", "return", "&", "PPC", "::", "GPRCRegClass", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "PPC", "PPC::G8RC_NOX0RegClass", "PPC::GPRC_NOR0RegClass", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", "1", ",", "true", ",", "true", ",", "false", ",", "true", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableLoopDataPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableFalkorHWPFFix", ")", "addPass", "(", "createFalkorMarkStridedAccessesPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInterleavedLoadCombinePass", "(", ")", ")", ";", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "addPass", "(", "createAArch64StackTaggingPass", "(", ")", ")", ";", "if", "(", "PACStack", "::", "doAArch64IRPass", "(", ")", ")", "addPass", "(", "PACStack", "::", "createPACStackOptCallPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "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", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "RISCV", "RISCV" ]

[]

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

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

[ "R600", "SI" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateUniformValues", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "MSSA", "=", "&", "getAnalysis", "<", "MemorySSAWrapperPass", ">", "(", ")", ".", "getMSSA", "(", ")", ";", "isEntryFunc", "=", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "visit", "(", "F", ")", ";", "noClobberClones", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::isEntryFunctionCC" ]

[]