Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "rtx", "standard_80387_constant_rtx", "(", "int", "idx", ")", "{", "int", "i", ";", "if", "(", "!", "ext_80387_constants_init", ")", "init_ext_80387_constants", "(", ")", ";", "switch", "(", "idx", ")", "{", "case", "3", ":", "case", "4", ":", "case", "5", ":", "case", "6", ":", "case", "7", ":", "i", "=", "idx", "-", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "ext_80387_constants_table", "[", "i", "]", ",", "XFmode", ")", ";", "}", "</s>" ]

[ "Return", "the", "CONST_DOUBLE", "representing", "the", "80387", "constant", "that", "is", "loaded", "by", "the", "specified", "special", "instruction", ".", "The", "argument", "IDX", "matches", "the", "return", "value", "from", "standard_80387_constant_p", "." ]

[ "i386", "3", "4", "5", "6", "7", "3" ]

[]

[ "<s>", "static", "int", "thumb_far_jump_used_p", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "bool", "far_jump", "=", "false", ";", "unsigned", "int", "func_size", "=", "0", ";", "if", "(", "cfun", "->", "machine", "->", "far_jump_used", ")", "return", "1", ";", "if", "(", "!", "(", "ARM_DOUBLEWORD_ALIGN", "||", "reload_completed", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "ARG_POINTER_REGNUM", ")", ")", "cfun", "->", "machine", "->", "arg_pointer_live", "=", "1", ";", "else", "if", "(", "!", "cfun", "->", "machine", "->", "arg_pointer_live", ")", "return", "0", ";", "}", "if", "(", "reload_in_progress", "||", "reload_completed", ")", "return", "0", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "get_attr_far_jump", "(", "insn", ")", "==", "FAR_JUMP_YES", ")", "{", "far_jump", "=", "true", ";", "}", "func_size", "+=", "get_attr_length", "(", "insn", ")", ";", "}", "if", "(", "far_jump", ")", "{", "if", "(", "(", "func_size", "*", "3", ")", ">=", "2048", ")", "{", "cfun", "->", "machine", "->", "far_jump_used", "=", "1", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Returns", "non-zero", "if", "the", "current", "function", "contains", ",", "or", "might", "contain", "a", "far", "jump", "." ]

[ "arm", "0", "1", "1", "0", "0", "3", "2048", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "ARMMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "RegNo", ";", "case", "ARM", "::", "Q0", ":", "case", "ARM", "::", "Q1", ":", "case", "ARM", "::", "Q2", ":", "case", "ARM", "::", "Q3", ":", "case", "ARM", "::", "Q4", ":", "case", "ARM", "::", "Q5", ":", "case", "ARM", "::", "Q6", ":", "case", "ARM", "::", "Q7", ":", "case", "ARM", "::", "Q8", ":", "case", "ARM", "::", "Q9", ":", "case", "ARM", "::", "Q10", ":", "case", "ARM", "::", "Q11", ":", "case", "ARM", "::", "Q12", ":", "case", "ARM", "::", "Q13", ":", "case", "ARM", "::", "Q14", ":", "case", "ARM", "::", "Q15", ":", "return", "2", "*", "RegNo", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "ARM", "ARM", "ARM::Q0", "ARM::Q1", "ARM::Q2", "ARM::Q3", "ARM::Q4", "ARM::Q5", "ARM::Q6", "ARM::Q7", "ARM::Q8", "ARM::Q9", "ARM::Q10", "ARM::Q11", "ARM::Q12", "ARM::Q13", "ARM::Q14", "ARM::Q15", "2", "32", "\"Unable to encode MCOperand!\"" ]

[]

[ "<s>", "static", "void", "s390_emit_stack_probe", "(", "rtx", "addr", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "word_mode", ",", "addr", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "1", ";", "emit_insn", "(", "gen_probe_stack", "(", "mem", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "compare", "instruction", "with", "a", "volatile", "memory", "access", "as", "stack", "probe", ".", "It", "does", "not", "waste", "store", "tags", "and", "does", "not", "clobber", "any", "registers", "apart", "from", "the", "condition", "code", "." ]

[ "s390", "1" ]

[]

[ "<s>", "X86GenInstrInfo", "::", "MachineOutlinerInstrType", "X86InstrInfo", "::", "getOutliningType", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "isIndirectDebugValue", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Invisible", ";", "if", "(", "isTailCall", "(", "MI", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "MI", ".", "isReturn", "(", ")", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "succ_empty", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RSP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RSP", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "readsRegister", "(", "X86", "::", "RIP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RIP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RIP", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MOP", ".", "isCPI", "(", ")", "||", "MOP", ".", "isJTI", "(", ")", "||", "MOP", ".", "isCFIIndex", "(", ")", "||", "MOP", ".", "isFI", "(", ")", "||", "MOP", ".", "isTargetIndex", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "X86", "X86", "X86", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RIP", "X86::RIP", "X86::RIP" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "return", "true", ";", "case", "MVT", "::", "f128", ":", "return", "false", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "MVT::f32", "MVT::f64", "MVT::f128" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "isBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "return", "Decoder", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "isBranch", ",", "Offset", ",", "Width", ",", "0", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "SystemZ", "0" ]

[]

[ "<s>", "int", "nds32_can_use_bset_p", "(", "int", "ival", ")", "{", "int", "one_bit_count", ";", "one_bit_count", "=", "popcount_hwi", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "ival", ")", ")", ";", "return", "(", "TARGET_EXT_PERF", "&&", "(", "one_bit_count", "==", "1", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'bset", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "static", "int", "aarch64_compute_pressure_classes", "(", "reg_class", "*", "classes", ")", "{", "int", "i", "=", "0", ";", "classes", "[", "i", "++", "]", "=", "GENERAL_REGS", ";", "classes", "[", "i", "++", "]", "=", "FP_REGS", ";", "classes", "[", "i", "++", "]", "=", "PR_LO_REGS", ";", "classes", "[", "i", "++", "]", "=", "PR_HI_REGS", ";", "return", "i", ";", "}", "</s>" ]

[ "Implement", "TARGET_COMPUTE_PRESSURE_CLASSES", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "isUnspillableTerminatorImpl", "(", "const", "MachineInstr", "*", "MI", ")", "const", "override", "{", "return", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopEndDec", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2DoLoopStartTP", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2WhileLoopStartLR", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2WhileLoopStartTP", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "terminator", "MI", "is", "not", "expected", "to", "spill", "." ]

[ "ARM", "ARM::t2LoopEndDec", "ARM::t2DoLoopStartTP", "ARM::t2WhileLoopStartLR", "ARM::t2WhileLoopStartTP" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "MipsInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "return", "std", "::", "make_pair", "(", "TF", ",", "0u", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_set_current_function", "(", "tree", "fndecl", ")", "{", "tree", "old_tree", "=", "(", "rs6000_previous_fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "rs6000_previous_fndecl", ")", ":", "NULL_TREE", ")", ";", "tree", "new_tree", "=", "(", "fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ":", "NULL_TREE", ")", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "bool", "print_final", "=", "false", ";", "fprintf", "(", "stderr", ",", "\"\\n==================== rs6000_set_current_function\"", ")", ";", "if", "(", "fndecl", ")", "fprintf", "(", "stderr", ",", "\", fndecl %s (%p)\"", ",", "(", "DECL_NAME", "(", "fndecl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ":", "\"<unknown>\"", ")", ",", "(", "void", "*", ")", "fndecl", ")", ";", "if", "(", "rs6000_previous_fndecl", ")", "fprintf", "(", "stderr", ",", "\", prev_fndecl (%p)\"", ",", "(", "void", "*", ")", "rs6000_previous_fndecl", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "new_tree", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nnew fndecl target specific options:\\n\"", ")", ";", "debug_tree", "(", "new_tree", ")", ";", "print_final", "=", "true", ";", "}", "if", "(", "old_tree", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nold fndecl target specific options:\\n\"", ")", ";", "debug_tree", "(", "old_tree", ")", ";", "print_final", "=", "true", ";", "}", "if", "(", "print_final", ")", "fprintf", "(", "stderr", ",", "\"--------------------\\n\"", ")", ";", "}", "if", "(", "fndecl", "&&", "fndecl", "!=", "rs6000_previous_fndecl", ")", "{", "rs6000_previous_fndecl", "=", "fndecl", ";", "if", "(", "old_tree", "==", "new_tree", ")", ";", "else", "if", "(", "new_tree", "&&", "new_tree", "!=", "target_option_default_node", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "else", "if", "(", "old_tree", "&&", "old_tree", "!=", "target_option_default_node", ")", "{", "new_tree", "=", "target_option_current_node", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "powerpcspe", "\"\\n==================== rs6000_set_current_function\"", "\", fndecl %s (%p)\"", "\"<unknown>\"", "\", prev_fndecl (%p)\"", "\"\\n\"", "\"\\nnew fndecl target specific options:\\n\"", "\"\\nold fndecl target specific options:\\n\"", "\"--------------------\\n\"" ]

[]

[ "<s>", "void", "rs6000_emit_sCOND", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "condition_rtx", ";", "machine_mode", "op_mode", ";", "enum", "rtx_code", "cond_code", ";", "rtx", "result", "=", "operands", "[", "0", "]", ";", "condition_rtx", "=", "rs6000_generate_compare", "(", "operands", "[", "1", "]", ",", "mode", ")", ";", "cond_code", "=", "GET_CODE", "(", "condition_rtx", ")", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "!", "TARGET_FPRS", "&&", "TARGET_HARD_FLOAT", ")", "{", "rtx", "t", ";", "PUT_MODE", "(", "condition_rtx", ",", "SImode", ")", ";", "t", "=", "XEXP", "(", "condition_rtx", ",", "0", ")", ";", "gcc_assert", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "EQ", ")", ";", "if", "(", "cond_code", "==", "NE", ")", "emit_insn", "(", "gen_e500_flip_gt_bit", "(", "t", ",", "t", ")", ")", ";", "emit_insn", "(", "gen_move_from_CR_gt_bit", "(", "result", ",", "t", ")", ")", ";", "return", ";", "}", "if", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "GE", "||", "cond_code", "==", "LE", "||", "cond_code", "==", "GEU", "||", "cond_code", "==", "LEU", "||", "cond_code", "==", "ORDERED", "||", "cond_code", "==", "UNGE", "||", "cond_code", "==", "UNLE", ")", "{", "rtx", "not_result", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "rtx", "not_op", ",", "rev_cond_rtx", ";", "machine_mode", "cc_mode", ";", "cc_mode", "=", "GET_MODE", "(", "XEXP", "(", "condition_rtx", ",", "0", ")", ")", ";", "rev_cond_rtx", "=", "gen_rtx_fmt_ee", "(", "rs6000_reverse_condition", "(", "cc_mode", ",", "cond_code", ")", ",", "SImode", ",", "XEXP", "(", "condition_rtx", ",", "0", ")", ",", "const0_rtx", ")", ";", "not_op", "=", "gen_rtx_COMPARE", "(", "CCEQmode", ",", "rev_cond_rtx", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "not_result", ",", "not_op", ")", ")", ";", "condition_rtx", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "not_result", ",", "const0_rtx", ")", ";", "}", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "if", "(", "op_mode", "==", "VOIDmode", ")", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "op_mode", "==", "DImode", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "{", "PUT_MODE", "(", "condition_rtx", ",", "DImode", ")", ";", "convert_move", "(", "result", ",", "condition_rtx", ",", "0", ")", ";", "}", "else", "{", "PUT_MODE", "(", "condition_rtx", ",", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "result", ",", "condition_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "RTL", "for", "an", "sCOND", "pattern", "." ]

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

[]

[ "<s>", "enum", "reg_class", "arm_regno_class", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "PC_REGNUM", ")", "return", "NO_REGS", ";", "if", "(", "IS_VPR_REGNUM", "(", "regno", ")", ")", "return", "VPR_REG", ";", "if", "(", "TARGET_THUMB1", ")", "{", "if", "(", "regno", "==", "STACK_POINTER_REGNUM", ")", "return", "STACK_REG", ";", "if", "(", "regno", "==", "CC_REGNUM", ")", "return", "CC_REG", ";", "if", "(", "regno", "<", "8", ")", "return", "LO_REGS", ";", "return", "HI_REGS", ";", "}", "if", "(", "TARGET_THUMB2", "&&", "regno", "<", "8", ")", "return", "LO_REGS", ";", "if", "(", "regno", "<=", "LAST_ARM_REGNUM", "||", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "TARGET_THUMB2", "?", "HI_REGS", ":", "GENERAL_REGS", ";", "if", "(", "regno", "==", "CC_REGNUM", "||", "regno", "==", "VFPCC_REGNUM", ")", "return", "TARGET_THUMB2", "?", "CC_REG", ":", "NO_REGS", ";", "if", "(", "IS_VFP_REGNUM", "(", "regno", ")", ")", "{", "if", "(", "regno", "<=", "D7_VFP_REGNUM", ")", "return", "VFP_D0_D7_REGS", ";", "else", "if", "(", "regno", "<=", "LAST_LO_VFP_REGNUM", ")", "return", "VFP_LO_REGS", ";", "else", "return", "VFP_HI_REGS", ";", "}", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "IWMMXT_REGS", ";", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "IWMMXT_GR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "For", "efficiency", "and", "historical", "reasons", "LO_REGS", ",", "HI_REGS", "and", "CC_REGS", "are", "not", "used", "in", "arm", "mode", "." ]

[ "arm", "8", "8" ]

[]

[ "<s>", "void", "MipsELFStreamer", "::", "createPendingLabelRelocs", "(", ")", "{", "MipsTargetELFStreamer", "*", "ELFTargetStreamer", "=", "static_cast", "<", "MipsTargetELFStreamer", "*", ">", "(", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "ELFTargetStreamer", "->", "isMicroMipsEnabled", "(", ")", ")", "{", "for", "(", "auto", "Label", ":", "Labels", ")", "{", "MCSymbolData", "&", "Data", "=", "getOrCreateSymbolData", "(", "Label", ")", ";", "MCELF", "::", "setOther", "(", "Data", ",", "ELF", "::", "STO_MIPS_MICROMIPS", ">>", "2", ")", ";", "}", "}", "Labels", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Mark", "labels", "as", "microMIPS", ",", "if", "necessary", "for", "the", "subtarget", "." ]

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

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Subtarget", ".", "isLittleEndian", "(", ")", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "AArch64GISelActualAccessor", "*", "GISel", "=", "new", "AArch64GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "AArch64MachineLegalizer", "(", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "new", "AArch64InstructionSelector", "(", "*", "I", ",", "*", "RBI", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "if", "(", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "BPF", "\"Expr shouldn't be null!\"" ]

[]

[ "<s>", "unsigned", "AMDGPUSubtarget", "::", "getOccupancyWithLocalMemSize", "(", "uint32_t", "Bytes", ",", "const", "Function", "&", "F", ")", "const", "{", "const", "unsigned", "MaxWorkGroupSize", "=", "getFlatWorkGroupSizes", "(", "F", ")", ".", "second", ";", "const", "unsigned", "MaxWorkGroupsPerCu", "=", "getMaxWorkGroupsPerCU", "(", "MaxWorkGroupSize", ")", ";", "if", "(", "!", "MaxWorkGroupsPerCu", ")", "return", "0", ";", "const", "unsigned", "WaveSize", "=", "getWavefrontSize", "(", ")", ";", "unsigned", "NumGroups", "=", "getLocalMemorySize", "(", ")", "/", "(", "Bytes", "?", "Bytes", ":", "1u", ")", ";", "if", "(", "NumGroups", "==", "0", ")", "return", "1", ";", "NumGroups", "=", "std", "::", "min", "(", "MaxWorkGroupsPerCu", ",", "NumGroups", ")", ";", "const", "unsigned", "MaxGroupNumWaves", "=", "(", "MaxWorkGroupSize", "+", "WaveSize", "-", "1", ")", "/", "WaveSize", ";", "unsigned", "MaxWaves", "=", "NumGroups", "*", "MaxGroupNumWaves", ";", "MaxWaves", "=", "std", "::", "min", "(", "MaxWaves", ",", "getMaxWavesPerEU", "(", ")", ")", ";", "assert", "(", "MaxWaves", ">", "0", "&&", "MaxWaves", "<=", "getMaxWavesPerEU", "(", ")", "&&", "\"computed invalid occupancy\"", ")", ";", "return", "MaxWaves", ";", "}", "</s>" ]

[ "Inverse", "of", "getMaxLocalMemWithWaveCount", "." ]

[ "AMDGPU", "AMDGPU", "0", "1u", "0", "1", "1", "0", "\"computed invalid occupancy\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "createVR", "(", "MachineFunction", "*", "MF", ",", "MVT", "VT", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", ";", "if", "(", "VT", "==", "MVT", "::", "i1", ")", "{", "TRC", "=", "&", "Hexagon", "::", "PredRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "{", "TRC", "=", "&", "Hexagon", "::", "IntRegsRegClass", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "f64", ")", "{", "TRC", "=", "&", "Hexagon", "::", "DoubleRegsRegClass", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this register class\"", ")", ";", "}", "unsigned", "NewReg", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "return", "NewReg", ";", "}", "</s>" ]

[ "HexagonInstrInfo", "specifics", "." ]

[ "Hexagon", "Hexagon", "MVT::i1", "Hexagon::PredRegsRegClass", "MVT::i32", "MVT::f32", "Hexagon::IntRegsRegClass", "MVT::i64", "MVT::f64", "Hexagon::DoubleRegsRegClass", "\"Cannot handle this register class\"" ]

[]

[ "<s>", "bool", "MandarinAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "isLandingPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "PI", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "I", "==", "Pred", "->", "end", "(", ")", "||", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Mandarin" ]

[]

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

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

[ "MSP430" ]

[]

[ "<s>", "int", "calc_live_regs", "(", "int", "*", "count", ")", "{", "int", "reg", ";", "int", "live_regs_mask", "=", "0", ";", "*", "count", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "FIRST_PSEUDO_REGISTER", ";", "reg", "++", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", "{", "(", "*", "count", ")", "++", ";", "live_regs_mask", "|=", "(", "1", "<<", "reg", ")", ";", "if", "(", "reg", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", "&&", "TARGET_BIG", ")", "{", "(", "*", "count", ")", "++", ";", "reg", "++", ";", "live_regs_mask", "|=", "(", "1", "<<", "reg", ")", ";", "}", "}", "}", "return", "live_regs_mask", ";", "}", "</s>" ]

[ "Work", "out", "the", "registers", "which", "need", "to", "be", "saved", ",", "both", "as", "a", "mask", "and", "a", "count" ]

[ "z8k", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "EVT", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "override", "{", "return", "Op", ".", "size", "(", ")", ">=", "8", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "BPF", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "EVT", "VETargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "VE", "VE", "MVT::i32" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "bool", "HaveSData", "=", "isSmallDataEnabled", "(", "TM", ")", ";", "if", "(", "!", "HaveSData", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Small-data allocation is disabled, but symbols \"", "\"may have explicit section assignments...\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Checking if value is in small-data, -G\"", "<<", "SmallDataThreshold", "<<", "\": \\\"\"", "<<", "GO", "->", "getName", "(", ")", "<<", "\"\\\": \"", ")", ";", "const", "GlobalVariable", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GO", ")", ";", "if", "(", "!", "GVar", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, not a global variable\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "GVar", "->", "hasSection", "(", ")", ")", "{", "bool", "IsSmall", "=", "isSmallDataSection", "(", "GVar", "->", "getSection", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "(", "IsSmall", "?", "\"yes\"", ":", "\"no\"", ")", "<<", "\", has section: \"", "<<", "GVar", "->", "getSection", "(", ")", "<<", "'\\n'", ")", ";", "return", "IsSmall", ";", "}", "if", "(", "!", "HaveSData", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, small-data allocation is disabled\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "GVar", "->", "isConstant", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is a constant\\n\"", ")", ";", "return", "false", ";", "}", "bool", "IsLocal", "=", "GVar", "->", "hasLocalLinkage", "(", ")", ";", "if", "(", "!", "StaticsInSData", "&&", "IsLocal", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is static\\n\"", ")", ";", "return", "false", ";", "}", "Type", "*", "GType", "=", "GVar", "->", "getValueType", "(", ")", ";", "if", "(", "isa", "<", "ArrayType", ">", "(", "GType", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is an array\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "StructType", "*", "ST", "=", "dyn_cast", "<", "StructType", ">", "(", "GType", ")", ")", "{", "if", "(", "ST", "->", "isOpaque", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has opaque type\\n\"", ")", ";", "return", "false", ";", "}", "}", "unsigned", "Size", "=", "GVar", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GType", ")", ";", "if", "(", "Size", "==", "0", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has size 0\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "Size", ">", "SmallDataThreshold", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, size exceeds sdata threshold: \"", "<<", "Size", "<<", "'\\n'", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"yes\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Hexagon", "Hexagon", "\"Small-data allocation is disabled, but symbols \"", "\"may have explicit section assignments...\\n\"", "\"Checking if value is in small-data, -G\"", "\": \\\"\"", "\"\\\": \"", "\"no, not a global variable\\n\"", "\"yes\"", "\"no\"", "\", has section: \"", "\"no, small-data allocation is disabled\\n\"", "\"no, is a constant\\n\"", "\"no, is static\\n\"", "\"no, is an array\\n\"", "\"no, has opaque type\\n\"", "0", "\"no, has size 0\\n\"", "\"no, size exceeds sdata threshold: \"", "\"yes\\n\"" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_save_reg_mask", "(", ")", "{", "unsigned", "int", "save_reg_mask", "=", "0", ";", "unsigned", "long", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "frame_pointer_needed", ")", "save_reg_mask", "|=", "(", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ")", "|", "(", "1", "<<", "IP_REGNUM", ")", "|", "(", "1", "<<", "LR_REGNUM", ")", "|", "(", "1", "<<", "PC_REGNUM", ")", ";", "if", "(", "IS_VOLATILE", "(", "func_type", ")", ")", "return", "save_reg_mask", ";", "save_reg_mask", "|=", "arm_compute_save_reg0_reg12_mask", "(", ")", ";", "if", "(", "regs_ever_live", "[", "LR_REGNUM", "]", "||", "(", "save_reg_mask", "&&", "optimize_size", "&&", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_NORMAL", ")", ")", "save_reg_mask", "|=", "1", "<<", "LR_REGNUM", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "save_reg_mask", "&=", "~", "(", "1", "<<", "LR_REGNUM", ")", ";", "return", "save_reg_mask", ";", "}", "</s>" ]

[ "Compute", "a", "bit", "mask", "of", "which", "registers", "need", "to", "be", "saved", "on", "the", "stack", "for", "the", "current", "function", ".", "This", "is", "used", "by", "arm_get_frame_offsets", ",", "which", "may", "add", "extra", "registers", "." ]

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

[]

[ "<s>", "static", "void", "c6x_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", "mode", ",", "rtx", "addr", ")", "{", "c6x_print_address_operand", "(", "file", ",", "addr", ",", "mode", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "language", "output", "for", "the", "address", "ADDR", "to", "FILE", "." ]

[ "c6x" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateUniformValues", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSILowerControlFlowPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "rs6000_output_function_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "!", "cfun", "->", "is_thunk", ")", "rs6000_output_savres_externs", "(", "file", ")", ";", "if", "(", "rs6000_global_entry_point_needed_p", "(", ")", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "file", ",", "\"LCF\"", ",", "rs6000_pic_labelno", ")", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_LARGE", ")", "{", "char", "buf", "[", "256", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCF\"", ",", "rs6000_pic_labelno", ")", ";", "fprintf", "(", "file", ",", "\"0:\\taddis 2,12,.TOC.-\"", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"@ha\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\taddi 2,2,.TOC.-\"", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"@l\\n\"", ")", ";", "}", "else", "{", "char", "buf", "[", "256", "]", ";", "fprintf", "(", "file", ",", "\"\\t.reloc .,R_PPC64_ENTRY\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tld 2,\"", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCL\"", ",", "rs6000_pic_labelno", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCF\"", ",", "rs6000_pic_labelno", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "fprintf", "(", "file", ",", "\"(12)\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\tadd 2,2,12\\n\"", ")", ";", "}", "fputs", "(", "\"\\t.localentry\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fputs", "(", "\",.-\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "}", "if", "(", "TARGET_PROFILE_KERNEL", "&&", "crtl", "->", "profile", ")", "{", "gcc_assert", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", ";", "gcc_assert", "(", "!", "TARGET_32BIT", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tmflr %s\\n\"", ",", "reg_names", "[", "0", "]", ")", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_ELFv2", "&&", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "{", "asm_fprintf", "(", "file", ",", "\"\\tstd %s,24(%s)\\n\"", ",", "reg_names", "[", "STATIC_CHAIN_REGNUM", "]", ",", "reg_names", "[", "1", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\tbl %s\\n\"", ",", "RS6000_MCOUNT", ")", ";", "asm_fprintf", "(", "file", ",", "\"\\tld %s,24(%s)\\n\"", ",", "reg_names", "[", "STATIC_CHAIN_REGNUM", "]", ",", "reg_names", "[", "1", "]", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"\\tbl %s\\n\"", ",", "RS6000_MCOUNT", ")", ";", "}", "rs6000_pic_labelno", "++", ";", "}", "</s>" ]

[ "Write", "function", "prologue", "." ]

[ "rs6000", "0", "0", "\"LCF\"", "256", "\"LCF\"", "\"0:\\taddis 2,12,.TOC.-\"", "\"@ha\\n\"", "\"\\taddi 2,2,.TOC.-\"", "\"@l\\n\"", "256", "\"\\t.reloc .,R_PPC64_ENTRY\\n\"", "\"\\tld 2,\"", "\"LCL\"", "\"-\"", "\"LCF\"", "\"(12)\\n\"", "\"\\tadd 2,2,12\\n\"", "\"\\t.localentry\\t\"", "\",.-\"", "\"\\n\"", "\"\\tmflr %s\\n\"", "0", "\"\\tstd %s,24(%s)\\n\"", "1", "\"\\tbl %s\\n\"", "\"\\tld %s,24(%s)\\n\"", "1", "\"\\tbl %s\\n\"" ]

[]

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

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

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

[]

[ "<s>", "void", "thumb_expand_movmemqi", "(", "rtx", "*", "operands", ")", "{", "rtx", "out", "=", "copy_to_mode_reg", "(", "SImode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "in", "=", "copy_to_mode_reg", "(", "SImode", ",", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "HOST_WIDE_INT", "len", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "while", "(", "len", ">=", "12", ")", "{", "emit_insn", "(", "gen_movmem12b", "(", "out", ",", "in", ",", "out", ",", "in", ")", ")", ";", "len", "-=", "12", ";", "}", "if", "(", "len", ">=", "8", ")", "{", "emit_insn", "(", "gen_movmem8b", "(", "out", ",", "in", ",", "out", ",", "in", ")", ")", ";", "len", "-=", "8", ";", "}", "if", "(", "len", ">=", "4", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "gen_rtx_MEM", "(", "SImode", ",", "in", ")", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "gen_rtx_MEM", "(", "SImode", ",", "out", ")", ",", "reg", ")", ")", ";", "len", "-=", "4", ";", "offset", "+=", "4", ";", "}", "if", "(", "len", ">=", "2", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_movhi", "(", "reg", ",", "gen_rtx_MEM", "(", "HImode", ",", "plus_constant", "(", "Pmode", ",", "in", ",", "offset", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_movhi", "(", "gen_rtx_MEM", "(", "HImode", ",", "plus_constant", "(", "Pmode", ",", "out", ",", "offset", ")", ")", ",", "reg", ")", ")", ";", "len", "-=", "2", ";", "offset", "+=", "2", ";", "}", "if", "(", "len", ")", "{", "rtx", "reg", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "emit_insn", "(", "gen_movqi", "(", "reg", ",", "gen_rtx_MEM", "(", "QImode", ",", "plus_constant", "(", "Pmode", ",", "in", ",", "offset", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_movqi", "(", "gen_rtx_MEM", "(", "QImode", ",", "plus_constant", "(", "Pmode", ",", "out", ",", "offset", ")", ")", ",", "reg", ")", ")", ";", "}", "}", "</s>" ]

[ "Routines", "for", "generating", "rtl", "." ]

[ "arm", "0", "0", "1", "0", "2", "0", "12", "12", "8", "8", "4", "4", "4", "2", "2", "2" ]

[]

[ "<s>", "MVT", "SITargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "!=", "CallingConv", "::", "AMDGPU_KERNEL", "&&", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "==", "3", ")", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "ScalarVT", ".", "getSizeInBits", "(", ")", "==", "32", ")", "return", "ScalarVT", ".", "getSimpleVT", "(", ")", ";", "}", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "AMDGPU", "SI", "AMDGPU", "3", "32" ]

[]

[ "<s>", "const", "char", "*", "csky_output_casesi", "(", "rtx", "*", "operands", ")", "{", "rtx", "diff_vec", "=", "PATTERN", "(", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "operands", "[", "0", "]", ")", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "diff_vec", ")", "==", "ADDR_DIFF_VEC", ")", ";", "switch", "(", "GET_MODE", "(", "diff_vec", ")", ")", "{", "case", "E_QImode", ":", "return", "(", "ADDR_DIFF_VEC_FLAGS", "(", "diff_vec", ")", ".", "offset_unsigned", "?", "\"jbsr\\t___gnu_csky_case_uqi\"", ":", "\"jbsr\\t___gnu_csky_case_sqi\"", ")", ";", "case", "E_HImode", ":", "return", "(", "ADDR_DIFF_VEC_FLAGS", "(", "diff_vec", ")", ".", "offset_unsigned", "?", "\"jbsr\\t___gnu_csky_case_uhi\"", ":", "\"jbsr\\t___gnu_csky_case_shi\"", ")", ";", "case", "E_SImode", ":", "return", "\"jbsr\\t___gnu_csky_case_si\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "assembly", "code", "for", "CASESI", ".", "This", "is", "only", "used", "on", "CK801", "and", "CK802", "when", "optimizing", "for", "size", ",", "and", "uses", "helper", "functions", "in", "libgcc", "instead", "of", "doing", "the", "control", "transfer", "inline", "." ]

[ "csky", "0", "\"jbsr\\t___gnu_csky_case_uqi\"", "\"jbsr\\t___gnu_csky_case_sqi\"", "\"jbsr\\t___gnu_csky_case_uhi\"", "\"jbsr\\t___gnu_csky_case_shi\"", "\"jbsr\\t___gnu_csky_case_si\"" ]

[]

[ "<s>", "BitVector", "TOYRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "TOY", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "TOY", "::", "LR", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::SP", "TOY::LR" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "assert", "(", "!", "MI", ".", "isBundle", "(", ")", "&&", "\"TargetInstrInfo::findCommutedOpIndices() can't handle bundles\"", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isCommutable", "(", ")", ")", "return", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DPADD_U_H", ":", "case", "Mips", "::", "DPADD_U_W", ":", "case", "Mips", "::", "DPADD_U_D", ":", "case", "Mips", "::", "DPADD_S_H", ":", "case", "Mips", "::", "DPADD_S_W", ":", "case", "Mips", "::", "DPADD_S_D", ":", "{", "if", "(", "!", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "2", ",", "3", ")", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "SrcOpIdx1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "SrcOpIdx2", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "}", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "Mips", "Mips", "\"TargetInstrInfo::findCommutedOpIndices() can't handle bundles\"", "Mips::DPADD_U_H", "Mips::DPADD_U_W", "Mips::DPADD_U_D", "Mips::DPADD_S_H", "Mips::DPADD_S_W", "Mips::DPADD_S_D", "2", "3" ]

[]

[ "<s>", "const", "MachineDomTreeNode", "*", "MBBInfo", "::", "getNode", "(", ")", "const", "{", "return", "Node", ";", "}", "</s>" ]

[ "getNode", "{" ]

[ "Mips" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "splitValueIntoRegisterParts", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Val", ",", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "bool", "IsABIRegCopy", "=", "CC", ".", "hasValue", "(", ")", ";", "EVT", "ValueVT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "IsABIRegCopy", "&&", "ValueVT", "==", "MVT", "::", "f16", "&&", "PartVT", "==", "MVT", "::", "f32", ")", "{", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i16", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "MVT", "::", "i32", ",", "Val", ",", "DAG", ".", "getConstant", "(", "0xFFFF0000", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "f32", ",", "Val", ")", ";", "Parts", "[", "0", "]", "=", "Val", ";", "return", "true", ";", "}", "if", "(", "ValueVT", ".", "isScalableVector", "(", ")", "&&", "PartVT", ".", "isScalableVector", "(", ")", ")", "{", "LLVMContext", "&", "Context", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "EVT", "ValueEltVT", "=", "ValueVT", ".", "getVectorElementType", "(", ")", ";", "EVT", "PartEltVT", "=", "PartVT", ".", "getVectorElementType", "(", ")", ";", "unsigned", "ValueVTBitSize", "=", "ValueVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "unsigned", "PartVTBitSize", "=", "PartVT", ".", "getSizeInBits", "(", ")", ".", "getKnownMinSize", "(", ")", ";", "if", "(", "PartVTBitSize", "%", "ValueVTBitSize", "==", "0", ")", "{", "assert", "(", "PartVTBitSize", ">=", "ValueVTBitSize", ")", ";", "if", "(", "ValueEltVT", "!=", "PartEltVT", ")", "{", "if", "(", "PartVTBitSize", ">", "ValueVTBitSize", ")", "{", "unsigned", "Count", "=", "PartVTBitSize", "/", "ValueEltVT", ".", "getFixedSizeInBits", "(", ")", ";", "assert", "(", "Count", "!=", "0", "&&", "\"The number of element should not be zero.\"", ")", ";", "EVT", "SameEltTypeVT", "=", "EVT", "::", "getVectorVT", "(", "Context", ",", "ValueEltVT", ",", "Count", ",", "true", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "DL", ",", "SameEltTypeVT", ",", "DAG", ".", "getUNDEF", "(", "SameEltTypeVT", ")", ",", "Val", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "DL", ")", ")", ";", "}", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "PartVT", ",", "Val", ")", ";", "}", "else", "{", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "DL", ",", "PartVT", ",", "DAG", ".", "getUNDEF", "(", "PartVT", ")", ",", "Val", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "DL", ")", ")", ";", "}", "Parts", "[", "0", "]", "=", "Val", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Target-specific", "splitting", "of", "values", "into", "parts", "that", "fit", "a", "register", "storing", "a", "legal", "type", "." ]

[ "RISCV", "RISCV", "MVT::f16", "MVT::f32", "ISD::BITCAST", "MVT::i16", "ISD::ANY_EXTEND", "MVT::i32", "ISD::OR", "MVT::i32", "0xFFFF0000", "MVT::i32", "ISD::BITCAST", "MVT::f32", "0", "0", "0", "\"The number of element should not be zero.\"", "ISD::INSERT_SUBVECTOR", "0", "ISD::BITCAST", "ISD::INSERT_SUBVECTOR", "0", "0" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "assert", "(", "MI", ".", "isCompare", "(", ")", "&&", "\"Caller should have checked for a comparison\"", ")", ";", "if", "(", "MI", ".", "getNumExplicitOperands", "(", ")", "==", "2", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "{", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "Value", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Mask", "=", "~", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "SystemZ", "SystemZ", "\"Caller should have checked for a comparison\"", "2", "0", "1", "0", "0", "1", "0" ]

[]

[ "<s>", "BitVector", "AlphaRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R15", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Alpha", "::", "R31", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::R15", "Alpha::R30", "Alpha::R31" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "HasDebugInfo", "=", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ";", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "Module", "::", "GlobalListType", "&", "global_list", "=", "M", ".", "getGlobalList", "(", ")", ";", "int", "i", ",", "n", "=", "global_list", ".", "size", "(", ")", ";", "GlobalVariable", "*", "*", "gv_array", "=", "new", "GlobalVariable", "*", "[", "n", "]", ";", "i", "=", "0", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "global_list", ".", "begin", "(", ")", ",", "E", "=", "global_list", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "gv_array", "[", "i", "++", "]", "=", "&", "*", "I", ";", "while", "(", "!", "global_list", ".", "empty", "(", ")", ")", "global_list", ".", "remove", "(", "global_list", ".", "begin", "(", ")", ")", ";", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "global_list", ".", "insert", "(", "global_list", ".", "end", "(", ")", ",", "gv_array", "[", "i", "]", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "delete", "[", "]", "gv_array", ";", "if", "(", "HasDebugInfo", ")", "{", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "closeLastSection", "(", ")", ";", "OutStreamer", "->", "emitRawText", "(", "\"\\t.section\\t.debug_loc\\t{\\t}\"", ")", ";", "}", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "outputDwarfFileDirectives", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "NVPTX", "NVPTX", "0", "0", "NVPTX", "\"\\t.section\\t.debug_loc\\t{\\t}\"", "NVPTX" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "PCReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "*", "GetPC", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "PCReg", ")", ";", "if", "(", "BrOffset", ">=", "0", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "PCReg", ",", "0", ",", "AMDGPU", "::", "sub0", ")", ".", "addMBB", "(", "&", "DestBB", ",", "AMDGPU", "::", "TF_LONG_BRANCH_FORWARD", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub1", ")", ".", "addReg", "(", "PCReg", ",", "0", ",", "AMDGPU", "::", "sub1", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "PCReg", ",", "0", ",", "AMDGPU", "::", "sub0", ")", ".", "addMBB", "(", "&", "DestBB", ",", "AMDGPU", "::", "TF_LONG_BRANCH_BACKWARD", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_SUBB_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub1", ")", ".", "addReg", "(", "PCReg", ",", "0", ",", "AMDGPU", "::", "sub1", ")", ".", "addImm", "(", "0", ")", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_SETPC_B64", ")", ")", ".", "addReg", "(", "PCReg", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "unsigned", "Scav", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ",", "MachineBasicBlock", "::", "iterator", "(", "GetPC", ")", ",", "0", ")", ";", "MRI", ".", "replaceRegWith", "(", "PCReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "return", "4", "+", "8", "+", "4", "+", "4", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "AMDGPU", "SI", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "AMDGPU::SReg_64RegClass", "AMDGPU::S_GETPC_B64", "0", "AMDGPU::S_ADD_U32", "AMDGPU::sub0", "0", "AMDGPU::sub0", "AMDGPU::TF_LONG_BRANCH_FORWARD", "AMDGPU::S_ADDC_U32", "AMDGPU::sub1", "0", "AMDGPU::sub1", "0", "AMDGPU::S_SUB_U32", "AMDGPU::sub0", "0", "AMDGPU::sub0", "AMDGPU::TF_LONG_BRANCH_BACKWARD", "AMDGPU::S_SUBB_U32", "AMDGPU::sub1", "0", "AMDGPU::sub1", "0", "AMDGPU::S_SETPC_B64", "AMDGPU::SReg_64RegClass", "0", "4", "8", "4", "4" ]

[]

[ "<s>", "static", "bool", "arm_array_mode_supported_p", "(", "machine_mode", "mode", ",", "unsigned", "HOST_WIDE_INT", "nelems", ")", "{", "if", "(", "TARGET_NEON", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode", ")", ")", "&&", "(", "nelems", ">=", "2", "&&", "nelems", "<=", "4", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "array_mode_supported_p", "." ]

[ "arm", "2", "4" ]

[]

[ "<s>", "static", "void", "avr_asm_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "fputs", "(", "\"/* prologue: naked */\\n\"", ",", "file", ")", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "{", "fputs", "(", "\"/* prologue: Interrupt */\\n\"", ",", "file", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "is_signal", ")", "{", "fputs", "(", "\"/* prologue: Signal */\\n\"", ",", "file", ")", ";", "}", "else", "fputs", "(", "\"/* prologue: function */\\n\"", ",", "file", ")", ";", "}", "if", "(", "ACCUMULATE_OUTGOING_ARGS", ")", "fprintf", "(", "file", ",", "\"/* outgoing args size = %d */\\n\"", ",", "avr_outgoing_args_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"/* frame size = \"", "HOST_WIDE_INT_PRINT_DEC", "\" */\\n\"", ",", "get_frame_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"/* stack size = %d */\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "fprintf", "(", "file", ",", "\".L__stack_usage = %d\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "}", "</s>" ]

[ "Output", "summary", "at", "end", "of", "function", "prologue", "." ]

[ "avr", "\"/* prologue: naked */\\n\"", "\"/* prologue: Interrupt */\\n\"", "\"/* prologue: Signal */\\n\"", "\"/* prologue: function */\\n\"", "\"/* outgoing args size = %d */\\n\"", "\"/* frame size = \"", "\" */\\n\"", "\"/* stack size = %d */\\n\"", "\".L__stack_usage = %d\\n\"" ]

[]

[ "<s>", "const", "PPCInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "arm_option_reconfigure_globals", "(", "void", ")", "{", "sprintf", "(", "arm_arch_name", ",", "\"__ARM_ARCH_%s__\"", ",", "arm_active_target", ".", "arch_pp_name", ")", ";", "arm_base_arch", "=", "arm_active_target", ".", "base_arch", ";", "arm_arch4", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv4", ")", ";", "arm_arch4t", "=", "arm_arch4", "&&", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ";", "arm_arch5t", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv5t", ")", ";", "arm_arch5te", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv5te", ")", ";", "arm_arch6", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv6", ")", ";", "arm_arch6k", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv6k", ")", ";", "arm_arch_notm", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_notm", ")", ";", "arm_arch6m", "=", "arm_arch6", "&&", "!", "arm_arch_notm", ";", "arm_arch7", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv7", ")", ";", "arm_arch7em", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv7em", ")", ";", "arm_arch8", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv8", ")", ";", "arm_arch8_1", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv8_1", ")", ";", "arm_arch8_2", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv8_2", ")", ";", "arm_arch8_3", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv8_3", ")", ";", "arm_arch8_4", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_armv8_4", ")", ";", "arm_arch_thumb1", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ";", "arm_arch_thumb2", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb2", ")", ";", "arm_arch_xscale", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_xscale", ")", ";", "arm_arch_iwmmxt", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_iwmmxt", ")", ";", "arm_arch_iwmmxt2", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_iwmmxt2", ")", ";", "arm_arch_thumb_hwdiv", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_tdiv", ")", ";", "arm_arch_arm_hwdiv", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_adiv", ")", ";", "arm_arch_crc", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_crc32", ")", ";", "arm_arch_cmse", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_cmse", ")", ";", "arm_fp16_inst", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_fp16", ")", ";", "arm_arch_lpae", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_lpae", ")", ";", "if", "(", "arm_fp16_inst", ")", "{", "if", "(", "arm_fp16_format", "==", "ARM_FP16_FORMAT_ALTERNATIVE", ")", "error", "(", "\"selected fp16 options are incompatible\"", ")", ";", "arm_fp16_format", "=", "ARM_FP16_FORMAT_IEEE", ";", "}", "arm_arch_no_volatile_ce", "=", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_quirk_no_volatile_ce", ")", ";", "arm_arch6kz", "=", "arm_arch6k", "&&", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_quirk_armv6kz", ")", ";", "if", "(", "target_thread_pointer", "==", "TP_AUTO", ")", "{", "if", "(", "arm_arch6k", "&&", "!", "TARGET_THUMB1", ")", "target_thread_pointer", "=", "TP_CP15", ";", "else", "target_thread_pointer", "=", "TP_SOFT", ";", "}", "}", "</s>" ]

[ "Reconfigure", "global", "status", "flags", "from", "the", "active_target.isa", "." ]

[ "arm", "\"__ARM_ARCH_%s__\"", "\"selected fp16 options are incompatible\"" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i32", ";", "if", "(", "VT", ".", "isScalableVector", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "MVT::i32", "MVT::getVectorVT", "MVT::i1" ]

[]

[ "<s>", "llvm", "::", "FastISel", "*", "ARM", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ")", "{", "if", "(", "EnableARMFastISel", ")", "return", "new", "ARMFastISel", "(", "funcInfo", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "ARM", "ARM::createFastISel", "ARM", "ARM", "0" ]

[]

[ "<s>", "void", "LanaiInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annotation", ",", "const", "MCSubtargetInfo", "&", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "printAlias", "(", "MI", ",", "OS", ")", "&&", "!", "printAliasInstr", "(", "MI", ",", "Address", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annotation", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "combineRepeatedFPDivisors", "(", ")", "const", "{", "return", "2", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "GBZ80TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerDivRem", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "\"Don't know how to custom lower this!\"", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ROTL", "ISD::ROTR", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::FrameIndex", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::LOAD" ]

[]

[ "<s>", "static", "void", "alpha_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "bool", "onstack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ";", "int", "increment", "=", "onstack", "?", "6", ":", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ")", ";", "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "6", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment", ";", "}", "</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", ".", ")" ]

[ "alpha", "6", "6" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "case", "G_GEP", ":", "case", "G_AND", ":", "case", "G_OR", ":", "case", "G_XOR", ":", "case", "G_SHL", ":", "case", "G_ASHR", ":", "case", "G_LSHR", ":", "case", "G_SDIV", ":", "case", "G_UDIV", ":", "case", "G_SREM", ":", "case", "G_UREM", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "case", "G_GLOBAL_VALUE", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "case", "G_ICMP", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]

[]

[ "<s>", "bool", "SIPeepholeSDWA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasSDWA", "(", ")", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Ret", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "do", "{", "matchSDWAOperands", "(", "MBB", ")", ";", "for", "(", "const", "auto", "&", "OperandPair", ":", "SDWAOperands", ")", "{", "const", "auto", "&", "Operand", "=", "OperandPair", ".", "second", ";", "MachineInstr", "*", "PotentialMI", "=", "Operand", "->", "potentialToConvert", "(", "TII", ")", ";", "if", "(", "PotentialMI", "&&", "isConvertibleToSDWA", "(", "*", "PotentialMI", ",", "ST", ")", ")", "{", "PotentialMatches", "[", "PotentialMI", "]", ".", "push_back", "(", "Operand", ".", "get", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "PotentialPair", ":", "PotentialMatches", ")", "{", "MachineInstr", "&", "PotentialMI", "=", "*", "PotentialPair", ".", "first", ";", "convertToSDWA", "(", "PotentialMI", ",", "PotentialPair", ".", "second", ")", ";", "}", "PotentialMatches", ".", "clear", "(", ")", ";", "SDWAOperands", ".", "clear", "(", ")", ";", "Changed", "=", "!", "ConvertedInstructions", ".", "empty", "(", ")", ";", "if", "(", "Changed", ")", "Ret", "=", "true", ";", "while", "(", "!", "ConvertedInstructions", ".", "empty", "(", ")", ")", "legalizeScalarOperands", "(", "*", "ConvertedInstructions", ".", "pop_back_val", "(", ")", ",", "ST", ")", ";", "}", "while", "(", "Changed", ")", ";", "}", "return", "Ret", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "ARM", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_arm_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_pcrel_10_unscaled\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_thumb_adr_pcrel_10\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_condbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_uncondbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_condbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_uncondbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_br\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_bl\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_blx\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bl\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_blx\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cb\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cp\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bcc\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "ARM", "ARM::NumTargetFixupKinds", "\"fixup_arm_ldst_pcrel_12\"", "0", "32", "\"fixup_t2_ldst_pcrel_12\"", "0", "32", "\"fixup_arm_pcrel_10_unscaled\"", "0", "32", "\"fixup_arm_pcrel_10\"", "0", "32", "\"fixup_t2_pcrel_10\"", "0", "32", "\"fixup_thumb_adr_pcrel_10\"", "0", "8", "\"fixup_arm_adr_pcrel_12\"", "0", "32", "\"fixup_t2_adr_pcrel_12\"", "0", "32", "\"fixup_arm_condbranch\"", "0", "24", "\"fixup_arm_uncondbranch\"", "0", "24", "\"fixup_t2_condbranch\"", "0", "32", "\"fixup_t2_uncondbranch\"", "0", "32", "\"fixup_arm_thumb_br\"", "0", "16", "\"fixup_arm_bl\"", "0", "24", "\"fixup_arm_blx\"", "0", "24", "\"fixup_arm_thumb_bl\"", "0", "32", "\"fixup_arm_thumb_blx\"", "0", "32", "\"fixup_arm_thumb_cb\"", "0", "16", "\"fixup_arm_thumb_cp\"", "0", "8", "\"fixup_arm_thumb_bcc\"", "0", "8", "\"fixup_arm_movt_hi16\"", "0", "20", "0", "\"fixup_arm_movw_lo16\"", "0", "20", "0", "\"fixup_t2_movt_hi16\"", "0", "20", "0", "\"fixup_t2_movw_lo16\"", "0", "20", "0", "\"fixup_arm_movt_hi16_pcrel\"", "0", "20", "\"fixup_arm_movw_lo16_pcrel\"", "0", "20", "\"fixup_t2_movt_hi16_pcrel\"", "0", "20", "\"fixup_t2_movw_lo16_pcrel\"", "0", "20", "\"Invalid kind!\"" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "hppa_encode_label", "(", "rtx", "sym", ")", "{", "const", "char", "*", "str", "=", "XSTR", "(", "sym", ",", "0", ")", ";", "int", "len", "=", "strlen", "(", "str", ")", "+", "1", ";", "char", "*", "newstr", ",", "*", "p", ";", "p", "=", "newstr", "=", "alloca", "(", "len", "+", "1", ")", ";", "*", "p", "++", "=", "'@'", ";", "strcpy", "(", "p", ",", "str", ")", ";", "XSTR", "(", "sym", ",", "0", ")", "=", "ggc_alloc_string", "(", "newstr", ",", "len", ")", ";", "}", "</s>" ]

[ "In", "HPUX", "8.0", "'s", "shared", "library", "scheme", ",", "special", "relocations", "are", "needed", "for", "function", "labels", "if", "they", "might", "be", "passed", "to", "a", "function", "in", "a", "shared", "library", "(", "because", "shared", "libraries", "do", "n't", "live", "in", "code", "space", ")", ",", "and", "special", "magic", "is", "needed", "to", "construct", "their", "address", "." ]

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

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "SubIdx", "&&", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "{", "DestReg", "=", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubIdx", ")", ";", "SubIdx", "=", "0", ";", "}", "bool", "Clone", "=", "true", ";", "unsigned", "Opc", "=", "Orig", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8r0", ":", "case", "X86", "::", "MOV16r0", ":", "case", "X86", "::", "MOV32r0", ":", "{", "if", "(", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8r0", ":", "Opc", "=", "X86", "::", "MOV8ri", ";", "break", ";", "case", "X86", "::", "MOV16r0", ":", "Opc", "=", "X86", "::", "MOV16ri", ";", "break", ";", "case", "X86", "::", "MOV32r0", ":", "Opc", "=", "X86", "::", "MOV32ri", ";", "break", ";", "}", "Clone", "=", "false", ";", "}", "break", ";", "}", "}", "if", "(", "Clone", ")", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestReg", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "MachineInstr", "*", "NewMI", "=", "prior", "(", "I", ")", ";", "NewMI", "->", "getOperand", "(", "0", ")", ".", "setSubReg", "(", "SubIdx", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "0", "X86::MOV8r0", "X86::MOV16r0", "X86::MOV32r0", "X86::MOV8r0", "X86::MOV8ri", "X86::MOV16r0", "X86::MOV16ri", "X86::MOV32r0", "X86::MOV32ri", "0", "0", "0" ]

[]

[ "<s>", "bool", "NVPTXAtomicLower", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "SmallVector", "<", "AtomicRMWInst", "*", ">", "LocalMemoryAtomics", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "F", ")", ")", "if", "(", "AtomicRMWInst", "*", "RMWI", "=", "dyn_cast", "<", "AtomicRMWInst", ">", "(", "&", "I", ")", ")", "if", "(", "RMWI", "->", "getPointerAddressSpace", "(", ")", "==", "ADDRESS_SPACE_LOCAL", ")", "LocalMemoryAtomics", ".", "push_back", "(", "RMWI", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "AtomicRMWInst", "*", "RMWI", ":", "LocalMemoryAtomics", ")", "Changed", "|=", "lowerAtomicRMWInst", "(", "RMWI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "int", "s390_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "struct", "s390_address", "ad", ";", "if", "(", "!", "s390_decompose_address", "(", "addr", ",", "&", "ad", ")", ")", "return", "1000", ";", "return", "ad", ".", "indx", "?", "COSTS_N_INSNS", "(", "1", ")", "+", "1", ":", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "an", "address", "rtx", "ADDR", "." ]

[ "s390", "1000", "1", "1", "1" ]

[]

[ "<s>", "void", "CAHPFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "CAHP", "::", "GPRRegClass", ";", "if", "(", "!", "isInt", "<", "9", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlignment", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "}", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP::GPRRegClass", "9" ]

[]

[ "<s>", "rtx", "rs6000_darwin64_record_arg", "(", "CUMULATIVE_ARGS", "*", "orig_cum", ",", "const_tree", "type", ",", "bool", "named", ",", "bool", "retval", ")", "{", "rtx", "rvec", "[", "FIRST_PSEUDO_REGISTER", "]", ";", "int", "k", "=", "1", ",", "kbase", "=", "1", ";", "HOST_WIDE_INT", "typesize", "=", "int_size_in_bytes", "(", "type", ")", ";", "CUMULATIVE_ARGS", "copy_cum", "=", "*", "orig_cum", ";", "CUMULATIVE_ARGS", "*", "cum", "=", "&", "copy_cum", ";", "if", "(", "!", "retval", "&&", "TYPE_ALIGN", "(", "type", ")", ">=", "2", "*", "BITS_PER_WORD", "&&", "(", "cum", "->", "words", "%", "2", ")", "!=", "0", ")", "cum", "->", "words", "++", ";", "cum", "->", "intoffset", "=", "0", ";", "cum", "->", "use_stack", "=", "0", ";", "cum", "->", "named", "=", "named", ";", "rs6000_darwin64_record_arg_recurse", "(", "cum", ",", "type", ",", "0", ",", "rvec", ",", "&", "k", ")", ";", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "typesize", "*", "BITS_PER_UNIT", ",", "rvec", ",", "&", "k", ")", ";", "if", "(", "cum", "->", "use_stack", ")", "{", "if", "(", "retval", ")", "return", "NULL_RTX", ";", "kbase", "=", "0", ";", "rvec", "[", "0", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "}", "if", "(", "k", ">", "1", "||", "cum", "->", "use_stack", ")", "return", "gen_rtx_PARALLEL", "(", "BLKmode", ",", "gen_rtvec_v", "(", "k", "-", "kbase", ",", "&", "rvec", "[", "kbase", "]", ")", ")", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "For", "the", "darwin64", "ABI", ",", "we", "want", "to", "construct", "a", "PARALLEL", "consisting", "of", "the", "register", "(", "s", ")", "to", "be", "used", "for", "each", "field", "and", "subfield", "of", "a", "struct", "being", "passed", "by", "value", ",", "along", "with", "the", "offset", "of", "where", "the", "register", "'s", "value", "may", "be", "found", "in", "the", "block", ".", "FP", "fields", "go", "in", "FP", "register", ",", "vector", "fields", "go", "in", "vector", "registers", ",", "and", "everything", "else", "goes", "in", "int", "registers", ",", "packed", "as", "in", "memory", ".", "This", "code", "is", "also", "used", "for", "function", "return", "values", ".", "RETVAL", "indicates", "whether", "this", "is", "the", "case", ".", "Much", "of", "this", "is", "taken", "from", "the", "SPARC", "V9", "port", ",", "which", "has", "a", "similar", "calling", "convention", "." ]

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

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", "||", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "RC", "==", "ARM", "::", "tcGPRRegisterClass", "||", "RC", "==", "ARM", "::", "rGPRRegisterClass", "||", "RC", "==", "ARM", "::", "GPRnopcRegisterClass", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegisterClass", "ARM::tGPRRegisterClass", "ARM::tcGPRRegisterClass", "ARM::rGPRRegisterClass", "ARM::GPRnopcRegisterClass", "ARM::t2STRi12", "0", "ARM" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "LowerGlobalAddressDarwin", "(", "Op", ",", "DAG", ")", ":", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "VarArgsFrameIndex", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FP16_TO_FP32", ":", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP32_TO_FP16", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "LowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "break", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "BIT_CONVERT", ":", "return", "ExpandBIT_CONVERT", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShift", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "return", "LowerCTTZ", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSETCC", ":", "return", "LowerVSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Don't know how to custom lower this!\"", "ISD::ConstantPool", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::BR_JT", "ISD::DYNAMIC_STACKALLOC", "ISD::VASTART", "ISD::MEMBARRIER", "ISD::FP16_TO_FP32", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP32_TO_FP16", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::FCOPYSIGN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GLOBAL_OFFSET_TABLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::BIT_CONVERT", "ISD::SHL", "ISD::SRL", "ISD::SRA", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::CTTZ", "ISD::VSETCC", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "ISD::CONCAT_VECTORS" ]

[]

[ "<s>", "static", "void", "s390_emit_stack_tie", "(", "void", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "emit_insn", "(", "gen_stack_tie", "(", "mem", ")", ")", ";", "}", "</s>" ]

[ "This", "ties", "together", "stack", "memory", "(", "MEM", "with", "an", "alias", "set", "of", "frame_alias_set", ")", "and", "the", "change", "to", "the", "stack", "pointer", "." ]

[ "s390" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "LLVM_FALLTHROUGH", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "case", "X86", "::", "MOVSX64rr32", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unreachable!\"", ")", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "SubIdx", "=", "X86", "::", "sub_8bit", ";", "break", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "SubIdx", "=", "X86", "::", "sub_16bit", ";", "break", ";", "case", "X86", "::", "MOVSX64rr32", ":", "SubIdx", "=", "X86", "::", "sub_32bit", ";", "break", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "X86", "X86", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVSX64rr32", "0", "1", "1", "0", "\"Unreachable!\"", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::sub_8bit", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::sub_16bit", "X86::MOVSX64rr32", "X86::sub_32bit" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "rs6000_call_darwin_1", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "tlsarg", ",", "rtx", "cookie", ",", "bool", "sibcall", ")", "{", "rtx", "func", "=", "func_desc", ";", "rtx", "func_addr", ";", "rtx", "call", "[", "3", "]", ";", "rtx", "insn", ";", "int", "cookie_val", "=", "INTVAL", "(", "cookie", ")", ";", "bool", "make_island", "=", "false", ";", "if", "(", "(", "cookie_val", "&", "CALL_LONG", ")", "!=", "0", "&&", "GET_CODE", "(", "func_desc", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "darwin_emit_branch_islands", "&&", "TARGET_32BIT", ")", "make_island", "=", "true", ";", "else", "{", "func", "=", "rs6000_longcall_ref", "(", "func_desc", ",", "NULL_RTX", ")", ";", "cookie_val", "&=", "~", "CALL_LONG", ";", "}", "}", "if", "(", "GET_CODE", "(", "func", ")", "!=", "SYMBOL_REF", ")", "{", "func", "=", "force_reg", "(", "Pmode", ",", "func", ")", ";", "func_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "CTR_REGNO", ")", ";", "emit_move_insn", "(", "func_addr", ",", "func", ")", ";", "}", "else", "func_addr", "=", "func", ";", "call", "[", "0", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_addr", ")", ",", "tlsarg", ")", ";", "if", "(", "value", "!=", "NULL_RTX", ")", "call", "[", "0", "]", "=", "gen_rtx_SET", "(", "value", ",", "call", "[", "0", "]", ")", ";", "call", "[", "1", "]", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "GEN_INT", "(", "cookie_val", ")", ")", ";", "if", "(", "sibcall", ")", "call", "[", "2", "]", "=", "simple_return_rtx", ";", "else", "call", "[", "2", "]", "=", "gen_hard_reg_clobber", "(", "Pmode", ",", "LR_REGNO", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "3", ",", "call", ")", ")", ";", "insn", "=", "emit_call_insn", "(", "insn", ")", ";", "if", "(", "make_island", ")", "{", "tree", "funname", "=", "get_identifier", "(", "XSTR", "(", "func_desc", ",", "0", ")", ")", ";", "if", "(", "no_previous_def", "(", "funname", ")", ")", "{", "rtx", "label_rtx", "=", "gen_label_rtx", "(", ")", ";", "char", "*", "label_buf", ",", "temp_buf", "[", "256", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "temp_buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "label_rtx", ")", ")", ";", "label_buf", "=", "temp_buf", "[", "0", "]", "==", "'*'", "?", "temp_buf", "+", "1", ":", "temp_buf", ";", "tree", "labelname", "=", "get_identifier", "(", "label_buf", ")", ";", "add_compiler_branch_island", "(", "labelname", ",", "funname", ",", "insn_line", "(", "(", "const", "rtx_insn", "*", ")", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "code", "to", "perform", "a", "call", "under", "the", "Darwin", "ABI", ".", "Modulo", "handling", "of", "mlongcall", ",", "this", "is", "much", "the", "same", "as", "sysv", ".", "if/when", "the", "longcall", "optimisation", "is", "removed", ",", "we", "could", "drop", "this", "code", "and", "use", "the", "sysv", "case", "(", "taking", "care", "to", "avoid", "the", "tls", "stuff", ")", ".", "We", "can", "use", "this", "for", "sibcalls", "too", ",", "if", "needed", "." ]

[ "rs6000", "3", "0", "0", "0", "0", "1", "2", "2", "3", "0", "256", "\"L\"", "0", "1" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "classifyLEAReg", "(", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "Src", ",", "unsigned", "Opc", ",", "bool", "AllowSP", ",", "unsigned", "&", "NewSrc", ",", "bool", "&", "isKill", ",", "bool", "&", "isUndef", ",", "MachineOperand", "&", "ImplicitOp", ",", "LiveVariables", "*", "LV", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "AllowSP", ")", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "}", "else", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64_NOSPRegClass", ":", "&", "X86", "::", "GR32_NOSPRegClass", ";", "}", "unsigned", "SrcReg", "=", "Src", ".", "getReg", "(", ")", ";", "if", "(", "Opc", "!=", "X86", "::", "LEA64_32r", ")", "{", "NewSrc", "=", "SrcReg", ";", "isKill", "=", "Src", ".", "isKill", "(", ")", ";", "isUndef", "=", "Src", ".", "isUndef", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "NewSrc", ")", "&&", "!", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "NewSrc", ",", "RC", ")", ")", "return", "false", ";", "return", "true", ";", "}", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", ")", "{", "ImplicitOp", "=", "Src", ";", "ImplicitOp", ".", "setImplicit", "(", ")", ";", "NewSrc", "=", "getX86SubSuperRegister", "(", "Src", ".", "getReg", "(", ")", ",", "64", ")", ";", "isKill", "=", "Src", ".", "isKill", "(", ")", ";", "isUndef", "=", "Src", ".", "isUndef", "(", ")", ";", "}", "else", "{", "NewSrc", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MachineInstr", "*", "Copy", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ".", "addReg", "(", "NewSrc", ",", "RegState", "::", "Define", "|", "RegState", "::", "Undef", ",", "X86", "::", "sub_32bit", ")", ".", "add", "(", "Src", ")", ";", "isKill", "=", "true", ";", "isUndef", "=", "false", ";", "if", "(", "LV", ")", "LV", "->", "replaceKillInstruction", "(", "SrcReg", ",", "MI", ",", "*", "Copy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Given", "an", "operand", "within", "a", "MachineInstr", ",", "insert", "preceding", "code", "to", "put", "it", "into", "the", "right", "format", "for", "a", "particular", "kind", "of", "LEA", "instruction", "." ]

[ "X86", "X86", "X86::LEA32r", "X86::GR64RegClass", "X86::GR32RegClass", "X86::LEA32r", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "X86::LEA64_32r", "X86", "64", "X86::sub_32bit" ]

[]

[ "<s>", "unsigned", "ARMCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "II", "->", "getRegisterInfo", "(", ")", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ",", "true", ",", "false", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "unsigned", "Reloc", "=", "(", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "==", "ARMII", "::", "VFPLdStFrm", ")", "?", "ARM", "::", "reloc_arm_vfp_cp_entry", ":", "ARM", "::", "reloc_arm_cp_entry", ";", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "Reloc", ")", ";", "}", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "ARM", "::", "reloc_arm_relative", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "ARM", "ARM", "ARM::reloc_arm_branch", "ARM::reloc_arm_branch", "ARMII::FormMask", "ARMII::VFPLdStFrm", "ARM::reloc_arm_vfp_cp_entry", "ARM::reloc_arm_cp_entry", "ARM::reloc_arm_relative", "ARM::reloc_arm_branch", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "static", "unsigned", "findDeadCallerSavedReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "M680x0RegisterInfo", "*", "TRI", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", "->", "callsEHReturn", "(", ")", ")", "return", "0", ";", "const", "TargetRegisterClass", "&", "AvailableRegs", "=", "*", "TRI", "->", "getRegsForTailCall", "(", "*", "MF", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "switch", "(", "MBBI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "PATCHABLE_RET", ":", "case", "M680x0", "::", "RET", ":", "{", "SmallSet", "<", "uint16_t", ",", "8", ">", "Uses", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MBBI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "continue", ";", "for", "(", "MCRegAliasIterator", "AI", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Uses", ".", "insert", "(", "*", "AI", ")", ";", "}", "for", "(", "auto", "CS", ":", "AvailableRegs", ")", "if", "(", "!", "Uses", ".", "count", "(", "CS", ")", ")", "return", "CS", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "findDeadCallerSavedReg", "-", "Return", "a", "caller-saved", "register", "that", "is", "n't", "live", "when", "it", "reaches", "the", "``", "return", "''", "instruction", "." ]

[ "M680x0", "M680x0", "0", "0", "0", "M680x0::RET", "8", "0", "0" ]

[]

[ "<s>", "void", "AAPFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "AAPMachineFunctionInfo", "*", "MFuncInfo", "=", "MF", ".", "getInfo", "<", "AAPMachineFunctionInfo", ">", "(", ")", ";", "const", "AAPInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "AAPInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "auto", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "assert", "(", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", ")", "&&", "\"Epilogue can only be inserted in returning blocks\"", ")", ";", "const", "uint64_t", "StackSize", "=", "MFrameInfo", ".", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "MFuncInfo", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "unsigned", "SP", "=", "AAPRegisterInfo", "::", "getStackPtrRegister", "(", ")", ";", "assert", "(", "!", "hasFP", "(", "MF", ")", "&&", "\"Frame pointer unsupported!\"", ")", ";", "if", "(", "NumBytes", ")", "{", "const", "uint64_t", "Addend", "=", "NumBytes", "%", "1023", ";", "const", "uint64_t", "NumChunks", "=", "NumBytes", "/", "1023", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "NumChunks", ";", "++", "i", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AAP", "::", "ADDI_i10", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "1023", ")", ";", "}", "if", "(", "Addend", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AAP", "::", "ADDI_i10", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Addend", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AAP", "AAP", "AAP", "AAP", "AAP", "AAP", "\"Epilogue can only be inserted in returning blocks\"", "AAP", "\"Frame pointer unsupported!\"", "1023", "1023", "0", "AAP::ADDI_i10", "1023", "AAP::ADDI_i10" ]

[]

[ "<s>", "static", "void", "def_or_undef_macro", "(", "struct", "cpp_reader", "*", "pfile", ",", "const", "char", "*", "name", ",", "bool", "def_p", ")", "{", "if", "(", "def_p", ")", "cpp_define", "(", "pfile", ",", "name", ")", ";", "else", "cpp_undef", "(", "pfile", ",", "name", ")", ";", "}", "</s>" ]

[ "Define", "or", "undefine", "macros", "based", "on", "the", "current", "target", ".", "If", "the", "user", "does", "#", "pragma", "GCC", "target", ",", "we", "need", "to", "adjust", "the", "macros", "dynamically", "." ]

[ "arm" ]

[]

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

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

[ "X86", "\"X86 DAG->DAG Instruction Selection\"" ]

[]

[ "<s>", "static", "rtx", "hwloop_pattern_reg", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "reg", ";", "if", "(", "!", "JUMP_P", "(", "insn", ")", "||", "recog_memoized", "(", "insn", ")", "!=", "CODE_FOR_loop_end", ")", "return", "NULL_RTX", ";", "reg", "=", "SET_DEST", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "NULL_RTX", ";", "return", "reg", ";", "}", "</s>" ]

[ "A", "callback", "for", "the", "hw-doloop", "pass", ".", "This", "function", "examines", "INSN", ";", "if", "it", "is", "a", "doloop_end", "pattern", "we", "recognize", ",", "return", "the", "reg", "rtx", "for", "the", "loop", "counter", ".", "Otherwise", ",", "return", "NULL_RTX", "." ]

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

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "M88kInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "M88kII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "MO_ABS_HI", ",", "\"m88k-abs-hi\"", "}", ",", "{", "MO_ABS_LO", ",", "\"m88k-abs-lo\"", "}", ",", "}", ";", "return", "makeArrayRef", "(", "Flags", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k", "\"m88k-abs-hi\"", "\"m88k-abs-lo\"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "decomposeMulByConstant", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "SDValue", "C", ")", "const", "{", "if", "(", "VT", ".", "isScalarInteger", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "ConstNode", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "C", ".", "getNode", "(", ")", ")", ")", "{", "const", "APInt", "&", "Imm", "=", "ConstNode", "->", "getAPIntValue", "(", ")", ";", "if", "(", "(", "Imm", "+", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "Imm", "-", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "1", "-", "Imm", ")", ".", "isPowerOf2", "(", ")", "||", "(", "-", "1", "-", "Imm", ")", ".", "isPowerOf2", "(", ")", ")", "return", "true", ";", "if", "(", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "VT", ".", "getSizeInBits", "(", ")", ">=", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Imm", ".", "isSignedIntN", "(", "12", ")", "&&", "Imm", ".", "countTrailingZeros", "(", ")", "<", "12", ")", "{", "APInt", "ImmS", "=", "Imm", ".", "ashr", "(", "Imm", ".", "countTrailingZeros", "(", ")", ")", ";", "if", "(", "(", "ImmS", "+", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "ImmS", "-", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "1", "-", "ImmS", ")", ".", "isPowerOf2", "(", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "transform", "an", "integer", "multiplication-by-constant", "into", "simpler", "operations", "like", "shifts", "and", "adds", "." ]

[ "RI5CY", "RISCV", "1", "1", "1", "1", "12", "12", "1", "1", "1" ]

[]

[ "<s>", "void", "MipsTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isABI_N64", "(", ")", "||", "Subtarget", ".", "isABI_N32", "(", ")", ")", "ReginfoSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".MIPS.options\"", ",", "ELF", "::", "SHT_MIPS_OPTIONS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MIPS_NOSTRIP", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "else", "ReginfoSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".reginfo\"", ",", "ELF", "::", "SHT_MIPS_REGINFO", ",", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "isTargetNaCl", "(", ")", ")", "{", "StaticCtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".init_array\"", ",", "ELF", "::", "SHT_INIT_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "StaticDtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".fini_array\"", ",", "ELF", "::", "SHT_FINI_ARRAY", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "\".sdata\"", "\".sbss\"", "Mips", "Mips", "\".MIPS.options\"", "\".reginfo\"", "\".init_array\"", "\".fini_array\"" ]

[]

[ "<s>", "static", "void", "ix86_emit_restore_regs_using_pop", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "GENERAL_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "false", ",", "true", ")", ")", "ix86_emit_restore_reg_using_pop", "(", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "saved", "registers", "using", "POP", "insns", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "VEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "VE", "::", "EXTEND_STACK", ":", "{", "return", "expandExtendStackPseudo", "(", "MI", ")", ";", "}", "case", "VE", "::", "EXTEND_STACK_GUARD", ":", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::EXTEND_STACK", "VE::EXTEND_STACK_GUARD" ]

[]

[ "<s>", "static", "bool", "microblaze_const_double_ok", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "REAL_VALUE_TYPE", "d", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_DOUBLE", ")", "return", "0", ";", "if", "(", "GET_MODE", "(", "op", ")", "==", "VOIDmode", ")", "return", "1", ";", "if", "(", "mode", "!=", "SFmode", "&&", "mode", "!=", "DFmode", ")", "return", "0", ";", "if", "(", "op", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "1", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "d", ",", "op", ")", ";", "if", "(", "REAL_VALUE_ISNAN", "(", "d", ")", ")", "return", "FALSE", ";", "if", "(", "REAL_VALUE_NEGATIVE", "(", "d", ")", ")", "d", "=", "real_value_negate", "(", "&", "d", ")", ";", "if", "(", "mode", "==", "DFmode", ")", "{", "if", "(", "REAL_VALUES_LESS", "(", "d", ",", "dfhigh", ")", "&&", "REAL_VALUES_LESS", "(", "dflow", ",", "d", ")", ")", "return", "1", ";", "}", "else", "{", "if", "(", "REAL_VALUES_LESS", "(", "d", ",", "sfhigh", ")", "&&", "REAL_VALUES_LESS", "(", "sflow", ",", "d", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "truth", "value", "if", "a", "CONST_DOUBLE", "is", "ok", "to", "be", "a", "legitimate", "constant", "." ]

[ "microblaze", "0", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "if", "(", "AI", "->", "isFloatingPointOperation", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Nand", "&&", "Size", "<", "128", ")", "{", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "Subtarget", "->", "outlineAtomics", "(", ")", ")", "{", "if", "(", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Min", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Max", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMin", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMax", ")", "{", "return", "AtomicExpansionKind", "::", "None", ";", "}", "}", "}", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

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

[]

[ "<s>", "static", "rtx", "sparc_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "orig_x", "=", "x", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "MULT", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "1", ")", ",", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "MULT", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "NULL_RTX", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ")", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "force_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "NULL_RTX", ")", ")", ";", "if", "(", "x", "!=", "orig_x", "&&", "sparc_legitimate_address_p", "(", "mode", ",", "x", ",", "FALSE", ")", ")", "return", "x", ";", "if", "(", "sparc_tls_referenced_p", "(", "x", ")", ")", "x", "=", "sparc_legitimize_tls_address", "(", "x", ")", ";", "else", "if", "(", "flag_pic", ")", "x", "=", "sparc_legitimize_pic_address", "(", "x", ",", "NULL_RTX", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ",", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "x", ",", "1", ")", ",", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "x", "=", "copy_to_suggested_reg", "(", "x", ",", "NULL_RTX", ",", "Pmode", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", ".", "On", "SPARC", ",", "change", "REG+N", "into", "REG+REG", ",", "and", "REG+", "(", "X", "*", "Y", ")", "into", "REG+REG", "." ]

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

[]

[ "<s>", "bool", "aarch64_prepare_sve_cond_int_fma", "(", "rtx", "*", "operands", ",", "rtx_code", "code", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "rtx", "shifts", "=", "aarch64_convert_mult_to_shift", "(", "operands", "[", "3", "]", ",", "code", ")", ")", "{", "rtx", "product", "=", "expand_binop", "(", "mode", ",", "vashl_optab", ",", "operands", "[", "2", "]", ",", "shifts", ",", "NULL_RTX", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "emit_insn", "(", "gen_cond", "(", "code", ",", "mode", ",", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "4", "]", ",", "product", ",", "operands", "[", "5", "]", ")", ")", ";", "return", "true", ";", "}", "operands", "[", "3", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "3", "]", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "for", "a", "conditional", "pattern", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI insert wait instructions\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI insert wait instructions\"" ]

[]

[ "<s>", "int", "arm_legitimate_address_outer_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "RTX_CODE", "outer", ",", "int", "strict_p", ")", "{", "bool", "use_ldrd", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "1", ";", "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "(", "mode", "==", "DFmode", "&&", "(", "TARGET_SOFT_FLOAT", "||", "TARGET_VFP", ")", ")", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ";", "if", "(", "use_ldrd", "&&", "GET_CODE", "(", "x", ")", "==", "POST_MODIFY", "&&", "REG_P", "(", "addend", ")", ")", "return", "0", ";", "return", "(", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "addend", ",", "outer", ",", "strict_p", ")", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "1", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "TARGET_NEON", "&&", "VALID_NEON_STRUCT_MODE", "(", "mode", ")", ")", ")", "return", "0", ";", "else", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "(", "(", "CONST_INT_P", "(", "xop1", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop1", ",", "outer", ",", "strict_p", ")", ")", "||", "(", "!", "strict_p", "&&", "will_be_in_index_register", "(", "xop1", ")", ")", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop0", ",", "outer", ",", "strict_p", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MINUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop1", ",", "outer", ",", "strict_p", ")", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "&&", "!", "(", "flag_pic", "&&", "symbol_mentioned_p", "(", "get_pool_constant", "(", "x", ")", ")", "&&", "!", "pcrel_constant_p", "(", "get_pool_constant", "(", "x", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "a", "valid", "ARM", "state", "address", "operand", "." ]

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

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "ScratchExecCopy", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "if", "(", "ScratchExecCopy", "==", "AMDGPU", "::", "NoRegister", ")", "{", "LivePhysRegs", "LiveRegs", "(", "*", "ST", ".", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveIns", "(", "MBB", ")", ";", "ScratchExecCopy", "=", "findScratchNonCalleeSaveRegister", "(", "MF", ",", "LiveRegs", ",", "AMDGPU", "::", "SReg_64_XEXECRegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ")", ",", "ScratchExecCopy", ")", ".", "addImm", "(", "-", "1", ")", ";", "}", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "if", "(", "ScratchExecCopy", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "ScratchExecCopy", ")", ";", "}", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "==", "AMDGPU", "::", "NoRegister", ")", "return", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "NumBytes", "!=", "0", "&&", "hasSP", "(", "MF", ")", ")", "{", "uint32_t", "RoundedSize", "=", "FuncInfo", "->", "isStackRealigned", "(", ")", "?", "NumBytes", "+", "MFI", ".", "getMaxAlignment", "(", ")", ":", "NumBytes", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "RoundedSize", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::NoRegister", "SI", "AMDGPU::NoRegister", "AMDGPU::SReg_64_XEXECRegClass", "AMDGPU::S_OR_SAVEEXEC_B64", "1", "AMDGPU::VGPR_32RegClass", "AMDGPU::NoRegister", "AMDGPU::S_MOV_B64", "AMDGPU::EXEC", "AMDGPU::NoRegister", "0", "AMDGPU::S_SUB_U32" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AArch64TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR64commonRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "GPR32commonRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "16", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR16RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR64RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128RegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AArch64", "::", "FPR128_loRegClass", ")", ";", "break", ";", "}", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AArch64", "::", "NZCV", ")", ",", "&", "AArch64", "::", "CCRRegClass", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Res", ";", "Res", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "if", "(", "!", "Res", ".", "second", ")", "{", "unsigned", "Size", "=", "Constraint", ".", "size", "(", ")", ";", "if", "(", "(", "Size", "==", "4", "||", "Size", "==", "5", ")", "&&", "Constraint", "[", "0", "]", "==", "'{'", "&&", "tolower", "(", "Constraint", "[", "1", "]", ")", "==", "'v'", "&&", "Constraint", "[", "Size", "-", "1", "]", "==", "'}'", ")", "{", "int", "RegNo", ";", "bool", "Failed", "=", "Constraint", ".", "slice", "(", "2", ",", "Size", "-", "1", ")", ".", "getAsInteger", "(", "10", ",", "RegNo", ")", ";", "if", "(", "!", "Failed", "&&", "RegNo", ">=", "0", "&&", "RegNo", "<=", "31", ")", "{", "if", "(", "VT", "!=", "MVT", "::", "Other", "&&", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "{", "Res", ".", "first", "=", "AArch64", "::", "FPR64RegClass", ".", "getRegister", "(", "RegNo", ")", ";", "Res", ".", "second", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "}", "else", "{", "Res", ".", "first", "=", "AArch64", "::", "FPR128RegClass", ".", "getRegister", "(", "RegNo", ")", ";", "Res", ".", "second", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "}", "}", "}", "}", "return", "Res", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "0", "64", "0U", "AArch64::GPR64commonRegClass", "0U", "AArch64::GPR32commonRegClass", "16", "0U", "AArch64::FPR16RegClass", "32", "0U", "AArch64::FPR32RegClass", "64", "0U", "AArch64::FPR64RegClass", "128", "0U", "AArch64::FPR128RegClass", "128", "0U", "AArch64::FPR128_loRegClass", "\"{cc}\"", "AArch64::NZCV", "AArch64::CCRRegClass", "4", "5", "0", "1", "1", "2", "1", "10", "0", "31", "MVT::Other", "64", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::FPR128RegClass" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v32i8", ";", "if", "(", "(", "VT", "==", "MVT", "::", "v32i16", "||", "VT", "==", "MVT", "::", "v64i8", ")", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", "&&", "!", "EnableOldKNLABI", ")", "return", "MVT", "::", "v16i32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::v32i1", "MVT::v32i8", "MVT::v32i16", "MVT::v64i8", "MVT::v16i32" ]

[]

[ "<s>", "void", "frv_debug_stack", "(", "frv_stack_t", "*", "info", ")", "{", "int", "range", ";", "if", "(", "!", "info", ")", "info", "=", "frv_stack_info", "(", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nStack information for function %s:\\n\"", ",", "(", "(", "current_function_decl", "&&", "DECL_NAME", "(", "current_function_decl", ")", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", ":", "\"<unknown>\"", ")", ")", ";", "fprintf", "(", "stderr", ",", "\"\\ttotal_size\\t= %6d\\n\"", ",", "info", "->", "total_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tvars_size\\t= %6d\\n\"", ",", "info", "->", "vars_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tparam_size\\t= %6d\\n\"", ",", "info", "->", "parameter_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tregs_size\\t= %6d, 1w = %3d, 2w = %3d\\n\"", ",", "info", "->", "regs_size", ",", "info", "->", "regs_size_1word", ",", "info", "->", "regs_size_2words", ")", ";", "fprintf", "(", "stderr", ",", "\"\\theader_size\\t= %6d\\n\"", ",", "info", "->", "header_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tpretend_size\\t= %6d\\n\"", ",", "info", "->", "pretend_size", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tvars_offset\\t= %6d\\n\"", ",", "info", "->", "vars_offset", ")", ";", "fprintf", "(", "stderr", ",", "\"\\tregs_offset\\t= %6d\\n\"", ",", "info", "->", "regs_offset", ")", ";", "for", "(", "range", "=", "0", ";", "range", "<", "STACK_REGS_MAX", ";", "range", "++", ")", "{", "frv_stack_regs_t", "*", "regs", "=", "&", "(", "info", "->", "regs", "[", "range", "]", ")", ";", "if", "(", "(", "regs", "->", "size_1word", "+", "regs", "->", "size_2words", ")", ">", "0", ")", "{", "int", "first", "=", "regs", "->", "first", ";", "int", "last", "=", "regs", "->", "last", ";", "int", "regno", ";", "fprintf", "(", "stderr", ",", "\"\\t%s\\tsize\\t= %6d, 1w = %3d, 2w = %3d, save =\"", ",", "regs", "->", "name", ",", "regs", "->", "size_1word", "+", "regs", "->", "size_2words", ",", "regs", "->", "size_1word", ",", "regs", "->", "size_2words", ")", ";", "for", "(", "regno", "=", "first", ";", "regno", "<=", "last", ";", "regno", "++", ")", "{", "if", "(", "info", "->", "save_p", "[", "regno", "]", "==", "REG_SAVE_1WORD", ")", "fprintf", "(", "stderr", ",", "\" %s (%d)\"", ",", "reg_names", "[", "regno", "]", ",", "info", "->", "reg_offset", "[", "regno", "]", ")", ";", "else", "if", "(", "info", "->", "save_p", "[", "regno", "]", "==", "REG_SAVE_2WORDS", ")", "fprintf", "(", "stderr", ",", "\" %s-%s (%d)\"", ",", "reg_names", "[", "regno", "]", ",", "reg_names", "[", "regno", "+", "1", "]", ",", "info", "->", "reg_offset", "[", "regno", "]", ")", ";", "}", "fputc", "(", "'\\n'", ",", "stderr", ")", ";", "}", "}", "fflush", "(", "stderr", ")", ";", "}", "</s>" ]

[ "Print", "the", "information", "about", "the", "frv", "stack", "offsets", ",", "etc", ".", "when", "debugging", "." ]

[ "frv", "\"\\nStack information for function %s:\\n\"", "\"<unknown>\"", "\"\\ttotal_size\\t= %6d\\n\"", "\"\\tvars_size\\t= %6d\\n\"", "\"\\tparam_size\\t= %6d\\n\"", "\"\\tregs_size\\t= %6d, 1w = %3d, 2w = %3d\\n\"", "\"\\theader_size\\t= %6d\\n\"", "\"\\tpretend_size\\t= %6d\\n\"", "\"\\tvars_offset\\t= %6d\\n\"", "\"\\tregs_offset\\t= %6d\\n\"", "0", "0", "\"\\t%s\\tsize\\t= %6d, 1w = %3d, 2w = %3d, save =\"", "\" %s (%d)\"", "\" %s-%s (%d)\"", "1" ]

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "Register", "GlobalBaseReg", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "getGlobalBaseReg", "(", "*", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Atom pad short functions\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Atom pad short functions\"" ]

[]

[ "<s>", "bool", "loongarch_base_index_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "struct", "loongarch_address_info", "addr", ";", "return", "(", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG_REG", "&&", "REG_P", "(", "addr", ".", "offset", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "address", "with", "base", "and", "index", ".", "MODE", "is", "the", "mode", "of", "the", "value", "being", "accessed", "." ]

[ "loongarch" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "bool", "CanImplicitFloat", "=", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "bool", "CanUseNEON", "=", "Subtarget", "->", "hasNEON", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "CanUseFP", "=", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "IsSmallMemset", "=", "Op", ".", "isMemset", "(", ")", "&&", "Op", ".", "size", "(", ")", "<", "32", ";", "auto", "AlignmentIsAcceptable", "=", "[", "&", "]", "(", "EVT", "VT", ",", "Align", "AlignCheck", ")", "{", "if", "(", "Op", ".", "isAligned", "(", "AlignCheck", ")", ")", "return", "true", ";", "bool", "Fast", ";", "return", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "0", ",", "Align", "(", "1", ")", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", ";", "if", "(", "CanUseNEON", "&&", "Op", ".", "isMemset", "(", ")", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "v2i64", ",", "Align", "(", "16", ")", ")", ")", "return", "MVT", "::", "v2i64", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "Align", "(", "16", ")", ")", ")", "return", "MVT", "::", "f128", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "Align", "(", "8", ")", ")", ")", "return", "MVT", "::", "i64", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "Align", "(", "4", ")", ")", ")", "return", "MVT", "::", "i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "AArch64", "AArch64", "32", "0", "1", "MVT::v2i64", "16", "MVT::v2i64", "MVT::f128", "16", "MVT::f128", "8", "MVT::i64", "8", "MVT::i64", "4", "MVT::i32", "4", "MVT::i32", "MVT::Other" ]

[]

[ "<s>", "static", "void", "register_builtin_type", "(", "vector_type_index", "type", ",", "tree", "eltype", ",", "machine_mode", "mode", ")", "{", "builtin_types", "[", "type", "]", ".", "scalar", "=", "eltype", ";", "builtin_types", "[", "type", "]", ".", "scalar_ptr", "=", "build_pointer_type", "(", "eltype", ")", ";", "builtin_types", "[", "type", "]", ".", "scalar_const_ptr", "=", "build_const_pointer", "(", "eltype", ")", ";", "if", "(", "!", "riscv_v_ext_vector_mode_p", "(", "mode", ")", ")", "return", ";", "tree", "vectype", "=", "build_vector_type_for_mode", "(", "eltype", ",", "mode", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "TYPE_MODE", "(", "vectype", ")", ")", "&&", "TYPE_MODE", "(", "vectype", ")", "==", "mode", "&&", "TYPE_MODE_RAW", "(", "vectype", ")", "==", "mode", "&&", "TYPE_ALIGN", "(", "vectype", ")", "<=", "128", "&&", "known_eq", "(", "tree_to_poly_uint64", "(", "TYPE_SIZE", "(", "vectype", ")", ")", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ")", ")", ";", "vectype", "=", "build_distinct_type_copy", "(", "vectype", ")", ";", "gcc_assert", "(", "vectype", "==", "TYPE_MAIN_VARIANT", "(", "vectype", ")", ")", ";", "SET_TYPE_STRUCTURAL_EQUALITY", "(", "vectype", ")", ";", "TYPE_ARTIFICIAL", "(", "vectype", ")", "=", "1", ";", "TYPE_INDIVISIBLE_P", "(", "vectype", ")", "=", "1", ";", "add_vector_type_attribute", "(", "vectype", ",", "vector_types", "[", "type", "]", ".", "mangled_name", ")", ";", "make_type_sizeless", "(", "vectype", ")", ";", "abi_vector_types", "[", "type", "]", "=", "vectype", ";", "lang_hooks", ".", "types", ".", "register_builtin_type", "(", "vectype", ",", "vector_types", "[", "type", "]", ".", "abi_name", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "register", "a", "single", "built-in", "RVV", "ABI", "type", "." ]

[ "riscv", "128", "1", "1" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "auto", "&", "HST", "=", "static_cast", "<", "const", "HexagonSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "MachineBasicBlock", "*", "PrologB", "=", "&", "MF", ".", "front", "(", ")", ",", "*", "EpilogB", "=", "nullptr", ";", "if", "(", "EnableShrinkWrapping", ")", "findShrunkPrologEpilog", "(", "MF", ",", "PrologB", ",", "EpilogB", ")", ";", "bool", "PrologueStubs", "=", "false", ";", "insertCSRSpillsInBlock", "(", "*", "PrologB", ",", "CSI", ",", "HRI", ",", "PrologueStubs", ")", ";", "insertPrologueInBlock", "(", "*", "PrologB", ",", "PrologueStubs", ")", ";", "if", "(", "EpilogB", ")", "{", "insertCSRRestoresInBlock", "(", "*", "EpilogB", ",", "CSI", ",", "HRI", ")", ";", "insertEpilogueInBlock", "(", "*", "EpilogB", ")", ";", "}", "else", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "isReturnBlock", "(", ")", ")", "insertCSRRestoresInBlock", "(", "B", ",", "CSI", ",", "HRI", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "isReturnBlock", "(", ")", ")", "insertEpilogueInBlock", "(", "B", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "{", "if", "(", "B", ".", "empty", "(", ")", ")", "continue", ";", "MachineInstr", "*", "RetI", "=", "getReturn", "(", "B", ")", ";", "if", "(", "!", "RetI", "||", "isRestoreCall", "(", "RetI", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "&", "R", ":", "CSI", ")", "RetI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "R", ".", "getReg", "(", ")", ",", "false", ",", "true", ")", ")", ";", "}", "}", "if", "(", "EpilogB", ")", "{", "unsigned", "MaxBN", "=", "0", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "if", "(", "B", ".", "getNumber", "(", ")", ">=", "0", ")", "MaxBN", "=", "std", "::", "max", "(", "MaxBN", ",", "unsigned", "(", "B", ".", "getNumber", "(", ")", ")", ")", ";", "BitVector", "DoneT", "(", "MaxBN", "+", "1", ")", ",", "DoneF", "(", "MaxBN", "+", "1", ")", ",", "Path", "(", "MaxBN", "+", "1", ")", ";", "updateExitPaths", "(", "*", "EpilogB", ",", "EpilogB", ",", "DoneT", ",", "DoneF", ",", "Path", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "rs6000_got_register", "(", "rtx", "value", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "no_new_pseudos", "&&", "!", "regs_ever_live", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", ")", "regs_ever_live", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "current_function_uses_pic_offset_table", "=", "1", ";", "return", "pic_offset_table_rtx", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "visium_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "cumulative_args_t", "local_args_so_far", ";", "CUMULATIVE_ARGS", "local_copy", ";", "CUMULATIVE_ARGS", "*", "locargs", ";", "int", "gp_saved", ",", "fp_saved", ",", "size", ";", "local_args_so_far", ".", "p", "=", "&", "local_copy", ";", "locargs", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "local_args_so_far", ".", "magic", "=", "CUMULATIVE_ARGS_MAGIC", ";", "local_copy", ".", "grcount", "=", "locargs", "->", "grcount", ";", "local_copy", ".", "frcount", "=", "locargs", "->", "frcount", ";", "local_copy", ".", "stack_words", "=", "locargs", "->", "stack_words", ";", "TARGET_FUNCTION_ARG_ADVANCE", "(", "local_args_so_far", ",", "mode", ",", "type", ",", "1", ")", ";", "locargs", "=", "get_cumulative_args", "(", "local_args_so_far", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_GP_REGISTERS", "-", "locargs", "->", "grcount", ";", "fp_saved", "=", "(", "TARGET_FPU", "?", "MAX_ARGS_IN_FP_REGISTERS", "-", "locargs", "->", "frcount", ":", "0", ")", ";", "size", "=", "(", "gp_saved", "*", "UNITS_PER_WORD", ")", "+", "(", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ";", "if", "(", "!", "no_rtl", "&&", "size", ">", "0", ")", "{", "rtx", "ptr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "size", ")", ")", ";", "if", "(", "gp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "ptr", ",", "fp_saved", "*", "UNITS_PER_HWFPVALUE", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "locargs", "->", "grcount", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "fp_saved", ">", "0", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "gcc_assert", "(", "UNITS_PER_WORD", "==", "UNITS_PER_HWFPVALUE", ")", ";", "move_block_from_reg", "(", "locargs", "->", "frcount", "+", "FP_ARG_FIRST", ",", "mem", ",", "fp_saved", ")", ";", "}", "}", "visium_reg_parm_save_area_size", "=", "size", ";", "}", "</s>" ]

[ "Store", "the", "anonymous", "register", "arguments", "into", "the", "stack", "so", "that", "all", "the", "arguments", "appear", "to", "have", "been", "passed", "consecutively", "on", "the", "stack", "." ]

[ "visium", "1", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isLoadBitCastBeneficial", "(", "EVT", "LoadTy", ",", "EVT", "CastTy", ")", "const", "{", "if", "(", "LoadTy", ".", "getSizeInBits", "(", ")", "!=", "CastTy", ".", "getSizeInBits", "(", ")", ")", "return", "true", ";", "unsigned", "LScalarSize", "=", "LoadTy", ".", "getScalarType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "unsigned", "CastScalarSize", "=", "CastTy", ".", "getScalarType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "return", "(", "(", "LScalarSize", "<=", "CastScalarSize", ")", "||", "(", "CastScalarSize", ">=", "32", ")", "||", "(", "LScalarSize", "<", "32", ")", ")", ";", "}", "</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", "." ]

[ "R600", "32", "32" ]

[]