Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "MOS" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createMipsExpandPseudoPass", "(", ")", ")", ";", "addPass", "(", "createMicroMipsSizeReducePass", "(", ")", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", ")", ")", ";", "addPass", "(", "createMipsBranchExpansion", "(", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "enum", "reg_class", "coproc_secondary_reload_class", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "wb", ")", "{", "if", "(", "mode", "==", "HFmode", ")", "{", "if", "(", "!", "TARGET_NEON_FP16", "&&", "!", "TARGET_VFP_FP16INST", ")", "return", "GENERAL_REGS", ";", "if", "(", "s_register_operand", "(", "x", ",", "mode", ")", "||", "neon_vector_mem_operand", "(", "x", ",", "2", ",", "true", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "if", "(", "TARGET_NEON", "&&", "(", "MEM_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", "||", "VALID_NEON_STRUCT_MODE", "(", "mode", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "arm_coproc_mem_operand", "(", "x", ",", "wb", ")", "||", "s_register_operand", "(", "x", ",", "mode", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "GENERAL_REGS", "if", "a", "scratch", "register", "required", "to", "reload", "x", "to/from", "coprocessor", "registers", ".", "Otherwise", "return", "NO_REGS", "." ]

[ "arm", "2" ]

[]

[ "<s>", "static", "bool", "or1k_legitimize_address_displacement", "(", "rtx", "*", "off1", ",", "rtx", "*", "off2", ",", "poly_int64", "poly_offset", ",", "machine_mode", ")", "{", "HOST_WIDE_INT", "orig_offset", "=", "poly_offset", ";", "HOST_WIDE_INT", "lo", ",", "hi", ";", "if", "(", "orig_offset", ">=", "0", "&&", "orig_offset", "<", "2", "*", "32767", ")", "{", "hi", "=", "32767", ";", "lo", "=", "orig_offset", "-", "hi", ";", "}", "else", "if", "(", "orig_offset", "<", "0", "&&", "orig_offset", ">=", "2", "*", "-", "32768", ")", "{", "hi", "=", "-", "32768", ";", "lo", "=", "orig_offset", "-", "hi", ";", "}", "else", "{", "lo", "=", "sext_hwi", "(", "orig_offset", ",", "16", ")", ";", "hi", "=", "orig_offset", "-", "lo", ";", "}", "*", "off1", "=", "GEN_INT", "(", "hi", ")", ";", "*", "off2", "=", "GEN_INT", "(", "lo", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT", ".", "Split", "an", "out-of-range", "address", "displacement", "into", "hi", "and", "lo", "parts", ".", "The", "hi", "part", "will", "have", "to", "be", "loaded", "into", "a", "register", "separately", ",", "but", "the", "low", "part", "will", "be", "folded", "into", "the", "memory", "operand", "." ]

[ "or1k", "0", "2", "32767", "32767", "0", "2", "32768", "32768", "16" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "aarch64_operands_ok_for_ldpstp", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "offval_1", ",", "offval_2", ",", "msize", ";", "enum", "reg_class", "rclass_1", ",", "rclass_2", ";", "rtx", "mem_1", ",", "mem_2", ",", "reg_1", ",", "reg_2", ",", "base_1", ",", "base_2", ",", "offset_1", ",", "offset_2", ";", "if", "(", "load", ")", "{", "mem_1", "=", "operands", "[", "1", "]", ";", "mem_2", "=", "operands", "[", "3", "]", ";", "reg_1", "=", "operands", "[", "0", "]", ";", "reg_2", "=", "operands", "[", "2", "]", ";", "gcc_assert", "(", "REG_P", "(", "reg_1", ")", "&&", "REG_P", "(", "reg_2", ")", ")", ";", "if", "(", "REGNO", "(", "reg_1", ")", "==", "REGNO", "(", "reg_2", ")", ")", "return", "false", ";", "}", "else", "{", "mem_1", "=", "operands", "[", "0", "]", ";", "mem_2", "=", "operands", "[", "2", "]", ";", "reg_1", "=", "operands", "[", "1", "]", ";", "reg_2", "=", "operands", "[", "3", "]", ";", "}", "if", "(", "MEM_VOLATILE_P", "(", "mem_1", ")", "||", "MEM_VOLATILE_P", "(", "mem_2", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_SLOW_UNALIGNED_LDPW", ")", "&&", "!", "optimize_size", "&&", "MEM_ALIGN", "(", "mem_1", ")", "<", "8", "*", "BITS_PER_UNIT", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem_1", ",", "&", "base_1", ",", "&", "offset_1", ")", ";", "if", "(", "base_1", "==", "NULL_RTX", "||", "offset_1", "==", "NULL_RTX", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem_2", ",", "&", "base_2", ",", "&", "offset_2", ")", ";", "if", "(", "base_2", "==", "NULL_RTX", "||", "offset_2", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "base_1", ",", "base_2", ")", ")", "return", "false", ";", "offval_1", "=", "INTVAL", "(", "offset_1", ")", ";", "offval_2", "=", "INTVAL", "(", "offset_2", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "offval_1", "!=", "(", "offval_2", "+", "msize", ")", "&&", "offval_2", "!=", "(", "offval_1", "+", "msize", ")", ")", "return", "false", ";", "if", "(", "load", ")", "{", "if", "(", "reg_mentioned_p", "(", "reg_1", ",", "mem_1", ")", ")", "return", "false", ";", "if", "(", "offval_1", ">", "offval_2", "&&", "reg_mentioned_p", "(", "reg_2", ",", "mem_2", ")", ")", "return", "false", ";", "}", "if", "(", "REG_P", "(", "reg_1", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg_1", ")", ")", ")", "rclass_1", "=", "FP_REGS", ";", "else", "rclass_1", "=", "GENERAL_REGS", ";", "if", "(", "REG_P", "(", "reg_2", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg_2", ")", ")", ")", "rclass_2", "=", "FP_REGS", ";", "else", "rclass_2", "=", "GENERAL_REGS", ";", "if", "(", "rclass_1", "!=", "rclass_2", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", ",", "check", "if", "we", "can", "merge", "them", "into", "ldp/stp", ".", "LOAD", "is", "true", "if", "they", "are", "load", "instructions", ".", "MODE", "is", "the", "mode", "of", "memory", "operands", "." ]

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

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCondOpt", ")", "addPass", "(", "createAArch64ConditionOptimizerPass", "(", ")", ")", ";", "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableMCR", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "if", "(", "EnableEarlyIfConversion", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "addPass", "(", "createAArch64VectorByElementOptPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

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

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "SM", ".", "reset", "(", ")", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "SystemZ" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "frv_pack_insns", "(", "void", ")", "{", "if", "(", "frv_for_each_packet", "(", "frv_reorder_packet", ")", ")", "frv_insn_packing_flag", "=", "0", ";", "else", "frv_insn_packing_flag", "=", "-", "1", ";", "}", "</s>" ]

[ "Divide", "instructions", "into", "packets", ".", "Reorder", "the", "contents", "of", "each", "packet", "so", "that", "they", "are", "in", "the", "correct", "assembly-language", "order", ".", "Since", "this", "pass", "can", "change", "the", "raw", "meaning", "of", "the", "rtl", "stream", ",", "it", "must", "only", "be", "called", "at", "the", "last", "minute", ",", "just", "before", "the", "instructions", "are", "written", "out", "." ]

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

[]

[ "<s>", "static", "enum", "insn_code", "aarch64_constant_pool_reload_icode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "CODE_FOR_aarch64_reload_movcpsfdi", ";", "case", "DFmode", ":", "return", "CODE_FOR_aarch64_reload_movcpdfdi", ";", "case", "TFmode", ":", "return", "CODE_FOR_aarch64_reload_movcptfdi", ";", "case", "V8QImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv8qidi", ";", "case", "V16QImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv16qidi", ";", "case", "V4HImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv4hidi", ";", "case", "V8HImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv8hidi", ";", "case", "V2SImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv2sidi", ";", "case", "V4SImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv4sidi", ";", "case", "V2DImode", ":", "return", "CODE_FOR_aarch64_reload_movcpv2didi", ";", "case", "V2DFmode", ":", "return", "CODE_FOR_aarch64_reload_movcpv2dfdi", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "reload", "icode", "required", "for", "a", "constant", "pool", "in", "mode", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "AGCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "report_fatal_error", "(", "\"Subroutines not supported yet\"", ")", ";", "}", "</s>" ]

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

[ "AGC", "AGC", "\"Subroutines not supported yet\"" ]

[]

[ "<s>", "static", "void", "mn10300_insert_setlb_lcc", "(", "rtx_insn", "*", "label", ",", "rtx_insn", "*", "branch", ")", "{", "rtx", "lcc", ",", "comparison", ",", "cmp_reg", ";", "if", "(", "LABEL_NUSES", "(", "label", ")", ">", "1", ")", "{", "rtx_insn", "*", "insn", ";", "DUMP", "(", "\"Inserting SETLB insn after:\"", ",", "label", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_setlb", "(", ")", ",", "label", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label_after", "(", "label", ",", "insn", ")", ";", "DUMP", "(", "\"Created new loop-back label:\"", ",", "label", ")", ";", "}", "else", "{", "DUMP", "(", "\"Inserting SETLB insn before:\"", ",", "label", ")", ";", "emit_insn_before", "(", "gen_setlb", "(", ")", ",", "label", ")", ";", "}", "comparison", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "branch", ")", ")", ",", "0", ")", ";", "cmp_reg", "=", "XEXP", "(", "comparison", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "cmp_reg", ")", ")", ";", "gcc_assert", "(", "REGNO", "(", "cmp_reg", ")", "==", "CC_REG", ")", ";", "if", "(", "GET_MODE", "(", "cmp_reg", ")", "==", "CC_FLOATmode", ")", "lcc", "=", "gen_FLcc", "(", "comparison", ",", "label", ")", ";", "else", "lcc", "=", "gen_Lcc", "(", "comparison", ",", "label", ")", ";", "rtx_insn", "*", "jump", "=", "emit_jump_insn_before", "(", "lcc", ",", "branch", ")", ";", "mark_jump_label", "(", "XVECEXP", "(", "lcc", ",", "0", ",", "0", ")", ",", "jump", ",", "0", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "label", ";", "DUMP", "(", "\"Replacing branch insn...\"", ",", "branch", ")", ";", "DUMP", "(", "\"... with Lcc insn:\"", ",", "jump", ")", ";", "delete_insn", "(", "branch", ")", ";", "}", "</s>" ]

[ "Replace", "the", "BRANCH", "insn", "with", "a", "Lcc", "insn", "that", "goes", "to", "LABEL", ".", "Insert", "a", "SETLB", "insn", "just", "before", "LABEL", "." ]

[ "mn10300", "1", "\"Inserting SETLB insn after:\"", "\"Created new loop-back label:\"", "\"Inserting SETLB insn before:\"", "0", "0", "0", "0", "0", "\"Replacing branch insn...\"", "\"... with Lcc insn:\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "return", "Subtarget", ".", "hasV5TOps", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "expand_epilogue", "(", ")", "{", "unsigned", "int", "size", ";", "unsigned", "int", "outgoing_args_size", "=", "current_function_outgoing_args_size", ";", "int", "offset", ",", "i", ",", "temp_regno", ";", "rtx", "basereg", ";", "size", "=", "total_frame_size", "(", ")", ";", "if", "(", "DECL_RESULT", "(", "current_function_decl", ")", "&&", "DECL_RTL", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", "&&", "REG_P", "(", "DECL_RTL", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ")", ")", "temp_regno", "=", "(", "REGNO", "(", "DECL_RTL", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ")", "==", "4", "?", "0", ":", "4", ")", ";", "else", "temp_regno", "=", "4", ";", "if", "(", "out_of_line_epilogue", ")", "{", "if", "(", "get_frame_size", "(", ")", "==", "0", "&&", "outgoing_args_size", "==", "0", ")", "{", "emit_jump_insn", "(", "gen_outline_epilogue_jump", "(", ")", ")", ";", "return", ";", "}", "if", "(", "outgoing_args_size", ")", "emit_insn", "(", "gen_addpsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "outgoing_args_size", ")", ")", ")", ";", "if", "(", "temp_regno", "==", "0", ")", "emit_insn", "(", "gen_outline_epilogue_call_d0", "(", ")", ")", ";", "else", "if", "(", "temp_regno", "==", "4", ")", "emit_insn", "(", "gen_outline_epilogue_call_a0", "(", ")", ")", ";", "if", "(", "get_frame_size", "(", ")", "!=", "0", ")", "emit_insn", "(", "gen_addpsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", "-", "outgoing_args_size", "-", "16", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_return_internal", "(", ")", ")", ";", "return", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "basereg", "=", "frame_pointer_rtx", ";", "offset", "=", "-", "(", "size", "-", "outgoing_args_size", ")", ";", "}", "else", "{", "basereg", "=", "stack_pointer_rtx", ";", "offset", "=", "outgoing_args_size", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", "&&", "!", "fixed_regs", "[", "i", "]", ")", "||", "(", "i", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", ")", "{", "int", "regno", ";", "regno", "=", "(", "(", "i", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "?", "temp_regno", ":", "i", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "PSImode", ",", "regno", ")", ",", "gen_rtx_MEM", "(", "PSImode", ",", "plus_constant", "(", "basereg", ",", "offset", ")", ")", ")", ";", "offset", "+=", "4", ";", "}", "}", "if", "(", "frame_pointer_needed", ")", "{", "emit_move_insn", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ";", "emit_move_insn", "(", "frame_pointer_rtx", ",", "gen_rtx_REG", "(", "PSImode", ",", "temp_regno", ")", ")", ";", "}", "else", "if", "(", "size", ")", "{", "emit_insn", "(", "gen_addpsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "}", "if", "(", "current_function_needs_context", ")", "emit_insn", "(", "gen_addpsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "if", "(", "size", "==", "0", "&&", "!", "current_function_needs_context", ")", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_return_internal", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "epilogue", "into", "RTL", "." ]

[ "mn10200", "4", "0", "4", "4", "0", "0", "0", "4", "0", "16", "0", "4", "4", "0" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_storewb_pair", "(", "machine_mode", "mode", ",", "rtx", "base", ",", "rtx", "reg", ",", "rtx", "reg2", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "gen_storewb_pairdi_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "-", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", "-", "adjustment", ")", ")", ";", "case", "E_DFmode", ":", "return", "gen_storewb_pairdf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "-", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", "-", "adjustment", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "and", "return", "an", "instruction", "to", "store", "the", "pair", "of", "registers", "REG", "and", "REG2", "of", "mode", "MODE", "to", "location", "BASE", "with", "write-back", "adjusting", "the", "stack", "location", "BASE", "by", "ADJUSTMENT", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx", "sparc_builtin_setjmp_frame_value", "(", "void", ")", "{", "return", "hard_frame_pointer_rtx", ";", "}", "</s>" ]

[ "Return", "the", "hard", "frame", "pointer", "directly", "to", "bypass", "the", "stack", "bias", "." ]

[ "sparc" ]

[]

[ "<s>", "X86DCFunction", "&", "getParent", "(", ")", "{", "return", "static_cast", "<", "X86DCFunction", "&", ">", "(", "DCBasicBlock", "::", "getParent", "(", ")", ")", ";", "}", "</s>" ]

[ "getParent", "-", "Return", "the", "last", "analyzed", "interval", "." ]

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

[]

[ "<s>", "TVMSubtarget", "&", "TVMSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "(", "void", ")", "FS", ";", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"tvm\"", ";", "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", "." ]

[ "TVM", "TVM", "TVM", "\"tvm\"" ]

[]

[ "<s>", "static", "rtx", "move_to_x", "(", "int", "opno", ",", "rtx_insn", "*", "before", ")", "{", "rtx", "src", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "reg", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "recog_data", ".", "operand_mode", "[", "opno", "]", ";", "reg", "=", "(", "mode", "==", "QImode", ")", "?", "X", ":", "AX", ";", "if", "(", "mode", "==", "QImode", "||", "!", "is_virtual_register", "(", "OP", "(", "opno", ")", ")", ")", "{", "OP", "(", "opno", ")", "=", "move_to_acc", "(", "opno", ",", "before", ")", ";", "OP", "(", "opno", ")", "=", "move_acc_to_reg", "(", "OP", "(", "opno", ")", ",", "X_REG", ",", "before", ")", ";", "return", "reg", ";", "}", "return", "gen_and_emit_move", "(", "reg", ",", "src", ",", "before", ",", "true", ")", ";", "}", "</s>" ]

[ "Copy", "SRC", "to", "X", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "X", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "void", "m32c_emit_prologue", "(", "void", ")", "{", "int", "frame_size", ",", "extra_frame_size", "=", "0", ",", "reg_save_size", ";", "int", "complex_prologue", "=", "0", ";", "cfun", "->", "machine", "->", "is_leaf", "=", "m32c_leaf_function_p", "(", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "cfun", "->", "machine", "->", "is_interrupt", "=", "1", ";", "complex_prologue", "=", "1", ";", "}", "else", "if", "(", "bank_switch_p", "(", "cfun", "->", "decl", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"%<bank_switch%> has no effect on non-interrupt functions\"", ")", ";", "reg_save_size", "=", "m32c_pushm_popm", "(", "PP_justcount", ")", ";", "if", "(", "interrupt_p", "(", "cfun", "->", "decl", ")", ")", "{", "if", "(", "bank_switch_p", "(", "cfun", "->", "decl", ")", ")", "emit_insn", "(", "gen_fset_b", "(", ")", ")", ";", "else", "if", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", "emit_insn", "(", "gen_pushm", "(", "GEN_INT", "(", "cfun", "->", "machine", "->", "intr_pushm", ")", ")", ")", ";", "}", "frame_size", "=", "m32c_initial_elimination_offset", "(", "FB_REGNO", ",", "SP_REGNO", ")", "-", "reg_save_size", ";", "if", "(", "frame_size", "==", "0", "&&", "!", "m32c_function_needs_enter", "(", ")", ")", "cfun", "->", "machine", "->", "use_rts", "=", "1", ";", "if", "(", "frame_size", ">", "254", ")", "{", "extra_frame_size", "=", "frame_size", "-", "254", ";", "frame_size", "=", "254", ";", "}", "if", "(", "cfun", "->", "machine", "->", "use_rts", "==", "0", ")", "F", "(", "emit_insn", "(", "m32c_all_frame_related", "(", "TARGET_A16", "?", "gen_prologue_enter_16", "(", "GEN_INT", "(", "frame_size", "+", "2", ")", ")", ":", "gen_prologue_enter_24", "(", "GEN_INT", "(", "frame_size", "+", "4", ")", ")", ")", ")", ")", ";", "if", "(", "extra_frame_size", ")", "{", "complex_prologue", "=", "1", ";", "if", "(", "TARGET_A16", ")", "F", "(", "emit_insn", "(", "gen_addhi3", "(", "gen_rtx_REG", "(", "HImode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "HImode", ",", "SP_REGNO", ")", ",", "GEN_INT", "(", "-", "extra_frame_size", ")", ")", ")", ")", ";", "else", "F", "(", "emit_insn", "(", "gen_addpsi3", "(", "gen_rtx_REG", "(", "PSImode", ",", "SP_REGNO", ")", ",", "gen_rtx_REG", "(", "PSImode", ",", "SP_REGNO", ")", ",", "GEN_INT", "(", "-", "extra_frame_size", ")", ")", ")", ")", ";", "}", "complex_prologue", "+=", "m32c_pushm_popm", "(", "PP_pushm", ")", ";", "if", "(", "complex_prologue", ")", "emit_insn", "(", "gen_prologue_end", "(", ")", ")", ";", "}", "</s>" ]

[ "Emits", "the", "prologue", ".", "See", "the", "frame", "layout", "comment", "earlier", "in", "this", "file", ".", "We", "can", "reserve", "up", "to", "256", "bytes", "with", "the", "ENTER", "opcode", ",", "beyond", "that", "we", "manually", "update", "sp", "." ]

[ "m32c", "0", "0", "1", "1", "\"%<bank_switch%> has no effect on non-interrupt functions\"", "0", "1", "254", "254", "254", "0", "2", "4", "1" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "addPass", "(", "createR600OpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "int", "expand_a_rotate", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "rotate_amount", "=", "operands", "[", "2", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "if", "(", "h8sx_classify_shift", "(", "mode", ",", "ROTATE", ",", "rotate_amount", ")", "==", "H8SX_SHIFT_UNARY", ")", "return", "false", ";", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "if", "(", "GET_CODE", "(", "rotate_amount", ")", "!=", "CONST_INT", ")", "{", "rtx", "counter", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "rtx_code_label", "*", "start_label", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "end_label", "=", "gen_label_rtx", "(", ")", ";", "emit_cmp_and_jump_insns", "(", "rotate_amount", ",", "const0_rtx", ",", "LE", ",", "NULL_RTX", ",", "QImode", ",", "0", ",", "end_label", ")", ";", "emit_move_insn", "(", "counter", ",", "rotate_amount", ")", ";", "emit_label", "(", "start_label", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_rotlqi3_1", "(", "dst", ",", "dst", ",", "const1_rtx", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_rotlhi3_1", "(", "dst", ",", "dst", ",", "const1_rtx", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_rotlsi3_1", "(", "dst", ",", "dst", ",", "const1_rtx", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_addqi3", "(", "counter", ",", "counter", ",", "constm1_rtx", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "counter", ",", "const0_rtx", ",", "NE", ",", "NULL_RTX", ",", "QImode", ",", "1", ",", "start_label", ")", ";", "emit_label", "(", "end_label", ")", ";", "}", "else", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "emit_insn", "(", "gen_rotlqi3_1", "(", "dst", ",", "dst", ",", "rotate_amount", ")", ")", ";", "break", ";", "case", "HImode", ":", "emit_insn", "(", "gen_rotlhi3_1", "(", "dst", ",", "dst", ",", "rotate_amount", ")", ")", ";", "break", ";", "case", "SImode", ":", "emit_insn", "(", "gen_rotlsi3_1", "(", "dst", ",", "dst", ",", "rotate_amount", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "1", ";", "}", "</s>" ]

[ "A", "rotation", "by", "a", "non-constant", "will", "cause", "a", "loop", "to", "be", "generated", ",", "in", "which", "a", "rotation", "by", "one", "bit", "is", "used", ".", "A", "rotation", "by", "a", "constant", ",", "including", "the", "one", "in", "the", "loop", ",", "will", "be", "taken", "care", "of", "by", "emit_a_rotate", "(", ")", "at", "the", "insn", "emit", "time", "." ]

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

[]

[ "<s>", "Register", "MipsTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isGP64bit", "(", ")", ")", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"$28\"", ",", "Mips", "::", "GP_64", ")", ".", "Default", "(", "Register", "(", ")", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "}", "else", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"$28\"", ",", "Mips", "::", "GP", ")", ".", "Default", "(", "Register", "(", ")", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "}", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"$28\"", "Mips::GP_64", "\"$28\"", "Mips::GP", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "void", "function_expander", "::", "add_output_operand", "(", "insn_code", "icode", ")", "{", "unsigned", "int", "opno", "=", "m_ops", ".", "length", "(", ")", ";", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "opno", "]", ".", "mode", ";", "m_ops", ".", "safe_grow", "(", "opno", "+", "1", ")", ";", "create_output_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "possible_target", ",", "mode", ")", ";", "}", "</s>" ]

[ "Create", "output", "and", "add", "it", "into", "M_OPS", "and", "increase", "OPNO", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64PostSelectOptimize", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "3", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "0", "4", "support::little", "3", "8", "0xff" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "return", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "true", ";", "if", "(", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "MachineBasicBlock", "*", "MaskBrDest", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "TBB", "!=", "MaskBrDest", "||", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "auto", "Pred", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "return", "(", "Pred", "!=", "EXECZ", "&&", "Pred", "!=", "EXECNZ", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_MASK_BRANCH", "0", "0" ]

[]

[ "<s>", "bool", "AArch64AdvSIMDScalar", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64AdvSIMDScalar *****\\n\"", ")", ";", "if", "(", "skipFunction", "(", "mf", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "mf", ".", "getRegInfo", "(", ")", ";", "TII", "=", "mf", ".", "getSubtarget", "(", ")", ".", "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", "." ]

[ "AArch64", "AArch64", "\"***** AArch64AdvSIMDScalar *****\\n\"" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "FlagSfiBranch", ")", "{", "NaclAlignAllJumpTargetsAndConstantPools", "(", "MF", ")", ";", "}", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "arm_change_mode_p", "(", "tree", "func", ")", "{", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "func", ")", ";", "if", "(", "!", "callee_tree", ")", "callee_tree", "=", "target_option_default_node", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "int", "flags", "=", "callee_opts", "->", "x_target_flags", ";", "return", "(", "TARGET_THUMB_P", "(", "flags", ")", "!=", "TARGET_THUMB", ")", ";", "}", "</s>" ]

[ "Check", "that", "FUNC", "is", "called", "with", "a", "different", "mode", "." ]

[ "arm" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "LHSTy", ")", "const", "override", "{", "return", "LHSTy", ".", "getSizeInBits", "(", ")", "<=", "32", "?", "MVT", "::", "i32", ":", "MVT", "::", "i64", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "RISCV", "32", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "tree", "function_resolver", "::", "lookup_form", "(", "mode_suffix_index", "mode", ",", "type_suffix_index", "type0", ",", "type_suffix_index", "type1", ")", "{", "type_suffix_pair", "types", "=", "{", "type0", ",", "type1", "}", ";", "function_instance", "instance", "(", "base_name", ",", "base", ",", "shape", ",", "mode", ",", "types", ",", "pred", ")", ";", "registered_function", "*", "rfn", "=", "function_table", "->", "find_with_hash", "(", "instance", ",", "instance", ".", "hash", "(", ")", ")", ";", "return", "rfn", "?", "rfn", "->", "decl", ":", "NULL_TREE", ";", "}", "</s>" ]

[ "Silently", "check", "whether", "there", "is", "an", "instance", "of", "the", "function", "with", "the", "mode", "suffix", "given", "by", "MODE", "and", "the", "type", "suffixes", "given", "by", "TYPE0", "and", "TYPE1", ".", "Return", "its", "function", "decl", "if", "so", ",", "otherwise", "return", "null", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "order_regs_for_local_alloc", "(", "void", ")", "{", "static", "int", "last_order_nonleaf", "=", "1", ";", "if", "(", "regs_ever_live", "[", "15", "]", "!=", "last_order_nonleaf", ")", "{", "last_order_nonleaf", "=", "!", "last_order_nonleaf", ";", "memcpy", "(", "(", "char", "*", ")", "reg_alloc_order", ",", "(", "const", "char", "*", ")", "reg_alloc_orders", "[", "last_order_nonleaf", "]", ",", "FIRST_PSEUDO_REGISTER", "*", "sizeof", "(", "int", ")", ")", ";", "}", "}", "</s>" ]

[ "Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "." ]

[ "sparc", "1", "15" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "GetMemOperand", "(", "MBB", ",", "FI", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "Mips", "::", "CPURegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "LW_P8", ":", "Mips", "::", "LW", ";", "else", "if", "(", "Mips", "::", "CPU64RegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "LD_P8", ":", "Mips", "::", "LD", ";", "else", "if", "(", "Mips", "::", "FGR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "LWC1_P8", ":", "Mips", "::", "LWC1", ";", "else", "if", "(", "Mips", "::", "AFGR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Mips", "::", "LDC1", ";", "else", "if", "(", "Mips", "::", "FGR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "IsN64", "?", "Mips", "::", "LDC164_P8", ":", "Mips", "::", "LDC164", ";", "assert", "(", "Opc", "&&", "\"Register class not handled!\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::CPURegsRegClass", "Mips::LW_P8", "Mips::LW", "Mips::CPU64RegsRegClass", "Mips::LD_P8", "Mips::LD", "Mips::FGR32RegClass", "Mips::LWC1_P8", "Mips::LWC1", "Mips::AFGR64RegClass", "Mips::LDC1", "Mips::FGR64RegClass", "Mips::LDC164_P8", "Mips::LDC164", "\"Register class not handled!\"", "0" ]

[]

[ "<s>", "OperandMatchResultTy", "RISCVAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "const", "AsmToken", "&", "Tok", "=", "getParser", "(", ")", ".", "getTok", "(", ")", ";", "StartLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "EndLoc", "=", "Tok", ".", "getEndLoc", "(", ")", ";", "RegNo", "=", "0", ";", "StringRef", "Name", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "if", "(", "matchRegisterNameHelper", "(", "isRV32E", "(", ")", ",", "(", "MCRegister", "&", ")", "RegNo", ",", "Name", ")", ")", "return", "MatchOperand_NoMatch", ";", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "RI5CY", "RISCV", "0" ]

[]

[ "<s>", "const", "char", "*", "XCoreTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "XCoreISD", "::", "BL", ":", "return", "\"XCoreISD::BL\"", ";", "case", "XCoreISD", "::", "PCRelativeWrapper", ":", "return", "\"XCoreISD::PCRelativeWrapper\"", ";", "case", "XCoreISD", "::", "DPRelativeWrapper", ":", "return", "\"XCoreISD::DPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "CPRelativeWrapper", ":", "return", "\"XCoreISD::CPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "STWSP", ":", "return", "\"XCoreISD::STWSP\"", ";", "case", "XCoreISD", "::", "RETSP", ":", "return", "\"XCoreISD::RETSP\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "XCoreISD::BL", "\"XCoreISD::BL\"", "XCoreISD::PCRelativeWrapper", "\"XCoreISD::PCRelativeWrapper\"", "XCoreISD::DPRelativeWrapper", "\"XCoreISD::DPRelativeWrapper\"", "XCoreISD::CPRelativeWrapper", "\"XCoreISD::CPRelativeWrapper\"", "XCoreISD::STWSP", "\"XCoreISD::STWSP\"", "XCoreISD::RETSP", "\"XCoreISD::RETSP\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "Reloc", "::", "Model", "RM", "=", "TM", ".", "getRelocationModel", "(", ")", ";", "if", "(", "shouldAssumeDSOLocal", "(", "RM", ",", "TargetTriple", ",", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "if", "(", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "RM", "!=", "Reloc", "::", "PIC_", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_GOT", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "static", "void", "nvptx_dump_pars", "(", "parallel", "*", "par", ",", "unsigned", "depth", ")", "{", "fprintf", "(", "dump_file", ",", "\"%u: mask %d head=%d, tail=%d\\n\"", ",", "depth", ",", "par", "->", "mask", ",", "par", "->", "forked_block", "?", "par", "->", "forked_block", "->", "index", ":", "-", "1", ",", "par", "->", "join_block", "?", "par", "->", "join_block", "->", "index", ":", "-", "1", ")", ";", "fprintf", "(", "dump_file", ",", "\" blocks:\"", ")", ";", "basic_block", "block", ";", "for", "(", "unsigned", "ix", "=", "0", ";", "par", "->", "blocks", ".", "iterate", "(", "ix", ",", "&", "block", ")", ";", "ix", "++", ")", "fprintf", "(", "dump_file", ",", "\" %d\"", ",", "block", "->", "index", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "if", "(", "par", "->", "inner", ")", "nvptx_dump_pars", "(", "par", "->", "inner", ",", "depth", "+", "1", ")", ";", "if", "(", "par", "->", "next", ")", "nvptx_dump_pars", "(", "par", "->", "next", ",", "depth", ")", ";", "}", "</s>" ]

[ "See", "also", "'gcc/omp-oacc-neuter-broadcast.cc", ":", "omp_sese_dump_pars", "'", "." ]

[ "nvptx", "\"%u: mask %d head=%d, tail=%d\\n\"", "1", "1", "\" blocks:\"", "0", "\" %d\"", "\"\\n\"", "1" ]

[]

[ "<s>", "static", "char", "*", "describe_cache", "(", "unsigned", "l1_sizekb", ",", "unsigned", "l1_line", ",", "unsigned", "l1_assoc", "ATTRIBUTE_UNUSED", ",", "unsigned", "l2_sizekb", ")", "{", "char", "l1size", "[", "1000", "]", ",", "line", "[", "1000", "]", ",", "l2size", "[", "1000", "]", ";", "sprintf", "(", "l1size", ",", "\"--param l1-cache-size=%u\"", ",", "l1_sizekb", ")", ";", "sprintf", "(", "line", ",", "\"--param l1-cache-line-size=%u\"", ",", "l1_line", ")", ";", "sprintf", "(", "l2size", ",", "\"--param l2-cache-size=%u\"", ",", "l2_sizekb", ")", ";", "return", "concat", "(", "l1size", ",", "\" \"", ",", "line", ",", "\" \"", ",", "l2size", ",", "\" \"", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Returns", "parameters", "that", "describe", "L1_ASSOC", "associative", "cache", "of", "size", "L1_SIZEKB", "with", "lines", "of", "size", "L1_LINE", ",", "and", "L2_SIZEKB", "." ]

[ "powerpcspe", "1000", "1000", "1000", "\"--param l1-cache-size=%u\"", "\"--param l1-cache-line-size=%u\"", "\"--param l2-cache-size=%u\"", "\" \"", "\" \"", "\" \"" ]

[]

[ "<s>", "MachineInstrBuilder", "SIInstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "const", "DebugLoc", "&", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "unsigned", "IndirectBaseReg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "getIndirectIndexBegin", "(", "*", "MBB", "->", "getParent", "(", ")", ")", ")", ";", "return", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "SI_INDIRECT_SRC", ")", ")", ".", "addOperand", "(", "I", "->", "getOperand", "(", "0", ")", ")", ".", "addOperand", "(", "I", "->", "getOperand", "(", "1", ")", ")", ".", "addReg", "(", "IndirectBaseReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]

[ "AMDGPU", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SI_INDIRECT_SRC", "0", "1", "0" ]

[]

[ "<s>", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "override", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "TRI", "->", "getPointerRegClass", "(", "*", "MF", ",", "1", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "NewOp", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "Op", ",", "RC", ")", ",", "0", ")", ";", "OutOps", ".", "push_back", "(", "NewOp", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "1", "MVT::i32", "0" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "}", "if", "(", "getPPCTargetMachine", "(", ")", ".", "isPositionIndependent", "(", ")", ")", "{", "addPass", "(", "&", "LiveVariablesID", ",", "false", ")", ";", "addPass", "(", "createPPCTLSDynamicCallPass", "(", ")", ")", ";", "}", "if", "(", "EnableExtraTOCRegDeps", ")", "addPass", "(", "createPPCTOCRegDepsPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "PostRAMachineSinkingID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "disablePass", "(", "&", "MachineBlockPlacementID", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "bool", "mayAlias", "(", "MachineInstr", "*", "MIa", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "MemInsns", ",", "const", "AArch64InstrInfo", "*", "TII", ")", "{", "for", "(", "auto", "&", "MIb", ":", "MemInsns", ")", "if", "(", "mayAlias", "(", "MIa", ",", "MIb", ",", "TII", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "instruction", "'s", "memory", "access", "aliases", "the", "memory", "access", "of", "Other", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ",", "bool", "altivec_p", ")", "{", "if", "(", "to_type", "==", "NO_REG_TYPE", "||", "from_type", "==", "NO_REG_TYPE", ")", "return", "false", ";", "if", "(", "(", "to_type", "==", "PSEUDO_REG_TYPE", "&&", "from_type", "==", "PSEUDO_REG_TYPE", ")", "||", "(", "to_type", "==", "PSEUDO_REG_TYPE", "&&", "IS_STD_REG_TYPE", "(", "from_type", ")", ")", "||", "(", "from_type", "==", "PSEUDO_REG_TYPE", "&&", "IS_STD_REG_TYPE", "(", "to_type", ")", ")", ")", "return", "true", ";", "if", "(", "to_type", "==", "from_type", "&&", "IS_STD_REG_TYPE", "(", "to_type", ")", ")", "return", "true", ";", "if", "(", "rs6000_secondary_reload_simple_move", "(", "to_type", ",", "from_type", ",", "mode", ")", ")", "{", "if", "(", "sri", ")", "{", "sri", "->", "icode", "=", "CODE_FOR_nothing", ";", "sri", "->", "extra_cost", "=", "0", ";", "}", "return", "true", ";", "}", "return", "rs6000_secondary_reload_direct_move", "(", "to_type", ",", "from_type", ",", "mode", ",", "sri", ",", "altivec_p", ")", ";", "}", "</s>" ]

[ "Return", "whether", "a", "move", "between", "two", "register", "classes", "can", "be", "done", "either", "directly", "(", "simple", "move", ")", "or", "via", "a", "pattern", "that", "uses", "a", "single", "extra", "temporary", "(", "using", "power8", "'s", "direct", "move", "in", "this", "case", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MipsCCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Mips", ",", "CLI", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "if", "(", "VA", ".", "isUpperBitsInLoc", "(", ")", ")", "{", "unsigned", "ValSizeInBits", "=", "Ins", "[", "i", "]", ".", "ArgVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "LocSizeInBits", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "unsigned", "Shift", "=", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExtUpper", "?", "ISD", "::", "SRL", ":", "ISD", "::", "SRA", ";", "Val", "=", "DAG", ".", "getNode", "(", "Shift", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getConstant", "(", "LocSizeInBits", "-", "ValSizeInBits", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "case", "CCValAssign", "::", "AExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "case", "CCValAssign", "::", "ZExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "SExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Mips", "Mips", "ISD::InputArg", "16", "Mips", "Mips", "0", "\"Can only return in registers!\"", "1", "2", "ISD::SRL", "ISD::SRA", "\"Unknown loc info!\"", "ISD::BITCAST", "ISD::TRUNCATE", "ISD::AssertZext", "ISD::TRUNCATE", "ISD::AssertSext", "ISD::TRUNCATE" ]

[]

[ "<s>", "void", "rs6000_sibcall_aix", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "flag", ",", "rtx", "cookie", ")", "{", "rtx", "call", "[", "2", "]", ";", "rtx", "insn", ";", "gcc_assert", "(", "INTVAL", "(", "cookie", ")", "==", "0", ")", ";", "call", "[", "0", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_desc", ")", ",", "flag", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "0", "]", "=", "gen_rtx_SET", "(", "value", ",", "call", "[", "0", "]", ")", ";", "call", "[", "1", "]", "=", "simple_return_rtx", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "2", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Expand", "code", "to", "perform", "a", "sibling", "call", "under", "the", "AIX", "or", "ELFv2", "ABI", "." ]

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

[]

[ "<s>", "unsigned", "getOpSize", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "return", "getOpRegClass", "(", "MI", ",", "OpNo", ")", "->", "getSize", "(", ")", ";", "}", "</s>" ]

[ "This", "form", "should", "usually", "be", "preferred", "since", "it", "handles", "operands", "with", "unknown", "register", "classes", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "DataTy", ")", "{", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "!", "isPowerOf2_32", "(", "DataTy", "->", "getVectorNumElements", "(", ")", ")", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "isa", "<", "PointerType", ">", "(", "ScalarTy", ")", "?", "DL", ".", "getPointerSizeInBits", "(", ")", ":", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "DataWidth", "==", "32", "||", "DataWidth", "==", "64", ")", "&&", "ST", "->", "hasAVX512", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "int", "frv_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "xmode", "=", "(", "mode", "==", "BLKmode", ")", "?", "SImode", ":", "mode", ";", "int", "bytes", "=", "GET_MODE_SIZE", "(", "xmode", ")", ";", "int", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "arg_num", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "int", "ret", ";", "ret", "=", "(", "(", "arg_num", "<=", "LAST_ARG_REGNUM", "&&", "arg_num", "+", "words", ">", "LAST_ARG_REGNUM", "+", "1", ")", "?", "LAST_ARG_REGNUM", "-", "arg_num", "+", "1", ":", "0", ")", ";", "ret", "*=", "UNITS_PER_WORD", ";", "if", "(", "TARGET_DEBUG_ARG", "&&", "ret", ")", "fprintf", "(", "stderr", ",", "\"frv_arg_partial_bytes: %d\\n\"", ",", "ret", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "for", "the", "number", "of", "words", ",", "at", "the", "beginning", "of", "an", "argument", ",", "must", "be", "put", "in", "registers", ".", "The", "value", "must", "be", "zero", "for", "arguments", "that", "are", "passed", "entirely", "in", "registers", "or", "that", "are", "entirely", "pushed", "on", "the", "stack", ".", "On", "some", "machines", ",", "certain", "arguments", "must", "be", "passed", "partially", "in", "registers", "and", "partially", "in", "memory", ".", "On", "these", "machines", ",", "typically", "the", "first", "N", "words", "of", "arguments", "are", "passed", "in", "registers", ",", "and", "the", "rest", "on", "the", "stack", ".", "If", "a", "multi-word", "argument", "(", "a", "`", "double", "'", "or", "a", "structure", ")", "crosses", "that", "boundary", ",", "its", "first", "few", "words", "must", "be", "passed", "in", "registers", "and", "the", "rest", "must", "be", "pushed", ".", "This", "macro", "tells", "the", "compiler", "when", "this", "occurs", ",", "and", "how", "many", "of", "the", "words", "should", "go", "in", "registers", ".", "`", "FUNCTION_ARG", "'", "for", "these", "arguments", "should", "return", "the", "first", "register", "to", "be", "used", "by", "the", "caller", "for", "this", "argument", ";", "likewise", "`", "FUNCTION_INCOMING_ARG", "'", ",", "for", "the", "called", "function", "." ]

[ "frv", "1", "1", "1", "0", "\"frv_arg_partial_bytes: %d\\n\"" ]

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "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", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_BUILTIN", ")", "{", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_AVR_BUILTIN", ")", ";", "}", "else", "{", "analyzeReturnValues", "(", "Outs", ",", "CCInfo", ",", "Subtarget", ".", "hasTinyEncoding", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "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", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasFnAttr", "(", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpc", "=", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "AVRISD", "::", "RETI_FLAG", ":", "AVRISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MipsTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'d'", ":", "case", "'y'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i8", ")", "{", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "CPU16RegsRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "}", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "Subtarget", ".", "isGP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "Subtarget", ".", "isGP64bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "GPR64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "FGR32RegClass", ")", ";", "else", "if", "(", "(", "VT", "==", "MVT", "::", "f64", ")", "&&", "(", "!", "Subtarget", ".", "isSingleFloat", "(", ")", ")", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Mips", "::", "AFGR64RegClass", ")", ";", "}", "break", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "&", "Mips", "::", "GPR32RegClass", ")", ";", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Unexpected type.\"", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9_64", ",", "&", "Mips", "::", "GPR64RegClass", ")", ";", "case", "'l'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO0", ",", "&", "Mips", "::", "LO32RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "LO0_64", ",", "&", "Mips", "::", "LO64RegClass", ")", ";", "case", "'x'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", ";", "R", "=", "parseRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "second", ")", "return", "R", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "Mips", "Mips", "1", "0", "MVT::i32", "MVT::i16", "MVT::i8", "Mips", "0U", "Mips::CPU16RegsRegClass", "0U", "Mips::GPR32RegClass", "MVT::i64", "0U", "Mips::GPR32RegClass", "MVT::i64", "0U", "Mips::GPR64RegClass", "0U", "MVT::f32", "0U", "Mips::FGR32RegClass", "MVT::f64", "0U", "Mips::AFGR64RegClass", "MVT::i32", "Mips::T9", "Mips::GPR32RegClass", "MVT::i64", "\"Unexpected type.\"", "Mips::T9_64", "Mips::GPR64RegClass", "MVT::i32", "Mips::LO0", "Mips::LO32RegClass", "Mips::LO0_64", "Mips::LO64RegClass", "0U" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "if", "(", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainNEON", ")", "{", "ARMFunctionInfo", "*", "AFI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "return", "AFI", "->", "isThumb2Function", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainNEON", "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "find_alignment_op", "(", "rtx_insn", "*", "insn", ",", "rtx", "base_reg", ")", "{", "df_ref", "base_use", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "rtx", "and_operation", "=", "0", ";", "FOR_EACH_INSN_INFO_USE", "(", "base_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "base_use", ")", ",", "base_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "base_def_link", "=", "DF_REF_CHAIN", "(", "base_use", ")", ";", "if", "(", "!", "base_def_link", "||", "base_def_link", "->", "next", ")", "break", ";", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "base_def_link", "->", "ref", ")", ")", "break", ";", "rtx_insn", "*", "and_insn", "=", "DF_REF_INSN", "(", "base_def_link", "->", "ref", ")", ";", "and_operation", "=", "alignment_mask", "(", "and_insn", ")", ";", "if", "(", "and_operation", "!=", "0", ")", "break", ";", "}", "return", "and_operation", ";", "}", "</s>" ]

[ "Given", "INSN", "that", "'s", "a", "load", "or", "store", "based", "at", "BASE_REG", ",", "check", "if", "all", "of", "its", "feeding", "computations", "align", "its", "address", "on", "a", "16-byte", "boundary", ".", "If", "so", ",", "return", "true", "and", "add", "all", "definition", "insns", "into", "AND_INSNS", "and", "their", "corresponding", "fully-expanded", "rtxes", "for", "the", "masking", "operations", "into", "AND_OPS", "." ]

[ "powerpcspe", "0", "0" ]

[]

[ "<s>", "bool", "NVPTXLowerStructArgs", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "isKernelFunction", "(", "F", ")", ")", "return", "false", ";", "handleStructPtrArgs", "(", "F", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

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

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

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

[]

[ "<s>", "SMRange", "getLocRange", "(", ")", "const", "{", "return", "SMRange", "(", "StartLoc", ",", "EndLoc", ")", ";", "}", "</s>" ]

[ "getLocRange", "-", "Get", "the", "range", "between", "the", "first", "and", "last", "token", "of", "this", "operand", "." ]

[ "AMDGPU" ]

[]

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

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

[ "Xtensa", "\"Xtensa Instruction Selection\"" ]

[]

[ "<s>", "MachineInstr", "*", "ARMBaseInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", "PreferFalse", ")", "const", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MOVCCr", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2MOVCCr", ")", "&&", "\"Unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoMOVCC", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "this", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "2", ":", "1", ")", ";", "MachineOperand", "TrueReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "1", ":", "2", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "FalseClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "TrueClass", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "FalseClass", ")", ")", "return", "nullptr", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "TrueClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "add", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "ARMCC", "::", "CondCodes", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "add", "(", "MI", ".", "getOperand", "(", "4", ")", ")", ";", "if", "(", "NewMI", "->", "hasOptionalDef", "(", ")", ")", "NewMI", ".", "add", "(", "condCodeOp", "(", ")", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "add", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "ARM", "ARM", "ARM::MOVCCr", "ARM::t2MOVCCr", "\"Unknown select instruction\"", "2", "1", "2", "1", "1", "2", "0", "1", "3", "ARMCC::getOppositeCondition", "ARMCC::CondCodes", "4", "0", "1" ]

[]

[ "<s>", "EVT", "AlphaTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i64", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Alpha", "Alpha", "MVT::i64" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::GlobalAddress", "ISD::JumpTable", "ISD::BR_JT" ]

[]

[ "<s>", "const", "char", "*", "emit_fusion_p9_store", "(", "rtx", "mem", ",", "rtx", "reg", ",", "rtx", "tmp_reg", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "store_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "store_string", "=", "\"stfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "r", ")", "&&", "TARGET_P9_VECTOR", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stxssp\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "store_string", "=", "\"stxsd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "store_string", "=", "\"stb\"", ";", "break", ";", "case", "E_HImode", ":", "store_string", "=", "\"sth\"", ";", "break", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "store_string", "=", "\"stw\"", ";", "break", ";", "case", "E_DImode", ":", "case", "E_DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "store_string", "=", "\"std\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "store_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "store", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "rs6000", "0", "\"emit_fusion_p9_store, bad reg #1\"", "\"stfs\"", "\"stfd\"", "\"stxssp\"", "\"stxsd\"", "\"stb\"", "\"sth\"", "\"stw\"", "\"std\"", "\"emit_fusion_p9_store, bad reg #2\"", "\"emit_fusion_p9_store not MEM\"", "0", "\"\"" ]

[]

[ "<s>", "static", "int", "shmedia_reserve_space_for_target_registers_p", "(", "int", "regs_saved", ",", "HARD_REG_SET", "*", "live_regs_mask", ")", "{", "if", "(", "optimize_size", ")", "return", "0", ";", "return", "shmedia_target_regs_stack_space", "(", "live_regs_mask", ")", "<=", "regs_saved", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "should", "reserve", "space", "for", "callee-save", "target", "registers", ",", "in", "case", "target", "register", "allocation", "wants", "to", "use", "them", ".", "REGS_SAVED", "is", "the", "space", ",", "in", "bytes", ",", "that", "is", "already", "required", "for", "register", "saves", ".", "LIVE_REGS_MASK", "is", "the", "register", "mask", "calculated", "by", "calc_live_regs", "." ]

[ "sh", "0" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "dag", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "TRI", "=", "static_cast", "<", "const", "R600RegisterInfo", "*", ">", "(", "DAG", "->", "TRI", ")", ";", "VLIW5", "=", "!", "DAG", "->", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "hasCaymanISA", "(", ")", ";", "MRI", "=", "&", "DAG", "->", "MRI", ";", "CurInstKind", "=", "IDOther", ";", "CurEmitted", "=", "0", ";", "OccupedSlotsMask", "=", "31", ";", "InstKindLimit", "[", "IDAlu", "]", "=", "TII", "->", "getMaxAlusPerClause", "(", ")", ";", "InstKindLimit", "[", "IDOther", "]", "=", "32", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "DAG", "->", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "InstKindLimit", "[", "IDFetch", "]", "=", "ST", ".", "getTexVTXClauseSize", "(", ")", ";", "AluInstCount", "=", "0", ";", "FetchInstCount", "=", "0", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "R600", "0", "31", "32", "0", "0" ]

[]

[ "<s>", "static", "int", "ix86_count_insn", "(", "basic_block", "bb", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "int", "min_prev_count", ";", "min_prev_count", "=", "4", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "{", "edge", "prev_e", ";", "edge_iterator", "prev_ei", ";", "if", "(", "e", "->", "src", "==", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", "{", "min_prev_count", "=", "0", ";", "break", ";", "}", "FOR_EACH_EDGE", "(", "prev_e", ",", "prev_ei", ",", "e", "->", "src", "->", "preds", ")", "{", "if", "(", "prev_e", "->", "src", "==", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", "{", "int", "count", "=", "ix86_count_insn_bb", "(", "e", "->", "src", ")", ";", "if", "(", "count", "<", "min_prev_count", ")", "min_prev_count", "=", "count", ";", "break", ";", "}", "}", "}", "if", "(", "min_prev_count", "<", "4", ")", "min_prev_count", "+=", "ix86_count_insn_bb", "(", "bb", ")", ";", "return", "min_prev_count", ";", "}", "</s>" ]

[ "Count", "the", "minimum", "number", "of", "instructions", "in", "code", "path", "in", "BB", ".", "Return", "4", "if", "the", "number", "of", "instructions", ">", "=", "4", "." ]

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

[]

[ "<s>", "bool", "HexagonMCChecker", "::", "check", "(", "bool", "FullCheck", ")", "{", "bool", "chkB", "=", "checkBranches", "(", ")", ";", "bool", "chkP", "=", "checkPredicates", "(", ")", ";", "bool", "chkNV", "=", "checkNewValues", "(", ")", ";", "bool", "chkR", "=", "checkRegisters", "(", ")", ";", "bool", "chkS", "=", "checkSolo", "(", ")", ";", "bool", "chkSh", "=", "true", ";", "if", "(", "FullCheck", ")", "chkSh", "=", "checkShuffle", "(", ")", ";", "bool", "chkSl", "=", "true", ";", "if", "(", "FullCheck", ")", "chkSl", "=", "checkSlots", "(", ")", ";", "bool", "chk", "=", "chkB", "&&", "chkP", "&&", "chkNV", "&&", "chkR", "&&", "chkS", "&&", "chkSh", "&&", "chkSl", ";", "return", "chk", ";", "}", "</s>" ]

[ "Check", "if", "the", "constraints", "are", "satisfiable", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "ix86_libc_has_function", "(", "enum", "function_class", "fn_class", ")", "{", "return", "targetm", ".", "libc_has_function", "(", "fn_class", ",", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "We", "add", "this", "as", "a", "workaround", "in", "order", "to", "use", "libc_has_function", "hook", "in", "i386.md", "." ]

[ "i386" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "MIB", ".", "addReg", "(", "Tmp", ",", "RegState", "::", "Define", ")", ";", "}", "MIB", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "AMDGPU::VGPR_32RegClass", "0" ]

[]

[ "<s>", "static", "void", "tilepro_gen_bundles", "(", "void", ")", "{", "basic_block", "bb", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "rtx_insn", "*", "end", "=", "NEXT_INSN", "(", "BB_END", "(", "bb", ")", ")", ";", "for", "(", "insn", "=", "next_insn_to_bundle", "(", "BB_HEAD", "(", "bb", ")", ",", "end", ")", ";", "insn", ";", "insn", "=", "next", ")", "{", "next", "=", "next_insn_to_bundle", "(", "NEXT_INSN", "(", "insn", ")", ",", "end", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ASM_INPUT", ")", "{", "if", "(", "next", "==", "NULL_RTX", "||", "GET_MODE", "(", "next", ")", "==", "TImode", "||", "CALL_P", "(", "insn", ")", ")", "{", "PUT_MODE", "(", "insn", ",", "QImode", ")", ";", "}", "else", "{", "PUT_MODE", "(", "insn", ",", "SImode", ")", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "Go", "through", "all", "insns", ",", "and", "use", "the", "information", "generated", "during", "scheduling", "to", "generate", "SEQUENCEs", "to", "represent", "bundles", "of", "instructions", "issued", "simultaneously", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_4", ")", ";", "else", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_16", ")", ";", "std", "::", "string", "Arch", "=", "\"rv32\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "Feature64Bit", ")", ")", "Arch", "=", "\"rv64\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "Arch", "+=", "\"e1p9\"", ";", "else", "Arch", "+=", "\"i2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtM", ")", ")", "Arch", "+=", "\"_m2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtA", ")", ")", "Arch", "+=", "\"_a2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtF", ")", ")", "Arch", "+=", "\"_f2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtD", ")", ")", "Arch", "+=", "\"_d2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtC", ")", ")", "Arch", "+=", "\"_c2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtB", ")", ")", "Arch", "+=", "\"_b0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtV", ")", ")", "Arch", "+=", "\"_v1p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZfh", ")", ")", "Arch", "+=", "\"_zfh0p1\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZba", ")", ")", "Arch", "+=", "\"_zba0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbb", ")", ")", "Arch", "+=", "\"_zbb0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbc", ")", ")", "Arch", "+=", "\"_zbc0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbe", ")", ")", "Arch", "+=", "\"_zbe0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbf", ")", ")", "Arch", "+=", "\"_zbf0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbm", ")", ")", "Arch", "+=", "\"_zbm0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbp", ")", ")", "Arch", "+=", "\"_zbp0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbproposedc", ")", ")", "Arch", "+=", "\"_zbproposedc0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbr", ")", ")", "Arch", "+=", "\"_zbr0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbs", ")", ")", "Arch", "+=", "\"_zbs0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbt", ")", ")", "Arch", "+=", "\"_zbt0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZvamo", ")", ")", "Arch", "+=", "\"_zvamo1p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtZvlsseg", ")", ")", "Arch", "+=", "\"_zvlsseg1p0\"", ";", "emitTextAttribute", "(", "RISCVAttrs", "::", "ARCH", ",", "Arch", ")", ";", "}", "</s>" ]

[ "Emit", "the", "build", "attributes", "that", "only", "depend", "on", "the", "hardware", "that", "we", "expect", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRV32E", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_4", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_16", "\"rv32\"", "RISCV::Feature64Bit", "\"rv64\"", "RISCV::FeatureRV32E", "\"e1p9\"", "\"i2p0\"", "RISCV::FeatureStdExtM", "\"_m2p0\"", "RISCV::FeatureStdExtA", "\"_a2p0\"", "RISCV::FeatureStdExtF", "\"_f2p0\"", "RISCV::FeatureStdExtD", "\"_d2p0\"", "RISCV::FeatureStdExtC", "\"_c2p0\"", "RISCV::FeatureStdExtB", "\"_b0p93\"", "RISCV::FeatureStdExtV", "\"_v1p0\"", "RISCV::FeatureExtZfh", "\"_zfh0p1\"", "RISCV::FeatureExtZba", "\"_zba0p93\"", "RISCV::FeatureExtZbb", "\"_zbb0p93\"", "RISCV::FeatureExtZbc", "\"_zbc0p93\"", "RISCV::FeatureExtZbe", "\"_zbe0p93\"", "RISCV::FeatureExtZbf", "\"_zbf0p93\"", "RISCV::FeatureExtZbm", "\"_zbm0p93\"", "RISCV::FeatureExtZbp", "\"_zbp0p93\"", "RISCV::FeatureExtZbproposedc", "\"_zbproposedc0p93\"", "RISCV::FeatureExtZbr", "\"_zbr0p93\"", "RISCV::FeatureExtZbs", "\"_zbs0p93\"", "RISCV::FeatureExtZbt", "\"_zbt0p93\"", "RISCV::FeatureExtZvamo", "\"_zvamo1p0\"", "RISCV::FeatureStdExtZvlsseg", "\"_zvlsseg1p0\"", "RISCVAttrs::ARCH" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "XtensaSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createX86MaxStackAlignmentHeuristicPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ")", "const", "{", "bool", "isPPC64", "=", "PPCSubTarget", ".", "isPPC64", "(", ")", ";", "bool", "isDarwinABI", "=", "PPCSubTarget", ".", "isDarwinABI", "(", ")", ";", "if", "(", "(", "isPPC64", "&&", "VT", "!=", "MVT", "::", "i64", "&&", "VT", "!=", "MVT", "::", "i32", ")", "||", "(", "!", "isPPC64", "&&", "VT", "!=", "MVT", "::", "i32", ")", ")", "report_fatal_error", "(", "\"Invalid register global variable type\"", ")", ";", "bool", "is64Bit", "=", "isPPC64", "&&", "VT", "==", "MVT", "::", "i64", ";", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"r1\"", ",", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ")", ".", "Case", "(", "\"r2\"", ",", "isDarwinABI", "?", "0", ":", "(", "is64Bit", "?", "PPC", "::", "X2", ":", "PPC", "::", "R2", ")", ")", ".", "Case", "(", "\"r13\"", ",", "(", "!", "isPPC64", "&&", "isDarwinABI", ")", "?", "0", ":", "(", "is64Bit", "?", "PPC", "::", "X13", ":", "PPC", "::", "R13", ")", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "MVT::i64", "MVT::i32", "PPC", "MVT::i32", "\"Invalid register global variable type\"", "PPC", "MVT::i64", "\"r1\"", "PPC::X1", "PPC::R1", "\"r2\"", "0", "PPC::X2", "PPC::R2", "\"r13\"", "PPC", "0", "PPC::X13", "PPC::R13", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "void", "output_compiler_stub", "(", ")", "{", "char", "tmp_buf", "[", "256", "]", ";", "char", "label_buf", "[", "256", "]", ";", "char", "*", "label", ";", "tree", "tmp_stub", ",", "stub", ";", "if", "(", "!", "flag_pic", ")", "for", "(", "stub", "=", "stub_list", ";", "stub", ";", "stub", "=", "TREE_CHAIN", "(", "stub", ")", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"%s:\\n\"", ",", "IDENTIFIER_POINTER", "(", "STUB_LABEL_NAME", "(", "stub", ")", ")", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.stabd 68,0,%d\\n\"", ",", "STUB_LINE_NUMBER", "(", "stub", ")", ")", ";", "if", "(", "IDENTIFIER_POINTER", "(", "STUB_FUNCTION_NAME", "(", "stub", ")", ")", "[", "0", "]", "==", "'*'", ")", "strcpy", "(", "label_buf", ",", "IDENTIFIER_POINTER", "(", "STUB_FUNCTION_NAME", "(", "stub", ")", ")", "+", "1", ")", ";", "else", "{", "label_buf", "[", "0", "]", "=", "'_'", ";", "strcpy", "(", "label_buf", "+", "1", ",", "IDENTIFIER_POINTER", "(", "STUB_FUNCTION_NAME", "(", "stub", ")", ")", ")", ";", "}", "strcpy", "(", "tmp_buf", ",", "\"lis r12,hi16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\")\\n\\tori r12,r12,lo16(\"", ")", ";", "strcat", "(", "tmp_buf", ",", "label_buf", ")", ";", "strcat", "(", "tmp_buf", ",", "\")\\n\\tmtctr r12\\n\\tbctr\"", ")", ";", "output_asm_insn", "(", "tmp_buf", ",", "0", ")", ";", "if", "(", "write_symbols", "==", "DBX_DEBUG", "||", "write_symbols", "==", "XCOFF_DEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.stabd 68,0,%d\\n\"", ",", "STUB_LINE_NUMBER", "(", "stub", ")", ")", ";", "}", "stub_list", "=", "0", ";", "}", "</s>" ]

[ "OUTPUT_COMPILER_STUB", "outputs", "the", "compiler", "generated", "stub", "for", "handling", "procedure", "calls", "from", "the", "linked", "list", "and", "initializes", "the", "linked", "list", "." ]

[ "rs6000", "256", "256", "\"%s:\\n\"", "\"\\t.stabd 68,0,%d\\n\"", "0", "1", "0", "1", "\"lis r12,hi16(\"", "\")\\n\\tori r12,r12,lo16(\"", "\")\\n\\tmtctr r12\\n\\tbctr\"", "0", "\"\\t.stabd 68,0,%d\\n\"", "0" ]

[]

[ "<s>", "static", "rtx", "nvptx_get_unisimt_master", "(", ")", "{", "rtx", "&", "master", "=", "cfun", "->", "machine", "->", "unisimt_master", ";", "return", "master", "?", "master", ":", "master", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "}", "</s>" ]

[ "Return", "a", "SImode", "``", "master", "lane", "index", "''", "register", "for", "uniform-simt", ",", "allocating", "on", "first", "use", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "section", "*", "pa_select_section", "(", "tree", "exp", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "TREE_READONLY", "(", "exp", ")", "&&", "!", "TREE_THIS_VOLATILE", "(", "exp", ")", "&&", "DECL_INITIAL", "(", "exp", ")", "&&", "(", "DECL_INITIAL", "(", "exp", ")", "==", "error_mark_node", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "exp", ")", ")", ")", "&&", "!", "(", "reloc", "&", "pa_reloc_rw_mask", "(", ")", ")", ")", "{", "if", "(", "TARGET_SOM", "&&", "DECL_ONE_ONLY", "(", "exp", ")", "&&", "!", "DECL_WEAK", "(", "exp", ")", ")", "return", "som_one_only_readonly_data_section", ";", "else", "return", "readonly_data_section", ";", "}", "else", "if", "(", "CONSTANT_CLASS_P", "(", "exp", ")", "&&", "!", "(", "reloc", "&", "pa_reloc_rw_mask", "(", ")", ")", ")", "return", "readonly_data_section", ";", "else", "if", "(", "TARGET_SOM", "&&", "TREE_CODE", "(", "exp", ")", "==", "VAR_DECL", "&&", "DECL_ONE_ONLY", "(", "exp", ")", "&&", "!", "DECL_WEAK", "(", "exp", ")", ")", "return", "som_one_only_data_section", ";", "else", "return", "data_section", ";", "}", "</s>" ]

[ "On", "hpux10", ",", "the", "linker", "will", "give", "an", "error", "if", "we", "have", "a", "reference", "in", "the", "read-only", "data", "section", "to", "a", "symbol", "defined", "in", "a", "shared", "library", ".", "Therefore", ",", "expressions", "that", "might", "require", "a", "reloc", "can", "not", "be", "placed", "in", "the", "read-only", "data", "section", "." ]

[ "pa" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"TLCS900 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "TLCS900", "\"TLCS900 DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "else", "if", "(", "Constraint", "==", "\"wc\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "first", "&&", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", "&&", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "R", ".", "first", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TRI", "->", "getMatchingSuperReg", "(", "R", ".", "first", ",", "PPC", "::", "sub_32", ",", "&", "PPC", "::", "G8RCRegClass", ")", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "}", "return", "R", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass", "\"wc\"", "0U", "PPC::CRBITRCRegClass", "MVT::i64", "PPC", "PPC", "PPC::GPRCRegClass", "PPC::sub_32", "PPC::G8RCRegClass", "PPC::G8RCRegClass" ]

[]

[ "<s>", "virtual", "bool", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "ARMELFStreamer", "&", "ARMTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "ARMELFStreamer", "*", "S", "=", "static_cast", "<", "ARMELFStreamer", "*", ">", "(", "Streamer", ")", ";", "return", "*", "S", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "RTX_CODE", "avr_normalize_condition", "(", "RTX_CODE", "condition", ")", "{", "switch", "(", "condition", ")", "{", "case", "GT", ":", "return", "GE", ";", "case", "GTU", ":", "return", "GEU", ";", "case", "LE", ":", "return", "LT", ";", "case", "LEU", ":", "return", "LTU", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Convert", "condition", "code", "CONDITION", "to", "the", "valid", "AVR", "condition", "code" ]

[ "avr" ]

[]

[ "<s>", "const", "Cpu0TargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "Cpu0TargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

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

[]

[ "<s>", "void", "mmix_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "locals_size", "=", "get_frame_size", "(", ")", ";", "int", "regno", ";", "HOST_WIDE_INT", "stack_space_to_deallocate", "=", "(", "crtl", "->", "outgoing_args_size", "+", "crtl", "->", "args", ".", "pretend_args_size", "+", "locals_size", "+", "7", ")", "&", "~", "7", ";", "HOST_WIDE_INT", "offset", "=", "crtl", "->", "outgoing_args_size", ";", "for", "(", "regno", "=", "255", ";", "regno", ">=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "--", ")", "if", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "stack_space_to_deallocate", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "frame_pointer_needed", ")", "stack_space_to_deallocate", "+=", "8", ";", "if", "(", "(", "stack_space_to_deallocate", "%", "8", ")", "!=", "0", ")", "internal_error", "(", "\"stack frame not a multiple of octabyte: %wd\"", ",", "stack_space_to_deallocate", ")", ";", "for", "(", "regno", "=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "<=", "255", ";", "regno", "++", ")", "if", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "{", "if", "(", "offset", ">", "255", ")", "{", "mmix_emit_sp_add", "(", "offset", ")", ";", "stack_space_to_deallocate", "-=", "offset", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ")", ";", "offset", "+=", "8", ";", "}", "offset", "+=", "(", "locals_size", "+", "7", ")", "&", "~", "7", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "offset", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "offset", "+=", "8", ";", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "offset", ">", "255", ")", "{", "mmix_emit_sp_add", "(", "offset", ")", ";", "stack_space_to_deallocate", "-=", "offset", ";", "offset", "=", "0", ";", "}", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ")", ";", "offset", "+=", "8", ";", "}", "if", "(", "stack_space_to_deallocate", "!=", "0", ")", "mmix_emit_sp_add", "(", "stack_space_to_deallocate", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "DImode", ",", "MMIX_EH_RETURN_STACKADJ_REGNUM", ")", ")", ")", ";", "}", "</s>" ]

[ "Expands", "the", "function", "epilogue", "into", "RTX", "." ]

[ "mmix", "7", "7", "255", "8", "16", "8", "8", "8", "0", "\"stack frame not a multiple of octabyte: %wd\"", "255", "255", "0", "8", "7", "7", "16", "8", "255", "0", "8", "0" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCRetInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCRetInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_PPC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "VT", "=", "VA", ".", "getValVT", "(", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "16", "PPC", "0", "\"Can only return in registers!\"", "1", "0", "2" ]

[]

[ "<s>", "static", "__inline", "float", "sh_media_FMAC_S", "(", "float", "fg", ",", "float", "fh", ",", "float", "fq", ")", "{", "return", "fg", "*", "fh", "+", "fq", ";", "}", "</s>" ]

[ "This", "gives", "different", "results", "for", "-O0" ]

[ "sh" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

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

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

[ "RI5CY", "\"RISCV Assembly Printer\"" ]

[]

[ "<s>", "void", "print_reg", "(", "rtx", "x", ",", "int", "code", ",", "FILE", "*", "file", ")", "{", "gcc_assert", "(", "REGNO", "(", "x", ")", "!=", "ARG_POINTER_REGNUM", "&&", "REGNO", "(", "x", ")", "!=", "FRAME_POINTER_REGNUM", "&&", "REGNO", "(", "x", ")", "!=", "FLAGS_REG", "&&", "REGNO", "(", "x", ")", "!=", "FPSR_REG", ")", ";", "if", "(", "ASSEMBLER_DIALECT", "==", "ASM_ATT", "||", "USER_LABEL_PREFIX", "[", "0", "]", "==", "0", ")", "putc", "(", "'%'", ",", "file", ")", ";", "if", "(", "code", "==", "'w'", "||", "MMX_REG_P", "(", "x", ")", ")", "code", "=", "2", ";", "else", "if", "(", "code", "==", "'b'", ")", "code", "=", "1", ";", "else", "if", "(", "code", "==", "'k'", ")", "code", "=", "4", ";", "else", "if", "(", "code", "==", "'q'", ")", "code", "=", "8", ";", "else", "if", "(", "code", "==", "'y'", ")", "code", "=", "3", ";", "else", "if", "(", "code", "==", "'h'", ")", "code", "=", "0", ";", "else", "code", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ";", "if", "(", "REX_INT_REG_P", "(", "x", ")", ")", "{", "gcc_assert", "(", "TARGET_64BIT", ")", ";", "switch", "(", "code", ")", "{", "case", "0", ":", "error", "(", "\"extended registers have no high halves\"", ")", ";", "break", ";", "case", "1", ":", "fprintf", "(", "file", ",", "\"r%ib\"", ",", "REGNO", "(", "x", ")", "-", "FIRST_REX_INT_REG", "+", "8", ")", ";", "break", ";", "case", "2", ":", "fprintf", "(", "file", ",", "\"r%iw\"", ",", "REGNO", "(", "x", ")", "-", "FIRST_REX_INT_REG", "+", "8", ")", ";", "break", ";", "case", "4", ":", "fprintf", "(", "file", ",", "\"r%id\"", ",", "REGNO", "(", "x", ")", "-", "FIRST_REX_INT_REG", "+", "8", ")", ";", "break", ";", "case", "8", ":", "fprintf", "(", "file", ",", "\"r%i\"", ",", "REGNO", "(", "x", ")", "-", "FIRST_REX_INT_REG", "+", "8", ")", ";", "break", ";", "default", ":", "error", "(", "\"unsupported operand size for extended register\"", ")", ";", "break", ";", "}", "return", ";", "}", "switch", "(", "code", ")", "{", "case", "3", ":", "if", "(", "STACK_TOP_P", "(", "x", ")", ")", "{", "fputs", "(", "\"st(0)\"", ",", "file", ")", ";", "break", ";", "}", "case", "8", ":", "case", "4", ":", "case", "12", ":", "if", "(", "!", "ANY_FP_REG_P", "(", "x", ")", ")", "putc", "(", "code", "==", "8", "&&", "TARGET_64BIT", "?", "'r'", ":", "'e'", ",", "file", ")", ";", "case", "16", ":", "case", "2", ":", "normal", ":", "fputs", "(", "hi_reg_name", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "break", ";", "case", "1", ":", "if", "(", "REGNO", "(", "x", ")", ">=", "ARRAY_SIZE", "(", "qi_reg_name", ")", ")", "goto", "normal", ";", "fputs", "(", "qi_reg_name", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "break", ";", "case", "0", ":", "if", "(", "REGNO", "(", "x", ")", ">=", "ARRAY_SIZE", "(", "qi_high_reg_name", ")", ")", "goto", "normal", ";", "fputs", "(", "qi_high_reg_name", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Print", "a", "register", "." ]

[ "i386", "0", "0", "2", "1", "4", "8", "3", "0", "0", "\"extended registers have no high halves\"", "1", "\"r%ib\"", "8", "2", "\"r%iw\"", "8", "4", "\"r%id\"", "8", "8", "\"r%i\"", "8", "\"unsupported operand size for extended register\"", "3", "\"st(0)\"", "8", "4", "12", "8", "16", "2", "1", "0" ]

[]

[ "<s>", "const", "AMDGPUTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "WDC65816PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createWDC65816ISelDag", "(", "getWDC65816TargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC", "WDC", "WDC" ]

[]

[ "<s>", "void", "P2MCInstLower", "::", "Initialize", "(", "MCContext", "*", "C", ")", "{", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "P2", "P2" ]

[]

[ "<s>", "void", "pass_vsetvl", "::", "compute_local_backward_infos", "(", "const", "bb_info", "*", "bb", ")", "{", "vector_insn_info", "change", ";", "change", ".", "set_empty", "(", ")", ";", "auto", "&", "block_info", "=", "m_vector_manager", "->", "vector_block_infos", "[", "bb", "->", "index", "(", ")", "]", ";", "block_info", ".", "reaching_out", "=", "change", ";", "for", "(", "insn_info", "*", "insn", ":", "bb", "->", "reverse_real_nondebug_insns", "(", ")", ")", "{", "auto", "&", "info", "=", "m_vector_manager", "->", "vector_insn_infos", "[", "insn", "->", "uid", "(", ")", "]", ";", "if", "(", "info", ".", "uninit_p", "(", ")", ")", "info", "=", "change", ";", "else", "if", "(", "info", ".", "unknown_p", "(", ")", ")", "change", "=", "info", ";", "else", "{", "gcc_assert", "(", "info", ".", "valid_p", "(", ")", "&&", "\"Unexpected Invalid demanded info\"", ")", ";", "if", "(", "change", ".", "valid_p", "(", ")", ")", "{", "if", "(", "!", "(", "propagate_avl_across_demands_p", "(", "change", ",", "info", ")", "&&", "!", "reg_available_p", "(", "insn", ",", "change", ")", ")", "&&", "change", ".", "compatible_p", "(", "info", ")", ")", "{", "info", "=", "change", ".", "merge", "(", "info", ")", ";", "if", "(", "vsetvl_insn_p", "(", "insn", "->", "rtl", "(", ")", ")", ")", "change_vsetvl_insn", "(", "insn", ",", "info", ")", ";", "}", "}", "change", "=", "info", ";", "}", "}", "block_info", ".", "local_dem", "=", "change", ";", "if", "(", "block_info", ".", "local_dem", ".", "empty_p", "(", ")", ")", "block_info", ".", "reaching_out", "=", "block_info", ".", "local_dem", ";", "}", "</s>" ]

[ "Compute", "demanded", "information", "by", "backward", "data-flow", "analysis", "." ]

[ "riscv", "\"Unexpected Invalid demanded info\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_movq_load\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_signed_4byte\"", ",", "0", ",", "4", "*", "8", ",", "0", "}", ",", "{", "\"reloc_global_offset_table\"", ",", "0", ",", "4", "*", "8", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCCodeEmitter", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "X86", "\"reloc_riprel_4byte\"", "0", "4", "8", "\"reloc_riprel_4byte_movq_load\"", "0", "4", "8", "\"reloc_signed_4byte\"", "0", "4", "8", "0", "\"reloc_global_offset_table\"", "0", "4", "8", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "rtx", "ix86_find_base_term", "(", "rtx", "x", ")", "{", "rtx", "term", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST", ")", "return", "x", ";", "term", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "term", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "term", ",", "1", ")", ")", ")", "term", "=", "XEXP", "(", "term", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "term", ")", "!=", "UNSPEC", "||", "(", "XINT", "(", "term", ",", "1", ")", "!=", "UNSPEC_GOTPCREL", "&&", "XINT", "(", "term", ",", "1", ")", "!=", "UNSPEC_PCREL", ")", ")", "return", "x", ";", "return", "XVECEXP", "(", "term", ",", "0", ",", "0", ")", ";", "}", "return", "ix86_delegitimize_address_1", "(", "x", ",", "true", ")", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "machine", "specific", "address", "(", "i.e", ".", "a", "symbol", "or", "label", "being", "referenced", "as", "a", "displacement", "from", "the", "GOT", "implemented", "using", "an", "UNSPEC", ")", ",", "then", "return", "the", "base", "term", ".", "Otherwise", "return", "X", "." ]

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

[]

[ "<s>", "void", "aarch64_init_builtins", "(", "void", ")", "{", "tree", "ftype_set_fpr", "=", "build_function_type_list", "(", "void_type_node", ",", "unsigned_type_node", ",", "NULL", ")", ";", "tree", "ftype_get_fpr", "=", "build_function_type_list", "(", "unsigned_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPCR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_get_fpcr\"", ",", "ftype_get_fpr", ",", "AARCH64_BUILTIN_GET_FPCR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPCR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_set_fpcr\"", ",", "ftype_set_fpr", ",", "AARCH64_BUILTIN_SET_FPCR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_GET_FPSR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_get_fpsr\"", ",", "ftype_get_fpr", ",", "AARCH64_BUILTIN_GET_FPSR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_BUILTIN_SET_FPSR", "]", "=", "add_builtin_function", "(", "\"__builtin_aarch64_set_fpsr\"", ",", "ftype_set_fpr", ",", "AARCH64_BUILTIN_SET_FPSR", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "aarch64_init_fp16_types", "(", ")", ";", "if", "(", "TARGET_SIMD", ")", "aarch64_init_simd_builtins", "(", ")", ";", "aarch64_init_crc32_builtins", "(", ")", ";", "aarch64_init_builtin_rsqrt", "(", ")", ";", "if", "(", "!", "TARGET_ILP32", ")", "aarch64_init_pauth_hint_builtins", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "aarch64", "\"__builtin_aarch64_get_fpcr\"", "\"__builtin_aarch64_set_fpcr\"", "\"__builtin_aarch64_get_fpsr\"", "\"__builtin_aarch64_set_fpsr\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "LLVM_OVERRIDE", "{", "return", "\"SystemZ DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "loongarch_got_load_tls_gd", "(", "rtx", "dest", ",", "rtx", "sym", ")", "{", "return", "gen_got_load_tls_gd", "(", "Pmode", ",", "dest", ",", "sym", ")", ";", "}", "</s>" ]

[ "Load", "an", "entry", "from", "the", "GOT", "for", "a", "TLS", "GD", "access", "." ]

[ "loongarch" ]

[]