Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "virtual", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "{", "return", "createPatmosVLIWMachineSched", "(", "C", ")", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos" ]

[]

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

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

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

[]

[ "<s>", "bool", "isEqualTo", "(", "const", "MCExpr", "*", "X", ")", "const", "override", "{", "if", "(", "auto", "*", "E", "=", "dyn_cast", "<", "X86MCExpr", ">", "(", "X", ")", ")", "return", "getRegNo", "(", ")", "==", "E", "->", "getRegNo", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Test", "whether", "two", "SDValues", "are", "known", "to", "compare", "equal", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "tilepro_emit_setcc_internal", "(", "rtx", "res", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "cmp_mode", ")", "{", "rtx", "tmp", ";", "bool", "swap", "=", "false", ";", "if", "(", "cmp_mode", "==", "DImode", ")", "{", "return", "tilepro_emit_setcc_internal_di", "(", "res", ",", "code", ",", "op0", ",", "op1", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "swap", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "swap", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "}", "if", "(", "!", "reg_or_0_operand", "(", "op0", ",", "SImode", ")", ")", "op0", "=", "force_reg", "(", "SImode", ",", "op0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", "&&", "!", "register_operand", "(", "op1", ",", "SImode", ")", ")", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "res", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Certain", "simplifications", "can", "be", "done", "to", "make", "invalid", "setcc", "operations", "valid", ".", "Return", "the", "final", "comparison", ",", "or", "NULL", "if", "we", "ca", "n't", "work", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "if", "(", "!", "addr", ")", "error", "(", "\"%<PRINT_OPERAND_ADDRESS%>, null pointer\"", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "default", ":", "fatal_insn", "(", "\"invalid address\"", ",", "addr", ")", ";", "break", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s, 0\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "reg", "=", "(", "rtx", ")", "0", ";", "rtx", "offset", "=", "(", "rtx", ")", "0", ";", "rtx", "arg0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "arg1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "arg0", ")", "==", "REG", ")", "{", "reg", "=", "arg0", ";", "offset", "=", "arg1", ";", "}", "else", "if", "(", "GET_CODE", "(", "arg1", ")", "==", "REG", ")", "{", "reg", "=", "arg1", ";", "offset", "=", "arg0", ";", "}", "else", "fatal_insn", "(", "\"no register in address\"", ",", "addr", ")", ";", "if", "(", "CONSTANT_P", "(", "offset", ")", ")", "{", "fprintf", "(", "file", ",", "\"%s, \"", ",", "reg_names", "[", "REGNO", "(", "reg", ")", "]", ")", ";", "output_addr_const", "(", "file", ",", "offset", ")", ";", "}", "else", "fatal_insn", "(", "\"address offset not a constant\"", ",", "addr", ")", ";", "}", "break", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST_INT", ":", "case", "CONST", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "xtensa", "\"%<PRINT_OPERAND_ADDRESS%>, null pointer\"", "\"invalid address\"", "\"%s, 0\"", "0", "0", "0", "1", "\"no register in address\"", "\"%s, \"", "\"address offset not a constant\"" ]

[]

[ "<s>", "int", "microblaze_regno_ok_for_base_p", "(", "int", "regno", ",", "int", "strict", ")", "{", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "{", "if", "(", "!", "strict", ")", "return", "true", ";", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "}", "if", "(", "regno", "==", "ARG_POINTER_REGNUM", "||", "regno", "==", "FRAME_POINTER_REGNUM", ")", "return", "true", ";", "return", "GP_REG_P", "(", "regno", ")", ";", "}", "</s>" ]

[ "Implement", "REG_OK_FOR_BASE_P", "-and-", "REG_OK_FOR_INDEX_P", "." ]

[ "microblaze" ]

[]

[ "<s>", "static", "bool", "avr_is_casesi_sequence", "(", "basic_block", "bb", ",", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "insns", "[", "6", "]", ")", "{", "rtx", "set_5", ",", "set_0", ";", "if", "(", "!", "(", "JUMP_P", "(", "insns", "[", "5", "]", "=", "insn", ")", "&&", "(", "set_5", "=", "single_set", "(", "insns", "[", "5", "]", ")", ")", "&&", "UNSPEC", "==", "GET_CODE", "(", "SET_SRC", "(", "set_5", ")", ")", "&&", "UNSPEC_INDEX_JMP", "==", "XINT", "(", "SET_SRC", "(", "set_5", ")", ",", "1", ")", "&&", "(", "insns", "[", "4", "]", "=", "prev_real_insn", "(", "insns", "[", "5", "]", ")", ")", "&&", "(", "insns", "[", "3", "]", "=", "prev_real_insn", "(", "insns", "[", "4", "]", ")", ")", "&&", "(", "insns", "[", "2", "]", "=", "prev_real_insn", "(", "insns", "[", "3", "]", ")", ")", "&&", "(", "insns", "[", "1", "]", "=", "prev_real_insn", "(", "insns", "[", "2", "]", ")", ")", "&&", "(", "insns", "[", "0", "]", "=", "prev_real_insn", "(", "insns", "[", "1", "]", ")", ")", "&&", "(", "set_0", "=", "single_set", "(", "insns", "[", "0", "]", ")", ")", "&&", "extend_operator", "(", "SET_SRC", "(", "set_0", ")", ",", "SImode", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Sequence from casesi in \"", "\"[bb %d]:\\n\\n\"", ",", "bb", "->", "index", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "print_rtl_single", "(", "dump_file", ",", "insns", "[", "i", "]", ")", ";", "}", "rtx_insn", "*", "xinsn", "=", "avr_parallel_insn_from_insns", "(", "insns", ")", ";", "INSN_CODE", "(", "xinsn", ")", "=", "recog", "(", "PATTERN", "(", "xinsn", ")", ",", "xinsn", ",", "NULL", ")", ";", "if", "(", "INSN_CODE", "(", "xinsn", ")", "<", "0", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; Sequence not recognized, giving up.\\n\\n\"", ")", ";", "return", "false", ";", "}", "gcc_assert", "(", "CODE_FOR_casesi_qi_sequence", "==", "INSN_CODE", "(", "xinsn", ")", "||", "CODE_FOR_casesi_hi_sequence", "==", "INSN_CODE", "(", "xinsn", ")", ")", ";", "extract_insn", "(", "xinsn", ")", ";", "gcc_assert", "(", "11", "==", "recog_data", ".", "n_operands", ")", ";", "gcc_assert", "(", "4", "==", "recog_data", ".", "n_dups", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Operands extracted:\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "avr_fdump", "(", "dump_file", ",", "\";; $%d = %r\\n\"", ",", "i", ",", "recog_data", ".", "operand", "[", "i", "]", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "see", "an", "insn", "stream", "generated", "by", "casesi", "expander", "together", "with", "an", "extension", "to", "SImode", "of", "the", "switch", "value", ".", "If", "this", "is", "the", "case", ",", "fill", "in", "the", "insns", "from", "casesi", "to", "INSNS", "[", "1", "..", "5", "]", "and", "the", "SImode", "extension", "to", "INSNS", "[", "0", "]", ".", "Moreover", ",", "extract", "the", "operands", "of", "pattern", "casesi_", "<", "mode", ">", "_sequence", "forged", "from", "the", "sequence", "to", "recog_data", "." ]

[ "avr", "6", "5", "5", "1", "4", "5", "3", "4", "2", "3", "1", "2", "0", "1", "0", "\";; Sequence from casesi in \"", "\"[bb %d]:\\n\\n\"", "0", "6", "0", "\";; Sequence not recognized, giving up.\\n\\n\"", "11", "4", "\";; Operands extracted:\\n\"", "0", "\";; $%d = %r\\n\"", "\"\\n\"" ]

[]

[ "<s>", "MCSymbol", "*", "MSP430MCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "MSP430", "MSP430", "0", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "static", "void", "rs6000_maybe_dead", "(", "rtx", "insn", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_MAYBE_DEAD", ",", "const0_rtx", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "REG_MAYBE_DEAD", "note", "to", "the", "insn", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "ix86_avx256_split_vector_move_misalign", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "m", ";", "rtx", "(", "*", "extract", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "load_unaligned", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "store_unaligned", ")", "(", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "switch", "(", "GET_MODE", "(", "op0", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "V32QImode", ":", "extract", "=", "gen_avx_vextractf128v32qi", ";", "load_unaligned", "=", "gen_avx_loaddquv32qi", ";", "store_unaligned", "=", "gen_avx_storedquv32qi", ";", "mode", "=", "V16QImode", ";", "break", ";", "case", "V8SFmode", ":", "extract", "=", "gen_avx_vextractf128v8sf", ";", "load_unaligned", "=", "gen_avx_loadups256", ";", "store_unaligned", "=", "gen_avx_storeups256", ";", "mode", "=", "V4SFmode", ";", "break", ";", "case", "V4DFmode", ":", "extract", "=", "gen_avx_vextractf128v4df", ";", "load_unaligned", "=", "gen_avx_loadupd256", ";", "store_unaligned", "=", "gen_avx_storeupd256", ";", "mode", "=", "V2DFmode", ";", "break", ";", "}", "if", "(", "MEM_P", "(", "op1", ")", ")", "{", "if", "(", "TARGET_AVX256_SPLIT_UNALIGNED_LOAD", "&&", "optimize_insn_for_speed_p", "(", ")", ")", "{", "rtx", "r", "=", "gen_reg_rtx", "(", "mode", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "0", ")", ";", "emit_move_insn", "(", "r", ",", "m", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "16", ")", ";", "r", "=", "gen_rtx_VEC_CONCAT", "(", "GET_MODE", "(", "op0", ")", ",", "r", ",", "m", ")", ";", "emit_move_insn", "(", "op0", ",", "r", ")", ";", "}", "else", "if", "(", "misaligned_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ")", ";", "else", "emit_insn", "(", "load_unaligned", "(", "op0", ",", "op1", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "if", "(", "TARGET_AVX256_SPLIT_UNALIGNED_STORE", "&&", "optimize_insn_for_speed_p", "(", ")", ")", "{", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "op1", ",", "const0_rtx", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "16", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "op1", ",", "const1_rtx", ")", ")", ";", "}", "else", "emit_insn", "(", "store_unaligned", "(", "op0", ",", "op1", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Split", "32-byte", "AVX", "unaligned", "load", "and", "store", "if", "needed", "." ]

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

[]

[ "<s>", "int", "R600InstrInfo", "::", "getSrcIdx", "(", "unsigned", "Opcode", ",", "unsigned", "SrcNum", ")", "const", "{", "static", "const", "unsigned", "OpTable", "[", "]", "=", "{", "AMDGPU", "::", "OpName", "::", "src0", ",", "AMDGPU", "::", "OpName", "::", "src1", ",", "AMDGPU", "::", "OpName", "::", "src2", "}", ";", "assert", "(", "SrcNum", "<", "3", ")", ";", "return", "getOperandIdx", "(", "Opcode", ",", "OpTable", "[", "SrcNum", "]", ")", ";", "}", "</s>" ]

[ "Return", "the", "subregister", "index", "that", "SrcReg", "will", "be", "coalesced", "into", ",", "or", "0", "." ]

[ "R600", "3" ]

[]

[ "<s>", "static", "rtx", "ix86_convert_const_wide_int_to_broadcast", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "if", "(", "!", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", "return", "nullptr", ";", "if", "(", "!", "TARGET_AVX", "||", "!", "CONST_WIDE_INT_P", "(", "op", ")", "||", "standard_sse_constant_p", "(", "op", ",", "mode", ")", ")", "return", "nullptr", ";", "HOST_WIDE_INT", "val", "=", "CONST_WIDE_INT_ELT", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "val_broadcast", ";", "scalar_int_mode", "broadcast_mode", ";", "if", "(", "TARGET_AVX2", "&&", "ix86_broadcast", "(", "val", ",", "GET_MODE_BITSIZE", "(", "QImode", ")", ",", "val_broadcast", ")", ")", "broadcast_mode", "=", "QImode", ";", "else", "if", "(", "TARGET_AVX2", "&&", "ix86_broadcast", "(", "val", ",", "GET_MODE_BITSIZE", "(", "HImode", ")", ",", "val_broadcast", ")", ")", "broadcast_mode", "=", "HImode", ";", "else", "if", "(", "ix86_broadcast", "(", "val", ",", "GET_MODE_BITSIZE", "(", "SImode", ")", ",", "val_broadcast", ")", ")", "broadcast_mode", "=", "SImode", ";", "else", "if", "(", "TARGET_64BIT", "&&", "ix86_broadcast", "(", "val", ",", "GET_MODE_BITSIZE", "(", "DImode", ")", ",", "val_broadcast", ")", ")", "broadcast_mode", "=", "DImode", ";", "else", "return", "nullptr", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "CONST_WIDE_INT_NUNITS", "(", "op", ")", ";", "i", "++", ")", "if", "(", "val", "!=", "CONST_WIDE_INT_ELT", "(", "op", ",", "i", ")", ")", "return", "nullptr", ";", "unsigned", "int", "nunits", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "/", "GET_MODE_SIZE", "(", "broadcast_mode", ")", ")", ";", "machine_mode", "vector_mode", ";", "if", "(", "!", "mode_for_vector", "(", "broadcast_mode", ",", "nunits", ")", ".", "exists", "(", "&", "vector_mode", ")", ")", "gcc_unreachable", "(", ")", ";", "rtx", "target", "=", "ix86_gen_scratch_sse_rtx", "(", "vector_mode", ")", ";", "bool", "ok", "=", "ix86_expand_vector_init_duplicate", "(", "false", ",", "vector_mode", ",", "target", ",", "GEN_INT", "(", "val_broadcast", ")", ")", ";", "gcc_assert", "(", "ok", ")", ";", "target", "=", "lowpart_subreg", "(", "mode", ",", "target", ",", "vector_mode", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Convert", "the", "CONST_WIDE_INT", "operand", "OP", "to", "broadcast", "in", "MODE", "." ]

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

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "SystemZInstPrinter", "::", "printAddress", "(", "MAI", ",", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ",", "MCOperand", "::", "createImm", "(", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "getImm", "(", ")", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "2", ")", ".", "getReg", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "1", "2" ]

[]

[ "<s>", "static", "void", "mips16_split_long_branches", "(", "void", ")", "{", "bool", "something_changed", ";", "if", "(", "!", "TARGET_MIPS16", ")", "return", ";", "do", "{", "rtx_insn", "*", "insn", ";", "rtx_jump_insn", "*", "jump_insn", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "something_changed", "=", "false", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "(", "jump_insn", "=", "dyn_cast", "<", "rtx_jump_insn", "*", ">", "(", "insn", ")", ")", "&&", "get_attr_length", "(", "jump_insn", ")", ">", "4", "&&", "(", "any_condjump_p", "(", "jump_insn", ")", "||", "any_uncondjump_p", "(", "jump_insn", ")", ")", ")", "{", "rtx", "old_label", ",", "temp", ",", "saved_temp", ";", "rtx_code_label", "*", "new_label", ";", "rtx", "target", ";", "rtx_insn", "*", "jump", ",", "*", "jump_sequence", ";", "start_sequence", "(", ")", ";", "saved_temp", "=", "gen_rtx_REG", "(", "Pmode", ",", "AT_REGNUM", ")", ";", "temp", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_REG_FIRST", "+", "2", ")", ";", "emit_move_insn", "(", "saved_temp", ",", "temp", ")", ";", "old_label", "=", "JUMP_LABEL", "(", "jump_insn", ")", ";", "target", "=", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "old_label", ")", ";", "mips16_load_branch_target", "(", "temp", ",", "target", ")", ";", "jump", "=", "emit_jump_insn", "(", "PMODE_INSN", "(", "gen_indirect_jump_and_restore", ",", "(", "temp", ",", "temp", ",", "saved_temp", ")", ")", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "old_label", ";", "LABEL_NUSES", "(", "old_label", ")", "++", ";", "mips16_lay_out_constants", "(", "false", ")", ";", "if", "(", "simplejump_p", "(", "jump_insn", ")", ")", "new_label", "=", "NULL", ";", "else", "{", "new_label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "new_label", ")", ";", "}", "jump_sequence", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_after", "(", "jump_sequence", ",", "jump_insn", ")", ";", "if", "(", "new_label", ")", "invert_jump", "(", "jump_insn", ",", "new_label", ",", "false", ")", ";", "else", "delete_insn", "(", "jump_insn", ")", ";", "something_changed", "=", "true", ";", "}", "}", "while", "(", "something_changed", ")", ";", "}", "</s>" ]

