Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "if", "(", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "isHvxOperation", "(", "N", ",", "DCI", ".", "DAG", ")", ")", "{", "if", "(", "SDValue", "V", "=", "PerformHvxDAGCombine", "(", "N", ",", "DCI", ")", ")", "return", "V", ";", "return", "SDValue", "(", ")", ";", "}", "SDValue", "Op", "(", "N", ",", "0", ")", ";", "const", "SDLoc", "&", "dl", "(", "Op", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "HexagonISD", "::", "P2D", ")", "{", "SDValue", "P", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "switch", "(", "P", ".", "getOpcode", "(", ")", ")", "{", "case", "HexagonISD", "::", "PTRUE", ":", "return", "DCI", ".", "DAG", ".", "getConstant", "(", "-", "1", ",", "dl", ",", "ty", "(", "Op", ")", ")", ";", "case", "HexagonISD", "::", "PFALSE", ":", "return", "getZero", "(", "dl", ",", "ty", "(", "Op", ")", ",", "DCI", ".", "DAG", ")", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "Opc", "==", "ISD", "::", "VSELECT", ")", "{", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Cond", "->", "getOpcode", "(", ")", "==", "ISD", "::", "XOR", ")", "{", "SDValue", "C0", "=", "Cond", ".", "getOperand", "(", "0", ")", ",", "C1", "=", "Cond", ".", "getOperand", "(", "1", ")", ";", "if", "(", "C1", "->", "getOpcode", "(", ")", "==", "HexagonISD", "::", "PTRUE", ")", "{", "SDValue", "VSel", "=", "DCI", ".", "DAG", ".", "getNode", "(", "ISD", "::", "VSELECT", ",", "dl", ",", "ty", "(", "Op", ")", ",", "C0", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "Op", ".", "getOperand", "(", "1", ")", ")", ";", "return", "VSel", ";", "}", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "Hexagon", "Hexagon", "0", "HexagonISD::P2D", "0", "HexagonISD::PTRUE", "1", "HexagonISD::PFALSE", "ISD::VSELECT", "0", "ISD::XOR", "0", "1", "HexagonISD::PTRUE", "ISD::VSELECT", "2", "1" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "{", "if", "(", "doesNotReturn", "(", "MI", ")", ")", "return", "true", ";", "for", "(", "auto", "I", ":", "MBB", "->", "successors", "(", ")", ")", "if", "(", "I", "->", "isEHPad", "(", ")", ")", "return", "true", ";", "}", "if", "(", "MI", ".", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "INLINEASM_BR", ")", "return", "true", ";", "if", "(", "MI", ".", "isInlineAsm", "(", ")", "&&", "!", "ScheduleInlineAsm", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "void", "pdp11_asm_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "REAL_VALUE_TYPE", "r", ";", "long", "sval", "[", "2", "]", ";", "if", "(", "code", "==", "'#'", ")", "fprintf", "(", "file", ",", "\"#\"", ")", ";", "else", "if", "(", "code", "==", "'@'", ")", "{", "if", "(", "TARGET_UNIX_ASM", ")", "fprintf", "(", "file", ",", "\"*\"", ")", ";", "else", "fprintf", "(", "file", ",", "\"@\"", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "x", ")", "!=", "SImode", ")", "{", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "r", ",", "sval", ")", ";", "fprintf", "(", "file", ",", "\"$%#lo\"", ",", "sval", "[", "0", "]", ">>", "16", ")", ";", "}", "else", "{", "putc", "(", "'$'", ",", "file", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "x", ")", ";", "}", "}", "</s>" ]

[ "Special", "format", "operators", "handled", "here", ":", "#", "--", "output", "the", "correct", "immediate", "operand", "marker", "for", "the", "assembler", "dialect", ".", "@", "--", "output", "the", "correct", "indirect", "marker", "for", "the", "assembler", "dialect", ".", "o", "--", "emit", "a", "constant", "value", "as", "a", "number", "(", "not", "an", "immediate", "operand", ")", "in", "octal", "." ]

[ "pdp11", "2", "\"#\"", "\"*\"", "\"@\"", "\"%s\"", "0", "\"$%#lo\"", "0", "16" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "getSGPRNum", "(", ")", "==", "0", "&&", "getVGPRNum", "(", ")", "==", "0", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

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

[]

[ "<s>", "static", "void", "ix86_emit_cmove", "(", "rtx", "dst", ",", "rtx", "src", ",", "enum", "rtx_code", "code", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "t", ";", "if", "(", "TARGET_CMOVE", ")", "{", "t", "=", "ix86_expand_compare", "(", "code", ",", "op1", ",", "op2", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dst", ")", ",", "t", ",", "src", ",", "dst", ")", ")", ")", ";", "}", "else", "{", "rtx_code_label", "*", "nomove", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_and_jump_insns", "(", "op1", ",", "op2", ",", "reverse_condition", "(", "code", ")", ",", "const0_rtx", ",", "GET_MODE", "(", "op1", ")", ",", "1", ",", "nomove", ")", ";", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_label", "(", "nomove", ")", ";", "}", "}", "</s>" ]

[ "Emit", "conditional", "move", "of", "SRC", "to", "DST", "with", "condition", "OP1", "CODE", "OP2", "." ]

[ "i386", "1" ]

[]

[ "<s>", "static", "int", "comparator", "(", "const", "void", "*", "va", ",", "const", "void", "*", "vb", ")", "{", "const", "avr_mcu_t", "*", "mcu_a", "=", "*", "(", "const", "avr_mcu_t", "*", "const", "*", ")", "va", ";", "const", "avr_mcu_t", "*", "mcu_b", "=", "*", "(", "const", "avr_mcu_t", "*", "const", "*", ")", "vb", ";", "const", "char", "*", "a", "=", "mcu_a", "->", "name", ";", "const", "char", "*", "b", "=", "mcu_b", "->", "name", ";", "int", "c", "=", "c_prefix", "(", "a", ")", "-", "c_prefix", "(", "b", ")", ";", "if", "(", "c", ")", "return", "c", ";", "c", "=", "(", "int", ")", "mcu_a", "->", "flash_size", "-", "(", "int", ")", "mcu_b", "->", "flash_size", ";", "if", "(", "c", ")", "return", "c", ";", "while", "(", "*", "a", "&&", "*", "b", ")", "{", "c", "=", "c_number", "(", "a", ")", "-", "c_number", "(", "b", ")", ";", "if", "(", "c", ")", "return", "c", ";", "if", "(", "*", "a", "!=", "*", "b", ")", "return", "*", "a", "-", "*", "b", ";", "a", "++", ";", "b", "++", ";", "}", "return", "*", "a", "-", "*", "b", ";", "}", "</s>" ]

[ "Compare", "two", "MCUs", "and", "order", "them", "for", "easy", "lookup", "." ]

[ "avr" ]

[]

[ "<s>", "void", "ix86_target_macros", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "cpp_assert", "(", "parse_in", ",", "\"cpu=x86_64\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"machine=x86_64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__amd64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__amd64__\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__x86_64\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__x86_64__\"", ")", ";", "if", "(", "TARGET_X32", ")", "{", "cpp_define", "(", "parse_in", ",", "\"_ILP32\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__ILP32__\"", ")", ";", "}", "}", "else", "{", "cpp_assert", "(", "parse_in", ",", "\"cpu=i386\"", ")", ";", "cpp_assert", "(", "parse_in", ",", "\"machine=i386\"", ")", ";", "builtin_define_std", "(", "\"i386\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"_ILP32\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__ILP32__\"", ")", ";", "}", "if", "(", "!", "TARGET_80387", ")", "cpp_define", "(", "parse_in", ",", "\"_SOFT_FLOAT\"", ")", ";", "if", "(", "TARGET_LONG_DOUBLE_64", ")", "cpp_define", "(", "parse_in", ",", "\"__LONG_DOUBLE_64__\"", ")", ";", "if", "(", "TARGET_LONG_DOUBLE_128", ")", "cpp_define", "(", "parse_in", ",", "\"__LONG_DOUBLE_128__\"", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__SIZEOF_FLOAT80__=%d\"", ",", "GET_MODE_SIZE", "(", "XFmode", ")", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SIZEOF_FLOAT128__=16\"", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__ATOMIC_HLE_ACQUIRE=%d\"", ",", "IX86_HLE_ACQUIRE", ")", ";", "cpp_define_formatted", "(", "parse_in", ",", "\"__ATOMIC_HLE_RELEASE=%d\"", ",", "IX86_HLE_RELEASE", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__GCC_ASM_FLAG_OUTPUTS__\"", ")", ";", "ix86_target_macros_internal", "(", "ix86_isa_flags", ",", "ix86_isa_flags2", ",", "ix86_arch", ",", "ix86_tune", ",", "ix86_fpmath", ",", "cpp_define", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SEG_FS\"", ")", ";", "cpp_define", "(", "parse_in", ",", "\"__SEG_GS\"", ")", ";", "if", "(", "flag_cf_protection", "!=", "CF_NONE", ")", "cpp_define_formatted", "(", "parse_in", ",", "\"__CET__=%d\"", ",", "flag_cf_protection", "&", "~", "CF_SET", ")", ";", "}", "</s>" ]

[ "Function", "to", "tell", "the", "preprocessor", "about", "the", "defines", "for", "the", "current", "target", "." ]

[ "i386", "\"cpu=x86_64\"", "\"machine=x86_64\"", "\"__amd64\"", "\"__amd64__\"", "\"__x86_64\"", "\"__x86_64__\"", "\"_ILP32\"", "\"__ILP32__\"", "\"cpu=i386\"", "\"machine=i386\"", "\"i386\"", "\"_ILP32\"", "\"__ILP32__\"", "\"_SOFT_FLOAT\"", "\"__LONG_DOUBLE_64__\"", "\"__LONG_DOUBLE_128__\"", "\"__SIZEOF_FLOAT80__=%d\"", "\"__SIZEOF_FLOAT128__=16\"", "\"__ATOMIC_HLE_ACQUIRE=%d\"", "\"__ATOMIC_HLE_RELEASE=%d\"", "\"__GCC_ASM_FLAG_OUTPUTS__\"", "\"__SEG_FS\"", "\"__SEG_GS\"", "\"__CET__=%d\"" ]

[]

