Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "RISCVTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", "&&", "\"getIntImmCost can only estimate cost of materialising integers\"", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "return", "RISCVMatInt", "::", "getIntMatCost", "(", "Imm", ",", "DL", ".", "getTypeSizeInBits", "(", "Ty", ")", ",", "getST", "(", ")", "->", "is64Bit", "(", ")", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"getIntImmCost can only estimate cost of materialising integers\"", "0", "RISCVMatInt::getIntMatCost" ]

[]

[ "<s>", "unsigned", "MBlazeInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "MBlaze", "::", "LWI", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze::LWI", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16mr", "0", "MSP430::GR8RegClass", "MSP430::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SparcTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SP", "::", "IntRegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "0", "0U", "SP::IntRegsRegClass" ]

[]

[ "<s>", "static", "tree", "lookup_vector_type_attribute", "(", "const_tree", "type", ")", "{", "if", "(", "type", "==", "error_mark_node", ")", "return", "NULL_TREE", ";", "return", "lookup_attribute", "(", "\"RVV type\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "}", "</s>" ]

[ "If", "TYPE", "is", "an", "ABI-defined", "RVV", "type", ",", "return", "its", "attribute", "descriptor", ",", "otherwise", "return", "null", "." ]

[ "riscv", "\"RVV type\"" ]

[]

[ "<s>", "MSP430Subtarget", "&", "MSP430Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "ParseSubtargetFeatures", "(", "\"generic\"", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "\"generic\"" ]

[]

[ "<s>", "static", "void", "riscv_legitimize_const_move", "(", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "splittable_const_int_operand", "(", "src", ",", "mode", ")", ")", "{", "riscv_move_integer", "(", "dest", ",", "dest", ",", "INTVAL", "(", "src", ")", ")", ";", "return", ";", "}", "if", "(", "riscv_split_symbol", "(", "dest", ",", "src", ",", "MAX_MACHINE_MODE", ",", "&", "src", ")", ")", "{", "riscv_emit_set", "(", "dest", ",", "src", ")", ";", "return", ";", "}", "if", "(", "riscv_tls_symbol_p", "(", "src", ")", ")", "{", "riscv_emit_move", "(", "dest", ",", "riscv_legitimize_tls_address", "(", "src", ")", ")", ";", "return", ";", "}", "split_const", "(", "src", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "offset", "!=", "const0_rtx", "&&", "(", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "src", ")", "||", "can_create_pseudo_p", "(", ")", ")", ")", "{", "base", "=", "riscv_force_temporary", "(", "dest", ",", "base", ")", ";", "riscv_emit_move", "(", "dest", ",", "riscv_add_offset", "(", "NULL", ",", "base", ",", "INTVAL", "(", "offset", ")", ")", ")", ";", "return", ";", "}", "src", "=", "force_const_mem", "(", "mode", ",", "src", ")", ";", "riscv_split_symbol", "(", "dest", ",", "XEXP", "(", "src", ",", "0", ")", ",", "mode", ",", "&", "XEXP", "(", "src", ",", "0", ")", ")", ";", "riscv_emit_move", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "riscv_legitimize_move", ".", "Move", "constant", "SRC", "into", "register", "DEST", "given", "that", "SRC", "satisfies", "immediate_operand", "but", "does", "n't", "satisfy", "move_operand", "." ]

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

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "emitLabel", "(", "MCSymbol", "*", "S", ")", "{", "auto", "*", "Symbol", "=", "cast", "<", "MCSymbolELF", ">", "(", "S", ")", ";", "if", "(", "!", "isMicroMipsEnabled", "(", ")", ")", "return", ";", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ".", "registerSymbol", "(", "*", "Symbol", ")", ";", "uint8_t", "Type", "=", "Symbol", "->", "getType", "(", ")", ";", "if", "(", "Type", "!=", "ELF", "::", "STT_FUNC", ")", "return", ";", "Symbol", "->", "setOther", "(", "ELF", "::", "STO_MIPS_MICROMIPS", ")", ";", "}", "</s>" ]

[ "Emit", "a", "label", "for", "Symbol", "into", "the", "current", "section", "." ]

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "const", "Function", "&", "F", ",", "Type", "*", "Ty", ")", "const", "{", "switch", "(", "Ty", "->", "getScalarType", "(", ")", "->", "getTypeID", "(", ")", ")", "{", "case", "Type", "::", "FloatTyID", ":", "case", "Type", "::", "DoubleTyID", ":", "return", "true", ";", "case", "Type", "::", "FP128TyID", ":", "return", "EnableQuadPrecision", "&&", "Subtarget", ".", "hasP9Vector", "(", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

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

[ "Return", "true", "if", "it", "'s", "profitable", "to", "unpredicate", "one", "side", "of", "a", "'diamond", "'", ",", "i.e", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "int", "arc_verify_short", "(", "rtx_insn", "*", "insn", ",", "int", ",", "int", "check_attr", ")", "{", "enum", "attr_iscompact", "iscompact", ";", "struct", "machine_function", "*", "machine", ";", "if", "(", "check_attr", ">", "0", ")", "{", "iscompact", "=", "get_attr_iscompact", "(", "insn", ")", ";", "if", "(", "iscompact", "==", "ISCOMPACT_FALSE", ")", "return", "0", ";", "}", "machine", "=", "cfun", "->", "machine", ";", "if", "(", "machine", "->", "force_short_suffix", ">=", "0", ")", "return", "machine", "->", "force_short_suffix", ";", "return", "(", "get_attr_length", "(", "insn", ")", "&", "2", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "INSN", "should", "be", "output", "as", "a", "short", "insn", ".", "UNALIGN", "is", "zero", "if", "the", "current", "insn", "is", "aligned", "to", "a", "4-byte-boundary", ",", "two", "otherwise", ".", "If", "CHECK_ATTR", "is", "greater", "than", "0", ",", "check", "the", "iscompact", "attribute", "first", "." ]

[ "arc", "0", "0", "0", "2", "0" ]

[]

[ "<s>", "X86Subtarget", "&", "X86Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "TuneCPU", ",", "StringRef", "FS", ")", "{", "initSubtargetFeatures", "(", "CPU", ",", "TuneCPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_function_specific_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", ")", "{", "ptr", "->", "arch", "=", "ix86_arch", ";", "ptr", "->", "schedule", "=", "ix86_schedule", ";", "ptr", "->", "prefetch_sse", "=", "ix86_prefetch_sse", ";", "ptr", "->", "tune", "=", "ix86_tune", ";", "ptr", "->", "branch_cost", "=", "ix86_branch_cost", ";", "ptr", "->", "tune_defaulted", "=", "ix86_tune_defaulted", ";", "ptr", "->", "arch_specified", "=", "ix86_arch_specified", ";", "ptr", "->", "x_ix86_isa_flags_explicit", "=", "opts", "->", "x_ix86_isa_flags_explicit", ";", "ptr", "->", "x_ix86_isa_flags2_explicit", "=", "opts", "->", "x_ix86_isa_flags2_explicit", ";", "ptr", "->", "x_recip_mask_explicit", "=", "opts", "->", "x_recip_mask_explicit", ";", "ptr", "->", "x_ix86_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "ptr", "->", "x_ix86_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "ptr", "->", "x_ix86_abi", "=", "opts", "->", "x_ix86_abi", ";", "ptr", "->", "x_ix86_asm_dialect", "=", "opts", "->", "x_ix86_asm_dialect", ";", "ptr", "->", "x_ix86_branch_cost", "=", "opts", "->", "x_ix86_branch_cost", ";", "ptr", "->", "x_ix86_dump_tunes", "=", "opts", "->", "x_ix86_dump_tunes", ";", "ptr", "->", "x_ix86_force_align_arg_pointer", "=", "opts", "->", "x_ix86_force_align_arg_pointer", ";", "ptr", "->", "x_ix86_force_drap", "=", "opts", "->", "x_ix86_force_drap", ";", "ptr", "->", "x_ix86_recip_name", "=", "opts", "->", "x_ix86_recip_name", ";", "ptr", "->", "x_ix86_section_threshold", "=", "opts", "->", "x_ix86_section_threshold", ";", "ptr", "->", "x_ix86_sse2avx", "=", "opts", "->", "x_ix86_sse2avx", ";", "ptr", "->", "x_ix86_stack_protector_guard", "=", "opts", "->", "x_ix86_stack_protector_guard", ";", "ptr", "->", "x_ix86_stringop_alg", "=", "opts", "->", "x_ix86_stringop_alg", ";", "ptr", "->", "x_ix86_tls_dialect", "=", "opts", "->", "x_ix86_tls_dialect", ";", "ptr", "->", "x_ix86_tune_ctrl_string", "=", "opts", "->", "x_ix86_tune_ctrl_string", ";", "ptr", "->", "x_ix86_tune_memcpy_strategy", "=", "opts", "->", "x_ix86_tune_memcpy_strategy", ";", "ptr", "->", "x_ix86_tune_memset_strategy", "=", "opts", "->", "x_ix86_tune_memset_strategy", ";", "ptr", "->", "x_ix86_tune_no_default", "=", "opts", "->", "x_ix86_tune_no_default", ";", "gcc_assert", "(", "ptr", "->", "arch", "==", "ix86_arch", ")", ";", "gcc_assert", "(", "ptr", "->", "schedule", "==", "ix86_schedule", ")", ";", "gcc_assert", "(", "ptr", "->", "tune", "==", "ix86_tune", ")", ";", "gcc_assert", "(", "ptr", "->", "branch_cost", "==", "ix86_branch_cost", ")", ";", "}", "</s>" ]

[ "Save", "the", "current", "options" ]

[ "i386" ]

[]

[ "<s>", "void", "arm_split_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "neg_bval", ";", "machine_mode", "mode", ";", "enum", "memmodel", "mod_s", ",", "mod_f", ";", "bool", "is_weak", ";", "rtx_code_label", "*", "label1", ",", "*", "label2", ";", "rtx", "x", ",", "cond", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "(", "operands", "[", "5", "]", "!=", "const0_rtx", ")", ";", "mod_s", "=", "memmodel_from_int", "(", "INTVAL", "(", "operands", "[", "6", "]", ")", ")", ";", "mod_f", "=", "memmodel_from_int", "(", "INTVAL", "(", "operands", "[", "7", "]", ")", ")", ";", "neg_bval", "=", "TARGET_THUMB1", "?", "operands", "[", "0", "]", ":", "operands", "[", "8", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "bool", "is_armv8_sync", "=", "arm_arch8", "&&", "is_mm_sync", "(", "mod_s", ")", ";", "bool", "use_acquire", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "is_mm_relaxed", "(", "mod_s", ")", "||", "is_mm_consume", "(", "mod_s", ")", "||", "is_mm_release", "(", "mod_s", ")", ")", ";", "bool", "use_release", "=", "TARGET_HAVE_LDACQ", "&&", "!", "(", "is_mm_relaxed", "(", "mod_s", ")", "||", "is_mm_consume", "(", "mod_s", ")", "||", "is_mm_acquire", "(", "mod_s", ")", ")", ";", "if", "(", "is_armv8_sync", ")", "use_acquire", "=", "false", ";", "if", "(", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_pre_atomic_barrier", "(", "mod_s", ")", ";", "label1", "=", "NULL", ";", "if", "(", "!", "is_weak", ")", "{", "label1", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label1", ")", ";", "}", "label2", "=", "gen_label_rtx", "(", ")", ";", "arm_emit_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "use_acquire", ")", ";", "if", "(", "TARGET_32BIT", ")", "{", "cond", "=", "arm_gen_compare_reg", "(", "NE", ",", "rval", ",", "oldval", ",", "neg_bval", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label2", ")", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "}", "else", "{", "emit_move_insn", "(", "neg_bval", ",", "const1_rtx", ")", ";", "cond", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "rval", ",", "oldval", ")", ";", "if", "(", "thumb1_cmpneg_operand", "(", "oldval", ",", "SImode", ")", ")", "emit_unlikely_jump", "(", "gen_cbranchsi4_scratch", "(", "neg_bval", ",", "rval", ",", "oldval", ",", "label2", ",", "cond", ")", ")", ";", "else", "emit_unlikely_jump", "(", "gen_cbranchsi4_insn", "(", "cond", ",", "rval", ",", "oldval", ",", "label2", ")", ")", ";", "}", "arm_emit_store_exclusive", "(", "mode", ",", "neg_bval", ",", "mem", ",", "newval", ",", "use_release", ")", ";", "if", "(", "TARGET_32BIT", ")", "{", "cond", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "CCmode", ",", "neg_bval", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cond", ",", "x", ")", ")", ";", "}", "if", "(", "!", "is_weak", ")", "{", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "neg_bval", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_cbranchsi4", "(", "x", ",", "neg_bval", ",", "const0_rtx", ",", "label1", ")", ")", ";", "}", "if", "(", "!", "is_mm_relaxed", "(", "mod_f", ")", ")", "emit_label", "(", "label2", ")", ";", "if", "(", "is_armv8_sync", "||", "!", "(", "use_acquire", "||", "use_release", ")", ")", "arm_post_atomic_barrier", "(", "mod_s", ")", ";", "if", "(", "is_mm_relaxed", "(", "mod_f", ")", ")", "emit_label", "(", "label2", ")", ";", "}", "</s>" ]

