Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "MipsPreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "MipsPreLegalizerCombinerInfo", "PCInfo", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isWhileOpcode", "(", "unsigned", "Opc", ")", "const", "{", "return", "get", "(", "Opc", ")", ".", "TSFlags", "&", "AArch64", "::", "InstrFlagIsWhile", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "opcode", "is", "for", "an", "SVE", "WHILE", "#", "#", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::InstrFlagIsWhile" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "IA64AsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "O", "<<", "\"\\n.ident \\\"LLVM-ia64\\\"\\n\\n\"", "<<", "\"\\t.psr lsb\\n\"", "<<", "\"\\t.radix C\\n\"", "<<", "\"\\t.psr abi64\\n\"", ";", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "IA64", "IA64", "\"\\n.ident \\\"LLVM-ia64\\\"\\n\\n\"", "\"\\t.psr lsb\\n\"", "\"\\t.radix C\\n\"", "\"\\t.psr abi64\\n\"" ]

[]

[ "<s>", "static", "rtx", "alpha_lookup_xfloating_lib_func", "(", "enum", "rtx_code", "code", ")", "{", "struct", "xfloating_op", "*", "ops", "=", "xfloating_ops", ";", "long", "n", "=", "ARRAY_SIZE", "(", "xfloating_ops", ")", ";", "long", "i", ";", "gcc_assert", "(", "TARGET_HAS_XFLOATING_LIBS", ")", ";", "if", "(", "TARGET_FLOAT_VAX", "&&", "(", "code", "==", "FLOAT_EXTEND", "||", "code", "==", "FLOAT_TRUNCATE", ")", ")", "{", "ops", "=", "vax_cvt_ops", ";", "n", "=", "ARRAY_SIZE", "(", "vax_cvt_ops", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "++", "i", ",", "++", "ops", ")", "if", "(", "ops", "->", "code", "==", "code", ")", "{", "rtx", "func", "=", "ops", "->", "libcall", ";", "if", "(", "!", "func", ")", "{", "func", "=", "init_one_libfunc", "(", "TARGET_ABI_OPEN_VMS", "?", "ops", "->", "vms_func", ":", "ops", "->", "osf_func", ")", ";", "ops", "->", "libcall", "=", "func", ";", "}", "return", "func", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Look", "up", "the", "function", "X_floating", "library", "function", "name", "for", "the", "given", "operation", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "static", "bool", "bpf_frame_pointer_required", "(", "void", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "function", "must", "have", "and", "use", "a", "frame", "pointer", "." ]

[ "bpf" ]

[]

[ "<s>", "SDNode", "*", "X86DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "auto", "&", "DL", "=", "MF", "->", "getDataLayout", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "legitimate_reload_constant_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "DISP_IN_RANGE", "(", "INTVAL", "(", "op", ")", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "CONST_OK_FOR_K", "(", "INTVAL", "(", "op", ")", ")", "||", "CONST_OK_FOR_Os", "(", "INTVAL", "(", "op", ")", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_ZARCH", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "==", "INTVAL", "(", "op", ")", "&&", "s390_single_part", "(", "op", ",", "word_mode", ",", "HImode", ",", "0", ")", ">=", "0", ")", "return", "true", ";", "if", "(", "TARGET_EXTIMM", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "==", "INTVAL", "(", "op", ")", "&&", "s390_single_part", "(", "op", ",", "word_mode", ",", "SImode", ",", "0", ")", ">=", "0", ")", "return", "true", ";", "if", "(", "TARGET_CPU_ZARCH", "&&", "larl_operand", "(", "op", ",", "VOIDmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "s390_float_const_zero_p", "(", "op", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", "<=", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_WIDE_INT", "||", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "trunc_int_for_mode", "(", "INTVAL", "(", "op", ")", ",", "word_mode", ")", "!=", "INTVAL", "(", "op", ")", ")", ")", "{", "machine_mode", "dword_mode", "=", "word_mode", "==", "SImode", "?", "DImode", ":", "TImode", ";", "rtx", "hi", "=", "operand_subword", "(", "op", ",", "0", ",", "0", ",", "dword_mode", ")", ";", "rtx", "lo", "=", "operand_subword", "(", "op", ",", "1", ",", "0", ",", "dword_mode", ")", ";", "return", "legitimate_reload_constant_p", "(", "hi", ")", "&&", "legitimate_reload_constant_p", "(", "lo", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "constant", "value", "OP", "is", "a", "legitimate", "general", "operand", "during", "and", "after", "reload", ".", "The", "difference", "to", "legitimate_constant_p", "is", "that", "this", "function", "will", "not", "accept", "a", "constant", "that", "would", "need", "to", "be", "forced", "to", "the", "literal", "pool", "before", "it", "can", "be", "used", "as", "operand", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_do_expand_vec_perm", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "vmode", ",", "const", "vec_perm_builder", "&", "perm", ")", "{", "rtx", "x", "=", "expand_vec_perm_const", "(", "vmode", ",", "op0", ",", "op1", ",", "perm", ",", "BLKmode", ",", "target", ")", ";", "if", "(", "x", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "x", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "for", "rs6000_expand_extract_even", "&", "rs6000_expand_interleave", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "write_init_bif_table", "(", "void", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "curr_bif", ";", "i", "++", ")", "{", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_info[RS6000_BIF_%s].fntype\"", "\"\\n = %s;\\n\"", ",", "bifs", "[", "i", "]", ".", "idname", ",", "bifs", "[", "i", "]", ".", "fndecl", ")", ";", "int", "tf_found", "=", "strstr", "(", "bifs", "[", "i", "]", ".", "fndecl", ",", "\"tf\"", ")", "!=", "NULL", ";", "int", "dfp_found", "=", "(", "strstr", "(", "bifs", "[", "i", "]", ".", "fndecl", ",", "\"sd\"", ")", "!=", "NULL", "||", "strstr", "(", "bifs", "[", "i", "]", ".", "fndecl", ",", "\"dd\"", ")", "!=", "NULL", "||", "strstr", "(", "bifs", "[", "i", "]", ".", "fndecl", ",", "\"td\"", ")", "!=", "NULL", ")", ";", "if", "(", "tf_found", ")", "{", "fprintf", "(", "init_file", ",", "\" if (float128_type_node)\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "}", "else", "if", "(", "dfp_found", ")", "{", "fprintf", "(", "init_file", ",", "\" if (dfloat64_type_node)\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "}", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_decls[(int)RS6000_BIF_%s] = t\\n\"", ",", "bifs", "[", "i", "]", ".", "idname", ")", ";", "fprintf", "(", "init_file", ",", "\" = add_builtin_function (\\\"%s\\\",\\n\"", ",", "bifs", "[", "i", "]", ".", "proto", ".", "bifname", ")", ";", "fprintf", "(", "init_file", ",", "\" %s,\\n\"", ",", "bifs", "[", "i", "]", ".", "fndecl", ")", ";", "fprintf", "(", "init_file", ",", "\" (int)RS6000_BIF_%s,\"", "\" BUILT_IN_MD,\\n\"", ",", "bifs", "[", "i", "]", ".", "idname", ")", ";", "fprintf", "(", "init_file", ",", "\" NULL, NULL_TREE);\\n\"", ")", ";", "if", "(", "bifs", "[", "i", "]", ".", "kind", "==", "FNK_CONST", ")", "{", "fprintf", "(", "init_file", ",", "\" TREE_READONLY (t) = 1;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" TREE_NOTHROW (t) = 1;\\n\"", ")", ";", "}", "else", "if", "(", "bifs", "[", "i", "]", ".", "kind", "==", "FNK_PURE", ")", "{", "fprintf", "(", "init_file", ",", "\" DECL_PURE_P (t) = 1;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" TREE_NOTHROW (t) = 1;\\n\"", ")", ";", "}", "else", "if", "(", "bifs", "[", "i", "]", ".", "kind", "==", "FNK_FPMATH", ")", "{", "fprintf", "(", "init_file", ",", "\" TREE_NOTHROW (t) = 1;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" if (flag_rounding_math)\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" DECL_PURE_P (t) = 1;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" DECL_IS_NOVOPS (t) = 1;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" }\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" else\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" TREE_READONLY (t) = 1;\\n\"", ")", ";", "}", "if", "(", "tf_found", "||", "dfp_found", ")", "{", "fprintf", "(", "init_file", ",", "\" }\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" else\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" {\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_decls\"", "\"[(int)RS6000_BIF_%s] = NULL_TREE;\\n\"", ",", "bifs", "[", "i", "]", ".", "idname", ")", ";", "fprintf", "(", "init_file", ",", "\" }\\n\"", ")", ";", "}", "fprintf", "(", "init_file", ",", "\"\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Write", "code", "to", "initialize", "the", "built-in", "function", "table", "." ]

[ "rs6000", "0", "\" rs6000_builtin_info[RS6000_BIF_%s].fntype\"", "\"\\n = %s;\\n\"", "\"tf\"", "\"sd\"", "\"dd\"", "\"td\"", "\" if (float128_type_node)\\n\"", "\" {\\n\"", "\" if (dfloat64_type_node)\\n\"", "\" {\\n\"", "\" rs6000_builtin_decls[(int)RS6000_BIF_%s] = t\\n\"", "\" = add_builtin_function (\\\"%s\\\",\\n\"", "\" %s,\\n\"", "\" (int)RS6000_BIF_%s,\"", "\" BUILT_IN_MD,\\n\"", "\" NULL, NULL_TREE);\\n\"", "\" TREE_READONLY (t) = 1;\\n\"", "\" TREE_NOTHROW (t) = 1;\\n\"", "\" DECL_PURE_P (t) = 1;\\n\"", "\" TREE_NOTHROW (t) = 1;\\n\"", "\" TREE_NOTHROW (t) = 1;\\n\"", "\" if (flag_rounding_math)\\n\"", "\" {\\n\"", "\" DECL_PURE_P (t) = 1;\\n\"", "\" DECL_IS_NOVOPS (t) = 1;\\n\"", "\" }\\n\"", "\" else\\n\"", "\" TREE_READONLY (t) = 1;\\n\"", "\" }\\n\"", "\" else\\n\"", "\" {\\n\"", "\" rs6000_builtin_decls\"", "\"[(int)RS6000_BIF_%s] = NULL_TREE;\\n\"", "\" }\\n\"", "\"\\n\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "SCS", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "ShadowCallStack", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "SCS", "?", "CSR_AArch64_NoRegs_SCS_RegMask", ":", "CSR_AArch64_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "SCS", "?", "CSR_AArch64_AllRegs_SCS_RegMask", ":", "CSR_AArch64_AllRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "SCS", "?", "CSR_AArch64_CXX_TLS_Darwin_SCS_RegMask", ":", "CSR_AArch64_CXX_TLS_Darwin_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "SCS", "?", "CSR_AArch64_AAPCS_SwiftError_SCS_RegMask", ":", "CSR_AArch64_AAPCS_SwiftError_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "PreserveMost", ")", "return", "SCS", "?", "CSR_AArch64_RT_MostRegs_SCS_RegMask", ":", "CSR_AArch64_RT_MostRegs_RegMask", ";", "else", "return", "SCS", "?", "CSR_AArch64_AAPCS_SCS_RegMask", ":", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

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

[]

[ "<s>", "void", "setFunction", "(", "Function", "&", "Func", ")", "{", "F", "=", "&", "Func", ";", "}", "</s>" ]

[ "Initialize", "data", "structures", "for", "specified", "new", "function", "." ]

[ "JVM" ]

[]

[ "<s>", "void", "alpha_split_atomic_exchange", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "retval", ",", "mem", ",", "val", ",", "scratch", ";", "enum", "memmodel", "model", ";", "machine_mode", "mode", ";", "rtx", "label", ",", "x", ",", "cond", ";", "retval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "scratch", "=", "operands", "[", "4", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "alpha_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "emit_move_insn", "(", "scratch", ",", "val", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "alpha_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "exchange", "operation", "." ]

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

[]

[ "<s>", "void", "loongarch_expand_prologue", "(", "void", ")", "{", "struct", "loongarch_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "HOST_WIDE_INT", "size", "=", "frame", "->", "total_size", ";", "HOST_WIDE_INT", "tmp", ";", "rtx", "insn", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "||", "flag_stack_clash_protection", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "size", ">", "PROBE_INTERVAL", "&&", "size", ">", "get_stack_check_protect", "(", ")", ")", "{", "tmp", "=", "size", "-", "get_stack_check_protect", "(", ")", ";", "loongarch_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "tmp", ")", ";", "}", "}", "else", "if", "(", "size", ">", "0", ")", "loongarch_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "size", ")", ";", "}", "if", "(", "(", "frame", "->", "mask", "|", "frame", "->", "fmask", ")", "!=", "0", ")", "{", "HOST_WIDE_INT", "step1", "=", "MIN", "(", "size", ",", "loongarch_first_stack_step", "(", "frame", ")", ")", ";", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "step1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "size", "-=", "step1", ";", "loongarch_for_each_saved_reg", "(", "size", ",", "loongarch_save_reg", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "gen_add3_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "frame", "->", "hard_frame_pointer_offset", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "loongarch_emit_stack_tie", "(", ")", ";", "}", "if", "(", "size", ">", "0", ")", "{", "if", "(", "IMM12_OPERAND", "(", "-", "size", ")", ")", "{", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "}", "else", "{", "loongarch_emit_move", "(", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ")", ")", ";", "insn", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "size", ")", ";", "insn", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "insn", ")", ";", "loongarch_set_frame_expr", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "the", "``", "prologue", "''", "pattern", "." ]

[ "loongarch", "0", "0", "1", "1", "0", "1" ]

[]

[ "<s>", "void", "RISCVDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "doPeepholeLoadStoreADDI", "(", ")", ";", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "MachineBasicBlock", "*", "HexagonTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "ALLOCA", ":", "{", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "auto", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "addAllocaAdjustInst", "(", "MI", ")", ";", "return", "BB", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::ALLOCA", "Hexagon", "\"Unexpected instr type to insert\"" ]

[]

[ "<s>", "void", "VERegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "VEFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Register", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ".", "getFixed", "(", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "STQrii", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "Register", "SrcHiReg", "=", "getSubReg", "(", "SrcReg", ",", "VE", "::", "sub_even", ")", ";", "Register", "SrcLoReg", "=", "getSubReg", "(", "SrcReg", ",", "VE", "::", "sub_odd", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "VE", "::", "STrii", ")", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcLoReg", ")", ";", "replaceFI", "(", "MF", ",", "II", ",", "*", "StMI", ",", "dl", ",", "0", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "VE", "::", "STrii", ")", ")", ";", "MI", ".", "getOperand", "(", "3", ")", ".", "setReg", "(", "SrcHiReg", ")", ";", "Offset", "+=", "8", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDQrii", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "DestHiReg", "=", "getSubReg", "(", "DestReg", ",", "VE", "::", "sub_even", ")", ";", "Register", "DestLoReg", "=", "getSubReg", "(", "DestReg", ",", "VE", "::", "sub_odd", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "VE", "::", "LDrii", ")", ",", "DestLoReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "replaceFI", "(", "MF", ",", "II", ",", "*", "StMI", ",", "dl", ",", "1", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "VE", "::", "LDrii", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestHiReg", ")", ";", "Offset", "+=", "8", ";", "}", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "\"Unexpected\"", "VE", "2", "VE::STQrii", "3", "VE::sub_even", "VE::sub_odd", "VE::STrii", "0", "0", "0", "VE::STrii", "3", "8", "VE::LDQrii", "0", "VE::sub_even", "VE::sub_odd", "VE::LDrii", "0", "0", "1", "VE::LDrii", "0", "8" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "!", "CurrCycleInstr", ")", "return", ";", "unsigned", "NumWaitStates", "=", "TII", ".", "getNumWaitStates", "(", "*", "CurrCycleInstr", ")", ";", "EmittedInstrs", ".", "push_front", "(", "CurrCycleInstr", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "std", "::", "min", "(", "NumWaitStates", ",", "getMaxLookAhead", "(", ")", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "EmittedInstrs", ".", "resize", "(", "getMaxLookAhead", "(", ")", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "unsigned", "SICFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "return", "GlobalBaseReg", "=", "SIC", "::", "B", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC::B" ]

[]

[ "<s>", "machine_mode", "loongarch_hard_regno_caller_save_mode", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "nregs", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "choose_hard_reg_mode", "(", "regno", ",", "nregs", ",", "NULL", ")", ";", "else", "return", "mode", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_CALLER_SAVE_MODE", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "int", "ia64_sched_reorder", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "pn_ready", ",", "int", "clock_var", ")", "{", "return", "ia64_dfa_sched_reorder", "(", "dump", ",", "sched_verbose", ",", "ready", ",", "pn_ready", ",", "clock_var", ",", "0", ")", ";", "}", "</s>" ]

[ "We", "are", "about", "to", "being", "issuing", "insns", "for", "this", "clock", "cycle", ".", "Override", "the", "default", "sort", "algorithm", "to", "better", "slot", "instructions", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "bool", "SystemZFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", "->", "getManipulatesSP", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "FISC" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Mips", "::", "NOP", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "Mips", "Mips", "Mips::NOP" ]

[]

[ "<s>", "bool", "PTXInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "int", "i", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "return", "i", "!=", "-", "1", "&&", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", "!=", "PTX", "::", "NoRegister", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "PTX", "PTX", "1", "PTX::NoRegister" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "*", "DL", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "Triple", "(", "TM", ".", "getTargetTriple", "(", ")", ")", ".", "isOSDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", "->", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mang", "->", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "GetOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_NLP_HIDDEN_FLAG", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getAddrModeArguments", "(", "IntrinsicInst", "*", "II", ",", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Ops", ",", "Type", "*", "&", "AccessTy", ")", "const", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_append", ":", "case", "Intrinsic", "::", "amdgcn_ds_consume", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "case", "Intrinsic", "::", "amdgcn_global_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_global_atomic_csub", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "0", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "CodeGenPrepare", "sinks", "address", "calculations", "into", "the", "same", "BB", "as", "Load/Store", "instructions", "reading", "the", "address", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_ordered_add", "Intrinsic::amdgcn_ds_ordered_swap", "Intrinsic::amdgcn_ds_append", "Intrinsic::amdgcn_ds_consume", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "Intrinsic::amdgcn_global_atomic_fadd", "Intrinsic::amdgcn_global_atomic_csub", "0" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_machine_reorg2", "(", "void", ")", "{", "mips_reorg_process_insns", "(", ")", ";", "if", "(", "!", "TARGET_MIPS16", "&&", "TARGET_EXPLICIT_RELOCS", "&&", "TUNE_MIPS4130", "&&", "TARGET_VR4130_ALIGN", ")", "vr4130_align_insns", "(", ")", ";", "if", "(", "mips_expand_ghost_gp_insns", "(", ")", ")", "mips_reorg_process_insns", "(", ")", ";", "mips16_split_long_branches", "(", ")", ";", "mips_insert_insn_pseudos", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "We", "use", "a", "machine", "specific", "pass", "to", "do", "a", "second", "machine", "dependent", "reorg", "pass", "after", "delay", "branch", "scheduling", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "bool", "arc_use_by_pieces_infrastructure_p", "(", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ",", "enum", "by_pieces_operation", "op", ",", "bool", "speed_p", ")", "{", "if", "(", "op", "==", "MOVE_BY_PIECES", ")", "return", "false", ";", "return", "default_use_by_pieces_infrastructure_p", "(", "size", ",", "align", ",", "op", ",", "speed_p", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_BY_PIECES_INFRASTRUCTURE_P", "." ]

[ "arc" ]

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_symbol", "(", "rtx", "x", ",", "rtx", "offset", ",", "enum", "aarch64_symbol_context", "context", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_LARGE", ":", "return", "SYMBOL_FORCE_TO_MEM", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_TINY", ":", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL", ":", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_LARGE", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "if", "(", "aarch64_tls_symbol_p", "(", "x", ")", ")", "return", "aarch64_classify_tls_symbol", "(", "x", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "||", "INTVAL", "(", "offset", ")", "<", "-", "1048575", "||", "INTVAL", "(", "offset", ")", ">", "1048575", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "offset", ")", ",", "HOST_WIDE_INT_C", "(", "-", "4294967263", ")", ",", "HOST_WIDE_INT_C", "(", "4294967264", ")", ")", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_TINY_GOT", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_SMALL_GOT", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "SYMBOL_FORCE_TO_MEM", ";", "}", "</s>" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ "aarch64", "1048575", "1048575", "4294967263", "4294967264" ]

[]

[ "<s>", "bool", "Mips16HardFloat", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Run on Module Mips16HardFloat\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "Module", "::", "iterator", "F", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "F", "!=", "E", ";", "++", "F", ")", "{", "if", "(", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", "&&", "F", "->", "hasFnAttribute", "(", "\"use-soft-float\"", ")", ")", "{", "removeUseSoftFloat", "(", "*", "F", ")", ";", "continue", ";", "}", "if", "(", "F", "->", "isDeclaration", "(", ")", "||", "F", "->", "hasFnAttribute", "(", "\"mips16_fp_stub\"", ")", "||", "F", "->", "hasFnAttribute", "(", "\"nomips16\"", ")", ")", "continue", ";", "Modified", "|=", "fixupFPReturnAndCall", "(", "*", "F", ",", "&", "M", ",", "Subtarget", ")", ";", "FPParamVariant", "V", "=", "whichFPParamVariantNeeded", "(", "*", "F", ")", ";", "if", "(", "V", "!=", "NoSig", ")", "{", "Modified", "=", "true", ";", "createFPFnStub", "(", "F", ",", "&", "M", ",", "V", ",", "Subtarget", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"Run on Module Mips16HardFloat\\n\"", "\"nomips16\"", "\"use-soft-float\"", "\"mips16_fp_stub\"", "\"nomips16\"" ]

[]

[ "<s>", "void", "ia64_output_function_profiler", "(", "FILE", "*", "file", ",", "int", "labelno", ")", "{", "bool", "indirect_call", ";", "if", "(", "cfun", "->", "static_chain_decl", "&&", "!", "TARGET_NO_PIC", "&&", "!", "TARGET_AUTO_PIC", ")", "{", "gcc_assert", "(", "STATIC_CHAIN_REGNUM", "==", "15", ")", ";", "indirect_call", "=", "true", ";", "}", "else", "indirect_call", "=", "false", ";", "if", "(", "TARGET_GNU_AS", ")", "fputs", "(", "\"\\t.prologue 4, r40\\n\"", ",", "file", ")", ";", "else", "fputs", "(", "\"\\t.prologue\\n\\t.save ar.pfs, r40\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\talloc out0 = ar.pfs, 8, 0, 4, 0\\n\"", ",", "file", ")", ";", "if", "(", "NO_PROFILE_COUNTERS", ")", "fputs", "(", "\"\\tmov out3 = r0\\n\"", ",", "file", ")", ";", "else", "{", "char", "buf", "[", "20", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LP\"", ",", "labelno", ")", ";", "if", "(", "TARGET_AUTO_PIC", ")", "fputs", "(", "\"\\tmovl out3 = @gprel(\"", ",", "file", ")", ";", "else", "fputs", "(", "\"\\taddl out3 = @ltoff(\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "if", "(", "TARGET_AUTO_PIC", ")", "fputs", "(", "\")\\n\"", ",", "file", ")", ";", "else", "fputs", "(", "\"), r1\\n\"", ",", "file", ")", ";", "}", "if", "(", "indirect_call", ")", "fputs", "(", "\"\\taddl r14 = @ltoff(@fptr(_mcount)), r1\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t;;\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.save rp, r42\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\tmov out2 = b0\\n\"", ",", "file", ")", ";", "if", "(", "indirect_call", ")", "fputs", "(", "\"\\tld8 r14 = [r14]\\n\\t;;\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.body\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\tmov out1 = r1\\n\"", ",", "file", ")", ";", "if", "(", "indirect_call", ")", "{", "fputs", "(", "\"\\tld8 r16 = [r14], 8\\n\\t;;\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\tmov b6 = r16\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\tld8 r1 = [r14]\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\tbr.call.sptk.many b0 = b6\\n\\t;;\\n\"", ",", "file", ")", ";", "}", "else", "fputs", "(", "\"\\tbr.call.sptk.many b0 = _mcount\\n\\t;;\\n\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Implement", "the", "FUNCTION_PROFILER", "macro", "." ]

[ "ia64", "15", "\"\\t.prologue 4, r40\\n\"", "\"\\t.prologue\\n\\t.save ar.pfs, r40\\n\"", "\"\\talloc out0 = ar.pfs, 8, 0, 4, 0\\n\"", "\"\\tmov out3 = r0\\n\"", "20", "\"LP\"", "\"\\tmovl out3 = @gprel(\"", "\"\\taddl out3 = @ltoff(\"", "\")\\n\"", "\"), r1\\n\"", "\"\\taddl r14 = @ltoff(@fptr(_mcount)), r1\\n\"", "\"\\t;;\\n\"", "\"\\t.save rp, r42\\n\"", "\"\\tmov out2 = b0\\n\"", "\"\\tld8 r14 = [r14]\\n\\t;;\\n\"", "\"\\t.body\\n\"", "\"\\tmov out1 = r1\\n\"", "\"\\tld8 r16 = [r14], 8\\n\\t;;\\n\"", "\"\\tmov b6 = r16\\n\"", "\"\\tld8 r1 = [r14]\\n\"", "\"\\tbr.call.sptk.many b0 = b6\\n\\t;;\\n\"", "\"\\tbr.call.sptk.many b0 = _mcount\\n\\t;;\\n\"" ]

[]

[ "<s>", "const", "NVPTXGenericMCSymbolRefExpr", "*", "NVPTXGenericMCSymbolRefExpr", "::", "create", "(", "const", "MCSymbolRefExpr", "*", "SymExpr", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "NVPTXGenericMCSymbolRefExpr", "(", "SymExpr", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "push_back", "(", "T", "V", ")", "{", "if", "(", "Set", ".", "count", "(", "V", ")", ")", "return", ";", "Queue", ".", "push", "(", "V", ")", ";", "Set", ".", "insert", "(", "V", ")", ";", "}", "</s>" ]

[ "Insert", "a", "node", "at", "the", "back", ";", "never", "copies", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "loongarch_signed_immediate_p", "(", "unsigned", "HOST_WIDE_INT", "x", ",", "int", "bits", ",", "int", "shift", "=", "0", ")", "{", "x", "+=", "1", "<<", "(", "bits", "+", "shift", "-", "1", ")", ";", "return", "loongarch_unsigned_immediate_p", "(", "x", ",", "bits", ",", "shift", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "fits", "within", "a", "signed", "field", "of", "BITS", "bits", "that", "is", "shifted", "left", "SHIFT", "bits", "before", "being", "used", "." ]

[ "loongarch", "0", "1", "1" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "&", "Flags", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "that", "returns", "true", "if", "MBB", "is", "safe", "to", "outline", "from", ",", "and", "returns", "any", "target-specific", "information", "in", "Flags", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "BPFInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "BPF", "::", "JMP", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "BPF", "BPF", "BPF::JMP", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "TBB", ")", "return", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a successor block\"", ")", ";", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_UNLESS", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"code size not handled\"", "0", "WebAssembly::BR", "1", "2", "\"Expected a flag and a successor block\"", "0", "WebAssembly::BR_IF", "1", "WebAssembly::BR_UNLESS", "1", "1", "WebAssembly::BR", "2" ]

[]

[ "<s>", "bool", "aarch64_prepare_sve_int_fma", "(", "rtx", "*", "operands", ",", "rtx_code", "code", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "rtx", "shifts", "=", "aarch64_convert_mult_to_shift", "(", "operands", "[", "2", "]", ",", "code", ")", ")", "{", "rtx", "product", "=", "expand_binop", "(", "mode", ",", "vashl_optab", ",", "operands", "[", "1", "]", ",", "shifts", ",", "NULL_RTX", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "force_expand_binop", "(", "mode", ",", "code", "==", "PLUS", "?", "add_optab", ":", "sub_optab", ",", "operands", "[", "3", "]", ",", "product", ",", "operands", "[", "0", "]", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "return", "true", ";", "}", "operands", "[", "2", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "2", "]", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Prepare", "for", "an", "integer", "SVE", "multiply-add", "or", "multiply-subtract", "pattern", ";", "CODE", "is", "PLUS", "for", "the", "former", "and", "MINUS", "for", "the", "latter", ".", "OPERANDS", "is", "the", "operands", "array", ",", "in", "the", "same", "order", "as", "for", "fma_optab", ".", "Return", "true", "if", "the", "function", "emitted", "all", "the", "necessary", "instructions", ",", "false", "if", "the", "caller", "should", "generate", "the", "pattern", "normally", "with", "the", "new", "OPERANDS", "array", "." ]

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

[]

[ "<s>", "BitVector", "MipsRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "uint16_t", "ReservedCPURegs", "[", "]", "=", "{", "Mips", "::", "ZERO", ",", "Mips", "::", "K0", ",", "Mips", "::", "K1", ",", "Mips", "::", "SP", "}", ";", "static", "const", "uint16_t", "ReservedCPU64Regs", "[", "]", "=", "{", "Mips", "::", "ZERO_64", ",", "Mips", "::", "K0_64", ",", "Mips", "::", "K1_64", ",", "Mips", "::", "SP_64", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "typedef", "TargetRegisterClass", "::", "const_iterator", "RegIter", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPU64Regs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPU64Regs", "[", "I", "]", ")", ";", "if", "(", "Subtarget", ".", "hasMips64", "(", ")", ")", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "AFGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "AFGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "else", "{", "for", "(", "RegIter", "Reg", "=", "Mips", "::", "FGR64RegClass", ".", "begin", "(", ")", ",", "EReg", "=", "Mips", "::", "FGR64RegClass", ".", "end", "(", ")", ";", "Reg", "!=", "EReg", ";", "++", "Reg", ")", "Reserved", ".", "set", "(", "*", "Reg", ")", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "Reserved", ".", "set", "(", "Mips", "::", "S0", ")", ";", "else", "{", "Reserved", ".", "set", "(", "Mips", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "FP_64", ")", ";", "}", "}", "Reserved", ".", "set", "(", "Mips", "::", "HWR29", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "HWR29_64", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPPos", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPSCount", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPCarry", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPEFI", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "DSPOutFlag", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "RA_64", ")", ";", "}", "if", "(", "Subtarget", ".", "useSmallSection", "(", ")", ")", "{", "Reserved", ".", "set", "(", "Mips", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Mips", "::", "GP_64", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::ZERO", "Mips::K0", "Mips::K1", "Mips::SP", "Mips::ZERO_64", "Mips::K0_64", "Mips::K1_64", "Mips::SP_64", "0", "0", "Mips", "Mips::AFGR64RegClass", "Mips::AFGR64RegClass", "Mips::FGR64RegClass", "Mips::FGR64RegClass", "Mips", "Mips::S0", "Mips::FP", "Mips::FP_64", "Mips::HWR29", "Mips::HWR29_64", "Mips::DSPPos", "Mips::DSPSCount", "Mips::DSPCarry", "Mips::DSPEFI", "Mips::DSPOutFlag", "Mips", "Mips::RA", "Mips::RA_64", "Mips::GP", "Mips::GP_64" ]

[]

[ "<s>", "bool", "MOSPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "fixed_size_mode", "aarch64_get_reg_raw_mode", "(", "int", "regno", ")", "{", "if", "(", "TARGET_SVE", "&&", "FP_REGNUM_P", "(", "regno", ")", ")", "return", "as_a", "<", "fixed_size_mode", ">", "(", "V16QImode", ")", ";", "return", "default_get_reg_raw_mode", "(", "regno", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_GET_RAW_RESULT_MODE", "and", "TARGET_GET_RAW_ARG_MODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "uint64_t", "RawVectorOstream", "::", "current_pos", "(", ")", "const", "{", "return", "static_cast", "<", "uint64_t", ">", "(", "Position", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "position", "within", "the", "stream", ",", "not", "counting", "the", "bytes", "currently", "in", "the", "buffer", "." ]

[ "HSAIL" ]

[]

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

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

[ "Hexagon", "\"Invalid access!\"" ]

[]

[ "<s>", "void", "MBlazeTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getELFSection", "(", "\".sdata\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getELFSection", "(", "\".sbss\"", ",", "MCSectionELF", "::", "SHT_NOBITS", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "gen_df_reg", "(", "rtx", "reg", ",", "int", "low", ")", "{", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "(", "WORDS_BIG_ENDIAN", "==", "0", ")", "^", "(", "low", "!=", "0", ")", ")", "regno", "+=", "(", "TARGET_ARCH64", "&&", "SPARC_INT_REG_P", "(", "regno", ")", ")", "?", "1", ":", "2", ";", "return", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Generate", "a", "DFmode", "part", "of", "a", "hard", "TFmode", "register", ".", "REG", "is", "the", "TFmode", "hard", "register", ",", "LOW", "is", "1", "for", "the", "low", "64bit", "of", "the", "register", "and", "0", "otherwise", "." ]

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

[]

[ "<s>", "unsigned", "mmix_debugger_regno", "(", "unsigned", "regno", ")", "{", "regno", "=", "MMIX_OUTPUT_REGNO", "(", "regno", ")", ";", "return", "regno", ">=", "224", "?", "(", "regno", "-", "224", ")", ":", "(", "regno", "+", "48", ")", ";", "}", "</s>" ]

[ "DEBUGGER_REGNO", "." ]

[ "mmix", "224", "224", "48" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Restore callee saved registers: \"", "<<", "MBB", ".", "getParent", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "if", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Restore callee saved registers: \"", "\"\\n\"", "ARC::R14" ]

[]

[ "<s>", "void", "mips_expand_atomic_qihi", "(", "union", "mips_gen_fn_ptrs", "generator", ",", "rtx", "result", ",", "rtx", "mem", ",", "rtx", "oldval", ",", "rtx", "newval", ")", "{", "rtx", "orig_addr", ",", "memsi_addr", ",", "memsi", ",", "shift", ",", "shiftsi", ",", "unshifted_mask", ";", "rtx", "unshifted_mask_reg", ",", "mask", ",", "inverted_mask", ",", "si_op", ";", "rtx", "res", "=", "NULL", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "orig_addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "memsi_addr", "=", "mips_force_binary", "(", "Pmode", ",", "AND", ",", "orig_addr", ",", "force_reg", "(", "Pmode", ",", "GEN_INT", "(", "-", "4", ")", ")", ")", ";", "memsi", "=", "gen_rtx_MEM", "(", "SImode", ",", "memsi_addr", ")", ";", "set_mem_alias_set", "(", "memsi", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "MEM_VOLATILE_P", "(", "memsi", ")", "=", "MEM_VOLATILE_P", "(", "mem", ")", ";", "shift", "=", "mips_force_binary", "(", "Pmode", ",", "AND", ",", "orig_addr", ",", "GEN_INT", "(", "3", ")", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "mips_emit_binary", "(", "XOR", ",", "shift", ",", "shift", ",", "GEN_INT", "(", "mode", "==", "QImode", "?", "3", ":", "2", ")", ")", ";", "mips_emit_binary", "(", "ASHIFT", ",", "shift", ",", "shift", ",", "GEN_INT", "(", "3", ")", ")", ";", "shiftsi", "=", "force_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "shift", ")", ")", ";", "unshifted_mask", "=", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ";", "unshifted_mask_reg", "=", "force_reg", "(", "SImode", ",", "unshifted_mask", ")", ";", "mask", "=", "mips_force_binary", "(", "SImode", ",", "ASHIFT", ",", "unshifted_mask_reg", ",", "shiftsi", ")", ";", "inverted_mask", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "inverted_mask", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ")", ")", ";", "if", "(", "oldval", "!=", "const0_rtx", ")", "{", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "oldval", "=", "force_reg", "(", "SImode", ",", "oldval", ")", ";", "oldval", "=", "mips_force_binary", "(", "SImode", ",", "ASHIFT", ",", "oldval", ",", "shiftsi", ")", ";", "}", "if", "(", "newval", "&&", "newval", "!=", "const0_rtx", ")", "{", "newval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "newval", ",", "true", ")", ";", "newval", "=", "force_reg", "(", "SImode", ",", "newval", ")", ";", "newval", "=", "mips_force_binary", "(", "SImode", ",", "ASHIFT", ",", "newval", ",", "shiftsi", ")", ";", "}", "if", "(", "result", ")", "res", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "newval", ")", "si_op", "=", "generator", ".", "fn_6", "(", "res", ",", "memsi", ",", "mask", ",", "inverted_mask", ",", "oldval", ",", "newval", ")", ";", "else", "if", "(", "result", ")", "si_op", "=", "generator", ".", "fn_5", "(", "res", ",", "memsi", ",", "mask", ",", "inverted_mask", ",", "oldval", ")", ";", "else", "si_op", "=", "generator", ".", "fn_4", "(", "memsi", ",", "mask", ",", "inverted_mask", ",", "oldval", ")", ";", "emit_insn", "(", "si_op", ")", ";", "if", "(", "result", ")", "{", "mips_emit_binary", "(", "AND", ",", "res", ",", "res", ",", "mask", ")", ";", "mips_emit_binary", "(", "LSHIFTRT", ",", "res", ",", "res", ",", "shiftsi", ")", ";", "mips_emit_move", "(", "result", ",", "gen_lowpart", "(", "GET_MODE", "(", "result", ")", ",", "res", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "a", "QI", "or", "HI", "mode", "atomic", "memory", "operation", ".", "GENERATOR", "contains", "a", "pointer", "to", "the", "gen_", "*", "function", "that", "generates", "the", "SI", "mode", "underlying", "atomic", "operation", "using", "masks", "that", "we", "calculate", ".", "RESULT", "is", "the", "return", "register", "for", "the", "operation", ".", "Its", "value", "is", "NULL", "if", "unused", ".", "MEM", "is", "the", "location", "of", "the", "atomic", "access", ".", "OLDVAL", "is", "the", "first", "operand", "for", "the", "operation", ".", "NEWVAL", "is", "the", "optional", "second", "operand", "for", "the", "operation", ".", "Its", "value", "is", "NULL", "if", "unused", "." ]

[ "mips", "0", "4", "3", "3", "2", "3" ]

[]

[ "<s>", "static", "bool", "avr_2word_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "TARGET_SKIP_BUG", "||", "!", "insn", "||", "get_attr_length", "(", "insn", ")", "!=", "2", ")", "{", "return", "false", ";", "}", "switch", "(", "INSN_CODE", "(", "insn", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CODE_FOR_movqi_insn", ":", "case", "CODE_FOR_movuqq_insn", ":", "case", "CODE_FOR_movqq_insn", ":", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "MEM_P", "(", "dest", ")", "&&", "(", "REG_P", "(", "src", ")", "||", "src", "==", "CONST0_RTX", "(", "GET_MODE", "(", "dest", ")", ")", ")", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ";", "}", "return", "false", ";", "}", "case", "CODE_FOR_call_insn", ":", "case", "CODE_FOR_call_value_insn", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Helper", "for", "jump_over_one_insn_p", ":", "Test", "if", "INSN", "is", "a", "2-word", "instruction", "and", "thus", "is", "suitable", "to", "be", "skipped", "by", "CPSE", ",", "SBRC", ",", "etc", "." ]

[ "avr", "2", "0", "0" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "const", "ARMSubtarget", "&", "Subtarget", "=", "DAG", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isTargetNaCl", "(", ")", "||", "!", "EnableARMAEABIFunctions", "||", "!", "Subtarget", ".", "isAAPCS_ABI", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", "||", "Subtarget", ".", "isTargetWindows", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "TOY", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "TOY", "TOY::NumTargetFixupKinds" ]

[]

[ "<s>", "static", "rtx_insn", "*", "cris_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", "outputs", ",", "vec", "<", "rtx", ">", "&", "inputs", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", "constraints", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "CRIS_CC0_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "CRIS_CC0_REGNUM", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "constraints", ".", "length", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "strchr", "(", "constraints", "[", "i", "]", ",", "'h'", ")", "!=", "NULL", ")", "return", "NULL", ";", "rtx", "mof_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "CRIS_MOF_REGNUM", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "outputs", ".", "length", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "reg_overlap_mentioned_p", "(", "mof_reg", ",", "outputs", "[", "i", "]", ")", ")", "return", "NULL", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "inputs", ".", "length", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "if", "(", "reg_overlap_mentioned_p", "(", "mof_reg", ",", "inputs", "[", "i", "]", ")", ")", "return", "NULL", ";", "clobbers", ".", "safe_push", "(", "mof_reg", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "CRIS_MOF_REGNUM", ")", ";", "return", "NULL", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "nvptx_builtin_decl", "(", "unsigned", "code", ",", "bool", "ARG_UNUSED", "(", "initialize_p", ")", ")", "{", "if", "(", "code", ">=", "NVPTX_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "nvptx_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Return", "the", "NVPTX", "builtin", "for", "CODE", "." ]

[ "nvptx" ]

[]

[ "<s>", "InstructionCost", "AArch64TargetLowering", "::", "getScalingFactorCost", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "isLegalAddressingMode", "(", "DL", ",", "AM", ",", "Ty", ",", "AS", ")", ")", "return", "AM", ".", "Scale", "!=", "0", "&&", "AM", ".", "Scale", "!=", "1", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "scaling", "factor", "used", "in", "the", "addressing", "mode", "represented", "by", "AM", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

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

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "STI", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "AttributeSet", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "OptimizeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "MinimizeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "PTXMCAsmStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ")", "{", "assert", "(", "CurSection", "&&", "\"Cannot emit contents before setting section!\"", ")", ";", "if", "(", "Emitter", ")", "AddEncodingComment", "(", "Inst", ")", ";", "if", "(", "ShowInst", ")", "{", "Inst", ".", "dump_pretty", "(", "GetCommentOS", "(", ")", ",", "&", "MAI", ",", "InstPrinter", ".", "get", "(", ")", ",", "\"\\n \"", ")", ";", "GetCommentOS", "(", ")", "<<", "\"\\n\"", ";", "}", "if", "(", "InstPrinter", ")", "InstPrinter", "->", "printInst", "(", "&", "Inst", ",", "OS", ")", ";", "else", "Inst", ".", "print", "(", "OS", ",", "&", "MAI", ")", ";", "EmitEOL", "(", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "\"Cannot emit contents before setting section!\"", "\"\\n \"", "\"\\n\"" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "DebugHandlerBase", "::", "beginInstruction", "(", "MI", ")", ";", "if", "(", "SkipInstruction", "||", "MI", "->", "isMetaInstruction", "(", ")", "||", "MI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "return", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "{", "unsigned", "NumDefs", "=", "0", ";", "for", "(", ";", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "isDef", "(", ")", ";", "++", "NumDefs", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", "->", "getOperand", "(", "NumDefs", ")", ".", "getSymbolName", "(", ")", ";", "if", "(", "AsmStr", "[", "0", "]", "==", "0", ")", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "{", "processReloc", "(", "MI", "->", "getOperand", "(", "1", ")", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_ALU32_MEM", "||", "MI", "->", "getOpcode", "(", ")", "==", "BPF", "::", "CORE_SHIFT", ")", "{", "processReloc", "(", "MI", "->", "getOperand", "(", "3", ")", ")", ";", "}", "const", "DebugLoc", "&", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DL", "||", "PrevInstLoc", "==", "DL", ")", "{", "if", "(", "LineInfoGenerated", "==", "false", ")", "{", "auto", "*", "S", "=", "MI", "->", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "constructLineInfo", "(", "S", ",", "FuncLabel", ",", "S", "->", "getLine", "(", ")", ",", "0", ")", ";", "LineInfoGenerated", "=", "true", ";", "}", "return", ";", "}", "MCSymbol", "*", "LineSym", "=", "OS", ".", "getContext", "(", ")", ".", "createTempSymbol", "(", ")", ";", "OS", ".", "EmitLabel", "(", "LineSym", ")", ";", "auto", "SP", "=", "DL", ".", "get", "(", ")", "->", "getScope", "(", ")", "->", "getSubprogram", "(", ")", ";", "constructLineInfo", "(", "SP", ",", "LineSym", ",", "DL", ".", "getLine", "(", ")", ",", "DL", ".", "getCol", "(", ")", ")", ";", "LineInfoGenerated", "=", "true", ";", "PrevInstLoc", "=", "DL", ";", "}", "</s>" ]

[ "Process", "beginning", "of", "an", "instruction", "." ]

[ "BPF", "0", "0", "0", "BPF::LD_imm64", "1", "BPF::CORE_MEM", "BPF::CORE_ALU32_MEM", "BPF::CORE_SHIFT", "3", "0" ]

[]

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

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "NVPTX" ]

[]

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

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

[ "AVR" ]

[]

[ "<s>", "LoadInst", "*", "getLoad", "(", ")", "{", "return", "NewLd", ";", "}", "</s>" ]

[ "Loads", "are", "not", "normal", "binary", "operators", ":", "their", "result", "type", "is", "not", "determined", "by", "their", "operands", ",", "and", "they", "produce", "a", "value", "AND", "a", "token", "chain", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "microblaze_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "struct", "microblaze_address_info", "addr", ";", "return", "microblaze_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "strict", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "implement", "GO_IF_LEGITIMATE_ADDRESS", ".", "It", "returns", "a", "nonzero", "value", "if", "X", "is", "a", "legitimate", "address", "for", "a", "memory", "operand", "of", "the", "indicated", "MODE", ".", "STRICT", "is", "nonzero", "if", "this", "function", "is", "called", "during", "reload", "." ]

[ "microblaze" ]

[]

[ "<s>", "std", "::", "vector", "<", "SIScheduleBlock", "*", ">", "getBlocks", "(", ")", "{", "return", "BlocksScheduled", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "the", "basic", "blocks", "which", "make", "up", "this", "loop", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "PredicateFtor", "&&", "!", "PredicateFtor", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "STI", "->", "isThumb1Only", "(", ")", "||", "STI", "->", "prefers32BitThumb", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "OptimizeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "MinimizeSize", "=", "STI", "->", "optForMinSize", "(", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "::", "rpo_iterator", "I", "=", "RPOT", ".", "begin", "(", ")", ",", "E", "=", "RPOT", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "set_frame_related_p", "(", ")", "{", "rtx", "seq", "=", "gen_sequence", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "GET_CODE", "(", "seq", ")", "==", "SEQUENCE", ")", "{", "int", "i", "=", "XVECLEN", "(", "seq", ",", "0", ")", ";", "while", "(", "--", "i", ">=", "0", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "seq", ",", "0", ",", "i", ")", ")", "=", "1", ";", "return", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "return", "seq", ";", "}", "}", "</s>" ]

[ "Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "." ]

[ "alpha", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "void", "finishLayout", "(", "MCAssembler", "const", "&", "Asm", ",", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "for", "(", "auto", "I", ":", "Layout", ".", "getSectionOrder", "(", ")", ")", "{", "auto", "&", "Fragments", "=", "I", "->", "getFragmentList", "(", ")", ";", "for", "(", "auto", "&", "J", ":", "Fragments", ")", "{", "switch", "(", "J", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "auto", "Size", "=", "Asm", ".", "computeFragmentSize", "(", "Layout", ",", "J", ")", ";", "for", "(", "auto", "K", "=", "J", ".", "getIterator", "(", ")", ";", "K", "!=", "Fragments", ".", "begin", "(", ")", "&&", "Size", ">=", "HEXAGON_PACKET_SIZE", ";", ")", "{", "--", "K", ";", "switch", "(", "K", "->", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "Size", "=", "0", ";", "break", ";", "}", "case", "MCFragment", "::", "FT_Relaxable", ":", "{", "MCContext", "&", "Context", "=", "Asm", ".", "getContext", "(", ")", ";", "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "0", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "4", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Context", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "4", ";", "if", "(", "!", "HexagonMCChecker", "(", "Context", ",", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "*", "Context", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "1", ")", ";", "Size", "=", "0", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "Context", ",", "true", ",", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "0", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}", "}", "</s>" ]

[ "Give", "backend", "an", "opportunity", "to", "finish", "layout", "after", "relaxation", "." ]

[ "Hexagon", "0", "0", "Hexagon", "4", "Hexagon::A2_nop", "4", "Hexagon", "1", "0", "Hexagon", "0" ]

[]

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

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

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass" ]

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"add\\t%0, %1, %0\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "reg2", ";", "output_asm_insn", "(", "\"cmp\\t%0, %1\"", ",", "xops", ")", ";", "if", "(", "TARGET_ARCH64", ")", "fputs", "(", "\"\\tbne,pt\\t%xcc,\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\tbne\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "SPARC_STACK_BIAS", ")", ";", "output_asm_insn", "(", "\" st\\t%%g0, [%0+%1]\"", ",", "xops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

[ "sparc", "0", "32", "2", "\"LPSRL\"", "0", "1", "\"add\\t%0, %1, %0\"", "1", "\"cmp\\t%0, %1\"", "\"\\tbne,pt\\t%xcc,\"", "\"\\tbne\\t\"", "1", "\" st\\t%%g0, [%0+%1]\"", "\"\"" ]

[]

[ "<s>", "void", "GBZ80InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "GBZ80", "GB" ]

[]

[ "<s>", "unsigned", "getExplicitKernelArgOffset", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "isAmdCodeObjectV2", "(", "MF", ")", "?", "0", ":", "36", ";", "}", "</s>" ]

[ "Returns", "the", "offset", "in", "bytes", "from", "the", "start", "of", "the", "input", "buffer", "of", "the", "first", "explicit", "kernel", "argument", "." ]

[ "AMDGPU", "0", "36" ]

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "const", "HexagonEvaluator", "HE", "(", "HRI", ",", "MRI", ",", "HII", ",", "MF", ")", ";", "BitTracker", "BT", "(", "HE", ",", "MF", ")", ";", "LLVM_DEBUG", "(", "BT", ".", "trace", "(", "true", ")", ")", ";", "BT", ".", "run", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "RegisterSet", "AIG", ";", "ConstGeneration", "ImmG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "ImmG", ",", "AIG", ")", ";", "RegisterSet", "ARE", ";", "RedundantInstrElimination", "RIE", "(", "BT", ",", "HII", ",", "HRI", ",", "MRI", ")", ";", "bool", "Ried", "=", "visitBlock", "(", "Entry", ",", "RIE", ",", "ARE", ")", ";", "if", "(", "Ried", ")", "{", "Changed", "=", "true", ";", "BT", ".", "run", "(", ")", ";", "}", "RegisterSet", "ACG", ";", "CopyGeneration", "CopyG", "(", "BT", ",", "HII", ",", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyG", ",", "ACG", ")", ";", "RegisterSet", "ACP", ";", "CopyPropagation", "CopyP", "(", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyP", ",", "ACP", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "BT", ".", "run", "(", ")", ";", "RegisterSet", "ABS", ";", "BitSimplification", "BitS", "(", "BT", ",", "*", "MDT", ",", "HII", ",", "HRI", ",", "MRI", ",", "MF", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "BitS", ",", "ABS", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "if", "(", "Changed", ")", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "I", ".", "clearKillInfo", "(", ")", ";", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "WebAssembly", "::", "COPY", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::COPY", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "isRegKind", "(", ")", "&&", "!", "hasModifiers", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

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

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

[ "AMDGPU", "R600" ]

[]

[ "<s>", "Register", "SIRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIFrameLowering", "*", "TFI", "=", "ST", ".", "getFrameLowering", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FuncInfo", "->", "getFrameOffsetReg", "(", ")", ":", "Register", "(", ")", ";", "}", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FuncInfo", "->", "getFrameOffsetReg", "(", ")", ":", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Asm", ",", "Fixup", ",", "Target", ",", "Value", ",", "IsPCRel", ",", "Ctx", ",", "IsLittleEndian", ",", "true", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "!", "IsLittleEndian", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "int", "m16_check_op", "(", "rtx", "op", ",", "int", "low", ",", "int", "high", ",", "int", "mask", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op", ")", ">=", "low", "&&", "INTVAL", "(", "op", ")", "<=", "high", "&&", "(", "INTVAL", "(", "op", ")", "&", "mask", ")", "==", "0", ")", ";", "}", "</s>" ]

[ "We", "need", "a", "lot", "of", "little", "routines", "to", "check", "constant", "values", "on", "the", "mips16", ".", "These", "are", "used", "to", "figure", "out", "how", "long", "the", "instruction", "will", "be", ".", "It", "would", "be", "much", "better", "to", "do", "this", "using", "constraints", ",", "but", "there", "are", "n't", "nearly", "enough", "letters", "available", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "0", "]", ",", "Pmode", ")", ")", "operands", "[", "0", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "{", "prepare_pic_move", "(", "operands", ",", "SImode", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "MEM", "&&", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "move_dest_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "if", "(", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "pat", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "." ]

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

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createR600VectorRegMerger", "(", "*", "TM", ")", ")", ";", "}", "else", "{", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", "&&", "ST", ".", "loadStoreOptEnabled", "(", ")", ")", "{", "initializeSILoadStoreOptimizerPass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SILoadStoreOptimizerID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIFixSGPRLiveRangesPass", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "isMBB", "(", ")", "{", "return", "getMBBMRT", "(", ")", "!=", "nullptr", ";", "}", "</s>" ]

[ "isMBB", "-", "Tests", "if", "this", "is", "a", "MO_MachineBasicBlock", "operand", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "MCInst", "const", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "Inst", ")", "&&", "\"Hexagon relaxInstruction only works on bundles\"", ")", ";", "Res", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "bool", "Update", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "Inst", ")", ")", "{", "MCInst", "&", "CrntHMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "if", "(", "*", "RelaxTarget", "==", "&", "CrntHMI", ")", "{", "Update", "=", "true", ";", "assert", "(", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Res", ")", "<", "HEXAGON_PACKET_SIZE", ")", "&&", "\"No room to insert extender for relaxation\"", ")", ";", "MCInst", "*", "HMIx", "=", "takeExtender", "(", ")", ";", "*", "HMIx", "=", "HexagonMCInstrInfo", "::", "deriveExtender", "(", "*", "MCII", ",", "CrntHMI", ",", "HexagonMCInstrInfo", "::", "getExtendableOperand", "(", "*", "MCII", ",", "CrntHMI", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "HMIx", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "}", "Res", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "I", ".", "getInst", "(", ")", ")", ")", ";", "}", "(", "void", ")", "Update", ";", "assert", "(", "Update", "&&", "\"Didn't find relaxation target\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Hexagon relaxInstruction only works on bundles\"", "Hexagon", "Hexagon", "Hexagon", "\"No room to insert extender for relaxation\"", "Hexagon", "Hexagon", "\"Didn't find relaxation target\"" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "assert", "(", "!", "isFuncletEHPersonality", "(", "classifyEHPersonality", "(", "PersonalityFn", ")", ")", ")", ";", "return", "Subtarget", "->", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RDX", ":", "X86", "::", "EDX", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "X86", "X86", "X86::RDX", "X86::EDX" ]

[]

[ "<s>", "static", "bool", "chain_already_loaded", "(", "rtx_insn", "*", "last", ")", "{", "for", "(", ";", "last", "!=", "NULL", ";", "last", "=", "PREV_INSN", "(", "last", ")", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "last", ")", ")", "{", "rtx", "patt", "=", "PATTERN", "(", "last", ")", ";", "if", "(", "GET_CODE", "(", "patt", ")", "==", "SET", ")", "{", "rtx", "lhs", "=", "XEXP", "(", "patt", ",", "0", ")", ";", "if", "(", "REG_P", "(", "lhs", ")", "&&", "REGNO", "(", "lhs", ")", "==", "STATIC_CHAIN_REGNUM", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "iff", "the", "sequence", "ending", "in", "LAST", "sets", "the", "static", "chain", "." ]

[ "rs6000", "0" ]

[]

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

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

[ "TOY", "TOY", "TOY" ]

[]

[ "<s>", "bool", "XCoreRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "static", "reg_class_t", "mn10300_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "x", "==", "stack_pointer_rtx", "&&", "rclass", "!=", "SP_REGS", ")", "return", "(", "TARGET_AM33", "?", "GENERAL_REGS", ":", "ADDRESS_REGS", ")", ";", "else", "if", "(", "MEM_P", "(", "x", ")", "||", "(", "REG_P", "(", "x", ")", "&&", "!", "HARD_REGISTER_P", "(", "x", ")", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "REG_P", "(", "SUBREG_REG", "(", "x", ")", ")", "&&", "!", "HARD_REGISTER_P", "(", "SUBREG_REG", "(", "x", ")", ")", ")", ")", "return", "LIMIT_RELOAD_CLASS", "(", "GET_MODE", "(", "x", ")", ",", "rclass", ")", ";", "else", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_RELOAD_CLASS", "." ]

[ "mn10300" ]

[]

[ "<s>", "static", "int", "rs6000_use_sched_lookahead_guard", "(", "rtx_insn", "*", "insn", ",", "int", "ready_index", ")", "{", "if", "(", "ready_index", "==", "0", ")", "return", "0", ";", "if", "(", "rs6000_cpu_attr", "!=", "CPU_CELL", ")", "return", "0", ";", "gcc_assert", "(", "insn", "!=", "NULL_RTX", "&&", "INSN_P", "(", "insn", ")", ")", ";", "if", "(", "!", "reload_completed", "||", "is_nonpipeline_insn", "(", "insn", ")", "||", "is_microcoded_insn", "(", "insn", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "We", "are", "choosing", "insn", "from", "the", "ready", "queue", ".", "Return", "zero", "if", "INSN", "can", "be", "chosen", "." ]

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

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "return", "Error", "(", "IDLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "R600", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "(", "Idx", "==", "1", ")", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "if", "(", "(", "Idx", "<", "2", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "(", "Idx", "<", "4", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "}", "return", "X86TTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "Intrinsic::ID", "0", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "1", "64", "32", "Intrinsic::experimental_stackmap", "2", "64", "64", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "4", "64", "64", "X86" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "setSpecialOperandAttr", "(", "MachineInstr", "&", "OldMI1", ",", "MachineInstr", "&", "OldMI2", ",", "MachineInstr", "&", "NewMI1", ",", "MachineInstr", "&", "NewMI2", ")", "const", "{", "if", "(", "OldMI1", ".", "getNumOperands", "(", ")", "!=", "4", "||", "OldMI2", ".", "getNumOperands", "(", ")", "!=", "4", ")", "return", ";", "assert", "(", "NewMI1", ".", "getNumOperands", "(", ")", "==", "4", "&&", "NewMI2", ".", "getNumOperands", "(", ")", "==", "4", "&&", "\"Unexpected instruction type for reassociation\"", ")", ";", "MachineOperand", "&", "OldOp1", "=", "OldMI1", ".", "getOperand", "(", "3", ")", ";", "MachineOperand", "&", "OldOp2", "=", "OldMI2", ".", "getOperand", "(", "3", ")", ";", "MachineOperand", "&", "NewOp1", "=", "NewMI1", ".", "getOperand", "(", "3", ")", ";", "MachineOperand", "&", "NewOp2", "=", "NewMI2", ".", "getOperand", "(", "3", ")", ";", "assert", "(", "OldOp1", ".", "isReg", "(", ")", "&&", "OldOp1", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "OldOp1", ".", "isDead", "(", ")", "&&", "\"Must have dead EFLAGS operand in reassociable instruction\"", ")", ";", "assert", "(", "OldOp2", ".", "isReg", "(", ")", "&&", "OldOp2", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "OldOp2", ".", "isDead", "(", ")", "&&", "\"Must have dead EFLAGS operand in reassociable instruction\"", ")", ";", "(", "void", ")", "OldOp1", ";", "(", "void", ")", "OldOp2", ";", "assert", "(", "NewOp1", ".", "isReg", "(", ")", "&&", "NewOp1", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "\"Unexpected operand in reassociable instruction\"", ")", ";", "assert", "(", "NewOp2", ".", "isReg", "(", ")", "&&", "NewOp2", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", "&&", "\"Unexpected operand in reassociable instruction\"", ")", ";", "NewOp1", ".", "setIsDead", "(", ")", ";", "NewOp2", ".", "setIsDead", "(", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "architecture-specific", "helper", "function", "of", "reassociateOps", "." ]

[ "X86", "X86", "4", "4", "4", "4", "\"Unexpected instruction type for reassociation\"", "3", "3", "3", "3", "X86::EFLAGS", "\"Must have dead EFLAGS operand in reassociable instruction\"", "X86::EFLAGS", "\"Must have dead EFLAGS operand in reassociable instruction\"", "X86::EFLAGS", "\"Unexpected operand in reassociable instruction\"", "X86::EFLAGS", "\"Unexpected operand in reassociable instruction\"" ]

[]

[ "<s>", "static", "bool", "rs6000_attribute_takes_identifier_p", "(", "const_tree", "attr_id", ")", "{", "return", "is_attribute_p", "(", "\"altivec\"", ",", "attr_id", ")", ";", "}", "</s>" ]

[ "Returns", "TRUE", "iff", "the", "target", "attribute", "indicated", "by", "ATTR_ID", "takes", "a", "plain", "identifier", "as", "an", "argument", ",", "so", "the", "front", "end", "should", "n't", "look", "it", "up", "." ]

[ "rs6000", "\"altivec\"" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ",", "unsigned", "Op1", ",", "bool", "Op1IsKill", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "2", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addReg", "(", "Op1", ",", "Op1IsKill", "*", "RegState", "::", "Kill", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addReg", "(", "Op1", ",", "Op1IsKill", "*", "RegState", "::", "Kill", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "two", "register", "operands", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "ARM", "ARM", "1", "2", "1", "0" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "emitZeroCallUsedRegs", "(", "BitVector", "RegsToZero", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AArch64Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "AArch64RegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "BitVector", "GPRsToZero", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ";", "BitVector", "FPRsToZero", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ";", "bool", "HasSVE", "=", "STI", ".", "hasSVE", "(", ")", ";", "for", "(", "MCRegister", "Reg", ":", "RegsToZero", ".", "set_bits", "(", ")", ")", "{", "if", "(", "TRI", ".", "isGeneralPurposeRegister", "(", "MF", ",", "Reg", ")", ")", "{", "if", "(", "MCRegister", "XReg", "=", "getRegisterOrZero", "(", "Reg", ",", "HasSVE", ")", ")", "GPRsToZero", ".", "set", "(", "XReg", ")", ";", "}", "else", "if", "(", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR32RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR16RegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "FPR8RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "MCRegister", "XReg", "=", "getRegisterOrZero", "(", "Reg", ",", "HasSVE", ")", ")", "FPRsToZero", ".", "set", "(", "XReg", ")", ";", "}", "}", "const", "AArch64InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MCRegister", "Reg", ":", "GPRsToZero", ".", "set_bits", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "MOVi64imm", ")", ",", "Reg", ")", ".", "addImm", "(", "0", ")", ";", "for", "(", "MCRegister", "Reg", ":", "FPRsToZero", ".", "set_bits", "(", ")", ")", "if", "(", "HasSVE", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "DUP_ZI_D", ")", ",", "Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "MOVIv2d_ns", ")", ",", "Reg", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "HasSVE", ")", "{", "for", "(", "MCRegister", "PReg", ":", "{", "AArch64", "::", "P0", ",", "AArch64", "::", "P1", ",", "AArch64", "::", "P2", ",", "AArch64", "::", "P3", ",", "AArch64", "::", "P4", ",", "AArch64", "::", "P5", ",", "AArch64", "::", "P6", ",", "AArch64", "::", "P7", ",", "AArch64", "::", "P8", ",", "AArch64", "::", "P9", ",", "AArch64", "::", "P10", ",", "AArch64", "::", "P11", ",", "AArch64", "::", "P12", ",", "AArch64", "::", "P13", ",", "AArch64", "::", "P14", ",", "AArch64", "::", "P15", "}", ")", "{", "if", "(", "RegsToZero", "[", "PReg", "]", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "PFALSE", ")", ",", "PReg", ")", ";", "}", "}", "}", "</s>" ]

[ "emitZeroCallUsedRegs", "-", "Zeros", "out", "call", "used", "registers", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::FPR128RegClass", "AArch64::FPR64RegClass", "AArch64::FPR32RegClass", "AArch64::FPR16RegClass", "AArch64::FPR8RegClass", "AArch64", "AArch64::MOVi64imm", "0", "AArch64::DUP_ZI_D", "0", "0", "AArch64::MOVIv2d_ns", "0", "AArch64::P0", "AArch64::P1", "AArch64::P2", "AArch64::P3", "AArch64::P4", "AArch64::P5", "AArch64::P6", "AArch64::P7", "AArch64::P8", "AArch64::P9", "AArch64::P10", "AArch64::P11", "AArch64::P12", "AArch64::P13", "AArch64::P14", "AArch64::P15", "AArch64::PFALSE" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "if", "(", "TM", "->", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "X86FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "unsigned", "PC", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "PC", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "X86", "::", "GR32RegClass", ")", ";", "else", "PC", "=", "GlobalBaseReg", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOVPC32r", ")", ",", "PC", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isPICStyleGOT", "(", ")", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "ADD32ri", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "PC", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "X86II", "::", "MO_GOT_ABSOLUTE_ADDRESS", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "X86", "X86::GR32RegClass", "X86::MOVPC32r", "0", "X86", "X86::ADD32ri", "\"_GLOBAL_OFFSET_TABLE_\"", "X86II::MO_GOT_ABSOLUTE_ADDRESS" ]

[]

[ "<s>", "static", "int", "str_prefix_p", "(", "const", "char", "*", "str", ",", "const", "char", "*", "prefix", ")", "{", "return", "strncmp", "(", "str", ",", "prefix", ",", "strlen", "(", "prefix", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "iff", "STR", "starts", "with", "PREFIX", "." ]

[ "avr", "0" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "override", "{", "markPhysRegUsed", "(", "PhysReg", ")", ";", "IncomingValueHandler", "::", "assignValueToReg", "(", "ValVReg", ",", "PhysReg", ",", "VA", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "X86" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "PPCInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "PPCII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PLT", ",", "\"ppc-plt\"", "}", ",", "{", "MO_PIC_FLAG", ",", "\"ppc-pic\"", "}", ",", "{", "MO_PCREL_FLAG", ",", "\"ppc-pcrel\"", "}", ",", "{", "MO_GOT_FLAG", ",", "\"ppc-got\"", "}", ",", "{", "MO_PCREL_OPT_FLAG", ",", "\"ppc-opt-pcrel\"", "}", ",", "{", "MO_TLSGD_FLAG", ",", "\"ppc-tlsgd\"", "}", ",", "{", "MO_TPREL_FLAG", ",", "\"ppc-tprel\"", "}", ",", "{", "MO_GOT_TLSGD_PCREL_FLAG", ",", "\"ppc-got-tlsgd-pcrel\"", "}", ",", "{", "MO_GOT_TPREL_PCREL_FLAG", ",", "\"ppc-got-tprel-pcrel\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "PowerPC", "PPC", "PPC", "\"ppc-plt\"", "\"ppc-pic\"", "\"ppc-pcrel\"", "\"ppc-got\"", "\"ppc-opt-pcrel\"", "\"ppc-tlsgd\"", "\"ppc-tprel\"", "\"ppc-got-tlsgd-pcrel\"", "\"ppc-got-tprel-pcrel\"" ]

[]

[ "<s>", "static", "rtx", "sparc_got", "(", "void", ")", "{", "if", "(", "!", "sparc_got_symbol", ")", "sparc_got_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "return", "sparc_got_symbol", ";", "}", "</s>" ]

[ "Return", "the", "SYMBOL_REF", "for", "the", "Global", "Offset", "Table", "." ]

[ "sparc", "\"_GLOBAL_OFFSET_TABLE_\"" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "FeatureBitset", "Features", "=", "coalesceFeatures", "(", "M", ")", ";", "std", "::", "string", "FeatureStr", "=", "getFeatureString", "(", "Features", ")", ";", "for", "(", "auto", "&", "F", ":", "M", ")", "replaceFeatures", "(", "F", ",", "FeatureStr", ")", ";", "bool", "StrippedAtomics", "=", "false", ";", "bool", "StrippedTLS", "=", "false", ";", "if", "(", "!", "Features", "[", "WebAssembly", "::", "FeatureAtomics", "]", ")", "StrippedAtomics", "=", "stripAtomics", "(", "M", ")", ";", "if", "(", "!", "Features", "[", "WebAssembly", "::", "FeatureBulkMemory", "]", ")", "StrippedTLS", "=", "stripThreadLocals", "(", "M", ")", ";", "if", "(", "StrippedAtomics", "&&", "!", "StrippedTLS", ")", "stripThreadLocals", "(", "M", ")", ";", "else", "if", "(", "StrippedTLS", "&&", "!", "StrippedAtomics", ")", "stripAtomics", "(", "M", ")", ";", "recordFeatures", "(", "M", ",", "Features", ",", "StrippedAtomics", "||", "StrippedTLS", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly::FeatureAtomics", "WebAssembly::FeatureBulkMemory" ]

[]