[ "<s>", "void", "ia64_override_options", "(", ")", "{", "if", "(", "TARGET_AUTO_PIC", ")", "target_flags", "|=", "MASK_CONST_GP", ";", "if", "(", "TARGET_INLINE_DIV_LAT", "&&", "TARGET_INLINE_DIV_THR", ")", "{", "warning", "(", "\"cannot optimize division for both latency and throughput\"", ")", ";", "target_flags", "&=", "~", "MASK_INLINE_DIV_THR", ";", "}", "if", "(", "ia64_fixed_range_string", ")", "fix_range", "(", "ia64_fixed_range_string", ")", ";", "ia64_flag_schedule_insns2", "=", "flag_schedule_insns_after_reload", ";", "flag_schedule_insns_after_reload", "=", "0", ";", "ia64_section_threshold", "=", "g_switch_set", "?", "g_switch_value", ":", "IA64_DEFAULT_GVALUE", ";", "init_machine_status", "=", "ia64_init_machine_status", ";", "mark_machine_status", "=", "ia64_mark_machine_status", ";", "free_machine_status", "=", "ia64_free_machine_status", ";", "ia64_add_gc_roots", "(", ")", ";", "}", "</s>" ]

[ "Implement", "OVERRIDE_OPTIONS", "." ]

[ "ia64", "\"cannot optimize division for both latency and throughput\"", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "size", "(", ")", "<", "2", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "I", "!=", "MF", ".", "end", "(", ")", ";", ")", "{", "MachineBasicBlock", "&", "B", "=", "*", "I", "++", ";", "if", "(", "processBlock", "(", "B", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "2" ]

[]

[ "<s>", "bool", "X86AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "static", "const", "uint8_t", "Nops", "[", "10", "]", "[", "10", "]", "=", "{", "{", "0x90", "}", ",", "{", "0x66", ",", "0x90", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x40", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x80", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x2e", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "}", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureNOPL", "]", ")", "{", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "++", "i", ")", "OW", "->", "write8", "(", "0x90", ")", ";", "return", "true", ";", "}", "uint64_t", "MaxNopLength", "=", "10", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "ProcIntelSLM", "]", ")", "MaxNopLength", "=", "7", ";", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast15ByteNOP", "]", ")", "MaxNopLength", "=", "15", ";", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "FeatureFast11ByteNOP", "]", ")", "MaxNopLength", "=", "11", ";", "do", "{", "const", "uint8_t", "ThisNopLength", "=", "(", "uint8_t", ")", "std", "::", "min", "(", "Count", ",", "MaxNopLength", ")", ";", "const", "uint8_t", "Prefixes", "=", "ThisNopLength", "<=", "10", "?", "0", ":", "ThisNopLength", "-", "10", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Prefixes", ";", "i", "++", ")", "OW", "->", "write8", "(", "0x66", ")", ";", "const", "uint8_t", "Rest", "=", "ThisNopLength", "-", "Prefixes", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Rest", ";", "i", "++", ")", "OW", "->", "write8", "(", "Nops", "[", "Rest", "-", "1", "]", "[", "i", "]", ")", ";", "Count", "-=", "ThisNopLength", ";", "}", "while", "(", "Count", "!=", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "10", "10", "0x90", "0x66", "0x90", "0x0f", "0x1f", "0x00", "0x0f", "0x1f", "0x40", "0x00", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x0f", "0x1f", "0x80", "0x00", "0x00", "0x00", "0x00", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x2e", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "X86::FeatureNOPL", "0", "0x90", "10", "X86::ProcIntelSLM", "7", "X86::FeatureFast15ByteNOP", "15", "X86::FeatureFast11ByteNOP", "11", "10", "0", "10", "0", "0x66", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "process_cfa_register", "(", "FILE", "*", "out_file", ",", "rtx", "pat", ",", "bool", "unwind", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "int", "src_regno", ";", "if", "(", "src", "==", "pc_rtx", ")", "{", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save rp, r%d\\n\"", ",", "ia64_debugger_regno", "(", "dest_regno", ")", ")", ";", "return", ";", "}", "src_regno", "=", "REGNO", "(", "src", ")", ";", "switch", "(", "src_regno", ")", "{", "case", "PR_REG", "(", "0", ")", ":", "gcc_assert", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save pr, r%d\\n\"", ",", "ia64_debugger_regno", "(", "dest_regno", ")", ")", ";", "break", ";", "case", "AR_UNAT_REGNUM", ":", "gcc_assert", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_ar_unat", "]", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save ar.unat, r%d\\n\"", ",", "ia64_debugger_regno", "(", "dest_regno", ")", ")", ";", "break", ";", "case", "AR_LC_REGNUM", ":", "gcc_assert", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_ar_lc", "]", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save ar.lc, r%d\\n\"", ",", "ia64_debugger_regno", "(", "dest_regno", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "This", "function", "processes", "a", "SET", "pattern", "for", "REG_CFA_REGISTER", "." ]

[ "ia64", "\"\\t.save rp, r%d\\n\"", "0", "\"\\t.save pr, r%d\\n\"", "\"\\t.save ar.unat, r%d\\n\"", "\"\\t.save ar.lc, r%d\\n\"" ]

[]

[ "<s>", "bool", "TPCSetIndxCoalescer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "if", "(", "skipFunction", "(", "Func", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableSetIndxCoalescer", ")", "return", "false", ";", "MF", "=", "&", "Func", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "NumReplaced", "=", "0", ";", "RemovedInstrs", ".", "clear", "(", ")", ";", "AddedInstrs", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "Func", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "RemovedInstrs", ".", "count", "(", "&", "I", ")", "==", "0", ")", "if", "(", "isSET_INDX", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "processSetIndx", "(", "&", "I", ")", ")", "Changed", "=", "true", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "RemovedInstrs", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "0", "0" ]

[]

[ "<s>", "static", "inline", "bool", "aarch64_can_use_per_function_literal_pools_p", "(", "void", ")", "{", "return", "(", "aarch64_pcrelative_literal_loads", "||", "aarch64_cmodel", "==", "AARCH64_CMODEL_LARGE", ")", ";", "}", "</s>" ]

[ "Constant", "pools", "are", "per", "function", "only", "when", "PC", "relative", "literal", "loads", "are", "true", "or", "we", "are", "in", "the", "large", "memory", "model", "." ]

[ "aarch64" ]

[]

[ "<s>", "rtx", "rs6000_got_register", "(", "rtx", "value", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "can_create_pseudo_p", "(", ")", "&&", "!", "df_regs_ever_live_p", "(", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ")", "df_set_regs_ever_live", "(", "RS6000_PIC_OFFSET_TABLE_REGNUM", ",", "true", ")", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "pic_offset_table_rtx", ";", "}", "</s>" ]

[ "Return", "the", "GOT", "register", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "static", "rtx", "tilegx_got_symbol", "(", "void", ")", "{", "if", "(", "g_got_symbol", "==", "NULL", ")", "g_got_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "return", "g_got_symbol", ";", "}", "</s>" ]

[ "Return", "the", "SYMBOL_REF", "for", "_GLOBAL_OFFSET_TABLE_", "." ]

[ "tilegx", "\"_GLOBAL_OFFSET_TABLE_\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 EFLAGS copy lowering\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 EFLAGS copy lowering\"" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_zip", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "high", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ">", "8", ")", "return", "false", ";", "high", "=", "nelt", "/", "2", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "high", ")", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "high", "=", "0", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "i", "+", "high", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "*", "2", "]", "!=", "elt", ")", "return", "false", ";", "elt", "=", "(", "elt", "+", "nelt", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "*", "2", "+", "1", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "high", "=", "!", "high", ";", "}", "out", "=", "d", "->", "target", ";", "if", "(", "high", ")", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_zip2v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_zip2v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_zip2v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_zip2v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_zip2v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_zip2v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_zip2v2di", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_zip2v4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_zip2v8hf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_zip2v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_zip2v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_zip2v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "else", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_zip1v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_zip1v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_zip1v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_zip1v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_zip1v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_zip1v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_zip1v2di", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_zip1v4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_zip1v8hf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_zip1v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_zip1v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_zip1v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "emit_insn", "(", "gen", "(", "out", ",", "in0", ",", "in1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "suitable", "for", "the", "ZIP", "instructions", "." ]

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

[]

[ "<s>", "static", "bool", "mips_use_blocks_for_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "TARGET_MIPS16_PCREL_LOADS", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_BLOCKS_FOR_CONSTANT_P", ".", "We", "ca", "n't", "use", "blocks", "for", "constants", "when", "we", "'re", "using", "a", "per-function", "constant", "pool", "." ]

[ "mips" ]

[]

[ "<s>", "void", "OR1KPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createOR1KDelaySlotFillerPass", "(", ")", ")", ";", "addPass", "(", "createNEMESISPass", "(", ")", ")", ";", "addPass", "(", "createZDCPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K" ]

[]

[ "<s>", "bool", "ARMFrameInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "PushOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STMDB_UPD", ":", "ARM", "::", "STMDB_UPD", ";", "unsigned", "PushOneOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VSTMDDB_UPD", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea1Register", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea2Register", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "true", ",", "&", "isARMArea3Register", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM::t2STMDB_UPD", "ARM::STMDB_UPD", "ARM::t2STR_PRE", "ARM::STR_PRE", "ARM::VSTMDDB_UPD", "ARM", "ARM", "0", "ARM" ]

[]

[ "<s>", "int", "mips_const_insns", "(", "rtx", "x", ")", "{", "struct", "mips_integer_op", "codes", "[", "MIPS_MAX_INTEGER_OPS", "]", ";", "enum", "mips_symbol_type", "symbol_type", ";", "rtx", "offset", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "HIGH", ":", "if", "(", "!", "mips_symbolic_constant_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "SYMBOL_CONTEXT_LEA", ",", "&", "symbol_type", ")", "||", "!", "mips_split_p", "[", "symbol_type", "]", ")", "return", "0", ";", "return", "TARGET_MIPS16", "?", "4", ":", "1", ";", "case", "CONST_INT", ":", "if", "(", "TARGET_MIPS16", ")", "return", "(", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "0", ",", "255", ")", "?", "1", ":", "SMALL_OPERAND_UNSIGNED", "(", "INTVAL", "(", "x", ")", ")", "?", "2", ":", "IN_RANGE", "(", "-", "INTVAL", "(", "x", ")", ",", "0", ",", "255", ")", "?", "2", ":", "SMALL_OPERAND_UNSIGNED", "(", "-", "INTVAL", "(", "x", ")", ")", "?", "3", ":", "0", ")", ";", "return", "mips_build_integer", "(", "codes", ",", "INTVAL", "(", "x", ")", ")", ";", "case", "CONST_VECTOR", ":", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", "&&", "mips_const_vector_same_int_p", "(", "x", ",", "GET_MODE", "(", "x", ")", ",", "-", "512", ",", "511", ")", ")", "return", "1", ";", "case", "CONST_DOUBLE", ":", "return", "!", "TARGET_MIPS16", "&&", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", "?", "1", ":", "0", ";", "case", "CONST", ":", "if", "(", "CONST_GP_P", "(", "x", ")", ")", "return", "1", ";", "if", "(", "mips_symbolic_constant_p", "(", "x", ",", "SYMBOL_CONTEXT_LEA", ",", "&", "symbol_type", ")", ")", "return", "mips_symbol_insns", "(", "symbol_type", ",", "MAX_MACHINE_MODE", ")", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "0", ")", "{", "int", "n", "=", "mips_const_insns", "(", "x", ")", ";", "if", "(", "n", "!=", "0", ")", "{", "if", "(", "SMALL_INT", "(", "offset", ")", ")", "return", "n", "+", "1", ";", "else", "if", "(", "!", "targetm", ".", "cannot_force_const_mem", "(", "GET_MODE", "(", "x", ")", ",", "x", ")", ")", "return", "n", "+", "1", "+", "mips_build_integer", "(", "codes", ",", "INTVAL", "(", "offset", ")", ")", ";", "}", "}", "return", "0", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "mips_symbol_insns", "(", "mips_classify_symbol", "(", "x", ",", "SYMBOL_CONTEXT_LEA", ")", ",", "MAX_MACHINE_MODE", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Likewise", "for", "constant", "X", "." ]