[ "Split", "a", "compare", "and", "swap", "pattern", ".", "It", "is", "IMPLEMENTATION", "DEFINED", "whether", "another", "memory", "store", "between", "the", "load-exclusive", "and", "store-exclusive", "can", "reset", "the", "monitor", "from", "Exclusive", "to", "Open", "state", ".", "This", "means", "we", "must", "wait", "until", "after", "reload", "to", "split", "the", "pattern", ",", "lest", "we", "get", "a", "register", "spill", "in", "the", "middle", "of", "the", "atomic", "sequence", "." ]

[ "arm", "1", "2", "3", "4", "5", "6", "7", "0", "8" ]

[]

[ "<s>", "bool", "Tile64TargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "Tile64" ]

[]

[ "<s>", "static", "void", "avr_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "new_decl_p", ")", "{", "if", "(", "new_decl_p", "&&", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "NULL_TREE", "==", "DECL_INITIAL", "(", "decl", ")", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "warning", "(", "OPT_Wuninitialized", ",", "\"uninitialized variable %q+D put into \"", "\"program memory area\"", ",", "decl", ")", ";", "}", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "new_decl_p", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", "&&", "MEM_P", "(", "rtl", ")", "&&", "SYMBOL_REF", "==", "GET_CODE", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ")", "{", "rtx", "sym", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "tree", "attr", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "if", "(", "type", "==", "error_mark_node", ")", "return", ";", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "type", ")", ";", "if", "(", "-", "1", "==", "avr_progmem_p", "(", "decl", ",", "attr", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "AVR_SYMBOL_SET_ADDR_SPACE", "(", "sym", ",", "as", ")", ";", "tree", "io_low_attr", "=", "lookup_attribute", "(", "\"io_low\"", ",", "attr", ")", ";", "tree", "io_attr", "=", "lookup_attribute", "(", "\"io\"", ",", "attr", ")", ";", "tree", "addr_attr", ";", "if", "(", "io_low_attr", "&&", "TREE_VALUE", "(", "io_low_attr", ")", "&&", "TREE_VALUE", "(", "TREE_VALUE", "(", "io_low_attr", ")", ")", ")", "addr_attr", "=", "io_attr", ";", "else", "if", "(", "io_attr", "&&", "TREE_VALUE", "(", "io_attr", ")", "&&", "TREE_VALUE", "(", "TREE_VALUE", "(", "io_attr", ")", ")", ")", "addr_attr", "=", "io_attr", ";", "else", "addr_attr", "=", "lookup_attribute", "(", "\"address\"", ",", "attr", ")", ";", "if", "(", "io_low_attr", "||", "(", "io_attr", "&&", "addr_attr", "&&", "low_io_address_operand", "(", "GEN_INT", "(", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "addr_attr", ")", ")", ")", ")", ",", "QImode", ")", ")", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_IO_LOW", ";", "if", "(", "io_attr", "||", "io_low_attr", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_IO", ";", "if", "(", "addr_attr", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_ADDRESS", ";", "}", "}", "</s>" ]

[ "Implement", "`", "TARGET_ENCODE_SECTION_INFO", "'", "." ]

[ "avr", "\"uninitialized variable %q+D put into \"", "\"program memory area\"", "0", "0", "1", "\"io_low\"", "\"io\"", "\"address\"" ]

[]

[ "<s>", "void", "CSKYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "Dl", "(", "N", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "IsSelected", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADDCARRY", ":", "IsSelected", "=", "selectAddCarry", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "SUBCARRY", ":", "IsSelected", "=", "selectSubCarry", "(", "N", ")", ";", "break", ";", "}", "if", "(", "IsSelected", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"== \"", "\"\\n\"", "1", "ISD::ADDCARRY", "ISD::SUBCARRY" ]

[]

[ "<s>", "static", "int", "ix86_dirflag_mode_needed", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_NORMAL", ")", "return", "X86_DIRFLAG_ANY", ";", "else", "return", "TARGET_CLD", "?", "X86_DIRFLAG_ANY", ":", "X86_DIRFLAG_RESET", ";", "}", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "X86_DIRFLAG_ANY", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_STR", ")", "{", "if", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_NORMAL", ")", "return", "TARGET_CLD", "?", "X86_DIRFLAG_RESET", ":", "X86_DIRFLAG_ANY", ";", "else", "return", "X86_DIRFLAG_RESET", ";", "}", "return", "X86_DIRFLAG_ANY", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "rtx", "nios2_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "return_rtx", "=", "NULL_RTX", ";", "if", "(", "cum", "->", "regs_used", "<", "NUM_ARG_REGS", ")", "return_rtx", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "FIRST_ARG_REGNO", "+", "cum", "->", "regs_used", ")", ";", "return", "return_rtx", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_call_properties", "(", "aarch64_simd_builtin_datum", "*", "d", ")", "{", "unsigned", "int", "flags", "=", "d", "->", "flags", ";", "if", "(", "!", "(", "flags", "&", "FLAG_AUTO_FP", ")", "&&", "FLOAT_MODE_P", "(", "d", "->", "mode", ")", ")", "flags", "|=", "FLAG_FP", ";", "if", "(", "!", "flag_trapping_math", ")", "flags", "&=", "~", "FLAG_RAISE_FP_EXCEPTIONS", ";", "return", "flags", ";", "}", "</s>" ]

[ "Return", "a", "set", "of", "FLAG_", "*", "flags", "that", "describe", "what", "the", "function", "could", "do", ",", "taking", "the", "command-line", "flags", "into", "account", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "rtx", "rs6000_load_constant_and_splat", "(", "machine_mode", "mode", ",", "REAL_VALUE_TYPE", "dconst", ")", "{", "rtx", "reg", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", "{", "rtx", "d", "=", "const_double_from_real_value", "(", "dconst", ",", "mode", ")", ";", "reg", "=", "force_reg", "(", "mode", ",", "d", ")", ";", "}", "else", "if", "(", "mode", "==", "V4SFmode", ")", "{", "rtx", "d", "=", "const_double_from_real_value", "(", "dconst", ",", "SFmode", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "4", ",", "d", ",", "d", ",", "d", ",", "d", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_expand_vector_init", "(", "reg", ",", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "if", "(", "mode", "==", "V2DFmode", ")", "{", "rtx", "d", "=", "const_double_from_real_value", "(", "dconst", ",", "DFmode", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "2", ",", "d", ",", "d", ")", ";", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_expand_vector_init", "(", "reg", ",", "gen_rtx_PARALLEL", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Load", "up", "a", "constant", ".", "If", "the", "mode", "is", "a", "vector", "mode", ",", "splat", "the", "value", "across", "all", "of", "the", "vector", "elements", "." ]

[ "powerpcspe", "4", "2" ]

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "SUnit", "*", "SU", ";", "if", "(", "ForceTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ".", "Available", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "TopResult", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "ForceBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ".", "Available", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "BotResult", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidrectional", "(", "IsTopNode", ")", ";", "}", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "(", "IsTopNode", "?", "\"Top\"", ":", "\"Bottom\"", ")", "<<", "\" Scheduling Instruction in cycle \"", "<<", "(", "IsTopNode", "?", "Top", ".", "CurrCycle", ":", "Bot", ".", "CurrCycle", ")", "<<", "'\\n'", ";", "SU", "->", "dump", "(", "DAG", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "Hexagon", "\"ReadyQ garbage\"", "\"failed to find the first candidate\"", "\"failed to find the first candidate\"", "\"*** \"", "\"Top\"", "\"Bottom\"", "\" Scheduling Instruction in cycle \"" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "combineRepeatedFPDivisors", "(", ")", "const", "{", "switch", "(", "Subtarget", ".", "getDarwinDirective", "(", ")", ")", "{", "default", ":", "return", "3", ";", "case", "PPC", "::", "DIR_440", ":", "case", "PPC", "::", "DIR_A2", ":", "case", "PPC", "::", "DIR_E500", ":", "case", "PPC", "::", "DIR_E500mc", ":", "case", "PPC", "::", "DIR_E5500", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Indicate", "whether", "this", "target", "prefers", "to", "combine", "FDIVs", "with", "the", "same", "divisor", "." ]

[ "PowerPC", "PPC", "3", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500", "PPC::DIR_E500mc", "PPC::DIR_E5500", "2" ]

[]

[ "<s>", "AVRSubtarget", "::", "AVRSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "AVRTargetMachine", "&", "TM", ")", ":", "AVRGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "ELFArch", "(", "0", ")", ",", "m_hasSRAM", "(", "false", ")", ",", "m_hasJMPCALL", "(", "false", ")", ",", "m_hasIJMPCALL", "(", "false", ")", ",", "m_hasEIJMPCALL", "(", "false", ")", ",", "m_hasADDSUBIW", "(", "false", ")", ",", "m_hasSmallStack", "(", "false", ")", ",", "m_hasMOVW", "(", "false", ")", ",", "m_hasLPM", "(", "false", ")", ",", "m_hasLPMX", "(", "false", ")", ",", "m_hasELPM", "(", "false", ")", ",", "m_hasELPMX", "(", "false", ")", ",", "m_hasSPM", "(", "false", ")", ",", "m_hasSPMX", "(", "false", ")", ",", "m_hasDES", "(", "false", ")", ",", "m_supportsRMW", "(", "false", ")", ",", "m_supportsMultiplication", "(", "false", ")", ",", "m_hasBREAK", "(", "false", ")", ",", "m_hasTinyEncoding", "(", "false", ")", ",", "m_hasMemMappedGPR", "(", "false", ")", ",", "m_FeatureSetDummy", "(", "false", ")", ",", "TLInfo", "(", "TM", ",", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "Creates", "an", "AVR", "subtarget", "." ]

[ "AVR", "AVR", "AVR", "AVR", "AVR", "0" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", "||", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "if", "(", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "!", "isOperandLegal", "(", "MI", ",", "1", ",", "&", "MI", "->", "getOperand", "(", "2", ")", ")", "||", "!", "isOperandLegal", "(", "MI", ",", "2", ",", "&", "MI", "->", "getOperand", "(", "1", ")", ")", ")", ")", "return", "nullptr", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "MI", "->", "getOperand", "(", "2", ")", ".", "isFPImm", "(", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "nullptr", ";", "}", "const", "MachineOperand", "*", "Abs", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "abs", ")", ";", "const", "MachineOperand", "*", "Neg", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "neg", ")", ";", "const", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ";", "const", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "const", "MachineOperand", "*", "Src2Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "if", "(", "(", "Abs", "&&", "Abs", "->", "getImm", "(", ")", ")", "||", "(", "Neg", "&&", "Neg", "->", "getImm", "(", ")", ")", "||", "(", "Src0Mods", "&&", "Src0Mods", "->", "getImm", "(", ")", ")", "||", "(", "Src1Mods", "&&", "Src1Mods", "->", "getImm", "(", ")", ")", "||", "(", "Src2Mods", "&&", "Src2Mods", "->", "getImm", "(", ")", ")", ")", "return", "nullptr", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "ChangeToImmediate", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "1", "2", "2", "1", "2", "2", "1", "1", "1", "2", "2", "2" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "bool", "IsN64", "=", "Subtarget", ".", "isABI_N64", "(", ")", ";", "if", "(", "Subtarget", ".", "inMips16Mode", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Mips", "::", "S0", ":", "Mips", "::", "SP", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "IsN64", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ")", ":", "(", "IsN64", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips::S0", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::SP_64", "Mips::SP" ]

[]

[ "<s>", "void", "VideoCore4InstrInfo", "::", "adjustStackPtr", "(", "int64_t", "amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "amount", "<", "0", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "MOV_LI", ")", ",", "VideoCore4", "::", "R15", ")", ".", "addImm", "(", "-", "amount", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "SUB_F_RR", ")", ",", "VideoCore4", "::", "SP", ")", ".", "addReg", "(", "VideoCore4", "::", "SP", ")", ".", "addReg", "(", "VideoCore4", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "SUB_F_RI", ")", ",", "VideoCore4", "::", "SP", ")", ".", "addReg", "(", "VideoCore4", "::", "SP", ")", ".", "addImm", "(", "-", "amount", ")", ";", "}", "else", "if", "(", "amount", ">", "0", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "MOV_LI", ")", ",", "VideoCore4", "::", "R15", ")", ".", "addImm", "(", "amount", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "ADD_F_RR", ")", ",", "VideoCore4", "::", "SP", ")", ".", "addReg", "(", "VideoCore4", "::", "SP", ")", ".", "addReg", "(", "VideoCore4", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "ADD_F_RI", ")", ",", "VideoCore4", "::", "SP", ")", ".", "addReg", "(", "VideoCore4", "::", "SP", ")", ".", "addImm", "(", "amount", ")", ";", "}", "else", "{", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "VideoCore4", "VideoCore4", "0", "VideoCore4::MOV_LI", "VideoCore4::R15", "VideoCore4::SUB_F_RR", "VideoCore4::SP", "VideoCore4::SP", "VideoCore4::R15", "VideoCore4::SUB_F_RI", "VideoCore4::SP", "VideoCore4::SP", "0", "VideoCore4::MOV_LI", "VideoCore4::R15", "VideoCore4::ADD_F_RR", "VideoCore4::SP", "VideoCore4::SP", "VideoCore4::R15", "VideoCore4::ADD_F_RI", "VideoCore4::SP", "VideoCore4::SP" ]

[]

[ "<s>", "int", "m32c_secondary_reload_class", "(", "int", "rclass", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "int", "cc", "=", "class_contents", "[", "rclass", "]", "[", "0", "]", ";", "fprintf", "(", "stderr", ",", "\"\\nsecondary reload class %s %s\\n\"", ",", "class_names", "[", "rclass", "]", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "mode", "==", "QImode", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "(", "cc", "&", "~", "class_contents", "[", "R23_REGS", "]", "[", "0", "]", ")", "==", "0", ")", "return", "QI_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "CR_REGS", ")", "&&", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "REGNO", "(", "x", ")", ">=", "SB_REGNO", "&&", "REGNO", "(", "x", ")", "<=", "SP_REGNO", ")", "return", "(", "TARGET_A16", "||", "mode", "==", "HImode", ")", "?", "HI_REGS", ":", "A_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implements", "SECONDARY_RELOAD_CLASS", ".", "QImode", "have", "to", "be", "reloaded", "in", "r0", "or", "r1", ",", "as", "those", "are", "the", "only", "real", "QImode", "registers", ".", "CR", "regs", "get", "reloaded", "through", "appropriately", "sized", "general", "or", "address", "registers", "." ]