[ "If", "we", "'re", "compiling", "a", "MIPS16", "function", ",", "look", "for", "and", "split", "any", "long", "branches", ".", "This", "must", "be", "called", "after", "all", "other", "instruction", "modifications", "in", "mips_reorg", "." ]

[ "mips", "4", "2" ]

[]

[ "<s>", "bool", "X86InsertPrefetch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "Reader", ")", "return", "false", ";", "const", "FunctionSamples", "*", "Samples", "=", "Reader", "->", "getSamplesFor", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "if", "(", "!", "Samples", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "PrefetchInfo", ",", "4", ">", "Prefetches", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "instr_begin", "(", ")", ";", "MI", "!=", "MBB", ".", "instr_end", "(", ")", ";", ")", "{", "auto", "Current", "=", "MI", ";", "++", "MI", ";", "int", "Offset", "=", "X86II", "::", "getMemoryOperandNo", "(", "Current", "->", "getDesc", "(", ")", ".", "TSFlags", ")", ";", "if", "(", "Offset", "<", "0", ")", "continue", ";", "unsigned", "Bias", "=", "X86II", "::", "getOperandBias", "(", "Current", "->", "getDesc", "(", ")", ")", ";", "int", "MemOpOffset", "=", "Offset", "+", "Bias", ";", "if", "(", "!", "IsMemOpCompatibleWithPrefetch", "(", "*", "Current", ",", "MemOpOffset", ")", ")", "continue", ";", "Prefetches", ".", "clear", "(", ")", ";", "if", "(", "!", "findPrefetchInfo", "(", "Samples", ",", "*", "Current", ",", "Prefetches", ")", ")", "continue", ";", "assert", "(", "!", "Prefetches", ".", "empty", "(", ")", "&&", "\"The Prefetches vector should contain at least a value if \"", "\"findPrefetchInfo returned true.\"", ")", ";", "for", "(", "auto", "&", "PrefInfo", ":", "Prefetches", ")", "{", "unsigned", "PFetchInstrID", "=", "PrefInfo", ".", "InstructionID", ";", "int64_t", "Delta", "=", "PrefInfo", ".", "Delta", ";", "const", "MCInstrDesc", "&", "Desc", "=", "TII", "->", "get", "(", "PFetchInstrID", ")", ";", "MachineInstr", "*", "PFetch", "=", "MF", ".", "CreateMachineInstr", "(", "Desc", ",", "Current", "->", "getDebugLoc", "(", ")", ",", "true", ")", ";", "MachineInstrBuilder", "MIB", "(", "MF", ",", "PFetch", ")", ";", "assert", "(", "X86", "::", "AddrBaseReg", "==", "0", "&&", "X86", "::", "AddrScaleAmt", "==", "1", "&&", "X86", "::", "AddrIndexReg", "==", "2", "&&", "X86", "::", "AddrDisp", "==", "3", "&&", "X86", "::", "AddrSegmentReg", "==", "4", "&&", "\"Unexpected change in X86 operand offset order.\"", ")", ";", "MIB", ".", "addReg", "(", "Current", "->", "getOperand", "(", "MemOpOffset", "+", "X86", "::", "AddrBaseReg", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "Current", "->", "getOperand", "(", "MemOpOffset", "+", "X86", "::", "AddrScaleAmt", ")", ".", "getImm", "(", ")", ")", ".", "addReg", "(", "Current", "->", "getOperand", "(", "MemOpOffset", "+", "X86", "::", "AddrIndexReg", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "Current", "->", "getOperand", "(", "MemOpOffset", "+", "X86", "::", "AddrDisp", ")", ".", "getImm", "(", ")", "+", "Delta", ")", ".", "addReg", "(", "Current", "->", "getOperand", "(", "MemOpOffset", "+", "X86", "::", "AddrSegmentReg", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "Current", "->", "memoperands_empty", "(", ")", ")", "{", "MachineMemOperand", "*", "CurrentOp", "=", "*", "(", "Current", "->", "memoperands_begin", "(", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "CurrentOp", ",", "CurrentOp", "->", "getOffset", "(", ")", "+", "Delta", ",", "CurrentOp", "->", "getSize", "(", ")", ")", ")", ";", "}", "MBB", ".", "insert", "(", "Current", ",", "PFetch", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "4", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "\"The Prefetches vector should contain at least a value if \"", "\"findPrefetchInfo returned true.\"", "X86::AddrBaseReg", "0", "X86::AddrScaleAmt", "1", "X86::AddrIndexReg", "2", "X86::AddrDisp", "3", "X86::AddrSegmentReg", "4", "\"Unexpected change in X86 operand offset order.\"", "X86::AddrBaseReg", "X86::AddrScaleAmt", "X86::AddrIndexReg", "X86::AddrDisp", "X86::AddrSegmentReg" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "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", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "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", "X86", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "AttributeSet", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "ForCodeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Lanai", "::", "SFSUB_F_RI_LO", ":", "case", "Lanai", "::", "SFSUB_F_RI_HI", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "Register", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "Lanai", "::", "SFSUB_F_RR", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "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", "." ]

[ "Lanai", "Lanai", "Lanai::SFSUB_F_RI_LO", "Lanai::SFSUB_F_RI_HI", "0", "0", "1", "Lanai::SFSUB_F_RR", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "unsigned", "PopOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDMIA_UPD", ":", "ARM", "::", "LDMIA_UPD", ";", "unsigned", "LdrOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDR_POST", ":", "ARM", "::", "LDR_POST_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VLDMDIA_UPD", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "isVarArg", ",", "true", ",", "&", "isARMArea3Register", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea2Register", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea1Register", ")", ";", "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", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM::t2LDMIA_UPD", "ARM::LDMIA_UPD", "ARM::t2LDR_POST", "ARM::LDR_POST_IMM", "ARM::VLDMDIA_UPD", "0", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "rtx", "gen_acc1", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "56", ":", "57", ")", ";", "}", "</s>" ]

[ "Return", "a", "REG", "rtx", "for", "acc1", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "acc1", "and", "acc2", "." ]

[ "arc", "56", "57" ]

[]