[ "mips", "0", "0", "4", "1", "0", "255", "1", "2", "0", "255", "2", "3", "0", "512", "511", "1", "1", "0", "1", "0", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "Type", "*", "getType", "(", ")", "const", "{", "return", "Root", "->", "getType", "(", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "bool", "MOSInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "auto", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "isCompare", "(", ")", ")", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "auto", "FirstBR", "=", "I", "++", ";", "if", "(", "FirstBR", "->", "isPreISelOpcode", "(", ")", ")", "return", "true", ";", "TBB", "=", "getBranchDestBlock", "(", "*", "FirstBR", ")", ";", "if", "(", "!", "TBB", ")", "return", "true", ";", "if", "(", "FirstBR", "->", "isConditionalBranch", "(", ")", ")", "{", "Cond", ".", "push_back", "(", "FirstBR", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "FirstBR", "->", "getOperand", "(", "2", ")", ")", ";", "}", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "auto", "SecondBR", "=", "I", "++", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "return", "true", ";", "if", "(", "!", "SecondBR", "->", "isUnconditionalBranch", "(", ")", "||", "SecondBR", "->", "isPreISelOpcode", "(", ")", ")", "return", "true", ";", "FBB", "=", "getBranchDestBlock", "(", "*", "SecondBR", ")", ";", "if", "(", "!", "FBB", ")", "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", "." ]

[ "MOS", "MOS", "1", "2" ]

[]