[ "m32c", "0", "\"\\nsecondary reload class %s %s\\n\"", "0", "0" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "const", "MCSchedClassDesc", "*", "SC", "=", "HazardRec", "->", "getSchedClass", "(", "SU", ")", ";", "bool", "AffectsGrouping", "=", "(", "SC", "->", "isValid", "(", ")", "&&", "(", "SC", "->", "BeginGroup", "||", "SC", "->", "EndGroup", ")", ")", ";", "SU", "->", "isScheduleHigh", "=", "(", "AffectsGrouping", "||", "SU", "->", "isUnbuffered", ")", ";", "Available", ".", "insert", "(", "SU", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "unsigned", "TOYInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "assert", "(", "0", "&&", "\"Unimplemented\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "TOY", "TOY", "0", "\"Unimplemented\"", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "mips16e_collect_argument_saves", "(", "void", ")", "{", "rtx", "reg_values", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "rtx_insn", "*", "insn", ",", "*", "next", ";", "rtx", "set", ",", "dest", ",", "src", ";", "unsigned", "int", "nargs", ",", "regno", ";", "push_topmost_sequence", "(", ")", ";", "nargs", "=", "0", ";", "memset", "(", "reg_values", ",", "0", ",", "sizeof", "(", "reg_values", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "next", ")", "{", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "NOTE_P", "(", "insn", ")", "||", "DEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "break", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "break", ";", "dest", "=", "SET_DEST", "(", "set", ")", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "mips16e_collect_argument_save_p", "(", "dest", ",", "src", ",", "reg_values", ",", "&", "regno", ")", ")", "{", "if", "(", "!", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "regno", ")", ")", "{", "delete_insn", "(", "insn", ")", ";", "nargs", "=", "MAX", "(", "nargs", ",", "(", "regno", "-", "GP_ARG_FIRST", ")", "+", "1", ")", ";", "}", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "GET_MODE", "(", "dest", ")", "==", "word_mode", ")", "reg_values", "[", "REGNO", "(", "dest", ")", "]", "=", "mips16e_collect_propagate_value", "(", "src", ",", "reg_values", ")", ";", "else", "break", ";", "}", "pop_topmost_sequence", "(", ")", ";", "return", "nargs", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "mips_expand_prologue", ",", "called", "only", "when", "generating", "MIPS16e", "SAVE", "instructions", ".", "Search", "the", "start", "of", "the", "function", "for", "any", "instructions", "that", "save", "argument", "registers", "into", "their", "caller-allocated", "save", "slots", ".", "Delete", "such", "instructions", "and", "return", "a", "value", "N", "such", "that", "saving", "[", "GP_ARG_FIRST", ",", "GP_ARG_FIRST", "+", "N", ")", "would", "make", "all", "the", "deleted", "instructions", "redundant", "." ]