[ "<s>", "bool", "SIInsertSkips", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "SkipThreshold", "=", "SkipThresholdFlag", ";", "bool", "HaveKill", "=", "false", ";", "bool", "MadeChange", "=", "false", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "16", ">", "ExecBranchStack", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "MachineBasicBlock", "*", "EmptyMBBAtEnd", "=", "nullptr", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "if", "(", "!", "ExecBranchStack", ".", "empty", "(", ")", "&&", "ExecBranchStack", ".", "back", "(", ")", "==", "&", "MBB", ")", "{", "ExecBranchStack", ".", "pop_back", "(", ")", ";", "}", "if", "(", "HaveKill", "&&", "ExecBranchStack", ".", "empty", "(", ")", ")", "{", "HaveKill", "=", "false", ";", "}", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "{", "ExecBranchStack", ".", "push_back", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "MadeChange", "|=", "skipMaskBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "S_BRANCH", ":", "{", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_KILL_TERMINATOR", ":", "{", "MadeChange", "=", "true", ";", "kill", "(", "MI", ")", ";", "if", "(", "ExecBranchStack", ".", "empty", "(", ")", ")", "{", "if", "(", "skipIfDead", "(", "MI", ",", "*", "NextBB", ")", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "BE", "=", "MF", ".", "end", "(", ")", ";", "Next", "=", "MBB", ".", "end", "(", ")", ";", "}", "}", "else", "{", "HaveKill", "=", "true", ";", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_RETURN", ":", "{", "assert", "(", "!", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "returnsVoid", "(", ")", ")", ";", "if", "(", "BI", "!=", "--", "MF", ".", "end", "(", ")", "||", "I", "!=", "MBB", ".", "getFirstTerminator", "(", ")", ")", "{", "if", "(", "!", "EmptyMBBAtEnd", ")", "{", "EmptyMBBAtEnd", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "MF", ".", "insert", "(", "MF", ".", "end", "(", ")", ",", "EmptyMBBAtEnd", ")", ";", "}", "MBB", ".", "addSuccessor", "(", "EmptyMBBAtEnd", ")", ";", "BuildMI", "(", "*", "BI", ",", "I", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "EmptyMBBAtEnd", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "}", "}", "default", ":", "break", ";", "}", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "16", "AMDGPU::SI_MASK_BRANCH", "0", "AMDGPU::S_BRANCH", "0", "AMDGPU::SI_KILL_TERMINATOR", "AMDGPU::SI_RETURN", "SI", "AMDGPU::S_BRANCH" ]

[]

[ "<s>", "unsigned", "CSKYMCCodeEmitter", "::", "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", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Unhandled expression!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"Unhandled expression!\"", "0" ]

[]

[ "<s>", "inline", "void", "count_registers", "(", "const_tree", "field", ",", "int", "bitpos", ",", "bool", "fp", ",", "assign_data_t", "*", "data", ")", "{", "if", "(", "fp", ")", "{", "int", "nregs", ";", "machine_mode", "mode", ";", "if", "(", "compute_int_layout", "(", "bitpos", ",", "data", ",", "&", "nregs", ")", ")", "data", "->", "nregs", "+=", "nregs", ";", "if", "(", "compute_fp_layout", "(", "field", ",", "bitpos", ",", "data", ",", "&", "nregs", ",", "&", "mode", ")", ")", "data", "->", "nregs", "+=", "nregs", ";", "}", "else", "{", "if", "(", "data", "->", "intoffset", "<", "0", ")", "data", "->", "intoffset", "=", "bitpos", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Count", "the", "number", "of", "registers", "to", "be", "assigned", "for", "FIELD", "and", "between", "PARMS-", ">", "intoffset", "and", "BITPOS", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "alias_set_type", "ix86_GOT_alias_set", "(", "void", ")", "{", "static", "alias_set_type", "set", "=", "-", "1", ";", "if", "(", "set", "==", "-", "1", ")", "set", "=", "new_alias_set", "(", ")", ";", "return", "set", ";", "}", "</s>" ]

[ "Return", "an", "unique", "alias", "set", "for", "the", "GOT", "." ]

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

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "return", "AnalyzeBranchImpl", "(", "MBB", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "BitVector", "Nios2RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "ReservedCPURegs", "[", "]", "=", "{", "Nios2", "::", "ZERO", ",", "Nios2", "::", "AT", ",", "Nios2", "::", "SP", ",", "Nios2", "::", "RA", ",", "Nios2", "::", "PC", ",", "Nios2", "::", "GP", "}", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "array_lengthof", "(", "ReservedCPURegs", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "ReservedCPURegs", "[", "I", "]", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2::ZERO", "Nios2::AT", "Nios2::SP", "Nios2::RA", "Nios2::PC", "Nios2::GP", "0" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "assert", "(", "!", "isFuncletEHPersonality", "(", "classifyEHPersonality", "(", "PersonalityFn", ")", ")", ")", ";", "return", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RDX", ":", "X86", "::", "EDX", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "X86", "X86", "X86::RDX", "X86::EDX" ]

[]

[ "<s>", "static", "bool", "expand_perm_with_merge", "(", "const", "struct", "expand_vec_perm_d", "&", "d", ")", "{", "bool", "merge_lo_p", "=", "true", ";", "bool", "merge_hi_p", "=", "true", ";", "if", "(", "d", ".", "nelt", "%", "2", ")", "return", "false", ";", "for", "(", "int", "telt", "=", "0", ";", "telt", "<", "d", ".", "nelt", ";", "telt", "++", ")", "if", "(", "d", ".", "perm", "[", "telt", "]", "!=", "telt", "/", "2", "+", "(", "telt", "%", "2", ")", "*", "d", ".", "nelt", ")", "{", "merge_hi_p", "=", "false", ";", "break", ";", "}", "if", "(", "!", "merge_hi_p", ")", "{", "for", "(", "int", "telt", "=", "0", ";", "telt", "<", "d", ".", "nelt", ";", "telt", "++", ")", "if", "(", "d", ".", "perm", "[", "telt", "]", "!=", "(", "telt", "+", "d", ".", "nelt", ")", "/", "2", "+", "(", "telt", "%", "2", ")", "*", "d", ".", "nelt", ")", "{", "merge_lo_p", "=", "false", ";", "break", ";", "}", "}", "else", "merge_lo_p", "=", "false", ";", "if", "(", "d", ".", "testing_p", ")", "return", "merge_lo_p", "||", "merge_hi_p", ";", "if", "(", "merge_lo_p", "||", "merge_hi_p", ")", "s390_expand_merge", "(", "d", ".", "target", ",", "d", ".", "op0", ",", "d", ".", "op1", ",", "merge_hi_p", ")", ";", "return", "merge_lo_p", "||", "merge_hi_p", ";", "}", "</s>" ]

[ "Try", "to", "expand", "the", "vector", "permute", "operation", "described", "by", "D", "using", "the", "vector", "merge", "instructions", "vml", "and", "vmh", ".", "Return", "true", "if", "vector", "merge", "could", "be", "used", "." ]

[ "s390", "2", "0", "2", "2", "0", "2", "2" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "LW", ")", "||", "(", "Opc", "==", "Mips", "::", "LD", ")", "||", "(", "Opc", "==", "Mips", "::", "LWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC164", ")", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::LW", "Mips::LD", "Mips::LWC1", "Mips::LDC1", "Mips::LDC164", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Combine STU / STI instructions\"", ";", "}", "</s>" ]

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

[ "TVM", "\"Combine STU / STI instructions\"" ]

[]

[ "<s>", "SDNode", "*", "NVPTXDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "SDNode", "*", "ResNode", "=", "NULL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "ResNode", "=", "SelectLoad", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "STORE", ":", "ResNode", "=", "SelectStore", "(", "N", ")", ";", "break", ";", "}", "if", "(", "ResNode", ")", "return", "ResNode", ";", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::LOAD", "ISD::STORE" ]

[]

[ "<s>", "void", "TriCoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "TriCore", "::", "A14", ":", "TriCore", "::", "A10", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TriCore", "::", "ADDrc", ")", "{", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";", "Offset", "=", "-", "Offset", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "TriCore", "::", "MOVDrr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "{", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "ADDrc", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "ADDrc", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "return", ";", "}", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "0", "\"Unexpected\"", "TriCore::A14", "TriCore::A10", "0", "TriCore::ADDrc", "TriCore::MOVDrr", "0", "0", "0", "TriCore::ADDrc", "TriCore::ADDrc", "1" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tLDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "4", "ARM::tLDRpci" ]

[]

[ "<s>", "static", "rtx", "arm_pic_static_addr", "(", "rtx", "orig", ",", "rtx", "reg", ")", "{", "rtx", "l1", ",", "labelno", ",", "offset_rtx", ",", "insn", ";", "gcc_assert", "(", "flag_pic", ")", ";", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "l1", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "l1", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "l1", ")", ";", "offset_rtx", "=", "plus_constant", "(", "Pmode", ",", "l1", ",", "TARGET_ARM", "?", "8", ":", "4", ")", ";", "offset_rtx", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "orig", ",", "offset_rtx", ")", ",", "UNSPEC_SYMBOL_OFFSET", ")", ";", "offset_rtx", "=", "gen_rtx_CONST", "(", "Pmode", ",", "offset_rtx", ")", ";", "insn", "=", "emit_insn", "(", "gen_pic_load_addr_unified", "(", "reg", ",", "offset_rtx", ",", "labelno", ")", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "the", "address", "of", "a", "static", "var", "when", "flag_pic", "is", "set", "." ]

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

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "X86InstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "uint16_t", "domain", "=", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "bool", "hasAVX2", "=", "Subtarget", ".", "hasAVX2", "(", ")", ";", "uint16_t", "validDomains", "=", "0", ";", "if", "(", "domain", "&&", "lookup", "(", "MI", "->", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "0xe", ";", "else", "if", "(", "domain", "&&", "lookupAVX2", "(", "MI", "->", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "hasAVX2", "?", "0xe", ":", "0x6", ";", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "X86", "X86", "X86II::SSEDomainShift", "3", "0", "0xe", "0xe", "0x6" ]

[]

[ "<s>", "inline", "static", "rtx_insn", "*", "emit_set_insn", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "y", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "insn", "that", "'s", "a", "simple", "single-set", ".", "Both", "the", "operands", "must", "be", "known", "to", "be", "valid", "." ]

[ "arm" ]

[]

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

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

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

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "SetVector", "<", "Function", "*", ">", "Functions", ";", "AnalysisGetter", "AG", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "Functions", ".", "insert", "(", "&", "F", ")", ";", "CallGraphUpdater", "CGUpdater", ";", "BumpPtrAllocator", "Allocator", ";", "AMDGPUInformationCache", "InfoCache", "(", "M", ",", "AG", ",", "Allocator", ",", "nullptr", ",", "*", "TM", ")", ";", "Attributor", "A", "(", "Functions", ",", "InfoCache", ",", "CGUpdater", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "A", ".", "getOrCreateAAFor", "<", "AAAMDAttributes", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "A", ".", "getOrCreateAAFor", "<", "AAAMDWorkGroupSize", ">", "(", "IRPosition", "::", "function", "(", "F", ")", ")", ";", "}", "ChangeStatus", "Change", "=", "A", ".", "run", "(", ")", ";", "return", "Change", "==", "ChangeStatus", "::", "CHANGED", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "void", "riscv_restore_reg", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "insn", "=", "riscv_emit_move", "(", "reg", ",", "mem", ")", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "dwarf", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Restore", "register", "REG", "from", "MEM", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "S2_storerb_io", ":", "case", "Hexagon", "::", "S2_storerh_io", ":", "case", "Hexagon", "::", "S2_storeri_io", ":", "case", "Hexagon", "::", "S2_storerd_io", ":", "case", "Hexagon", "::", "V6_vS32b_ai", ":", "case", "Hexagon", "::", "V6_vS32Ub_ai", ":", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "STriw_mod", ":", "case", "Hexagon", "::", "PS_vstorerq_ai", ":", "case", "Hexagon", "::", "PS_vstorerw_ai", ":", "{", "const", "MachineOperand", "&", "OpFI", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "OpOff", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "}", "case", "Hexagon", "::", "S2_pstorerbt_io", ":", "case", "Hexagon", "::", "S2_pstorerbf_io", ":", "case", "Hexagon", "::", "S2_pstorerht_io", ":", "case", "Hexagon", "::", "S2_pstorerhf_io", ":", "case", "Hexagon", "::", "S2_pstorerit_io", ":", "case", "Hexagon", "::", "S2_pstorerif_io", ":", "case", "Hexagon", "::", "S2_pstorerdt_io", ":", "case", "Hexagon", "::", "S2_pstorerdf_io", ":", "{", "const", "MachineOperand", "&", "OpFI", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "OpOff", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::S2_storerb_io", "Hexagon::S2_storerh_io", "Hexagon::S2_storeri_io", "Hexagon::S2_storerd_io", "Hexagon::V6_vS32b_ai", "Hexagon::V6_vS32Ub_ai", "Hexagon::STriw_pred", "Hexagon::STriw_mod", "Hexagon::PS_vstorerq_ai", "Hexagon::PS_vstorerw_ai", "0", "0", "1", "0", "0", "2", "Hexagon::S2_pstorerbt_io", "Hexagon::S2_pstorerbf_io", "Hexagon::S2_pstorerht_io", "Hexagon::S2_pstorerhf_io", "Hexagon::S2_pstorerit_io", "Hexagon::S2_pstorerif_io", "Hexagon::S2_pstorerdt_io", "Hexagon::S2_pstorerdf_io", "1", "0", "2", "0", "0", "3", "0" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "ix86_memmodel_check", "(", "unsigned", "HOST_WIDE_INT", "val", ")", "{", "enum", "memmodel", "model", "=", "memmodel_from_int", "(", "val", ")", ";", "bool", "strong", ";", "if", "(", "val", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "IX86_HLE_ACQUIRE", "|", "IX86_HLE_RELEASE", "|", "MEMMODEL_MASK", ")", "||", "(", "(", "val", "&", "IX86_HLE_ACQUIRE", ")", "&&", "(", "val", "&", "IX86_HLE_RELEASE", ")", ")", ")", "{", "warning", "(", "OPT_Winvalid_memory_model", ",", "\"unknown architecture specific memory model\"", ")", ";", "return", "MEMMODEL_SEQ_CST", ";", "}", "strong", "=", "(", "is_mm_acq_rel", "(", "model", ")", "||", "is_mm_seq_cst", "(", "model", ")", ")", ";", "if", "(", "val", "&", "IX86_HLE_ACQUIRE", "&&", "!", "(", "is_mm_acquire", "(", "model", ")", "||", "strong", ")", ")", "{", "warning", "(", "OPT_Winvalid_memory_model", ",", "\"%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger \"", "\"memory model\"", ")", ";", "return", "MEMMODEL_SEQ_CST", "|", "IX86_HLE_ACQUIRE", ";", "}", "if", "(", "val", "&", "IX86_HLE_RELEASE", "&&", "!", "(", "is_mm_release", "(", "model", ")", "||", "strong", ")", ")", "{", "warning", "(", "OPT_Winvalid_memory_model", ",", "\"%<HLE_RELEASE%> not used with %<RELEASE%> or stronger \"", "\"memory model\"", ")", ";", "return", "MEMMODEL_SEQ_CST", "|", "IX86_HLE_RELEASE", ";", "}", "return", "val", ";", "}", "</s>" ]

[ "Validate", "target", "specific", "memory", "model", "bits", "in", "VAL", "." ]

[ "i386", "\"unknown architecture specific memory model\"", "\"%<HLE_ACQUIRE%> not used with %<ACQUIRE%> or stronger \"", "\"memory model\"", "\"%<HLE_RELEASE%> not used with %<RELEASE%> or stronger \"", "\"memory model\"" ]

[]

[ "<s>", "static", "NodeRef", "getEntryNode", "(", "SPScope", "*", "G", ")", "{", "return", "G", ";", "}", "</s>" ]

[ "Return", "the", "token", "chain", "corresponding", "to", "the", "entry", "of", "the", "function", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "getTargetStreamer", "(", ")", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", "||", "isHsaAbiVersion2", "(", "getGlobalSTI", "(", ")", ")", ")", "getTargetStreamer", "(", ")", "->", "EmitISAVersion", "(", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "{", "HSAMetadataStream", "->", "end", "(", ")", ";", "bool", "Success", "=", "HSAMetadataStream", "->", "emitTo", "(", "*", "getTargetStreamer", "(", ")", ")", ";", "(", "void", ")", "Success", ";", "assert", "(", "Success", "&&", "\"Malformed HSA Metadata\"", ")", ";", "}", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "AMDGPU", "AMDGPU", "\"Malformed HSA Metadata\"" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "auto", "&", "Args", "=", "F", ".", "getArgumentList", "(", ")", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "i", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "1", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "MIRBuilder", ".", "buildSequence", "(", "VRegs", "[", "i", "]", ",", "Regs", ",", "Offsets", ")", ";", "}", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "ARCompact", "128" ]

[]

[ "<s>", "const", "char", "*", "TL45TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "TL45ISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "TL45ISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "TL45ISD", "::", "RET", ":", "return", "\"TL45ISD::RET\"", ";", "case", "TL45ISD", "::", "CALL", ":", "return", "\"TL45ISD::CALL\"", ";", "case", "TL45ISD", "::", "JMP", ":", "return", "\"TL45ISD::JMP\"", ";", "case", "TL45ISD", "::", "NAND", ":", "return", "\"TL45ISD::NAND\"", ";", "case", "TL45ISD", "::", "CMP_SKIP", ":", "return", "\"TL45ISD::CMP_SKIP\"", ";", "case", "TL45ISD", "::", "CMP_JMP", ":", "return", "\"TL45ISD::CMP_JMP\"", ";", "case", "TL45ISD", "::", "CMPI_JMP", ":", "return", "\"TL45ISD::CMPI_JMP\"", ";", "case", "TL45ISD", "::", "SUB_TERM", ":", "return", "\"TL45ISD::SUB_TERM\"", ";", "case", "TL45ISD", "::", "SELECT_MOVE", ":", "return", "\"TL45ISD::SELECT_MOVE\"", ";", "case", "TL45ISD", "::", "CMP_SELECT_MOVE", ":", "return", "\"TL45ISD::CMP_SELECT_MOVE\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45ISD::NodeType", "TL45ISD::FIRST_NUMBER", "TL45ISD::RET", "\"TL45ISD::RET\"", "TL45ISD::CALL", "\"TL45ISD::CALL\"", "TL45ISD::JMP", "\"TL45ISD::JMP\"", "TL45ISD::NAND", "\"TL45ISD::NAND\"", "TL45ISD::CMP_SKIP", "\"TL45ISD::CMP_SKIP\"", "TL45ISD::CMP_JMP", "\"TL45ISD::CMP_JMP\"", "TL45ISD::CMPI_JMP", "\"TL45ISD::CMPI_JMP\"", "TL45ISD::SUB_TERM", "\"TL45ISD::SUB_TERM\"", "TL45ISD::SELECT_MOVE", "\"TL45ISD::SELECT_MOVE\"", "TL45ISD::CMP_SELECT_MOVE", "\"TL45ISD::CMP_SELECT_MOVE\"" ]

[]

[ "<s>", "static", "scalar_int_mode", "spu_addr_space_address_mode", "(", "addr_space_t", "addrspace", ")", "{", "switch", "(", "addrspace", ")", "{", "case", "ADDR_SPACE_GENERIC", ":", "return", "Pmode", ";", "case", "ADDR_SPACE_EA", ":", "return", "EAmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "appropriate", "mode", "for", "a", "named", "address", "address", "." ]

[ "spu" ]

[]

[ "<s>", "SUnit", "*", "GCNMaxOccupancySchedStrategy", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "nullptr", ";", "}", "SUnit", "*", "SU", ";", "do", "{", "if", "(", "RegionPolicy", ".", "OnlyTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "CandPolicy", "NoPolicy", ";", "TopCand", ".", "reset", "(", "NoPolicy", ")", ";", "pickNodeFromQueue", "(", "Top", ",", "NoPolicy", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find a candidate\"", ")", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "RegionPolicy", ".", "OnlyBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "CandPolicy", "NoPolicy", ";", "BotCand", ".", "reset", "(", "NoPolicy", ")", ";", "pickNodeFromQueue", "(", "Bot", ",", "NoPolicy", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find a candidate\"", ")", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidirectional", "(", "IsTopNode", ")", ";", "}", "}", "while", "(", "SU", "->", "isScheduled", ")", ";", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "!", "HasClusteredNodes", "&&", "SU", "->", "getInstr", "(", ")", "->", "mayLoadOrStore", "(", ")", ")", "{", "for", "(", "SDep", "&", "Dep", ":", "SU", "->", "Preds", ")", "{", "if", "(", "Dep", ".", "isCluster", "(", ")", ")", "{", "HasClusteredNodes", "=", "true", ";", "break", ";", "}", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") \"", "<<", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"ReadyQ garbage\"", "\"failed to find a candidate\"", "\"failed to find a candidate\"", "\"Scheduling SU(\"", "\") \"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"OR1K PIC Global Base Reg Initialization\"", ";", "}", "</s>" ]

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

[ "OR1K", "\"OR1K PIC Global Base Reg Initialization\"" ]

[]

[ "<s>", "bool", "XCoreInstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "true", ";", "}", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineModuleInfo", "*", "MMI", "=", "MFI", "->", "getMachineModuleInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "MBB", ".", "addLiveIn", "(", "it", "->", "getReg", "(", ")", ")", ";", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "it", "->", "getReg", "(", ")", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "it", "->", "getRegClass", "(", ")", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "unsigned", "SaveLabelId", "=", "MMI", "->", "NextLabelID", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "XCore", "::", "DBG_LABEL", ")", ")", ".", "addImm", "(", "SaveLabelId", ")", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "pair", "<", "unsigned", ",", "CalleeSavedInfo", ">", "(", "SaveLabelId", ",", "*", "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::DBG_LABEL" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "GV", ")", ")", "return", ";", "assert", "(", "!", "GV", "->", "getName", "(", ")", ".", "startswith", "(", "\"llvm.\"", ")", "&&", "\"Unhandled intrinsic global variable.\"", ")", ";", "ValidateGV", "(", "GV", ")", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "if", "(", "GV", "->", "isDeclarationForLinker", "(", ")", ")", "{", "emitLinkage", "(", "GV", ",", "GVSym", ")", ";", "return", ";", "}", "SectionKind", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"", ")", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", ",", "TM", ")", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "Align", "Alignment", "=", "GV", "->", "getAlign", "(", ")", ".", "getValueOr", "(", "DL", ".", "getPreferredAlign", "(", "GV", ")", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "OutContext", ".", "getOrCreateSymbol", "(", "GVSym", "->", "getUnqualifiedName", "(", ")", ")", ",", "Size", ",", "GVSym", ",", "Alignment", ".", "value", "(", ")", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "GVSym", ",", "Size", ",", "Alignment", ".", "value", "(", ")", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "llvm", "::", "for_each", "(", "GOAliasMap", "[", "GV", "]", ",", "[", "this", "]", "(", "const", "GlobalAlias", "*", "Alias", ")", "{", "OutStreamer", "->", "emitLabel", "(", "getSymbol", "(", "Alias", ")", ")", ";", "}", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "PowerPC", "PPC", "\"llvm.\"", "\"Unhandled intrinsic global variable.\"", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "return", "MI", "->", "getDesc", "(", ")", ".", "isPredicable", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "BitVector", "MSP430RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "PCW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SPW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "SRW", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "CGW", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "MSP430", "::", "FPB", ")", ";", "Reserved", ".", "set", "(", "MSP430", "::", "FPW", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::PCB", "MSP430::SPB", "MSP430::SRB", "MSP430::CGB", "MSP430::PCW", "MSP430::SPW", "MSP430::SRW", "MSP430::CGW", "MSP430::FPB", "MSP430::FPW" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "NVPTXFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "sparc_profile_hook", "(", "int", "labelno", ")", "{", "char", "buf", "[", "32", "]", ";", "rtx", "lab", ",", "fun", ";", "fun", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "MCOUNT_FUNCTION", ")", ";", "if", "(", "NO_PROFILE_COUNTERS", ")", "{", "emit_library_call", "(", "fun", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "0", ")", ";", "}", "else", "{", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LP\"", ",", "labelno", ")", ";", "lab", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "buf", ")", ")", ";", "emit_library_call", "(", "fun", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "lab", ",", "Pmode", ")", ";", "}", "}", "</s>" ]

[ "Output", "rtl", "to", "increment", "the", "profiler", "label", "LABELNO", "for", "profiling", "a", "function", "entry", "." ]

[ "sparc", "32", "0", "\"LP\"", "1" ]

[]

[ "<s>", "static", "char", "*", "locate_lib", "(", "char", "*", "lib_name", ")", "{", "int", "lib_len", "=", "strlen", "(", "lib_name", ")", ";", "const", "char", "*", "exts", "[", "3", "]", ";", "int", "i", ";", "if", "(", "staticp", ")", "{", "exts", "[", "0", "]", "=", "\".a\"", ";", "exts", "[", "1", "]", "=", "\".olb\"", ";", "exts", "[", "2", "]", "=", "\".exe\"", ";", "}", "else", "{", "exts", "[", "0", "]", "=", "\".exe\"", ";", "exts", "[", "1", "]", "=", "\".a\"", ";", "exts", "[", "2", "]", "=", "\".olb\"", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "search_dirs_len", ";", "i", "++", ")", "{", "char", "*", "buf", ";", "int", "l", ";", "int", "j", ";", "l", "=", "strlen", "(", "search_dirs", "[", "i", "]", ")", ";", "buf", "=", "(", "char", "*", ")", "alloca", "(", "l", "+", "4", "+", "lib_len", "+", "4", "+", "1", ")", ";", "memcpy", "(", "buf", ",", "search_dirs", "[", "i", "]", ",", "l", ")", ";", "memcpy", "(", "buf", "+", "l", ",", "\"/lib\"", ",", "4", ")", ";", "l", "+=", "4", ";", "memcpy", "(", "buf", "+", "l", ",", "lib_name", ",", "lib_len", ")", ";", "l", "+=", "lib_len", ";", "for", "(", "j", "=", "0", ";", "j", "<", "3", ";", "j", "++", ")", "{", "strcpy", "(", "buf", "+", "l", ",", "exts", "[", "j", "]", ")", ";", "if", "(", "is_regular_file", "(", "buf", ")", ")", "return", "xstrdup", "(", "to_host_file_spec", "(", "buf", ")", ")", ";", "}", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Locate", "library", "LIB_NAME", "on", "the", "library", "path", "." ]

[ "vms", "3", "0", "\".a\"", "1", "\".olb\"", "2", "\".exe\"", "0", "\".exe\"", "1", "\".a\"", "2", "\".olb\"", "0", "4", "4", "1", "\"/lib\"", "4", "4", "0", "3" ]

[]

[ "<s>", "static", "bool", "epiphany_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "(", "regno", "&", "1", ")", "==", "0", "&&", "GPR_P", "(", "regno", ")", ";", "else", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "epiphany", "1", "0" ]

[]

[ "<s>", "void", "XCoreTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "Results", ".", "push_back", "(", "ExpandADDSUB", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "XCore", "XCore", "\"Don't know how to custom expand this!\"", "ISD::ADD", "ISD::SUB" ]

[]

[ "<s>", "void", "pa_asm_output_aligned_common", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "unsigned", "int", "max_common_align", ";", "max_common_align", "=", "TARGET_64BIT", "?", "128", ":", "(", "size", ">=", "4096", "?", "256", ":", "64", ")", ";", "if", "(", "align", ">", "max_common_align", ")", "{", "warning", "(", "0", ",", "\"alignment (%u) for %s exceeds maximum alignment \"", "\"for global common data. Using %u\"", ",", "align", "/", "BITS_PER_UNIT", ",", "name", ",", "max_common_align", "/", "BITS_PER_UNIT", ")", ";", "align", "=", "max_common_align", ";", "}", "switch_to_section", "(", "bss_section", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.comm \"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\"\\n\"", ",", "MAX", "(", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "}", "</s>" ]

[ "Both", "the", "HP", "and", "GNU", "assemblers", "under", "HP-UX", "provide", "a", ".comm", "directive", "that", "does", "n't", "allow", "the", "alignment", "of", "global", "common", "storage", "to", "be", "directly", "specified", ".", "The", "SOM", "linker", "aligns", "common", "storage", "based", "on", "the", "rounded", "value", "of", "the", "NUM_BYTES", "parameter", "in", "the", ".comm", "directive", ".", "It", "'s", "not", "possible", "to", "use", "the", ".align", "directive", "as", "it", "does", "n't", "affect", "the", "alignment", "of", "the", "label", "associated", "with", "a", ".comm", "directive", "." ]

[ "pa", "128", "4096", "256", "64", "0", "\"alignment (%u) for %s exceeds maximum alignment \"", "\"for global common data. Using %u\"", "\"\\t.comm \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "riscv_store_data_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "out_set", ",", "in_set", ";", "rtx", "out_pat", ",", "in_pat", ";", "rtx", "out_exp", ",", "in_exp", ";", "int", "i", ",", "j", ";", "in_set", "=", "single_set", "(", "in_insn", ")", ";", "if", "(", "in_set", ")", "{", "if", "(", "MEM_P", "(", "SET_DEST", "(", "in_set", ")", ")", ")", "{", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "out_set", ")", "{", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "out_pat", ",", "0", ")", ";", "i", "++", ")", "{", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "0", ",", "i", ")", ";", "if", "(", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "out_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "out_exp", ")", "!=", "SET", ")", "return", "false", ";", "}", "}", "}", "}", "}", "else", "{", "in_pat", "=", "PATTERN", "(", "in_insn", ")", ";", "if", "(", "GET_CODE", "(", "in_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "in_pat", ",", "0", ")", ";", "i", "++", ")", "{", "in_exp", "=", "XVECEXP", "(", "in_pat", ",", "0", ",", "i", ")", ";", "if", "(", "(", "GET_CODE", "(", "in_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "in_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "in_exp", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "MEM_P", "(", "SET_DEST", "(", "in_exp", ")", ")", ")", "{", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "out_set", ")", "{", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "out_pat", ",", "0", ")", ";", "j", "++", ")", "{", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "0", ",", "j", ")", ";", "if", "(", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "out_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "out_exp", ")", "!=", "SET", ")", "return", "false", ";", "}", "}", "}", "}", "}", "return", "store_data_bypass_p", "(", "out_insn", ",", "in_insn", ")", ";", "}", "</s>" ]

[ "Given", "that", "there", "exists", "at", "least", "one", "variable", "that", "is", "set", "(", "produced", ")", "by", "OUT_INSN", "and", "read", "(", "consumed", ")", "by", "IN_INSN", ",", "return", "true", "iff", "IN_INSN", "represents", "one", "or", "more", "memory", "store", "operations", "and", "none", "of", "the", "variables", "set", "by", "OUT_INSN", "is", "used", "by", "IN_INSN", "as", "the", "address", "of", "a", "store", "operation", ".", "If", "either", "IN_INSN", "or", "OUT_INSN", "does", "not", "represent", "a", "``", "single", "''", "RTL", "SET", "expression", "(", "as", "loosely", "defined", "by", "the", "implementation", "of", "the", "single_set", "function", ")", "or", "a", "PARALLEL", "with", "only", "SETs", ",", "CLOBBERs", ",", "and", "USEs", "inside", ",", "this", "function", "returns", "false", ".", "Borrowed", "from", "rs6000", ",", "riscv_store_data_bypass_p", "checks", "for", "certain", "conditions", "that", "result", "in", "assertion", "failures", "in", "the", "generic", "store_data_bypass_p", "function", "and", "returns", "FALSE", "in", "such", "cases", ".", "This", "is", "required", "to", "make", "-msave-restore", "work", "with", "the", "sifive-7", "pipeline", "description", "." ]

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

[]

[ "<s>", "static", "void", "frv_reorg", "(", "void", ")", "{", "if", "(", "optimize", ">", "0", "&&", "TARGET_OPTIMIZE_MEMBAR", "&&", "cfun", "->", "machine", "->", "has_membar_p", ")", "frv_optimize_membar", "(", ")", ";", "frv_num_nops", "=", "0", ";", "frv_register_nop", "(", "gen_nop", "(", ")", ")", ";", "if", "(", "TARGET_MEDIA", ")", "frv_register_nop", "(", "gen_mnop", "(", ")", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "frv_register_nop", "(", "gen_fnop", "(", ")", ")", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "frv_packet_address", "=", "0", ";", "frv_for_each_packet", "(", "frv_reorg_packet", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MACHINE_DEPENDENT_REORG", ".", "Divide", "the", "instructions", "into", "packets", "and", "check", "whether", "we", "need", "to", "insert", "nops", "in", "order", "to", "fulfill", "the", "processor", "'s", "issue", "requirements", ".", "Also", ",", "if", "the", "user", "has", "requested", "a", "certain", "alignment", "for", "a", "label", ",", "try", "to", "meet", "that", "alignment", "by", "inserting", "nops", "in", "the", "previous", "packet", "." ]

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

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "||", "Subtarget", "->", "isTargetMachO", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "MRI", ".", "isPhysRegUsed", "(", "*", "I", ")", ")", "return", "*", "I", ";", "}", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]

[ "Returns", "a", "lowest", "register", "that", "is", "not", "used", "at", "any", "point", "in", "the", "function", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "static", "rtx", "rl78_subreg", "(", "machine_mode", "mode", ",", "rtx", "r", ",", "machine_mode", "omode", ",", "int", "byte", ")", "{", "if", "(", "GET_CODE", "(", "r", ")", "==", "MEM", ")", "return", "adjust_address", "(", "r", ",", "mode", ",", "byte", ")", ";", "else", "return", "simplify_gen_subreg", "(", "mode", ",", "r", ",", "omode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Simplify_gen_subreg", "(", ")", "does", "n't", "handle", "memory", "references", "the", "way", "we", "need", "it", "to", "below", ",", "so", "we", "use", "this", "function", "for", "when", "we", "must", "get", "a", "valid", "subreg", "in", "a", "``", "natural", "''", "state", "." ]

[ "rl78" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "int", "pru_function_arg_regi", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "size_t", "argsize", "=", "pru_function_arg_size", "(", "mode", ",", "type", ")", ";", "size_t", "i", ",", "bi", ";", "int", "regi", "=", "-", "1", ";", "if", "(", "!", "pru_arg_in_reg_bysize", "(", "argsize", ")", ")", "return", "-", "1", ";", "if", "(", "!", "named", ")", "return", "-", "1", ";", "for", "(", "i", "=", "0", ";", "regi", "<", "0", "&&", "i", "<", "ARRAY_SIZE", "(", "cum", "->", "regs_used", ")", ";", "i", "++", ")", "{", "gcc_assert", "(", "argsize", "==", "1", "||", "argsize", "==", "2", "||", "argsize", "==", "3", "||", "argsize", "==", "4", "||", "argsize", "==", "8", ")", ";", "if", "(", "(", "argsize", ">=", "4", ")", "&&", "(", "i", "%", "4", ")", "!=", "0", ")", "continue", ";", "if", "(", "argsize", "==", "3", "&&", "(", "i", "%", "4", ")", "!=", "0", ")", "continue", ";", "if", "(", "argsize", "==", "2", "&&", "(", "i", "%", "4", ")", "==", "3", ")", "continue", ";", "for", "(", "bi", "=", "0", ";", "bi", "<", "argsize", "&&", "(", "bi", "+", "i", ")", "<", "ARRAY_SIZE", "(", "cum", "->", "regs_used", ")", ";", "bi", "++", ")", "{", "if", "(", "cum", "->", "regs_used", "[", "bi", "+", "i", "]", ")", "break", ";", "}", "if", "(", "bi", "==", "argsize", ")", "regi", "=", "FIRST_ARG_REGNUM", "+", "i", ";", "}", "return", "regi", ";", "}", "</s>" ]

[ "Helper", "function", "to", "get", "the", "starting", "storage", "HW", "register", "for", "an", "argument", ",", "or", "-1", "if", "it", "must", "be", "passed", "on", "stack", ".", "The", "cum_v", "state", "is", "not", "changed", "." ]

[ "pru", "1", "1", "1", "0", "0", "1", "2", "3", "4", "8", "4", "4", "0", "3", "4", "0", "2", "4", "3", "0" ]

[]

[ "<s>", "bool", "function_expander", "::", "overlaps_input_p", "(", "rtx", "x", ")", "{", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "args", ".", "length", "(", ")", ";", "++", "i", ")", "if", "(", "reg_overlap_mentioned_p", "(", "x", ",", "args", "[", "i", "]", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "overlaps", "any", "input", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "int", "m32c_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "cost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "HARD_REG_SET", "cc", ";", "cc", "=", "reg_class_contents", "[", "from", "]", "|", "reg_class_contents", "[", "(", "int", ")", "to", "]", ";", "if", "(", "mode", "==", "QImode", "&&", "hard_reg_set_intersect_p", "(", "cc", ",", "reg_class_contents", "[", "R23_REGS", "]", ")", ")", "{", "if", "(", "hard_reg_set_subset_p", "(", "cc", ",", "reg_class_contents", "[", "R23_REGS", "]", ")", ")", "cost", "=", "COSTS_N_INSNS", "(", "1000", ")", ";", "else", "cost", "=", "COSTS_N_INSNS", "(", "80", ")", ";", "}", "if", "(", "!", "class_can_hold_mode", "(", "from", ",", "mode", ")", "||", "!", "class_can_hold_mode", "(", "to", ",", "mode", ")", ")", "cost", "=", "COSTS_N_INSNS", "(", "1000", ")", ";", "if", "(", "reg_classes_intersect_p", "(", "from", ",", "CR_REGS", ")", ")", "cost", "+=", "COSTS_N_INSNS", "(", "5", ")", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "CR_REGS", ")", ")", "cost", "+=", "COSTS_N_INSNS", "(", "5", ")", ";", "if", "(", "from", "==", "MEM_REGS", "||", "to", "==", "MEM_REGS", ")", "cost", "+=", "COSTS_N_INSNS", "(", "50", ")", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "from", ",", "MEM_REGS", ")", "||", "reg_classes_intersect_p", "(", "to", ",", "MEM_REGS", ")", ")", "cost", "+=", "COSTS_N_INSNS", "(", "10", ")", ";", "fprintf", "(", "stderr", ",", "\"register_move_cost %s from %s to %s = %d\\n\"", ",", "mode_name", "[", "mode", "]", ",", "class_names", "[", "(", "int", ")", "from", "]", ",", "class_names", "[", "(", "int", ")", "to", "]", ",", "cost", ")", ";", "return", "cost", ";", "}", "</s>" ]

[ "Implements", "REGISTER_MOVE_COST", ".", "We", "make", "impossible", "moves", "prohibitively", "expensive", ",", "like", "trying", "to", "put", "QIs", "in", "r2/r3", "(", "there", "are", "no", "opcodes", "to", "do", "that", ")", ".", "We", "also", "discourage", "use", "of", "mem", "*", "registers", "since", "they", "'re", "really", "memory", "." ]

[ "m32c", "3", "1000", "80", "1000", "5", "5", "50", "10", "\"register_move_cost %s from %s to %s = %d\\n\"" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTargetMachine", "(", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", "!=", "Intrinsic", "::", "ppc_is_decremented_ctr_nonzero", ")", "break", ";", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i1", "&&", "\"Unexpected result type for CTR decrement intrinsic\"", ")", ";", "EVT", "SVT", "=", "getSetCCResultType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "N", "->", "getValueType", "(", "0", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "SVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "NewInt", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "NewInt", ")", ";", "Results", ".", "push_back", "(", "NewInt", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "VAARG", ":", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isSVR4ABI", "(", ")", "||", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ")", "return", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "{", "SDValue", "NewNode", "=", "LowerVAARG", "(", "SDValue", "(", "N", ",", "1", ")", ",", "DAG", ",", "PPCSubTarget", ")", ";", "Results", ".", "push_back", "(", "NewNode", ")", ";", "Results", ".", "push_back", "(", "NewNode", ".", "getValue", "(", "1", ")", ")", ";", "}", "return", ";", "}", "case", "ISD", "::", "FP_ROUND_INREG", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "ppcf128", ")", ";", "assert", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "0", ")", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "dl", ",", "MVT", "::", "f64", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ")", ")", ";", "SDValue", "FPreg", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "FADDRTZ", ",", "dl", ",", "MVT", "::", "f64", ",", "Lo", ",", "Hi", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "ppcf128", ",", "FPreg", ",", "FPreg", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "ppcf128", ")", "return", ";", "Results", ".", "push_back", "(", "LowerFP_TO_INT", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "dl", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "PowerPC", "PPC", "\"Do not know how to custom type legalize this operation!\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ppc_is_decremented_ctr_nonzero", "0", "MVT::i1", "\"Unexpected result type for CTR decrement intrinsic\"", "0", "MVT::Other", "0", "1", "1", "ISD::VAARG", "PPC", "PPC", "PPC", "0", "MVT::i64", "1", "PPC", "1", "ISD::FP_ROUND_INREG", "0", "MVT::ppcf128", "0", "MVT::ppcf128", "ISD::EXTRACT_ELEMENT", "MVT::f64", "0", "0", "ISD::EXTRACT_ELEMENT", "MVT::f64", "0", "1", "PPCISD::FADDRTZ", "MVT::f64", "ISD::BUILD_PAIR", "MVT::ppcf128", "ISD::FP_TO_SINT", "0", "MVT::ppcf128", "0" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "convertToThreeAddress", "(", "MachineFunction", "::", "iterator", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "LiveVariables", "*", "LV", ")", "const", "{", "bool", "IsF16", "=", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "nullptr", ";", "case", "AMDGPU", "::", "V_MAC_F16_e64", ":", "IsF16", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "AMDGPU", "::", "V_MAC_F32_e64", ":", "break", ";", "case", "AMDGPU", "::", "V_MAC_F16_e32", ":", "IsF16", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "AMDGPU", "::", "V_MAC_F32_e32", ":", "{", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "const", "MachineOperand", "*", "Src0", "=", "&", "MI", ".", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "Src0", "->", "isImm", "(", ")", "&&", "!", "isInlineConstant", "(", "MI", ",", "Src0Idx", ",", "*", "Src0", ")", ")", "return", "nullptr", ";", "break", ";", "}", "}", "const", "MachineOperand", "*", "Dst", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "const", "MachineOperand", "*", "Src0", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "const", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ";", "const", "MachineOperand", "*", "Src1", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "const", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "const", "MachineOperand", "*", "Src2", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "const", "MachineOperand", "*", "Clamp", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "clamp", ")", ";", "const", "MachineOperand", "*", "Omod", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "omod", ")", ";", "return", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "IsF16", "?", "AMDGPU", "::", "V_MAD_F16", ":", "AMDGPU", "::", "V_MAD_F32", ")", ")", ".", "add", "(", "*", "Dst", ")", ".", "addImm", "(", "Src0Mods", "?", "Src0Mods", "->", "getImm", "(", ")", ":", "0", ")", ".", "add", "(", "*", "Src0", ")", ".", "addImm", "(", "Src1Mods", "?", "Src1Mods", "->", "getImm", "(", ")", ":", "0", ")", ".", "add", "(", "*", "Src1", ")", ".", "addImm", "(", "0", ")", ".", "add", "(", "*", "Src2", ")", ".", "addImm", "(", "Clamp", "?", "Clamp", "->", "getImm", "(", ")", ":", "0", ")", ".", "addImm", "(", "Omod", "?", "Omod", "->", "getImm", "(", ")", ":", "0", ")", ";", "}", "</s>" ]