[ "<s>", "bool", "compact_sda_memory_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "bool", "short_p", ")", "{", "rtx", "addr", ";", "int", "size", ";", "int", "align", "=", "0", ";", "int", "mask", "=", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "legitimate_small_data_address_p", "(", "addr", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "!", "short_p", "||", "size", "==", "1", ")", "return", "true", ";", "align", "=", "get_symbol_alignment", "(", "addr", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "mask", "=", "1", ";", "break", ";", "default", ":", "mask", "=", "3", ";", "break", ";", "}", "if", "(", "align", "&&", "(", "(", "align", "&", "mask", ")", "==", "0", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "volatile", "cache", "option", "still", "to", "be", "handled", "." ]

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

[]

[ "<s>", "static", "int", "alpha_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "dep_insn_type", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "!=", "0", ")", "return", "cost", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", "||", "recog_memoized", "(", "dep_insn", ")", "<", "0", ")", "return", "cost", ";", "dep_insn_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "if", "(", "dep_insn_type", "==", "TYPE_ILD", "||", "dep_insn_type", "==", "TYPE_FLD", "||", "dep_insn_type", "==", "TYPE_LDSYM", ")", "cost", "+=", "alpha_memory_latency", "-", "1", ";", "return", "cost", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "." ]

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

[]

[ "<s>", "TargetTransformInfo", "BPFTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "BPFTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ",", "MFI", ")", "||", "!", "needsSPWriteback", "(", "MF", ",", "MFI", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SPReg", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "InsertAddr", "=", "InsertPt", ";", "if", "(", "StackSize", ")", "{", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "unsigned", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "InsertAddr", "=", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "SPReg", ")", ".", "addReg", "(", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "else", "{", "SPReg", "=", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ";", "}", "writeSPToMemory", "(", "SPReg", ",", "MF", ",", "MBB", ",", "InsertAddr", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::FP32", "WebAssembly::SP32" ]

[]

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

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

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

[]

[ "<s>", "void", "PPCTTI", "::", "getUnrollingPreferences", "(", "const", "Function", "*", "F", ",", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "if", "(", "TM", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", "F", ")", ".", "getDarwinDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "}", "TargetTransformInfo", "::", "getUnrollingPreferences", "(", "F", ",", "L", ",", "UP", ")", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_A2" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI annotate control flow\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI annotate control flow\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "AMDGPULateCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "for", "(", "Instruction", "&", "I", ":", "llvm", "::", "make_early_inc_range", "(", "BB", ")", ")", "Changed", "|=", "visit", "(", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "HexagonGenInsert", "::", "removeDeadCode", "(", "MachineDomTreeNode", "*", "N", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "DTN", ":", "children", "<", "MachineDomTreeNode", "*", ">", "(", "N", ")", ")", "Changed", "|=", "removeDeadCode", "(", "DTN", ")", ";", "MachineBasicBlock", "*", "B", "=", "N", "->", "getBlock", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "auto", "I", "=", "B", "->", "rbegin", "(", ")", ",", "E", "=", "B", "->", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Instrs", ".", "push_back", "(", "&", "*", "I", ")", ";", "for", "(", "auto", "I", "=", "Instrs", ".", "begin", "(", ")", ",", "E", "=", "Instrs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "*", "I", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LIFETIME_START", "||", "Opc", "==", "TargetOpcode", "::", "LIFETIME_END", ")", "continue", ";", "bool", "Store", "=", "false", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "||", "!", "MI", "->", "isSafeToMove", "(", "nullptr", ",", "Store", ")", ")", "continue", ";", "bool", "AllDead", "=", "true", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "Regs", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "R", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "R", ".", "isVirtual", "(", ")", "||", "!", "MRI", "->", "use_nodbg_empty", "(", "R", ")", ")", "{", "AllDead", "=", "false", ";", "break", ";", "}", "Regs", ".", "push_back", "(", "R", ")", ";", "}", "if", "(", "!", "AllDead", ")", "continue", ";", "B", "->", "erase", "(", "MI", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "N", "=", "Regs", ".", "size", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "MRI", "->", "markUsesInDebugValueAsUndef", "(", "Regs", "[", "I", "]", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

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

[]

[ "<s>", "static", "rtx", "gen_frame_mem_offset", "(", "enum", "machine_mode", "mode", ",", "rtx", "reg", ",", "int", "offset", ")", "{", "rtx", "int_rtx", ",", "offset_rtx", ";", "int_rtx", "=", "GEN_INT", "(", "offset", ")", ";", "if", "(", "(", "TARGET_SPE_ABI", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "mode", "==", "DFmode", ")", ")", "{", "offset_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIXED_SCRATCH", ")", ";", "emit_move_insn", "(", "offset_rtx", ",", "int_rtx", ")", ";", "}", "else", "offset_rtx", "=", "int_rtx", ";", "return", "gen_rtx_MEM", "(", "mode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "reg", ",", "offset_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "offset", "memory", "reference", "suitable", "for", "a", "frame", "store", ",", "while", "converting", "to", "a", "valid", "addressing", "mode", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "X86ATTAsmParser", "::", "ParseInstruction", "(", "const", "StringRef", "&", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "StringRef", "PatchedName", "=", "StringSwitch", "<", "StringRef", ">", "(", "Name", ")", ".", "Case", "(", "\"sal\"", ",", "\"shl\"", ")", ".", "Case", "(", "\"salb\"", ",", "\"shlb\"", ")", ".", "Case", "(", "\"sall\"", ",", "\"shll\"", ")", ".", "Case", "(", "\"salq\"", ",", "\"shlq\"", ")", ".", "Case", "(", "\"salw\"", ",", "\"shlw\"", ")", ".", "Case", "(", "\"repe\"", ",", "\"rep\"", ")", ".", "Case", "(", "\"repz\"", ",", "\"rep\"", ")", ".", "Case", "(", "\"repnz\"", ",", "\"repne\"", ")", ".", "Default", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "X86Operand", "::", "CreateToken", "(", "PatchedName", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Star", ")", ")", "{", "SMLoc", "Loc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "X86Operand", "::", "CreateToken", "(", "\"*\"", ",", "Loc", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "if", "(", "X86Operand", "*", "Op", "=", "ParseOperand", "(", ")", ")", "Operands", ".", "push_back", "(", "Op", ")", ";", "else", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "X86Operand", "*", "Op", "=", "ParseOperand", "(", ")", ")", "Operands", ".", "push_back", "(", "Op", ")", ";", "else", "return", "true", ";", "}", "}", "if", "(", "(", "Name", ".", "startswith", "(", "\"shr\"", ")", "||", "Name", ".", "startswith", "(", "\"sar\"", ")", "||", "Name", ".", "startswith", "(", "\"shl\"", ")", ")", "&&", "Operands", ".", "size", "(", ")", "==", "3", "&&", "static_cast", "<", "X86Operand", "*", ">", "(", "Operands", "[", "1", "]", ")", "->", "isImm", "(", ")", "&&", "isa", "<", "MCConstantExpr", ">", "(", "static_cast", "<", "X86Operand", "*", ">", "(", "Operands", "[", "1", "]", ")", "->", "getImm", "(", ")", ")", "&&", "cast", "<", "MCConstantExpr", ">", "(", "static_cast", "<", "X86Operand", "*", ">", "(", "Operands", "[", "1", "]", ")", "->", "getImm", "(", ")", ")", "->", "getValue", "(", ")", "==", "1", ")", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", "+", "1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "X86", "X86", "\"sal\"", "\"shl\"", "\"salb\"", "\"shlb\"", "\"sall\"", "\"shll\"", "\"salq\"", "\"shlq\"", "\"salw\"", "\"shlw\"", "\"repe\"", "\"rep\"", "\"repz\"", "\"rep\"", "\"repnz\"", "\"repne\"", "X86Operand::CreateToken", "X86Operand::CreateToken", "\"*\"", "X86", "X86", "\"shr\"", "\"sar\"", "\"shl\"", "3", "X86", "1", "X86", "1", "X86", "1", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "output_condmove_single", "(", "rtx", "operands", "[", "]", ",", "rtx", "insn", ")", "{", "rtx", "dest", "=", "operands", "[", "2", "]", ";", "rtx", "src", "=", "operands", "[", "3", "]", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", "{", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "\"cmov %z3, %2, %1, %e0\"", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "return", "\"cmovfg %3, %2, %1, %e0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "QImode", ":", "return", "\"cldsb%I3%U3 %M3, %2, %1, %e0\"", ";", "case", "HImode", ":", "return", "\"cldsh%I3%U3 %M3, %2, %1, %e0\"", ";", "case", "SImode", ":", "case", "SFmode", ":", "return", "\"cld%I3%U3 %M3, %2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "\"cmov %., %2, %1, %e0\"", ";", "}", "else", "if", "(", "FPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "\"cmovgf %3, %2, %1, %e0\"", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "TARGET_HARD_FLOAT", ")", "return", "\"cfmovs %3,%2,%1,%e0\"", ";", "else", "return", "\"cmor %3, %3, %2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", "return", "\"cldf%I3%U3 %M3, %2, %1, %e0\"", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "\"cmovgf %., %2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "QImode", ":", "return", "\"cstb%I2%U2 %3, %M2, %1, %e0\"", ";", "case", "HImode", ":", "return", "\"csth%I2%U2 %3, %M2, %1, %e0\"", ";", "case", "SImode", ":", "case", "SFmode", ":", "return", "\"cst%I2%U2 %3, %M2, %1, %e0\"", ";", "}", "}", "else", "if", "(", "FPR_P", "(", "src_regno", ")", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", ")", "return", "\"cstf%I2%U2 %3, %M2, %1, %e0\"", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "QImode", ":", "return", "\"cstb%I2%U2 %., %M2, %1, %e0\"", ";", "case", "HImode", ":", "return", "\"csth%I2%U2 %., %M2, %1, %e0\"", ";", "case", "SImode", ":", "case", "SFmode", ":", "return", "\"cst%I2%U2 %., %M2, %1, %e0\"", ";", "}", "}", "}", "fatal_insn", "(", "\"bad output_condmove_single operand\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "output", "a", "single", "word", "conditional", "move", ".", "Operand0", "--", "EQ/NE", "of", "ccr", "register", "and", "0", "Operand1", "--", "CCR", "register", "Operand2", "--", "destination", "Operand3", "--", "source" ]

[ "frv", "2", "3", "\"cmov %z3, %2, %1, %e0\"", "\"cmovfg %3, %2, %1, %e0\"", "\"cldsb%I3%U3 %M3, %2, %1, %e0\"", "\"cldsh%I3%U3 %M3, %2, %1, %e0\"", "\"cld%I3%U3 %M3, %2, %1, %e0\"", "\"cmov %., %2, %1, %e0\"", "\"cmovgf %3, %2, %1, %e0\"", "\"cfmovs %3,%2,%1,%e0\"", "\"cmor %3, %3, %2, %1, %e0\"", "\"cldf%I3%U3 %M3, %2, %1, %e0\"", "\"cmovgf %., %2, %1, %e0\"", "\"cstb%I2%U2 %3, %M2, %1, %e0\"", "\"csth%I2%U2 %3, %M2, %1, %e0\"", "\"cst%I2%U2 %3, %M2, %1, %e0\"", "\"cstf%I2%U2 %3, %M2, %1, %e0\"", "\"cstb%I2%U2 %., %M2, %1, %e0\"", "\"csth%I2%U2 %., %M2, %1, %e0\"", "\"cst%I2%U2 %., %M2, %1, %e0\"", "\"bad output_condmove_single operand\"", "\"\"" ]

[]

[ "<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVSZX_RR", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "isSigned", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to \"", ")", ";", "unsigned", "Move", ";", "if", "(", "MVTDst", "==", "MVT", "::", "i16", ")", "{", "Move", "=", "M680x0", "::", "MOV16rr", ";", "}", "else", "{", "Move", "=", "M680x0", "::", "MOV32rr", ";", "}", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Dst", "!=", "Src", "&&", "\"You cannot use the same Regs with MOVSX_RR\"", ")", ";", "auto", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "RCDst", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Dst", ",", "MVTDst", ")", ";", "auto", "RCSrc", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Src", ",", "MVTSrc", ")", ";", "assert", "(", "RCDst", "&&", "RCSrc", "&&", "\"Wrong use of MOVSX_RR\"", ")", ";", "assert", "(", "RCDst", "!=", "RCSrc", "&&", "\"You cannot use the same Reg Classes with MOVSX_RR\"", ")", ";", "unsigned", "SSrc", "=", "RI", ".", "getMatchingMegaReg", "(", "Src", ",", "RCDst", ")", ";", "assert", "(", "SSrc", "&&", "\"No viable MEGA register available\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Dst", "!=", "SSrc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Move and \"", "<<", "'\\n'", ")", ";", "BuildMI", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "get", "(", "Move", ")", ",", "Dst", ")", ".", "addReg", "(", "SSrc", ")", ";", "}", "if", "(", "isSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Move", "from", "register", "and", "extend", "." ]

[ "M680x0", "M680x0", "\"Expand \"", "\" to \"", "MVT::i16", "M680x0::MOV16rr", "M680x0::MOV32rr", "0", "1", "\"You cannot use the same Regs with MOVSX_RR\"", "\"Wrong use of MOVSX_RR\"", "\"You cannot use the same Reg Classes with MOVSX_RR\"", "\"No viable MEGA register available\"", "\"Move and \"", "\"Sign Extend\"", "\"Zero Extend\"" ]

[]

[ "<s>", "bool", "AArch64LowerHomogeneousPrologEpilog", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "skipModule", "(", "M", ")", ")", "return", "false", ";", "MachineModuleInfo", "*", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ".", "getMMI", "(", ")", ";", "return", "AArch64LowerHomogeneousPE", "(", "&", "M", ",", "MMI", ")", ".", "run", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "mayStore", "(", ")", "const", "{", "return", "Store", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "could", "possibly", "modify", "memory", "." ]

[ "Hexagon" ]

[]

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

[ "Return", "the", "number", "of", "bytes", "in", "the", "encoding", "of", "this", "instruction", ",", "or", "zero", "if", "the", "encoding", "size", "can", "not", "be", "known", "from", "the", "opcode", "." ]

[ "PIC16" ]

[]

[ "<s>", "void", "rs6000_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "enum", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "0", ",", "one_var", "=", "-", "1", ";", "bool", "all_same", "=", "true", ",", "all_const_zero", "=", "true", ";", "rtx", "x", ",", "mem", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "x", ")", ")", "++", "n_var", ",", "one_var", "=", "i", ";", "else", "if", "(", "x", "!=", "CONST0_RTX", "(", "inner_mode", ")", ")", "all_const_zero", "=", "false", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "if", "(", "mode", "!=", "V4SFmode", "&&", "all_const_zero", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_XOR", "(", "mode", ",", "target", ",", "target", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "mode", "!=", "V4SFmode", "&&", "easy_vector_constant", "(", "vals", ",", "mode", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "vals", ")", ")", ";", "return", ";", "}", "else", "if", "(", "all_same", ")", ";", "else", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ";", "return", ";", "}", "}", "if", "(", "all_same", ")", "{", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "inner_mode", ")", ",", "0", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_LVE", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "mem", ")", ",", "x", ")", ")", ")", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "inner_mode", ",", "target", ",", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "x", ")", ")", ")", ";", "return", ";", "}", "if", "(", "n_var", "==", "1", ")", "{", "rtx", "copy", "=", "copy_rtx", "(", "vals", ")", ";", "XVECEXP", "(", "copy", ",", "0", ",", "one_var", ")", "=", "XVECEXP", "(", "vals", ",", "0", ",", "(", "one_var", "+", "1", ")", "%", "n_elts", ")", ";", "rs6000_expand_vector_init", "(", "target", ",", "copy", ")", ";", "rs6000_expand_vector_set", "(", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "one_var", ")", ",", "one_var", ")", ";", "return", ";", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ",", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "i", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ")", ";", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "}", "</s>" ]

[ "Initialize", "vector", "TARGET", "to", "VALS", "." ]

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

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_emit_allocate_stack", "(", "HOST_WIDE_INT", "size", ",", "rtx", "copy_reg", ",", "int", "copy_off", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "stack_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "rtx", "todec", "=", "gen_int_mode", "(", "-", "size", ",", "Pmode", ")", ";", "if", "(", "INTVAL", "(", "todec", ")", "!=", "-", "size", ")", "{", "warning", "(", "0", ",", "\"stack frame too large\"", ")", ";", "emit_insn", "(", "gen_trap", "(", ")", ")", ";", "return", "0", ";", "}", "if", "(", "crtl", "->", "limit_stack", ")", "{", "if", "(", "REG_P", "(", "stack_limit_rtx", ")", "&&", "REGNO", "(", "stack_limit_rtx", ")", ">", "1", "&&", "REGNO", "(", "stack_limit_rtx", ")", "<=", "31", ")", "{", "rtx_insn", "*", "insn", "=", "gen_add3_insn", "(", "tmp_reg", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ";", "gcc_assert", "(", "insn", ")", ";", "emit_insn", "(", "insn", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "tmp_reg", ",", "const0_rtx", ")", ")", ";", "}", "else", "if", "(", "SYMBOL_REF_P", "(", "stack_limit_rtx", ")", "&&", "TARGET_32BIT", "&&", "DEFAULT_ABI", "==", "ABI_V4", "&&", "!", "flag_pic", ")", "{", "rtx", "toload", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_limit_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "rtx", "r11_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "11", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "r11_reg", ")", ";", "emit_insn", "(", "gen_elf_high", "(", "r11_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_elf_low", "(", "r11_reg", ",", "r11_reg", ",", "toload", ")", ")", ";", "emit_insn", "(", "gen_cond_trap", "(", "LTU", ",", "stack_reg", ",", "r11_reg", ",", "const0_rtx", ")", ")", ";", "emit_move_insn", "(", "r11_reg", ",", "tmp_reg", ")", ";", "}", "else", "warning", "(", "0", ",", "\"stack limit expression is not supported\"", ")", ";", "}", "if", "(", "flag_stack_clash_protection", ")", "{", "if", "(", "size", "<", "get_stack_clash_protection_guard_size", "(", ")", ")", "dump_stack_clash_frame_info", "(", "NO_PROBE_SMALL_FRAME", ",", "true", ")", ";", "else", "{", "rtx_insn", "*", "insn", "=", "rs6000_emit_probe_stack_range_stack_clash", "(", "size", ",", "copy_reg", ")", ";", "if", "(", "copy_reg", "&&", "copy_off", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "copy_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "return", "insn", ";", "}", "}", "if", "(", "copy_reg", ")", "{", "if", "(", "copy_off", "!=", "0", ")", "emit_insn", "(", "gen_add3_insn", "(", "copy_reg", ",", "stack_reg", ",", "GEN_INT", "(", "copy_off", ")", ")", ")", ";", "else", "emit_move_insn", "(", "copy_reg", ",", "stack_reg", ")", ";", "}", "insn", "=", "rs6000_emit_allocate_stack_1", "(", "size", ",", "stack_reg", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Emit", "the", "correct", "code", "for", "allocating", "stack", "space", ",", "as", "insns", ".", "If", "COPY_R12", ",", "make", "sure", "a", "copy", "of", "the", "old", "frame", "is", "left", "in", "r12", ".", "The", "generated", "code", "may", "use", "hard", "register", "0", "as", "a", "temporary", "." ]

