Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "LanaiInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "createMipsELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ",", "IsLittle", ",", "Is64Bit", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "rx_fuse_in_memory_bitop", "(", "rtx", "*", "operands", ",", "rtx_insn", "*", "curr_insn", ",", "rtx", "(", "*", "gen_insn", ")", "(", "rtx", ",", "rtx", ")", ")", "{", "rtx", "op2_reg", "=", "SUBREG_P", "(", "operands", "[", "2", "]", ")", "?", "SUBREG_REG", "(", "operands", "[", "2", "]", ")", ":", "operands", "[", "2", "]", ";", "set_of_reg", "op2_def", "=", "rx_find_set_of_reg", "(", "op2_reg", ",", "curr_insn", ",", "prev_nonnote_nondebug_insn_bb", ")", ";", "if", "(", "op2_def", ".", "set_src", "==", "NULL_RTX", "||", "!", "MEM_P", "(", "op2_def", ".", "set_src", ")", "||", "GET_MODE", "(", "op2_def", ".", "set_src", ")", "!=", "QImode", "||", "!", "rx_is_restricted_memory_address", "(", "XEXP", "(", "op2_def", ".", "set_src", ",", "0", ")", ",", "GET_MODE", "(", "op2_def", ".", "set_src", ")", ")", "||", "reg_used_between_p", "(", "operands", "[", "2", "]", ",", "op2_def", ".", "insn", ",", "curr_insn", ")", "||", "!", "rx_reg_dead_or_unused_after_insn", "(", "curr_insn", ",", "REGNO", "(", "op2_reg", ")", ")", ")", "return", "false", ";", "rtx", "mem", "=", "op2_def", ".", "set_src", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "POST_INC", "||", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "POST_DEC", "||", "GET_CODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "PRE_DEC", ")", "return", "false", ";", "rtx_insn", "*", "op0_use", "=", "rx_find_use_of_reg", "(", "operands", "[", "0", "]", ",", "curr_insn", ",", "next_nonnote_nondebug_insn_bb", ")", ";", "if", "(", "op0_use", "==", "NULL", "||", "!", "(", "GET_CODE", "(", "PATTERN", "(", "op0_use", ")", ")", "==", "SET", "&&", "RX_REG_P", "(", "XEXP", "(", "PATTERN", "(", "op0_use", ")", ",", "1", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "XEXP", "(", "PATTERN", "(", "op0_use", ")", ",", "1", ")", ")", "&&", "rtx_equal_p", "(", "mem", ",", "XEXP", "(", "PATTERN", "(", "op0_use", ")", ",", "0", ")", ")", ")", "||", "!", "rx_reg_dead_or_unused_after_insn", "(", "op0_use", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "||", "reg_set_between_p", "(", "operands", "[", "2", "]", ",", "curr_insn", ",", "op0_use", ")", ")", "return", "false", ";", "for", "(", "rtx_insn", "*", "i", "=", "next_nonnote_nondebug_insn_bb", "(", "op2_def", ".", "insn", ")", ";", "i", "!=", "NULL", "&&", "i", "!=", "op0_use", ";", "i", "=", "next_nonnote_nondebug_insn_bb", "(", "i", ")", ")", "if", "(", "volatile_insn_p", "(", "PATTERN", "(", "i", ")", ")", "||", "CALL_P", "(", "i", ")", ")", "return", "false", ";", "emit_insn", "(", "gen_insn", "(", "mem", ",", "gen_lowpart", "(", "QImode", ",", "operands", "[", "1", "]", ")", ")", ")", ";", "set_insn_deleted", "(", "op2_def", ".", "insn", ")", ";", "set_insn_deleted", "(", "op0_use", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "fuse", "the", "current", "bit-operation", "insn", "with", "the", "surrounding", "memory", "load", "and", "store", "." ]

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

[]

[ "<s>", "void", "sparc_d_target_versions", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "d_add_builtin_version", "(", "\"SPARC64\"", ")", ";", "else", "d_add_builtin_version", "(", "\"SPARC\"", ")", ";", "if", "(", "TARGET_V8PLUS", ")", "d_add_builtin_version", "(", "\"SPARC_V8Plus\"", ")", ";", "if", "(", "TARGET_FPU", ")", "{", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "d_add_builtin_version", "(", "\"SPARC_HardFloat\"", ")", ";", "}", "else", "{", "d_add_builtin_version", "(", "\"D_SoftFloat\"", ")", ";", "d_add_builtin_version", "(", "\"SPARC_SoftFloat\"", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "SPARC", "targets", "." ]

[ "sparc", "\"SPARC64\"", "\"SPARC\"", "\"SPARC_V8Plus\"", "\"D_HardFloat\"", "\"SPARC_HardFloat\"", "\"D_SoftFloat\"", "\"SPARC_SoftFloat\"" ]

[]

[ "<s>", "int", "m32c_preferred_output_reload_class", "(", "rtx", "x", ",", "int", "rclass", ")", "{", "return", "m32c_preferred_reload_class", "(", "x", ",", "rclass", ")", ";", "}", "</s>" ]

[ "Implements", "PREFERRED_OUTPUT_RELOAD_CLASS", "." ]

[ "m32c" ]

[]

[ "<s>", "static", "bool", "c6x_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "UNITS_PER_WORD", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "UNITS_PER_WORD", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "aarch64_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "scratch", ";", "machine_mode", "mode", ";", "bool", "is_weak", ";", "rtx_code_label", "*", "label1", ",", "*", "label2", ";", "rtx", "x", ",", "cond", ";", "enum", "memmodel", "model", ";", "rtx", "model_rtx", ";", "rval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "oldval", "=", "operands", "[", "2", "]", ";", "newval", "=", "operands", "[", "3", "]", ";", "is_weak", "=", "(", "operands", "[", "4", "]", "!=", "const0_rtx", ")", ";", "model_rtx", "=", "operands", "[", "5", "]", ";", "scratch", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "model", "=", "memmodel_from_int", "(", "INTVAL", "(", "model_rtx", ")", ")", ";", "bool", "strong_zero_p", "=", "!", "is_weak", "&&", "oldval", "==", "const0_rtx", ";", "label1", "=", "NULL", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "GEN_INT", "(", "MEMMODEL_RELAXED", ")", ")", ";", "else", "aarch64_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "model_rtx", ")", ";", "if", "(", "strong_zero_p", ")", "{", "if", "(", "aarch64_track_speculation", ")", "{", "rtx", "cc_reg", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "rval", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "else", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "rval", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "{", "cond", "=", "aarch64_gen_compare_reg_maybe_ze", "(", "NE", ",", "rval", ",", "oldval", ",", "mode", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "aarch64_emit_store_exclusive", "(", "mode", ",", "scratch", ",", "mem", ",", "newval", ",", "model_rtx", ")", ";", "if", "(", "!", "is_weak", ")", "{", "if", "(", "aarch64_track_speculation", ")", "{", "rtx", "cc_reg", "=", "aarch64_gen_compare_reg", "(", "NE", ",", "scratch", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ";", "}", "else", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "scratch", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label1", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "{", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "scratch", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "}", "emit_label", "(", "label2", ")", ";", "if", "(", "strong_zero_p", ")", "{", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "rval", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "}", "if", "(", "is_mm_sync", "(", "model", ")", ")", "aarch64_emit_post_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Split", "a", "compare", "and", "swap", "pattern", "." ]

[ "aarch64", "0", "1", "2", "3", "4", "5", "7" ]

[]

[ "<s>", "tree", "loongarch_builtin_decl", "(", "unsigned", "int", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "ARRAY_SIZE", "(", "loongarch_builtins", ")", ")", "return", "error_mark_node", ";", "return", "loongarch_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "aarch64_validate_mtune", "(", "const", "char", "*", "str", ",", "const", "struct", "processor", "*", "*", "res", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_tune", "(", "str", ",", "res", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "return", "true", ";", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing cpu name in -mtune=%qs\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"unknown value %qs for -mtune\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Validate", "a", "command-line", "-mtune", "option", ".", "Parse", "the", "cpu", "specified", "in", "STR", "and", "throw", "errors", "if", "appropriate", ".", "Put", "the", "result", ",", "if", "it", "is", "valid", ",", "in", "RES", ".", "Return", "whether", "the", "option", "is", "valid", "." ]

[ "aarch64", "\"missing cpu name in -mtune=%qs\"", "\"unknown value %qs for -mtune\"" ]

[]

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

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

[ "OpenRISC", "OpenRISC" ]

[]

[ "<s>", "static", "void", "sh_override_options_after_change", "(", "void", ")", "{", "if", "(", "align_loops", "==", "0", ")", "align_loops", "=", "optimize_size", "?", "2", ":", "4", ";", "if", "(", "align_jumps", "==", "0", ")", "align_jumps", "=", "2", ";", "else", "if", "(", "align_jumps", "<", "2", ")", "align_jumps", "=", "2", ";", "if", "(", "align_functions", "==", "0", ")", "align_functions", "=", "optimize_size", "?", "2", ":", "4", ";", "if", "(", "TARGET_RELAX", ")", "{", "int", "min_align", "=", "align_loops", ">", "align_jumps", "?", "align_loops", ":", "align_jumps", ";", "if", "(", "min_align", "<", "4", ")", "min_align", "=", "4", ";", "if", "(", "align_functions", "<", "min_align", ")", "align_functions", "=", "min_align", ";", "}", "}", "</s>" ]

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

[ "sh", "0", "2", "4", "0", "2", "2", "2", "0", "2", "4", "4", "4" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", ")", "return", "true", ";", "}", "bool", "DummyBool", ";", "int", "DummyInt", ";", "unsigned", "DummyUnsigned", ";", "return", "(", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isEXTMask", "(", "M", ",", "VT", ",", "DummyBool", ",", "DummyUnsigned", ")", "||", "isTRNMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isTRN_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isINSMask", "(", "M", ",", "VT", ".", "getVectorNumElements", "(", ")", ",", "DummyBool", ",", "DummyInt", ")", "||", "isConcatMask", "(", "M", ",", "VT", ",", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "ARM64", "ARM64", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "0", "64", "32", "16", "128" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "AGC" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasUnwantedEffectsWhenEXECEmpty", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "isSMRD", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SENDMSG", "||", "Opcode", "==", "AMDGPU", "::", "S_SENDMSGHALT", "||", "Opcode", "==", "AMDGPU", "::", "EXP", "||", "Opcode", "==", "AMDGPU", "::", "EXP_DONE", "||", "Opcode", "==", "AMDGPU", "::", "DS_ORDERED_COUNT", "||", "Opcode", "==", "AMDGPU", "::", "S_TRAP", "||", "Opcode", "==", "AMDGPU", "::", "DS_GWS_INIT", "||", "Opcode", "==", "AMDGPU", "::", "DS_GWS_BARRIER", ")", "return", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", "||", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "true", ";", "if", "(", "modifiesModeRegister", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "V_READFIRSTLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_READLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_WRITELANE_B32", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "we", "must", "prevent", "this", "instruction", "from", "executing", "with", "EXEC", "=", "0", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_SENDMSG", "AMDGPU::S_SENDMSGHALT", "AMDGPU::EXP", "AMDGPU::EXP_DONE", "AMDGPU::DS_ORDERED_COUNT", "AMDGPU::S_TRAP", "AMDGPU::DS_GWS_INIT", "AMDGPU::DS_GWS_BARRIER", "AMDGPU::V_READFIRSTLANE_B32", "AMDGPU::V_READLANE_B32", "AMDGPU::V_WRITELANE_B32" ]

[]

[ "<s>", "bool", "OR1KAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "static", "void", "setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "rtx", "mem", ";", "int", "i", ";", "if", "(", "no_rtl", ")", "return", ";", "for", "(", "i", "=", "get_cumulative_args", "(", "cum", ")", "->", "words", "+", "1", ";", "i", "<", "max_arg_registers", ";", "i", "++", ")", "{", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "(", "i", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "Pmode", ",", "i", ")", ")", ";", "}", "*", "pretend_size", "=", "0", ";", "}", "</s>" ]

[ "Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", ".", "CUM", "is", "as", "above", ".", "MODE", "and", "TYPE", "are", "the", "mode", "and", "type", "of", "the", "current", "parameter", ".", "PRETEND_SIZE", "is", "a", "variable", "that", "should", "be", "set", "to", "the", "amount", "of", "stack", "that", "must", "be", "pushed", "by", "the", "prolog", "to", "pretend", "that", "our", "caller", "pushed", "it", ".", "Normally", ",", "this", "macro", "will", "push", "all", "remaining", "incoming", "registers", "on", "the", "stack", "and", "set", "PRETEND_SIZE", "to", "the", "length", "of", "the", "registers", "pushed", "." ]

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

[]

[ "<s>", "static", "void", "iq2000_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", "mode", ",", "rtx", "addr", ")", "{", "if", "(", "!", "addr", ")", "error", "(", "\"%<PRINT_OPERAND_ADDRESS%>, null pointer\"", ")", ";", "else", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "addr", ")", "==", "ARG_POINTER_REGNUM", ")", "abort_with_insn", "(", "addr", ",", "\"Arg pointer not eliminated.\"", ")", ";", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "LO_SUM", ":", "{", "rtx", "arg0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "arg0", ")", "!=", "REG", ")", "abort_with_insn", "(", "addr", ",", "\"PRINT_OPERAND_ADDRESS, LO_SUM with #1 not REG.\"", ")", ";", "fprintf", "(", "file", ",", "\"%%lo(\"", ")", ";", "iq2000_print_operand_address", "(", "file", ",", "mode", ",", "arg1", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "REGNO", "(", "arg0", ")", "]", ")", ";", "}", "break", ";", "case", "PLUS", ":", "{", "rtx", "reg", "=", "0", ";", "rtx", "offset", "=", "0", ";", "rtx", "arg0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "arg0", ")", "==", "REG", ")", "{", "reg", "=", "arg0", ";", "offset", "=", "arg1", ";", "if", "(", "GET_CODE", "(", "offset", ")", "==", "REG", ")", "abort_with_insn", "(", "addr", ",", "\"PRINT_OPERAND_ADDRESS, 2 regs\"", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "arg1", ")", "==", "REG", ")", "reg", "=", "arg1", ",", "offset", "=", "arg0", ";", "else", "if", "(", "CONSTANT_P", "(", "arg0", ")", "&&", "CONSTANT_P", "(", "arg1", ")", ")", "{", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "else", "abort_with_insn", "(", "addr", ",", "\"PRINT_OPERAND_ADDRESS, no regs\"", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "offset", ")", ")", "abort_with_insn", "(", "addr", ",", "\"PRINT_OPERAND_ADDRESS, invalid insn #2\"", ")", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "ARG_POINTER_REGNUM", ")", "abort_with_insn", "(", "addr", ",", "\"Arg pointer not eliminated.\"", ")", ";", "output_addr_const", "(", "file", ",", "offset", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "}", "break", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "case", "CONST", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "0", "]", ")", ";", "break", ";", "default", ":", "abort_with_insn", "(", "addr", ",", "\"PRINT_OPERAND_ADDRESS, invalid insn #1\"", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "A", "C", "compound", "statement", "to", "output", "to", "stdio", "stream", "STREAM", "the", "assembler", "syntax", "for", "an", "instruction", "operand", "that", "is", "a", "memory", "reference", "whose", "address", "is", "ADDR", ".", "ADDR", "is", "an", "RTL", "expression", "." ]

[ "iq2000", "\"%<PRINT_OPERAND_ADDRESS%>, null pointer\"", "\"Arg pointer not eliminated.\"", "\"0(%s)\"", "0", "1", "\"PRINT_OPERAND_ADDRESS, LO_SUM with #1 not REG.\"", "\"%%lo(\"", "\")(%s)\"", "0", "0", "0", "1", "\"PRINT_OPERAND_ADDRESS, 2 regs\"", "\"PRINT_OPERAND_ADDRESS, no regs\"", "\"PRINT_OPERAND_ADDRESS, invalid insn #2\"", "\"Arg pointer not eliminated.\"", "\"(%s)\"", "\"(%s)\"", "0", "\"PRINT_OPERAND_ADDRESS, invalid insn #1\"" ]

[]

[ "<s>", "AArch64TargetLowering", "::", "ConstraintType", "AArch64TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'x'", ":", "case", "'w'", ":", "case", "'y'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'Y'", ":", "case", "'Z'", ":", "return", "C_Immediate", ";", "case", "'z'", ":", "case", "'S'", ":", "return", "C_Other", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "X86TTI", "::", "getNumberOfRegisters", "(", "bool", "Vector", ")", "const", "{", "if", "(", "Vector", "&&", "!", "ST", "->", "hasSSE1", "(", ")", ")", "return", "0", ";", "if", "(", "ST", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "Vector", "&&", "ST", "->", "hasAVX512", "(", ")", ")", "return", "32", ";", "return", "16", ";", "}", "return", "8", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "X86", "X86", "0", "32", "16", "8" ]

[]

[ "<s>", "int", "use_return_insn", "(", "int", "iscond", ",", "rtx", "sibling", ")", "{", "int", "regno", ";", "unsigned", "int", "func_type", ";", "unsigned", "long", "saved_int_regs", ";", "unsigned", "HOST_WIDE_INT", "stack_adjust", ";", "arm_stack_offsets", "*", "offsets", ";", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "func_type", "&", "(", "ARM_FT_VOLATILE", "|", "ARM_FT_NAKED", "|", "ARM_FT_STACKALIGN", ")", ")", "return", "0", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", "&&", "(", "frame_pointer_needed", "||", "TARGET_THUMB", ")", ")", "return", "0", ";", "if", "(", "TARGET_LDRD", "&&", "current_tune", "->", "prefer_ldrd_strd", "&&", "!", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "0", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "stack_adjust", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_regs", ";", "if", "(", "crtl", "->", "args", ".", "pretend_args_size", "||", "cfun", "->", "machine", "->", "uses_anonymous_args", "||", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "calls_alloca", "||", "!", "(", "stack_adjust", "==", "0", "||", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "stack_adjust", "==", "4", ")", ")", "||", "(", "!", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", ")", "&&", "arm_compute_static_chain_stack_bytes", "(", ")", "!=", "0", ")", ")", "return", "0", ";", "saved_int_regs", "=", "offsets", "->", "saved_regs_mask", ";", "if", "(", "stack_adjust", "==", "4", "&&", "!", "arm_arch5t", "&&", "TARGET_ARM", ")", "{", "if", "(", "!", "call_used_regs", "[", "3", "]", ")", "return", "0", ";", "if", "(", "arm_size_return_regs", "(", ")", ">=", "(", "4", "*", "UNITS_PER_WORD", ")", ")", "return", "0", ";", "if", "(", "sibling", ")", "{", "gcc_assert", "(", "CALL_P", "(", "sibling", ")", ")", ";", "if", "(", "find_regno_fusage", "(", "sibling", ",", "USE", ",", "3", ")", ")", "return", "0", ";", "}", "if", "(", "saved_int_regs", "&", "0x7", ")", "return", "0", ";", "}", "if", "(", "TARGET_INTERWORK", "&&", "saved_int_regs", "!=", "0", "&&", "!", "IS_INTERRUPT", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "iscond", "&&", "arm_tune_strongarm", ")", "{", "if", "(", "saved_int_regs", "!=", "0", "&&", "saved_int_regs", "!=", "(", "1", "<<", "LR_REGNUM", ")", ")", "return", "0", ";", "if", "(", "flag_pic", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "return", "0", ";", "}", "if", "(", "saved_int_regs", "&&", "IS_CMSE_ENTRY", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "saved_int_regs", "&&", "!", "(", "saved_int_regs", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", ")", "return", "0", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "for", "(", "regno", "=", "FIRST_VFP_REGNUM", ";", "regno", "<=", "LAST_VFP_REGNUM", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "0", ";", "if", "(", "TARGET_REALLY_IWMMXT", ")", "for", "(", "regno", "=", "FIRST_IWMMXT_REGNUM", ";", "regno", "<=", "LAST_IWMMXT_REGNUM", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "function", "'s", "epilogue", "can", "be", "output", "as", "RTL", "." ]

[ "arm", "0", "0", "0", "0", "0", "4", "0", "0", "4", "3", "0", "4", "0", "3", "0", "0x7", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseOffs", "<=", "-", "(", "1LL", "<<", "13", ")", "||", "AM", ".", "BaseOffs", ">=", "(", "1LL", "<<", "13", ")", "-", "1", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "switch", "(", "Scale", ")", "{", "case", "0", ":", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "Hexagon", "Hexagon", "1LL", "13", "1LL", "13", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "ia64_output_function_prologue", "(", "FILE", "*", "file", ")", "{", "int", "mask", ",", "grsave", ",", "grsave_prev", ";", "if", "(", "current_frame_info", ".", "need_regstk", ")", "fprintf", "(", "file", ",", "\"\\t.regstk %d, %d, %d, %d\\n\"", ",", "current_frame_info", ".", "n_input_regs", ",", "current_frame_info", ".", "n_local_regs", ",", "current_frame_info", ".", "n_output_regs", ",", "current_frame_info", ".", "n_rotate_regs", ")", ";", "if", "(", "ia64_except_unwind_info", "(", "&", "global_options", ")", "!=", "UI_TARGET", ")", "return", ";", "mask", "=", "0", ";", "grsave", "=", "grsave_prev", "=", "0", ";", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_b0", "]", "!=", "0", ")", "{", "mask", "|=", "8", ";", "grsave", "=", "grsave_prev", "=", "current_frame_info", ".", "r", "[", "reg_save_b0", "]", ";", "}", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "4", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", ";", "grsave_prev", "=", "current_frame_info", ".", "r", "[", "reg_save_ar_pfs", "]", ";", "}", "if", "(", "current_frame_info", ".", "r", "[", "reg_fp", "]", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "r", "[", "reg_fp", "]", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "2", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "HARD_FRAME_POINTER_REGNUM", ";", "grsave_prev", "=", "current_frame_info", ".", "r", "[", "reg_fp", "]", ";", "}", "if", "(", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", "!=", "0", "&&", "(", "grsave_prev", "==", "0", "||", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", "==", "grsave_prev", "+", "1", ")", ")", "{", "mask", "|=", "1", ";", "if", "(", "grsave_prev", "==", "0", ")", "grsave", "=", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", ";", "}", "if", "(", "mask", "&&", "TARGET_GNU_AS", ")", "fprintf", "(", "file", ",", "\"\\t.prologue %d, %d\\n\"", ",", "mask", ",", "ia64_dbx_register_number", "(", "grsave", ")", ")", ";", "else", "fputs", "(", "\"\\t.prologue\\n\"", ",", "file", ")", ";", "if", "(", "current_frame_info", ".", "spill_cfa_off", "!=", "-", "16", ")", "fprintf", "(", "file", ",", "\"\\t.spill %ld\\n\"", ",", "(", "long", ")", "(", "current_frame_info", ".", "spill_cfa_off", "+", "current_frame_info", ".", "spill_size", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "function", "prologue", "." ]

[ "ia64", "\"\\t.regstk %d, %d, %d, %d\\n\"", "0", "0", "0", "8", "0", "0", "1", "4", "0", "0", "0", "1", "2", "0", "0", "0", "1", "1", "0", "\"\\t.prologue %d, %d\\n\"", "\"\\t.prologue\\n\"", "16", "\"\\t.spill %ld\\n\"" ]

[]

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

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

[ "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "static", "void", "spu_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "op", "[", "8", "]", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "file", ",", "1", ")", ";", "op", "[", "0", "]", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "op", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIRST_ARG_REGNUM", "+", "1", ")", ";", "else", "op", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "FIRST_ARG_REGNUM", ")", ";", "op", "[", "2", "]", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "delta", ",", "HImode", ")", ")", ";", "op", "[", "3", "]", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "delta", ">>", "16", ",", "HImode", ")", ")", ";", "op", "[", "4", "]", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "vcall_offset", ",", "HImode", ")", ")", ";", "op", "[", "5", "]", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "vcall_offset", ">>", "16", ",", "HImode", ")", ")", ";", "op", "[", "6", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "79", ")", ";", "op", "[", "7", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "78", ")", ";", "if", "(", "delta", ")", "{", "if", "(", "delta", ">=", "-", "0x200", "&&", "delta", "<", "0x200", ")", "output_asm_insn", "(", "\"ai\\t%1,%1,%2\"", ",", "op", ")", ";", "else", "if", "(", "delta", ">=", "-", "0x8000", "&&", "delta", "<", "0x8000", ")", "{", "output_asm_insn", "(", "\"il\\t%6,%2\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%1,%1,%6\"", ",", "op", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"ilhu\\t%6,%3\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"iohl\\t%6,%2\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%1,%1,%6\"", ",", "op", ")", ";", "}", "}", "if", "(", "vcall_offset", ")", "{", "output_asm_insn", "(", "\"lqd\\t%7,0(%1)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"rotqby\\t%7,%7,%1\"", ",", "op", ")", ";", "if", "(", "vcall_offset", ">=", "-", "0x200", "&&", "vcall_offset", "<", "0x200", ")", "output_asm_insn", "(", "\"ai\\t%7,%7,%4\"", ",", "op", ")", ";", "else", "if", "(", "vcall_offset", ">=", "-", "0x8000", "&&", "vcall_offset", "<", "0x8000", ")", "{", "output_asm_insn", "(", "\"il\\t%6,%4\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%7,%7,%6\"", ",", "op", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"ilhu\\t%6,%5\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"iohl\\t%6,%4\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%7,%7,%6\"", ",", "op", ")", ";", "}", "output_asm_insn", "(", "\"lqd\\t%6,0(%7)\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"rotqby\\t%6,%6,%7\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"a\\t%1,%1,%6\"", ",", "op", ")", ";", "}", "output_asm_insn", "(", "\"br\\t%0\"", ",", "op", ")", ";", "final_end_function", "(", ")", ";", "}", "</s>" ]

[ "Output", "thunk", "to", "FILE", "that", "implements", "a", "C++", "virtual", "function", "call", "(", "with", "multiple", "inheritance", ")", "to", "FUNCTION", ".", "The", "thunk", "adjusts", "the", "this", "pointer", "by", "DELTA", ",", "and", "unless", "VCALL_OFFSET", "is", "zero", ",", "applies", "an", "additional", "adjustment", "stored", "at", "VCALL_OFFSET", "in", "the", "vtable", "whose", "address", "is", "located", "at", "offset", "0", "relative", "to", "the", "resulting", "this", "pointer", "." ]

[ "spu", "8", "1", "0", "0", "1", "1", "1", "2", "3", "16", "4", "5", "16", "6", "79", "7", "78", "0x200", "0x200", "\"ai\\t%1,%1,%2\"", "0x8000", "0x8000", "\"il\\t%6,%2\"", "\"a\\t%1,%1,%6\"", "\"ilhu\\t%6,%3\"", "\"iohl\\t%6,%2\"", "\"a\\t%1,%1,%6\"", "\"lqd\\t%7,0(%1)\"", "\"rotqby\\t%7,%7,%1\"", "0x200", "0x200", "\"ai\\t%7,%7,%4\"", "0x8000", "0x8000", "\"il\\t%6,%4\"", "\"a\\t%7,%7,%6\"", "\"ilhu\\t%6,%5\"", "\"iohl\\t%6,%4\"", "\"a\\t%7,%7,%6\"", "\"lqd\\t%6,0(%7)\"", "\"rotqby\\t%6,%6,%7\"", "\"a\\t%1,%1,%6\"", "\"br\\t%0\"" ]

[]

[ "<s>", "static", "int", "aarch64_reduc_type", "(", "vec_info", "*", "vinfo", ",", "stmt_vec_info", "stmt_info", ")", "{", "if", "(", "loop_vec_info", "loop_vinfo", "=", "dyn_cast", "<", "loop_vec_info", ">", "(", "vinfo", ")", ")", "if", "(", "STMT_VINFO_REDUC_DEF", "(", "stmt_info", ")", ")", "{", "stmt_vec_info", "reduc_info", "=", "info_for_reduction", "(", "loop_vinfo", ",", "stmt_info", ")", ";", "return", "int", "(", "STMT_VINFO_REDUC_TYPE", "(", "reduc_info", ")", ")", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "If", "STMT_INFO", "describes", "a", "reduction", ",", "return", "the", "type", "of", "reduction", "it", "describes", ",", "otherwise", "return", "-1", "." ]

[ "aarch64", "1" ]

[]

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

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

[ "AAP", "\"AAP Assembly Printer\"" ]

[]

[ "<s>", "static", "bool", "arm_mem_costs", "(", "rtx", "x", ",", "const", "struct", "cpu_cost_table", "*", "extra_cost", ",", "int", "*", "cost", ",", "bool", "speed_p", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "*", "cost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "will_be_in_index_register", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", "*", "cost", "+=", "COSTS_N_INSNS", "(", "1", ")", ";", "if", "(", "speed_p", ")", "{", "arm_addr_mode_op", "op_type", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "default", ":", "case", "REG", ":", "op_type", "=", "AMO_DEFAULT", ";", "break", ";", "case", "MINUS", ":", "case", "PLUS", ":", "op_type", "=", "AMO_NO_WB", ";", "break", ";", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "op_type", "=", "AMO_WB", ";", "break", ";", "}", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "*", "cost", "+=", "current_tune", "->", "addr_mode_costs", "->", "vector", "[", "op_type", "]", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "*", "cost", "+=", "current_tune", "->", "addr_mode_costs", "->", "fp", "[", "op_type", "]", ";", "else", "*", "cost", "+=", "current_tune", "->", "addr_mode_costs", "->", "integer", "[", "op_type", "]", ";", "}", "if", "(", "speed_p", ")", "{", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "*", "cost", "+=", "extra_cost", "->", "ldst", ".", "loadd", ";", "else", "*", "cost", "+=", "extra_cost", "->", "ldst", ".", "loadf", ";", "}", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "*", "cost", "+=", "extra_cost", "->", "ldst", ".", "loadv", ";", "else", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "*", "cost", "+=", "extra_cost", "->", "ldst", ".", "ldrd", ";", "else", "*", "cost", "+=", "extra_cost", "->", "ldst", ".", "load", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Helper", "function", "for", "arm_rtx_costs_internal", ".", "Calculates", "the", "cost", "of", "a", "MEM", ",", "considering", "the", "costs", "of", "the", "addressing", "mode", "and", "memory", "access", "separately", "." ]

[ "arm", "1", "0", "0", "1", "1", "0", "8", "8" ]

[]

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

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

[ "AMDGPU", "36" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "bool", "Split", "=", "false", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "VRegs", "[", "i", "]", ")", ";", "unsigned", "Dst", "=", "VRegs", "[", "i", "]", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "if", "(", "!", "Split", ")", "{", "Split", "=", "true", ";", "Dst", "=", "MRI", ".", "createGenericVirtualRegister", "(", "Ty", ")", ";", "MIRBuilder", ".", "buildUndef", "(", "Dst", ")", ";", "}", "unsigned", "Tmp", "=", "MRI", ".", "createGenericVirtualRegister", "(", "Ty", ")", ";", "MIRBuilder", ".", "buildInsert", "(", "Tmp", ",", "Dst", ",", "Reg", ",", "Offset", ")", ";", "Dst", "=", "Tmp", ";", "}", ")", ";", "if", "(", "Dst", "!=", "VRegs", "[", "i", "]", ")", "MIRBuilder", ".", "buildCopy", "(", "VRegs", "[", "i", "]", ",", "Dst", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "uint64_t", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "8", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "4", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "0", "AArch64", "AArch64", "AArch64", "8", "AArch64", "AArch64", "4" ]

[]

[ "<s>", "virtual", "unsigned", "getCycles", "(", ")", "const", "{", "return", "NumCycles", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "cycles", "the", "stage", "is", "occupied", "." ]

[ "TMS320C64X" ]

[]

[ "<s>", "static", "bool", "sh_legitimize_address_displacement", "(", "rtx", "*", "disp", ",", "rtx", "*", "offs", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SHMEDIA", ")", "return", "false", ";", "if", "(", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "mode", "==", "DFmode", ")", "||", "(", "TARGET_SH2E", "&&", "mode", "==", "SFmode", ")", ")", "return", "false", ";", "struct", "disp_adjust", "adj", "=", "sh_find_mov_disp_adjust", "(", "mode", ",", "INTVAL", "(", "*", "disp", ")", ")", ";", "if", "(", "adj", ".", "offset_adjust", "!=", "NULL_RTX", "&&", "adj", ".", "mov_disp", "!=", "NULL_RTX", ")", "{", "*", "disp", "=", "adj", ".", "mov_disp", ";", "*", "offs", "=", "adj", ".", "offset_adjust", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "DISP", "can", "be", "legitimized", "." ]

[ "sh" ]

[]

[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "cpu", "=", "NULL", ";", "char", "*", "buf", "=", "NULL", ";", "kstat_ctl_t", "*", "kc", ";", "kstat_t", "*", "ksp", ";", "kstat_named_t", "*", "brand", "=", "NULL", ";", "char", "buf", "[", "128", "]", ";", "FILE", "*", "f", ";", "int", "i", ";", "if", "(", "argc", "<", "1", ")", "return", "NULL", ";", "if", "(", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "return", "NULL", ";", "kc", "=", "kstat_open", "(", ")", ";", "if", "(", "kc", "!=", "NULL", ")", "{", "ksp", "=", "kstat_lookup", "(", "kc", ",", "CONST_CAST2", "(", "char", "*", ",", "const", "char", "*", ",", "\"cpu_info\"", ")", ",", "-", "1", ",", "NULL", ")", ";", "if", "(", "ksp", "!=", "NULL", "&&", "kstat_read", "(", "kc", ",", "ksp", ",", "NULL", ")", "!=", "-", "1", "&&", "ksp", "->", "ks_type", "==", "KSTAT_TYPE_NAMED", ")", "brand", "=", "(", "kstat_named_t", "*", ")", "kstat_data_lookup", "(", "ksp", ",", "CONST_CAST2", "(", "char", "*", ",", "const", "char", "*", ",", "\"brand\"", ")", ")", ";", "if", "(", "brand", "==", "NULL", ")", "brand", "=", "(", "kstat_named_t", "*", ")", "kstat_data_lookup", "(", "ksp", ",", "CONST_CAST2", "(", "char", "*", ",", "const", "char", "*", ",", "\"implementation\"", ")", ")", ";", "if", "(", "brand", "!=", "NULL", "&&", "brand", "->", "data_type", "==", "KSTAT_DATA_STRING", ")", "buf", "=", "KSTAT_NAMED_STR_PTR", "(", "brand", ")", ";", "if", "(", "brand", "!=", "NULL", "&&", "brand", "->", "data_type", "==", "KSTAT_DATA_CHAR", ")", "buf", "=", "brand", "->", "value", ".", "c", ";", "}", "kstat_close", "(", "kc", ")", ";", "for", "(", "i", "=", "0", ";", "cpu_names", "[", "i", "]", ".", "name", "!=", "NULL", ";", "i", "++", ")", "if", "(", "strcmp", "(", "buf", ",", "cpu_names", "[", "i", "]", ".", "name", ")", "==", "0", ")", "cpu", "=", "cpu_names", "[", "i", "]", ".", "cpu", ";", "f", "=", "fopen", "(", "\"/proc/cpuinfo\"", ",", "\"r\"", ")", ";", "if", "(", "f", "==", "NULL", ")", "return", "NULL", ";", "while", "(", "fgets", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "f", ")", "!=", "NULL", ")", "if", "(", "strncmp", "(", "buf", ",", "\"cpu\\t\\t:\"", ",", "sizeof", "(", "\"cpu\\t\\t:\"", ")", "-", "1", ")", "==", "0", ")", "{", "for", "(", "i", "=", "0", ";", "cpu_names", "[", "i", "]", ".", "name", ";", "i", "++", ")", "if", "(", "strstr", "(", "buf", ",", "cpu_names", "[", "i", "]", ".", "name", ")", "!=", "NULL", ")", "{", "cpu", "=", "cpu_names", "[", "i", "]", ".", "cpu", ";", "break", ";", "}", "break", ";", "}", "fclose", "(", "f", ")", ";", "if", "(", "cpu", "==", "NULL", ")", "return", "NULL", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "cpu", ",", "NULL", ")", ";", "}", "</s>" ]

[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]

[ "sparc", "128", "1", "0", "\"cpu\"", "0", "\"tune\"", "\"cpu_info\"", "1", "1", "\"brand\"", "\"implementation\"", "0", "0", "\"/proc/cpuinfo\"", "\"r\"", "\"cpu\\t\\t:\"", "\"cpu\\t\\t:\"", "1", "0", "0", "\"-m\"", "0", "\"=\"" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "WebAssemblyTTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "return", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "WebAssembly", "WebAssembly", "\"Ty width must be power of 2\"" ]

[]

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

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

[ "OR1K" ]

[]

[ "<s>", "bool", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "return", "MCInstLowering", ".", "lowerOperand", "(", "MO", ",", "MCOp", ")", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

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

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

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

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "parseExpression", "(", "MCExpr", "const", "*", "&", "Expr", ")", "{", "llvm", "::", "SmallVector", "<", "AsmToken", ",", "4", ">", "Tokens", ";", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "bool", "Done", "=", "false", ";", "static", "char", "const", "*", "Comma", "=", "\",\"", ";", "do", "{", "Tokens", ".", "emplace_back", "(", "Lexer", ".", "getTok", "(", ")", ")", ";", "Lexer", ".", "Lex", "(", ")", ";", "switch", "(", "Tokens", ".", "back", "(", ")", ".", "getKind", "(", ")", ")", "{", "case", "AsmToken", "::", "TokenKind", "::", "Hash", ":", "if", "(", "Tokens", ".", "size", "(", ")", ">", "1", ")", "if", "(", "(", "Tokens", ".", "end", "(", ")", "-", "2", ")", "->", "getKind", "(", ")", "==", "AsmToken", "::", "TokenKind", "::", "Plus", ")", "{", "Tokens", ".", "insert", "(", "Tokens", ".", "end", "(", ")", "-", "2", ",", "AsmToken", "(", "AsmToken", "::", "TokenKind", "::", "Comma", ",", "Comma", ")", ")", ";", "Done", "=", "true", ";", "}", "break", ";", "case", "AsmToken", "::", "TokenKind", "::", "RCurly", ":", "case", "AsmToken", "::", "TokenKind", "::", "EndOfStatement", ":", "case", "AsmToken", "::", "TokenKind", "::", "Eof", ":", "Done", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "while", "(", "!", "Done", ")", ";", "while", "(", "!", "Tokens", ".", "empty", "(", ")", ")", "{", "Lexer", ".", "UnLex", "(", "Tokens", ".", "back", "(", ")", ")", ";", "Tokens", ".", "pop_back", "(", ")", ";", "}", "return", "getParser", "(", ")", ".", "parseExpression", "(", "Expr", ")", ";", "}", "</s>" ]

[ "Parse", "an", "arbitrary", "expression", "." ]

[ "Hexagon", "Hexagon", "4", "\",\"", "1", "2", "2" ]

[]

[ "<s>", "CCAssignFn", "*", "R600TargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "CC_R600_Kernel", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_LS", ":", "return", "CC_R600", ";", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AMDGPU", "R600", "AMDGPU", "R600", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600", "\"Unsupported calling convention.\"" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "ABI", ".", "IsCheriPureCap", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_LabelDifference32", ";", "if", "(", "ABI", ".", "IsN64", "(", ")", "&&", "isPositionIndependent", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_GPRel64BlockAddress", ";", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "Mips16InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "0", ";", "}", "</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", "." ]

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

[]

[ "<s>", "int", "mem_min_alignment", "(", "rtx", "mem", ",", "int", "desired", ")", "{", "rtx", "addr", ",", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "mem", ")", "!=", "MEM", ")", "return", "0", ";", "if", "(", "!", "TARGET_UNALIGNED_DOUBLES", "&&", "MEM_ALIGN", "(", "mem", ")", "/", "BITS_PER_UNIT", ">=", "(", "unsigned", ")", "desired", ")", "return", "1", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "base", "=", "offset", "=", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "{", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", ")", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "offset", "=", "const0_rtx", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", "{", "base", "=", "addr", ";", "offset", "=", "const0_rtx", ";", "}", "if", "(", "base", "!=", "NULL_RTX", ")", "{", "int", "regno", "=", "REGNO", "(", "base", ")", ";", "if", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "&&", "regno", "!=", "STACK_POINTER_REGNUM", ")", "{", "if", "(", "(", "(", "cfun", "!=", "0", "&&", "REGNO_POINTER_ALIGN", "(", "regno", ")", ">=", "desired", "*", "BITS_PER_UNIT", ")", "||", "(", "optimize", "&&", "reload_completed", ")", ")", "&&", "(", "INTVAL", "(", "offset", ")", "&", "(", "desired", "-", "1", ")", ")", "==", "0", ")", "return", "1", ";", "}", "else", "{", "if", "(", "(", "(", "INTVAL", "(", "offset", ")", "-", "SPARC_STACK_BIAS", ")", "&", "(", "desired", "-", "1", ")", ")", "==", "0", ")", "return", "1", ";", "}", "}", "else", "if", "(", "!", "TARGET_UNALIGNED_DOUBLES", "||", "CONSTANT_P", "(", "addr", ")", "||", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "RTX", "is", "a", "MEM", "which", "is", "known", "to", "be", "aligned", "to", "at", "least", "a", "DESIRED", "byte", "boundary", "." ]

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

[]

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

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

[ "CAHP", "CAHP" ]

[]

[ "<s>", "AMDGPUMCObjectWriter", "*", "AMDGPUAsmBackend", "::", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "{", "return", "new", "AMDGPUMCObjectWriter", "(", "OS", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "AArch64Subtarget", "&", "AArch64Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "FS", ",", "StringRef", "CPUString", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "CPUString", ",", "FS", ")", ";", "initializeProperties", "(", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"generic\"" ]

[]

[ "<s>", "bool", "Nios2AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "ARMConstantPoolSymbol", "*", "ARMConstantPoolSymbol", "::", "Create", "(", "LLVMContext", "&", "C", ",", "StringRef", "s", ",", "ARMCP", "::", "ARMCPModifier", "Modifier", ")", "{", "return", "new", "ARMConstantPoolSymbol", "(", "C", ",", "s", ",", "0", ",", "0", ",", "Modifier", ",", "false", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "ARM", "ARM", "ARM", "ARMCP::ARMCPModifier", "ARM", "0", "0" ]

[]

[ "<s>", "const", "CSKYInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "void", "expand", "(", "enum", "insn_code", "icode", ",", "bool", "temporary_volatile_p", "=", "false", ")", "{", "if", "(", "temporary_volatile_p", ")", "{", "temporary_volatile_ok", "v", "(", "true", ")", ";", "expand_insn", "(", "icode", ",", "m_opno", ",", "m_ops", ")", ";", "}", "else", "expand_insn", "(", "icode", ",", "m_opno", ",", "m_ops", ")", ";", "}", "</s>" ]

[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]

[ "riscv" ]

[]

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

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

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegImm34", "(", "SDValue", "N", ",", "SDValue", "&", "Disp", ",", "SDValue", "&", "Base", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "N", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i64", ")", "return", "false", ";", "SDLoc", "dl", "(", "N", ")", ";", "int64_t", "Imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "!", "isIntS34Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "Imm", ")", ")", "return", "false", ";", "Disp", "=", "DAG", ".", "getTargetConstant", "(", "Imm", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "if", "(", "FrameIndexSDNode", "*", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "N", ".", "getOperand", "(", "0", ")", ")", ")", "Base", "=", "DAG", ".", "getTargetFrameIndex", "(", "FI", "->", "getIndex", "(", ")", ",", "N", ".", "getValueType", "(", ")", ")", ";", "else", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "return", "true", ";", "}", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "!", "isIntS34Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "Imm", ")", ")", "return", "false", ";", "KnownBits", "LHSKnown", "=", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "0", ")", ")", ";", "if", "(", "(", "LHSKnown", ".", "Zero", ".", "getZExtValue", "(", ")", "|", "~", "(", "uint64_t", ")", "Imm", ")", "!=", "~", "0ULL", ")", "return", "false", ";", "if", "(", "FrameIndexSDNode", "*", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "N", ".", "getOperand", "(", "0", ")", ")", ")", "Base", "=", "DAG", ".", "getTargetFrameIndex", "(", "FI", "->", "getIndex", "(", ")", ",", "N", ".", "getValueType", "(", ")", ")", ";", "else", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Disp", "=", "DAG", ".", "getTargetConstant", "(", "Imm", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "return", "true", ";", "}", "if", "(", "isIntS34Immediate", "(", "N", ",", "Imm", ")", ")", "{", "Disp", "=", "DAG", ".", "getTargetConstant", "(", "Imm", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "Base", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "ZERO8", ",", "N", ".", "getValueType", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Similar", "to", "the", "16-bit", "case", "but", "for", "instructions", "that", "take", "a", "34-bit", "displacement", "field", "(", "prefixed", "loads/stores", ")", "." ]

[ "PowerPC", "PPC", "MVT::i64", "0", "ISD::ADD", "1", "0", "0", "ISD::OR", "1", "0", "0ULL", "0", "0", "PPC::ZERO8" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "hasSGPRInitBug", "(", ")", ")", "{", "unsigned", "NumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "unsigned", "Limit", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "4", ";", "for", "(", "unsigned", "i", "=", "Limit", ";", "i", "<", "NumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU", "AMDGPU::SGPR_32RegClass", "AMDGPU", "4", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "SDValue", "AAPTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_AAP", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "AAPRegisterInfo", "::", "getLinkRegister", "(", ")", ",", "MVT", "::", "i16", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "MRI", ".", "disableCalleeSavedRegister", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "AAPISD", "::", "RET_FLAG", ",", "DL", ",", "{", "MVT", "::", "Other", ",", "MVT", "::", "i16", "}", ",", "RetOps", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Subtarget", "->", "requiresStrictAlign", "(", ")", ")", "return", "false", ";", "if", "(", "Fast", ")", "{", "*", "Fast", "=", "!", "Subtarget", "->", "isCyclone", "(", ")", "||", "VT", ".", "getStoreSize", "(", ")", "!=", "16", "||", "Align", "<=", "2", "||", "VT", "==", "MVT", "::", "v2i64", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AArch64", "AArch64", "16", "2", "MVT::v2i64" ]

[]

[ "<s>", "MCELFStreamer", "&", "MipsTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "*", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "Mips", "Mips" ]

[]

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

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

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

[]

[ "<s>", "bool", "m32r_can_eliminate", "(", "const", "int", "from", ",", "const", "int", "to", ")", "{", "return", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", "?", "!", "frame_pointer_needed", ":", "true", ")", ";", "}", "</s>" ]

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

[ "m32r" ]

[]

[ "<s>", "const", "unsigned", "*", "SPURegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "SPU_CalleeSaveRegs", "[", "]", "=", "{", "SPU", "::", "R80", ",", "SPU", "::", "R81", ",", "SPU", "::", "R82", ",", "SPU", "::", "R83", ",", "SPU", "::", "R84", ",", "SPU", "::", "R85", ",", "SPU", "::", "R86", ",", "SPU", "::", "R87", ",", "SPU", "::", "R88", ",", "SPU", "::", "R89", ",", "SPU", "::", "R90", ",", "SPU", "::", "R91", ",", "SPU", "::", "R92", ",", "SPU", "::", "R93", ",", "SPU", "::", "R94", ",", "SPU", "::", "R95", ",", "SPU", "::", "R96", ",", "SPU", "::", "R97", ",", "SPU", "::", "R98", ",", "SPU", "::", "R99", ",", "SPU", "::", "R100", ",", "SPU", "::", "R101", ",", "SPU", "::", "R102", ",", "SPU", "::", "R103", ",", "SPU", "::", "R104", ",", "SPU", "::", "R105", ",", "SPU", "::", "R106", ",", "SPU", "::", "R107", ",", "SPU", "::", "R108", ",", "SPU", "::", "R109", ",", "SPU", "::", "R110", ",", "SPU", "::", "R111", ",", "SPU", "::", "R112", ",", "SPU", "::", "R113", ",", "SPU", "::", "R114", ",", "SPU", "::", "R115", ",", "SPU", "::", "R116", ",", "SPU", "::", "R117", ",", "SPU", "::", "R118", ",", "SPU", "::", "R119", ",", "SPU", "::", "R120", ",", "SPU", "::", "R121", ",", "SPU", "::", "R122", ",", "SPU", "::", "R123", ",", "SPU", "::", "R124", ",", "SPU", "::", "R125", ",", "SPU", "::", "R126", ",", "SPU", "::", "R127", ",", "SPU", "::", "R2", ",", "SPU", "::", "R1", ",", "SPU", "::", "R0", ",", "0", "}", ";", "return", "SPU_CalleeSaveRegs", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::R80", "SPU::R81", "SPU::R82", "SPU::R83", "SPU::R84", "SPU::R85", "SPU::R86", "SPU::R87", "SPU::R88", "SPU::R89", "SPU::R90", "SPU::R91", "SPU::R92", "SPU::R93", "SPU::R94", "SPU::R95", "SPU::R96", "SPU::R97", "SPU::R98", "SPU::R99", "SPU::R100", "SPU::R101", "SPU::R102", "SPU::R103", "SPU::R104", "SPU::R105", "SPU::R106", "SPU::R107", "SPU::R108", "SPU::R109", "SPU::R110", "SPU::R111", "SPU::R112", "SPU::R113", "SPU::R114", "SPU::R115", "SPU::R116", "SPU::R117", "SPU::R118", "SPU::R119", "SPU::R120", "SPU::R121", "SPU::R122", "SPU::R123", "SPU::R124", "SPU::R125", "SPU::R126", "SPU::R127", "SPU::R2", "SPU::R1", "SPU::R0", "0", "SPU" ]

[]

[ "<s>", "static", "bool", "mn10300_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "unsigned", "HOST_WIDE_INT", "size", "=", "arg", ".", "type_size_in_bytes", "(", ")", ";", "return", "(", "size", ">", "8", "||", "size", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "parameter", "should", "be", "passed", "by", "reference", "." ]

[ "mn10300", "8", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "setSpecialOperandAttr", "(", "MachineInstr", "&", "OldMI1", ",", "MachineInstr", "&", "OldMI2", ",", "MachineInstr", "&", "NewMI1", ",", "MachineInstr", "&", "NewMI2", ")", "const", "{", "MachineOperand", "*", "OldFlagDef1", "=", "OldMI1", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "MachineOperand", "*", "OldFlagDef2", "=", "OldMI2", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "assert", "(", "!", "OldFlagDef1", "==", "!", "OldFlagDef2", "&&", "\"Unexpected instruction type for reassociation\"", ")", ";", "if", "(", "!", "OldFlagDef1", "||", "!", "OldFlagDef2", ")", "return", ";", "assert", "(", "OldFlagDef1", "->", "isDead", "(", ")", "&&", "OldFlagDef2", "->", "isDead", "(", ")", "&&", "\"Must have dead EFLAGS operand in reassociable instruction\"", ")", ";", "MachineOperand", "*", "NewFlagDef1", "=", "NewMI1", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "MachineOperand", "*", "NewFlagDef2", "=", "NewMI2", ".", "findRegisterDefOperand", "(", "X86", "::", "EFLAGS", ")", ";", "assert", "(", "NewFlagDef1", "&&", "NewFlagDef2", "&&", "\"Unexpected operand in reassociable instruction\"", ")", ";", "NewFlagDef1", "->", "setIsDead", "(", ")", ";", "NewFlagDef2", "->", "setIsDead", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "thumb2_output_casesi", "(", "rtx", "*", "operands", ")", "{", "rtx", "diff_vec", "=", "PATTERN", "(", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "operands", "[", "2", "]", ")", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "diff_vec", ")", "==", "ADDR_DIFF_VEC", ")", ";", "output_asm_insn", "(", "\"cmp\\t%0, %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"bhi\\t%l3\"", ",", "operands", ")", ";", "switch", "(", "GET_MODE", "(", "diff_vec", ")", ")", "{", "case", "QImode", ":", "return", "\"tbb\\t[%|pc, %0]\"", ";", "case", "HImode", ":", "return", "\"tbh\\t[%|pc, %0, lsl #1]\"", ";", "case", "SImode", ":", "if", "(", "flag_pic", ")", "{", "output_asm_insn", "(", "\"adr\\t%4, %l2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr\\t%5, [%4, %0, lsl #2]\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add\\t%4, %4, %5\"", ",", "operands", ")", ";", "return", "\"bx\\t%4\"", ";", "}", "else", "{", "output_asm_insn", "(", "\"adr\\t%4, %l2\"", ",", "operands", ")", ";", "return", "\"ldr\\t%|pc, [%4, %0, lsl #2]\"", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "Thumb-2", "casesi", "instruction", "." ]

[ "arm", "2", "\"cmp\\t%0, %1\"", "\"bhi\\t%l3\"", "\"tbb\\t[%|pc, %0]\"", "\"tbh\\t[%|pc, %0, lsl #1]\"", "\"adr\\t%4, %l2\"", "\"ldr\\t%5, [%4, %0, lsl #2]\"", "\"add\\t%4, %4, %5\"", "\"bx\\t%4\"", "\"adr\\t%4, %l2\"", "\"ldr\\t%|pc, [%4, %0, lsl #2]\"" ]

[]

[ "<s>", "RISCVSubtarget", "&", "RISCVSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "CPUName", "=", "\"\"", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "\"\"" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "struct", "sparc_args", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "cum", "->", "words", "=", "0", ";", "cum", "->", "prototype_p", "=", "fntype", "&&", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "cum", "->", "libcall_p", "=", "fntype", "==", "0", ";", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

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

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "isFixedRegister", "(", "const", "MachineFunction", "&", "MF", ",", "MCRegister", "PhysReg", ")", "const", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "ST", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "TRI", ".", "isSuperOrSubRegisterEq", "(", "X86", "::", "RSP", ",", "PhysReg", ")", ")", "return", "true", ";", "const", "X86FrameLowering", "&", "TFI", "=", "*", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "TFI", ".", "hasFP", "(", "MF", ")", "&&", "TRI", ".", "isSuperOrSubRegisterEq", "(", "X86", "::", "RBP", ",", "PhysReg", ")", ")", "return", "true", ";", "return", "X86GenRegisterInfo", "::", "isFixedRegister", "(", "MF", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "a", "fixed", "register", "." ]

[ "X86", "X86", "X86", "X86", "X86::RSP", "X86", "X86::RBP", "X86" ]

[]

[ "<s>", "unsigned", "MOSInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "MOS", "::", "LDAbs", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", ")", "return", "0", ";", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "case", "MOS", "::", "LDStk", ":", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "</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", "." ]

[ "MOS", "MOS", "0", "MOS::LDAbs", "0", "0", "1", "0", "MOS::LDStk", "2", "0" ]

[]

[ "<s>", "bool", "ARM64AdvSIMDScalar", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "if", "(", "!", "AdvSIMDScalar", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** ARM64AdvSIMDScalar *****\\n\"", ")", ";", "const", "TargetMachine", "&", "TM", "=", "mf", ".", "getTarget", "(", ")", ";", "MRI", "=", "&", "mf", ".", "getRegInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "mf", ".", "begin", "(", ")", ",", "E", "=", "mf", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "processMachineBasicBlock", "(", "I", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"***** ARM64AdvSIMDScalar *****\\n\"", "ARM64" ]

[]

[ "<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", ")", "{", "static", "const", "char", "*", "const", "hand_list", "[", "]", "=", "{", "\"__main\"", ",", "\"__cmpsi2\"", ",", "\"__divhi3\"", ",", "\"__modhi3\"", ",", "\"__udivhi3\"", ",", "\"__umodhi3\"", ",", "\"__divsi3\"", ",", "\"__modsi3\"", ",", "\"__udivsi3\"", ",", "\"__umodsi3\"", ",", "\"__mulhi3\"", ",", "\"__mulsi3\"", ",", "\"__reg_memcpy\"", ",", "\"__reg_memset\"", ",", "\"__ucmpsi2\"", ",", "0", ",", "}", ";", "rtx", "result", "=", "NULL_RTX", ";", "const", "char", "*", "fname", ";", "int", "regpass", "=", "0", ";", "if", "(", "!", "named", ")", "return", "NULL_RTX", ";", "if", "(", "TARGET_QUICKCALL", ")", "regpass", "=", "3", ";", "if", "(", "cum", "->", "libcall", ")", "{", "const", "char", "*", "const", "*", "p", ";", "fname", "=", "XSTR", "(", "cum", "->", "libcall", ",", "0", ")", ";", "for", "(", "p", "=", "hand_list", ";", "*", "p", "&&", "strcmp", "(", "*", "p", ",", "fname", ")", "!=", "0", ";", "p", "++", ")", ";", "if", "(", "*", "p", ")", "regpass", "=", "4", ";", "}", "if", "(", "regpass", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "size", "+", "cum", "->", "nbytes", "<=", "regpass", "*", "UNITS_PER_WORD", "&&", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", "<=", "3", ")", "result", "=", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

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

[ "h8300", "\"__main\"", "\"__cmpsi2\"", "\"__divhi3\"", "\"__modhi3\"", "\"__udivhi3\"", "\"__umodhi3\"", "\"__divsi3\"", "\"__modsi3\"", "\"__udivsi3\"", "\"__umodsi3\"", "\"__mulhi3\"", "\"__mulsi3\"", "\"__reg_memcpy\"", "\"__reg_memset\"", "\"__ucmpsi2\"", "0", "0", "3", "0", "0", "4", "3" ]

[]

[ "<s>", "bool", "expand_move", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "op", "=", "operands", "[", "1", "]", ";", "if", "(", "(", "reload_in_progress", "|", "reload_completed", ")", "==", "0", "&&", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "GET_CODE", "(", "op", ")", "!=", "REG", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "op", ")", ";", "else", "if", "(", "mode", "==", "SImode", "&&", "symbolic_operand", "(", "op", ",", "SImode", ")", ")", "{", "if", "(", "flag_pic", ")", "{", "if", "(", "sdata_symbolic_operand", "(", "op", ",", "SImode", ")", ")", "{", "emit_insn", "(", "gen_load_sdata_pic", "(", "dest", ",", "pic_offset_table_rtx", ",", "op", ")", ")", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "return", "true", ";", "}", "else", "{", "rtx", "temp", "=", "(", "reload_completed", "||", "reload_in_progress", "?", "dest", ":", "gen_reg_rtx", "(", "Pmode", ")", ")", ";", "operands", "[", "1", "]", "=", "legitimize_pic_address", "(", "op", ",", "temp", ",", "pic_offset_table_rtx", ")", ";", "}", "}", "else", "if", "(", "reload_completed", "&&", "!", "sdata_symbolic_operand", "(", "op", ",", "SImode", ")", ")", "{", "emit_insn", "(", "gen_movsi_high", "(", "dest", ",", "op", ")", ")", ";", "emit_insn", "(", "gen_movsi_lo_sum", "(", "dest", ",", "dest", ",", "op", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "move", "operation", "in", "mode", "MODE", ".", "The", "operands", "are", "in", "OPERANDS", "." ]

[ "c6x", "0", "1", "0", "1", "1", "1" ]

[]

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

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

[ "P2", "P2::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "gen_conditional_move", "(", "rtx", "*", "operands", ")", "{", "enum", "rtx_code", "code", ";", "rtx", "op0", ",", "op1", ";", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "mips_emit_compare", "(", "&", "code", ",", "&", "op0", ",", "&", "op1", ",", "true", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "op1", ")", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "common", "code", "for", "conditional", "moves", ".", "OPERANDS", "is", "the", "array", "of", "operands", "passed", "to", "the", "conditional", "move", "define_expand", "." ]

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

[]

[ "<s>", "static", "bool", "m68k_tls_symbol_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "TLS", "symbol", "." ]

[ "m68k", "0" ]

[]

[ "<s>", "bool", "symbolic_reference_mentioned_p", "(", "rtx", "op", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "true", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "a", "symbol", "reference" ]

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

[]

[ "<s>", "void", "sh_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", ",", "signed", "int", "n_named_args", ",", "machine_mode", "mode", ")", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_FLOAT", "]", "=", "0", ";", "pcum", "->", "free_single_fp_reg", "=", "0", ";", "pcum", "->", "outgoing", "=", "n_named_args", "!=", "-", "1", ";", "pcum", "->", "renesas_abi", "=", "sh_attr_renesas_p", "(", "fntype", ")", ";", "if", "(", "fntype", ")", "{", "pcum", "->", "force_mem", "=", "(", "(", "TARGET_HITACHI", "||", "pcum", "->", "renesas_abi", ")", "&&", "aggregate_value_p", "(", "TREE_TYPE", "(", "fntype", ")", ",", "fndecl", ")", ")", ";", "pcum", "->", "prototype_p", "=", "prototype_p", "(", "fntype", ")", ";", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "false", ";", "}", "else", "{", "pcum", "->", "arg_count", "[", "(", "int", ")", "SH_ARG_INT", "]", "=", "0", ";", "pcum", "->", "prototype_p", "=", "false", ";", "if", "(", "mode", "!=", "VOIDmode", ")", "{", "pcum", "->", "force_mem", "=", "(", "TARGET_DEFAULT", "&", "MASK_HITACHI", ")", "&&", "(", "mode", "==", "BLKmode", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "!", "(", "mode", "==", "DFmode", "&&", "TARGET_FPU_DOUBLE", ")", ")", ")", ";", "}", "else", "pcum", "->", "force_mem", "=", "false", ";", "}", "}", "</s>" ]

[ "Initialize", "the", "CUMULATIVE_ARGS", "structure", "." ]

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

[]

[ "<s>", "static", "void", "expand_block_move_1", "(", "rtx", "dst_reg", ",", "rtx", "src_reg", ",", "rtx", "bytes_rtx", ")", "{", "emit_library_call", "(", "byt_memcpy_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "dst_reg", ",", "Pmode", ",", "src_reg", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "move", "BYTES_RTX", "bytes", "from", "address", "SRC_REG", "to", "address", "DST_REG", "in", "1-byte", "chunks", "." ]

[ "visium", "3" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "parseMnemonicSuffix", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "case", "MatchOperand_NoMatch", ":", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"not a valid operand.\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "static", "rtx", "arm_expand_vfp_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", ">=", "ARM_BUILTIN_VFP_BASE", "&&", "!", "TARGET_HARD_FLOAT", ")", "{", "fatal_error", "(", "input_location", ",", "\"You must enable VFP instructions\"", "\" to use these intrinsics.\"", ")", ";", "return", "const0_rtx", ";", "}", "arm_builtin_datum", "*", "d", "=", "&", "vfp_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_VFP_PATTERN_START", "]", ";", "return", "arm_expand_builtin_1", "(", "fcode", ",", "exp", ",", "target", ",", "d", ")", ";", "}", "</s>" ]

[ "Expand", "a", "VFP", "builtin", ".", "These", "builtins", "are", "treated", "like", "neon", "builtins", "except", "that", "the", "data", "is", "looked", "up", "in", "table", "VFP_BUILTIN_DATA", "." ]

[ "arm", "\"You must enable VFP instructions\"", "\" to use these intrinsics.\"" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_function_return", "(", "bool", "long_p", ")", "{", "output_return_instrumentation", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_keep", ")", "{", "char", "thunk_name", "[", "32", "]", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_thunk_inline", ")", "{", "bool", "need_thunk", "=", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk", ")", ";", "indirect_thunk_name", "(", "thunk_name", ",", "INVALID_REGNUM", ",", "need_prefix", ",", "true", ")", ";", "indirect_return_needed", "|=", "need_thunk", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "thunk_name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "else", "output_indirect_thunk", "(", "INVALID_REGNUM", ")", ";", "return", "\"\"", ";", "}", "output_asm_insn", "(", "long_p", "?", "\"rep%; ret\"", ":", "\"ret\"", ",", "nullptr", ")", ";", "return", "(", "ix86_harden_sls", "&", "harden_sls_return", ")", "?", "\"int3\"", ":", "\"\"", ";", "}", "</s>" ]

[ "Output", "function", "return", ".", "CALL_OP", "is", "the", "jump", "target", ".", "Add", "a", "REP", "prefix", "to", "RET", "if", "LONG_P", "is", "true", "and", "function", "return", "is", "kept", "." ]

[ "i386", "32", "\"\\tjmp\\t\"", "\"\"", "\"rep%; ret\"", "\"ret\"", "\"int3\"", "\"\"" ]

[]

[ "<s>", "const", "X86_64GNULDBackend", "&", "getTarget", "(", ")", "const", "{", "return", "m_Target", ";", "}", "</s>" ]

[ "getTarget", "-", "Return", "the", "target", "machine", "this", "machine", "code", "is", "compiled", "with" ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AArch64Operand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "RegKind", "Kind", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MCContext", "&", "Ctx", ",", "AArch64_AM", "::", "ShiftExtendType", "ExtTy", "=", "AArch64_AM", "::", "LSL", ",", "unsigned", "ShiftAmount", "=", "0", ",", "unsigned", "HasExplicitAmount", "=", "false", ")", "{", "auto", "Op", "=", "make_unique", "<", "AArch64Operand", ">", "(", "k_Register", ",", "Ctx", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "Reg", ".", "Kind", "=", "Kind", ";", "Op", "->", "Reg", ".", "ElementWidth", "=", "0", ";", "Op", "->", "Reg", ".", "ShiftExtend", ".", "Type", "=", "ExtTy", ";", "Op", "->", "Reg", ".", "ShiftExtend", ".", "Amount", "=", "ShiftAmount", ";", "Op", "->", "Reg", ".", "ShiftExtend", ".", "HasExplicitAmount", "=", "HasExplicitAmount", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "AArch64", "AArch64", "AArch64_AM::ShiftExtendType", "AArch64_AM::LSL", "0", "AArch64", "0" ]

[]

[ "<s>", "static", "void", "riscv_option_override", "(", "void", ")", "{", "const", "struct", "riscv_cpu_info", "*", "cpu", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "flag_pcc_struct_return", "=", "0", ";", "if", "(", "flag_pic", ")", "g_switch_value", "=", "0", ";", "if", "(", "TARGET_MUL", "&&", "(", "target_flags_explicit", "&", "MASK_DIV", ")", "==", "0", ")", "target_flags", "|=", "MASK_DIV", ";", "else", "if", "(", "!", "TARGET_MUL", "&&", "TARGET_DIV", ")", "error", "(", "\"-mdiv requires -march to subsume the %<M%> extension\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "(", "target_flags_explicit", "&", "MASK_FDIV", ")", "==", "0", ")", "target_flags", "|=", "MASK_FDIV", ";", "cpu", "=", "riscv_parse_cpu", "(", "riscv_tune_string", "?", "riscv_tune_string", ":", "RISCV_TUNE_STRING_DEFAULT", ")", ";", "tune_info", "=", "optimize_size", "?", "&", "optimize_size_tune_info", ":", "cpu", "->", "tune_info", ";", "riscv_slow_unaligned_access_p", "=", "(", "cpu", "->", "tune_info", "->", "slow_unaligned_access", "||", "TARGET_STRICT_ALIGN", ")", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_STRICT_ALIGN", ")", "==", "0", "&&", "cpu", "->", "tune_info", "->", "slow_unaligned_access", ")", "target_flags", "|=", "MASK_STRICT_ALIGN", ";", "if", "(", "riscv_branch_cost", "==", "0", ")", "riscv_branch_cost", "=", "tune_info", "->", "branch_cost", ";", "init_machine_status", "=", "&", "riscv_init_machine_status", ";", "if", "(", "flag_pic", ")", "riscv_cmodel", "=", "CM_PIC", ";", "if", "(", "(", "target_flags_explicit", "&", "MASK_EXPLICIT_RELOCS", ")", "==", "0", ")", "if", "(", "riscv_cmodel", "==", "CM_MEDLOW", ")", "target_flags", "|=", "MASK_EXPLICIT_RELOCS", ";", "if", "(", "UNITS_PER_FP_ARG", ">", "(", "TARGET_HARD_FLOAT", "?", "UNITS_PER_FP_REG", ":", "0", ")", ")", "error", "(", "\"requested ABI requires -march to subsume the %qc extension\"", ",", "UNITS_PER_FP_ARG", ">", "8", "?", "'Q'", ":", "(", "UNITS_PER_FP_ARG", ">", "4", "?", "'D'", ":", "'F'", ")", ")", ";", "if", "(", "BITS_PER_WORD", "!=", "POINTER_SIZE", ")", "error", "(", "\"ABI requires -march=rv%d\"", ",", "POINTER_SIZE", ")", ";", "riscv_stack_boundary", "=", "ABI_STACK_BOUNDARY", ";", "if", "(", "riscv_preferred_stack_boundary_arg", ")", "{", "int", "min", "=", "ctz_hwi", "(", "STACK_BOUNDARY", "/", "8", ")", ";", "int", "max", "=", "8", ";", "if", "(", "!", "IN_RANGE", "(", "riscv_preferred_stack_boundary_arg", ",", "min", ",", "max", ")", ")", "error", "(", "\"-mpreferred-stack-boundary=%d must be between %d and %d\"", ",", "riscv_preferred_stack_boundary_arg", ",", "min", ",", "max", ")", ";", "riscv_stack_boundary", "=", "8", "<<", "riscv_preferred_stack_boundary_arg", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "riscv", "0", "0", "0", "\"-mdiv requires -march to subsume the %<M%> extension\"", "0", "0", "0", "0", "0", "\"requested ABI requires -march to subsume the %qc extension\"", "8", "4", "\"ABI requires -march=rv%d\"", "8", "8", "\"-mpreferred-stack-boundary=%d must be between %d and %d\"", "8" ]

[]

[ "<s>", "SDValue", "TL45TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "lowerBrCc", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "lowerSelectCc", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "return", "lowerAnd", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "lowerOr", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "lowerXor", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "TL45", "TL45", "\"unimplemented operand\"", "ISD::BR_CC", "ISD::SELECT", "ISD::SELECT_CC", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::VASTART", "ISD::GlobalAddress" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "bool", "IsImmutable", "=", "!", "Flags", ".", "isByVal", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "IsImmutable", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "return", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "32", ")", ",", "FI", ")", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "ARM", "ISD::ArgFlagsTy", "1", "2", "4", "8", "\"Unsupported size\"", "32", "0" ]

[]

[ "<s>", "static", "void", "ix86_finalize_stack_realign_flags", "(", "void", ")", "{", "unsigned", "int", "incoming_stack_boundary", "=", "(", "crtl", "->", "parm_stack_boundary", ">", "ix86_incoming_stack_boundary", "?", "crtl", "->", "parm_stack_boundary", ":", "ix86_incoming_stack_boundary", ")", ";", "unsigned", "int", "stack_realign", "=", "(", "incoming_stack_boundary", "<", "(", "crtl", "->", "is_leaf", "?", "crtl", "->", "max_used_stack_slot_alignment", ":", "crtl", "->", "stack_alignment_needed", ")", ")", ";", "if", "(", "crtl", "->", "stack_realign_finalized", ")", "{", "gcc_assert", "(", "crtl", "->", "stack_realign_needed", "==", "stack_realign", ")", ";", "return", ";", "}", "if", "(", "stack_realign", "&&", "frame_pointer_needed", "&&", "crtl", "->", "is_leaf", "&&", "flag_omit_frame_pointer", "&&", "crtl", "->", "sp_is_unchanging", "&&", "!", "ix86_current_function_calls_tls_descriptor", "&&", "!", "crtl", "->", "accesses_prior_frames", "&&", "!", "cfun", "->", "calls_alloca", "&&", "!", "crtl", "->", "calls_eh_return", "&&", "!", "(", "flag_stack_check", "&&", "STACK_CHECK_MOVING_SP", ")", "&&", "!", "ix86_frame_pointer_required", "(", ")", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "ix86_nsaved_sseregs", "(", ")", "==", "0", "&&", "ix86_varargs_gpr_size", "+", "ix86_varargs_fpr_size", "==", "0", ")", "{", "HARD_REG_SET", "set_up_by_prologue", ",", "prologue_used", ";", "basic_block", "bb", ";", "CLEAR_HARD_REG_SET", "(", "prologue_used", ")", ";", "CLEAR_HARD_REG_SET", "(", "set_up_by_prologue", ")", ";", "add_to_hard_reg_set", "(", "&", "set_up_by_prologue", ",", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "add_to_hard_reg_set", "(", "&", "set_up_by_prologue", ",", "Pmode", ",", "ARG_POINTER_REGNUM", ")", ";", "add_to_hard_reg_set", "(", "&", "set_up_by_prologue", ",", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", "&&", "requires_stack_frame_p", "(", "insn", ",", "prologue_used", ",", "set_up_by_prologue", ")", ")", "{", "crtl", "->", "stack_realign_needed", "=", "stack_realign", ";", "crtl", "->", "stack_realign_finalized", "=", "true", ";", "return", ";", "}", "}", "if", "(", "crtl", "->", "drap_reg", ")", "{", "basic_block", "bb", "=", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "next_bb", ";", "if", "(", "!", "REGNO_REG_SET_P", "(", "DF_LR_IN", "(", "bb", ")", ",", "REGNO", "(", "crtl", "->", "drap_reg", ")", ")", ")", "{", "crtl", "->", "drap_reg", "=", "NULL_RTX", ";", "crtl", "->", "need_drap", "=", "false", ";", "}", "}", "else", "cfun", "->", "machine", "->", "no_drap_save_restore", "=", "true", ";", "frame_pointer_needed", "=", "false", ";", "stack_realign", "=", "false", ";", "crtl", "->", "max_used_stack_slot_alignment", "=", "incoming_stack_boundary", ";", "crtl", "->", "stack_alignment_needed", "=", "incoming_stack_boundary", ";", "crtl", "->", "stack_alignment_estimated", "=", "incoming_stack_boundary", ";", "if", "(", "crtl", "->", "preferred_stack_boundary", ">", "incoming_stack_boundary", ")", "crtl", "->", "preferred_stack_boundary", "=", "incoming_stack_boundary", ";", "df_finish_pass", "(", "true", ")", ";", "df_scan_alloc", "(", "NULL", ")", ";", "df_scan_blocks", "(", ")", ";", "df_compute_regs_ever_live", "(", "true", ")", ";", "df_analyze", "(", ")", ";", "}", "crtl", "->", "stack_realign_needed", "=", "stack_realign", ";", "crtl", "->", "stack_realign_finalized", "=", "true", ";", "}", "</s>" ]

[ "Finalize", "stack_realign_needed", "flag", ",", "which", "will", "guide", "prologue/epilogue", "to", "be", "generated", "in", "correct", "form", "." ]

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

[]

[ "<s>", "static", "void", "sh_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "const", "unsigned", "SH_FE_INVALID", "=", "64", ";", "const", "unsigned", "SH_FE_DIVBYZERO", "=", "32", ";", "const", "unsigned", "SH_FE_OVERFLOW", "=", "16", ";", "const", "unsigned", "SH_FE_UNDERFLOW", "=", "8", ";", "const", "unsigned", "SH_FE_INEXACT", "=", "4", ";", "const", "unsigned", "HOST_WIDE_INT", "SH_FE_ALL_EXCEPT", "=", "(", "SH_FE_INVALID", "|", "SH_FE_DIVBYZERO", "|", "SH_FE_OVERFLOW", "|", "SH_FE_UNDERFLOW", "|", "SH_FE_INEXACT", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "SH_FE_EXCEPT_SHIFT", "=", "5", ";", "tree", "fenv_var", ",", "mask", ",", "ld_fenv", ",", "masked_fenv", ";", "tree", "new_fenv_var", ",", "reload_fenv", ",", "restore_fnenv", ";", "tree", "update_call", ",", "atomic_feraiseexcept", ",", "hold_fnclex", ";", "if", "(", "!", "TARGET_FPU_ANY", ")", "return", ";", "fenv_var", "=", "create_tmp_var", "(", "unsigned_type_node", ")", ";", "mask", "=", "build_int_cst", "(", "unsigned_type_node", ",", "~", "(", "(", "SH_FE_ALL_EXCEPT", "<<", "SH_FE_EXCEPT_SHIFT", ")", "|", "SH_FE_ALL_EXCEPT", ")", ")", ";", "ld_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "sh_builtin_get_fpscr", ",", "0", ")", ")", ";", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "sh_builtin_set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "masked_fenv", ",", "ld_fenv", ")", ",", "hold_fnclex", ")", ";", "*", "clear", "=", "build_call_expr", "(", "sh_builtin_set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "new_fenv_var", "=", "create_tmp_var", "(", "unsigned_type_node", ")", ";", "reload_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "unsigned_type_node", ",", "new_fenv_var", ",", "build_call_expr", "(", "sh_builtin_get_fpscr", ",", "0", ")", ")", ";", "restore_fnenv", "=", "build_call_expr", "(", "sh_builtin_set_fpscr", ",", "1", ",", "fenv_var", ")", ";", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "new_fenv_var", ")", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "reload_fenv", ",", "restore_fnenv", ")", ",", "update_call", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

[ "sh", "64", "32", "16", "8", "4", "5", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "static", "bool", "bpf_hard_regno_mode_ok", "(", "unsigned", "int", "regno", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_HImode", ":", "case", "E_QImode", ":", "case", "E_TImode", ":", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "permissible", "to", "store", "a", "value", "of", "mode", "MODE", "in", "hard", "register", "number", "REGNO", ",", "or", "in", "several", "registers", "starting", "with", "that", "one", "." ]

[ "bpf" ]

[]

[ "<s>", "void", "ix86_set_current_function", "(", "tree", "fndecl", ")", "{", "if", "(", "fndecl", "==", "ix86_previous_fndecl", ")", "{", "if", "(", "fndecl", "!=", "NULL_TREE", ")", "{", "ix86_set_func_type", "(", "fndecl", ")", ";", "ix86_set_indirect_branch_type", "(", "fndecl", ")", ";", "}", "return", ";", "}", "tree", "old_tree", ";", "if", "(", "ix86_previous_fndecl", "==", "NULL_TREE", ")", "old_tree", "=", "target_option_current_node", ";", "else", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "ix86_previous_fndecl", ")", ")", "old_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "ix86_previous_fndecl", ")", ";", "else", "old_tree", "=", "target_option_default_node", ";", "if", "(", "fndecl", "==", "NULL_TREE", ")", "{", "if", "(", "old_tree", "!=", "target_option_current_node", ")", "ix86_reset_previous_fndecl", "(", ")", ";", "return", ";", "}", "ix86_set_func_type", "(", "fndecl", ")", ";", "ix86_set_indirect_branch_type", "(", "fndecl", ")", ";", "tree", "new_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "new_tree", "==", "NULL_TREE", ")", "new_tree", "=", "target_option_default_node", ";", "bool", "fp_flag_change", "=", "(", "flag_unsafe_math_optimizations", "!=", "TREE_TARGET_OPTION", "(", "new_tree", ")", "->", "x_ix86_unsafe_math_optimizations", "||", "(", "flag_excess_precision", "!=", "TREE_TARGET_OPTION", "(", "new_tree", ")", "->", "x_ix86_excess_precision", ")", ")", ";", "if", "(", "old_tree", "!=", "new_tree", "||", "fp_flag_change", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "fp_flag_change", ")", "{", "ix86_excess_precision", "=", "flag_excess_precision", ";", "ix86_unsafe_math_optimizations", "=", "flag_unsafe_math_optimizations", ";", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_tree", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "ix86_previous_fndecl", "=", "fndecl", ";", "static", "bool", "prev_no_caller_saved_registers", ";", "if", "(", "TARGET_64BIT", "&&", "(", "call_used_or_fixed_reg_p", "(", "SI_REG", ")", "==", "(", "cfun", "->", "machine", "->", "call_abi", "==", "MS_ABI", ")", ")", ")", "reinit_regs", "(", ")", ";", "else", "if", "(", "prev_no_caller_saved_registers", "!=", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "reinit_regs", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", "||", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "{", "const", "char", "*", "isa", ";", "if", "(", "TARGET_SSE", ")", "isa", "=", "\"SSE\"", ";", "else", "if", "(", "TARGET_MMX", ")", "isa", "=", "\"MMX/3Dnow\"", ";", "else", "if", "(", "TARGET_80387", ")", "isa", "=", "\"80387\"", ";", "else", "isa", "=", "NULL", ";", "if", "(", "isa", "!=", "NULL", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "sorry", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_EXCEPTION", "?", "G_", "(", "\"%s instructions aren%'t allowed in an\"", "\" exception service routine\"", ")", ":", "G_", "(", "\"%s instructions aren%'t allowed in an\"", "\" interrupt service routine\"", ")", ",", "isa", ")", ";", "else", "sorry", "(", "\"%s instructions aren%'t allowed in a function with \"", "\"the %<no_caller_saved_registers%> attribute\"", ",", "isa", ")", ";", "cfun", "->", "machine", "->", "func_type", "=", "TYPE_NORMAL", ";", "cfun", "->", "machine", "->", "no_caller_saved_registers", "=", "false", ";", "}", "}", "prev_no_caller_saved_registers", "=", "cfun", "->", "machine", "->", "no_caller_saved_registers", ";", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "i386", "\"SSE\"", "\"MMX/3Dnow\"", "\"80387\"", "\"%s instructions aren%'t allowed in an\"", "\" exception service routine\"", "\"%s instructions aren%'t allowed in an\"", "\" interrupt service routine\"", "\"%s instructions aren%'t allowed in a function with \"", "\"the %<no_caller_saved_registers%> attribute\"" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "BREV", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "bool", "UPTInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "UPT", "::", "MOVi32", ":", "{", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "bool", "DstIsDead", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "auto", "LO16", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "UPT", "::", "MOVLOi16", ")", ",", "DstReg", ")", ";", "auto", "HI16", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "UPT", "::", "MOVHIi16", ")", ")", ".", "addReg", "(", "DstReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "DstIsDead", ")", ")", ".", "addReg", "(", "DstReg", ")", ";", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "const", "unsigned", "TF", "=", "MO", ".", "getTargetFlags", "(", ")", ";", "LO16", "=", "LO16", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "TF", "|", "UPTII", "::", "MO_LO16", ")", ";", "HI16", "=", "HI16", ".", "addGlobalAddress", "(", "GV", ",", "MO", ".", "getOffset", "(", ")", ",", "TF", "|", "UPTII", "::", "MO_HI16", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "}", "}", "</s>" ]

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

[ "UPT", "UPT", "UPT::MOVi32", "0", "0", "1", "UPT::MOVLOi16", "UPT::MOVHIi16", "UPTII::MO_LO16", "UPTII::MO_HI16" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "LowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "LowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::BR_JT", "ISD::LOAD", "ISD::STORE", "ISD::SELECT_CC", "ISD::VAARG", "ISD::VASTART", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "\"unimplemented operand\"" ]

[]

[ "<s>", "static", "void", "mcore_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "fprintf", "(", "f", ",", "\"\\t.short\t0x7102\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.short\t0x7d02\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.short\t0x00cd\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.short\t0x1e00\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.long\t0\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.long\t0\\n\"", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_ASM_TRAMPOLINE_TEMPLATE", ".", "Output", "assembler", "code", "for", "a", "block", "containing", "the", "constant", "parts", "of", "a", "trampoline", ",", "leaving", "space", "for", "the", "variable", "parts", ".", "On", "the", "MCore", ",", "the", "trampoline", "looks", "like", ":", "lrw", "r1", ",", "function", "lrw", "r13", ",", "area", "jmp", "r13", "or", "r0", ",", "r0", ".literals" ]

[ "mcore", "\"\\t.short\t0x7102\\n\"", "\"\\t.short\t0x7d02\\n\"", "\"\\t.short\t0x00cd\\n\"", "\"\\t.short\t0x1e00\\n\"", "\"\\t.long\t0\\n\"", "\"\\t.long\t0\\n\"" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "PPCTargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getPointerOperand", "(", ")", "->", "getType", "(", ")", "->", "getPointerElementType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "EnableQuadwordAtomics", "&&", "Subtarget", ".", "hasQuadwordAtomics", "(", ")", "&&", "Size", "==", "128", ")", "return", "AtomicExpansionKind", "::", "MaskedIntrinsic", ";", "return", "TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AI", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

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

[]

[ "<s>", "int", "tilepro_asm_preferred_eh_data_format", "(", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "global", ")", "{", "return", "(", "global", "?", "DW_EH_PE_indirect", ":", "0", ")", "|", "DW_EH_PE_pcrel", "|", "DW_EH_PE_sdata4", ";", "}", "</s>" ]

[ "Select", "a", "format", "to", "encode", "pointers", "in", "exception", "handling", "data", ".", "CODE", "is", "0", "for", "data", ",", "1", "for", "code", "labels", ",", "2", "for", "function", "pointers", ".", "GLOBAL", "is", "true", "if", "the", "symbol", "may", "be", "affected", "by", "dynamic", "relocations", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "bool", "fusion_p9_p", "(", "rtx", "addis_reg", ",", "rtx", "addis_value", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "rtx", "addr", ",", "mem", ",", "offset", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "if", "(", "!", "base_reg_operand", "(", "addis_reg", ",", "GET_MODE", "(", "addis_reg", ")", ")", ")", "return", "false", ";", "if", "(", "!", "fusion_gpr_addis", "(", "addis_value", ",", "GET_MODE", "(", "addis_value", ")", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "FLOAT_EXTEND", "||", "GET_CODE", "(", "src", ")", "==", "ZERO_EXTEND", ")", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "fpr_reg_operand", "(", "src", ",", "mode", ")", "||", "int_reg_operand", "(", "src", ",", "mode", ")", ")", "{", "if", "(", "!", "MEM_P", "(", "dest", ")", ")", "return", "false", ";", "mem", "=", "dest", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", ")", "{", "if", "(", "!", "fpr_reg_operand", "(", "dest", ",", "mode", ")", "&&", "!", "int_reg_operand", "(", "dest", ",", "mode", ")", ")", "return", "false", ";", "mem", "=", "src", ";", "}", "else", "return", "false", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "addis_reg", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "return", "false", ";", "return", "satisfies_constraint_I", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "addis_reg", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "return", "false", ";", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "TARGET_XCOFF", "||", "(", "TARGET_ELF", "&&", "TARGET_POWERPC64", ")", ")", "return", "small_toc_ref", "(", "offset", ",", "GET_MODE", "(", "offset", ")", ")", ";", "else", "if", "(", "TARGET_ELF", "&&", "!", "TARGET_POWERPC64", ")", "return", "CONSTANT_P", "(", "offset", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "peephole2", "can", "combine", "a", "load/store", "involving", "a", "combination", "of", "an", "addis", "instruction", "and", "the", "memory", "operation", ".", "This", "was", "added", "to", "the", "ISA", "3.0", "(", "power9", ")", "hardware", "." ]

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

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "const", "HexagonRegisterInfo", "*", "QRI", "=", "static_cast", "<", "const", "HexagonRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "determineFrameLayout", "(", "MF", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "HexagonMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "AdjustRegs", "=", "FuncInfo", "->", "getAllocaAdjustInsts", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "MachineInstr", "*", ">", "::", "const_iterator", "i", "=", "AdjustRegs", ".", "begin", "(", ")", ",", "e", "=", "AdjustRegs", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineInstr", "*", "MI", "=", "*", "i", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJDYNALLOC", ")", "&&", "\"Expected adjust alloca node\"", ")", ";", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "2", ")", ";", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Expected immediate\"", ")", ";", "MO", ".", "setImm", "(", "MFI", "->", "getMaxCallFrameSize", "(", ")", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "int", "ALLOCFRAME_MAX", "=", "16384", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "NumBytes", ">=", "ALLOCFRAME_MAX", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "S2_allocframe", ")", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "CONST32_Int_Real", ")", ",", "HEXAGON_RESERVED_REG_1", ")", ".", "addImm", "(", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "A2_sub", ")", ",", "QRI", "->", "getStackRegister", "(", ")", ")", ".", "addReg", "(", "QRI", "->", "getStackRegister", "(", ")", ")", ".", "addReg", "(", "HEXAGON_RESERVED_REG_1", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "S2_allocframe", ")", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::ADJDYNALLOC", "\"Expected adjust alloca node\"", "2", "\"Expected immediate\"", "16384", "Hexagon::S2_allocframe", "0", "Hexagon::CONST32_Int_Real", "Hexagon::A2_sub", "Hexagon::S2_allocframe" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "TargetMachine", "&", "TM", ",", "const", "Module", "&", "M", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ")", ":", "MipsArchVersion", "(", "Mips1", ")", ",", "MipsABI", "(", "O32", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasABICall", "(", "true", ")", ",", "HasAbsoluteCall", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasMulDivAdd", "(", "false", ")", ",", "HasMinMax", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", "{", "std", "::", "string", "CPU", "=", "\"mips1\"", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "const", "std", "::", "string", "&", "TT", "=", "M", ".", "getTargetTriple", "(", ")", ";", "SSectionThreshold", "=", "SSThreshold", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "if", "(", "TT", ".", "find", "(", "\"mipsallegrex\"", ")", "!=", "std", "::", "string", "::", "npos", "||", "TT", ".", "find", "(", "\"psp\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "{", "MipsABI", "=", "EABI", ";", "IsSingleFloat", "=", "true", ";", "MipsArchVersion", "=", "Mips2", ";", "HasVFPU", "=", "true", ";", "HasSEInReg", "=", "true", ";", "HasBitCount", "=", "true", ";", "HasSwap", "=", "true", ";", "HasCondMov", "=", "true", ";", "}", "if", "(", "NotABICall", "||", "isABI_EABI", "(", ")", "||", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", ")", "HasABICall", "=", "false", ";", "if", "(", "HasABICall", "&&", "AbsoluteCall", ")", "HasAbsoluteCall", "=", "true", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips1\"", "\"linux\"", "\"mipsallegrex\"", "\"psp\"", "Mips", "Mips", "Mips" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Tile64 VLIW Packetizer\"", ";", "}", "</s>" ]

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

[ "Tile64", "\"Tile64 VLIW Packetizer\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "bool", "isWin64", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", ";", "unsigned", "SlotSize", "=", "is64Bit", "?", "8", ":", "4", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FPReg", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "-", "1", "]", ".", "getRegClass", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "if", "(", "RegClass", "!=", "&", "X86", "::", "VR128RegClass", "&&", "!", "isWin64", ")", "{", "CalleeFrameSize", "+=", "SlotSize", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RegClass", ")", ";", "}", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "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", "(", ")", "." ]

[ "X86", "X86", "X86", "X86", "8", "4", "X86", "X86", "X86", "0", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "1", "X86::VR128RegClass", "1", "X86" ]

[]