gcc_assert ((len & 3) == 0);
start_sequence ();
clear_storage (shadow_mem, GEN_INT (len), BLOCK_OP_NORMAL);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
for (insn = insns; insn; insn = NEXT_INSN (insn))
if (CALL_P (insn))
break;
if (lab)
emit_label (lab);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
return insns;
}
top, ptr_mode, bot, ptr_mode);
do_pending_stack_adjust ();
- rtx_insn *insns = get_insns ();
- end_sequence ();
+ rtx_insn *insns = end_sequence ();
return insns;
}
= force_reg (Pmode,
targetm.memtag.insert_random_tag (virtual_stack_vars_rtx,
NULL_RTX));
- hwasan_frame_base_init_seq = get_insns ();
- end_sequence ();
+ hwasan_frame_base_init_seq = end_sequence ();
}
return hwasan_frame_base_ptr;
size_rtx, ptr_mode);
do_pending_stack_adjust ();
- rtx_insn *insns = get_insns ();
- end_sequence ();
+ rtx_insn *insns = end_sequence ();
return insns;
}
{
start_sequence ();
emit_move_insn (inc_insn.reg_res, inc_insn.reg0);
- mov_insn = get_insns ();
- end_sequence ();
+ mov_insn = end_sequence ();
new_cost += seq_cost (mov_insn, speed);
}
start_sequence ();
rtx_insn *insn = emit_insn (load_move);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
if (recog_memoized (insn) < 0)
return false;
start_sequence ();
emit_move_insn (new_reg, label_addr);
emit_indirect_jump (new_reg);
- indirect_jump_sequence = get_insns ();
- end_sequence ();
+ indirect_jump_sequence = end_sequence ();
/* Make sure every instruction in the new jump sequence has
its basic block set to be cur_bb. */
start_sequence ();
temp = expand_builtin_apply_args_1 ();
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
apply_args_value = temp;
push_to_sequence (call_fusage);
emit_use (reg);
- call_fusage = get_insns ();
- end_sequence ();
+ call_fusage = end_sequence ();
size += GET_MODE_SIZE (mode);
}
}
/* Output the entire sequence. */
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return result;
if (result != 0)
{
/* Output the entire sequence. */
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return result;
}
if (expand_sfix_optab (target, op0, builtin_optab))
{
/* Output the entire sequence. */
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return target;
}
if (expand_sfix_optab (result, op0, builtin_optab))
{
/* Output the entire sequence. */
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return result;
}
#endif
emit_move_insn (src_reg, pat);
}
- pat = get_insns ();
- end_sequence ();
+ pat = end_sequence ();
if (before_strlen)
emit_insn_after (pat, before_strlen);
/* Do whatever the machine needs done in this case. */
val = targetm.calls.expand_builtin_saveregs ();
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
saveregs_value = val;
}
emit_label (ne_label);
- rtx_insn *insns = get_insns ();
- end_sequence ();
+ rtx_insn *insns = end_sequence ();
emit_insn (insns);
return result;
add_reg_note (last, REG_NOALIAS, temp);
/* Write out the sequence. */
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
valreg = temp;
}
targetm.calls.end_call_args (args_so_far);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (pass == 0)
{
start_sequence ();
duplicate_insn_chain (after_rtl_seq, after_rtl_end,
NULL, NULL);
- copy = get_insns ();
- end_sequence ();
+ copy = end_sequence ();
}
prepend_insn_to_edge (copy, e);
}
var_ret_seq = expand_used_vars (forced_stack_vars);
- var_seq = get_insns ();
- end_sequence ();
+ var_seq = end_sequence ();
timevar_pop (TV_VAR_EXPAND);
/* Honor stack protection warnings. */
start_sequence ();
emit_move_insn (reg1, reg2);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
target_reg_cost [speed] = seq_cost (seq, speed);
start_sequence ();
emit_move_insn (mem, reg1);
emit_move_insn (reg2, mem);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
target_spill_cost [speed] = seq_cost (seq, speed);
}
default_rtl_profile ();
emit_insn (pattern);
- e->insns.r = get_insns ();
- end_sequence ();
+ e->insns.r = end_sequence ();
}
/* Like insert_insn_on_edge, but if there are already queued instructions
emit_insn (pattern);
emit_insn (e->insns.r);
- e->insns.r = get_insns ();
- end_sequence ();
+ e->insns.r = end_sequence ();
}
/* Update the CFG for the instructions queued on edge E. */
jump = get_last_insn ();
JUMP_LABEL (jump) = label;
LABEL_NUSES (label)++;
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
/* Add the new cond, in the new head. */
emit_insn_after (seq, BB_END (cond_bb));
emit_insn (gen_rtx_SET (scratch, sp));
emit_insn (gen_anddi3 (scratch, scratch, tracker));
emit_insn (gen_rtx_SET (sp, scratch));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
return seq;
}
rtx cc = aarch64_gen_compare_reg (EQ, sp, const0_rtx);
emit_insn (gen_cstoredi_neg (tracker,
gen_rtx_NE (CCmode, cc, const0_rtx), cc));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
return seq;
}
{
start_sequence ();
emit_insn (seq);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
}
for (rtx_insn *list = seq; list; list = NEXT_INSN (list))
aarch64_emit_call_insn (gen_tlsgd_small_si (result, imm));
else
aarch64_emit_call_insn (gen_tlsgd_small_di (result, imm));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
RTL_CONST_CALL_P (insns) = 1;
emit_libcall_block (insns, tmp_reg, result, imm);
rtx tmp_reg = gen_reg_rtx (GET_MODE (new_vals));
aarch64_expand_vector_init (tmp_reg, new_vals);
halves[i] = gen_rtx_SUBREG (mode, tmp_reg, 0);
- rtx_insn *rec_seq = get_insns ();
- end_sequence ();
+ rtx_insn *rec_seq = end_sequence ();
costs[i] = seq_cost_ignoring_scalar_moves (rec_seq, !optimize_size);
emit_insn (rec_seq);
}
= (!optimize_size) ? std::max (costs[0], costs[1]) : costs[0] + costs[1];
seq_total_cost += insn_cost (zip1_insn, !optimize_size);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
start_sequence ();
aarch64_expand_vector_init_fallback (target, vals);
end_sequence ();
return NULL_RTX;
}
- *prep_seq = get_insns ();
- end_sequence ();
+ *prep_seq = end_sequence ();
create_fixed_operand (&ops[0], op0);
create_fixed_operand (&ops[1], op1);
end_sequence ();
return NULL_RTX;
}
- *gen_seq = get_insns ();
- end_sequence ();
+ *gen_seq = end_sequence ();
return gen_rtx_fmt_ee (code, cc_mode,
gen_rtx_REG (cc_mode, CC_REGNUM), const0_rtx);
end_sequence ();
return NULL_RTX;
}
- *prep_seq = get_insns ();
- end_sequence ();
+ *prep_seq = end_sequence ();
target = gen_rtx_REG (cc_mode, CC_REGNUM);
aarch64_cond = aarch64_get_condition_code_1 (cc_mode, cmp_code);
return NULL_RTX;
}
- *gen_seq = get_insns ();
- end_sequence ();
+ *gen_seq = end_sequence ();
return gen_rtx_fmt_ee (cmp_code, VOIDmode, target, const0_rtx);
}
aarch64_local_sme_state (prev_mode));
break;
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
/* Get the set of clobbered registers that are currently live. */
HARD_REG_SET clobbers = {};
emit_insn (REGNO (x) == ZA_REGNUM
? gen_aarch64_asm_update_za (id_rtx)
: gen_aarch64_asm_update_zt0 (id_rtx));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
auto mode = REGNO (x) == ZA_REGNUM ? VNx16QImode : V8DImode;
uses.safe_push (gen_rtx_REG (mode, REGNO (x)));
args_switch.emit_epilogue ();
if (guard_label)
emit_label (guard_label);
- auto seq = get_insns ();
- end_sequence ();
+ auto seq = end_sequence ();
emit_insn_after (seq, bb_note (bb));
return true;
aarch64_switch_pstate_sm (AARCH64_ISA_MODE_SM_ON, AARCH64_ISA_MODE_SM_OFF);
if (guard_label)
emit_label (guard_label);
- auto seq = get_insns ();
- end_sequence ();
+ auto seq = end_sequence ();
emit_insn_before (seq, jump);
return true;
args_switch.emit_epilogue ();
if (args_guard_label)
emit_label (args_guard_label);
- auto args_seq = get_insns ();
- end_sequence ();
+ auto args_seq = end_sequence ();
emit_insn_before (args_seq, call);
if (find_reg_note (call, REG_NORETURN, NULL_RTX))
return_switch.emit_epilogue ();
if (return_guard_label)
emit_label (return_guard_label);
- auto result_seq = get_insns ();
- end_sequence ();
+ auto result_seq = end_sequence ();
emit_insn_after (result_seq, call);
return true;
}
RTL_CONST_CALL_P (insn) = 1;
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r16);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
emit_libcall_block (insn, dest, r0, x);
return dest;
RTL_CONST_CALL_P (insn) = 1;
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r16);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
UNSPEC_TLSLDM_CALL);
CALL_INSN_FUNCTION_USAGE (tmp) = usage;
RTL_CONST_CALL_P (tmp) = 1;
- tmp = get_insns ();
- end_sequence ();
+ tmp = end_sequence ();
emit_libcall_block (tmp, target, reg, equiv);
}
m = validize_mem (m);
emit_move_insn (m, pic_offset_table_rtx);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
/* We used to simply emit the sequence after entry_of_function.
However this breaks the CFG if the first instruction in the
insn = emit_insn (gen_arc_lp (loop->start_label,
loop->end_label));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
entry_after = BB_END (entry_bb);
if (!single_succ_p (entry_bb) || vec_safe_length (loop->incoming) > 1
emit_move_insn (dest, tmp);
}
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
return saw_asm_flag ? seq : NULL;
}
builtin and error out if not. */
start_sequence ();
emit_insn (pat);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
if (recog_memoized (insn) < 0)
error ("this builtin is not supported for this target");
else
arm_load_pic_register (0UL, pic_reg);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
for (insn = seq; insn; insn = NEXT_INSN (insn))
if (INSN_P (insn))
LCT_PURE, /* LCT_CONST? */
Pmode, reg, Pmode);
- rtx_insn *insns = get_insns ();
- end_sequence ();
+ rtx_insn *insns = end_sequence ();
return insns;
}
if (wback_offset != 0)
emit_move_insn (basereg, plus_constant (Pmode, basereg, wback_offset));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
if (wback_offset != 0)
emit_move_insn (basereg, plus_constant (Pmode, basereg, wback_offset));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
XVECEXP (par, 0, k++) = set;
emit_use (reg);
}
- use_seq = get_insns ();
- end_sequence ();
+ use_seq = end_sequence ();
emit_insn_after (use_seq, emit_insn (par));
}
rtx clobber = gen_rtx_CLOBBER (VOIDmode, ccreg);
XVECEXP (par, 0, j) = clobber;
- use_seq = get_insns ();
- end_sequence ();
+ use_seq = end_sequence ();
emit_insn_after (use_seq, emit_insn (par));
}
cmse_clear_registers (to_clear_bitmap, padding_bits_to_clear,
NUM_ARG_REGS, ip_reg, clearing_reg);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
/* The AAPCS requires the callee to widen integral types narrower
emit_insn (PATTERN (insn));
}
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
/* Re-write the entire BB contents with the transformed
sequence. */
|| (bbinfo_t::try_split_any_p && od.try_split_any (this))
|| (bbinfo_t::try_mem0_p && od.try_mem0 (this)));
- rtx_insn *new_insns = get_insns ();
- end_sequence ();
+ rtx_insn *new_insns = end_sequence ();
gcc_assert (found == (od.n_new_insns >= 0));
PATTERN (i[3]), PATTERN (i[4]));
start_sequence ();
emit (gen_rtx_PARALLEL (VOIDmode, vec));
- rtx_insn *insn = get_insns ();
- end_sequence ();
+ rtx_insn *insn = end_sequence ();
return insn;
}
-size_cfa)));
}
- fp_plus_insns = get_insns ();
- end_sequence ();
+ fp_plus_insns = end_sequence ();
/************ Method 2: Adjust Stack pointer ************/
RTX_FRAME_RELATED_P (insn) = 1;
}
- sp_plus_insns = get_insns ();
- end_sequence ();
+ sp_plus_insns = end_sequence ();
/************ Use shortest method ************/
emit_insn (gen_movhi_sp_r (stack_pointer_rtx, fp,
GEN_INT (irq_state)));
- rtx_insn *fp_plus_insns = get_insns ();
- end_sequence ();
+ rtx_insn *fp_plus_insns = end_sequence ();
/********** Method 2: Adjust Stack pointer **********/
emit_move_insn (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, size));
- rtx_insn *sp_plus_insns = get_insns ();
- end_sequence ();
+ rtx_insn *sp_plus_insns = end_sequence ();
/************ Use shortest method ************/
}
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (loop->incoming_src)
{
cmp = emit_library_call_value (libfunc, 0, LCT_CONST, SImode,
op0, op_mode, op1, op_mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, cmp, cmp,
gen_rtx_fmt_ee (code, SImode, op0, op1));
else
internal_error ("unknown dest");
- val = get_insns ();
- end_sequence ();
+ val = end_sequence ();
return val;
}
operand_subword (op1, 0, 1, DImode));
emit_move_insn (operand_subword (op0, 1, 1, DImode),
operand_subword (op1, 1, 1, DImode));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
DONE;
*valuep = emit_library_call_value (get_tls_get_addr (),
NULL_RTX, LCT_PURE, /* LCT_CONST? */
Pmode, reg, Pmode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
return insns;
}
emit_set_fp_mode (EPIPHANY_MSW_ENTITY_ROUND_UNKNOWN,
jilted_mode, FP_MODE_NONE,
reg_class_contents[NO_REGS]);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
need_commit = true;
insert_insn_on_edge (seq, e);
}
/* This should have been prevented by the constraints on movdi_insn. */
gcc_unreachable ();
- val = get_insns ();
- end_sequence ();
+ val = end_sequence ();
return val;
}
gen_rtx_SET (dest, const0_rtx)));
/* Finish up, return sequence. */
- ret = get_insns ();
- end_sequence ();
+ ret = end_sequence ();
return ret;
}
}
/* Finish up, return sequence. */
- ret = get_insns ();
- end_sequence ();
+ ret = end_sequence ();
return ret;
}
}
/* Finish up, return sequence. */
- ret = get_insns ();
- end_sequence ();
+ ret = end_sequence ();
return ret;
}
gen_rtx_SET (dest, src)));
/* Finish up, return sequence. */
- ret = get_insns ();
- end_sequence ();
+ ret = end_sequence ();
return ret;
}
gen_rtx_NE (CC_CCRmode, icr, const0_rtx),
gen_rtx_SET (dest, const0_rtx)));
- operands[3] = get_insns ();
- end_sequence ();
+ operands[3] = end_sequence ();
}")
;; Reload CC_UNSmode for unsigned integer comparisons
gen_rtx_NE (CC_CCRmode, icr, const0_rtx),
gen_rtx_SET (dest, const0_rtx)));
- operands[3] = get_insns ();
- end_sequence ();
+ operands[3] = end_sequence ();
}")
;; Reload CC_NZmode. This is mostly the same as the CCmode and CC_UNSmode
emit_insn (gen_andsi3 (int_op0, int_op0, GEN_INT (CC_MASK)));
- operands[2] = get_insns ();
- end_sequence ();
+ operands[2] = end_sequence ();
}")
;; Move a gpr value to FCC.
const0_rtx),
gen_rtx_SET (int_op0, const0_rtx)));
- operands[2] = get_insns ();
- end_sequence ();
+ operands[2] = end_sequence ();
}")
(define_split
if (! ICR_P (REGNO (operands[0])))
emit_insn (gen_movcc_ccr (operands[0], icr));
- operands[2] = get_insns ();
- end_sequence ();
+ operands[2] = end_sequence ();
}")
\f
saved_scalars++;
}
- rtx move_scalars = get_insns ();
- end_sequence ();
+ rtx move_scalars = end_sequence ();
start_sequence ();
/* Ensure that all vector lanes are moved. */
offset += size;
}
- rtx move_vectors = get_insns ();
- end_sequence ();
+ rtx move_vectors = end_sequence ();
if (prologue)
{
+ offsets->callee_saves))));
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn (seq);
}
{
start_sequence ();
emit_move_insn (exec_save_reg, exec_reg);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_after (seq, last_exec_def);
if (dump_file && (dump_flags & TDF_DETAILS))
/* Restore EXEC register before the usage. */
start_sequence ();
emit_move_insn (exec_reg, exec);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_before (seq, insn);
if (dump_file && (dump_flags & TDF_DETAILS))
{
start_sequence ();
emit_move_insn (exec_reg, GEN_INT (new_exec));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_before (seq, insn);
if (dump_file && (dump_flags & TDF_DETAILS))
too common scenario. */
start_sequence ();
compare_op = ix86_expand_fp_compare (code, op0, op1);
- compare_seq = get_insns ();
- end_sequence ();
+ compare_seq = end_sequence ();
if (GET_MODE (XEXP (compare_op, 0)) == CCFPmode)
code = ix86_fp_compare_code_to_integer (GET_CODE (compare_op));
start_sequence ();
compare_op = ix86_expand_compare (code, op0, op1);
- compare_seq = get_insns ();
- end_sequence ();
+ compare_seq = end_sequence ();
compare_code = GET_CODE (compare_op);
if (GET_MODE (reg) != innermode)
reg = gen_lowpart (innermode, reg);
SET_SRC (PATTERN (insn)) = gen_vec_duplicate (mode, reg);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (seq)
emit_insn_before (seq, insn);
V4SImode this *will* succeed. For V8HImode or V16QImode it may not. */
start_sequence ();
ok = expand_vec_perm_1 (&dfinal);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (!ok)
return false;
start_sequence ();
ok = expand_vec_perm_1 (&dfirst);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (!ok)
return false;
{
start_sequence ();
ok = expand_vec_perm_1 (&dfirst);
- seq1 = get_insns ();
- end_sequence ();
+ seq1 = end_sequence ();
if (!ok)
return false;
{
start_sequence ();
ok = expand_vec_perm_1 (&dsecond);
- seq2 = get_insns ();
- end_sequence ();
+ seq2 = end_sequence ();
if (!ok)
return false;
{
start_sequence ();
ok = expand_vec_perm_1 (&dfirst);
- seq1 = get_insns ();
- end_sequence ();
+ seq1 = end_sequence ();
if (!ok)
return false;
{
start_sequence ();
ok = expand_vec_perm_1 (&dsecond);
- seq2 = get_insns ();
- end_sequence ();
+ seq2 = end_sequence ();
if (!ok)
return false;
canonicalize_perm (&dfirst);
start_sequence ();
ok = ix86_expand_vec_perm_const_1 (&dfirst);
- seq1 = get_insns ();
- end_sequence ();
+ seq1 = end_sequence ();
if (!ok)
return false;
canonicalize_perm (&dsecond);
start_sequence ();
ok = ix86_expand_vec_perm_const_1 (&dsecond);
- seq2 = get_insns ();
- end_sequence ();
+ seq2 = end_sequence ();
if (!ok)
return false;
}
}
- *prep_seq = get_insns ();
- end_sequence ();
+ *prep_seq = end_sequence ();
start_sequence ();
end_sequence ();
return NULL_RTX;
}
- *gen_seq = get_insns ();
- end_sequence ();
+ *gen_seq = end_sequence ();
return res;
}
return NULL_RTX;
}
- *prep_seq = get_insns ();
- end_sequence ();
+ *prep_seq = end_sequence ();
target = gen_rtx_REG (cc_mode, FLAGS_REG);
dfv = ix86_get_flags_cc ((rtx_code) cmp_code);
return NULL_RTX;
}
- *gen_seq = get_insns ();
- end_sequence ();
+ *gen_seq = end_sequence ();
return gen_rtx_fmt_ee ((rtx_code) cmp_code, VOIDmode, target, const0_rtx);
}
else
emit_insn (gen_rtx_SET (gen_rtx_SUBREG (vmode, vreg, 0),
gen_gpr_to_xmm_move_src (vmode, reg)));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_conversion_insns (seq, insn);
if (dump_file)
else
emit_move_insn (dst, src);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_conversion_insns (seq, insn);
if (dump_file)
{
start_sequence ();
vec_cst = validize_mem (force_const_mem (vmode, vec_cst));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_before (seq, insn);
}
src = validize_mem (force_const_mem (V1TImode, src));
use_move = MEM_P (dst);
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
if (seq)
emit_insn_before (seq, insn);
if (use_move)
add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
insert_insn_on_edge (seq, entry_edge);
start_sequence ();
emit_move_insn (reg, gen_rtx_REG (Pmode, scratch_regno));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
push_topmost_sequence ();
emit_insn_after (seq, entry_of_function ());
start_sequence ();
drap_vreg = copy_to_reg (arg_ptr);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
insn = emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
if (!optimize)
start_sequence ();
emit_call_insn
(gen_tls_global_dynamic_64 (Pmode, rax, x, caddr));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (GET_MODE (x) != Pmode)
x = gen_rtx_ZERO_EXTEND (Pmode, x);
start_sequence ();
emit_call_insn
(gen_tls_local_dynamic_base_64 (Pmode, rax, caddr));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
/* Attach a unique REG_EQUAL, to allow the RTL optimizers to
share the LD_BASE result with other LD model accesses. */
}
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
if (saw_asm_flag)
return seq;
LCT_CONST, Pmode,
tga_op1, Pmode, tga_op2, Pmode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (GET_MODE (op0) != Pmode)
op0 = tga_ret;
LCT_CONST, Pmode,
tga_op1, Pmode, tga_op2, Pmode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
tga_eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
UNSPEC_LD_BASE);
emit_insn (gen_rtx_SET (cmp, gen_rtx_fmt_ee (ncode, BImode,
ret, const0_rtx)));
- rtx_insn *insns = get_insns ();
- end_sequence ();
+ rtx_insn *insns = end_sequence ();
emit_libcall_block (insns, cmp, cmp,
gen_rtx_fmt_ee (code, BImode, *op0, *op1));
spill_fill_data.init_reg[iter],
disp_rtx));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
}
/* Careful for being the first insn in a sequence. */
this *will* succeed. For V8QImode or V2SImode it may not. */
start_sequence ();
ok = expand_vec_perm_1 (&dfinal);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (!ok)
return false;
if (d->testing_p)
RTL_CONST_CALL_P (insn) = 1;
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
- insn = get_insns ();
-
- end_sequence ();
+ insn = end_sequence ();
return insn;
}
else
gcc_unreachable ();
- val = get_insns ();
- end_sequence ();
+ val = end_sequence ();
return val;
}
start_sequence ();
emit_insn (gen_cmp_ltusi_insn (op1, const1_rtx));
emit_insn (gen_movcc_insn (op0));
- operands[3] = get_insns ();
- end_sequence ();
+ operands[3] = end_sequence ();
}")
(define_insn "seq_insn"
emit_insn (gen_cmp_ltusi_insn (op3, const1_rtx));
emit_insn (gen_movcc_insn (op0));
- operands[4] = get_insns ();
- end_sequence ();
+ operands[4] = end_sequence ();
}")
(define_insn "sne_zero_insn"
Pmode, x, Pmode);
m68k_libcall_value_in_a0_p = false;
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
gcc_assert (can_create_pseudo_p ());
dest = gen_reg_rtx (Pmode);
a0 = emit_library_call_value (m68k_get_m68k_read_tp (), NULL_RTX, LCT_PURE,
Pmode);
m68k_libcall_value_in_a0_p = false;
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
/* Attach a unique REG_EQUIV, to allow the RTL optimizers to
share the m68k_read_tp result with other IE/LE model accesses. */
start_sequence ();
emit_insn (gen_ib ());
- sched_ib.insn = get_insns ();
- end_sequence ();
+ sched_ib.insn = end_sequence ();
}
/* Scheduling pass is now finished. Free/reset static variables. */
emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
operand_subword_force (operands[1], 1, DFmode));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
DONE;
emit_move_insn (operand_subword (operands[0], 2, 1, XFmode),
operand_subword_force (operands[1], 2, XFmode));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
DONE;
emit_move_insn (operand_subword (operands[0], 1, 1, DFmode),
operand_subword_force (operands[1], 1, DFmode));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
DONE;
emit_move_insn (operand_subword (operands[0], 2, 1, XFmode),
operand_subword_force (operands[1], 2, XFmode));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
DONE;
LCT_PURE, /* LCT_CONST? */
Pmode, reg, Pmode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
return insns;
}
const0_rtx, NULL_RTX, false);
RTL_CONST_CALL_P (insn) = 1;
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
- insn = get_insns ();
-
- end_sequence ();
+ insn = end_sequence ();
return insn;
}
{
start_sequence ();
emit_insn (gen_ls2_alu1_turn_enabled_insn ());
- mips_ls2.alu1_turn_enabled_insn = get_insns ();
- end_sequence ();
+ mips_ls2.alu1_turn_enabled_insn = end_sequence ();
start_sequence ();
emit_insn (gen_ls2_alu2_turn_enabled_insn ());
- mips_ls2.alu2_turn_enabled_insn = get_insns ();
- end_sequence ();
+ mips_ls2.alu2_turn_enabled_insn = end_sequence ();
start_sequence ();
emit_insn (gen_ls2_falu1_turn_enabled_insn ());
- mips_ls2.falu1_turn_enabled_insn = get_insns ();
- end_sequence ();
+ mips_ls2.falu1_turn_enabled_insn = end_sequence ();
start_sequence ();
emit_insn (gen_ls2_falu2_turn_enabled_insn ());
- mips_ls2.falu2_turn_enabled_insn = get_insns ();
- end_sequence ();
+ mips_ls2.falu2_turn_enabled_insn = end_sequence ();
mips_ls2.alu1_core_unit_code = get_cpu_unit_code ("ls2_alu1_core");
mips_ls2.alu2_core_unit_code = get_cpu_unit_code ("ls2_alu2_core");
emit_label (new_label);
}
- jump_sequence = get_insns ();
- end_sequence ();
+ jump_sequence = end_sequence ();
emit_insn_after (jump_sequence, jump_insn);
if (new_label)
start_sequence ();
emit_insn (nvptx_gen_shuffle (dst_real, src_real, idx, kind));
emit_insn (nvptx_gen_shuffle (dst_imag, src_imag, idx, kind));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
case E_SImode:
emit_insn (nvptx_gen_shuffle (tmp0, tmp0, idx, kind));
emit_insn (nvptx_gen_shuffle (tmp1, tmp1, idx, kind));
emit_insn (nvptx_gen_pack (dst, tmp0, tmp1));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
case E_V2SImode:
emit_insn (nvptx_gen_shuffle (tmp1, tmp1, idx, kind));
emit_insn (gen_movsi (dst0, tmp0));
emit_insn (gen_movsi (dst1, tmp1));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
case E_V2DImode:
emit_insn (nvptx_gen_shuffle (tmp1, tmp1, idx, kind));
emit_insn (gen_movdi (dst0, tmp0));
emit_insn (gen_movdi (dst1, tmp1));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
case E_BImode:
emit_insn (gen_sel_truesi (tmp, src, GEN_INT (1), const0_rtx));
emit_insn (nvptx_gen_shuffle (tmp, tmp, idx, kind));
emit_insn (gen_rtx_SET (dst, gen_rtx_NE (BImode, tmp, const0_rtx)));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
case E_QImode:
emit_insn (nvptx_gen_shuffle (tmp, tmp, idx, kind));
emit_insn (gen_rtx_SET (dst, gen_rtx_fmt_e (TRUNCATE, GET_MODE (dst),
tmp)));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
emit_insn (nvptx_gen_shared_bcast (tmp, pm, rep, data, vector));
if (pm & PM_write)
emit_insn (gen_rtx_SET (reg, gen_rtx_NE (BImode, tmp, const0_rtx)));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
break;
emit_insn (res);
emit_insn (gen_adddi3 (data->ptr, data->ptr,
GEN_INT (GET_MODE_SIZE (GET_MODE (reg)))));
- res = get_insns ();
- end_sequence ();
+ res = end_sequence ();
}
else
rep = 1;
}
emit_insn (gen_rtx_CLOBBER (GET_MODE (tmp), tmp));
emit_insn (gen_rtx_CLOBBER (GET_MODE (ptr), ptr));
- rtx cpy = get_insns ();
- end_sequence ();
+ rtx cpy = end_sequence ();
insn = emit_insn_after (cpy, insn);
}
if (nvptx_comment && first != NULL)
emit_insn (gen_comment ("Start: Added by -minit-regs=1"));
emit_move_insn (reg, CONST0_RTX (GET_MODE (reg)));
- rtx_insn *inits = get_insns ();
- end_sequence ();
+ rtx_insn *inits = end_sequence ();
if (dump_file && (dump_flags & TDF_DETAILS))
for (rtx_insn *init = inits; init != NULL; init = NEXT_INSN (init))
if (nvptx_comment && first != NULL)
emit_insn (gen_comment ("Start: Added by -minit-regs=2:"));
emit_move_insn (reg, CONST0_RTX (GET_MODE (reg)));
- rtx_insn *inits = get_insns ();
- end_sequence ();
+ rtx_insn *inits = end_sequence ();
if (dump_file && (dump_flags & TDF_DETAILS))
for (rtx_insn *init = inits; init != NULL; init = NEXT_INSN (init))
start_sequence ();
emit_move_insn (reg, CONST0_RTX (GET_MODE (reg)));
- rtx_insn *inits = get_insns ();
- end_sequence ();
+ rtx_insn *inits = end_sequence ();
if (dump_file && (dump_flags & TDF_DETAILS))
for (rtx_insn *init = inits; init != NULL;
emit_insn (gen_comment ("Start: Added by -minit-regs=3:"));
emit_insn (e->insns.r);
emit_insn (gen_comment ("End: Added by -minit-regs=3:"));
- e->insns.r = get_insns ();
- end_sequence ();
+ e->insns.r = end_sequence ();
}
}
cfun->machine->set_got_insn =
emit_insn (gen_set_got_tmp (pic_offset_table_rtx));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
insert_insn_on_edge (seq, entry_edge);
else
emit_insn (gen_tld_load (tmp, addr));
t1 = hppa_tls_call (tmp);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
t2 = gen_reg_rtx (Pmode);
emit_libcall_block (insn, t2, t1,
gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
cmp = emit_library_call_value (libfunc, 0, LCT_CONST, SImode,
op0, op_mode, op1, op_mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, cmp, cmp,
gen_rtx_fmt_ee (code, SImode, op0, op1));
LABEL_NUSES (end->label)++;
/* Emit the whole sequence before the doloop_end. */
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
emit_insn_before (insn, end->insn);
/* Delete the doloop_end. */
}
}
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_before (seq, insn);
}
}
}
start_sequence ();
insert_vsetvl_insn (EMIT_DIRECT, footer_info);
- rtx_insn *rinsn = get_insns ();
- end_sequence ();
+ rtx_insn *rinsn = end_sequence ();
default_rtl_profile ();
insert_insn_on_edge (rinsn, eg);
need_commit = true;
start_sequence ();
insert_vsetvl_insn (EMIT_DIRECT, info);
- rtx_insn *rinsn = get_insns ();
- end_sequence ();
+ rtx_insn *rinsn = end_sequence ();
default_rtl_profile ();
/* We should not get an abnormal edge here. */
gen_int_mode (RISCV_CC_BASE, SImode)));
RTL_CONST_CALL_P (insn) = 1;
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
- insn = get_insns ();
-
- end_sequence ();
+ insn = end_sequence ();
return insn;
}
{
start_sequence ();
emit_insn (gen_frrmsi (DYNAMIC_FRM_RTL (cfun)));
- rtx_insn *backup_insn = get_insns ();
- end_sequence ();
+ rtx_insn *backup_insn = end_sequence ();
insert_insn_on_edge (backup_insn, eg);
}
{
start_sequence ();
emit_insn (gen_frrmsi (DYNAMIC_FRM_RTL (cfun)));
- rtx_insn *backup_insn = get_insns ();
- end_sequence ();
+ rtx_insn *backup_insn = end_sequence ();
insert_insn_end_basic_block (backup_insn, bb);
}
gcc_unreachable ();
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, operands[0], ret, equiv);
return ret;
}
start_sequence ();
ret = rs6000_legitimize_address (x, oldx, mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (ret != x)
{
new_rtx = force_const_mem (Pmode, new_rtx);
emit_move_insn (r2, new_rtx);
s390_emit_tls_call_insn (r2, tls_call);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
temp = gen_reg_rtx (Pmode);
new_rtx = force_const_mem (Pmode, new_rtx);
emit_move_insn (r2, new_rtx);
s390_emit_tls_call_insn (r2, tls_call);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM_NTPOFF);
temp = gen_reg_rtx (Pmode);
const0_rtx, ins))
{
*seq1 = NULL;
- *seq2 = get_insns ();
- end_sequence ();
+ *seq2 = end_sequence ();
return tmp;
}
end_sequence ();
/* Failed to use insv. Generate a two part shift and mask. */
start_sequence ();
tmp = s390_expand_mask_and_shift (ins, mode, ac->shift);
- *seq1 = get_insns ();
- end_sequence ();
+ *seq1 = end_sequence ();
start_sequence ();
tmp = expand_simple_binop (SImode, IOR, tmp, val, NULL_RTX, 1, OPTAB_DIRECT);
- *seq2 = get_insns ();
- end_sequence ();
+ *seq2 = end_sequence ();
return tmp;
}
emit_move_insn (got_rtx, s390_got_symbol ());
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
return insns;
}
start_sequence ();
emit_move_insn (reg, gen_rtx_REG (Pmode, 1));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
push_topmost_sequence ();
emit_insn_after (seq, entry_of_function ());
else
gcc_unreachable ();
- rtx i = get_insns ();
- end_sequence ();
+ rtx i = end_sequence ();
return i;
}
addr, const1_rtx));
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), o0);
RTL_CONST_CALL_P (insn) = 1;
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
emit_libcall_block (insn, ret, o0, addr);
break;
const1_rtx));
use_reg (&CALL_INSN_FUNCTION_USAGE (insn), o0);
RTL_CONST_CALL_P (insn) = 1;
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
/* Attach a unique REG_EQUAL, to allow the RTL optimizers to
share the LD_BASE result with other LD model accesses. */
emit_libcall_block (insn, temp3, o0,
if (!TARGET_VXWORKS_RTP)
pic_offset_table_rtx = got_register_rtx;
scratch = sparc_legitimize_pic_address (funexp, scratch);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_and_preserve (seq, spill_reg, pic_offset_table_rtx);
}
else if (TARGET_ARCH32)
spill_reg = gen_rtx_REG (DImode, 15); /* %o7 */
start_sequence ();
sparc_emit_set_symbolic_const64 (scratch, funexp, spill_reg);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_and_preserve (seq, spill_reg, 0);
break;
load_got_register ();
if (!TARGET_VXWORKS_RTP)
emit_move_insn (pic_offset_table_rtx, got_register_rtx);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
insert_insn_on_edge (seq, entry_edge);
start_sequence ();
xstormy16_expand_arith (mode, COMPARE, dest, op0, op1);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
gcc_assert (INSN_P (seq));
if (mode == DFmode || mode == DImode)
emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 0),
gen_rtx_REG (SImode, A7_REG - 1)));
- entry_insns = get_insns ();
- end_sequence ();
+ entry_insns = end_sequence ();
if (cfun->machine->vararg_a7)
{
GEN_INT (value), SImode,
GEN_INT (bytes), SImode);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
}
while (bytes > 0);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
emit_insn (gen_addsi3 (dst, dst, GEN_INT (align)));
emit_cmp_and_jump_insns (dst, end, NE, const0_rtx, SImode, true, label);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
emit_move_insn (a_io, arg);
call_insn = emit_call_insn (gen_tls_call (a_io, fn, sym, const1_rtx));
use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn), a_io);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
*retp = a_io;
return insns;
{
start_sequence ();
emit_insn (gen_add3_insn (dest, src, srcoff));
- new_insn = get_insns ();
- end_sequence ();
+ new_insn = end_sequence ();
}
else
new_insn = gen_move_insn (dest, src);
gen_int_shift_amount (new_mode, shift),
new_reg, 1, OPTAB_DIRECT);
- shift_seq = get_insns ();
- end_sequence ();
+ shift_seq = end_sequence ();
if (target != new_reg || shift_seq == NULL)
continue;
}
else
read_reg = copy_to_mode_reg (read_mode, read_reg);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (insns != NULL_RTX)
{
start_sequence ();
... emit the new instructions ...
- insns_head = get_insns ();
- end_sequence ();
+ insns_head = end_sequence ();
emit_insn_before (insns_head, SPOT);
start_sequence ();
emit_clobber (x);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
start_sequence ();
emit_use (x);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
expand_dw2_landing_pad_for_region (lp->region);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
bb->count = bb->next_bb->count;
buf_addr = plus_constant (Pmode, XEXP (crtl->eh.sjlj_fc, 0),
sjlj_fc_jbuf_ofs);
expand_builtin_update_setjmp_buf (buf_addr);
- p = get_insns ();
- end_sequence ();
+ p = end_sequence ();
emit_insn_before (p, insn);
}
mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
sjlj_fc_call_site_ofs);
emit_move_insn (mem, gen_int_mode (this_call_site, GET_MODE (mem)));
- p = get_insns ();
- end_sequence ();
+ p = end_sequence ();
emit_insn_before (p, before);
last_call_site = this_call_site;
emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
XEXP (fc, 0), Pmode);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
/* ??? Instead of doing this at the beginning of the function,
do this in a block that is at loop level 0 and dominates all
emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
XEXP (crtl->eh.sjlj_fc, 0), Pmode);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
/* ??? Really this can be done in any block at loop level 0 that
post-dominates all can_throw_internal instructions. This is
if (r->filter_reg)
emit_move_insn (r->filter_reg, filter_reg);
- seq2 = get_insns ();
- end_sequence ();
+ seq2 = end_sequence ();
rtx_insn *before = label_rtx (lp->post_landing_pad);
bb = emit_to_new_bb_before (seq2, before);
expand_sjlj_dispatch_table (disp, dispatch_labels);
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
bb = emit_to_new_bb_before (seq, first_reachable_label);
if (num_dispatch == 1)
wop1 = convert_modes (wider_mode, mode, op1, unsignedp);
tem = expand_binop (wider_mode, smul_optab, wop0, wop1, 0,
unsignedp, OPTAB_WIDEN);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (tem)
{
temp, temp2, mode, 0);
if (temp2)
{
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn (seq);
return expand_shift (RSHIFT_EXPR, mode, temp2, logd, NULL_RTX, 0);
}
emit_move_insn (to, tof);
}
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (tof)
{
emit_insn (insns);
emit_move_insn (to, tof);
}
while (0);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (tof)
{
emit_insn (insns);
start_sequence ();
value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,
from, from_mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, to, value,
tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,
from)
emit_move_insn (subword, fill_value);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return;
last_insn = emit_move_insn (xpart, ypart);
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
/* Show the output dies here. This is necessary for SUBREGs
of pseudos since we cannot track their lifetimes correctly;
start_sequence ();
emit_move_insn_1 (x, y);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
and return. */
if (insn)
{
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn (seq);
return convert_modes (orig_mode, mode, temp, 0);
}
do_pending_stack_adjust ();
start_sequence ();
rtx uns_ret = expand_divmod (mod_p, code, mode, op0, op1, target, 1);
- rtx_insn *uns_insns = get_insns ();
- end_sequence ();
+ rtx_insn *uns_insns = end_sequence ();
start_sequence ();
rtx sgn_ret = expand_divmod (mod_p, code, mode, op0, op1, target, 0);
- rtx_insn *sgn_insns = get_insns ();
- end_sequence ();
+ rtx_insn *sgn_insns = end_sequence ();
unsigned uns_cost = seq_cost (uns_insns, speed_p);
unsigned sgn_cost = seq_cost (sgn_insns, speed_p);
bool was_tie = false;
op0, op1, NULL_RTX, unsignedp);
divmul_ret = expand_mult (mode, divmul_ret, op1, target,
unsignedp);
- rtx_insn *divmul_insns = get_insns ();
- end_sequence ();
+ rtx_insn *divmul_insns = end_sequence ();
start_sequence ();
rtx modsub_ret
= expand_expr_divmod (TRUNC_MOD_EXPR, mode, treeop0, treeop1,
optab_default);
modsub_ret = expand_binop (mode, this_optab, op0, modsub_ret,
target, unsignedp, OPTAB_LIB_WIDEN);
- rtx_insn *modsub_insns = get_insns ();
- end_sequence ();
+ rtx_insn *modsub_insns = end_sequence ();
unsigned divmul_cost = seq_cost (divmul_insns, speed_p);
unsigned modsub_cost = seq_cost (modsub_insns, speed_p);
/* If costs are the same then use as tie breaker the other other
and return. */
if (insn)
{
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn (seq);
return target;
}
if (temp != dest_low)
emit_move_insn (dest_low, temp);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
temp = target ;
if (have_insn_for (ASHIFT, int_mode))
target,
unsignedp);
- seq_old = get_insns ();
- end_sequence ();
+ seq_old = end_sequence ();
if (seq_cost (seq, speed_p)
>= seq_cost (seq_old, speed_p))
{
start_sequence ();
rtx mor = expand_expr_real_2 (&ops, NULL_RTX, TYPE_MODE (ops.type),
EXPAND_NORMAL);
- rtx_insn *moinsns = get_insns ();
- end_sequence ();
+ rtx_insn *moinsns = end_sequence ();
unsigned mocost = seq_cost (moinsns, speed_p);
mocost += rtx_cost (mor, mode, EQ, 0, speed_p);
start_sequence ();
rtx mur = expand_expr_real_2 (&ops, NULL_RTX, TYPE_MODE (ops.type),
EXPAND_NORMAL);
- rtx_insn *muinsns = get_insns ();
- end_sequence ();
+ rtx_insn *muinsns = end_sequence ();
unsigned mucost = seq_cost (muinsns, speed_p);
mucost += rtx_cost (mur, mode, EQ, 0, speed_p);
start_sequence ();
rtx mor = expand_expr_real_2 (&ops, NULL_RTX, TYPE_MODE (ops.type),
EXPAND_NORMAL);
- rtx_insn *moinsns = get_insns ();
- end_sequence ();
+ rtx_insn *moinsns = end_sequence ();
unsigned mocost = seq_cost (moinsns, speed_p);
mocost += rtx_cost (mor, mode, EQ, 0, speed_p);
start_sequence ();
rtx mur = expand_normal (t);
- rtx_insn *muinsns = get_insns ();
- end_sequence ();
+ rtx_insn *muinsns = end_sequence ();
unsigned mucost = seq_cost (muinsns, speed_p);
mucost += rtx_cost (mur, mode, LE, 0, speed_p);
start_sequence ();
for (i = 0; i < ivs->num_entries; i++)
emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_at_entry (seq);
}
if (x != new_rtx)
emit_move_insn (new_rtx, x);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
delete_insn (insn);
if (x != SET_DEST (set))
emit_move_insn (SET_DEST (set), x);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
delete_insn (insn);
{
start_sequence ();
emit_move_insn (SET_DEST (set), new_rtx);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
delete_insn (insn);
addr = force_reg (GET_MODE (addr), addr);
x = replace_equiv_address (x, addr, true);
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (seq)
emit_insn_before (seq, insn);
}
x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx,
gen_int_mode (offset, GET_MODE (x)),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
}
break;
(GET_MODE (new_rtx), PLUS, new_rtx,
gen_int_mode (offset, GET_MODE (new_rtx)),
NULL_RTX, 1, OPTAB_LIB_WIDEN);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
}
x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx,
}
else
x = force_reg (insn_data[insn_code].operand[i].mode, x);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (seq)
emit_insn_before (seq, insn);
}
anti_adjust_stack_and_probe (max_frame_size, true);
else
probe_stack_range (STACK_OLD_CHECK_PROTECT, max_frame_size);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
set_insn_locations (seq, prologue_location);
emit_insn_before (seq, stack_check_probe_note);
break;
{
start_sequence ();
clobber_return_register ();
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_after (seq, clobber_after);
}
start_sequence ();
emit_stack_save (SAVE_FUNCTION, &tem);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn_before (seq, parm_birth_insn);
emit_stack_restore (SAVE_FUNCTION, tem);
start_sequence ();
emit_move_insn (validize_mem (copy_rtx (ret)),
crtl->args.internal_arg_pointer);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
push_topmost_sequence ();
emit_insn_after (seq, entry_of_function ());
start_sequence ();
emit_insn (targetm.gen_split_stack_prologue ());
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
record_insns (seq, NULL, &prologue_insn_hash);
set_insn_locations (seq, prologue_location);
if (!targetm.profile_before_prologue () && crtl->profile)
emit_insn (gen_blockage ());
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
set_insn_locations (seq, prologue_location);
return seq;
all call used registers. */
gcc_assert (hard_reg_set_subset_p (zeroed_hardregs, all_call_used_regs));
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
if (seq)
{
/* Emit the memory blockage and register clobber asm volatile before
the whole sequence. */
start_sequence ();
expand_asm_reg_clobber_mem_blockage (zeroed_hardregs);
- rtx_insn *seq_barrier = get_insns ();
- end_sequence ();
+ rtx_insn *seq_barrier = end_sequence ();
emit_insn_before (seq_barrier, ret);
emit_insn_before (seq, ret);
{
start_sequence ();
targetm.emit_epilogue_for_sibcall (as_a<rtx_call_insn *> (insn));
- ep_seq = get_insns ();
- end_sequence ();
+ ep_seq = end_sequence ();
}
else
ep_seq = targetm.gen_sibcall_epilogue ();
start_sequence ();
emit_note (NOTE_INSN_EPILOGUE_BEG);
emit_insn (ep_seq);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
/* Retain a map of the epilogue insns. Used in life analysis to
avoid getting rid of sibcall epilogue insns. Do this before we
start_sequence ();
emit_move_insn (output, copy_rtx (input));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn_before (insns, insn);
constraint = ASM_OPERANDS_OUTPUT_CONSTRAINT(SET_SRC(p_sets[match]));
gcc_unreachable ();
}
- pat = get_insns ();
- end_sequence ();
+ pat = end_sequence ();
return pat;
}
if (recog_memoized (insn) >= 0)
{
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn (seq);
if_info->cond_earliest = if_info->jump;
insn = (OBJECT_P (y) || CONSTANT_P (y) || GET_CODE (y) == SUBREG)
? emit_move_insn (x, y)
: emit_insn (gen_rtx_SET (x, y));
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
if (recog_memoized (insn) <= 0)
{
if (recog_memoized (insn) >= 0)
{
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
emit_insn (seq);
return x;
CONST0_RTX defined. */
if (CONST0_RTX (GET_MODE (reg)))
emit_move_insn (reg, CONST0_RTX (GET_MODE (reg)));
- move_insn = get_insns ();
- end_sequence ();
+ move_insn = end_sequence ();
emit_insn_before (move_insn, insn);
if (dump_file)
fprintf (dump_file,
do_pending_stack_adjust ();
start_sequence ();
expand_unary_optab_fn (fn, stmt, popcount_optab);
- rtx_insn *popcount_insns = get_insns ();
- end_sequence ();
+ rtx_insn *popcount_insns = end_sequence ();
start_sequence ();
rtx plhs = expand_normal (lhs);
rtx pcmp = emit_store_flag (NULL_RTX, EQ, plhs, const1_rtx, lhsmode, 0, 0);
emit_insn (popcount_insns);
return;
}
- rtx_insn *popcount_cmp_insns = get_insns ();
- end_sequence ();
+ rtx_insn *popcount_cmp_insns = end_sequence ();
start_sequence ();
rtx op0 = expand_normal (arg);
rtx argm1 = expand_simple_binop (mode, PLUS, op0, constm1_rtx, NULL_RTX,
cmp = emit_store_flag (NULL_RTX, GTU, argxorargm1, argm1, mode, 1, 1);
if (cmp == NULL_RTX)
goto fail;
- rtx_insn *cmp_insns = get_insns ();
- end_sequence ();
+ rtx_insn *cmp_insns = end_sequence ();
unsigned popcount_cost = (seq_cost (popcount_insns, speed_p)
+ seq_cost (popcount_cmp_insns, speed_p));
unsigned cmp_cost = seq_cost (cmp_insns, speed_p);
goto fail;
}
emit_move_insn (plhs, cmp);
- rtx_insn *all_insns = get_insns ();
- end_sequence ();
+ rtx_insn *all_insns = end_sequence ();
emit_insn (all_insns);
}
}
from = allocno_emit_reg (list->from);
from_regno = REGNO (from);
emit_move_insn (to, from);
- list->insn = get_insns ();
- end_sequence ();
+ list->insn = end_sequence ();
for (insn = list->insn; insn != NULL_RTX; insn = NEXT_INSN (insn))
{
/* The reload needs to have set up insn codes. If the
}
ira_overall_cost += cost;
}
- result = get_insns ();
- end_sequence ();
+ result = end_sequence ();
return result;
}
not put a note as commit_edges insertion will
fail. */
emit_insn (gen_rtx_USE (VOIDmode, const1_rtx));
- rtx_insn *insns = get_insns ();
- end_sequence ();
+ rtx_insn *insns = end_sequence ();
insert_insn_on_edge (insns, e);
}
break;
/* Reset the counter to zero in the set_zero block. */
start_sequence ();
convert_move (counter_reg, noloop, 0);
- sequence = get_insns ();
- end_sequence ();
+ sequence = end_sequence ();
emit_insn_after (sequence, BB_END (set_zero));
set_immediate_dominator (CDI_DOMINATORS, set_zero,
if (prob.initialized_p ())
add_reg_br_prob_note (jump, prob);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
return seq;
}
niter, gen_int_mode (max_unroll, desc->mode),
NULL_RTX, 0, OPTAB_LIB_WIDEN);
- init_code = get_insns ();
- end_sequence ();
+ init_code = end_sequence ();
unshare_all_rtl_in_chain (init_code);
/* Precondition the loop. */
expr = force_operand (expr, ivts->base_var);
if (expr != ivts->base_var)
emit_move_insn (ivts->base_var, expr);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
}
expr = force_operand (expr, var);
if (expr != var)
emit_move_insn (var, expr);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
if (validate_change (insn, loc, var, 0))
src = force_operand (src, dest);
if (src != dest)
emit_move_insn (dest, src);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_before (seq, insn);
delete_insn (insn);
gcc_unreachable ();
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
emit_insn_after (seq, BB_END (place));
}
expr = force_operand (sum, ve->reg);
if (expr != ve->reg)
emit_move_insn (ve->reg, expr);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
insn = BB_HEAD (place);
while (!NOTE_INSN_BASIC_BLOCK_P (insn))
resolve_simple_move (smove, minsn);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
copy_reg_eh_region_note_forward (insn, insns, NULL_RTX);
emit_move_insn (dest_upper, upper_src);
}
- insns = get_insns ();
-
- end_sequence ();
+ insns = end_sequence ();
emit_insn_before (insns, insn);
accurate. */
narrow_reload_pseudo_class (in_rtx, goal_class);
lra_emit_move (copy_rtx (new_in_reg), in_rtx);
- *before = get_insns ();
- end_sequence ();
+ *before = end_sequence ();
/* Add the new pseudo to consider values of subsequent input reload
pseudos. */
lra_assert (curr_insn_input_reloads_num < LRA_MAX_INSN_RELOADS);
out_rtx = gen_rtx_STRICT_LOW_PART (VOIDmode, out_rtx);
lra_emit_move (out_rtx, copy_rtx (new_out_reg));
emit_insn (*after);
- *after = get_insns ();
- end_sequence ();
+ *after = end_sequence ();
}
*curr_id->operand_loc[out] = new_out_reg;
lra_update_dup (curr_id, out);
emit_insn (GEN_FCN (sri.icode) (new_reg != NULL_RTX ? new_reg : dest,
src, scratch_reg));
}
- before = get_insns ();
- end_sequence ();
+ before = end_sequence ();
lra_process_new_insns (curr_insn, before, NULL, "Inserting the move");
if (new_reg != NULL_RTX)
SET_SRC (curr_insn_set) = new_reg;
{
push_to_sequence (*before);
lra_emit_move (new_reg, reg);
- *before = get_insns ();
- end_sequence ();
+ *before = end_sequence ();
}
*loc = new_reg;
if (after != NULL)
start_sequence ();
lra_emit_move (before_p ? copy_rtx (reg) : reg, new_reg);
emit_insn (*after);
- *after = get_insns ();
- end_sequence ();
+ *after = end_sequence ();
}
return true;
}
{
push_to_sequence (*before);
lra_emit_move (newreg, origreg);
- *before = get_insns ();
- end_sequence ();
+ *before = end_sequence ();
}
if (after)
{
start_sequence ();
lra_emit_move (origreg, newreg);
emit_insn (*after);
- *after = get_insns ();
- end_sequence ();
+ *after = end_sequence ();
}
}
lra_emit_move (new_reg, addr);
*ad.inner = new_reg;
}
- *before = get_insns ();
- end_sequence ();
+ *before = end_sequence ();
return true;
}
push_to_sequence (before);
before = emit_spill_move (true, new_reg, src);
emit_insn (before);
- before = get_insns ();
- end_sequence ();
+ before = end_sequence ();
lra_process_new_insns (curr_insn, before, NULL, "Changing on");
lra_set_insn_deleted (curr_insn);
}
push_to_sequence (before);
before = emit_spill_move (true, new_reg, src);
emit_insn (before);
- before = get_insns ();
- end_sequence ();
+ before = end_sequence ();
lra_process_new_insns (curr_insn, before, NULL,
"Inserting the sec. move");
}
if (align_p)
emit_move_insn (new_reg, gen_rtx_AND (GET_MODE (new_reg), new_reg, XEXP (*loc, 1)));
}
- before = get_insns ();
- end_sequence ();
+ before = end_sequence ();
*loc = new_reg;
lra_update_dup (curr_id, i);
}
{
push_to_sequence (before);
lra_emit_move (new_reg, old);
- before = get_insns ();
- end_sequence ();
+ before = end_sequence ();
}
*loc = new_reg;
if (type != OP_IN
start_sequence ();
lra_emit_move (type == OP_INOUT ? copy_rtx (old) : old, new_reg);
emit_insn (after);
- after = get_insns ();
- end_sequence ();
+ after = end_sequence ();
*loc = new_reg;
}
for (j = 0; j < goal_alt_dont_inherit_ops_num; j++)
lra_emit_move (original_reg, new_reg);
else
lra_emit_move (new_reg, original_reg);
- new_insns = get_insns ();
- end_sequence ();
+ new_insns = end_sequence ();
if (NEXT_INSN (new_insns) != NULL_RTX)
{
if (lra_dump_file != NULL)
lra_reg_info[REGNO (new_reg)].restore_rtx = PATTERN (insn);
start_sequence ();
lra_emit_move (new_reg, dst_reg);
- new_insns = get_insns ();
- end_sequence ();
+ new_insns = end_sequence ();
lra_process_new_insns (curr_insn, NULL, new_insns,
"Add invariant inheritance<-original");
start_sequence ();
lra_emit_move (SET_DEST (insn_set), new_reg);
- new_insns = get_insns ();
- end_sequence ();
+ new_insns = end_sequence ();
lra_process_new_insns (insn, NULL, new_insns,
"Changing reload<-inheritance");
lra_set_insn_deleted (insn);
{
start_sequence ();
emit_move_insn (cheap, copy_rtx (dest));
- restore = get_insns ();
- end_sequence ();
+ restore = end_sequence ();
lra_process_new_insns (curr_insn, NULL, restore,
"Inserting call parameter restore");
/* We don't need to save/restore of the pseudo from
/* We cannot just change the source. It might be
an insn different from the move. */
emit_insn (lra_reg_info[sregno].restore_rtx);
- rtx_insn *new_insns = get_insns ();
- end_sequence ();
+ rtx_insn *new_insns = end_sequence ();
lra_assert (single_set (new_insns) != NULL
&& SET_DEST (set) == SET_DEST (single_set (new_insns)));
lra_process_new_insns (curr_insn, NULL, new_insns,
start_sequence ();
emit_insn (remat_pat);
- remat_insn = get_insns ();
- end_sequence ();
+ remat_insn = end_sequence ();
if (recog_memoized (remat_insn) < 0)
remat_insn = NULL;
cand_sp_offset = cand_id->sp_offset;
targetm.mode_switching.emit (e, mode, cur_mode, live_at_edge);
- mode_set = get_insns ();
- end_sequence ();
+ mode_set = end_sequence ();
default_rtl_profile ();
/* Do not bother to insert empty sequence. */
targetm.mode_switching.emit (entity_map[j], ptr->mode,
cur_mode, ptr->regs_live);
- mode_set = get_insns ();
- end_sequence ();
+ mode_set = end_sequence ();
/* Insert MODE_SET only if it is nonempty. */
if (mode_set != NULL_RTX)
emit_move_insn (target_piece, x);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (i == GET_MODE_BITSIZE (int_mode) / BITS_PER_WORD)
{
outof_target, into_target,
unsignedp, next_methods, shift_mask))
{
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return target;
emit_move_insn (outof_target, inter);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
if (inter != 0)
{
NULL_RTX, LCT_CONST, mode,
op0, mode, op1x, op1_mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
bool trapv = trapv_binoptab_p (binoptab);
target = gen_reg_rtx (mode);
/* Get the part of VAL containing the value that we want. */
libval = simplify_gen_subreg (mode, libval, libval_mode,
targ0 ? 0 : GET_MODE_SIZE (mode));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
/* Move the into the desired location. */
emit_libcall_block (insns, targ0 ? targ0 : targ1, libval,
gen_rtx_fmt_ee (code, mode, op0, op1));
goto fail;
}
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
add_equal_note (seq, temp, CLRSB, op0, NULL_RTX, mode);
emit_insn (seq);
emit_label (after_label);
convert_move (target, result, true);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
add_equal_note (seq, target, optab_to_code (unoptab), xop0, NULL_RTX, mode);
emit_insn (seq);
t = expand_binop (word_mode, add_optab, t0, t1, target, 0, OPTAB_DIRECT);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
add_equal_note (seq, t, POPCOUNT, op0, NULL_RTX, mode);
emit_insn (seq);
return 0;
}
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
add_equal_note (seq, temp, CTZ, op0, NULL_RTX, mode);
emit_insn (seq);
if (!temp)
goto fail;
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
add_equal_note (seq, temp, FFS, op0, NULL_RTX, mode);
emit_insn (seq);
emit_move_insn (targ_piece, op0_piece);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
}
emit_move_insn (target_piece, x);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
return target;
if the libcall is cse'd or moved. */
value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST, outmode,
op0, mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
target = gen_reg_rtx (outmode);
bool trapv = trapv_unoptab_p (unoptab);
emit_move_insn (targ_piece, op0_piece);
}
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_insn (insns);
}
start_sequence ();
value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
cmp_mode, x, mode, y, mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
target = gen_reg_rtx (cmp_mode);
emit_libcall_block (insns, target, value, equiv);
value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
GET_MODE (to), from, GET_MODE (from));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, target, value,
gen_rtx_fmt_e (unsignedp ? UNSIGNED_FLOAT : FLOAT,
value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST,
GET_MODE (to), from, GET_MODE (from));
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, target, value,
gen_rtx_fmt_e (unsignedp ? UNSIGNED_FIX : FIX,
start_sequence ();
value = emit_library_call_value (libfunc, NULL_RTX, LCT_CONST, to_mode,
from, from_mode);
- insns = get_insns ();
- end_sequence ();
+ insns = end_sequence ();
emit_libcall_block (insns, to, value,
gen_rtx_fmt_e (optab_to_code (tab), to_mode, from));
}
emit_insn (insn);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
return insn;
}
if (result)
{
/* PLUS worked so emit the insns and return. */
- tmp = get_insns ();
- end_sequence ();
+ tmp = end_sequence ();
emit_insn (tmp);
return result;
}
/* For after, copy the value now. */
if (!unused_result && after)
emit_move_insn (target, t1);
- insn = get_insns ();
- end_sequence ();
+ insn = end_sequence ();
if (t1 != NULL && expand_compare_and_swap_loop (mem, t0, t1, insn))
return target;
REGNO (SET_DEST (set)));
emit_move_insn (new_dst, new_src);
- rtx_insn *insn = get_insns ();
- end_sequence ();
+ rtx_insn *insn = end_sequence ();
if (NEXT_INSN (insn))
return false;
if (recog_memoized (insn) == -1)
change_stack (after, ®stack, target_stack, EMIT_BEFORE);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
set_insn_locations (seq, e->goto_locus);
insert_insn_on_edge (seq, e);
copy_reg_eh_region_note_forward (insn, get_insns (), NULL);
/* End this sequence. */
- *where = get_insns ();
- end_sequence ();
+ *where = end_sequence ();
/* Update reload_override_in so that delete_address_reloads_1
can see the actual register usage. */
start_sequence ();
emit_insn (nop_pattern);
- exit_insn = get_insns ();
- end_sequence ();
+ exit_insn = end_sequence ();
set_block_for_insn (exit_insn, EXIT_BLOCK_PTR_FOR_FN (cfun));
}
{
start_sequence ();
targetm.shrink_wrap.emit_prologue_components (pro);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
record_prologue_seq (seq);
emit_insn_after (seq, bb_note (bb));
{
start_sequence ();
targetm.shrink_wrap.emit_epilogue_components (epi);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
record_epilogue_seq (seq);
emit_insn_after (seq, bb_note (bb));
{
start_sequence ();
targetm.shrink_wrap.emit_epilogue_components (epi);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
record_epilogue_seq (seq);
if (control_flow_insn_p (last_insn))
{
start_sequence ();
targetm.shrink_wrap.emit_prologue_components (pro);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
record_prologue_seq (seq);
if (control_flow_insn_p (last_insn))
/* Put the epilogue components in place. */
start_sequence ();
targetm.shrink_wrap.emit_epilogue_components (epi);
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
record_epilogue_seq (seq);
if (e->flags & EDGE_SIBCALL)
/* Put the prologue components in place. */
start_sequence ();
targetm.shrink_wrap.emit_prologue_components (pro);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
record_prologue_seq (seq);
insert_insn_on_edge (seq, e);
emit_move_insn (dest, src);
do_pending_stack_adjust ();
- rtx_insn *seq = get_insns ();
- end_sequence ();
+ rtx_insn *seq = end_sequence ();
return seq;
}
emit_move_insn (dest_rtx, x);
do_pending_stack_adjust ();
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
insert_insn_on_edge (seq, e);
}
walk_tree (&expr, prepare_decl_rtl, ®no, NULL);
start_sequence ();
rslt = expand_expr (expr, NULL_RTX, TYPE_MODE (type), EXPAND_NORMAL);
- seq = get_insns ();
- end_sequence ();
+ seq = end_sequence ();
default_rtl_profile ();
node->frequency = real_frequency;
projects / thirdparty / gcc.git / commitdiff