[ "convertToThreeAddress", "-", "This", "method", "must", "be", "implemented", "by", "targets", "that", "set", "the", "M_CONVERTIBLE_TO_3_ADDR", "flag", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MAC_F16_e64", "AMDGPU::V_MAC_F32_e64", "AMDGPU::V_MAC_F16_e32", "AMDGPU::V_MAC_F32_e32", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::V_MAD_F16", "AMDGPU::V_MAD_F32", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "MOSAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "int", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "uint32_t", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "if", "(", "Kind", "==", "MOS", "::", "AddrAsciz", ")", "{", "std", "::", "string", "ValueStr", "=", "utostr", "(", "Value", ")", ";", "assert", "(", "(", "(", "ValueStr", ".", "size", "(", ")", "+", "1", "+", "Offset", ")", "<=", "Data", ".", "size", "(", ")", ")", "&&", "\"Invalid offset within MOS instruction for modifier!\"", ")", ";", "std", "::", "copy", "(", "ValueStr", ".", "begin", "(", ")", ",", "ValueStr", ".", "end", "(", ")", ",", "Data", ".", "begin", "(", ")", "+", "Offset", ")", ";", "Data", "[", "Offset", "+", "ValueStr", ".", "size", "(", ")", "]", "=", "'\\0'", ";", "return", ";", "}", "unsigned", "int", "Bytes", "=", "0", ";", "switch", "(", "Kind", ")", "{", "case", "MOS", "::", "Imm8", ":", "case", "MOS", "::", "Addr8", ":", "case", "MOS", "::", "Addr16_High", ":", "case", "MOS", "::", "Addr16_Low", ":", "case", "MOS", "::", "Addr24_Bank", ":", "case", "MOS", "::", "Addr24_Segment_Low", ":", "case", "MOS", "::", "Addr24_Segment_High", ":", "case", "MOS", "::", "PCRel8", ":", "case", "FK_Data_1", ":", "Bytes", "=", "1", ";", "break", ";", "case", "FK_Data_2", ":", "case", "MOS", "::", "Imm16", ":", "case", "MOS", "::", "Addr16", ":", "case", "MOS", "::", "Addr24_Segment", ":", "case", "MOS", "::", "PCRel16", ":", "Bytes", "=", "2", ";", "break", ";", "case", "MOS", "::", "Addr24", ":", "Bytes", "=", "3", ";", "break", ";", "case", "FK_Data_4", ":", "Bytes", "=", "4", ";", "break", ";", "case", "FK_Data_8", ":", "Bytes", "=", "8", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown fixup kind\"", ")", ";", "return", ";", "}", "assert", "(", "(", "(", "Bytes", "+", "Offset", ")", "<=", "Data", ".", "size", "(", ")", ")", "&&", "\"Invalid offset within MOS instruction for modifier!\"", ")", ";", "char", "*", "RangeStart", "=", "Data", ".", "begin", "(", ")", "+", "Offset", ";", "for", "(", "char", "&", "Out", ":", "make_range", "(", "RangeStart", ",", "RangeStart", "+", "Bytes", ")", ")", "{", "Out", "=", "Value", "&", "0xff", ";", "Value", "=", "Value", ">>", "8", ";", "}", "}", "</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", "." ]

[ "MOS", "MOS", "MOS::AddrAsciz", "1", "\"Invalid offset within MOS instruction for modifier!\"", "0", "MOS::Imm8", "MOS::Addr8", "MOS::Addr16_High", "MOS::Addr16_Low", "MOS::Addr24_Bank", "MOS::Addr24_Segment_Low", "MOS::Addr24_Segment_High", "MOS::PCRel8", "1", "MOS::Imm16", "MOS::Addr16", "MOS::Addr24_Segment", "MOS::PCRel16", "2", "MOS::Addr24", "3", "4", "8", "\"unknown fixup kind\"", "\"Invalid offset within MOS instruction for modifier!\"", "0xff", "8" ]

[]

[ "<s>", "static", "rtx", "arm_expand_ternop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "tree", "arg2", "=", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "rtx", "op2", "=", "expand_normal", "(", "arg2", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "mode", ";", "machine_mode", "mode2", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "3", "]", ".", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode2", ")", ")", "op2", "=", "safe_vector_operand", "(", "op2", ",", "mode2", ")", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "gcc_assert", "(", "(", "GET_MODE", "(", "op0", ")", "==", "mode0", "||", "GET_MODE", "(", "op0", ")", "==", "VOIDmode", ")", "&&", "(", "GET_MODE", "(", "op1", ")", "==", "mode1", "||", "GET_MODE", "(", "op1", ")", "==", "VOIDmode", ")", "&&", "(", "GET_MODE", "(", "op2", ")", "==", "mode2", "||", "GET_MODE", "(", "op2", ")", "==", "VOIDmode", ")", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "3", "]", ".", "predicate", ")", "(", "op2", ",", "mode2", ")", ")", "op2", "=", "copy_to_mode_reg", "(", "mode2", ",", "op2", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ",", "op2", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Function", "to", "expand", "ternary", "builtins", "." ]

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

[]

[ "<s>", "bool", "ix86_expand_fp_movcc", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "tmp", ",", "compare_op", ";", "rtx", "op0", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ";", "if", "(", "TARGET_SSE_MATH", "&&", "SSE_FLOAT_MODE_P", "(", "mode", ")", ")", "{", "machine_mode", "cmode", ";", "cmode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "cmode", "==", "VOIDmode", ")", "cmode", "=", "GET_MODE", "(", "op1", ")", ";", "if", "(", "cmode", "!=", "mode", ")", "return", "false", ";", "code", "=", "ix86_prepare_sse_fp_compare_args", "(", "operands", "[", "0", "]", ",", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "if", "(", "code", "==", "UNKNOWN", ")", "return", "false", ";", "if", "(", "ix86_expand_sse_fp_minmax", "(", "operands", "[", "0", "]", ",", "code", ",", "op0", ",", "op1", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", "return", "true", ";", "tmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "code", ",", "op0", ",", "op1", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "ix86_expand_sse_movcc", "(", "operands", "[", "0", "]", ",", "tmp", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "return", "true", ";", "}", "if", "(", "GET_MODE", "(", "op0", ")", "==", "TImode", "||", "(", "GET_MODE", "(", "op0", ")", "==", "DImode", "&&", "!", "TARGET_64BIT", ")", ")", "return", "false", ";", "compare_op", "=", "ix86_expand_compare", "(", "code", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "fcmov_comparison_operator", "(", "compare_op", ",", "VOIDmode", ")", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "ix86_expand_setcc", "(", "tmp", ",", "code", ",", "op0", ",", "op1", ")", ";", "compare_op", "=", "ix86_expand_compare", "(", "NE", ",", "tmp", ",", "const0_rtx", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "compare_op", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "floating-point", "conditional", "move", ".", "Return", "true", "if", "successful", "." ]

[ "i386", "0", "1", "1", "0", "1", "1", "0", "0", "2", "3", "0", "2", "3", "0", "2", "3", "0", "2", "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", ")", ")", "{", "machine_mode", "mode", "=", "aarch64_reg_save_mode", "(", "regno", ")", ";", "if", "(", "mode", "==", "VNx2DImode", "&&", "BYTES_BIG_ENDIAN", ")", "continue", ";", "poly_int64", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "if", "(", "flag_stack_clash_protection", "&&", "maybe_ne", "(", "cfun", "->", "machine", "->", "frame", ".", "below_hard_fp_saved_regs_size", ",", "0", ")", "&&", "known_eq", "(", "offset", ",", "0", ")", ")", "continue", ";", "if", "(", "frame_pointer_needed", ")", "offset", "-=", "cfun", "->", "machine", "->", "frame", ".", "below_hard_fp_saved_regs_size", ";", "else", "offset", "+=", "crtl", "->", "outgoing_args_size", ";", "if", "(", "aarch64_sve_mode_p", "(", "mode", ")", "?", "offset_9bit_signed_scaled_p", "(", "mode", ",", "offset", ")", ":", "offset_12bit_unsigned_scaled_p", "(", "mode", ",", "offset", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "bitmap_clear_bit", "(", "components", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "spare_pred_reg", "!=", "INVALID_REGNUM", ")", "bitmap_clear_bit", "(", "components", ",", "cfun", "->", "machine", "->", "frame", ".", "spare_pred_reg", ")", ";", "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", "0", "0" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_vpshufb2_vpermq_even_odd", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "2", "]", "[", "32", "]", ",", "vperm", ",", "l", ",", "h", ",", "ior", ",", "op", ",", "m128", ";", "unsigned", "int", "i", ",", "nelt", ",", "eltsz", ";", "if", "(", "!", "TARGET_AVX2", "||", "d", "->", "one_operand_p", "||", "(", "d", "->", "vmode", "!=", "V32QImode", "&&", "d", "->", "vmode", "!=", "V16HImode", ")", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "d", "->", "nelt", ";", "++", "i", ")", "if", "(", "(", "d", "->", "perm", "[", "i", "]", "^", "(", "i", "*", "2", ")", ")", "&", "(", "3", "*", "d", "->", "nelt", "/", "2", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "nelt", "=", "d", "->", "nelt", ";", "eltsz", "=", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ";", "m128", "=", "GEN_INT", "(", "-", "128", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "j", ",", "e", "=", "d", "->", "perm", "[", "i", "]", "&", "(", "nelt", "/", "2", "-", "1", ")", ";", "unsigned", "which", "=", "d", "->", "perm", "[", "i", "]", ">=", "nelt", ";", "unsigned", "xorv", "=", "(", "i", ">=", "nelt", "/", "4", "&&", "i", "<", "3", "*", "nelt", "/", "4", ")", "?", "24", ":", "0", ";", "for", "(", "j", "=", "0", ";", "j", "<", "eltsz", ";", "++", "j", ")", "{", "rperm", "[", "which", "]", "[", "(", "i", "*", "eltsz", "+", "j", ")", "^", "xorv", "]", "=", "GEN_INT", "(", "e", "*", "eltsz", "+", "j", ")", ";", "rperm", "[", "1", "-", "which", "]", "[", "(", "i", "*", "eltsz", "+", "j", ")", "^", "xorv", "]", "=", "m128", ";", "}", "}", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "32", ",", "rperm", "[", "0", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V32QImode", ",", "vperm", ")", ";", "l", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V32QImode", ",", "d", "->", "op0", ")", ";", "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "l", ",", "op", ",", "vperm", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "32", ",", "rperm", "[", "1", "]", ")", ")", ";", "vperm", "=", "force_reg", "(", "V32QImode", ",", "vperm", ")", ";", "h", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "op", "=", "gen_lowpart", "(", "V32QImode", ",", "d", "->", "op1", ")", ";", "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "h", ",", "op", ",", "vperm", ")", ")", ";", "ior", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "emit_insn", "(", "gen_iorv32qi3", "(", "ior", ",", "l", ",", "h", ")", ")", ";", "op", "=", "gen_reg_rtx", "(", "V4DImode", ")", ";", "ior", "=", "gen_lowpart", "(", "V4DImode", ",", "ior", ")", ";", "emit_insn", "(", "gen_avx2_permv4di_1", "(", "op", ",", "ior", ",", "const0_rtx", ",", "const2_rtx", ",", "const1_rtx", ",", "GEN_INT", "(", "3", ")", ")", ")", ";", "emit_move_insn", "(", "d", "->", "target", ",", "gen_lowpart", "(", "d", "->", "vmode", ",", "op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "expand_vec_perm_even_odd_1", ".", "Implement", "extract-even", "and", "extract-odd", "permutations", "of", "two", "V32QImode", "and", "V16QImode", "operand", "with", "two", "vpshufb", "insns", ",", "vpor", "and", "vpermq", ".", "We", "should", "have", "already", "failed", "all", "two", "or", "three", "instruction", "sequences", "." ]

[ "i386", "2", "32", "0", "2", "3", "2", "128", "0", "2", "1", "4", "3", "4", "24", "0", "0", "1", "32", "0", "32", "1", "3" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_comi", "(", "const", "struct", "builtin_description", "*", "d", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "machine_mode", "mode0", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "enum", "rtx_code", "comparison", "=", "d", "->", "comparison", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "if", "(", "d", "->", "flag", "&", "BUILTIN_DESC_SWAP_OPERANDS", ")", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "target", ",", "const0_rtx", ")", ";", "target", "=", "gen_rtx_SUBREG", "(", "QImode", ",", "target", ",", "0", ")", ";", "if", "(", "(", "optimize", "&&", "!", "register_operand", "(", "op0", ",", "mode0", ")", ")", "||", "!", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "(", "optimize", "&&", "!", "register_operand", "(", "op1", ",", "mode1", ")", ")", "||", "!", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "d", "->", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_STRICT_LOW_PART", "(", "VOIDmode", ",", "target", ")", ",", "gen_rtx_fmt_ee", "(", "comparison", ",", "QImode", ",", "SET_DEST", "(", "pat", ")", ",", "const0_rtx", ")", ")", ")", ";", "return", "SUBREG_REG", "(", "target", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "ix86_expand_builtin", "to", "take", "care", "of", "comi", "insns", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_output_softstack_switch", "(", "FILE", "*", "file", ",", "bool", "entering", ",", "rtx", "ptr", ",", "rtx", "size", ",", "rtx", "align", ")", "{", "gcc_assert", "(", "REG_P", "(", "ptr", ")", "&&", "!", "HARD_REGISTER_P", "(", "ptr", ")", ")", ";", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "machine", "->", "simt_stack_size", ")", "return", ";", "int", "bits", "=", "POINTER_SIZE", ",", "regno", "=", "REGNO", "(", "ptr", ")", ";", "fprintf", "(", "file", ",", "\"\\t{\\n\"", ")", ";", "if", "(", "entering", ")", "{", "fprintf", "(", "file", ",", "\"\\t\\tcvta.local.u%d %%r%d, %%simtstack_ar + \"", "HOST_WIDE_INT_PRINT_DEC", "\";\\n\"", ",", "bits", ",", "regno", ",", "cfun", "->", "machine", "->", "simt_stack_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tsub.u%d %%r%d, %%r%d, \"", ",", "bits", ",", "regno", ",", "regno", ")", ";", "if", "(", "CONST_INT_P", "(", "size", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "ROUND_UP", "(", "UINTVAL", "(", "size", ")", ",", "GET_MODE_SIZE", "(", "DImode", ")", ")", ")", ";", "else", "output_reg", "(", "file", ",", "REGNO", "(", "size", ")", ",", "VOIDmode", ")", ";", "fputs", "(", "\";\\n\"", ",", "file", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "size", ")", "||", "UINTVAL", "(", "align", ")", ">", "GET_MODE_SIZE", "(", "DImode", ")", ")", "fprintf", "(", "file", ",", "\"\\t\\tand.u%d %%r%d, %%r%d, -\"", "HOST_WIDE_INT_PRINT_DEC", "\";\\n\"", ",", "bits", ",", "regno", ",", "regno", ",", "UINTVAL", "(", "align", ")", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "has_softstack", ")", "{", "const", "char", "*", "reg_stack", "=", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ";", "if", "(", "entering", ")", "{", "fprintf", "(", "file", ",", "\"\\t\\tst.u%d [%%r%d + -%d], %s;\\n\"", ",", "bits", ",", "regno", ",", "bits", "/", "8", ",", "reg_stack", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tsub.u%d %s, %%r%d, %d;\\n\"", ",", "bits", ",", "reg_stack", ",", "regno", ",", "bits", "/", "8", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\t\\tld.u%d %s, [%%r%d + -%d];\\n\"", ",", "bits", ",", "reg_stack", ",", "regno", ",", "bits", "/", "8", ")", ";", "}", "nvptx_output_set_softstack", "(", "REGNO", "(", "stack_pointer_rtx", ")", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\t}\\n\"", ")", ";", "}", "</s>" ]

[ "Output", "code", "for", "allocating", "per-lane", "storage", "and", "switching", "soft-stack", "pointer", ".", "ENTERING", "indicates", "whether", "we", "are", "entering", "or", "leaving", "non-uniform", "execution", ".", "PTR", "is", "the", "register", "pointing", "to", "allocated", "storage", ",", "it", "is", "assigned", "to", "on", "entering", "and", "used", "to", "restore", "state", "on", "leaving", ".", "SIZE", "and", "ALIGN", "are", "used", "only", "on", "entering", "." ]

[ "nvptx", "\"\\t{\\n\"", "\"\\t\\tcvta.local.u%d %%r%d, %%simtstack_ar + \"", "\";\\n\"", "\"\\t\\tsub.u%d %%r%d, %%r%d, \"", "\";\\n\"", "\"\\t\\tand.u%d %%r%d, %%r%d, -\"", "\";\\n\"", "\"\\t\\tst.u%d [%%r%d + -%d], %s;\\n\"", "8", "\"\\t\\tsub.u%d %s, %%r%d, %d;\\n\"", "8", "\"\\t\\tld.u%d %s, [%%r%d + -%d];\\n\"", "8", "\"\\t}\\n\"" ]

[]

[ "<s>", "int", "standard_sse_constant_p", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "x", "==", "const0_rtx", "||", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "1", ";", "if", "(", "vector_all_ones_operand", "(", "x", ",", "mode", ")", ")", "switch", "(", "mode", ")", "{", "case", "V16QImode", ":", "case", "V8HImode", ":", "case", "V4SImode", ":", "case", "V2DImode", ":", "if", "(", "TARGET_SSE2", ")", "return", "2", ";", "case", "V32QImode", ":", "case", "V16HImode", ":", "case", "V8SImode", ":", "case", "V4DImode", ":", "if", "(", "TARGET_AVX2", ")", "return", "2", ";", "case", "V64QImode", ":", "case", "V32HImode", ":", "case", "V16SImode", ":", "case", "V8DImode", ":", "if", "(", "TARGET_AVX512F", ")", "return", "2", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "X", "is", "all", "0s", "and", "2", "if", "x", "is", "all", "1s", "in", "supported", "SSE/AVX", "vector", "mode", "." ]

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

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "machreg_t", "inet_lnaof", "(", "machreg_t", "in", ")", "{", "return", "_inet_lnaof", "(", "in", "<<", "SHIFT_BITS", ")", ";", "}", "</s>" ]

[ "<", "arpa/inet.h", ">", "has", "unsigned", "long", "inet_lnaof", "(", "struct", "in_addr", ")", ";", "(", "IRIX", "6.2", ")", "in_addr_t", "inet_lnaof", "(", "struct", "in_addr", ")", ";", "(", "IRIX", "6.5", ")", "in_addr_t", "is", "a", "32-bit", "int", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "rs6000_quadword_masked_address_p", "(", "const_rtx", "expr", ")", "{", "if", "(", "GET_CODE", "(", "expr", ")", "==", "AND", ")", "{", "const_rtx", "operand1", "=", "XEXP", "(", "expr", ",", "0", ")", ";", "const_rtx", "operand2", "=", "XEXP", "(", "expr", ",", "1", ")", ";", "if", "(", "(", "REG_P", "(", "operand1", ")", "||", "rs6000_sum_of_two_registers_p", "(", "operand1", ")", ")", "&&", "CONST_SCALAR_INT_P", "(", "operand2", ")", "&&", "INTVAL", "(", "operand2", ")", "==", "-", "16", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "EXPR", "represents", "an", "address", "expression", "that", "masks", "off", "the", "low-order", "4", "bits", "in", "the", "style", "of", "an", "lvx", "or", "stvx", "rtl", "pattern", "." ]

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

[]

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

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "void", "ix86_expand_fp_absneg_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "mask", ",", "set", ",", "dst", ",", "src", ";", "bool", "use_sse", "=", "false", ";", "bool", "vector_mode", "=", "VECTOR_MODE_P", "(", "mode", ")", ";", "machine_mode", "vmode", "=", "mode", ";", "if", "(", "vector_mode", ")", "use_sse", "=", "true", ";", "else", "if", "(", "mode", "==", "TFmode", ")", "use_sse", "=", "true", ";", "else", "if", "(", "TARGET_SSE_MATH", ")", "{", "use_sse", "=", "SSE_FLOAT_MODE_P", "(", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "}", "if", "(", "use_sse", ")", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "vector_mode", ",", "code", "==", "ABS", ")", ";", "else", "mask", "=", "NULL_RTX", ";", "dst", "=", "operands", "[", "0", "]", ";", "src", "=", "operands", "[", "1", "]", ";", "set", "=", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ";", "set", "=", "gen_rtx_SET", "(", "dst", ",", "set", ")", ";", "if", "(", "mask", ")", "{", "rtx", "use", ",", "clob", ";", "rtvec", "par", ";", "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "mask", ")", ";", "if", "(", "vector_mode", ")", "par", "=", "gen_rtvec", "(", "2", ",", "set", ",", "use", ")", ";", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "par", "=", "gen_rtvec", "(", "3", ",", "set", ",", "use", ",", "clob", ")", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "par", ")", ")", ";", "}", "else", "emit_insn", "(", "set", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "floating", "point", "ABS", "or", "NEG", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_emit_store_exclusive", "(", "machine_mode", "mode", ",", "rtx", "bval", ",", "rtx", "mem", ",", "rtx", "rval", ",", "rtx", "model_rtx", ")", "{", "if", "(", "mode", "==", "TImode", ")", "emit_insn", "(", "gen_aarch64_store_exclusive_pair", "(", "bval", ",", "mem", ",", "operand_subword", "(", "rval", ",", "0", ",", "0", ",", "TImode", ")", ",", "operand_subword", "(", "rval", ",", "1", ",", "0", ",", "TImode", ")", ",", "model_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_aarch64_store_exclusive", "(", "mode", ",", "bval", ",", "mem", ",", "rval", ",", "model_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "store", "exclusive", "." ]

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

[]

[ "<s>", "static", "void", "arm_add_cfa_adjust_cfa_note", "(", "rtx", "insn", ",", "int", "size", ",", "rtx", "dest", ",", "rtx", "src", ")", "{", "rtx", "dwarf", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "dwarf", "=", "gen_rtx_SET", "(", "dest", ",", "plus_constant", "(", "Pmode", ",", "src", ",", "size", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "dwarf", ")", ";", "}", "</s>" ]

[ "Add", "a", "REG_CFA_ADJUST_CFA", "REG", "note", "to", "INSN", ".", "SIZE", "is", "the", "offset", "to", "be", "adjusted", ".", "DEST", "and", "SRC", "might", "be", "stack_pointer_rtx", "or", "hard_frame_pointer_rtx", "." ]

[ "arm", "1" ]

[]

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

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "static", "bool", "xtensa_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_COMPLEX_FLOAT", ")", "==", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_COMPLEX_FLOAT", ")", ")", ";", "}", "</s>" ]

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

[ "xtensa" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "int", "FrameIndex", ",", "LiveIntervals", "*", "LIS", ",", "VirtRegMap", "*", "VRM", ")", "const", "{", "if", "(", "MI", ".", "isFullCopy", "(", ")", ")", "{", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "DstReg", "==", "AMDGPU", "::", "M0", "&&", "SrcReg", ".", "isVirtual", "(", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "return", "nullptr", ";", "}", "if", "(", "SrcReg", "==", "AMDGPU", "::", "M0", "&&", "DstReg", ".", "isVirtual", "(", ")", ")", "{", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "DstReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "return", "nullptr", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "AMDGPU", "SI", "0", "1", "AMDGPU::M0", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "AMDGPU::SReg_32_XM0RegClass" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "&", "FirstLdSt", ",", "MachineInstr", "&", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "if", "(", "NumLoads", ">", "1", ")", "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", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "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", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "const", "PPCSubtarget", "*", "PPCTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "PPCSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "computeFSAdditions", "(", "FS", ",", "getOptLevel", "(", ")", ",", "getTargetTriple", "(", ")", ")", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "\"target-cpu\"", "\"target-features\"", "PPC" ]

[]

[ "<s>", "static", "bool", "nds32_pic_tls_group", "(", "rtx_insn", "*", "def_insn", ",", "enum", "nds32_relax_insn_type", "relax_type", ",", "int", "sym_type", ")", "{", "df_ref", "def_record", ";", "df_link", "*", "link", ";", "rtx_insn", "*", "use_insn", "=", "NULL", ";", "rtx", "pat", ",", "new_pat", ";", "def_record", "=", "DF_INSN_DEFS", "(", "def_insn", ")", ";", "for", "(", "link", "=", "DF_REF_CHAIN", "(", "def_record", ")", ";", "link", ";", "link", "=", "link", "->", "next", ")", "{", "if", "(", "!", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "continue", ";", "use_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "dominated_by_p", "(", "CDI_DOMINATORS", ",", "BLOCK_FOR_INSN", "(", "use_insn", ")", ",", "BLOCK_FOR_INSN", "(", "def_insn", ")", ")", ")", "return", "FALSE", ";", "if", "(", "!", "active_insn_p", "(", "use_insn", ")", ")", "return", "FALSE", ";", "switch", "(", "relax_type", ")", "{", "case", "RELAX_ORI", ":", "if", "(", "(", "sym_type", "==", "UNSPEC_TLSLE", "||", "sym_type", "==", "UNSPEC_GOTOFF", ")", "&&", "(", "recog_memoized", "(", "use_insn", ")", "==", "CODE_FOR_addsi3", ")", ")", "{", "pat", "=", "XEXP", "(", "PATTERN", "(", "use_insn", ")", ",", "1", ")", ";", "new_pat", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "2", ",", "XEXP", "(", "pat", ",", "0", ")", ",", "XEXP", "(", "pat", ",", "1", ")", ")", ",", "UNSPEC_ADD32", ")", ";", "validate_replace_rtx", "(", "pat", ",", "new_pat", ",", "use_insn", ")", ";", "nds32_group_infos", ".", "safe_push", "(", "use_insn", ")", ";", "}", "else", "if", "(", "nds32_plus_reg_load_store_p", "(", "use_insn", ")", "&&", "!", "nds32_sp_base_or_plus_load_store_p", "(", "use_insn", ")", ")", "nds32_group_infos", ".", "safe_push", "(", "use_insn", ")", ";", "else", "return", "FALSE", ";", "break", ";", "default", ":", "return", "FALSE", ";", "}", "}", "return", "TRUE", ";", "}", "</s>" ]

[ "Group", "the", "PIC", "and", "TLS", "relax", "candidate", "instructions", "for", "linker", "." ]

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

[]

[ "<s>", "static", "void", "epiphany_trampoline_init", "(", "rtx", "tramp_mem", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "tramp", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "tramp_mem", ",", "0", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "0", ")", ")", ",", "gen_rtx_IOR", "(", "SImode", ",", "GEN_INT", "(", "0x4002000b", ")", ",", "EPIPHANY_LOW_RTX", "(", "fnaddr", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "4", ")", ")", ",", "gen_rtx_IOR", "(", "SImode", ",", "GEN_INT", "(", "0x5002000b", ")", ",", "EPIPHANY_HIGH_RTX", "(", "fnaddr", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "8", ")", ")", ",", "gen_rtx_IOR", "(", "SImode", ",", "GEN_INT", "(", "0x2002800b", ")", ",", "EPIPHANY_LOW_RTX", "(", "cxt", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "12", ")", ")", ",", "gen_rtx_IOR", "(", "SImode", ",", "GEN_INT", "(", "0x3002800b", ")", ",", "EPIPHANY_HIGH_RTX", "(", "cxt", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "16", ")", ")", ",", "GEN_INT", "(", "0x0802014f", ")", ")", ";", "}", "</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", "." ]

[ "epiphany", "0", "0", "0", "0x4002000b", "4", "0x5002000b", "8", "0x2002800b", "12", "0x3002800b", "16", "0x0802014f" ]

[]

[ "<s>", "void", "AlphaInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R31", ")", ".", "addReg", "(", "Alpha", "::", "R31", ")", ".", "addReg", "(", "Alpha", "::", "R31", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "Alpha", "Alpha", "Alpha::BISr", "Alpha::R31", "Alpha::R31", "Alpha::R31" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "=", "0", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"AVR branch conditions have one component!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AVR", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "AVRCC", "::", "CondCodes", "CC", "=", "(", "AVRCC", "::", "CondCodes", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "auto", "&", "CondMI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "getBrCond", "(", "CC", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "CondMI", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AVR", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "if", "(", "BytesAdded", ")", "*", "BytesAdded", "+=", "getInstSizeInBytes", "(", "MI", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "AVR", "AVR", "0", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"AVR branch conditions have one component!\"", "\"Unconditional branch with multiple successors!\"", "AVR::RJMPk", "1", "0", "AVRCC::CondCodes", "AVRCC::CondCodes", "0", "AVR::RJMPk" ]

[]

[ "<s>", "bool", "arc_sets_cc_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "if", "(", "rtx_sequence", "*", "seq", "=", "dyn_cast", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "insn", ")", ")", ")", "insn", "=", "seq", "->", "insn", "(", "seq", "->", "len", "(", ")", "-", "1", ")", ";", "return", "arc_attr_type", "(", "insn", ")", "==", "TYPE_COMPARE", ";", "}", "</s>" ]

[ "Return", "true", "if", "insn", "sets", "the", "condition", "codes", "." ]

[ "arc", "1" ]

[]

[ "<s>", "void", "thumb2_asm_output_opcode", "(", "FILE", "*", "stream", ")", "{", "char", "buff", "[", "5", "]", ";", "int", "n", ";", "if", "(", "arm_condexec_mask", ")", "{", "for", "(", "n", "=", "0", ";", "n", "<", "arm_condexec_masklen", ";", "n", "++", ")", "buff", "[", "n", "]", "=", "(", "arm_condexec_mask", "&", "(", "1", "<<", "n", ")", ")", "?", "'t'", ":", "'e'", ";", "buff", "[", "n", "]", "=", "0", ";", "asm_fprintf", "(", "stream", ",", "\"i%s\\t%s\\n\\t\"", ",", "buff", ",", "arm_condition_codes", "[", "arm_current_cc", "]", ")", ";", "arm_condexec_mask", "=", "0", ";", "}", "}", "</s>" ]

[ "Output", "IT", "instructions", "." ]

[ "arm", "5", "0", "1", "0", "\"i%s\\t%s\\n\\t\"", "0" ]

[]

[ "<s>", "bool", "Thumb1FrameInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NumRegs", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MI", "=", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "true", ")", ")", ";", "NumRegs", "=", "true", ";", "}", "if", "(", "NumRegs", ")", "MBB", ".", "insert", "(", "MI", ",", "&", "*", "MIB", ")", ";", "else", "MF", ".", "DeleteMachineInstr", "(", "MIB", ")", ";", "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", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "if", "(", "requestsDoubleOperand", "(", "Name", ")", ")", "{", "setFpFormat", "(", "FP_FORMAT_D", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "}", "else", "{", "setDefaultFpFormat", "(", ")", ";", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ",", "Next", "+", "1", ")", ";", "StringRef", "Format", "=", "Name", ".", "slice", "(", "Next", ",", "Dot", ")", ";", "if", "(", "Dot", "==", "StringRef", "::", "npos", ")", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ";", "else", "{", "if", "(", "Name", ".", "startswith", "(", "\"c.\"", ")", ")", "{", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "\".\"", ",", "NameLoc", ")", ")", ";", "int", "Cc", "=", "ConvertCcString", "(", "Format", ")", ";", "if", "(", "Cc", "==", "-", "1", ")", "{", "return", "Error", "(", "NameLoc", ",", "\"Invalid conditional code\"", ")", ";", "}", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "1", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateImm", "(", "MCConstantExpr", "::", "Create", "(", "Cc", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "E", ")", ")", ";", "}", "else", "{", "return", "parseMathOperation", "(", "Name", ",", "NameLoc", ",", "Operands", ")", ";", "}", "Format", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ";", "}", "setFpFormat", "(", "Format", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsOperand::CreateToken", "0", "MipsOperand::CreateToken", "1", "MipsOperand::CreateToken", "\"c.\"", "MipsOperand::CreateToken", "\".\"", "1", "\"Invalid conditional code\"", "1", "MipsOperand::CreateImm", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "int", "HexagonFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FI", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "Hexagon", "Hexagon" ]

[]