[ "mips", "0", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "VEISD", "::", "NAME", ":", "\\", "return", "\"VEISD::\"", "#", "NAME", ";", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "TARGET_NODE_CASE", "(", "CALL", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_LONGJMP", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_SETJMP", ")", "TARGET_NODE_CASE", "(", "EH_SJLJ_SETUP_DISPATCH", ")", "TARGET_NODE_CASE", "(", "GETFUNPLT", ")", "TARGET_NODE_CASE", "(", "GETSTACKTOP", ")", "TARGET_NODE_CASE", "(", "GETTLSADDR", ")", "TARGET_NODE_CASE", "(", "GLOBAL_BASE_REG", ")", "TARGET_NODE_CASE", "(", "Hi", ")", "TARGET_NODE_CASE", "(", "Lo", ")", "TARGET_NODE_CASE", "(", "MEMBARRIER", ")", "TARGET_NODE_CASE", "(", "RET_FLAG", ")", "TARGET_NODE_CASE", "(", "TS1AM", ")", "TARGET_NODE_CASE", "(", "VEC_UNPACK_LO", ")", "TARGET_NODE_CASE", "(", "VEC_UNPACK_HI", ")", "TARGET_NODE_CASE", "(", "VEC_PACK", ")", "TARGET_NODE_CASE", "(", "VEC_BROADCAST", ")", "TARGET_NODE_CASE", "(", "REPL_I32", ")", "TARGET_NODE_CASE", "(", "REPL_F32", ")", "TARGET_NODE_CASE", "(", "LEGALAVL", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NAME", "\"VEISD::\"", "VEISD::NodeType", "VEISD::FIRST_NUMBER", "VE", "VE", "VE", "VE" ]

[]

[ "<s>", "const", "uint32_t", "*", "CAHPRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_RegMask", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "calculateIndirectAddress", "(", "unsigned", "RegIndex", ",", "unsigned", "Channel", ")", "const", "{", "assert", "(", "Channel", "==", "0", ")", ";", "return", "RegIndex", ";", "}", "</s>" ]

[ "Calculate", "the", "``", "Indirect", "Address", "''", "for", "the", "given", "RegIndex", "and", "Channel", "." ]

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

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "bool", "AddressOf", "=", "false", ",", "SMLoc", "OffsetOfLoc", "=", "SMLoc", "(", ")", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ")", "{", "auto", "Res", "=", "llvm", "::", "make_unique", "<", "X86Operand", ">", "(", "Register", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Res", "->", "AddressOf", "=", "AddressOf", ";", "Res", "->", "OffsetOfLoc", "=", "OffsetOfLoc", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "return", "Res", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AVRAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "assert", "(", "(", "Count", "%", "2", ")", "==", "0", "&&", "\"NOP instructions must be 2 bytes\"", ")", ";", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "2", "0", "\"NOP instructions must be 2 bytes\"" ]

[]

[ "<s>", "void", "riscv_register_pragmas", "(", "void", ")", "{", "targetm", ".", "check_builtin_call", "=", "riscv_check_builtin_call", ";", "c_register_pragma", "(", "\"riscv\"", ",", "\"intrinsic\"", ",", "riscv_pragma_intrinsic", ")", ";", "}", "</s>" ]

[ "Implement", "REGISTER_TARGET_PRAGMAS", "." ]

[ "riscv", "\"riscv\"", "\"intrinsic\"" ]

[]

[ "<s>", "static", "bool", "alpha_cannot_copy_insn_p", "(", "rtx", "insn", ")", "{", "if", "(", "!", "reload_completed", "||", "!", "TARGET_EXPLICIT_RELOCS", ")", "return", "false", ";", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "return", "get_attr_cannot_copy", "(", "insn", ")", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "true", "for", "any", "insn", "that", "we", "'ve", "marked", "with", "gpdisp", "relocs", ",", "since", "those", "have", "to", "stay", "in", "1-1", "correspondence", "with", "one", "another", ".", "Technically", "we", "could", "copy", "them", "if", "we", "could", "set", "up", "a", "mapping", "from", "one", "sequence", "number", "to", "another", ",", "across", "the", "set", "of", "insns", "to", "be", "duplicated", ".", "This", "seems", "overly", "complicated", "and", "error-prone", "since", "interblock", "motion", "from", "sched-ebb", "could", "move", "one", "of", "the", "pair", "of", "insns", "to", "a", "different", "block", ".", "Also", "can", "not", "allow", "jsr", "insns", "to", "be", "duplicated", ".", "If", "they", "throw", "exceptions", ",", "then", "they", "'ll", "be", "in", "a", "different", "block", "from", "their", "ldgp", ".", "Which", "could", "lead", "the", "bb", "reorder", "code", "to", "think", "that", "it", "would", "be", "ok", "to", "copy", "just", "the", "block", "containing", "the", "call", "and", "branch", "to", "the", "block", "containing", "the", "ldgp", "." ]