[ "rs6000", "0", "0", "\"stack frame too large\"", "0", "1", "31", "11", "0", "\"stack limit expression is not supported\"", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "bool", "UseSplitPush", "=", "STI", ".", "splitFramePushPop", "(", "*", "MF", ")", ";", "const", "MCPhysReg", "*", "RegList", "=", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SaveList", ":", "(", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SaveList", ":", "CSR_AAPCS_SaveList", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SaveList", ":", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "if", "(", "STI", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "F", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "{", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "return", "CSR_iOS_SwiftError_SaveList", ";", "return", "UseSplitPush", "?", "CSR_AAPCS_SplitPush_SwiftError_SaveList", ":", "CSR_AAPCS_SwiftError_SaveList", ";", "}", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_iOS_CXX_TLS_PE_SaveList", ":", "CSR_iOS_CXX_TLS_SaveList", ";", "return", "RegList", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"", "ARM" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_unspec_cond_code", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "NE", ":", "return", "UNSPEC_COND_FCMNE", ";", "case", "EQ", ":", "return", "UNSPEC_COND_FCMEQ", ";", "case", "LT", ":", "return", "UNSPEC_COND_FCMLT", ";", "case", "GT", ":", "return", "UNSPEC_COND_FCMGT", ";", "case", "LE", ":", "return", "UNSPEC_COND_FCMLE", ";", "case", "GE", ":", "return", "UNSPEC_COND_FCMGE", ";", "case", "UNORDERED", ":", "return", "UNSPEC_COND_FCMUO", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "UNSPEC_COND_", "*", "code", "for", "comparison", "CODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "tilepro_can_use_return_insn_p", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "cfun", "->", "static_chain_decl", "==", "0", "&&", "compute_total_frame_size", "(", ")", "==", "0", "&&", "tilepro_current_function_is_leaf", "(", ")", "&&", "!", "crtl", "->", "profile", "&&", "!", "df_regs_ever_live_p", "(", "TILEPRO_LINK_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "tilepro", "0", "0" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget7OpValueMM", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValueMM expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MICROMIPS_PC7_S1", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTarget7OpValueMM", "-", "Return", "binary", "encoding", "of", "the", "microMIPS", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "1", "\"getBranchTargetOpValueMM expects only expressions or immediates\"", "0", "Mips::fixup_MICROMIPS_PC7_S1", "0" ]

[]

[ "<s>", "void", "PPCXCOFFStreamer", "::", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "PPCMCCodeEmitter", "*", "Emitter", "=", "static_cast", "<", "PPCMCCodeEmitter", "*", ">", "(", "getAssembler", "(", ")", ".", "getEmitterPtr", "(", ")", ")", ";", "if", "(", "!", "Emitter", "->", "isPrefixedInstruction", "(", "Inst", ")", ")", "{", "MCXCOFFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "emitPrefixedInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "aarch64_bti_j_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "return", "GET_CODE", "(", "pat", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "UNSPECV_BTI_J", ";", "}", "</s>" ]

[ "Check", "if", "INSN", "is", "a", "BTI", "J", "insn", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "static", "bool", "arm_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "target_option_current_node", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ";", "struct", "cl_target_option", "*", "cur_opt", ";", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "cur_tree", "=", "arm_valid_target_attribute_tree", "(", "args", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "if", "(", "cur_tree", "==", "NULL_TREE", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ")", ";", "return", "false", ";", "}", "target_option_current_node", "=", "cur_tree", ";", "arm_configure_build_target", "(", "&", "arm_active_target", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ",", "&", "global_options_set", ",", "false", ")", ";", "}", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "gcc_assert", "(", "prev_opt", ")", ";", "gcc_assert", "(", "cur_opt", ")", ";", "if", "(", "cur_opt", "!=", "prev_opt", ")", "{", "cpp_options", "*", "cpp_opts", "=", "cpp_get_options", "(", "parse_in", ")", ";", "unsigned", "char", "saved_warn_unused_macros", "=", "cpp_opts", "->", "warn_unused_macros", ";", "cpp_opts", "->", "warn_unused_macros", "=", "0", ";", "gcc_assert", "(", "cur_opt", "->", "x_target_flags", "==", "target_flags", ")", ";", "tree", "acond_macro", "=", "get_identifier", "(", "\"__ARM_NEON_FP\"", ")", ";", "C_CPP_HASHNODE", "(", "acond_macro", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "acond_macro", "=", "get_identifier", "(", "\"__ARM_FP\"", ")", ";", "C_CPP_HASHNODE", "(", "acond_macro", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "acond_macro", "=", "get_identifier", "(", "\"__ARM_FEATURE_LDREX\"", ")", ";", "C_CPP_HASHNODE", "(", "acond_macro", ")", "->", "flags", "|=", "NODE_CONDITIONAL", ";", "arm_cpu_builtins", "(", "parse_in", ")", ";", "cpp_opts", "->", "warn_unused_macros", "=", "saved_warn_unused_macros", ";", "arm_reset_previous_fndecl", "(", ")", ";", "if", "(", "cur_tree", "==", "target_option_default_node", ")", "save_restore_target_globals", "(", "cur_tree", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "arch", "custom", "mode", "state", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "arm", "0", "\"__ARM_NEON_FP\"", "\"__ARM_FP\"", "\"__ARM_FEATURE_LDREX\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AArch64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "Align", ")", ";", "if", "(", "!", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "CalleePopAmount", "==", "0", ")", "{", "assert", "(", "Amount", ">", "-", "0xffffff", "&&", "Amount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "Amount", ",", "TII", ")", ";", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "assert", "(", "CalleePopAmount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "-", "CalleePopAmount", ",", "TII", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "1", "0", "0", "0", "0xffffff", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP", "0", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "static", "void", "*", "ix86_init_cost", "(", "class", "loop", "*", ")", "{", "unsigned", "*", "cost", "=", "XNEWVEC", "(", "unsigned", ",", "3", ")", ";", "cost", "[", "vect_prologue", "]", "=", "cost", "[", "vect_body", "]", "=", "cost", "[", "vect_epilogue", "]", "=", "0", ";", "return", "cost", ";", "}", "</s>" ]

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

[ "i386", "3", "0" ]

[]

[ "<s>", "bool", "AArch64LowerHomogeneousPE", "::", "run", "(", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "F", ":", "*", "M", ")", "{", "if", "(", "F", ".", "empty", "(", ")", ")", "continue", ";", "MachineFunction", "*", "MF", "=", "MMI", "->", "getMachineFunction", "(", "F", ")", ";", "if", "(", "!", "MF", ")", "continue", ";", "Changed", "|=", "runOnMachineFunction", "(", "*", "MF", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "RISCVSubtarget", "::", "getRegBankInfo", "(", ")", "const", "{", "return", "RegBankInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "const", "J2Subtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "J2", "J2" ]

[]

[ "<s>", "static", "bool", "aarch64_sve_pred_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "TARGET_SVE", "&&", "(", "mode", "==", "VNx16BImode", "||", "mode", "==", "VNx8BImode", "||", "mode", "==", "VNx4BImode", "||", "mode", "==", "VNx2BImode", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "an", "SVE", "predicate", "mode", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "LDR", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "DPRRegisterClass", "||", "RC", "==", "ARM", "::", "DPR_VFP2RegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FLDD", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "ARM", "::", "SPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "FLDS", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "RC", "==", "ARM", "::", "QPRRegisterClass", "&&", "\"Unknown regclass!\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "VLDRQ", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegisterClass", "ARM::LDR", "0", "0", "ARM::DPRRegisterClass", "ARM::DPR_VFP2RegisterClass", "ARM::FLDD", "0", "ARM::SPRRegisterClass", "ARM::FLDS", "0", "ARM::QPRRegisterClass", "\"Unknown regclass!\"", "ARM::VLDRQ", "0" ]

[]

[ "<s>", "const", "Region", "*", "getRegionFor", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "{", "const", "auto", "*", "ML", "=", "MLI", ".", "getLoopFor", "(", "MBB", ")", ";", "const", "auto", "*", "WE", "=", "WEI", ".", "getExceptionFor", "(", "MBB", ")", ";", "if", "(", "!", "ML", "&&", "!", "WE", ")", "return", "nullptr", ";", "if", "(", "(", "ML", "&&", "!", "WE", ")", "||", "(", "ML", "&&", "WE", "&&", "ML", "->", "getNumBlocks", "(", ")", "<", "WE", "->", "getNumBlocks", "(", ")", ")", ")", "{", "if", "(", "LoopMap", ".", "count", "(", "ML", ")", ")", "return", "LoopMap", "[", "ML", "]", ".", "get", "(", ")", ";", "LoopMap", "[", "ML", "]", "=", "llvm", "::", "make_unique", "<", "ConcreteRegion", "<", "MachineLoop", ">>", "(", "ML", ")", ";", "return", "LoopMap", "[", "ML", "]", ".", "get", "(", ")", ";", "}", "else", "{", "if", "(", "ExceptionMap", ".", "count", "(", "WE", ")", ")", "return", "ExceptionMap", "[", "WE", "]", ".", "get", "(", ")", ";", "ExceptionMap", "[", "WE", "]", "=", "llvm", "::", "make_unique", "<", "ConcreteRegion", "<", "WebAssemblyException", ">>", "(", "WE", ")", ";", "return", "ExceptionMap", "[", "WE", "]", ".", "get", "(", ")", ";", "}", "}", "</s>" ]

[ "Get", "the", "smallest", "region", "that", "contains", "a", "BasicBlock", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isSimpleMove", "(", "MI", ",", "FrameIndex", ",", "RISCVII", "::", "SimpleLoad", ")", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "RISCV", "RISCV", "RISCVII::SimpleLoad" ]

[]

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

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

[ "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "enum", "reg_class", "pdp11_regno_reg_class", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "NOTSP_REG", ";", "else", "if", "(", "regno", "==", "CC_REGNUM", "||", "regno", "==", "FCC_REGNUM", ")", "return", "CC_REGS", ";", "else", "if", "(", "regno", ">", "AC3_REGNUM", ")", "return", "NO_LOAD_FPU_REGS", ";", "else", "if", "(", "regno", ">=", "AC0_REGNUM", ")", "return", "LOAD_FPU_REGS", ";", "else", "if", "(", "regno", "==", "6", ")", "return", "NOTR0_REG", ";", "else", "if", "(", "regno", "<", "6", ")", "return", "NOTSP_REG", ";", "else", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "class", "number", "of", "the", "smallest", "class", "containing", "reg", "number", "REGNO", "." ]

[ "pdp11", "6", "6" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getMinValue", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "-", "1", "<<", "(", "bits", "-", "1", ")", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "minimal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1", "1", "0" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "bool", "HasStdExtC", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "if", "(", "(", "Count", "%", "MinNopLen", ")", "!=", "0", ")", "return", "false", ";", "uint64_t", "Nop32Count", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "Nop32Count", ";", "i", "!=", "0", ";", "--", "i", ")", "OS", ".", "write", "(", "\"\\x13\\0\\0\\0\"", ",", "4", ")", ";", "if", "(", "HasStdExtC", ")", "{", "uint64_t", "Nop16Count", "=", "(", "Count", "-", "Nop32Count", "*", "4", ")", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "Nop16Count", ";", "i", "!=", "0", ";", "--", "i", ")", "OS", ".", "write", "(", "\"\\x01\\0\"", ",", "2", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureStdExtC", "2", "4", "0", "4", "0", "\"\\x13\\0\\0\\0\"", "4", "4", "2", "0", "\"\\x01\\0\"", "2" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Cpu0", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Cpu0_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Cpu0_REL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Cpu0_24\"", ",", "0", ",", "24", ",", "0", "}", ",", "{", "\"fixup_Cpu0_HI16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_LO16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_GPREL16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_LITERAL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_GOT_Global\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_GOT_Local\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_PC24\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Cpu0_CALL24\"", ",", "0", ",", "24", ",", "0", "}", ",", "{", "\"fixup_Cpu0_GPREL32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Cpu0_SHIFT5\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Cpu0_SHIFT6\"", ",", "6", ",", "5", ",", "0", "}", ",", "{", "\"fixup_Cpu0_64\"", ",", "0", ",", "64", ",", "0", "}", ",", "{", "\"fixup_Cpu0_TLSGD\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_GOTTPREL\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_TPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_TPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_TLSLDM\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_DTPREL_HI\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_DTPREL_LO\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_Cpu0_Branch_PCRel\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0::NumTargetFixupKinds", "\"fixup_Cpu0_16\"", "0", "16", "0", "\"fixup_Cpu0_32\"", "0", "32", "0", "\"fixup_Cpu0_REL32\"", "0", "32", "0", "\"fixup_Cpu0_24\"", "0", "24", "0", "\"fixup_Cpu0_HI16\"", "0", "16", "0", "\"fixup_Cpu0_LO16\"", "0", "16", "0", "\"fixup_Cpu0_GPREL16\"", "0", "16", "0", "\"fixup_Cpu0_LITERAL\"", "0", "16", "0", "\"fixup_Cpu0_GOT_Global\"", "0", "16", "0", "\"fixup_Cpu0_GOT_Local\"", "0", "16", "0", "\"fixup_Cpu0_PC24\"", "0", "24", "\"fixup_Cpu0_CALL24\"", "0", "24", "0", "\"fixup_Cpu0_GPREL32\"", "0", "32", "0", "\"fixup_Cpu0_SHIFT5\"", "6", "5", "0", "\"fixup_Cpu0_SHIFT6\"", "6", "5", "0", "\"fixup_Cpu0_64\"", "0", "64", "0", "\"fixup_Cpu0_TLSGD\"", "0", "16", "0", "\"fixup_Cpu0_GOTTPREL\"", "0", "16", "0", "\"fixup_Cpu0_TPREL_HI\"", "0", "16", "0", "\"fixup_Cpu0_TPREL_LO\"", "0", "16", "0", "\"fixup_Cpu0_TLSLDM\"", "0", "16", "0", "\"fixup_Cpu0_DTPREL_HI\"", "0", "16", "0", "\"fixup_Cpu0_DTPREL_LO\"", "0", "16", "0", "\"fixup_Cpu0_Branch_PCRel\"", "0", "16", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "override", "{", "unsigned", "NumBytes", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ".", "TargetSize", "/", "8", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "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", "." ]

[ "AArch64", "8", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "inline", "bool", "s390_preserve_gpr_arg_in_range_p", "(", "int", "first", ",", "int", "last", ")", "{", "int", "num_arg_regs", "=", "MIN", "(", "crtl", "->", "args", ".", "info", ".", "gprs", "+", "cfun", "->", "va_list_gpr_size", ",", "GP_ARG_NUM_REG", ")", ";", "return", "(", "num_arg_regs", "&&", "s390_preserve_args_p", "&&", "first", "<=", "GPR2_REGNUM", "+", "num_arg_regs", "-", "1", "&&", "last", ">=", "GPR2_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "any", "of", "the", "registers", "in", "range", "[", "FIRST", ",", "LAST", "]", "is", "saved", "because", "of", "-mpreserve-args", "." ]

[ "s390", "1" ]

[]

[ "<s>", "const", "uint16_t", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_SaveList", ":", "CSR_Darwin64_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_SaveList", ":", "CSR_Darwin32_SaveList", ")", ";", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR464_Altivec_SaveList", ":", "CSR_SVR464_SaveList", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_SaveList", ":", "CSR_SVR432_SaveList", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetMachine", "*", "TM", "=", "0", ")", "const", "{", "if", "(", "isReg", "(", ")", ")", "{", "OS", "<<", "PrintReg", "(", "getReg", "(", ")", ")", ";", "}", "if", "(", "isImm", "(", ")", ")", "{", "OS", "<<", "getImm", "(", ")", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "PowerPC", "0" ]

[]

[ "<s>", "bool", "AArch64RedundantCopyElimination", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Changed", "|=", "optimizeCopy", "(", "&", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ";", "return", "createSparcELFObjectWriter", "(", "OS", ",", "is64Bit", "(", ")", ",", "OSABI", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "unsigned", "MipsCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "MachineOperand", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

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

[]

[ "<s>", "static", "bool", "riscv_compressed_lw_offset_p", "(", "rtx", "x", ")", "{", "return", "(", "CONST_INT_P", "(", "x", ")", "&&", "(", "INTVAL", "(", "x", ")", "&", "3", ")", "==", "0", "&&", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "0", ",", "CSW_MAX_OFFSET", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "x", "is", "an", "unsigned", "5-bit", "immediate", "scaled", "by", "4", "." ]

[ "riscv", "3", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "MipsExprKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "changeSection", "(", "MCSection", "*", "Section", ",", "const", "MCExpr", "*", "Subsection", ")", "override", "{", "LastMappingSymbols", "[", "getPreviousSection", "(", ")", ".", "first", "]", "=", "LastEMS", ";", "LastEMS", "=", "LastMappingSymbols", ".", "lookup", "(", "Section", ")", ";", "MCELFStreamer", "::", "changeSection", "(", "Section", ",", "Subsection", ")", ";", "}", "</s>" ]

[ "Update", "streamer", "for", "a", "new", "active", "section", "." ]

[ "AArch64" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown SELECT_CC!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "case", "SP", "::", "SELECT_CC_QFP_ICC", ":", "return", "expandSelectCC", "(", "MI", ",", "BB", ",", "SP", "::", "BCOND", ")", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "case", "SP", "::", "SELECT_CC_QFP_FCC", ":", "return", "expandSelectCC", "(", "MI", ",", "BB", ",", "SP", "::", "FBCOND", ")", ";", "case", "SP", "::", "EH_SJLJ_SETJMP32ri", ":", "case", "SP", "::", "EH_SJLJ_SETJMP32rr", ":", "return", "emitEHSjLjSetJmp", "(", "MI", ",", "BB", ")", ";", "case", "SP", "::", "EH_SJLJ_LONGJMP32rr", ":", "case", "SP", "::", "EH_SJLJ_LONGJMP32ri", ":", "return", "emitEHSjLjLongJmp", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Unknown SELECT_CC!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::SELECT_CC_QFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::SELECT_CC_QFP_FCC", "SP::FBCOND", "SP::EH_SJLJ_SETJMP32ri", "SP::EH_SJLJ_SETJMP32rr", "SP::EH_SJLJ_LONGJMP32rr", "SP::EH_SJLJ_LONGJMP32ri" ]

[]

[ "<s>", "static", "tree", "altivec_build_resolved_builtin", "(", "tree", "*", "args", ",", "int", "n", ",", "const", "struct", "altivec_builtin_types", "*", "desc", ")", "{", "tree", "impl_fndecl", "=", "rs6000_builtin_decls", "[", "desc", "->", "overloaded_code", "]", ";", "tree", "ret_type", "=", "rs6000_builtin_type", "(", "desc", "->", "ret_type", ")", ";", "tree", "argtypes", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "impl_fndecl", ")", ")", ";", "tree", "arg_type", "[", "4", "]", ";", "tree", "call", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "arg_type", "[", "i", "]", "=", "TREE_VALUE", "(", "argtypes", ")", ",", "argtypes", "=", "TREE_CHAIN", "(", "argtypes", ")", ";", "if", "(", "n", "==", "3", "&&", "desc", "->", "code", "==", "ALTIVEC_BUILTIN_VEC_VCMPGE_P", "&&", "desc", "->", "overloaded_code", "!=", "ALTIVEC_BUILTIN_VCMPGEFP_P", "&&", "desc", "->", "overloaded_code", "!=", "VSX_BUILTIN_XVCMPGEDP_P", ")", "{", "std", "::", "swap", "(", "args", "[", "1", "]", ",", "args", "[", "2", "]", ")", ";", "std", "::", "swap", "(", "arg_type", "[", "1", "]", ",", "arg_type", "[", "2", "]", ")", ";", "args", "[", "0", "]", "=", "fold_build2", "(", "BIT_XOR_EXPR", ",", "TREE_TYPE", "(", "args", "[", "0", "]", ")", ",", "args", "[", "0", "]", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ")", ";", "}", "switch", "(", "n", ")", "{", "case", "0", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "0", ")", ";", "break", ";", "case", "1", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "1", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ")", ";", "break", ";", "case", "2", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "2", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ")", ";", "break", ";", "case", "3", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "3", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "2", "]", ",", "args", "[", "2", "]", ")", ")", ";", "break", ";", "case", "4", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "4", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "2", "]", ",", "args", "[", "2", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "3", "]", ",", "args", "[", "3", "]", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "fold_convert", "(", "ret_type", ",", "call", ")", ";", "}", "</s>" ]

[ "Build", "a", "tree", "for", "a", "function", "call", "to", "an", "Altivec", "non-overloaded", "builtin", ".", "The", "overloaded", "builtin", "that", "matched", "the", "types", "and", "args", "is", "described", "by", "DESC", ".", "The", "N", "arguments", "are", "given", "in", "ARGS", ",", "respectively", ".", "Actually", "the", "only", "thing", "it", "does", "is", "calling", "fold_convert", "on", "ARGS", ",", "with", "a", "small", "exception", "for", "vec_", "{", "all", ",", "any", "}", "_", "{", "ge", ",", "le", "}", "predicates", "." ]

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

[]

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

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

[ "arm" ]

[]

[ "<s>", "static", "bool", "aarch64_check_builtin_call", "(", "location_t", "loc", ",", "vec", "<", "location_t", ">", "arg_loc", ",", "tree", "fndecl", ",", "tree", "orig_fndecl", ",", "unsigned", "int", "nargs", ",", "tree", "*", "args", ")", "{", "unsigned", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "unsigned", "int", "subcode", "=", "code", ">>", "AARCH64_BUILTIN_SHIFT", ";", "switch", "(", "code", "&", "AARCH64_BUILTIN_CLASS", ")", "{", "case", "AARCH64_BUILTIN_GENERAL", ":", "return", "true", ";", "case", "AARCH64_BUILTIN_SVE", ":", "return", "aarch64_sve", "::", "check_builtin_call", "(", "loc", ",", "arg_loc", ",", "subcode", ",", "orig_fndecl", ",", "nargs", ",", "args", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CHECK_BUILTIN_CALL", "." ]

[ "aarch64", "aarch64_sve::check_builtin_call" ]

[]

[ "<s>", "static", "int", "ia64_unspec_may_trap_p", "(", "const_rtx", "x", ",", "unsigned", "flags", ")", "{", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_LDA", ":", "case", "UNSPEC_LDS", ":", "case", "UNSPEC_LDSA", ":", "case", "UNSPEC_LDCCLR", ":", "case", "UNSPEC_CHKACLR", ":", "case", "UNSPEC_CHKS", ":", "return", "may_trap_p_1", "(", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ",", "flags", ")", ";", "}", "return", "default_unspec_may_trap_p", "(", "x", ",", "flags", ")", ";", "}", "</s>" ]

[ "Implement", "targetm.unspec_may_trap_p", "hook", "." ]

[ "ia64", "1", "0", "0" ]

[]

[ "<s>", "void", "SparcPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSparcDelaySlotFillerPass", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "ignoreZeroFlag", "(", ")", ")", "{", "addPass", "(", "new", "IgnoreZeroFlag", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "performSDIVReplace", "(", ")", ")", "{", "addPass", "(", "new", "ReplaceSDIV", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "fixCallImmediates", "(", ")", ")", "{", "addPass", "(", "new", "FixCALL", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "fixFSMULD", "(", ")", ")", "{", "addPass", "(", "new", "FixFSMULD", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "replaceFMULS", "(", ")", ")", "{", "addPass", "(", "new", "ReplaceFMULS", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "preventRoundChange", "(", ")", ")", "{", "addPass", "(", "new", "PreventRoundChange", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "fixAllFDIVSQRT", "(", ")", ")", "{", "addPass", "(", "new", "FixAllFDIVSQRT", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "insertNOPsLoadStore", "(", ")", ")", "{", "addPass", "(", "new", "InsertNOPsLoadStore", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "insertNOPLoad", "(", ")", ")", "{", "addPass", "(", "new", "InsertNOPLoad", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "flushCacheLineSWAP", "(", ")", ")", "{", "addPass", "(", "new", "FlushCacheLineSWAP", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "if", "(", "this", "->", "getSparcTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "insertNOPDoublePrecision", "(", ")", ")", "{", "addPass", "(", "new", "InsertNOPDoublePrecision", "(", "getSparcTargetMachine", "(", ")", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

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

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

[ "arm", "16" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasModifiers", "(", "unsigned", "Opcode", ")", "const", "{", "return", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", "!=", "-", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "has", "any", "modifiers", "." ]

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

[]

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

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

[ "Cpu0", "Cpu0", "\";\"" ]

[]

[ "<s>", "std", "::", "string", "getName", "(", ")", "const", "{", "std", "::", "stringstream", "s", ";", "if", "(", "MBB", ")", "s", "<<", "MBB", "->", "getName", "(", ")", ".", "str", "(", ")", "<<", "\"[\"", "<<", "ID", "<<", "\"]\"", ";", "else", "{", "s", "<<", "\"header\"", "<<", "ID", ";", "}", "return", "s", ".", "str", "(", ")", ";", "}", "</s>" ]

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

[ "Patmos", "\"[\"", "\"]\"", "\"header\"" ]

[]

[ "<s>", "static", "void", "rs6000_parse_tls_size_option", "(", "void", ")", "{", "if", "(", "rs6000_tls_size_string", "==", "0", ")", "return", ";", "else", "if", "(", "strcmp", "(", "rs6000_tls_size_string", ",", "\"16\"", ")", "==", "0", ")", "rs6000_tls_size", "=", "16", ";", "else", "if", "(", "strcmp", "(", "rs6000_tls_size_string", ",", "\"32\"", ")", "==", "0", ")", "rs6000_tls_size", "=", "32", ";", "else", "if", "(", "strcmp", "(", "rs6000_tls_size_string", ",", "\"64\"", ")", "==", "0", ")", "rs6000_tls_size", "=", "64", ";", "else", "error", "(", "\"bad value %qs for -mtls-size switch\"", ",", "rs6000_tls_size_string", ")", ";", "}", "</s>" ]

[ "Validate", "and", "record", "the", "size", "specified", "with", "the", "-mtls-size", "option", "." ]

[ "rs6000", "0", "\"16\"", "0", "16", "\"32\"", "0", "32", "\"64\"", "0", "64", "\"bad value %qs for -mtls-size switch\"" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_load_psi_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", "CR_TAB", "\"ld %C0,%1\"", "CR_TAB", "\"ld __tmp_reg__,-%1\"", "CR_TAB", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", "CR_TAB", "\"ld %A0,%1\"", "CR_TAB", "\"mov %B0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "8", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"ld %A0,%1+\"", "CR_TAB", "\"ld %B0,%1+\"", "CR_TAB", "\"ld %C0,%1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "reg_dest", "!=", "reg_base", "-", "2", "&&", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "{", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "return", "\"\"", ";", "}", "}", "</s>" ]

[ "Handle", "loads", "of", "24-bit", "types", "from", "memory", "to", "register", "." ]

[ "avr", "0", "1", "0", "2", "\"ld %C0,%1\"", "\"ld __tmp_reg__,-%1\"", "1", "\"ld %A0,%1\"", "\"mov %B0,__tmp_reg__\"", "8", "\"ld %A0,%1+\"", "\"ld %B0,%1+\"", "\"ld %C0,%1\"", "3", "2", "2", "2", "\"\"" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_PPC", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "16", "PPC" ]

[]

[ "<s>", "bool", "MipsTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createMipsISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

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

[]

[ "<s>", "TargetTransformInfo", "DLXTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "DLXTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "DLX", "DLX", "DLX" ]

[]

[ "<s>", "bool", "GeneralShuffle", "::", "add", "(", "SDValue", "Op", ",", "unsigned", "Elem", ")", "{", "unsigned", "BytesPerElement", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", ")", ";", "EVT", "FromVT", "=", "Op", ".", "getNode", "(", ")", "?", "Op", ".", "getValueType", "(", ")", ":", "VT", ";", "unsigned", "FromBytesPerElement", "=", "FromVT", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", ")", ";", "if", "(", "FromBytesPerElement", "<", "BytesPerElement", ")", "return", "false", ";", "unsigned", "Byte", "=", "(", "(", "Elem", "*", "FromBytesPerElement", ")", "%", "SystemZ", "::", "VectorBytes", "+", "(", "FromBytesPerElement", "-", "BytesPerElement", ")", ")", ";", "while", "(", "Op", ".", "getNode", "(", ")", ")", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "Op", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "else", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "VECTOR_SHUFFLE", "&&", "Op", ".", "hasOneUse", "(", ")", ")", "{", "SmallVector", "<", "int", ",", "SystemZ", "::", "VectorBytes", ">", "OpBytes", ";", "getVPermMask", "(", "cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ")", ",", "OpBytes", ")", ";", "int", "NewByte", ";", "if", "(", "!", "getShuffleInput", "(", "OpBytes", ",", "Byte", ",", "BytesPerElement", ",", "NewByte", ")", ")", "break", ";", "if", "(", "NewByte", "<", "0", ")", "{", "addUndef", "(", ")", ";", "return", "true", ";", "}", "Op", "=", "Op", ".", "getOperand", "(", "unsigned", "(", "NewByte", ")", "/", "SystemZ", "::", "VectorBytes", ")", ";", "Byte", "=", "unsigned", "(", "NewByte", ")", "%", "SystemZ", "::", "VectorBytes", ";", "}", "else", "if", "(", "Op", ".", "isUndef", "(", ")", ")", "{", "addUndef", "(", ")", ";", "return", "true", ";", "}", "else", "break", ";", "}", "unsigned", "OpNo", "=", "0", ";", "for", "(", ";", "OpNo", "<", "Ops", ".", "size", "(", ")", ";", "++", "OpNo", ")", "if", "(", "Ops", "[", "OpNo", "]", "==", "Op", ")", "break", ";", "if", "(", "OpNo", "==", "Ops", ".", "size", "(", ")", ")", "Ops", ".", "push_back", "(", "Op", ")", ";", "unsigned", "Base", "=", "OpNo", "*", "SystemZ", "::", "VectorBytes", "+", "Byte", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "BytesPerElement", ";", "++", "I", ")", "Bytes", ".", "push_back", "(", "Base", "+", "I", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "a", "string", "to", "the", "builder", "." ]

[ "SystemZ", "SystemZ::VectorBytes", "ISD::BITCAST", "0", "ISD::VECTOR_SHUFFLE", "SystemZ::VectorBytes", "0", "SystemZ::VectorBytes", "SystemZ::VectorBytes", "0", "SystemZ::VectorBytes", "0" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "{", "auto", "Op", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Op", "==", "AArch64", "::", "INLINEASM", "||", "Op", "==", "AArch64", "::", "INLINEASM_BR", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "}", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "AArch64", "::", "TLSDESC_CALLSEQ", ":", "NumBytes", "=", "16", ";", "break", ";", "case", "AArch64", "::", "JumpTableDest32", ":", "case", "AArch64", "::", "JumpTableDest16", ":", "case", "AArch64", "::", "JumpTableDest8", ":", "NumBytes", "=", "12", ";", "break", ";", "case", "AArch64", "::", "SPACE", ":", "NumBytes", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "NumBytes", "=", "getInstBundleLength", "(", "MI", ")", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "AArch64::INLINEASM_BR", "0", "0", "0", "4", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "AArch64::TLSDESC_CALLSEQ", "16", "AArch64::JumpTableDest32", "AArch64::JumpTableDest16", "AArch64::JumpTableDest8", "12", "AArch64::SPACE", "1" ]

[]

[ "<s>", "unsigned", "HexagonTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r19\"", ",", "Hexagon", "::", "R19", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Hexagon", "Hexagon", "\"r19\"", "Hexagon::R19", "0", "\"Invalid register name global variable\"" ]

[]

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

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

[ "ARM", "ARM::tGPRRegClass" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "const", "ARMSubtarget", "*", "Subtarget", "=", "&", "getARMSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "hasAnyDataBarrier", "(", ")", "&&", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "LowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BRCOND", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE" ]

[]

[ "<s>", "static", "int", "cbranch_predicted_taken_p", "(", "rtx", "insn", ")", "{", "rtx", "x", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "0", ")", ";", "if", "(", "x", ")", "{", "int", "pred_val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", "pred_val", ">=", "REG_BR_PROB_BASE", "/", "2", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "INSN", "is", "annotated", "with", "a", "REG_BR_PROB", "note", "that", "indicates", "it", "'s", "a", "branch", "that", "'s", "predicted", "taken", "." ]

[ "bfin", "0", "0", "2", "0" ]

[]

[ "<s>", "static", "int", "force_new_group", "(", "int", "sched_verbose", ",", "FILE", "*", "dump", ",", "rtx", "*", "group_insns", ",", "rtx_insn", "*", "next_insn", ",", "bool", "*", "group_end", ",", "int", "can_issue_more", ",", "int", "*", "group_count", ")", "{", "rtx", "nop", ";", "bool", "force", ";", "int", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "bool", "end", "=", "*", "group_end", ";", "int", "i", ";", "if", "(", "next_insn", "==", "NULL_RTX", "||", "DEBUG_INSN_P", "(", "next_insn", ")", ")", "return", "can_issue_more", ";", "if", "(", "rs6000_sched_insert_nops", ">", "sched_finish_regroup_exact", ")", "return", "can_issue_more", ";", "force", "=", "is_costly_group", "(", "group_insns", ",", "next_insn", ")", ";", "if", "(", "!", "force", ")", "return", "can_issue_more", ";", "if", "(", "sched_verbose", ">", "6", ")", "fprintf", "(", "dump", ",", "\"force: group count = %d, can_issue_more = %d\\n\"", ",", "*", "group_count", ",", "can_issue_more", ")", ";", "if", "(", "rs6000_sched_insert_nops", "==", "sched_finish_regroup_exact", ")", "{", "if", "(", "*", "group_end", ")", "can_issue_more", "=", "0", ";", "if", "(", "can_issue_more", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "can_issue_more", "--", ";", "if", "(", "rs6000_cpu_attr", "==", "CPU_POWER6", "||", "rs6000_cpu_attr", "==", "CPU_POWER7", "||", "rs6000_cpu_attr", "==", "CPU_POWER8", ")", "{", "nop", "=", "gen_group_ending_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "can_issue_more", "=", "0", ";", "}", "else", "while", "(", "can_issue_more", ">", "0", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "can_issue_more", "--", ";", "}", "*", "group_end", "=", "true", ";", "return", "0", ";", "}", "if", "(", "rs6000_sched_insert_nops", "<", "sched_finish_regroup_exact", ")", "{", "int", "n_nops", "=", "rs6000_sched_insert_nops", ";", "if", "(", "can_issue_more", "==", "0", ")", "can_issue_more", "=", "issue_rate", ";", "can_issue_more", "--", ";", "if", "(", "can_issue_more", "==", "0", ")", "{", "can_issue_more", "=", "issue_rate", "-", "1", ";", "(", "*", "group_count", ")", "++", ";", "end", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "0", ";", "}", "}", "while", "(", "n_nops", ">", "0", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "if", "(", "can_issue_more", "==", "issue_rate", "-", "1", ")", "end", "=", "false", ";", "can_issue_more", "--", ";", "if", "(", "can_issue_more", "==", "0", ")", "{", "can_issue_more", "=", "issue_rate", "-", "1", ";", "(", "*", "group_count", ")", "++", ";", "end", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "group_insns", "[", "i", "]", "=", "0", ";", "}", "}", "n_nops", "--", ";", "}", "can_issue_more", "++", ";", "*", "group_end", "=", "(", "end", "||", "(", "can_issue_more", "==", "1", "&&", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<=", "2", "&&", "is_cracked_insn", "(", "next_insn", ")", ")", "||", "(", "can_issue_more", "<", "issue_rate", "&&", "insn_terminates_group_p", "(", "next_insn", ",", "previous_group", ")", ")", ")", ";", "if", "(", "*", "group_end", "&&", "end", ")", "(", "*", "group_count", ")", "--", ";", "if", "(", "sched_verbose", ">", "6", ")", "fprintf", "(", "dump", ",", "\"done force: group count = %d, can_issue_more = %d\\n\"", ",", "*", "group_count", ",", "can_issue_more", ")", ";", "return", "can_issue_more", ";", "}", "return", "can_issue_more", ";", "}", "</s>" ]

[ "Utility", "of", "the", "function", "redefine_groups", ".", "Check", "if", "it", "is", "too", "costly", "to", "schedule", "NEXT_INSN", "together", "with", "GROUP_INSNS", "in", "the", "same", "dispatch", "group", ".", "If", "so", ",", "insert", "nops", "before", "NEXT_INSN", ",", "in", "order", "to", "keep", "it", "``", "far", "''", "(", "in", "a", "separate", "group", ")", "from", "GROUP_INSNS", ",", "following", "one", "of", "the", "following", "schemes", ",", "depending", "on", "the", "value", "of", "the", "flag", "-minsert_sched_nops", "=", "X", ":", "(", "1", ")", "X", "==", "sched_finish_regroup_exact", ":", "insert", "exactly", "as", "many", "nops", "as", "needed", "in", "order", "to", "force", "NEXT_INSN", "into", "a", "separate", "group", ".", "(", "2", ")", "X", "<", "sched_finish_regroup_exact", ":", "insert", "exactly", "X", "nops", ".", "GROUP_END", ",", "CAN_ISSUE_MORE", "and", "GROUP_COUNT", "record", "the", "state", "after", "nop", "insertion", "(", "has", "a", "group", "just", "ended", ",", "how", "many", "vacant", "issue", "slots", "remain", "in", "the", "last", "group", ",", "and", "how", "many", "dispatch", "groups", "were", "encountered", "so", "far", ")", "." ]

[ "rs6000", "6", "\"force: group count = %d, can_issue_more = %d\\n\"", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "2", "6", "\"done force: group count = %d, can_issue_more = %d\\n\"" ]

[]

[ "<s>", "bool", "SIModeRegister", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "processBlockPhase1", "(", "BB", ",", "TII", ")", ";", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "Phase2List", ".", "push", "(", "&", "BB", ")", ";", "while", "(", "!", "Phase2List", ".", "empty", "(", ")", ")", "{", "processBlockPhase2", "(", "*", "Phase2List", ".", "front", "(", ")", ",", "TII", ")", ";", "Phase2List", ".", "pop", "(", ")", ";", "}", "for", "(", "MachineBasicBlock", "&", "BB", ":", "MF", ")", "processBlockPhase3", "(", "BB", ",", "TII", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "return", "NumSetregInserted", ">", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "bool", "ForceImmediate", "=", "(", "Name", "==", "\"call\"", "||", "Name", "==", "\"tail\"", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "ForceImmediate", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "false", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "RISCV", "RISCV", "RISCV", "\"call\"", "\"tail\"", "\"unexpected token\"" ]

[]

[ "<s>", "static", "bool", "nds32_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "true", ";", "if", "(", "(", "TARGET_FPU_SINGLE", "||", "TARGET_FPU_DOUBLE", ")", "&&", "NDS32_IS_FPR_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "NDS32_IS_EXT_FPR_REGNUM", "(", "regno", ")", ")", "return", "(", "NDS32_FPR_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", "&&", "(", "mode", "==", "DFmode", ")", ")", ";", "else", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", "return", "NDS32_FPR_REGNO_OK_FOR_SINGLE", "(", "regno", ")", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "return", "NDS32_FPR_REGNO_OK_FOR_DOUBLE", "(", "regno", ")", ";", "return", "false", ";", "}", "if", "(", "regno", "<=", "NDS32_LAST_GPR_REGNUM", ")", "return", "(", "targetm", ".", "hard_regno_nregs", "(", "regno", ",", "mode", ")", "==", "1", "||", "!", "(", "(", "regno", ")", "&", "1", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "nds32", "1", "1" ]

[]