Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "char", "*", "cr16_prepare_push_pop_string", "(", "int", "push_or_pop", ")", "{", "static", "char", "one_inst_str", "[", "50", "]", ";", "int", "i", ",", "start_reg", ";", "int", "word_cnt", ";", "int", "print_ra", ";", "char", "*", "return_str", ";", "char", "*", "temp_str", ";", "return_str", "=", "(", "char", "*", ")", "xmalloc", "(", "160", ")", ";", "temp_str", "=", "(", "char", "*", ")", "xmalloc", "(", "160", ")", ";", "memset", "(", "return_str", ",", "0", ",", "3", ")", ";", "i", "=", "0", ";", "while", "(", "i", "<=", "current_frame_info", ".", "last_reg_to_save", ")", "{", "one_inst_str", "[", "0", "]", "=", "0", ";", "word_cnt", "=", "0", ";", "start_reg", "=", "i", ";", "print_ra", "=", "0", ";", "while", "(", "(", "word_cnt", "<", "MAX_COUNT", ")", "&&", "(", "i", "<=", "current_frame_info", ".", "last_reg_to_save", ")", ")", "{", "if", "(", "!", "current_frame_info", ".", "save_regs", "[", "i", "]", ")", "{", "++", "i", ";", "break", ";", "}", "if", "(", "i", "==", "RETURN_ADDRESS_REGNUM", ")", "print_ra", "=", "1", ";", "else", "{", "if", "(", "(", "word_cnt", "+", "(", "(", "i", "<", "CR16_FIRST_DWORD_REGISTER", ")", "?", "1", ":", "2", ")", ")", ">=", "MAX_COUNT", ")", "break", ";", "word_cnt", "+=", "(", "(", "i", "<", "CR16_FIRST_DWORD_REGISTER", ")", "?", "1", ":", "2", ")", ";", "}", "++", "i", ";", "}", "if", "(", "(", "word_cnt", "==", "0", ")", "&&", "(", "print_ra", "==", "0", ")", ")", "continue", ";", "if", "(", "word_cnt", ">", "0", ")", "{", "sprintf", "(", "one_inst_str", ",", "\"$%d, %s\"", ",", "word_cnt", ",", "reg_names", "[", "start_reg", "]", ")", ";", "if", "(", "print_ra", ")", "strcat", "(", "one_inst_str", ",", "\", ra\"", ")", ";", "}", "else", "strcat", "(", "one_inst_str", ",", "\"ra\"", ")", ";", "if", "(", "push_or_pop", "==", "1", ")", "{", "if", "(", "print_ra", "&&", "!", "cr16_interrupt_function_p", "(", ")", "&&", "!", "crtl", "->", "calls_eh_return", ")", "strcpy", "(", "temp_str", ",", "\"\\n\\tpopret\\t\"", ")", ";", "else", "strcpy", "(", "temp_str", ",", "\"\\n\\tpop\\t\"", ")", ";", "strcat", "(", "temp_str", ",", "one_inst_str", ")", ";", "strcat", "(", "return_str", ",", "temp_str", ")", ";", "}", "else", "{", "strcpy", "(", "temp_str", ",", "\"\\n\\tpush\\t\"", ")", ";", "strcat", "(", "temp_str", ",", "one_inst_str", ")", ";", "strcat", "(", "temp_str", ",", "return_str", ")", ";", "strcpy", "(", "return_str", ",", "temp_str", ")", ";", "}", "}", "if", "(", "push_or_pop", "==", "1", ")", "{", "if", "(", "cr16_interrupt_function_p", "(", ")", ")", "strcat", "(", "return_str", ",", "\"\\n\\tretx\\n\"", ")", ";", "else", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "strcat", "(", "return_str", ",", "\"\\n\\taddd\\t (r5, r4), (sp)\\t\\n\"", ")", ";", "strcat", "(", "return_str", ",", "\"\\n\\tjump\\t (ra)\\n\"", ")", ";", "strcpy", "(", "temp_str", ",", "\"\\n\\tsubd\\t (r5, r4), (sp)\\t\\n\"", ")", ";", "strcat", "(", "temp_str", ",", "return_str", ")", ";", "strcpy", "(", "return_str", ",", "temp_str", ")", ";", "}", "else", "if", "(", "!", "FUNC_IS_NORETURN_P", "(", "current_function_decl", ")", "&&", "!", "(", "current_frame_info", ".", "save_regs", "[", "RETURN_ADDRESS_REGNUM", "]", ")", ")", "strcat", "(", "return_str", ",", "\"\\n\\tjump\\t (ra)\\n\"", ")", ";", "}", "return_str", "+=", "2", ";", "return", "return_str", ";", "}", "</s>" ]

[ "Called", "from", "cr16.md", ".", "The", "return", "value", "depends", "on", "the", "parameter", "push_or_pop", ":", "When", "push_or_pop", "is", "zero", "-", ">", "string", "for", "push", "instructions", "of", "prologue", ".", "When", "push_or_pop", "is", "nonzero", "-", ">", "string", "for", "pop/popret/retx", "in", "epilogue", ".", "Relies", "on", "the", "assumptions", ":", "1", ".", "RA", "is", "the", "last", "register", "to", "be", "saved", ".", "2", ".", "The", "maximal", "value", "of", "the", "counter", "is", "MAX_COUNT", "." ]

[ "cr16", "50", "160", "160", "0", "3", "0", "0", "0", "0", "0", "1", "1", "2", "1", "2", "0", "0", "0", "\"$%d, %s\"", "\", ra\"", "\"ra\"", "1", "\"\\n\\tpopret\\t\"", "\"\\n\\tpop\\t\"", "\"\\n\\tpush\\t\"", "1", "\"\\n\\tretx\\n\"", "\"\\n\\taddd\\t (r5, r4), (sp)\\t\\n\"", "\"\\n\\tjump\\t (ra)\\n\"", "\"\\n\\tsubd\\t (r5, r4), (sp)\\t\\n\"", "\"\\n\\tjump\\t (ra)\\n\"", "2" ]

[]