[ "alpha", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalICmpImmediate", "(", "int64_t", "Val", ")", "const", "{", "if", "(", "Val", "<", "0", ")", "Val", "=", "-", "Val", ";", "return", "(", "Val", "&", "~", "0xfff", ")", "==", "0", "||", "(", "Val", "&", "~", "0xfff000", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "icmp", "immediate", ",", "that", "is", "the", "target", "has", "icmp", "instructions", "which", "can", "compare", "a", "register", "against", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "AArch64", "AArch64", "0", "0xfff", "0", "0xfff000", "0" ]

[]

[ "<s>", "bool", "M68kOperand", "::", "isReg", "(", ")", "const", "{", "return", "Kind", "==", "KindTy", "::", "MemOp", "&&", "MemOp", ".", "Op", "==", "M68kMemOp", "::", "Kind", "::", "Reg", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68kMemOp::Kind" ]

[]

[ "<s>", "static", "void", "avoid_collisions", "(", "tag_map_t", "&", "tag_map", ")", "{", "do", "{", "map_changed", "=", "false", ";", "tag_map", ".", "traverse", "<", "tag_map_t", "*", ",", "avoid_collisions_1", ">", "(", "&", "tag_map", ")", ";", "}", "while", "(", "map_changed", ")", ";", "}", "</s>" ]

[ "For", "each", "set", "of", "collisions", ",", "attempt", "to", "rename", "the", "registers", "or", "insert", "a", "move", "to", "avoid", "the", "collision", ".", "We", "repeatedly", "traverse", "through", "TAG_MAP", "using", "AVOID_COLLISIONS_1", "trying", "to", "rename", "registers", "to", "avoid", "collisions", "until", "a", "full", "traversal", "results", "in", "no", "change", "in", "the", "map", "." ]

[ "aarch64" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"BPF Preserve DebugInfo Type\"", ";", "}", "</s>" ]

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

[ "BPF", "\"BPF Preserve DebugInfo Type\"" ]

[]

[ "<s>", "void", "setReg", "(", "unsigned", "Reg", ")", "{", "assert", "(", "isRegBase", "(", ")", "&&", "\"Invalid base register access!\"", ")", ";", "Base", ".", "Reg", "=", "Reg", ";", "}", "</s>" ]

[ "Assigns", "the", "associated", "register", "for", "this", "edge", "." ]

[ "WebAssembly", "\"Invalid base register access!\"" ]

[]

[ "<s>", "bool", "pass_vsetvl", "::", "need_vsetvl", "(", "const", "vector_insn_info", "&", "require", ",", "const", "vector_insn_info", "&", "curr_info", ")", "const", "{", "if", "(", "!", "curr_info", ".", "valid_p", "(", ")", "||", "curr_info", ".", "unknown_p", "(", ")", "||", "curr_info", ".", "uninit_p", "(", ")", ")", "return", "true", ";", "if", "(", "require", ".", "compatible_p", "(", "static_cast", "<", "const", "vl_vtype_info", "&", ">", "(", "curr_info", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "dem_info", "is", "required", "to", "transition", "from", "curr_info", "to", "require", "before", "INSN", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "MachineOperand", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "if", "(", "HRI", ".", "isPhysicalRegister", "(", "DefMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "DefMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "DefMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "DefMI", ".", "findRegisterDefOperandIdx", "(", "*", "SR", ",", "false", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "DefIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "MachineOperand", "UseMO", "=", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ";", "if", "(", "UseMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "UseMO", ".", "getReg", "(", ")", ",", "&", "HRI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "UseMI", ".", "findRegisterUseOperandIdx", "(", "*", "SR", ",", "false", ",", "&", "HRI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "UseIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "}", "int", "Latency", "=", "TargetInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "if", "(", "!", "Latency", ")", "Latency", "=", "1", ";", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

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

[]

[ "<s>", "void", "GBZ80InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "GB", "::", "LD8_FI", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "assert", "(", "false", "&&", "\"not implemented\"", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot load this register from a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "0", "MVT::i8", "GB::LD8_FI", "MVT::i16", "\"not implemented\"", "\"Cannot load this register from a stack slot!\"" ]

[]

[ "<s>", "int", "mmix_starting_frame_offset", "(", "void", ")", "{", "return", "(", "-", "8", "+", "(", "MMIX_CFUN_HAS_LANDING_PAD", "?", "-", "16", ":", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", "?", "-", "8", ":", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "STARTING_FRAME_OFFSET", "." ]

[ "mmix", "8", "16", "8", "0" ]

[]

[ "<s>", "void", "msp430_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "const", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ",", "int", "local", ")", "{", "if", "(", "(", "msp430_data_region", "==", "MSP430_REGION_ANY", "||", "(", "(", "msp430_data_region", "==", "MSP430_REGION_LOWER", ")", "&&", "!", "TARGET_USE_LOWER_REGION_PREFIX", ")", ")", "&&", "!", "(", "decl", "!=", "NULL_TREE", "&&", "DECL_SECTION_NAME", "(", "decl", ")", ")", "&&", "!", "has_attr", "(", "ATTR_EITHER", ",", "decl", ")", "&&", "!", "has_attr", "(", "ATTR_LOWER", ",", "decl", ")", "&&", "!", "has_attr", "(", "ATTR_UPPER", ",", "decl", ")", "&&", "!", "has_attr", "(", "ATTR_PERSIST", ",", "decl", ")", "&&", "!", "has_attr", "(", "ATTR_NOINIT", ",", "decl", ")", ")", "{", "if", "(", "local", ")", "{", "fprintf", "(", "stream", ",", "LOCAL_ASM_OP", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "fprintf", "(", "stream", ",", "COMMON_ASM_OP", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\",\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\",%u\\n\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "else", "{", "section", "*", "sec", ";", "if", "(", "decl", ")", "sec", "=", "msp430_select_section", "(", "decl", ",", "0", ",", "align", ")", ";", "else", "switch", "(", "msp430_data_region", ")", "{", "case", "MSP430_REGION_UPPER", ":", "sec", "=", "get_named_section", "(", "NULL", ",", "\".upper.bss\"", ",", "0", ")", ";", "break", ";", "case", "MSP430_REGION_LOWER", ":", "sec", "=", "get_named_section", "(", "NULL", ",", "\".lower.bss\"", ",", "0", ")", ";", "break", ";", "case", "MSP430_REGION_EITHER", ":", "sec", "=", "get_named_section", "(", "NULL", ",", "\".either.bss\"", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "sec", "!=", "NULL", ")", ";", "switch_to_section", "(", "sec", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "if", "(", "!", "local", ")", "{", "targetm", ".", "asm_out", ".", "globalize_label", "(", "stream", ",", "name", ")", ";", "ASM_WEAKEN_LABEL", "(", "stream", ",", "name", ")", ";", "}", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "ASM_OUTPUT_SKIP", "(", "stream", ",", "size", "?", "size", ":", "1", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "declaration", "of", "a", "common", "symbol", ".", "If", "a", "data", "region", "is", "in", "use", "then", "put", "the", "symbol", "into", "the", "equivalent", ".bss", "section", "instead", ".", "If", "LOCAL", "is", "1", ",", "then", "DECL", "is", "for", "a", "local", "common", "variable", "." ]

[ "msp430", "\"\\n\"", "\",\"", "\",%u\\n\"", "0", "\".upper.bss\"", "0", "\".lower.bss\"", "0", "\".either.bss\"", "0", "1" ]

[]

[ "<s>", "void", "SystemZMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "!", "AsmPrinter", ".", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "Opcode", "=", "getShortenedInstr", "(", "Opcode", ")", ";", "OutMI", ".", "setOpcode", "(", "Opcode", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MI", "->", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "I", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isImplicit", "(", ")", ")", "OutMI", ".", "addOperand", "(", "lowerOperand", "(", "MO", ")", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

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

[]

[ "<s>", "bool", "ix86_function_arg_regno_p", "(", "int", "regno", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", "(", "regno", "<", "REGPARM_MAX", "||", "(", "TARGET_MMX", "&&", "MMX_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "<", "FIRST_MMX_REG", "+", "MMX_REGPARM_MAX", ")", ")", "||", "(", "TARGET_SSE", "&&", "SSE_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "<", "FIRST_SSE_REG", "+", "SSE_REGPARM_MAX", ")", ")", ")", ";", "if", "(", "TARGET_SSE", "&&", "SSE_REGNO_P", "(", "regno", ")", "&&", "(", "regno", "<", "FIRST_SSE_REG", "+", "SSE_REGPARM_MAX", ")", ")", "return", "true", ";", "if", "(", "!", "regno", ")", "return", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "REGPARM_MAX", ";", "i", "++", ")", "if", "(", "regno", "==", "x86_64_int_parameter_registers", "[", "i", "]", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "register", "may", "be", "used", "to", "pass", "function", "parameters", "." ]

[ "i386", "0" ]

[]

[ "<s>", "rtx", "gen_split_move_double", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "val", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "SUBREG", ")", "alter_subreg", "(", "&", "dest", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "SUBREG", ")", "alter_subreg", "(", "&", "src", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", "{", "int", "dregno", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "sregno", "=", "REGNO", "(", "src", ")", ";", "int", "reverse", "=", "(", "dregno", "==", "sregno", "+", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operand_subword", "(", "dest", ",", "reverse", ",", "TRUE", ",", "mode", ")", ",", "operand_subword", "(", "src", ",", "reverse", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operand_subword", "(", "dest", ",", "!", "reverse", ",", "TRUE", ",", "mode", ")", ",", "operand_subword", "(", "src", ",", "!", "reverse", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "{", "rtx", "words", "[", "2", "]", ";", "split_double", "(", "src", ",", "&", "words", "[", "0", "]", ",", "&", "words", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operand_subword", "(", "dest", ",", "0", ",", "TRUE", ",", "mode", ")", ",", "words", "[", "0", "]", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operand_subword", "(", "dest", ",", "1", ",", "TRUE", ",", "mode", ")", ",", "words", "[", "1", "]", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "int", "reverse", "=", "(", "refers_to_regno_p", "(", "dregno", ",", "dregno", "+", "1", ",", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", "!=", "0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operand_subword", "(", "dest", ",", "reverse", ",", "TRUE", ",", "mode", ")", ",", "adjust_address", "(", "src", ",", "SImode", ",", "reverse", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operand_subword", "(", "dest", ",", "!", "reverse", ",", "TRUE", ",", "mode", ")", ",", "adjust_address", "(", "src", ",", "SImode", ",", "!", "reverse", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "adjust_address", "(", "dest", ",", "SImode", ",", "0", ")", ",", "operand_subword", "(", "src", ",", "0", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "adjust_address", "(", "dest", ",", "SImode", ",", "UNITS_PER_WORD", ")", ",", "operand_subword", "(", "src", ",", "1", ",", "TRUE", ",", "mode", ")", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "val", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "val", ";", "}", "</s>" ]

[ "Split", "a", "2", "word", "move", "(", "DI", "or", "DF", ")", "into", "component", "parts", "." ]

[ "m32r", "0", "0", "1", "1", "2", "0", "1", "0", "0", "1", "1", "1", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "class", "LLVM_LIBRARY_VISIBILITY", "X86MCInstLower", "{", "MCContext", "&", "Ctx", ";", "Mangler", "*", "Mang", ";", "const", "MachineFunction", "&", "MF", ";", "const", "TargetMachine", "&", "TM", ";", "const", "MCAsmInfo", "&", "MAI", ";", "X86AsmPrinter", "&", "AsmPrinter", ";", "public", ":", "X86MCInstLower", "(", "Mangler", "*", "mang", ",", "const", "MachineFunction", "&", "MF", ",", "X86AsmPrinter", "&", "asmprinter", ")", ";", "void", "Lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", ";", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCOperand", "LowerSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCSymbol", "*", "Sym", ")", "const", ";", "private", ":", "MachineModuleInfoMachO", "&", "getMachOMMI", "(", ")", "const", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "JTI", "=", "(", "(", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "(", "const", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "const", "MipsTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getDataLayout", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MCE", ".", "setModuleInfo", "(", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "MBB", "->", "instr_begin", "(", ")", ",", "E", "=", "MBB", "->", "instr_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "bool", "AArch64LegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_VAARG", ":", "return", "legalizeVaArg", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "legalizeLoadStore", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AArch64", "AArch64", "\"expected switch to return\"" ]

[]

[ "<s>", "void", "AVRPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "void", "m68hc11_function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "mode", "!=", "BLKmode", ")", "{", "if", "(", "cum", "->", "words", "==", "0", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "4", ")", "{", "cum", "->", "nregs", "=", "2", ";", "cum", "->", "words", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "else", "{", "cum", "->", "words", "+=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "cum", "->", "words", "<=", "HARD_REG_SIZE", ")", "cum", "->", "nregs", "=", "1", ";", "}", "}", "else", "{", "cum", "->", "words", "+=", "int_size_in_bytes", "(", "type", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "m68hc11", "0", "4", "2", "1" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MI", ";", "while", "(", "++", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isDebugValue", "(", ")", ")", ";", "if", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isCall", "(", ")", "&&", "MI", ".", "definesRegister", "(", "ARM", "::", "SP", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::t2IT", "ARM::SP" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "X86CmovConverterPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableCmovConverter", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TSchedModel", ".", "init", "(", "STI", ".", "getSchedModel", "(", ")", ",", "&", "STI", ",", "TII", ")", ";", "if", "(", "ForceMemOperand", ")", "{", "CmovGroups", "AllCmovGroups", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "4", ">", "Blocks", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Blocks", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "collectCmovCandidates", "(", "Blocks", ",", "AllCmovGroups", ",", "true", ")", ")", "{", "for", "(", "auto", "&", "Group", ":", "AllCmovGroups", ")", "{", "if", "(", "!", "llvm", "::", "any_of", "(", "Group", ",", "[", "&", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "I", "->", "mayLoad", "(", ")", ";", "}", ")", ")", "continue", ";", "Changed", "=", "true", ";", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "}", "}", "SmallVector", "<", "MachineLoop", "*", ",", "4", ">", "Loops", "(", "MLI", ".", "begin", "(", ")", ",", "MLI", ".", "end", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "int", ")", "Loops", ".", "size", "(", ")", ";", "++", "i", ")", "for", "(", "MachineLoop", "*", "Child", ":", "Loops", "[", "i", "]", "->", "getSubLoops", "(", ")", ")", "Loops", ".", "push_back", "(", "Child", ")", ";", "for", "(", "MachineLoop", "*", "CurrLoop", ":", "Loops", ")", "{", "if", "(", "!", "CurrLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "continue", ";", "CmovGroups", "CmovInstGroups", ";", "if", "(", "!", "collectCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "if", "(", "!", "checkForProfitableCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "&", "Group", ":", "CmovInstGroups", ")", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"********** \"", "\" : \"", "\"**********\\n\"", "4", "4", "0" ]

[]

[ "<s>", "static", "bool", "nios2_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "0", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "0", ")", ";", "return", "true", ";", "}", "else", "if", "(", "nios2_simple_const_p", "(", "x", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "return", "true", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "return", "true", ";", "}", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_DOUBLE", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "return", "true", ";", "}", "case", "AND", ":", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "NOT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "NOT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "case", "MULT", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "}", "case", "SIGN_EXTEND", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "return", "false", ";", "}", "case", "ZERO_EXTEND", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "false", ";", "}", "case", "ZERO_EXTRACT", ":", "if", "(", "TARGET_HAS_BMX", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

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

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "LastOpcodeType", "=", "OTHER", ";", "LastInstWritesM0", "=", "false", ";", "ReturnsVoid", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "returnsVoid", "(", ")", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", "&&", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", "TII", "->", "insertWaitStates", "(", "std", "::", "next", "(", "I", ")", ",", "4", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BARRIER", ")", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "else", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "MBB", ",", "I", ")", ";", "handleSendMsg", "(", "MBB", ",", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "}", "return", "Changes", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU", "AMDGPU", "SI", "0", "0", "AMDGPU", "AMDGPU::V_READFIRSTLANE_B32", "4", "AMDGPU::S_BARRIER" ]

[]

[ "<s>", "int", "arc_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "TARGET_ARC600", ")", "return", "0", ";", "if", "(", "!", "pred", "||", "!", "INSN_P", "(", "pred", ")", "||", "!", "succ", "||", "!", "INSN_P", "(", "succ", ")", ")", "return", "0", ";", "if", "(", "recog_memoized", "(", "succ", ")", "==", "CODE_FOR_doloop_end_i", "&&", "(", "JUMP_P", "(", "pred", ")", "||", "CALL_P", "(", "pred", ")", "||", "GET_CODE", "(", "PATTERN", "(", "pred", ")", ")", "==", "SEQUENCE", ")", ")", "return", "4", ";", "return", "arc600_corereg_hazard", "(", "pred", ",", "succ", ")", ";", "}", "</s>" ]

[ "For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "." ]

[ "arc", "0", "0", "4" ]

[]

[ "<s>", "const", "MCExpr", "*", "PPCAIXAsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "CV", ")", ")", "{", "MCSymbolXCOFF", "*", "FSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "F", ")", ")", ";", "if", "(", "!", "FSym", "->", "hasContainingCsect", "(", ")", ")", "{", "const", "XCOFF", "::", "StorageClass", "SC", "=", "F", "->", "isDeclaration", "(", ")", "?", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "F", ")", ":", "XCOFF", "::", "C_HIDEXT", ";", "MCSectionXCOFF", "*", "Csect", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getXCOFFSection", "(", "FSym", "->", "getName", "(", ")", ",", "XCOFF", "::", "XMC_DS", ",", "F", "->", "isDeclaration", "(", ")", "?", "XCOFF", "::", "XTY_ER", ":", "XCOFF", "::", "XTY_SD", ",", "SC", ",", "SectionKind", "::", "getData", "(", ")", ")", ";", "FSym", "->", "setContainingCsect", "(", "Csect", ")", ";", "}", "return", "MCSymbolRefExpr", "::", "create", "(", "FSym", "->", "getContainingCsect", "(", ")", "->", "getQualNameSymbol", "(", ")", ",", "OutContext", ")", ";", "}", "return", "PPCAsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "LLVM", "Constant", "to", "an", "MCExpr", "." ]

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

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "!", "getMipsSubtarget", "(", ")", ".", "hasMips64", "(", ")", ")", "PM", "->", "add", "(", "createMipsEmitGPRestorePass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "uint16_t", "*", "TeeRISCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "TeeRISC", "::", "R6", ",", "TeeRISC", "::", "R7", ",", "TeeRISC", "::", "R8", ",", "TeeRISC", "::", "R9", ",", "TeeRISC", "::", "R10", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "TeeRISC::R6", "TeeRISC::R7", "TeeRISC::R8", "TeeRISC::R9", "TeeRISC::R10" ]

[]

[ "<s>", "static", "bool", "aarch64_vect_struct_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "OImode", "||", "mode", "==", "CImode", "||", "mode", "==", "XImode", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "MODE", "is", "any", "of", "the", "large", "INT", "modes", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "HexagonGenPredicate", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "PredGPRs", ".", "clear", "(", ")", ";", "PUsers", ".", "clear", "(", ")", ";", "G2P", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "collectPredicateGPR", "(", "MF", ")", ";", "for", "(", "SetOfReg", "::", "iterator", "I", "=", "PredGPRs", ".", "begin", "(", ")", ",", "E", "=", "PredGPRs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processPredicateGPR", "(", "*", "I", ")", ";", "bool", "Again", ";", "do", "{", "Again", "=", "false", ";", "VectOfInst", "Processed", ",", "Copy", ";", "using", "iterator", "=", "VectOfInst", "::", "iterator", ";", "Copy", "=", "PUsers", ";", "for", "(", "iterator", "I", "=", "Copy", ".", "begin", "(", ")", ",", "E", "=", "Copy", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "*", "I", ";", "bool", "Done", "=", "convertToPredForm", "(", "MI", ")", ";", "if", "(", "Done", ")", "{", "Processed", ".", "insert", "(", "MI", ")", ";", "Again", "=", "true", ";", "}", "}", "Changed", "|=", "Again", ";", "auto", "Done", "=", "[", "Processed", "]", "(", "MachineInstr", "*", "MI", ")", "->", "bool", "{", "return", "Processed", ".", "count", "(", "MI", ")", ";", "}", ";", "PUsers", ".", "remove_if", "(", "Done", ")", ";", "}", "while", "(", "Again", ")", ";", "Changed", "|=", "eliminatePredCopies", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "clear", "(", ")", "{", "std", "::", "fill", "(", "&", "Value", "[", "0", "]", ",", "&", "Value", "[", "TOTAL_KINDS", "]", ",", "0", ")", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

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

[]

[ "<s>", "bool", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Lanai" ]

[]

[ "<s>", "static", "bool", "tilegx_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "tilegx_cmodel", "!=", "CM_LARGE", "&&", "tilegx_cmodel", "!=", "CM_LARGE_PIC", "&&", "(", "decl", "!=", "NULL", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_OK_FOR_SIBCALL", "." ]

[ "tilegx" ]

[]

[ "<s>", "static", "const", "char", "*", "getName", "(", ")", "{", "return", "DEBUG_TYPE", ";", "}", "</s>" ]

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

[ "RI5CY" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "RISCVABI", "::", "isCheriPureCapABI", "(", "STI", ".", "getTargetABI", "(", ")", ")", ")", "RC", "=", "&", "RISCV", "::", "GPCRRegClass", ";", "else", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "int64_t", "RVVStackSize", "=", "assignRVVStackObjectOffsets", "(", "MFI", ")", ";", "RVFI", "->", "setRVVStackSize", "(", "RVVStackSize", ")", ";", "const", "RISCVInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", "||", "hasRVVSpillWithFIs", "(", "MF", ",", "TII", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "if", "(", "RVVStackSize", "!=", "0", ")", "{", "int", "RVVRegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RVVRegScavFI", ")", ";", "}", "}", "if", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "empty", "(", ")", "||", "RVFI", "->", "useSaveRestoreLibCalls", "(", "MF", ")", ")", "{", "RVFI", "->", "setCalleeSavedStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Size", "=", "0", ";", "for", "(", "const", "auto", "&", "Info", ":", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", "{", "int", "FrameIdx", "=", "Info", ".", "getFrameIdx", "(", ")", ";", "if", "(", "MFI", ".", "getStackID", "(", "FrameIdx", ")", "!=", "TargetStackID", "::", "Default", ")", "continue", ";", "Size", "+=", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ";", "}", "RVFI", "->", "setCalleeSavedStackSize", "(", "Size", ")", ";", "if", "(", "RVVStackSize", "&&", "!", "hasFP", "(", "MF", ")", "&&", "Size", "%", "8", "!=", "0", ")", "{", "RVFI", "->", "setRVVPadding", "(", "getStackAlign", "(", ")", ".", "value", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCVABI::isCheriPureCapABI", "RISCV::GPCRRegClass", "RISCV::GPRRegClass", "RISCV", "RISCV", "RISCV", "11", "0", "0", "0", "8", "0" ]

[]

[ "<s>", "bool", "aarch64_sve_vector_inc_dec_immediate_p", "(", "rtx", "x", ")", "{", "return", "aarch64_sve_vector_inc_dec_immediate_p", "(", "x", ",", "NULL", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "an", "SVE", "vector", "INC", "or", "DEC", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "virtual", "const", "MandarinSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Mandarin" ]

[]

[ "<s>", "static", "void", "avoid_func_arg_motion", "(", "rtx_insn", "*", "first_arg", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", ";", "rtx", "tmp", ";", "if", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_BNDSTX", ")", "{", "add_dependence", "(", "first_arg", ",", "insn", ",", "REG_DEP_ANTI", ")", ";", "return", ";", "}", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "return", ";", "tmp", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "REG_P", "(", "tmp", ")", ")", "{", "add_dependence", "(", "first_arg", ",", "insn", ",", "REG_DEP_OUTPUT", ")", ";", "return", ";", "}", "add_dependence", "(", "first_arg", ",", "insn", ",", "REG_DEP_ANTI", ")", ";", "}", "</s>" ]

[ "Add", "output", "or", "anti", "dependency", "from", "insn", "to", "first_arg", "to", "restrict", "its", "code", "motion", "." ]

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

[]

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

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

[ "SHUXI" ]

[]

[ "<s>", "StringRef", "ARM64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "\"\"", ";", "case", "VK_LO12", ":", "return", "\":lo12:\"", ";", "case", "VK_ABS_G3", ":", "return", "\":abs_g3:\"", ";", "case", "VK_ABS_G2", ":", "return", "\":abs_g2:\"", ";", "case", "VK_ABS_G2_S", ":", "return", "\":abs_g2_s:\"", ";", "case", "VK_ABS_G2_NC", ":", "return", "\":abs_g2_nc:\"", ";", "case", "VK_ABS_G1", ":", "return", "\":abs_g1:\"", ";", "case", "VK_ABS_G1_S", ":", "return", "\":abs_g1_s:\"", ";", "case", "VK_ABS_G1_NC", ":", "return", "\":abs_g1_nc:\"", ";", "case", "VK_ABS_G0", ":", "return", "\":abs_g0:\"", ";", "case", "VK_ABS_G0_S", ":", "return", "\":abs_g0_s:\"", ";", "case", "VK_ABS_G0_NC", ":", "return", "\":abs_g0_nc:\"", ";", "case", "VK_DTPREL_G2", ":", "return", "\":dtprel_g2:\"", ";", "case", "VK_DTPREL_G1", ":", "return", "\":dtprel_g1:\"", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "\":dtprel_g1_nc:\"", ";", "case", "VK_DTPREL_G0", ":", "return", "\":dtprel_g0:\"", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "\":dtprel_g0_nc:\"", ";", "case", "VK_DTPREL_HI12", ":", "return", "\":dtprel_hi12:\"", ";", "case", "VK_DTPREL_LO12", ":", "return", "\":dtprel_lo12:\"", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "\":dtprel_lo12_nc:\"", ";", "case", "VK_TPREL_G2", ":", "return", "\":tprel_g2:\"", ";", "case", "VK_TPREL_G1", ":", "return", "\":tprel_g1:\"", ";", "case", "VK_TPREL_G1_NC", ":", "return", "\":tprel_g1_nc:\"", ";", "case", "VK_TPREL_G0", ":", "return", "\":tprel_g0:\"", ";", "case", "VK_TPREL_G0_NC", ":", "return", "\":tprel_g0_nc:\"", ";", "case", "VK_TPREL_HI12", ":", "return", "\":tprel_hi12:\"", ";", "case", "VK_TPREL_LO12", ":", "return", "\":tprel_lo12:\"", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "\":tprel_lo12_nc:\"", ";", "case", "VK_TLSDESC_LO12", ":", "return", "\":tlsdesc_lo12:\"", ";", "case", "VK_ABS_PAGE", ":", "return", "\"\"", ";", "case", "VK_GOT_PAGE", ":", "return", "\":got:\"", ";", "case", "VK_GOT_LO12", ":", "return", "\":got_lo12:\"", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "\":gottprel_lo12:\"", ";", "case", "VK_GOTTPREL_G1", ":", "return", "\":gottprel_g1:\"", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "\":gottprel_g0_nc:\"", ";", "case", "VK_TLSDESC", ":", "return", "\"\"", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "\":tlsdesc:\"", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "ARM64", "ARM64", "\"\"", "\":lo12:\"", "\":abs_g3:\"", "\":abs_g2:\"", "\":abs_g2_s:\"", "\":abs_g2_nc:\"", "\":abs_g1:\"", "\":abs_g1_s:\"", "\":abs_g1_nc:\"", "\":abs_g0:\"", "\":abs_g0_s:\"", "\":abs_g0_nc:\"", "\":dtprel_g2:\"", "\":dtprel_g1:\"", "\":dtprel_g1_nc:\"", "\":dtprel_g0:\"", "\":dtprel_g0_nc:\"", "\":dtprel_hi12:\"", "\":dtprel_lo12:\"", "\":dtprel_lo12_nc:\"", "\":tprel_g2:\"", "\":tprel_g1:\"", "\":tprel_g1_nc:\"", "\":tprel_g0:\"", "\":tprel_g0_nc:\"", "\":tprel_hi12:\"", "\":tprel_lo12:\"", "\":tprel_lo12_nc:\"", "\":tlsdesc_lo12:\"", "\"\"", "\":got:\"", "\":got_lo12:\"", "\":gottprel:\"", "\":gottprel_lo12:\"", "\":gottprel_g1:\"", "\":gottprel_g0_nc:\"", "\"\"", "\":tlsdesc:\"", "\"Invalid ELF symbol kind\"" ]

[]

[ "<s>", "bool", "ARM64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** ARM64DeadRegisterDefinitions *****\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "if", "(", "processMachineBasicBlock", "(", "MBB", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "split_stack_arg_pointer_used_p", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "!=", "NULL_RTX", "&&", "(", "!", "REG_P", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "||", "(", "REGNO", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ")", ")", "return", "true", ";", "rtx_insn", "*", "insn", ";", "basic_block", "bb", "=", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "next_bb", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "df_ref", "use", ";", "FOR_EACH_INSN_USE", "(", "use", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "use", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "12", ")", "return", "true", ";", "}", "df_ref", "def", ";", "FOR_EACH_INSN_DEF", "(", "def", ",", "insn", ")", "{", "rtx", "x", "=", "DF_REF_REG", "(", "def", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "12", ")", "return", "false", ";", "}", "}", "return", "bitmap_bit_p", "(", "DF_LR_OUT", "(", "bb", ")", ",", "12", ")", ";", "}", "</s>" ]

[ "Return", "whether", "the", "split-stack", "arg", "pointer", "(", "r12", ")", "is", "used", "." ]

[ "rs6000", "12", "12", "12" ]

[]

[ "<s>", "const", "char", "*", "WebAssemblyTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "static_cast", "<", "WebAssemblyISD", "::", "NodeType", ">", "(", "Opcode", ")", ")", "{", "case", "WebAssemblyISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "WebAssemblyISD", "::", "NODE", ":", "\\", "return", "\"WebAssemblyISD::\"", "#", "NODE", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssemblyISD::NodeType", "WebAssemblyISD::FIRST_NUMBER", "WebAssemblyISD::NODE", "\"WebAssemblyISD::\"" ]

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "LWI", ")", ",", "MBlaze", "::", "R19", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "}", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "LWI", ")", ",", "MBlaze", "::", "R15", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "}", "int", "StackSize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "<", "28", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "StackSize", "=", "28", ";", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze::ADD", "MBlaze::R1", "MBlaze::R19", "MBlaze::R0", "MBlaze::LWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::LWI", "MBlaze::R15", "MBlaze::R1", "28", "28", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", "return", "isLegalGlobalAddressingMode", "(", "AM", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "{", "if", "(", "AM", ".", "BaseOffs", "%", "4", "!=", "0", ")", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "if", "(", "Ty", "->", "isSized", "(", ")", "&&", "DL", ".", "getTypeStoreSize", "(", "Ty", ")", "<", "4", ")", "return", "isLegalGlobalAddressingMode", "(", "AM", ")", ";", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "32", ">", "(", "AM", ".", "BaseOffs", "/", "4", ")", ")", "return", "false", ";", "}", "else", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "if", "(", "!", "isUInt", "<", "20", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "}", "else", "llvm_unreachable", "(", "\"unhandled generation\"", ")", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "{", "return", "isLegalMUBUFAddressingMode", "(", "AM", ")", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "4", "0", "4", "AMDGPU", "8", "4", "AMDGPU", "32", "4", "AMDGPU", "20", "\"unhandled generation\"", "0", "1", "AMDGPU", "AMDGPU", "AMDGPU", "16", "0", "1", "AMDGPU", "AMDGPU", "\"unhandled address space\"" ]

[]

[ "<s>", "static", "void", "mips_sim_next_cycle", "(", "struct", "mips_sim", "*", "state", ")", "{", "state", "->", "time", "++", ";", "state", "->", "insns_left", "=", "state", "->", "issue_rate", ";", "state_transition", "(", "state", "->", "dfa_state", ",", "0", ")", ";", "}", "</s>" ]

[ "Advance", "STATE", "by", "one", "clock", "cycle", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "x86_extended_reg_mentioned_p", "(", "rtx", "insn", ")", "{", "return", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "extended_reg_mentioned_1", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "INSN", "mentions", "register", "that", "must", "be", "encoded", "using", "REX", "prefix", "." ]

[ "i386" ]

[]

[ "<s>", "static", "machine_mode", "hfa_element_mode", "(", "const_tree", "type", ",", "bool", "nested", ")", "{", "machine_mode", "element_mode", "=", "VOIDmode", ";", "machine_mode", "mode", ";", "enum", "tree_code", "code", "=", "TREE_CODE", "(", "type", ")", ";", "int", "know_element_mode", "=", "0", ";", "tree", "t", ";", "if", "(", "!", "nested", "&&", "(", "!", "TYPE_SIZE", "(", "type", ")", "||", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", ")", "return", "VOIDmode", ";", "switch", "(", "code", ")", "{", "case", "VOID_TYPE", ":", "case", "INTEGER_TYPE", ":", "case", "ENUMERAL_TYPE", ":", "case", "BOOLEAN_TYPE", ":", "case", "POINTER_TYPE", ":", "case", "OFFSET_TYPE", ":", "case", "REFERENCE_TYPE", ":", "case", "METHOD_TYPE", ":", "case", "LANG_TYPE", ":", "case", "FUNCTION_TYPE", ":", "return", "VOIDmode", ";", "case", "COMPLEX_TYPE", ":", "if", "(", "GET_MODE_CLASS", "(", "TYPE_MODE", "(", "type", ")", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "TYPE_MODE", "(", "type", ")", "!=", "TCmode", ")", "return", "GET_MODE_INNER", "(", "TYPE_MODE", "(", "type", ")", ")", ";", "else", "return", "VOIDmode", ";", "case", "REAL_TYPE", ":", "if", "(", "nested", "&&", "TYPE_MODE", "(", "type", ")", "!=", "TFmode", ")", "return", "TYPE_MODE", "(", "type", ")", ";", "else", "return", "VOIDmode", ";", "case", "ARRAY_TYPE", ":", "return", "hfa_element_mode", "(", "TREE_TYPE", "(", "type", ")", ",", "1", ")", ";", "case", "RECORD_TYPE", ":", "case", "UNION_TYPE", ":", "case", "QUAL_UNION_TYPE", ":", "for", "(", "t", "=", "TYPE_FIELDS", "(", "type", ")", ";", "t", ";", "t", "=", "DECL_CHAIN", "(", "t", ")", ")", "{", "if", "(", "TREE_CODE", "(", "t", ")", "!=", "FIELD_DECL", ")", "continue", ";", "mode", "=", "hfa_element_mode", "(", "TREE_TYPE", "(", "t", ")", ",", "1", ")", ";", "if", "(", "know_element_mode", ")", "{", "if", "(", "mode", "!=", "element_mode", ")", "return", "VOIDmode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", ")", "return", "VOIDmode", ";", "else", "{", "know_element_mode", "=", "1", ";", "element_mode", "=", "mode", ";", "}", "}", "return", "element_mode", ";", "default", ":", "return", "VOIDmode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "Check", "whether", "TYPE", "is", "a", "homogeneous", "floating", "point", "aggregate", ".", "If", "it", "is", ",", "return", "the", "mode", "of", "the", "floating", "point", "type", "that", "appears", "in", "all", "leafs", ".", "If", "it", "is", "not", ",", "return", "VOIDmode", ".", "An", "aggregate", "is", "a", "homogeneous", "floating", "point", "aggregate", "is", "if", "all", "fields/elements", "in", "it", "have", "the", "same", "floating", "point", "type", "(", "e.g", ",", "SFmode", ")", ".", "128-bit", "quad-precision", "floats", "are", "excluded", "." ]

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

[]

[ "<s>", "std", "::", "unique_ptr", "<", "CSEConfigBase", ">", "MipsPassConfig", "::", "getCSEConfig", "(", ")", "const", "{", "return", "getStandardCSEConfigForOpt", "(", "TM", "->", "getOptLevel", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "CSEConfig", "object", "to", "use", "for", "the", "current", "optimization", "level", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FPReg", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "bool", "isWin64", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "]", ".", "getRegClass", "(", ")", ";", "if", "(", "RegClass", "!=", "&", "X86", "::", "VR128RegClass", "&&", "!", "isWin64", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ";", "}", "else", "{", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RegClass", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86::POP64r", "X86::POP32r", "0", "X86::VR128RegClass" ]

[]

[ "<s>", "static", "void", "emit_and_preserve", "(", "rtx", "seq", ",", "rtx", "reg", ",", "rtx", "reg2", ")", "{", "rtx", "slot", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "SPARC_STACK_BIAS", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_dec", "(", "GEN_INT", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "slot", ",", "reg", ")", ")", ";", "if", "(", "reg2", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "adjust_address", "(", "slot", ",", "word_mode", ",", "UNITS_PER_WORD", ")", ",", "reg2", ")", ")", ";", "emit_insn", "(", "seq", ")", ";", "if", "(", "reg2", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg2", ",", "adjust_address", "(", "slot", ",", "word_mode", ",", "UNITS_PER_WORD", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "slot", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "sequence", "of", "insns", "SEQ", "while", "preserving", "the", "registers", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "void", "epiphany_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "int", "this_regno", "=", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", "?", "1", ":", "0", ";", "const", "char", "*", "this_name", "=", "reg_names", "[", "this_regno", "]", ";", "const", "char", "*", "fname", ";", "gcc_assert", "(", "call_used_regs", "[", "GPR_IP", "]", ")", ";", "gcc_assert", "(", "call_used_regs", "[", "GPR_16", "]", ")", ";", "if", "(", "delta", "==", "0", ")", ";", "else", "if", "(", "SIMM11", "(", "delta", ")", ")", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s,%s,%d\\n\"", ",", "this_name", ",", "this_name", ",", "(", "int", ")", "delta", ")", ";", "else", "if", "(", "delta", "<", "0", "&&", "delta", ">=", "-", "0xffff", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tmov\\tip,%d\\n\"", ",", "(", "int", ")", "-", "delta", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tsub\\t%s,%s,ip\\n\"", ",", "this_name", ",", "this_name", ")", ";", "}", "else", "{", "asm_fprintf", "(", "file", ",", "\"\\tmov\\tip,%%low(%ld)\\n\"", ",", "(", "long", ")", "delta", ")", ";", "if", "(", "delta", "&", "~", "0xffff", ")", "asm_fprintf", "(", "file", ",", "\"\\tmovt\\tip,%%high(%ld)\\n\"", ",", "(", "long", ")", "delta", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s,%s,ip\\n\"", ",", "this_name", ",", "this_name", ")", ";", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tldr\\tip, [%s]\\n\"", ",", "this_name", ")", ";", "if", "(", "vcall_offset", "<", "-", "0x7ff", "*", "4", "||", "vcall_offset", ">", "0x7ff", "*", "4", "||", "(", "vcall_offset", "&", "3", ")", "!=", "0", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tmov\\tr16, %%low(%ld)\\n\"", ",", "(", "long", ")", "vcall_offset", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tmovt\\tr16, %%high(%ld)\\n\"", ",", "(", "long", ")", "vcall_offset", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tldr\\tip, [ip,r16]\\n\"", ")", ";", "}", "else", "asm_fprintf", "(", "file", ",", "\"\\tldr\\tip, [ip,%d]\\n\"", ",", "(", "int", ")", "vcall_offset", "/", "4", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tadd\\t%s, %s, ip\\n\"", ",", "this_name", ",", "this_name", ")", ";", "}", "fname", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ",", "0", ")", ";", "if", "(", "epiphany_is_long_call_p", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ")", ")", "{", "fputs", "(", "\"\\tmov\\tip,%low(\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fname", ")", ";", "fputs", "(", "\")\\n\\tmovt\\tip,%high(\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fname", ")", ";", "fputs", "(", "\")\\n\\tjr ip\\n\"", ",", "file", ")", ";", "}", "else", "{", "fputs", "(", "\"\\tb\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fname", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "epiphany", "1", "0", "0", "\"\\tadd\\t%s,%s,%d\\n\"", "0", "0xffff", "\"\\tmov\\tip,%d\\n\"", "\"\\tsub\\t%s,%s,ip\\n\"", "\"\\tmov\\tip,%%low(%ld)\\n\"", "0xffff", "\"\\tmovt\\tip,%%high(%ld)\\n\"", "\"\\tadd\\t%s,%s,ip\\n\"", "0", "\"\\tldr\\tip, [%s]\\n\"", "0x7ff", "4", "0x7ff", "4", "3", "0", "\"\\tmov\\tr16, %%low(%ld)\\n\"", "\"\\tmovt\\tr16, %%high(%ld)\\n\"", "\"\\tldr\\tip, [ip,r16]\\n\"", "\"\\tldr\\tip, [ip,%d]\\n\"", "4", "\"\\tadd\\t%s, %s, ip\\n\"", "0", "0", "0", "\"\\tmov\\tip,%low(\"", "\")\\n\\tmovt\\tip,%high(\"", "\")\\n\\tjr ip\\n\"", "\"\\tb\\t\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLoadBitCastBeneficial", "(", "EVT", "LoadVT", ",", "EVT", "BitcastVT", ",", "const", "SelectionDAG", "&", "DAG", ",", "const", "MachineMemOperand", "&", "MMO", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "LoadVT", ".", "isVector", "(", ")", "&&", "BitcastVT", ".", "isVector", "(", ")", "&&", "BitcastVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "false", ";", "if", "(", "!", "Subtarget", ".", "hasDQI", "(", ")", "&&", "BitcastVT", "==", "MVT", "::", "v8i1", "&&", "LoadVT", "==", "MVT", "::", "i8", ")", "return", "false", ";", "if", "(", "LoadVT", ".", "isVector", "(", ")", "&&", "BitcastVT", ".", "isVector", "(", ")", "&&", "isTypeLegal", "(", "LoadVT", ")", "&&", "isTypeLegal", "(", "BitcastVT", ")", ")", "return", "true", ";", "return", "TargetLowering", "::", "isLoadBitCastBeneficial", "(", "LoadVT", ",", "BitcastVT", ",", "DAG", ",", "MMO", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "following", "transform", "is", "beneficial", ":", "fold", "(", "conv", "(", "load", "x", ")", ")", "-", ">", "(", "load", "(", "conv", "*", ")", "x", ")", "On", "architectures", "that", "do", "n't", "natively", "support", "some", "vector", "loads", "efficiently", ",", "casting", "the", "load", "to", "a", "smaller", "vector", "of", "larger", "types", "and", "loading", "is", "more", "efficient", ",", "however", ",", "this", "can", "be", "undone", "by", "optimizations", "in", "dag", "combiner", "." ]

[ "X86", "X86", "MVT::i1", "MVT::v8i1", "MVT::i8" ]

[]

[ "<s>", "void", "changeSection", "(", "MCSection", "*", "Section", ",", "const", "MCExpr", "*", "Subsection", ")", "override", "{", "LastMappingSymbols", "[", "getCurrentSection", "(", ")", ".", "first", "]", "=", "std", "::", "move", "(", "LastEMSInfo", ")", ";", "MCELFStreamer", "::", "changeSection", "(", "Section", ",", "Subsection", ")", ";", "auto", "LastMappingSymbol", "=", "LastMappingSymbols", ".", "find", "(", "Section", ")", ";", "if", "(", "LastMappingSymbol", "!=", "LastMappingSymbols", ".", "end", "(", ")", ")", "{", "LastEMSInfo", "=", "std", "::", "move", "(", "LastMappingSymbol", "->", "second", ")", ";", "return", ";", "}", "LastEMSInfo", ".", "reset", "(", "new", "ElfMappingSymbolInfo", "(", "SMLoc", "(", ")", ",", "nullptr", ",", "0", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "ARMTargetStreamer", "::", "addConstantPoolEntry", "(", "const", "MCExpr", "*", "Expr", ")", "{", "return", "ConstantPools", "->", "addEntry", "(", "Streamer", ",", "Expr", ",", "4", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "entry", "to", "the", "constant", "pool", "for", "the", "current", "section", "and", "return", "an", "MCExpr", "that", "can", "be", "used", "to", "refer", "to", "the", "constant", "pool", "location", "." ]

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

[]

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

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

[ "ARM64", "5" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "HasSIMD128", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "SYSTEMZ_POSTREWRITE_NAME", ";", "}", "</s>" ]

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

[ "SystemZ" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "SystemZMCAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "unsigned", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "\"BFD_RELOC_NONE\"", ",", "ELF", "::", "R_390_NONE", ")", ".", "Case", "(", "\"BFD_RELOC_8\"", ",", "ELF", "::", "R_390_8", ")", ".", "Case", "(", "\"BFD_RELOC_16\"", ",", "ELF", "::", "R_390_16", ")", ".", "Case", "(", "\"BFD_RELOC_32\"", ",", "ELF", "::", "R_390_32", ")", ".", "Case", "(", "\"BFD_RELOC_64\"", ",", "ELF", "::", "R_390_64", ")", ".", "Default", "(", "-", "1u", ")", ";", "if", "(", "Type", "!=", "-", "1u", ")", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "return", "None", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "SystemZ", "SystemZ", "\"BFD_RELOC_NONE\"", "\"BFD_RELOC_8\"", "\"BFD_RELOC_16\"", "\"BFD_RELOC_32\"", "\"BFD_RELOC_64\"", "1u", "1u" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "RISCV_CLEANUP_VSETVLI_NAME", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "int", "hppa_can_use_return_insn_p", "(", ")", "{", "return", "(", "reload_completed", "&&", "(", "compute_frame_size", "(", "get_frame_size", "(", ")", ",", "0", ")", "?", "0", ":", "1", ")", "&&", "!", "regs_ever_live", "[", "2", "]", "&&", "!", "frame_pointer_needed", ")", ";", "}", "</s>" ]

[ "This", "is", "only", "valid", "once", "reload", "has", "completed", "because", "it", "depends", "on", "knowing", "exactly", "how", "much", "(", "if", "any", ")", "frame", "there", "is", "and", "...", "It", "'s", "only", "valid", "if", "there", "is", "no", "frame", "marker", "to", "de-allocate", "and", "...", "It", "'s", "only", "valid", "if", "%", "r2", "has", "n't", "been", "saved", "into", "the", "caller", "'s", "frame", "(", "we", "'re", "not", "profiling", "and", "%", "r2", "is", "n't", "live", "anywhere", ")", "." ]

[ "pa", "0", "0", "1", "2" ]

[]