[ "<s>", "bool", "M680x0InstrInfo", "::", "ExpandCCR", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "isToCCR", ")", "const", "{", "if", "(", "isToCCR", ")", "{", "MIB", "->", "setDesc", "(", "get", "(", "M680x0", "::", "MOV16cd", ")", ")", ";", "}", "else", "{", "MIB", "->", "setDesc", "(", "get", "(", "M680x0", "::", "MOV16dc", ")", ")", ";", "}", "auto", "&", "Opd", "=", "MIB", "->", "getOperand", "(", "1", ")", ";", "Opd", ".", "setReg", "(", "getRegisterInfo", "(", ")", ".", "getMatchingSuperReg", "(", "Opd", ".", "getReg", "(", ")", ",", "M680x0", "::", "MxSubRegIndex8Lo", ",", "&", "M680x0", "::", "DR16RegClass", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Moves", "to/from", "CCR", "." ]

[ "M680x0", "M680x0", "M680x0::MOV16cd", "M680x0::MOV16dc", "1", "M680x0::MxSubRegIndex8Lo", "M680x0::DR16RegClass" ]

[]

[ "<s>", "static", "bool", "ix86_use_mask_cmp_p", "(", "machine_mode", "mode", ",", "machine_mode", "cmp_mode", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "int", "vector_size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "cmp_mode", "==", "HFmode", ")", "return", "true", ";", "else", "if", "(", "vector_size", "<", "16", ")", "return", "false", ";", "else", "if", "(", "vector_size", "==", "64", ")", "return", "true", ";", "else", "if", "(", "GET_MODE_INNER", "(", "cmp_mode", ")", "==", "HFmode", ")", "return", "true", ";", "gcc_assert", "(", "!", "op_true", "==", "!", "op_false", ")", ";", "if", "(", "!", "op_true", "||", "!", "ix86_valid_mask_cmp_mode", "(", "cmp_mode", ")", ")", "return", "false", ";", "if", "(", "op_false", "==", "CONST0_RTX", "(", "mode", ")", "||", "op_true", "==", "CONST0_RTX", "(", "mode", ")", "||", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "(", "op_true", "==", "CONSTM1_RTX", "(", "mode", ")", "||", "op_false", "==", "CONSTM1_RTX", "(", "mode", ")", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "mask", "comparison", "should", "be", "used", "." ]

[ "i386", "16", "64" ]

[]

[ "<s>", "void", "arc_expand_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "orig_before", ",", "rtx", "orig_after", ",", "rtx", "model_rtx", ")", "{", "enum", "memmodel", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "model_rtx", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", ";", "rtx", "before", "=", "orig_before", ",", "after", "=", "orig_after", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "arc_pre_atomic_barrier", "(", "model", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL_RTX", ")", "before", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "after", "==", "NULL_RTX", ")", "after", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_arc_load_exclusivesi", "(", "before", ",", "mem", ")", ")", ";", "switch", "(", "code", ")", "{", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "after", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "val", ")", ")", "{", "val", "=", "GEN_INT", "(", "-", "INTVAL", "(", "val", ")", ")", ";", "code", "=", "PLUS", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "after", ",", "x", ")", ")", ";", "break", ";", "}", "emit_insn", "(", "gen_arc_store_exclusivesi", "(", "mem", ",", "after", ")", ")", ";", "cond", "=", "gen_rtx_REG", "(", "CC_Zmode", ",", "CC_REG", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "label", ",", "pc_rtx", ")", ";", "emit_unlikely_jump", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "arc_post_atomic_barrier", "(", "model", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "fetch-and-operate", "pattern", ".", "CODE", "is", "the", "binary", "operation", "to", "perform", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "VAL", "is", "the", "second", "operand", "of", "the", "binary", "operator", ".", "BEFORE", "and", "AFTER", "are", "optional", "locations", "to", "return", "the", "value", "of", "MEM", "either", "before", "of", "after", "the", "operation", ".", "MODEL_RTX", "is", "a", "CONST_INT", "containing", "the", "memory", "model", "to", "use", "." ]

[ "arc" ]

[]

[ "<s>", "void", "M680x0InstrInfo", "::", "AddZExt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "Reg", ",", "MVT", "From", ",", "MVT", "To", ")", "const", "{", "unsigned", "Mask", ",", "And", ";", "if", "(", "From", "==", "MVT", "::", "i8", ")", "{", "Mask", "=", "0xFF", ";", "}", "else", "{", "Mask", "=", "0xFFFF", ";", "}", "if", "(", "To", "==", "MVT", "::", "i16", ")", "{", "And", "=", "M680x0", "::", "AND16di", ";", "}", "else", "{", "And", "=", "M680x0", "::", "AND32di", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "And", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ")", ".", "addImm", "(", "Mask", ")", ";", "}", "</s>" ]

[ "Add", "appropriate", "ZExt", "nodes", "." ]

[ "M680x0", "M680x0", "MVT::i8", "0xFF", "0xFFFF", "MVT::i16", "M680x0::AND16di", "M680x0::AND32di" ]

[]

[ "<s>", "static", "bool", "ix86_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SSE", "&&", "VALID_SSE_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_SSE2", "&&", "VALID_SSE2_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX", "&&", "VALID_AVX256_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX512F", "&&", "VALID_AVX512F_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_MMX", "||", "TARGET_MMX_WITH_SSE", ")", "&&", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_3DNOW", "||", "TARGET_MMX_WITH_SSE", ")", "&&", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "i386" ]

[]

[ "<s>", "bool", "PPCLoopPreIncPrep", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "auto", "*", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "ST", "=", "TM", "?", "TM", "->", "getSubtargetImpl", "(", "F", ")", ":", "nullptr", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "moveFlatAddrToVGPR", "(", "MachineInstr", "&", "Inst", ")", "const", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "int", "OldSAddrIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "saddr", ")", ";", "if", "(", "OldSAddrIdx", "<", "0", ")", "return", "false", ";", "assert", "(", "isSegmentSpecificFLAT", "(", "Inst", ")", ")", ";", "int", "NewOpc", "=", "AMDGPU", "::", "getGlobalVaddrOp", "(", "Opc", ")", ";", "if", "(", "NewOpc", "<", "0", ")", "NewOpc", "=", "AMDGPU", "::", "getFlatScratchInstSVfromSS", "(", "Opc", ")", ";", "if", "(", "NewOpc", "<", "0", ")", "return", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "Inst", ".", "getMF", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineOperand", "&", "SAddr", "=", "Inst", ".", "getOperand", "(", "OldSAddrIdx", ")", ";", "if", "(", "RI", ".", "isSGPRReg", "(", "MRI", ",", "SAddr", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "int", "NewVAddrIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "NewOpc", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "if", "(", "NewVAddrIdx", "<", "0", ")", "return", "false", ";", "int", "OldVAddrIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "MachineInstr", "*", "VAddrDef", "=", "nullptr", ";", "if", "(", "OldVAddrIdx", ">=", "0", ")", "{", "MachineOperand", "&", "VAddr", "=", "Inst", ".", "getOperand", "(", "OldVAddrIdx", ")", ";", "VAddrDef", "=", "MRI", ".", "getUniqueVRegDef", "(", "VAddr", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "VAddrDef", "||", "VAddrDef", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_MOV_B32_e32", "||", "!", "VAddrDef", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "||", "VAddrDef", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "!=", "0", ")", "return", "false", ";", "}", "const", "MCInstrDesc", "&", "NewDesc", "=", "get", "(", "NewOpc", ")", ";", "Inst", ".", "setDesc", "(", "NewDesc", ")", ";", "if", "(", "OldVAddrIdx", "==", "NewVAddrIdx", ")", "{", "MachineOperand", "&", "NewVAddr", "=", "Inst", ".", "getOperand", "(", "NewVAddrIdx", ")", ";", "MRI", ".", "removeRegOperandFromUseList", "(", "&", "NewVAddr", ")", ";", "MRI", ".", "moveOperands", "(", "&", "NewVAddr", ",", "&", "SAddr", ",", "1", ")", ";", "Inst", ".", "removeOperand", "(", "OldSAddrIdx", ")", ";", "MRI", ".", "removeRegOperandFromUseList", "(", "&", "NewVAddr", ")", ";", "MRI", ".", "addRegOperandToUseList", "(", "&", "NewVAddr", ")", ";", "}", "else", "{", "assert", "(", "OldSAddrIdx", "==", "NewVAddrIdx", ")", ";", "if", "(", "OldVAddrIdx", ">=", "0", ")", "{", "int", "NewVDstIn", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "NewOpc", ",", "AMDGPU", "::", "OpName", "::", "vdst_in", ")", ";", "if", "(", "NewVDstIn", "!=", "-", "1", ")", "{", "int", "OldVDstIn", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "vdst_in", ")", ";", "Inst", ".", "untieRegOperand", "(", "OldVDstIn", ")", ";", "}", "Inst", ".", "removeOperand", "(", "OldVAddrIdx", ")", ";", "if", "(", "NewVDstIn", "!=", "-", "1", ")", "{", "int", "NewVDst", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "NewOpc", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "Inst", ".", "tieOperands", "(", "NewVDst", ",", "NewVDstIn", ")", ";", "}", "}", "}", "if", "(", "VAddrDef", "&&", "MRI", ".", "use_nodbg_empty", "(", "VAddrDef", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "VAddrDef", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Change", "SADDR", "form", "of", "a", "FLAT", "Inst", "to", "its", "VADDR", "form", "if", "saddr", "operand", "was", "moved", "to", "VGPR", "." ]

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "AMDGPU::getGlobalVaddrOp", "0", "AMDGPU::getFlatScratchInstSVfromSS", "0", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0", "AMDGPU::V_MOV_B32_e32", "1", "1", "0", "1", "0", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "0" ]

[]

[ "<s>", "static", "void", "nvptx_option_override", "(", "void", ")", "{", "init_machine_status", "=", "nvptx_init_machine_status", ";", "if", "(", "!", "global_options_set", ".", "x_flag_toplevel_reorder", ")", "flag_toplevel_reorder", "=", "1", ";", "debug_nonbind_markers_p", "=", "0", ";", "if", "(", "!", "global_options_set", ".", "x_flag_no_common", ")", "flag_no_common", "=", "1", ";", "if", "(", "function_entry_patch_area_size", ">", "0", ")", "sorry", "(", "\"not generating patch area, nops not supported\"", ")", ";", "flag_var_tracking", "=", "0", ";", "if", "(", "nvptx_optimize", "<", "0", ")", "nvptx_optimize", "=", "optimize", ">", "0", ";", "declared_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "needed_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "declared_libfuncs_htab", "=", "hash_table", "<", "declared_libfunc_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "worker_bcast_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__worker_bcast\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "worker_bcast_sym", ",", "DATA_AREA_SHARED", ")", ";", "worker_bcast_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "worker_red_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__worker_red\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "worker_red_sym", ",", "DATA_AREA_SHARED", ")", ";", "worker_red_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "diagnose_openacc_conflict", "(", "TARGET_GOMP", ",", "\"-mgomp\"", ")", ";", "diagnose_openacc_conflict", "(", "TARGET_SOFT_STACK", ",", "\"-msoft-stack\"", ")", ";", "diagnose_openacc_conflict", "(", "TARGET_UNIFORM_SIMT", ",", "\"-muniform-simt\"", ")", ";", "if", "(", "TARGET_GOMP", ")", "target_flags", "|=", "MASK_SOFT_STACK", "|", "MASK_UNIFORM_SIMT", ";", "}", "</s>" ]

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

[ "nvptx", "1", "0", "1", "0", "\"not generating patch area, nops not supported\"", "0", "0", "0", "17", "17", "17", "\"__worker_bcast\"", "\"__worker_red\"", "\"-mgomp\"", "\"-msoft-stack\"", "\"-muniform-simt\"" ]

[]

[ "<s>", "static", "bool", "rs6000_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_PAIRED_FLOAT", "&&", "PAIRED_VECTOR_MODE", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", "&&", "!", "FLOAT128_IEEE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Target", "hook", "for", "vector_mode_supported_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Call Graph Builder\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Call Graph Builder\"" ]

[]

[ "<s>", "static", "void", "nios2_dump_frame_layout", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"\\t%s Current Frame Info\\n\"", ",", "ASM_COMMENT_START", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s total_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "total_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s var_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "var_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s args_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "args_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s save_reg_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "save_reg_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s initialized = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "initialized", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s save_regs_offset = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "save_regs_offset", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s is_leaf = %d\\n\"", ",", "ASM_COMMENT_START", ",", "crtl", "->", "is_leaf", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s frame_pointer_needed = %d\\n\"", ",", "ASM_COMMENT_START", ",", "frame_pointer_needed", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s pretend_args_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "}", "</s>" ]

[ "Dump", "stack", "layout", "." ]

[ "nios2", "\"\\t%s Current Frame Info\\n\"", "\"\\t%s total_size = %d\\n\"", "\"\\t%s var_size = %d\\n\"", "\"\\t%s args_size = %d\\n\"", "\"\\t%s save_reg_size = %d\\n\"", "\"\\t%s initialized = %d\\n\"", "\"\\t%s save_regs_offset = %d\\n\"", "\"\\t%s is_leaf = %d\\n\"", "\"\\t%s frame_pointer_needed = %d\\n\"", "\"\\t%s pretend_args_size = %d\\n\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MipsRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "MipsABIInfo", "ABI", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "getABI", "(", ")", ";", "return", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "void", "BitcodeWriter", "::", "copyStrtab", "(", "StringRef", "Strtab", ")", "{", "writeBlob", "(", "bitc", "::", "STRTAB_BLOCK_ID", ",", "bitc", "::", "STRTAB_BLOB", ",", "Strtab", ")", ";", "WroteStrtab", "=", "true", ";", "}", "</s>" ]

[ "Copy", "the", "string", "table", "for", "another", "module", "into", "this", "bitcode", "file", "." ]

[ "DirectX" ]

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "STI", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "AttributeSet", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "OptimizeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "MinimizeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "::", "rpo_iterator", "I", "=", "RPOT", ".", "begin", "(", ")", ",", "E", "=", "RPOT", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "NVPTXImageOptimizer", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "InstrToDelete", ".", "clear", "(", ")", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "Instr", ":", "BB", ")", "{", "if", "(", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "Instr", ")", ")", "{", "Function", "*", "CalledF", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "CalledF", "&&", "CalledF", "->", "isIntrinsic", "(", ")", ")", "{", "switch", "(", "CalledF", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_sampler", ":", "Changed", "|=", "replaceIsTypePSampler", "(", "Instr", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_surface", ":", "Changed", "|=", "replaceIsTypePSurface", "(", "Instr", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_texture", ":", "Changed", "|=", "replaceIsTypePTexture", "(", "Instr", ")", ";", "break", ";", "}", "}", "}", "}", "}", "for", "(", "Instruction", "*", "I", ":", "InstrToDelete", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "Intrinsic::nvvm_istypep_sampler", "Intrinsic::nvvm_istypep_surface", "Intrinsic::nvvm_istypep_texture" ]

[]

[ "<s>", "int", "flags_in_68881", "(", "void", ")", "{", "return", "cc_status", ".", "flags", "&", "CC_IN_68881", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "flags", "are", "currently", "in", "the", "68881", "flag", "register", "." ]

[ "m68k" ]

[]

[ "<s>", "unsigned", "FISCMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"unknown operand kind in printOperand\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "if", "(", "Kind", "==", "MCExpr", "::", "Constant", ")", "return", "cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", "->", "getValue", "(", ")", ";", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "unsigned", "FixupKind", ";", "unsigned", "VKind", "=", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ";", "switch", "(", "VKind", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "return", "0", ";", "default", ":", "{", "std", "::", "string", "msg", "=", "\"Unknown fixup kind! (\"", "+", "std", "::", "to_string", "(", "VKind", ")", "+", "\")\"", ";", "llvm_unreachable", "(", "msg", ".", "c_str", "(", ")", ")", ";", "}", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q1", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q1_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q2", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q2_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q3", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q3_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_Q4", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_mov_q4_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_CALL26", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_call26_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_CALL19", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_call19_pcrel", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_9BIT", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_9bit_address", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_6BIT", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_6bit_shamt", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_12BIT", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_12bit_imm", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_FISC_MOVRZ", ":", "FixupKind", "=", "FISC", "::", "fixup_fisc_movrz_pcrel", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "MO", ".", "getExpr", "(", ")", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "FISC", "FISC", "\"unknown operand kind in printOperand\"", "0", "\"Unknown fixup kind! (\"", "\")\"", "FISC", "FISC::fixup_fisc_mov_q1_pcrel", "FISC", "FISC::fixup_fisc_mov_q2_pcrel", "FISC", "FISC::fixup_fisc_mov_q3_pcrel", "FISC", "FISC::fixup_fisc_mov_q4_pcrel", "FISC", "FISC::fixup_fisc_call26_pcrel", "FISC", "FISC::fixup_fisc_call19_pcrel", "FISC", "FISC::fixup_fisc_9bit_address", "FISC", "FISC::fixup_fisc_6bit_shamt", "FISC", "FISC::fixup_fisc_12bit_imm", "FISC", "FISC::fixup_fisc_movrz_pcrel", "0", "0" ]

[]

[ "<s>", "static", "inline", "bool", "rs6000_builtin_type_compatible", "(", "tree", "t", ",", "int", "id", ")", "{", "tree", "builtin_type", ";", "builtin_type", "=", "rs6000_builtin_type", "(", "id", ")", ";", "if", "(", "t", "==", "error_mark_node", ")", "return", "false", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "t", ")", "&&", "INTEGRAL_TYPE_P", "(", "builtin_type", ")", ")", "return", "true", ";", "else", "return", "lang_hooks", ".", "types_compatible_p", "(", "t", ",", "builtin_type", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "ARGTYPE", "can", "be", "compatibly", "passed", "as", "PARMTYPE", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "FDivFunc", "=", "findFunction", "(", "M", ",", "\"__fdiv\"", ")", ";", "FRemFunc", "=", "findFunction", "(", "M", ",", "\"__frem\"", ")", ";", "UDivFunc", "=", "findFunction", "(", "M", ",", "\"__udiv\"", ")", ";", "URemFunc", "=", "findFunction", "(", "M", ",", "\"__urem\"", ")", ";", "SDivFunc", "=", "findFunction", "(", "M", ",", "\"__sdiv\"", ")", ";", "SRemFunc", "=", "findFunction", "(", "M", ",", "\"__srem\"", ")", ";", "if", "(", "FDivFunc", ")", "FDivFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";", "if", "(", "FRemFunc", ")", "FRemFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";", "if", "(", "UDivFunc", ")", "UDivFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";", "if", "(", "URemFunc", ")", "URemFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";", "if", "(", "SDivFunc", ")", "SDivFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";", "if", "(", "SRemFunc", ")", "SRemFunc", "->", "setUnnamedAddr", "(", "GlobalValue", "::", "UnnamedAddr", "::", "Local", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TPC", "\"__fdiv\"", "\"__frem\"", "\"__udiv\"", "\"__urem\"", "\"__sdiv\"", "\"__srem\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lanai SET_FLAG ALU combiner pass\"", ";", "}", "</s>" ]

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

[ "Lanai", "\"Lanai SET_FLAG ALU combiner pass\"" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "LiveRangeShrinkID", ")", ";", "addPass", "(", "createX86FixupSetCC", "(", ")", ")", ";", "addPass", "(", "createX86OptimizeLEAs", "(", ")", ")", ";", "addPass", "(", "createX86CallFrameOptimization", "(", ")", ")", ";", "addPass", "(", "createX86AvoidStoreForwardingBlocks", "(", ")", ")", ";", "}", "addPass", "(", "createX86FlagsCopyLoweringPass", "(", ")", ")", ";", "addPass", "(", "createX86WinAllocaExpander", "(", ")", ")", ";", "addPass", "(", "createSandBoxingPreRegallocPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "dispatch_function_versions", "(", "tree", "dispatch_decl", ",", "void", "*", "fndecls_p", ",", "basic_block", "*", "empty_bb", ")", "{", "tree", "default_decl", ";", "gimple", "*", "ifunc_cpu_init_stmt", ";", "gimple_seq", "gseq", ";", "int", "ix", ";", "tree", "ele", ";", "vec", "<", "tree", ">", "*", "fndecls", ";", "unsigned", "int", "num_versions", "=", "0", ";", "unsigned", "int", "actual_versions", "=", "0", ";", "unsigned", "int", "i", ";", "struct", "_function_version_info", "{", "tree", "version_decl", ";", "tree", "predicate_chain", ";", "unsigned", "int", "dispatch_priority", ";", "}", "*", "function_version_info", ";", "gcc_assert", "(", "dispatch_decl", "!=", "NULL", "&&", "fndecls_p", "!=", "NULL", "&&", "empty_bb", "!=", "NULL", ")", ";", "fndecls", "=", "static_cast", "<", "vec", "<", "tree", ">", "*", ">", "(", "fndecls_p", ")", ";", "num_versions", "=", "fndecls", "->", "length", "(", ")", ";", "gcc_assert", "(", "num_versions", ">=", "2", ")", ";", "function_version_info", "=", "(", "struct", "_function_version_info", "*", ")", "XNEWVEC", "(", "struct", "_function_version_info", ",", "(", "num_versions", "-", "1", ")", ")", ";", "default_decl", "=", "(", "*", "fndecls", ")", "[", "0", "]", ";", "push_cfun", "(", "DECL_STRUCT_FUNCTION", "(", "dispatch_decl", ")", ")", ";", "gseq", "=", "bb_seq", "(", "*", "empty_bb", ")", ";", "ifunc_cpu_init_stmt", "=", "gimple_build_call_vec", "(", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_CPU_INIT", "]", ",", "vNULL", ")", ";", "gimple_seq_add_stmt", "(", "&", "gseq", ",", "ifunc_cpu_init_stmt", ")", ";", "gimple_set_bb", "(", "ifunc_cpu_init_stmt", ",", "*", "empty_bb", ")", ";", "set_bb_seq", "(", "*", "empty_bb", ",", "gseq", ")", ";", "pop_cfun", "(", ")", ";", "for", "(", "ix", "=", "1", ";", "fndecls", "->", "iterate", "(", "ix", ",", "&", "ele", ")", ";", "++", "ix", ")", "{", "tree", "version_decl", "=", "ele", ";", "tree", "predicate_chain", "=", "NULL_TREE", ";", "unsigned", "int", "priority", ";", "priority", "=", "get_builtin_code_for_version", "(", "version_decl", ",", "&", "predicate_chain", ")", ";", "if", "(", "predicate_chain", "==", "NULL_TREE", ")", "continue", ";", "function_version_info", "[", "actual_versions", "]", ".", "version_decl", "=", "version_decl", ";", "function_version_info", "[", "actual_versions", "]", ".", "predicate_chain", "=", "predicate_chain", ";", "function_version_info", "[", "actual_versions", "]", ".", "dispatch_priority", "=", "priority", ";", "actual_versions", "++", ";", "}", "qsort", "(", "function_version_info", ",", "actual_versions", ",", "sizeof", "(", "struct", "_function_version_info", ")", ",", "feature_compare", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "actual_versions", ";", "++", "i", ")", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "function_version_info", "[", "i", "]", ".", "version_decl", ",", "function_version_info", "[", "i", "]", ".", "predicate_chain", ",", "*", "empty_bb", ")", ";", "*", "empty_bb", "=", "add_condition_to_bb", "(", "dispatch_decl", ",", "default_decl", ",", "NULL", ",", "*", "empty_bb", ")", ";", "free", "(", "function_version_info", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "dispatch", "function", "for", "multi-versioned", "functions", ".", "DISPATCH_DECL", "is", "the", "function", "which", "will", "contain", "the", "dispatch", "logic", ".", "FNDECLS", "are", "the", "function", "choices", "for", "dispatch", ",", "and", "is", "a", "tree", "chain", ".", "EMPTY_BB", "is", "the", "basic", "block", "pointer", "in", "DISPATCH_DECL", "in", "which", "the", "dispatch", "code", "is", "generated", "." ]

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

[]

[ "<s>", "unsigned", "SPUTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "1", ";", "case", "ISD", "::", "SETCC", ":", "{", "MVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i32", ")", "{", "VT", "=", "MVT", "::", "i32", ";", "}", "return", "VT", ".", "getSizeInBits", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "CellSPU", "SPU", "1", "ISD::SETCC", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "!", "I", "->", "hasOneUse", "(", ")", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "if", "(", "User", "&&", "!", "(", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FSub", "||", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FAdd", ")", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "const", "DataLayout", "&", "DL", "=", "I", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "EVT", "VT", "=", "getValueType", "(", "DL", ",", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "return", "!", "(", "isFMAFasterThanFMulAndFAdd", "(", "VT", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "VT", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "AArch64", "AArch64", "0", "ISD::FMA" ]

[]

[ "<s>", "bool", "parse", "(", "cl", "::", "Option", "&", "O", ",", "StringRef", "ArgName", ",", "StringRef", "Arg", ",", "unsigned", "&", "Value", ")", "{", "if", "(", "Arg", ".", "getAsInteger", "(", "0", ",", "Value", ")", ")", "return", "O", ".", "error", "(", "\"'\"", "+", "Arg", "+", "\"' value invalid for uint argument!\"", ")", ";", "if", "(", "Value", ">", "100", ")", "return", "O", ".", "error", "(", "\"'\"", "+", "Arg", "+", "\"' value must be in the range [0, 100]!\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Parses", "just-constructed", "SpecialCaseList", "entries", "from", "a", "memory", "buffer", "." ]

[ "AMDGPU", "0", "\"'\"", "\"' value invalid for uint argument!\"", "100", "\"'\"", "\"' value must be in the range [0, 100]!\"" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "!", "CurrCycleInstr", ")", "return", ";", "if", "(", "CurrCycleInstr", "->", "isImplicitDef", "(", ")", "||", "CurrCycleInstr", "->", "isDebugInstr", "(", ")", "||", "CurrCycleInstr", "->", "isKill", "(", ")", ")", "return", ";", "if", "(", "CurrCycleInstr", "->", "isBundle", "(", ")", ")", "{", "processBundle", "(", ")", ";", "return", ";", "}", "unsigned", "NumWaitStates", "=", "TII", ".", "getNumWaitStates", "(", "*", "CurrCycleInstr", ")", ";", "EmittedInstrs", ".", "push_front", "(", "CurrCycleInstr", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "std", "::", "min", "(", "NumWaitStates", ",", "getMaxLookAhead", "(", ")", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "EmittedInstrs", ".", "resize", "(", "getMaxLookAhead", "(", ")", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "void", "WebAssemblyInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "llvm_unreachable", "(", "\"TODO: implement printInst\"", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"TODO: implement printInst\"" ]

[]

[ "<s>", "int", "riscv_split_const_insns", "(", "rtx", "x", ")", "{", "unsigned", "int", "low", ",", "high", ";", "low", "=", "riscv_const_insns", "(", "riscv_subword", "(", "x", ",", "false", ")", ")", ";", "high", "=", "riscv_const_insns", "(", "riscv_subword", "(", "x", ",", "true", ")", ")", ";", "gcc_assert", "(", "low", ">", "0", "&&", "high", ">", "0", ")", ";", "return", "low", "+", "high", ";", "}", "</s>" ]

[ "X", "is", "a", "doubleword", "constant", "that", "can", "be", "handled", "by", "splitting", "it", "into", "two", "words", "and", "loading", "each", "word", "separately", ".", "Return", "the", "number", "of", "instructions", "required", "to", "do", "this", "." ]

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

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\"\\n\"", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "switch", "(", "F", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Unknown linkage type!\"", ")", ";", "case", "Function", "::", "PrivateLinkage", ":", "case", "Function", "::", "InternalLinkage", ":", "SwitchToTextSection", "(", "\"\\t.text\"", ",", "F", ")", ";", "break", ";", "case", "Function", "::", "ExternalLinkage", ":", "SwitchToTextSection", "(", "\"\\t.text\"", ",", "F", ")", ";", "O", "<<", "\"\\t.globl\\t\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "break", ";", "case", "Function", "::", "WeakAnyLinkage", ":", "case", "Function", "::", "WeakODRLinkage", ":", "case", "Function", "::", "LinkOnceAnyLinkage", ":", "case", "Function", "::", "LinkOnceODRLinkage", ":", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "{", "SwitchToTextSection", "(", "\".section __TEXT,__textcoal_nt,coalesced,pure_instructions\"", ",", "F", ")", ";", "O", "<<", "\"\\t.globl\\t\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "O", "<<", "\"\\t.weak_definition\\t\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "}", "else", "{", "O", "<<", "TAI", "->", "getWeakRefDirective", "(", ")", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "}", "break", ";", "}", "printVisibility", "(", "CurrentFnName", ",", "F", "->", "getVisibility", "(", ")", ")", ";", "if", "(", "AFI", "->", "isThumbFunction", "(", ")", ")", "{", "EmitAlignment", "(", "1", ",", "F", ",", "AFI", "->", "getAlign", "(", ")", ")", ";", "O", "<<", "\"\\t.code\\t16\\n\"", ";", "O", "<<", "\"\\t.thumb_func\"", ";", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "O", "<<", "\"\\t\"", "<<", "CurrentFnName", ";", "O", "<<", "\"\\n\"", ";", "InCPMode", "=", "false", ";", "}", "else", "EmitAlignment", "(", "2", ",", "F", ")", ";", "O", "<<", "CurrentFnName", "<<", "\":\\n\"", ";", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "{", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ";", "if", "(", "++", "I", "==", "MF", ".", "end", "(", ")", "&&", "MF", ".", "front", "(", ")", ".", "empty", "(", ")", ")", "O", "<<", "\"\\tnop\\n\"", ";", "}", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ",", "VerboseAsm", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "if", "(", "TAI", "->", "hasDotTypeDotSizeDirective", "(", ")", ")", "O", "<<", "\"\\t.size \"", "<<", "CurrentFnName", "<<", "\", .-\"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "O", ".", "flush", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"\\n\"", "\"\\n\"", "0", "\"Unknown linkage type!\"", "\"\\t.text\"", "\"\\t.text\"", "\"\\t.globl\\t\"", "\"\\n\"", "\".section __TEXT,__textcoal_nt,coalesced,pure_instructions\"", "\"\\t.globl\\t\"", "\"\\n\"", "\"\\t.weak_definition\\t\"", "\"\\n\"", "\"\\n\"", "1", "\"\\t.code\\t16\\n\"", "\"\\t.thumb_func\"", "\"\\t\"", "\"\\n\"", "2", "\":\\n\"", "\"\\tnop\\n\"", "\"\\t.size \"", "\", .-\"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "nios2_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "ctx_reg", "=", "force_reg", "(", "Pmode", ",", "cxt", ")", ";", "rtx", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__trampoline_setup\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "addr", ",", "Pmode", ",", "fnaddr", ",", "Pmode", ",", "ctx_reg", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "On", "Nios", "II", ",", "we", "handle", "this", "by", "a", "library", "call", "." ]

[ "nios2", "0", "0", "\"__trampoline_setup\"", "3" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SPARC Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"SPARC Delay Slot Filler\"" ]

[]

[ "<s>", "static", "MachineInstr", "*", "getDef", "(", "unsigned", "Reg", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Reg", ")", ")", "return", "nullptr", ";", "return", "MRI", "->", "getUniqueVRegDef", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Get", "the", "concrete", "record", "with", "the", "specified", "name", "." ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "auto", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitPrologue\"", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "auto", "Store", "=", "MI", ";", "--", "Store", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "Store", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitPrologue\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps1", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps2", ",", "unsigned", "NumLoads", ",", "unsigned", "NumBytes", ")", "const", "{", "assert", "(", "BaseOps1", ".", "size", "(", ")", "==", "1", "&&", "BaseOps2", ".", "size", "(", ")", "==", "1", ")", ";", "const", "MachineOperand", "&", "BaseOp1", "=", "*", "BaseOps1", ".", "front", "(", ")", ";", "const", "MachineOperand", "&", "BaseOp2", "=", "*", "BaseOps2", ".", "front", "(", ")", ";", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "BaseOp1", ".", "getType", "(", ")", "!=", "BaseOp2", ".", "getType", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "BaseOp1", ".", "isReg", "(", ")", "||", "BaseOp1", ".", "isFI", "(", ")", ")", "&&", "\"Only base registers and frame indices are supported.\"", ")", ";", "if", "(", "BaseOp1", ".", "isReg", "(", ")", "&&", "BaseOp1", ".", "getReg", "(", ")", "!=", "BaseOp2", ".", "getReg", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">", "2", ")", "return", "false", ";", "if", "(", "!", "isPairableLdStInst", "(", "FirstLdSt", ")", "||", "!", "isPairableLdStInst", "(", "SecondLdSt", ")", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "hasUnscaledLdStOffset", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "hasUnscaledLdStOffset", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "if", "(", "BaseOp1", ".", "isFI", "(", ")", ")", "{", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", "<=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFrameInfo", "(", ")", ";", "return", "shouldClusterFI", "(", "MFI", ",", "BaseOp1", ".", "getIndex", "(", ")", ",", "Offset1", ",", "FirstOpc", ",", "BaseOp2", ".", "getIndex", "(", ")", ",", "Offset2", ",", "SecondOpc", ")", ";", "}", "assert", "(", "Offset1", "<=", "Offset2", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AArch64", "AArch64", "1", "1", "\"Only base registers and frame indices are supported.\"", "2", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "AAP" ]

[]

[ "<s>", "unsigned", "AMDGPUTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPUISD", "::", "BFE_I32", ":", "{", "ConstantSDNode", "*", "Width", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "Width", ")", "return", "1", ";", "unsigned", "SignBits", "=", "32", "-", "Width", "->", "getZExtValue", "(", ")", "+", "1", ";", "if", "(", "!", "isNullConstant", "(", "Op", ".", "getOperand", "(", "1", ")", ")", ")", "return", "SignBits", ";", "unsigned", "Op0SignBits", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "return", "std", "::", "max", "(", "SignBits", ",", "Op0SignBits", ")", ";", "}", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "Width", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "return", "Width", "?", "32", "-", "(", "Width", "->", "getZExtValue", "(", ")", "&", "0x1f", ")", ":", "1", ";", "}", "case", "AMDGPUISD", "::", "CARRY", ":", "case", "AMDGPUISD", "::", "BORROW", ":", "return", "31", ";", "case", "AMDGPUISD", "::", "BUFFER_LOAD_BYTE", ":", "return", "25", ";", "case", "AMDGPUISD", "::", "BUFFER_LOAD_SHORT", ":", "return", "17", ";", "case", "AMDGPUISD", "::", "BUFFER_LOAD_UBYTE", ":", "return", "24", ";", "case", "AMDGPUISD", "::", "BUFFER_LOAD_USHORT", ":", "return", "16", ";", "case", "AMDGPUISD", "::", "FP_TO_FP16", ":", "case", "AMDGPUISD", "::", "FP16_ZEXT", ":", "return", "16", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPUISD::BFE_I32", "2", "1", "32", "1", "1", "0", "1", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "1", "AMDGPUISD::CARRY", "AMDGPUISD::BORROW", "31", "AMDGPUISD::BUFFER_LOAD_BYTE", "25", "AMDGPUISD::BUFFER_LOAD_SHORT", "17", "AMDGPUISD::BUFFER_LOAD_UBYTE", "24", "AMDGPUISD::BUFFER_LOAD_USHORT", "16", "AMDGPUISD::FP_TO_FP16", "AMDGPUISD::FP16_ZEXT", "16", "1" ]

[]

[ "<s>", "TargetIRAnalysis", "PPCTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "PPCTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "parse_mtune_ctrl_str", "(", "bool", "dump", ")", "{", "if", "(", "!", "ix86_tune_ctrl_string", ")", "return", ";", "char", "*", "next_feature_string", "=", "NULL", ";", "char", "*", "curr_feature_string", "=", "xstrdup", "(", "ix86_tune_ctrl_string", ")", ";", "char", "*", "orig", "=", "curr_feature_string", ";", "int", "i", ";", "do", "{", "bool", "clear", "=", "false", ";", "next_feature_string", "=", "strchr", "(", "curr_feature_string", ",", "','", ")", ";", "if", "(", "next_feature_string", ")", "*", "next_feature_string", "++", "=", "'\\0'", ";", "if", "(", "*", "curr_feature_string", "==", "'^'", ")", "{", "curr_feature_string", "++", ";", "clear", "=", "true", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "X86_TUNE_LAST", ";", "i", "++", ")", "{", "if", "(", "!", "strcmp", "(", "curr_feature_string", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ")", "{", "ix86_tune_features", "[", "i", "]", "=", "!", "clear", ";", "if", "(", "dump", ")", "fprintf", "(", "stderr", ",", "\"Explicitly %s feature %s\\n\"", ",", "clear", "?", "\"clear\"", ":", "\"set\"", ",", "ix86_tune_feature_names", "[", "i", "]", ")", ";", "break", ";", "}", "}", "if", "(", "i", "==", "X86_TUNE_LAST", ")", "error", "(", "\"Unknown parameter to option -mtune-ctrl: %s\"", ",", "clear", "?", "curr_feature_string", "-", "1", ":", "curr_feature_string", ")", ";", "curr_feature_string", "=", "next_feature_string", ";", "}", "while", "(", "curr_feature_string", ")", ";", "free", "(", "orig", ")", ";", "}", "</s>" ]

[ "parse", "-mtune-ctrl=", "option", ".", "When", "DUMP", "is", "true", ",", "print", "the", "features", "that", "are", "explicitly", "set", "." ]

[ "i386", "0", "\"Explicitly %s feature %s\\n\"", "\"clear\"", "\"set\"", "\"Unknown parameter to option -mtune-ctrl: %s\"", "1" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "LD", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "RESTORE_CR", ":", "case", "PPC", "::", "RESTORE_CRBIT", ":", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "RESTORE_VRSAVE", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::LD", "PPC::LWZ", "PPC::LFS", "PPC::LFD", "PPC::RESTORE_CR", "PPC::RESTORE_CRBIT", "PPC::LVX", "PPC::RESTORE_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "unsigned", "from_size", "=", "GET_MODE_SIZE", "(", "from", ")", ";", "unsigned", "to_size", "=", "GET_MODE_SIZE", "(", "to", ")", ";", "if", "(", "from_size", "!=", "to_size", ")", "{", "enum", "reg_class", "xclass", "=", "(", "TARGET_VSX", ")", "?", "VSX_REGS", ":", "FLOAT_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "xclass", ",", "rclass", ")", ")", "{", "unsigned", "to_nregs", "=", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "to", ")", ";", "unsigned", "from_nregs", "=", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "from", ")", ";", "bool", "to_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "to", ")", ";", "bool", "from_float128_vector_p", "=", "FLOAT128_VECTOR_P", "(", "from", ")", ";", "if", "(", "to_float128_vector_p", "&&", "from_float128_vector_p", ")", "return", "true", ";", "else", "if", "(", "to_float128_vector_p", "||", "from_float128_vector_p", ")", "return", "false", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", "&&", "(", "to", "==", "TDmode", "||", "from", "==", "TDmode", ")", ")", "return", "false", ";", "if", "(", "from_size", "<", "8", "||", "to_size", "<", "8", ")", "return", "false", ";", "if", "(", "from_size", "==", "8", "&&", "(", "8", "*", "to_nregs", ")", "!=", "to_size", ")", "return", "false", ";", "if", "(", "to_size", "==", "8", "&&", "(", "8", "*", "from_nregs", ")", "!=", "from_size", ")", "return", "false", ";", "return", "true", ";", "}", "else", "return", "true", ";", "}", "if", "(", "TARGET_VSX", "&&", "VSX_REG_CLASS_P", "(", "rclass", ")", ")", "{", "unsigned", "num_regs", "=", "(", "from_size", "+", "15", ")", "/", "16", ";", "if", "(", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "to", ")", ">", "num_regs", "||", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "from", ")", ">", "num_regs", ")", "return", "false", ";", "return", "(", "from_size", "==", "8", "||", "from_size", "==", "16", ")", ";", "}", "if", "(", "TARGET_ALTIVEC", "&&", "rclass", "==", "ALTIVEC_REGS", "&&", "(", "ALTIVEC_VECTOR_MODE", "(", "from", ")", "+", "ALTIVEC_VECTOR_MODE", "(", "to", ")", ")", "==", "1", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "rs6000", "8", "8", "8", "8", "8", "8", "15", "16", "8", "16", "1" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "STI", ".", "hasMOVW", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AVR", "::", "MOVWRdRr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "Register", "DestLo", ",", "DestHi", ",", "SrcLo", ",", "SrcHi", ";", "TRI", ".", "splitReg", "(", "DestReg", ",", "DestLo", ",", "DestHi", ")", ";", "TRI", ".", "splitReg", "(", "SrcReg", ",", "SrcLo", ",", "SrcHi", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AVR", "::", "MOVRdRr", ")", ",", "DestLo", ")", ".", "addReg", "(", "SrcLo", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AVR", "::", "MOVRdRr", ")", ",", "DestHi", ")", ".", "addReg", "(", "SrcHi", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "else", "{", "if", "(", "AVR", "::", "GPR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "MOVRdRr", ";", "}", "else", "if", "(", "SrcReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPREAD", ";", "}", "else", "if", "(", "DestReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPWRITE", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "AVR", "AVR", "AVR", "AVR", "AVR", "AVR::DREGSRegClass", "AVR::MOVWRdRr", "AVR::MOVRdRr", "AVR::MOVRdRr", "AVR::GPR8RegClass", "AVR::MOVRdRr", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPREAD", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPWRITE", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ")", "return", "true", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "HINT", ":", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "==", "0x14", ")", "return", "true", ";", "break", ";", "case", "AArch64", "::", "DSB", ":", "case", "AArch64", "::", "ISB", ":", "return", "true", ";", "default", ":", ";", "}", "if", "(", "isSEHInstruction", "(", "MI", ")", ")", "return", "true", ";", "auto", "Next", "=", "std", "::", "next", "(", "MI", ".", "getIterator", "(", ")", ")", ";", "return", "Next", "!=", "MBB", "->", "end", "(", ")", "&&", "Next", "->", "isCFIInstruction", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::HINT", "0", "0x14", "AArch64::DSB", "AArch64::ISB" ]

[]

[ "<s>", "void", "SNESRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "SNESTargetMachine", "&", "TM", "=", "(", "const", "SNESTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", "+", "1", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "SNES", "::", "A", ",", "false", ")", ";", "assert", "(", "isUInt", "<", "6", ">", "(", "Offset", ")", "&&", "\"Offset is out of range\"", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "0", "\"Unexpected SPAdj value\"", "SNES", "SNES", "1", "1", "SNES::A", "6", "\"Offset is out of range\"", "1" ]

[]

[ "<s>", "bool", "XNCMFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "0" ]

[]

[ "<s>", "static", "int", "bfin_issue_rate", "(", "void", ")", "{", "return", "3", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_ISSUE_RATE", "." ]

[ "bfin", "3" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumInstrs", ")", "const", "{", "return", "NumInstrs", "&&", "NumInstrs", "==", "1", ";", "}", "</s>" ]

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

[ "ARM", "1" ]

[]

[ "<s>", "void", "ix86_emit_binop", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "dst", ",", "rtx", "src", ")", "{", "rtx", "op", ",", "clob", ";", "op", "=", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "dst", ",", "src", ")", ")", ";", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "x86", "binary", "operand", "CODE", "in", "mode", "MODE", ",", "where", "the", "first", "operand", "matches", "destination", ".", "RTX", "includes", "clobber", "of", "FLAGS_REG", "." ]

[ "i386", "2" ]

[]

[ "<s>", "void", "MetadataStreamerV3", "::", "verify", "(", "StringRef", "HSAMetadataString", ")", "const", "{", "errs", "(", ")", "<<", "\"AMDGPU HSA Metadata Parser Test: \"", ";", "msgpack", "::", "Document", "FromHSAMetadataString", ";", "if", "(", "!", "FromHSAMetadataString", ".", "fromYAML", "(", "HSAMetadataString", ")", ")", "{", "errs", "(", ")", "<<", "\"FAIL\\n\"", ";", "return", ";", "}", "std", "::", "string", "ToHSAMetadataString", ";", "raw_string_ostream", "StrOS", "(", "ToHSAMetadataString", ")", ";", "FromHSAMetadataString", ".", "toYAML", "(", "StrOS", ")", ";", "errs", "(", ")", "<<", "(", "HSAMetadataString", "==", "StrOS", ".", "str", "(", ")", "?", "\"PASS\"", ":", "\"FAIL\"", ")", "<<", "'\\n'", ";", "if", "(", "HSAMetadataString", "!=", "ToHSAMetadataString", ")", "{", "errs", "(", ")", "<<", "\"Original input: \"", "<<", "HSAMetadataString", "<<", "'\\n'", "<<", "\"Produced output: \"", "<<", "StrOS", ".", "str", "(", ")", "<<", "'\\n'", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "AMDGPU", "\"AMDGPU HSA Metadata Parser Test: \"", "\"FAIL\\n\"", "\"PASS\"", "\"FAIL\"", "\"Original input: \"", "\"Produced output: \"" ]

[]

[ "<s>", "unsigned", "getFramePred", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "assert", "(", "isFrameInstr", "(", "MI", ")", ")", ";", "if", "(", "isFrameSetup", "(", "MI", ")", ")", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "return", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "}", "</s>" ]

[ "Returns", "predicate", "register", "associated", "with", "the", "given", "frame", "instruction", "." ]

[ "ARM", "2", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP", "3" ]

[]

[ "<s>", "static", "sbitmap", "aarch64_get_separate_components", "(", "void", ")", "{", "sbitmap", "components", "=", "sbitmap_alloc", "(", "LAST_SAVED_REGNUM", "+", "1", ")", ";", "bitmap_clear", "(", "components", ")", ";", "for", "(", "unsigned", "regno", "=", "0", ";", "regno", "<=", "LAST_SAVED_REGNUM", ";", "regno", "++", ")", "if", "(", "aarch64_register_saved_on_entry", "(", "regno", ")", ")", "{", "poly_int64", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "if", "(", "!", "frame_pointer_needed", ")", "offset", "+=", "cfun", "->", "machine", "->", "frame", ".", "frame_size", "-", "cfun", "->", "machine", "->", "frame", ".", "hard_fp_offset", ";", "if", "(", "offset_12bit_unsigned_scaled_p", "(", "DImode", ",", "offset", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "bitmap_clear_bit", "(", "components", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "unsigned", "reg1", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", ";", "unsigned", "reg2", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ";", "if", "(", "reg2", "!=", "INVALID_REGNUM", ")", "bitmap_clear_bit", "(", "components", ",", "reg2", ")", ";", "if", "(", "reg1", "!=", "INVALID_REGNUM", ")", "bitmap_clear_bit", "(", "components", ",", "reg1", ")", ";", "bitmap_clear_bit", "(", "components", ",", "LR_REGNUM", ")", ";", "bitmap_clear_bit", "(", "components", ",", "SP_REGNUM", ")", ";", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS", "." ]

[ "aarch64", "1", "0" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", "||", "!", "STI", "->", "hasBWI", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "EnclosedEdges", ".", "clear", "(", ")", ";", "EnclosedInstrs", ".", "clear", "(", ")", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "unsigned", "ClosureID", "=", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "unsigned", "Reg", "=", "Register", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "ClosureID", "++", ",", "{", "MaskDomain", "}", ")", ";", "buildClosure", "(", "C", ",", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "{", "LLVM_DEBUG", "(", "C", ".", "dump", "(", "MRI", ")", ")", ";", "if", "(", "isReassignmentProfitable", "(", "C", ",", "MaskDomain", ")", ")", "{", "reassign", "(", "C", ",", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "}", "DeleteContainerSeconds", "(", "Converters", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]

[ "<s>", "bool", "MandarinFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

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

[ "Mandarin" ]

[]

[ "<s>", "static", "machine_mode", "cris_cc_modes_compatible", "(", "machine_mode", "m1", ",", "machine_mode", "m2", ")", "{", "if", "(", "m1", "==", "CC_NZVCmode", ")", "{", "if", "(", "m2", "==", "CC_NZVCmode", "||", "m2", "==", "CCmode", ")", "return", "CC_NZVCmode", ";", "return", "VOIDmode", ";", "}", "if", "(", "m2", "==", "CC_NZVCmode", ")", "{", "if", "(", "m1", "==", "CC_NZVCmode", "||", "m1", "==", "CCmode", ")", "return", "CC_NZVCmode", ";", "return", "VOIDmode", ";", "}", "if", "(", "m1", "!=", "m2", ")", "return", "CC_NZmode", ";", "return", "m1", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CC_MODES_COMPATIBLE", ".", "We", "start", "with", "CCmode", "for", "most", "comparisons", ",", "which", "merges", "and", "yields", "to", "CC_NZmode", "or", "CC_NZVCmode", ".", "The", "exceptions", "have", "CC_NZVCmode", "and", "ca", "n't", "do", "with", "another", "mode", "." ]

[ "cris" ]

[]

[ "<s>", "static", "int", "loongarch_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "return", "loongarch_address_insns", "(", "addr", ",", "mode", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ADDRESS_COST", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "void", "alpha_reorg", "(", "void", ")", "{", "if", "(", "alpha_tp", "!=", "ALPHA_TP_PROG", "||", "flag_exceptions", ")", "alpha_handle_trap_shadows", "(", ")", ";", "if", "(", "optimize", "&&", "!", "optimize_size", "&&", "alpha_tp", "!=", "ALPHA_TP_INSN", "&&", "flag_schedule_insns_after_reload", ")", "{", "if", "(", "alpha_tune", "==", "PROCESSOR_EV4", ")", "alpha_align_insns", "(", "8", ",", "alphaev4_next_group", ",", "alphaev4_next_nop", ")", ";", "else", "if", "(", "alpha_tune", "==", "PROCESSOR_EV5", ")", "alpha_align_insns", "(", "16", ",", "alphaev5_next_group", ",", "alphaev5_next_nop", ")", ";", "}", "}", "</s>" ]

[ "Machine", "dependent", "reorg", "pass", "." ]

[ "alpha", "8", "16" ]

[]

[ "<s>", "bool", "AMDGPUAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "AMDGPUAS", "AMDGPUAS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "M", ")", ";", "std", "::", "vector", "<", "GlobalAlias", "*", ">", "AliasesToRemove", ";", "SmallPtrSet", "<", "Function", "*", ",", "8", ">", "FuncsToAlwaysInline", ";", "SmallPtrSet", "<", "Function", "*", ",", "8", ">", "FuncsToNoInline", ";", "for", "(", "GlobalAlias", "&", "A", ":", "M", ".", "aliases", "(", ")", ")", "{", "if", "(", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "A", ".", "getAliasee", "(", ")", ")", ")", "{", "A", ".", "replaceAllUsesWith", "(", "F", ")", ";", "AliasesToRemove", ".", "push_back", "(", "&", "A", ")", ";", "}", "}", "if", "(", "GlobalOpt", ")", "{", "for", "(", "GlobalAlias", "*", "A", ":", "AliasesToRemove", ")", "{", "A", "->", "eraseFromParent", "(", ")", ";", "}", "}", "for", "(", "GlobalVariable", "&", "GV", ":", "M", ".", "globals", "(", ")", ")", "{", "unsigned", "AS", "=", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", ";", "if", "(", "AS", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "AS", "!=", "AMDGPUAS", ".", "REGION_ADDRESS", ")", "continue", ";", "recursivelyVisitUsers", "(", "GV", ",", "FuncsToAlwaysInline", ")", ";", "}", "if", "(", "!", "AMDGPUTargetMachine", "::", "EnableFunctionCalls", "||", "StressCalls", ")", "{", "auto", "IncompatAttr", "=", "StressCalls", "?", "Attribute", "::", "AlwaysInline", ":", "Attribute", "::", "NoInline", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "use_empty", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "IncompatAttr", ")", ")", "{", "if", "(", "StressCalls", ")", "{", "if", "(", "!", "FuncsToAlwaysInline", ".", "count", "(", "&", "F", ")", ")", "FuncsToNoInline", ".", "insert", "(", "&", "F", ")", ";", "}", "else", "FuncsToAlwaysInline", ".", "insert", "(", "&", "F", ")", ";", "}", "}", "}", "for", "(", "Function", "*", "F", ":", "FuncsToAlwaysInline", ")", "F", "->", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "for", "(", "Function", "*", "F", ":", "FuncsToNoInline", ")", "F", "->", "addFnAttr", "(", "Attribute", "::", "NoInline", ")", ";", "return", "!", "FuncsToAlwaysInline", ".", "empty", "(", ")", "||", "!", "FuncsToNoInline", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::getAMDGPUAS", "8", "8", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "CSKYAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "return", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "void", "mips_d_target_versions", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "d_add_builtin_version", "(", "\"MIPS64\"", ")", ";", "else", "d_add_builtin_version", "(", "\"MIPS32\"", ")", ";", "if", "(", "mips_abi", "==", "ABI_32", ")", "d_add_builtin_version", "(", "\"MIPS_O32\"", ")", ";", "else", "if", "(", "mips_abi", "==", "ABI_EABI", ")", "d_add_builtin_version", "(", "\"MIPS_EABI\"", ")", ";", "else", "if", "(", "mips_abi", "==", "ABI_N32", ")", "d_add_builtin_version", "(", "\"MIPS_N32\"", ")", ";", "else", "if", "(", "mips_abi", "==", "ABI_64", ")", "d_add_builtin_version", "(", "\"MIPS_N64\"", ")", ";", "else", "if", "(", "mips_abi", "==", "ABI_O64", ")", "d_add_builtin_version", "(", "\"MIPS_O64\"", ")", ";", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "{", "d_add_builtin_version", "(", "\"MIPS_HardFloat\"", ")", ";", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "}", "else", "if", "(", "TARGET_SOFT_FLOAT_ABI", ")", "{", "d_add_builtin_version", "(", "\"MIPS_SoftFloat\"", ")", ";", "d_add_builtin_version", "(", "\"D_SoftFloat\"", ")", ";", "}", "}", "</s>" ]

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

[ "mips", "\"MIPS64\"", "\"MIPS32\"", "\"MIPS_O32\"", "\"MIPS_EABI\"", "\"MIPS_N32\"", "\"MIPS_N64\"", "\"MIPS_O64\"", "\"MIPS_HardFloat\"", "\"D_HardFloat\"", "\"MIPS_SoftFloat\"", "\"D_SoftFloat\"" ]

[]

[ "<s>", "bool", "LC2200InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "reverse_iterator", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "REnd", "=", "MBB", ".", "rend", "(", ")", ";", "while", "(", "I", "!=", "REnd", "&&", "I", "->", "isDebugInstr", "(", ")", ")", "++", "I", ";", "if", "(", "I", "==", "REnd", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "return", "false", ";", "}", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "BranchInstrs", ";", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "BranchInstrs", ".", "push_back", "(", "LastInst", ")", ";", "if", "(", "!", "getAnalyzableBrOpc", "(", "LastOpc", ")", ")", "return", "true", ";", "unsigned", "SecondLastOpc", "=", "0", ";", "MachineInstr", "*", "SecondLastInst", "=", "nullptr", ";", "++", "I", ";", "while", "(", "I", "!=", "REnd", "&&", "I", "->", "isDebugInstr", "(", ")", ")", "++", "I", ";", "if", "(", "I", "!=", "REnd", ")", "{", "SecondLastInst", "=", "&", "*", "I", ";", "SecondLastOpc", "=", "SecondLastInst", "->", "getOpcode", "(", ")", ";", "if", "(", "isUnpredicatedTerminator", "(", "*", "SecondLastInst", ")", "&&", "!", "getAnalyzableBrOpc", "(", "SecondLastOpc", ")", ")", "return", "true", ";", "}", "if", "(", "!", "SecondLastOpc", "||", "(", "SecondLastOpc", "!=", "LC2200", "::", "JMP", "&&", "SecondLastOpc", "!=", "LC2200", "::", "CMP_JMP", "&&", "SecondLastOpc", "!=", "LC2200", "::", "GOTO", ")", ")", "{", "if", "(", "LastInst", "->", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "AnalyzeCondBr", "(", "LastInst", ",", "LastOpc", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "if", "(", "++", "I", "!=", "REnd", "&&", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "true", ";", "BranchInstrs", ".", "insert", "(", "BranchInstrs", ".", "begin", "(", ")", ",", "SecondLastInst", ")", ";", "if", "(", "SecondLastInst", "->", "isUnconditionalBranch", "(", ")", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "return", "true", ";", "}", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "LastInst", "->", "eraseFromParent", "(", ")", ";", "BranchInstrs", ".", "pop_back", "(", ")", ";", "return", "false", ";", "}", "if", "(", "!", "LastInst", "->", "isUnconditionalBranch", "(", ")", ")", "return", "true", ";", "AnalyzeCondBr", "(", "SecondLastInst", ",", "SecondLastOpc", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "4", "0", "LC2200::JMP", "LC2200::CMP_JMP", "LC2200::GOTO", "0", "0", "0" ]

[]

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

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

[ "WDC65816", "WDC", "WDC::Int32RegsRegClass" ]

[]

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

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte loads from stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created load reg=\"", "<<", "printReg", "(", "DestReg", ",", "TRI", ")", "<<", "\" from FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "LD_rs9", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte loads from stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created load reg=\"", "\" from FrameIndex=\"", "\"\\n\"", "ARC::LD_rs9", "0" ]

[]

[ "<s>", "static", "void", "record_content", "(", "rtx", "loc", ",", "rtx", "value", ")", "{", "machine_mode", "mode", ";", "unsigned", "char", "index", ";", "unsigned", "char", "val", ";", "if", "(", "(", "index", "=", "get_content_index", "(", "loc", ")", ")", "==", "NOT_KNOWN", ")", "return", ";", "val", "=", "get_content_index", "(", "value", ")", ";", "mode", "=", "GET_MODE", "(", "loc", ")", ";", "if", "(", "val", "==", "index", ")", "{", "if", "(", "!", "optimize", ")", "return", ";", "fprintf", "(", "stderr", ",", "\"ASSIGNMENT of location to itself detected! [%s]\\n\"", ",", "get_content_name", "(", "val", ",", "mode", ")", ")", ";", "return", ";", "gcc_unreachable", "(", ")", ";", "}", "update_content", "(", "index", ",", "val", ",", "mode", ")", ";", "}", "</s>" ]

[ "Record", "that", "LOC", "contains", "VALUE", ".", "For", "HImode", "locations", "record", "that", "LOC+1", "contains", "VALUE+1", ".", "If", "LOC", "is", "not", "a", "register", "or", "stack", "slot", ",", "do", "nothing", ".", "If", "VALUE", "is", "not", "a", "register", "or", "stack", "slot", ",", "clear", "the", "recorded", "content", "." ]

[ "rl78", "\"ASSIGNMENT of location to itself detected! [%s]\\n\"" ]

[]

[ "<s>", "MipsInstrInfo", "::", "BranchType", "MipsInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "BranchInstrs", ")", "const", "{", "MachineBasicBlock", "::", "reverse_iterator", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "REnd", "=", "MBB", ".", "rend", "(", ")", ";", "while", "(", "I", "!=", "REnd", "&&", "I", "->", "isDebugValue", "(", ")", ")", "++", "I", ";", "if", "(", "I", "==", "REnd", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "return", "BT_NoBranch", ";", "}", "MachineInstr", "*", "LastInst", "=", "&", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", "->", "getOpcode", "(", ")", ";", "BranchInstrs", ".", "push_back", "(", "LastInst", ")", ";", "if", "(", "!", "getAnalyzableBrOpc", "(", "LastOpc", ")", ")", "return", "LastInst", "->", "isIndirectBranch", "(", ")", "?", "BT_Indirect", ":", "BT_None", ";", "unsigned", "SecondLastOpc", "=", "0", ";", "MachineInstr", "*", "SecondLastInst", "=", "nullptr", ";", "++", "I", ";", "while", "(", "I", "!=", "REnd", "&&", "I", "->", "isDebugValue", "(", ")", ")", "++", "I", ";", "if", "(", "I", "!=", "REnd", ")", "{", "SecondLastInst", "=", "&", "*", "I", ";", "SecondLastOpc", "=", "getAnalyzableBrOpc", "(", "SecondLastInst", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "isUnpredicatedTerminator", "(", "*", "SecondLastInst", ")", "&&", "!", "SecondLastOpc", ")", "return", "BT_None", ";", "}", "if", "(", "!", "SecondLastOpc", ")", "{", "if", "(", "LastInst", "->", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "BT_Uncond", ";", "}", "AnalyzeCondBr", "(", "LastInst", ",", "LastOpc", ",", "TBB", ",", "Cond", ")", ";", "return", "BT_Cond", ";", "}", "if", "(", "++", "I", "!=", "REnd", "&&", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "BT_None", ";", "BranchInstrs", ".", "insert", "(", "BranchInstrs", ".", "begin", "(", ")", ",", "SecondLastInst", ")", ";", "if", "(", "SecondLastInst", "->", "isUnconditionalBranch", "(", ")", ")", "{", "if", "(", "!", "AllowModify", ")", "return", "BT_None", ";", "TBB", "=", "SecondLastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "LastInst", "->", "eraseFromParent", "(", ")", ";", "BranchInstrs", ".", "pop_back", "(", ")", ";", "return", "BT_Uncond", ";", "}", "if", "(", "!", "LastInst", "->", "isUnconditionalBranch", "(", ")", ")", "return", "BT_None", ";", "AnalyzeCondBr", "(", "SecondLastInst", ",", "SecondLastOpc", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "LastInst", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "BT_CondUncond", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"only integer returns supported\"", ")", ";", "}", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_BPF64", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "unsigned", "Opc", "=", "BPFISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::OutputArg", "16", "\"only integer returns supported\"", "BPF", "4", "1", "0", "\"Can only return in registers!\"", "1", "BPFISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "bool", "R600Packetizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "R600PacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "if", "(", "MI", "->", "isKill", "(", ")", "||", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", "||", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", "&&", "!", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "DeleteMI", "=", "MI", ";", "++", "MI", ";", "MBB", "->", "erase", "(", "DeleteMI", ")", ";", "End", "=", "MBB", "->", "end", "(", ")", ";", "continue", ";", "}", "++", "MI", ";", "}", "}", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "RemainingCount", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "RemainingCount", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "std", "::", "prev", "(", "I", ")", ",", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "I", "=", "MBB", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "--", "RemainingCount", ";", "continue", ";", "}", "if", "(", "I", "==", "std", "::", "prev", "(", "RegionEnd", ")", ")", "{", "RegionEnd", "=", "std", "::", "prev", "(", "RegionEnd", ")", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "MBB", ",", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "R600", "\"Empty DFA table!\"", "8" ]

[]

[ "<s>", "SUnit", "*", "R600SchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "SUnit", "*", "SU", "=", "nullptr", ";", "NextInstKind", "=", "IDOther", ";", "IsTopNode", "=", "false", ";", "bool", "AllowSwitchToAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "||", "(", "Available", "[", "CurInstKind", "]", ".", "empty", "(", ")", ")", ";", "bool", "AllowSwitchFromAlu", "=", "(", "CurEmitted", ">=", "InstKindLimit", "[", "CurInstKind", "]", ")", "&&", "(", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", "||", "!", "Available", "[", "IDOther", "]", ".", "empty", "(", ")", ")", ";", "if", "(", "CurInstKind", "==", "IDAlu", "&&", "!", "Available", "[", "IDFetch", "]", ".", "empty", "(", ")", ")", "{", "float", "ALUFetchRationEstimate", "=", "(", "AluInstCount", "+", "AvailablesAluCount", "(", ")", "+", "Pending", "[", "IDAlu", "]", ".", "size", "(", ")", ")", "/", "(", "FetchInstCount", "+", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ")", ";", "unsigned", "NeededWF", "=", "62.5f", "/", "ALUFetchRationEstimate", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "NeededWF", "<<", "\" approx. Wavefronts Required\\n\"", ")", ";", "unsigned", "NearRegisterRequirement", "=", "2", "*", "Available", "[", "IDFetch", "]", ".", "size", "(", ")", ";", "if", "(", "NeededWF", ">", "getWFCountLimitedByGPR", "(", "NearRegisterRequirement", ")", ")", "AllowSwitchFromAlu", "=", "true", ";", "}", "if", "(", "!", "SU", "&&", "(", "(", "AllowSwitchToAlu", "&&", "CurInstKind", "!=", "IDAlu", ")", "||", "(", "!", "AllowSwitchFromAlu", "&&", "CurInstKind", "==", "IDAlu", ")", ")", ")", "{", "SU", "=", "pickAlu", "(", ")", ";", "if", "(", "!", "SU", "&&", "!", "PhysicalRegCopy", ".", "empty", "(", ")", ")", "{", "SU", "=", "PhysicalRegCopy", ".", "front", "(", ")", ";", "PhysicalRegCopy", ".", "erase", "(", "PhysicalRegCopy", ".", "begin", "(", ")", ")", ";", "}", "if", "(", "SU", ")", "{", "if", "(", "CurEmitted", ">=", "InstKindLimit", "[", "IDAlu", "]", ")", "CurEmitted", "=", "0", ";", "NextInstKind", "=", "IDAlu", ";", "}", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDFetch", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDFetch", ";", "}", "if", "(", "!", "SU", ")", "{", "SU", "=", "pickOther", "(", "IDOther", ")", ";", "if", "(", "SU", ")", "NextInstKind", "=", "IDOther", ";", "}", "DEBUG", "(", "if", "(", "SU", ")", "{", "dbgs", "(", ")", "<<", "\" ** Pick node **\\n\"", ";", "SU", "->", "dump", "(", "DAG", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"NO NODE \\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "DAG", "->", "SUnits", ".", "size", "(", ")", ";", "i", "++", ")", "{", "const", "SUnit", "&", "S", "=", "DAG", "->", "SUnits", "[", "i", "]", ";", "if", "(", "!", "S", ".", "isScheduled", ")", "S", ".", "dump", "(", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "62.5f", "\" approx. Wavefronts Required\\n\"", "2", "0", "\" ** Pick node **\\n\"", "\"NO NODE \\n\"", "0" ]

[]

[ "<s>", "Register", "SIInstrInfo", "::", "readlaneVGPRToSGPR", "(", "Register", "SrcReg", ",", "MachineInstr", "&", "UseMI", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "const", "TargetRegisterClass", "*", "VRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "const", "TargetRegisterClass", "*", "SRC", "=", "RI", ".", "getEquivalentSGPRClass", "(", "VRC", ")", ";", "Register", "DstReg", "=", "MRI", ".", "createVirtualRegister", "(", "SRC", ")", ";", "unsigned", "SubRegs", "=", "RI", ".", "getRegSizeInBits", "(", "*", "VRC", ")", "/", "32", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "VRC", ")", ")", "{", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "VRC", ")", ";", "Register", "NewSrcReg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewSrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "SrcReg", "=", "NewSrcReg", ";", "}", "if", "(", "SubRegs", "==", "1", ")", "{", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", "DstReg", ";", "}", "SmallVector", "<", "unsigned", ",", "8", ">", "SRegs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "Register", "SGPR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "SGPR", ")", ".", "addReg", "(", "SrcReg", ",", "0", ",", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "SRegs", ".", "push_back", "(", "SGPR", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "DstReg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "MIB", ".", "addReg", "(", "SRegs", "[", "i", "]", ")", ";", "MIB", ".", "addImm", "(", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "}", "return", "DstReg", ";", "}", "</s>" ]

[ "Copy", "a", "value", "from", "a", "VGPR", "(", "SrcReg", ")", "to", "SGPR", "." ]

[ "AMDGPU", "SI", "32", "1", "AMDGPU::V_READFIRSTLANE_B32", "8", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::V_READFIRSTLANE_B32", "0", "AMDGPU::REG_SEQUENCE", "0" ]

[]

[ "<s>", "static", "inline", "int", "avr_outgoing_args_size", "(", "void", ")", "{", "return", "ACCUMULATE_OUTGOING_ARGS", "?", "crtl", "->", "outgoing_args_size", ":", "0", ";", "}", "</s>" ]

[ "Report", "contribution", "of", "accumulated", "outgoing", "arguments", "to", "stack", "size", "." ]

[ "avr", "0" ]

[]

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

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

[ "M68k", "M68k" ]

[]

[ "<s>", "virtual", "bool", "ShouldShrinkFPConstant", "(", "MVT", "VT", ")", "const", "{", "return", "!", "X86ScalarSSEf64", "||", "VT", "==", "MVT", "::", "f80", ";", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "X86", "X86", "MVT::f80" ]

[]

[ "<s>", "bool", "ARM64InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "unsigned", "ExtraCondLat", "=", "Cond", ".", "size", "(", ")", "!=", "1", ";", "if", "(", "ARM64", "::", "GPR64allRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "ARM64", "::", "GPR32allRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "1", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "1", ";", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "TrueReg", ")", ")", "TrueCycles", "=", "0", ";", "else", "if", "(", "canFoldIntoCSel", "(", "MRI", ",", "FalseReg", ")", ")", "FalseCycles", "=", "0", ";", "return", "true", ";", "}", "if", "(", "ARM64", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "ARM64", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "5", "+", "ExtraCondLat", ";", "TrueCycles", "=", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "ARM64", "ARM64", "1", "ARM64::GPR64allRegClass", "ARM64::GPR32allRegClass", "1", "1", "0", "0", "ARM64::FPR64RegClass", "ARM64::FPR32RegClass", "5", "2" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "VMOVRRD", ")", "{", "SDNode", "*", "VMov", "=", "Copy", ";", "SmallPtrSet", "<", "SDNode", "*", ",", "2", ">", "Copies", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "VMov", "->", "use_begin", "(", ")", ",", "UE", "=", "VMov", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", ")", "return", "false", ";", "Copies", ".", "insert", "(", "*", "UI", ")", ";", "}", "if", "(", "Copies", ".", "size", "(", ")", ">", "2", ")", "return", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "VMov", "->", "use_begin", "(", ")", ",", "UE", "=", "VMov", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "SDValue", "UseChain", "=", "UI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Copies", ".", "count", "(", "UseChain", ".", "getNode", "(", ")", ")", ")", "Copy", "=", "*", "UI", ";", "else", "TCChain", "=", "UseChain", ";", "}", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "{", "if", "(", "!", "Copy", "->", "hasOneUse", "(", ")", ")", "return", "false", ";", "Copy", "=", "*", "Copy", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", "||", "!", "Copy", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "{", "return", "false", ";", "}", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "ARMISD", "::", "RET_FLAG", "&&", "UI", "->", "getOpcode", "(", ")", "!=", "ARMISD", "::", "INTRET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "ARM", "ARM", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ARMISD::VMOVRRD", "2", "ISD::CopyToReg", "2", "0", "ISD::BITCAST", "ISD::CopyToReg", "1", "0", "0", "ARMISD::RET_FLAG", "ARMISD::INTRET_FLAG" ]

[]

[ "<s>", "bool", "invalid_e500_subreg", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_E500_DOUBLE", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "mode", "==", "TImode", "||", "mode", "==", "DDmode", "||", "mode", "==", "TDmode", "||", "mode", "==", "PTImode", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DFmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TFmode", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "TFmode", ")", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "PTImode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DDmode", "||", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "TDmode", ")", ")", "return", "true", ";", "}", "if", "(", "TARGET_SPE", "&&", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "mode", "==", "SImode", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "SPE_VECTOR_MODE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "an", "invalid", "SUBREG", "operation", "on", "the", "e500", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "MCInst", "const", "&", "MCB", "=", "DF", "->", "getInst", "(", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "MCB", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "MCInst", "&", "MCI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "HexagonMCInstrInfo", "::", "instruction", "(", "MCB", ",", "Fixup", ".", "getOffset", "(", ")", "/", "HEXAGON_INSTR_SIZE", ")", ")", ";", "bool", "Relaxable", "=", "isInstRelaxable", "(", "MCI", ")", ";", "if", "(", "Relaxable", "==", "false", ")", "return", "false", ";", "if", "(", "!", "Resolved", ")", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "fixup_Hexagon_B22_PCREL", ":", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "false", ";", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "break", ";", "}", "}", "}", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "int64_t", "sValue", "=", "Value", ";", "int64_t", "maxValue", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "fixup_Hexagon_B7_PCREL", ":", "maxValue", "=", "1", "<<", "8", ";", "break", ";", "case", "fixup_Hexagon_B9_PCREL", ":", "maxValue", "=", "1", "<<", "10", ";", "break", ";", "case", "fixup_Hexagon_B15_PCREL", ":", "maxValue", "=", "1", "<<", "16", ";", "break", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "maxValue", "=", "1", "<<", "23", ";", "break", ";", "default", ":", "maxValue", "=", "INT64_MAX", ";", "break", ";", "}", "bool", "isFarAway", "=", "-", "maxValue", ">", "sValue", "||", "sValue", ">", "maxValue", "-", "1", ";", "if", "(", "isFarAway", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "8", "Hexagon", "1", "10", "Hexagon", "1", "16", "Hexagon", "1", "23", "1", "Hexagon" ]

[]

[ "<s>", "void", "MBlazeFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MBlazeInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MBlazeInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "llvm", "::", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "bool", "requiresRA", "=", "CallConv", "==", "llvm", "::", "CallingConv", "::", "MBLAZE_INTR", ";", "determineFrameLayout", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "requiresRA", ")", "return", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDIK", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "||", "requiresRA", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R15", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "RAOffset", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "FPOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze", "MBlaze", "MBlaze::ADDIK", "MBlaze::R1", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R15", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::ADD", "MBlaze::R19", "MBlaze::R1", "MBlaze::R0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"AMDGPU simplify control flow\"", ";", "}", "</s>" ]

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

[ "R600", "\"AMDGPU simplify control flow\"" ]

[]

[ "<s>", "static", "rtx", "alpha_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "basereg", ";", "int", "num_args", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "basereg", "=", "16", ";", "else", "{", "gcc_checking_assert", "(", "!", "COMPLEX_MODE_P", "(", "mode", ")", ")", ";", "if", "(", "TARGET_FPREGS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "basereg", "=", "32", "+", "16", ";", "else", "basereg", "=", "16", ";", "}", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "alpha_arg_info_reg_val", "(", "*", "cum", ")", ";", "num_args", "=", "cum", "->", "num_args", ";", "if", "(", "num_args", ">=", "6", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "{", "if", "(", "*", "cum", ">=", "6", ")", "return", "NULL_RTX", ";", "num_args", "=", "*", "cum", ";", "if", "(", "type", "==", "void_type_node", ")", "basereg", "=", "16", ";", "else", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "num_args", "+", "basereg", ")", ";", "}", "</s>" ]

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

[ "alpha", "16", "32", "16", "16", "6", "6", "16" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "MBB", ".", "isEHFuncletEntry", "(", ")", "&&", "STI", ".", "is32Bit", "(", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "bool", "isLiveIn", "=", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "isKill", "=", "!", "isLiveIn", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "--", "MI", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "MI", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "void", "ARM64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", "<<", "\"(\"", "<<", "ARM64_AM", "::", "getFPImmFloat", "(", "getFPImm", "(", ")", ")", "<<", "\") >\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "bool", "Valid", ";", "StringRef", "Name", "=", "ARM64DB", "::", "DBarrierMapper", "(", ")", ".", "toString", "(", "getBarrier", "(", ")", ",", "Valid", ")", ";", "if", "(", "Valid", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"<memory>\"", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "bool", "Valid", ";", "StringRef", "Name", "=", "ARM64PRFM", "::", "PRFMMapper", "(", ")", ".", "toString", "(", "getPrefetch", "(", ")", ",", "Valid", ")", ";", "if", "(", "Valid", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Shifter", ":", "{", "unsigned", "Val", "=", "getShifter", "(", ")", ";", "OS", "<<", "\"<\"", "<<", "ARM64_AM", "::", "getShiftName", "(", "ARM64_AM", "::", "getShiftType", "(", "Val", ")", ")", "<<", "\" #\"", "<<", "ARM64_AM", "::", "getShiftValue", "(", "Val", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Extend", ":", "{", "unsigned", "Val", "=", "getExtend", "(", ")", ";", "OS", "<<", "\"<\"", "<<", "ARM64_AM", "::", "getExtendName", "(", "ARM64_AM", "::", "getArithExtendType", "(", "Val", ")", ")", "<<", "\" #\"", "<<", "ARM64_AM", "::", "getArithShiftValue", "(", "Val", ")", "<<", "\">\"", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"<fpimm \"", "\"(\"", "ARM64_AM::getFPImmFloat", "\") >\"", "ARM64DB::DBarrierMapper", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<memory>\"", "\"<register \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "ARM64PRFM::PRFMMapper", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<\"", "ARM64_AM::getShiftName", "ARM64_AM::getShiftType", "\" #\"", "ARM64_AM::getShiftValue", "\">\"", "\"<\"", "ARM64_AM::getExtendName", "ARM64_AM::getArithExtendType", "\" #\"", "ARM64_AM::getArithShiftValue", "\">\"" ]

[]

[ "<s>", "unsigned", "MSP430RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MSP430FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FP", ":", "MSP430", "::", "SP", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430::FP", "MSP430::SP" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'L'", ":", "O", "<<", "getDataLayout", "(", ")", ".", "getPointerSize", "(", ")", "<<", "\"(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "case", "'y'", ":", "O", "<<", "\"0, \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "case", "'U'", ":", "case", "'X'", ":", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"(\"", "\")\"", "\"0, \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "static", "void", "aarch64_adjust_generic_arch_tuning", "(", "struct", "tune_params", "&", "current_tune", ")", "{", "if", "(", "TARGET_SVE2", ")", "current_tune", ".", "extra_tuning_flags", "&=", "~", "AARCH64_EXTRA_TUNE_CSE_SVE_VL_CONSTANTS", ";", "}", "</s>" ]

[ "Adjust", "CURRENT_TUNE", "(", "a", "generic", "tuning", "struct", ")", "with", "settings", "that", "are", "best", "for", "a", "generic", "target", "with", "the", "currently-enabled", "architecture", "extensions", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "arm_options_perform_arch_sanity_checks", "(", "void", ")", "{", "if", "(", "TARGET_INTERWORK", ")", "arm_cpp_interwork", "=", "1", ";", "if", "(", "arm_arch5t", ")", "target_flags", "&=", "~", "MASK_INTERWORK", ";", "if", "(", "TARGET_IWMMXT", "&&", "!", "ARM_DOUBLEWORD_ALIGN", ")", "error", "(", "\"iwmmxt requires an AAPCS compatible ABI for proper operation\"", ")", ";", "if", "(", "TARGET_IWMMXT_ABI", "&&", "!", "TARGET_IWMMXT", ")", "error", "(", "\"iwmmxt abi requires an iwmmxt capable cpu\"", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "TARGET_BPABI", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support interworking\"", ")", ";", "target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_SOFT_FLOAT", ")", "arm_fpu_attr", "=", "FPU_NONE", ";", "else", "arm_fpu_attr", "=", "FPU_VFP", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "if", "(", "TARGET_CALLER_INTERWORKING", ")", "error", "(", "\"AAPCS does not support %<-mcaller-super-interworking%>\"", ")", ";", "else", "if", "(", "TARGET_CALLEE_INTERWORKING", ")", "error", "(", "\"AAPCS does not support %<-mcallee-super-interworking%>\"", ")", ";", "}", "if", "(", "!", "arm_arch4", "&&", "arm_fp16_format", "!=", "ARM_FP16_FORMAT_NONE", ")", "sorry", "(", "\"%<__fp16%> and no ldrh\"", ")", ";", "if", "(", "use_cmse", "&&", "!", "arm_arch_cmse", ")", "error", "(", "\"target CPU does not support ARMv8-M Security Extensions\"", ")", ";", "if", "(", "use_cmse", "&&", "TARGET_HARD_FLOAT", "&&", "LAST_VFP_REGNUM", ">", "LAST_LO_VFP_REGNUM", ")", "error", "(", "\"ARMv8-M Security Extensions incompatible with selected FPU\"", ")", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "if", "(", "arm_abi", "==", "ARM_ABI_IWMMXT", ")", "arm_pcs_default", "=", "ARM_PCS_AAPCS_IWMMXT", ";", "else", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "{", "arm_pcs_default", "=", "ARM_PCS_AAPCS_VFP", ";", "if", "(", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_vfpv2", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_mve", ")", ")", "error", "(", "\"%<-mfloat-abi=hard%>: selected architecture lacks an FPU\"", ")", ";", "}", "else", "arm_pcs_default", "=", "ARM_PCS_AAPCS", ";", "}", "else", "{", "if", "(", "arm_float_abi", "==", "ARM_FLOAT_ABI_HARD", ")", "sorry", "(", "\"%<-mfloat-abi=hard%> and VFP\"", ")", ";", "if", "(", "arm_abi", "==", "ARM_ABI_APCS", ")", "arm_pcs_default", "=", "ARM_PCS_APCS", ";", "else", "arm_pcs_default", "=", "ARM_PCS_ATPCS", ";", "}", "}", "</s>" ]

[ "Perform", "some", "validation", "between", "the", "desired", "architecture", "and", "the", "rest", "of", "the", "options", "." ]

[ "arm", "1", "\"iwmmxt requires an AAPCS compatible ABI for proper operation\"", "\"iwmmxt abi requires an iwmmxt capable cpu\"", "0", "\"target CPU does not support interworking\"", "\"AAPCS does not support %<-mcaller-super-interworking%>\"", "\"AAPCS does not support %<-mcallee-super-interworking%>\"", "\"%<__fp16%> and no ldrh\"", "\"target CPU does not support ARMv8-M Security Extensions\"", "\"ARMv8-M Security Extensions incompatible with selected FPU\"", "\"%<-mfloat-abi=hard%>: selected architecture lacks an FPU\"", "\"%<-mfloat-abi=hard%> and VFP\"" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMILive", "*", "DAG", "=", "createGenericSchedLive", "(", "C", ")", ";", "const", "ARMSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "hasFusion", "(", ")", ")", "DAG", "->", "addMutation", "(", "createARMMacroFusionDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

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

[]

[ "<s>", "static", "void", "mep_incompatible_arg", "(", "const", "struct", "insn_operand_data", "*", "operand", ",", "rtx", "arg", ",", "int", "argnum", ",", "tree", "fnname", ")", "{", "size_t", "i", ";", "if", "(", "GET_CODE", "(", "arg", ")", "==", "CONST_INT", ")", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "cgen_immediate_predicates", ")", ";", "i", "++", ")", "if", "(", "operand", "->", "predicate", "==", "cgen_immediate_predicates", "[", "i", "]", ".", "predicate", ")", "{", "const", "struct", "cgen_immediate_predicate", "*", "predicate", ";", "HOST_WIDE_INT", "argval", ";", "predicate", "=", "&", "cgen_immediate_predicates", "[", "i", "]", ";", "argval", "=", "INTVAL", "(", "arg", ")", ";", "if", "(", "argval", "<", "predicate", "->", "lower", "||", "argval", ">=", "predicate", "->", "upper", ")", "error", "(", "\"argument %d of %qE must be in the range %d...%d\"", ",", "argnum", ",", "fnname", ",", "predicate", "->", "lower", ",", "predicate", "->", "upper", "-", "1", ")", ";", "else", "error", "(", "\"argument %d of %qE must be a multiple of %d\"", ",", "argnum", ",", "fnname", ",", "predicate", "->", "align", ")", ";", "return", ";", "}", "error", "(", "\"incompatible type for argument %d of %qE\"", ",", "argnum", ",", "fnname", ")", ";", "}", "</s>" ]

[ "Report", "that", "ARG", "can", "not", "be", "passed", "to", "argument", "ARGNUM", "of", "intrinsic", "function", "FNNAME", ".", "OPERAND", "describes", "the", "operand", "to", "which", "ARGNUM", "is", "mapped", "." ]

[ "mep", "0", "\"argument %d of %qE must be in the range %d...%d\"", "1", "\"argument %d of %qE must be a multiple of %d\"", "\"incompatible type for argument %d of %qE\"" ]

[]

[ "<s>", "static", "void", "tilepro_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "fnaddr", ",", "chaddr", ";", "rtx", "mem", ";", "rtx", "begin_addr", ",", "end_addr", ";", "int", "ptr_mode_size", "=", "GET_MODE_SIZE", "(", "ptr_mode", ")", ";", "fnaddr", "=", "copy_to_reg", "(", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ")", ";", "chaddr", "=", "copy_to_reg", "(", "static_chain", ")", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "TRAMPOLINE_SIZE", "-", "2", "*", "ptr_mode_size", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "ptr_mode", ",", "TRAMPOLINE_SIZE", "-", "ptr_mode_size", ")", ";", "emit_move_insn", "(", "mem", ",", "chaddr", ")", ";", "begin_addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "end_addr", "=", "force_reg", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "TRAMPOLINE_SIZE", ")", ")", ";", "maybe_emit_call_builtin___clear_cache", "(", "begin_addr", ",", "end_addr", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_TRAMPOLINE_INIT", "." ]

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

[]

[ "<s>", "static", "void", "expand_setmem_epilogue_via_loop", "(", "rtx", "destmem", ",", "rtx", "destptr", ",", "rtx", "value", ",", "rtx", "count", ",", "int", "max_size", ")", "{", "count", "=", "expand_simple_binop", "(", "counter_mode", "(", "count", ")", ",", "AND", ",", "count", ",", "GEN_INT", "(", "max_size", "-", "1", ")", ",", "count", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "expand_set_or_movmem_via_loop", "(", "destmem", ",", "NULL", ",", "destptr", ",", "NULL", ",", "gen_lowpart", "(", "QImode", ",", "value", ")", ",", "count", ",", "QImode", ",", "1", ",", "max_size", "/", "2", ",", "true", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "set", "at", "most", "count", "&", "(", "max_size", "-", "1", ")", "bytes", "starting", "by", "DEST", "." ]

[ "i386", "1", "1", "1", "2" ]

[]

[ "<s>", "static", "int", "s390_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "TARGET_Z10", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "FP_REGS", ")", ")", "return", "1", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", "&&", "reg_classes_intersect_p", "(", "from", ",", "FP_REGS", ")", ")", "return", "3", ";", "}", "if", "(", "(", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "FP_REGS", ")", ")", "||", "(", "reg_classes_intersect_p", "(", "from", ",", "FP_REGS", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", ")", "return", "10", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", "." ]

[ "s390", "8", "1", "3", "10", "1" ]

[]

[ "<s>", "unsigned", "MBlazeRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MBlaze", "::", "R19", ":", "MBlaze", "::", "R1", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze::R19", "MBlaze::R1" ]

[]

[ "<s>", "void", "function_builder", "::", "add_overloaded_function", "(", "const", "function_instance", "&", "instance", ",", "uint64_t", "required_extensions", ")", "{", "char", "*", "name", "=", "get_name", "(", "instance", ",", "true", ")", ";", "if", "(", "registered_function", "*", "*", "map_value", "=", "m_overload_names", ".", "get", "(", "name", ")", ")", "gcc_assert", "(", "(", "*", "map_value", ")", "->", "instance", "==", "instance", "&&", "(", "(", "*", "map_value", ")", "->", "required_extensions", "&", "~", "required_extensions", ")", "==", "0", ")", ";", "else", "{", "registered_function", "&", "rfn", "=", "add_function", "(", "instance", ",", "name", ",", "m_overload_type", ",", "NULL_TREE", ",", "required_extensions", ",", "true", ")", ";", "const", "char", "*", "permanent_name", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "rfn", ".", "decl", ")", ")", ";", "m_overload_names", ".", "put", "(", "permanent_name", ",", "&", "rfn", ")", ";", "}", "obstack_free", "(", "&", "m_string_obstack", ",", "name", ")", ";", "}", "</s>" ]

[ "Add", "one", "function", "decl", "for", "INSTANCE", ",", "to", "be", "used", "with", "manual", "overload", "resolution", ".", "REQUIRED_EXTENSIONS", "are", "the", "set", "of", "architecture", "extensions", "that", "the", "function", "requires", ".", "For", "simplicity", ",", "deal", "with", "duplicate", "attempts", "to", "add", "the", "same", "function", ",", "including", "cases", "in", "which", "the", "new", "function", "requires", "more", "features", "than", "the", "original", "one", "did", ".", "In", "that", "case", "we", "'ll", "check", "whether", "the", "required", "features", "are", "available", "as", "part", "of", "resolving", "the", "function", "to", "the", "relevant", "unique", "function", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "X86AsmBackend", "::", "emitInstructionBegin", "(", "MCObjectStreamer", "&", "OS", ",", "const", "MCInst", "&", "Inst", ")", "{", "if", "(", "!", "needAlign", "(", "OS", ")", ")", "return", ";", "if", "(", "hasInterruptDelaySlot", "(", "PrevInst", ")", ")", "return", ";", "if", "(", "isPrefix", "(", "PrevInst", ",", "*", "MCII", ")", ")", "return", ";", "if", "(", "isRightAfterData", "(", "OS", ".", "getCurrentFragment", "(", ")", ",", "PrevInstPosition", ")", ")", "return", ";", "if", "(", "!", "isMacroFused", "(", "PrevInst", ",", "Inst", ")", ")", "PendingBoundaryAlign", "=", "nullptr", ";", "if", "(", "PendingBoundaryAlign", "&&", "OS", ".", "getCurrentFragment", "(", ")", "->", "getPrevNode", "(", ")", "==", "PendingBoundaryAlign", ")", "{", "return", ";", "}", "if", "(", "needAlignInst", "(", "Inst", ")", "||", "(", "(", "AlignBranchType", "&", "X86", "::", "AlignBranchFused", ")", "&&", "isFirstMacroFusibleInst", "(", "Inst", ",", "*", "MCII", ")", ")", ")", "{", "OS", ".", "insert", "(", "PendingBoundaryAlign", "=", "new", "MCBoundaryAlignFragment", "(", "AlignBoundary", ")", ")", ";", "}", "}", "</s>" ]

[ "Give", "the", "target", "a", "chance", "to", "manipulate", "state", "related", "to", "instruction", "alignment", "(", "e.g", "." ]

[ "X86", "X86", "X86::AlignBranchFused" ]

[]

[ "<s>", "static", "const", "char", "*", "rl78_strip_nonasm_name_encoding", "(", "const", "char", "*", "sym", ")", "{", "while", "(", "1", ")", "{", "if", "(", "*", "sym", "==", "'@'", "&&", "sym", "[", "2", "]", "==", "'.'", ")", "sym", "+=", "3", ";", "else", "return", "sym", ";", "}", "}", "</s>" ]

[ "Like", "rl78_strip_name_encoding", ",", "but", "does", "not", "strip", "leading", "asterisks", ".", "This", "is", "important", "if", "the", "stripped", "name", "is", "going", "to", "be", "passed", "to", "assemble_name", "(", ")", "as", "that", "handles", "asterisk", "prefixed", "names", "in", "a", "special", "manner", "." ]

[ "rl78", "1", "2", "3" ]

[]

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

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

[ "VE", "VE" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "NVPTX" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "CMPri", ":", "case", "ARM", "::", "t2CMPri", ":", "case", "ARM", "::", "tCMPi8", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "ARM", "::", "CMPrr", ":", "case", "ARM", "::", "t2CMPrr", ":", "case", "ARM", "::", "tCMPr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "ARM", "::", "TSTri", ":", "case", "ARM", "::", "t2TSTri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "CmpValue", "=", "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", "." ]

[ "ARM", "ARM", "ARM::CMPri", "ARM::t2CMPri", "ARM::tCMPi8", "0", "0", "0", "1", "ARM::CMPrr", "ARM::t2CMPrr", "ARM::tCMPr", "0", "1", "0", "0", "ARM::TSTri", "ARM::t2TSTri", "0", "0", "1", "0" ]

[]

[ "<s>", "int", "standard_80387_constant_p", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "REAL_VALUE_TYPE", "r", ";", "if", "(", "!", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", ")", ")", "return", "-", "1", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "1", ";", "if", "(", "x", "==", "CONST1_RTX", "(", "mode", ")", ")", "return", "2", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "mode", "==", "XFmode", "&&", "(", "optimize_function_for_size_p", "(", "cfun", ")", "||", "TARGET_EXT_80387_CONSTANTS", ")", ")", "{", "int", "i", ";", "if", "(", "!", "ext_80387_constants_init", ")", "init_ext_80387_constants", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "if", "(", "real_identical", "(", "&", "r", ",", "&", "ext_80387_constants_table", "[", "i", "]", ")", ")", "return", "i", "+", "3", ";", "}", "if", "(", "real_isnegzero", "(", "&", "r", ")", ")", "return", "8", ";", "if", "(", "real_identical", "(", "&", "r", ",", "&", "dconstm1", ")", ")", "return", "9", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "constant", "is", "something", "that", "can", "be", "loaded", "with", "a", "special", "instruction", "." ]

[ "i386", "1", "1", "2", "0", "5", "3", "8", "9", "0" ]

[]