+2015-05-07 Richard Sandiford <richard.sandiford@arm.com>
+
+ * rtl.h (always_void_p): New function.
+ * gengenrtl.c (always_void_p): Likewise.
+ (genmacro): Don't add a mode parameter to gen_rtx_foo if rtxes
+ with code foo are always VOIDmode.
+ * genemit.c (gen_exp): Update gen_rtx_foo calls accordingly.
+ * builtins.c, caller-save.c, calls.c, cfgexpand.c, combine.c,
+ compare-elim.c, config/aarch64/aarch64.c,
+ config/aarch64/aarch64.md, config/alpha/alpha.c,
+ config/alpha/alpha.md, config/arc/arc.c, config/arc/arc.md,
+ config/arm/arm-fixed.md, config/arm/arm.c, config/arm/arm.md,
+ config/arm/ldrdstrd.md, config/arm/thumb2.md, config/arm/vfp.md,
+ config/avr/avr.c, config/bfin/bfin.c, config/c6x/c6x.c,
+ config/c6x/c6x.md, config/cr16/cr16.c, config/cris/cris.c,
+ config/cris/cris.md, config/darwin.c, config/epiphany/epiphany.c,
+ config/epiphany/epiphany.md, config/fr30/fr30.c, config/frv/frv.c,
+ config/frv/frv.md, config/h8300/h8300.c, config/i386/i386.c,
+ config/i386/i386.md, config/i386/sse.md, config/ia64/ia64.c,
+ config/ia64/vect.md, config/iq2000/iq2000.c,
+ config/iq2000/iq2000.md, config/lm32/lm32.c, config/lm32/lm32.md,
+ config/m32c/m32c.c, config/m32r/m32r.c, config/m68k/m68k.c,
+ config/m68k/m68k.md, config/mcore/mcore.c, config/mcore/mcore.md,
+ config/mep/mep.c, config/microblaze/microblaze.c,
+ config/mips/mips.c, config/mips/mips.md, config/mmix/mmix.c,
+ config/mn10300/mn10300.c, config/msp430/msp430.c,
+ config/nds32/nds32-memory-manipulation.c, config/nds32/nds32.c,
+ config/nds32/nds32.md, config/nios2/nios2.c, config/nvptx/nvptx.c,
+ config/pa/pa.c, config/pa/pa.md, config/rl78/rl78.c,
+ config/rs6000/altivec.md, config/rs6000/rs6000.c,
+ config/rs6000/rs6000.md, config/rs6000/vector.md,
+ config/rs6000/vsx.md, config/rx/rx.c, config/rx/rx.md,
+ config/s390/s390.c, config/s390/s390.md, config/sh/sh.c,
+ config/sh/sh.md, config/sh/sh_treg_combine.cc,
+ config/sparc/sparc.c, config/sparc/sparc.md, config/spu/spu.c,
+ config/spu/spu.md, config/stormy16/stormy16.c,
+ config/tilegx/tilegx.c, config/tilegx/tilegx.md,
+ config/tilepro/tilepro.c, config/tilepro/tilepro.md,
+ config/v850/v850.c, config/v850/v850.md, config/vax/vax.c,
+ config/visium/visium.c, config/xtensa/xtensa.c, cprop.c, dse.c,
+ expr.c, gcse.c, ifcvt.c, ira.c, jump.c, lower-subreg.c,
+ lra-constraints.c, lra-eliminations.c, lra.c, postreload.c, ree.c,
+ reg-stack.c, reload.c, reload1.c, reorg.c, sel-sched.c,
+ var-tracking.c: Update calls accordingly.
+
2015-05-07 Segher Boessenkool <segher@kernel.crashing.org>
PR middle-end/192
reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
mem = adjust_address (result, mode, size);
savevec[nelts++] = (savep
- ? gen_rtx_SET (VOIDmode, mem, reg)
- : gen_rtx_SET (VOIDmode, reg, mem));
+ ? gen_rtx_SET (mem, reg)
+ : gen_rtx_SET (reg, mem));
size += GET_MODE_SIZE (mode);
}
return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
test_reg = gen_rtx_REG (VOIDmode, 0);
test_mem = gen_rtx_MEM (VOIDmode, address);
- savepat = gen_rtx_SET (VOIDmode, test_mem, test_reg);
- restpat = gen_rtx_SET (VOIDmode, test_reg, test_mem);
+ savepat = gen_rtx_SET (test_mem, test_reg);
+ restpat = gen_rtx_SET (test_reg, test_mem);
saveinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, savepat, 0, -1, 0);
restinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, restpat, 0, -1, 0);
Currently we handle only single return value case. */
if (REG_P (dest))
{
- newpat = gen_rtx_SET (VOIDmode, cheap, copy_rtx (dest));
+ newpat = gen_rtx_SET (cheap, copy_rtx (dest));
chain = insert_one_insn (chain, 0, -1, newpat);
}
}
gcc_assert (MIN (MAX_SUPPORTED_STACK_ALIGNMENT,
GET_MODE_ALIGNMENT (GET_MODE (mem))) <= MEM_ALIGN (mem));
- pat = gen_rtx_SET (VOIDmode,
- gen_rtx_REG (GET_MODE (mem),
- regno), mem);
+ pat = gen_rtx_SET (gen_rtx_REG (GET_MODE (mem), regno), mem);
code = reg_restore_code (regno, GET_MODE (mem));
new_chain = insert_one_insn (chain, before_p, code, pat);
gcc_assert (MIN (MAX_SUPPORTED_STACK_ALIGNMENT,
GET_MODE_ALIGNMENT (GET_MODE (mem))) <= MEM_ALIGN (mem));
- pat = gen_rtx_SET (VOIDmode, mem,
- gen_rtx_REG (GET_MODE (mem),
- regno));
+ pat = gen_rtx_SET (mem, gen_rtx_REG (GET_MODE (mem), regno));
code = reg_save_code (regno, GET_MODE (mem));
new_chain = insert_one_insn (chain, before_p, code, pat);
&& GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
call_fusage
= gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
- gen_rtx_SET (VOIDmode, valreg, args[arg_nr].reg),
+ gen_rtx_SET (valreg, args[arg_nr].reg),
call_fusage);
}
/* All arguments and registers used for the call must be set up by
else if (noutputs == 1 && nclobbers == 0)
{
ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = ggc_strdup (constraints[0]);
- emit_insn (gen_rtx_SET (VOIDmode, output_rtx[0], body));
+ emit_insn (gen_rtx_SET (output_rtx[0], body));
}
else
{
for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
{
XVECEXP (body, 0, i)
- = gen_rtx_SET (VOIDmode,
- output_rtx[i],
+ = gen_rtx_SET (output_rtx[i],
gen_rtx_ASM_OPERANDS
(GET_MODE (output_rtx[i]),
ggc_strdup (TREE_STRING_POINTER (string)),
if (added_sets_2)
{
if (GET_CODE (PATTERN (i2)) == PARALLEL)
- i2pat = gen_rtx_SET (VOIDmode, i2dest, copy_rtx (i2src));
+ i2pat = gen_rtx_SET (i2dest, copy_rtx (i2src));
else
i2pat = copy_rtx (PATTERN (i2));
}
if (added_sets_1)
{
if (GET_CODE (PATTERN (i1)) == PARALLEL)
- i1pat = gen_rtx_SET (VOIDmode, i1dest, copy_rtx (i1src));
+ i1pat = gen_rtx_SET (i1dest, copy_rtx (i1src));
else
i1pat = copy_rtx (PATTERN (i1));
}
if (added_sets_0)
{
if (GET_CODE (PATTERN (i0)) == PARALLEL)
- i0pat = gen_rtx_SET (VOIDmode, i0dest, copy_rtx (i0src));
+ i0pat = gen_rtx_SET (i0dest, copy_rtx (i0src));
else
i0pat = copy_rtx (PATTERN (i0));
}
/* Create new version of i2pat if needed; the below PARALLEL
creation needs this to work correctly. */
if (! rtx_equal_p (i2src, op0))
- i2pat = gen_rtx_SET (VOIDmode, i2dest, op0);
+ i2pat = gen_rtx_SET (i2dest, op0);
i2_is_used = 1;
}
}
/* Split "X = Y op Y" as "Z = Y; X = Z op Z". */
if (rtx_equal_p (src_op0, src_op1))
{
- newi2pat = gen_rtx_SET (VOIDmode, newdest, src_op0);
+ newi2pat = gen_rtx_SET (newdest, src_op0);
SUBST (XEXP (setsrc, 0), newdest);
SUBST (XEXP (setsrc, 1), newdest);
subst_done = true;
if ((rtx_equal_p (p,r) && rtx_equal_p (q,s))
|| (rtx_equal_p (p,s) && rtx_equal_p (q,r)))
{
- newi2pat = gen_rtx_SET (VOIDmode, newdest,
- XEXP (src_op0, 0));
+ newi2pat = gen_rtx_SET (newdest, XEXP (src_op0, 0));
SUBST (XEXP (setsrc, 0), newdest);
SUBST (XEXP (setsrc, 1), newdest);
subst_done = true;
else if (rtx_equal_p (p,q) && rtx_equal_p (r,s))
{
rtx tmp = simplify_gen_binary (code, mode, p, r);
- newi2pat = gen_rtx_SET (VOIDmode, newdest, tmp);
+ newi2pat = gen_rtx_SET (newdest, tmp);
SUBST (XEXP (setsrc, 0), newdest);
SUBST (XEXP (setsrc, 1), newdest);
subst_done = true;
if (!subst_done)
{
- newi2pat = gen_rtx_SET (VOIDmode, newdest, *split);
+ newi2pat = gen_rtx_SET (newdest, *split);
SUBST (*split, newdest);
}
MEM_ADDR_SPACE (x)))
{
rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
- rtx_insn *seq = combine_split_insns (gen_rtx_SET (VOIDmode, reg,
- XEXP (x, 0)),
+ rtx_insn *seq = combine_split_insns (gen_rtx_SET (reg, XEXP (x, 0)),
subst_insn);
/* This should have produced two insns, each of which sets our
== ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
{
- x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
+ x = gen_rtx_SET (SUBREG_REG (SET_DEST (x)),
gen_lowpart
(GET_MODE (SUBREG_REG (SET_DEST (x))),
SET_SRC (x)));
mask),
pos);
- x = gen_rtx_SET (VOIDmode, copy_rtx (inner),
+ x = gen_rtx_SET (copy_rtx (inner),
simplify_gen_binary (IOR, compute_mode,
cleared, masked));
}
assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
1, 1, 1, 0);
if (assign != 0)
- return gen_rtx_SET (VOIDmode, assign, const0_rtx);
+ return gen_rtx_SET (assign, const0_rtx);
return x;
}
XEXP (SUBREG_REG (XEXP (src, 0)), 1),
1, 1, 1, 0);
if (assign != 0)
- return gen_rtx_SET (VOIDmode, assign, const0_rtx);
+ return gen_rtx_SET (assign, const0_rtx);
return x;
}
assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
1, 1, 1, 0);
if (assign != 0)
- return gen_rtx_SET (VOIDmode, assign, const1_rtx);
+ return gen_rtx_SET (assign, const1_rtx);
return x;
}
/* Complete overlap. We can remove the source AND. */
if ((and_mask & ze_mask) == ze_mask)
- return gen_rtx_SET (VOIDmode, dest, XEXP (src, 0));
+ return gen_rtx_SET (dest, XEXP (src, 0));
/* Partial overlap. We can reduce the source AND. */
if ((and_mask & ze_mask) != and_mask)
mode = GET_MODE (src);
src = gen_rtx_AND (mode, XEXP (src, 0),
gen_int_mode (and_mask & ze_mask, mode));
- return gen_rtx_SET (VOIDmode, dest, src);
+ return gen_rtx_SET (dest, src);
}
}
== ((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (assign, 1))) - 1)
src = XEXP (src, 0);
- return gen_rtx_SET (VOIDmode, assign, src);
+ return gen_rtx_SET (assign, src);
}
\f
/* See if X is of the form (+ (* a c) (* b c)) and convert to (* (+ a b) c)
/* Generate new comparison for substitution. */
rtx flags = gen_rtx_REG (new_mode, targetm.flags_regnum);
rtx x = gen_rtx_COMPARE (new_mode, cmp->in_a, cmp->in_b);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
if (!validate_change (cmp->insn, &PATTERN (cmp->insn), x, false))
return false;
/* Generate a new comparison for installation in the setter. */
x = copy_rtx (cmp_src);
x = gen_rtx_COMPARE (GET_MODE (flags), x, cmp->in_b);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
/* Succeed if the new instruction is valid. Note that we may have started
a change group within maybe_select_cc_mode, therefore we must continue. */
inline static rtx
emit_set_insn (rtx x, rtx y)
{
- return emit_insn (gen_rtx_SET (VOIDmode, x, y));
+ return emit_insn (gen_rtx_SET (x, y));
}
/* X and Y are two things to compare using CODE. Emit the compare insn and
}
case SYMBOL_TINY_ABSOLUTE:
- emit_insn (gen_rtx_SET (Pmode, dest, imm));
+ emit_insn (gen_rtx_SET (dest, imm));
return;
case SYMBOL_SMALL_GOT:
if (mode != Pmode)
tp = gen_lowpart (mode, tp);
- emit_insn (gen_rtx_SET (mode, dest, gen_rtx_PLUS (mode, tp, x0)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_PLUS (mode, tp, x0)));
set_unique_reg_note (get_last_insn (), REG_EQUIV, imm);
return;
}
emit_insn (gen_tlsie_small_sidi (tmp_reg, imm));
}
- emit_insn (gen_rtx_SET (mode, dest, gen_rtx_PLUS (mode, tp, tmp_reg)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_PLUS (mode, tp, tmp_reg)));
set_unique_reg_note (get_last_insn (), REG_EQUIV, imm);
return;
}
if (CONST_INT_P (imm) && aarch64_move_imm (INTVAL (imm), mode))
{
if (generate)
- emit_insn (gen_rtx_SET (VOIDmode, dest, imm));
+ emit_insn (gen_rtx_SET (dest, imm));
num_insns++;
return num_insns;
}
us anything. */
if (generate)
{
- emit_insn (gen_rtx_SET (VOIDmode, dest,
- GEN_INT (INTVAL (imm) & 0xffff)));
+ emit_insn (gen_rtx_SET (dest, GEN_INT (INTVAL (imm) & 0xffff)));
emit_insn (gen_insv_immsi (dest, GEN_INT (16),
GEN_INT ((INTVAL (imm) >> 16) & 0xffff)));
}
mask = 0xffffll << first_not_ffff_match;
if (generate)
{
- emit_insn (gen_rtx_SET (VOIDmode, dest, GEN_INT (val | mask)));
+ emit_insn (gen_rtx_SET (dest, GEN_INT (val | mask)));
emit_insn (gen_insv_immdi (dest, GEN_INT (first_not_ffff_match),
GEN_INT ((val >> first_not_ffff_match)
& 0xffff)));
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (DImode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
- GEN_INT (val & mask)));
+ emit_insn (gen_rtx_SET (subtarget, GEN_INT (val & mask)));
emit_insn (gen_adddi3 (dest, subtarget,
GEN_INT (val - (val & mask))));
}
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (DImode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
+ emit_insn (gen_rtx_SET (subtarget,
GEN_INT ((val + comp) & mask)));
emit_insn (gen_adddi3 (dest, subtarget,
GEN_INT (val - ((val + comp) & mask))));
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (DImode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
+ emit_insn (gen_rtx_SET (subtarget,
GEN_INT ((val - comp) | ~mask)));
emit_insn (gen_adddi3 (dest, subtarget,
GEN_INT (val - ((val - comp) | ~mask))));
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (DImode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
- GEN_INT (val | ~mask)));
+ emit_insn (gen_rtx_SET (subtarget, GEN_INT (val | ~mask)));
emit_insn (gen_adddi3 (dest, subtarget,
GEN_INT (val - (val | ~mask))));
}
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (DImode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
+ emit_insn (gen_rtx_SET (subtarget,
GEN_INT (aarch64_bitmasks[i])));
emit_insn (gen_adddi3 (dest, subtarget,
GEN_INT (val - aarch64_bitmasks[i])));
{
if (generate)
{
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
GEN_INT (aarch64_bitmasks[i])));
emit_insn (gen_insv_immdi (dest, GEN_INT (j),
GEN_INT ((val >> j) & 0xffff)));
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (mode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
+ emit_insn (gen_rtx_SET (subtarget,
GEN_INT (aarch64_bitmasks[i])));
emit_insn (gen_iordi3 (dest, subtarget,
GEN_INT (aarch64_bitmasks[j])));
if (generate)
{
subtarget = subtargets ? gen_reg_rtx (mode) : dest;
- emit_insn (gen_rtx_SET (VOIDmode, subtarget,
+ emit_insn (gen_rtx_SET (subtarget,
GEN_INT (aarch64_bitmasks[j])));
emit_insn (gen_anddi3 (dest, subtarget,
GEN_INT (aarch64_bitmasks[i])));
/* Set either first three quarters or all but the third. */
mask = 0xffffll << (16 - first_not_ffff_match);
if (generate)
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
GEN_INT (val | mask | 0xffffffff00000000ull)));
num_insns ++;
if (first)
{
if (generate)
- emit_insn (gen_rtx_SET (VOIDmode, dest,
- GEN_INT (val & mask)));
+ emit_insn (gen_rtx_SET (dest, GEN_INT (val & mask)));
num_insns ++;
first = false;
}
gcc_assert (mem);
if (mode != ptr_mode)
mem = gen_rtx_ZERO_EXTEND (mode, mem);
- emit_insn (gen_rtx_SET (VOIDmode, dest, mem));
+ emit_insn (gen_rtx_SET (dest, mem));
return;
case SYMBOL_SMALL_TLSGD:
if (!CONST_INT_P (imm))
{
if (GET_CODE (imm) == HIGH)
- emit_insn (gen_rtx_SET (VOIDmode, dest, imm));
+ emit_insn (gen_rtx_SET (dest, imm));
else
{
rtx mem = force_const_mem (mode, imm);
gcc_assert (mem);
- emit_insn (gen_rtx_SET (VOIDmode, dest, mem));
+ emit_insn (gen_rtx_SET (dest, mem));
}
return;
insn = emit_insn (gen_add2_insn (stack_pointer_rtx, op0));
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-frame_size)));
RTX_FRAME_RELATED_P (insn) = 1;
{
if (mdelta >= 4096)
{
- emit_insn (gen_rtx_SET (Pmode, scratch_rtx, GEN_INT (mdelta / 4096)));
+ emit_insn (gen_rtx_SET (scratch_rtx, GEN_INT (mdelta / 4096)));
rtx shift = gen_rtx_ASHIFT (Pmode, scratch_rtx, GEN_INT (12));
if (delta < 0)
- emit_insn (gen_rtx_SET (Pmode, this_rtx,
+ emit_insn (gen_rtx_SET (this_rtx,
gen_rtx_MINUS (Pmode, this_rtx, shift)));
else
- emit_insn (gen_rtx_SET (Pmode, this_rtx,
+ emit_insn (gen_rtx_SET (this_rtx,
gen_rtx_PLUS (Pmode, this_rtx, shift)));
}
if (mdelta % 4096 != 0)
{
scratch_rtx = GEN_INT ((delta < 0 ? -1 : 1) * (mdelta % 4096));
- emit_insn (gen_rtx_SET (Pmode, this_rtx,
+ emit_insn (gen_rtx_SET (this_rtx,
gen_rtx_PLUS (Pmode, this_rtx, scratch_rtx)));
}
}
x = gen_rtx_REG (CCmode, CC_REGNUM);
x = gen_rtx_EQ (SImode, x, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, bval, x));
+ emit_insn (gen_rtx_SET (bval, x));
}
/* Split a compare and swap pattern. */
x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x,
gen_rtx_LABEL_REF (Pmode, label2), pc_rtx);
- aarch64_emit_unlikely_jump (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ aarch64_emit_unlikely_jump (gen_rtx_SET (pc_rtx, x));
aarch64_emit_store_exclusive (mode, scratch, mem, newval, operands[5]);
x = gen_rtx_NE (VOIDmode, scratch, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x,
gen_rtx_LABEL_REF (Pmode, label1), pc_rtx);
- aarch64_emit_unlikely_jump (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ aarch64_emit_unlikely_jump (gen_rtx_SET (pc_rtx, x));
}
else
{
cond = gen_rtx_REG (CCmode, CC_REGNUM);
x = gen_rtx_COMPARE (CCmode, scratch, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, cond, x));
+ emit_insn (gen_rtx_SET (cond, x));
}
emit_label (label2);
case NOT:
x = gen_rtx_AND (wmode, old_out, value);
- emit_insn (gen_rtx_SET (VOIDmode, new_out, x));
+ emit_insn (gen_rtx_SET (new_out, x));
x = gen_rtx_NOT (wmode, new_out);
- emit_insn (gen_rtx_SET (VOIDmode, new_out, x));
+ emit_insn (gen_rtx_SET (new_out, x));
break;
case MINUS:
default:
x = gen_rtx_fmt_ee (code, wmode, old_out, value);
- emit_insn (gen_rtx_SET (VOIDmode, new_out, x));
+ emit_insn (gen_rtx_SET (new_out, x));
break;
}
x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x,
gen_rtx_LABEL_REF (Pmode, label), pc_rtx);
- aarch64_emit_unlikely_jump (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ aarch64_emit_unlikely_jump (gen_rtx_SET (pc_rtx, x));
}
static void
}
/* Emit adjusting instruction. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[8],
- plus_constant (DImode, base, adj_off)));
+ emit_insn (gen_rtx_SET (operands[8], plus_constant (DImode, base, adj_off)));
/* Emit ldp/stp instructions. */
- t1 = gen_rtx_SET (VOIDmode, operands[0], operands[1]);
- t2 = gen_rtx_SET (VOIDmode, operands[2], operands[3]);
+ t1 = gen_rtx_SET (operands[0], operands[1]);
+ t2 = gen_rtx_SET (operands[2], operands[3]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, t1, t2)));
- t1 = gen_rtx_SET (VOIDmode, operands[4], operands[5]);
- t2 = gen_rtx_SET (VOIDmode, operands[6], operands[7]);
+ t1 = gen_rtx_SET (operands[4], operands[5]);
+ t2 = gen_rtx_SET (operands[6], operands[7]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, t1, t2)));
return true;
}
&& GP_REGNUM_P (REGNO (operands[1]))"
[(const_int 0)]
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_XOR (DImode,
gen_rtx_ASHIFTRT (DImode,
operands[1],
GEN_INT (63)),
operands[1])));
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_MINUS (DImode,
operands[0],
gen_rtx_ASHIFTRT (DImode,
(match_operand 3 "const0_operand")]))]
""
"{
- emit_insn (gen_rtx_SET (SImode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
cc_reg = SET_DEST (cmp);
bcomp = gen_rtx_NE (VOIDmode, cc_reg, const0_rtx);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands [1]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
DONE;
if (alpha_tls_size == 64)
{
dest = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, dest, eqv));
+ emit_insn (gen_rtx_SET (dest, eqv));
emit_insn (gen_adddi3 (dest, dest, scratch));
return dest;
}
insn = gen_rtx_HIGH (Pmode, eqv);
insn = gen_rtx_PLUS (Pmode, scratch, insn);
scratch = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, scratch, insn));
+ emit_insn (gen_rtx_SET (scratch, insn));
}
return gen_rtx_LO_SUM (Pmode, scratch, eqv);
dest = gen_reg_rtx (Pmode);
emit_insn (gen_get_thread_pointerdi (tp));
- emit_insn (gen_rtx_SET (VOIDmode, scratch, eqv));
+ emit_insn (gen_rtx_SET (scratch, eqv));
emit_insn (gen_adddi3 (dest, tp, scratch));
return dest;
insn = gen_rtx_HIGH (Pmode, eqv);
insn = gen_rtx_PLUS (Pmode, tp, insn);
tp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, tp, insn));
+ emit_insn (gen_rtx_SET (tp, insn));
}
return gen_rtx_LO_SUM (Pmode, tp, eqv);
{
if (can_create_pseudo_p ())
scratch = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, scratch,
- gen_rtx_HIGH (Pmode, x)));
+ emit_insn (gen_rtx_SET (scratch, gen_rtx_HIGH (Pmode, x)));
return gen_rtx_LO_SUM (Pmode, scratch, x);
}
}
return pc_rtx;
if (target == NULL)
target = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (c)));
+ emit_insn (gen_rtx_SET (target, GEN_INT (c)));
return target;
}
else if (n >= 2 + (extra != 0))
return pc_rtx;
if (!can_create_pseudo_p ())
{
- emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (high << 16)));
+ emit_insn (gen_rtx_SET (target, GEN_INT (high << 16)));
temp = target;
}
else
if (! subtarget)
subtarget = gen_reg_rtx (mode);
insn = gen_rtx_PLUS (mode, temp, GEN_INT (extra << 16));
- insn = gen_rtx_SET (VOIDmode, subtarget, insn);
+ insn = gen_rtx_SET (subtarget, insn);
emit_insn (insn);
temp = subtarget;
}
if (target == NULL)
target = gen_reg_rtx (mode);
insn = gen_rtx_PLUS (mode, temp, GEN_INT (low));
- insn = gen_rtx_SET (VOIDmode, target, insn);
+ insn = gen_rtx_SET (target, insn);
emit_insn (insn);
return target;
}
emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
- emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
+ emit_insn (gen_rtx_SET (out, gen_rtx_FLOAT (mode, in)));
emit_jump_insn (gen_jump (donelab));
emit_barrier ();
emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
emit_insn (gen_anddi3 (i1, in, const1_rtx));
emit_insn (gen_iordi3 (i0, i0, i1));
- emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
- emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
+ emit_insn (gen_rtx_SET (f0, gen_rtx_FLOAT (mode, i0)));
+ emit_insn (gen_rtx_SET (out, gen_rtx_PLUS (mode, f0, f0)));
emit_label (donelab);
}
}
/* Emit the branch instruction. */
- tem = gen_rtx_SET (VOIDmode, pc_rtx,
+ tem = gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
gen_rtx_fmt_ee (branch_code,
branch_mode, tem,
if (cmp_code != UNKNOWN)
{
tmp = gen_reg_rtx (cmp_mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_fmt_ee (cmp_code, cmp_mode, op0, op1)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_fmt_ee (cmp_code, cmp_mode,
+ op0, op1)));
op0 = cmp_mode != DImode ? gen_lowpart (DImode, tmp) : tmp;
op1 = const0_rtx;
}
/* Emit the setcc instruction. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
- gen_rtx_fmt_ee (code, DImode, op0, op1)));
+ emit_insn (gen_rtx_SET (operands[0], gen_rtx_fmt_ee (code, DImode,
+ op0, op1)));
return true;
}
}
tem = gen_reg_rtx (cmp_mode);
- emit_insn (gen_rtx_SET (VOIDmode, tem,
- gen_rtx_fmt_ee (cmp_code, cmp_mode,
- op0, op1)));
+ emit_insn (gen_rtx_SET (tem, gen_rtx_fmt_ee (cmp_code, cmp_mode,
+ op0, op1)));
cmp_mode = cmp_mode == DImode ? DFmode : DImode;
op0 = gen_lowpart (cmp_mode, tem);
&& (diff <= 8 || alpha_tune == PROCESSOR_EV6))
{
tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
+ emit_insn (gen_rtx_SET (copy_rtx (subtarget), tmp));
tmp = gen_rtx_ASHIFT (DImode, copy_rtx (subtarget),
GEN_INT (exact_log2 (t)));
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
}
else if (f == 0 && t == -1)
{
tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
+ emit_insn (gen_rtx_SET (copy_rtx (subtarget), tmp));
emit_insn (gen_negdi2 (target, copy_rtx (subtarget)));
}
rtx add_op;
tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
+ emit_insn (gen_rtx_SET (copy_rtx (subtarget), tmp));
if (diff == 1)
emit_insn (gen_adddi3 (target, copy_rtx (subtarget), GEN_INT (f)));
tmp = gen_rtx_MULT (DImode, copy_rtx (subtarget),
GEN_INT (diff));
tmp = gen_rtx_PLUS (DImode, tmp, add_op);
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
}
else
return 0;
{
emit_insn (gen_extql (data_regs[i], data_regs[i], sreg));
emit_insn (gen_extqh (ext_tmps[i], data_regs[i+1], sreg));
- emit_insn (gen_rtx_SET (VOIDmode, ext_tmps[i],
+ emit_insn (gen_rtx_SET (ext_tmps[i],
gen_rtx_IF_THEN_ELSE (DImode,
gen_rtx_EQ (DImode, areg,
const0_rtx),
rtx x;
x = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, label, pc_rtx);
- x = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ x = emit_jump_insn (gen_rtx_SET (pc_rtx, x));
add_int_reg_note (x, REG_BR_PROB, very_unlikely);
}
if (code == NOT)
{
x = gen_rtx_AND (mode, before, val);
- emit_insn (gen_rtx_SET (VOIDmode, val, x));
+ emit_insn (gen_rtx_SET (val, x));
x = gen_rtx_NOT (mode, val);
}
else
x = gen_rtx_fmt_ee (code, mode, before, val);
if (after)
- emit_insn (gen_rtx_SET (VOIDmode, after, copy_rtx (x)));
- emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
+ emit_insn (gen_rtx_SET (after, copy_rtx (x)));
+ emit_insn (gen_rtx_SET (scratch, x));
emit_store_conditional (mode, cond, mem, scratch);
else
{
x = gen_rtx_EQ (DImode, x, oldval);
- emit_insn (gen_rtx_SET (VOIDmode, cond, x));
+ emit_insn (gen_rtx_SET (cond, x));
x = gen_rtx_EQ (DImode, cond, const0_rtx);
}
emit_unlikely_jump (x, label2);
else
{
x = gen_rtx_EQ (DImode, dest, oldval);
- emit_insn (gen_rtx_SET (VOIDmode, cond, x));
+ emit_insn (gen_rtx_SET (cond, x));
x = gen_rtx_EQ (DImode, cond, const0_rtx);
}
emit_unlikely_jump (x, label2);
}
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, mem, frame_reg));
+ gen_rtx_SET (mem, frame_reg));
}
}
note it looks at instead. */
RTX_FRAME_RELATED_P (seq) = 1;
add_reg_note (seq, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-frame_size)));
}
bit at bit 48 of the fraction, which is representable in DFmode,
which prevents rounding error in the final conversion to SFmode. */
- emit_insn (gen_rtx_SET (VOIDmode, sticky,
- gen_rtx_NE (DImode, lo, const0_rtx)));
+ emit_insn (gen_rtx_SET (sticky, gen_rtx_NE (DImode, lo, const0_rtx)));
emit_insn (gen_iordi3 (hi, hi, sticky));
emit_insn (gen_trunctfdf2 (tmpf, arg));
emit_insn (gen_truncdfsf2 (operands[0], tmpf));
emit_insn (gen_movdi (operand_subword (target, 1, 0, TImode), out[1]));
if (target != operands[0])
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], target));
+ emit_insn (gen_rtx_SET (operands[0], target));
DONE;
}
}
if (mode != CC_FPXmode)
- emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
+ emit_insn (gen_rtx_SET (cc_reg,
gen_rtx_COMPARE (mode,
gen_rtx_REG (CC_FPXmode, 61),
const0_rtx)));
emit_insn (gen_cmp_float (cc_reg, gen_rtx_COMPARE (mode, op0, op1)));
}
else
- emit_insn (gen_rtx_SET (omode, cc_reg,
- gen_rtx_COMPARE (mode, x, y)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (mode, x, y)));
return gen_rtx_fmt_ee (code, omode, cc_reg, const0_rtx);
}
static rtx
frame_move (rtx dst, rtx src)
{
- return frame_insn (gen_rtx_SET (VOIDmode, dst, src));
+ return frame_insn (gen_rtx_SET (dst, src));
}
/* Like frame_move, but add a REG_INC note for REG if ADDR contains an
= gen_frame_mem (SImode, plus_constant (Pmode, base_reg, off));
if (epilogue_p)
- XVECEXP (insn, 0, i) = gen_rtx_SET (VOIDmode, reg, mem);
+ XVECEXP (insn, 0, i) = gen_rtx_SET (reg, mem);
else
- XVECEXP (insn, 0, i) = gen_rtx_SET (VOIDmode, mem, reg);
+ XVECEXP (insn, 0, i) = gen_rtx_SET (mem, reg);
gmask = gmask & ~(1L << r);
}
if (epilogue_p == 2)
{
rtx r12 = gen_rtx_REG (Pmode, 12);
- frame_insn (gen_rtx_SET (VOIDmode, r12, GEN_INT (offset)));
+ frame_insn (gen_rtx_SET (r12, GEN_INT (offset)));
XVECEXP (sibthunk_insn, 0, 0) = ret_rtx;
XVECEXP (sibthunk_insn, 0, 1)
- = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx, r12));
sibthunk_insn = emit_jump_insn (sibthunk_insn);
RTX_FRAME_RELATED_P (sibthunk_insn) = 1;
pat = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, pat), ARC_UNSPEC_GOT);
pat = gen_rtx_CONST (Pmode, pat);
- pat = gen_rtx_SET (VOIDmode, baseptr_rtx, pat);
+ pat = gen_rtx_SET (baseptr_rtx, pat);
emit_insn (pat);
}
if (next_active_insn (top_label) == insn)
{
rtx lc_set
- = gen_rtx_SET (VOIDmode,
- XEXP (XVECEXP (PATTERN (lp), 0, 3), 0),
+ = gen_rtx_SET (XEXP (XVECEXP (PATTERN (lp), 0, 3), 0),
const0_rtx);
rtx_insn *lc_set_insn = emit_insn_before (lc_set, insn);
brcc_insn
= gen_rtx_IF_THEN_ELSE (VOIDmode, op, label, pc_rtx);
- brcc_insn = gen_rtx_SET (VOIDmode, pc_rtx, brcc_insn);
+ brcc_insn = gen_rtx_SET (pc_rtx, brcc_insn);
cc_clob_rtx = gen_rtx_CLOBBER (VOIDmode, cc_clob_rtx);
brcc_insn
= gen_rtx_PARALLEL
variables. */
operands[1] = arc_rewrite_small_data (operands[1]);
- emit_insn (gen_rtx_SET (mode, operands[0],operands[1]));
+ emit_insn (gen_rtx_SET (operands[0],operands[1]));
/* ??? This note is useless, since it only restates the set itself.
We should rather use the original SYMBOL_REF. However, there is
the problem that we are lying to the compiler about these
variables. */
operands[1]
= gen_rtx_fmt_e (code, omode, arc_rewrite_small_data (operands[1]));
- emit_insn (gen_rtx_SET (omode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
set_unique_reg_note (get_last_insn (), REG_EQUAL, operands[1]);
/* Take care of the REG_EQUAL note that will be attached to mark the
/* Leave add_n alone - the canonical form is to
have the complex summand first. */
&& REG_P (src0))
- pat = gen_rtx_SET (VOIDmode, dst,
+ pat = gen_rtx_SET (dst,
gen_rtx_fmt_ee (GET_CODE (src), GET_MODE (src),
src1, src0));
}
else if (JUMP_P (insn) && ANY_RETURN_P (PATTERN (insn)))
{
pat = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, pat, pc_rtx);
- pat = gen_rtx_SET (VOIDmode, pc_rtx, pat);
+ pat = gen_rtx_SET (pc_rtx, pat);
}
else
gcc_unreachable ();
if (TARGET_DPFP_DISABLE_LRSR)
{
/* gen *movdf_insn_nolrsr */
- rtx set = gen_rtx_SET (VOIDmode, dest, src);
+ rtx set = gen_rtx_SET (dest, src);
rtx use1 = gen_rtx_USE (VOIDmode, const1_rtx);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, use1)));
}
rtx destLow = simplify_gen_subreg(SImode, dest, DFmode, 0);
/* Produce the two LR insns to get the high and low parts. */
- emit_insn (gen_rtx_SET (VOIDmode,
- destHigh,
+ emit_insn (gen_rtx_SET (destHigh,
gen_rtx_UNSPEC_VOLATILE (Pmode, gen_rtvec (1, src),
VUNSPEC_LR_HIGH)));
- emit_insn (gen_rtx_SET (VOIDmode,
- destLow,
+ emit_insn (gen_rtx_SET (destLow,
gen_rtx_UNSPEC_VOLATILE (Pmode, gen_rtvec (1, src),
VUNSPEC_LR)));
}
operands[5-swap] = xop[3];
start_sequence ();
- emit_insn (gen_rtx_SET (VOIDmode, operands[2], operands[3]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[4], operands[5]));
+ emit_insn (gen_rtx_SET (operands[2], operands[3]));
+ emit_insn (gen_rtx_SET (operands[4], operands[5]));
val = get_insns ();
end_sequence ();
(gen_rtx_COND_EXEC
(VOIDmode,
gen_rtx_LTU (VOIDmode, gen_rtx_REG (CC_Cmode, CC_REG), GEN_INT (0)),
- gen_rtx_SET (VOIDmode, h0, plus_constant (SImode, h0, 1))));
+ gen_rtx_SET (h0, plus_constant (SImode, h0, 1))));
DONE;
}
emit_insn (gen_add_f (l0, l1, l2));
{
h1 = simplify_gen_binary (MINUS, SImode, h1, h2);
if (!rtx_equal_p (h0, h1))
- emit_insn (gen_rtx_SET (VOIDmode, h0, h1));
+ emit_insn (gen_rtx_SET (h0, h1));
emit_insn (gen_sub_f (l0, l1, l2));
emit_insn
(gen_rtx_COND_EXEC
(VOIDmode,
gen_rtx_LTU (VOIDmode, gen_rtx_REG (CC_Cmode, CC_REG), GEN_INT (0)),
- gen_rtx_SET (VOIDmode, h0, plus_constant (SImode, h0, -1))));
+ gen_rtx_SET (h0, plus_constant (SImode, h0, -1))));
DONE;
}
emit_insn (gen_sub_f (l0, l1, l2));
x = gen_rtx_GTU (VOIDmode, gen_rtx_REG (CCmode, CC_REG), const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x,
gen_rtx_LABEL_REF (VOIDmode, operands[4]), pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, x));
if (TARGET_COMPACT_CASESI)
{
emit_jump_insn (gen_casesi_compact_jump (operands[5], operands[7]));
(gen_rtx_COND_EXEC
(VOIDmode,
gen_rtx_LT (VOIDmode, gen_rtx_REG (CC_ZNmode, CC_REG), const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0], const0_rtx)));
+ gen_rtx_SET (operands[0], const0_rtx)));
emit_insn
(gen_rtx_COND_EXEC
(VOIDmode,
gen_rtx_GE (VOIDmode, gen_rtx_REG (CC_ZNmode, CC_REG), const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0],
- plus_constant (SImode, operands[0], 1))));
+ gen_rtx_SET (operands[0], plus_constant (SImode, operands[0], 1))));
DONE;
})
(gen_rtx_COND_EXEC
(VOIDmode,
gen_rtx_LT (VOIDmode, gen_rtx_REG (CC_ZNmode, CC_REG), const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0], GEN_INT (32))));
+ gen_rtx_SET (operands[0], GEN_INT (32))));
emit_insn
(gen_rtx_COND_EXEC
(VOIDmode,
gen_rtx_GE (VOIDmode, gen_rtx_REG (CC_ZNmode, CC_REG), const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0],
- gen_rtx_MINUS (SImode, GEN_INT (31), temp))));
+ gen_rtx_SET (operands[0], gen_rtx_MINUS (SImode, GEN_INT (31), temp))));
DONE;
})
rshift = gen_rtx_ASHIFTRT (SImode, tmp, GEN_INT (7));
- emit_insn (gen_rtx_SET (VOIDmode, gen_lowpart (HImode, operands[0]),
+ emit_insn (gen_rtx_SET (gen_lowpart (HImode, operands[0]),
gen_rtx_SS_TRUNCATE (HImode, rshift)));
DONE;
inline static rtx_insn *
emit_set_insn (rtx x, rtx y)
{
- return emit_insn (gen_rtx_SET (VOIDmode, x, y));
+ return emit_insn (gen_rtx_SET (x, y));
}
/* Return the number of bits set in VALUE. */
{
if (generate)
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
GEN_INT (ARM_SIGN_EXTEND (val))));
return 1;
}
return 0;
if (generate)
- emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target, source));
+ emit_constant_insn (cond, gen_rtx_SET (target, source));
return 1;
}
break;
if (remainder == 0)
{
if (generate)
- emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target, const0_rtx));
+ emit_constant_insn (cond, gen_rtx_SET (target, const0_rtx));
return 1;
}
if (remainder == 0xffffffff)
if (reload_completed && rtx_equal_p (target, source))
return 0;
if (generate)
- emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target, source));
+ emit_constant_insn (cond, gen_rtx_SET (target, source));
return 1;
}
can_invert = 1;
if (reload_completed && rtx_equal_p (target, source))
return 0;
if (generate)
- emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target, source));
+ emit_constant_insn (cond, gen_rtx_SET (target, source));
return 1;
}
{
if (generate)
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_NOT (mode, source)));
return 1;
}
{
if (generate)
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_NEG (mode, source)));
return 1;
}
{
if (generate)
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_MINUS (mode, GEN_INT (val),
source)));
return 1;
{
if (generate)
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
(source
? gen_rtx_fmt_ee (code, mode, source,
GEN_INT (val))
{
rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, new_src,
- GEN_INT (temp1)));
+ gen_rtx_SET (new_src, GEN_INT (temp1)));
emit_constant_insn (cond,
gen_ashrsi3 (target, new_src,
GEN_INT (set_sign_bit_copies - 1)));
{
rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, new_src,
- GEN_INT (temp1)));
+ gen_rtx_SET (new_src, GEN_INT (temp1)));
emit_constant_insn (cond,
gen_ashrsi3 (target, new_src,
GEN_INT (set_sign_bit_copies - 1)));
{
rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, new_src,
- GEN_INT (temp1)));
+ gen_rtx_SET (new_src, GEN_INT (temp1)));
emit_constant_insn (cond,
gen_addsi3 (target, new_src,
GEN_INT (-temp2)));
emit_constant_insn
(cond,
gen_rtx_SET
- (VOIDmode, target,
+ (target,
gen_rtx_IOR (mode,
gen_rtx_ASHIFT (mode, source,
GEN_INT (i)),
if (generate)
emit_constant_insn
(cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_IOR
(mode,
gen_rtx_LSHIFTRT (mode, source,
rtx sub = subtargets ? gen_reg_rtx (mode) : target;
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, sub,
- GEN_INT (val)));
+ gen_rtx_SET (sub, GEN_INT (val)));
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_fmt_ee (code, mode,
source, sub)));
}
emit_constant_insn
(cond,
- gen_rtx_SET (VOIDmode, sub,
+ gen_rtx_SET (sub,
gen_rtx_NOT (mode,
gen_rtx_ASHIFT (mode,
source,
shift))));
emit_constant_insn
(cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_NOT (mode,
gen_rtx_LSHIFTRT (mode, sub,
shift))));
emit_constant_insn
(cond,
- gen_rtx_SET (VOIDmode, sub,
+ gen_rtx_SET (sub,
gen_rtx_NOT (mode,
gen_rtx_LSHIFTRT (mode,
source,
shift))));
emit_constant_insn
(cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_NOT (mode,
gen_rtx_ASHIFT (mode, sub,
shift))));
{
rtx sub = subtargets ? gen_reg_rtx (mode) : target;
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, sub,
+ gen_rtx_SET (sub,
gen_rtx_NOT (mode, source)));
source = sub;
if (subtargets)
sub = gen_reg_rtx (mode);
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, sub,
+ gen_rtx_SET (sub,
gen_rtx_AND (mode, source,
GEN_INT (temp1))));
emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, target,
+ gen_rtx_SET (target,
gen_rtx_NOT (mode, sub)));
}
return 3;
else
temp1_rtx = gen_rtx_fmt_ee (code, mode, source, temp1_rtx);
- emit_constant_insn (cond,
- gen_rtx_SET (VOIDmode, new_src,
- temp1_rtx));
+ emit_constant_insn (cond, gen_rtx_SET (new_src, temp1_rtx));
source = new_src;
if (code == SET)
if (final_invert)
{
if (generate)
- emit_constant_insn (cond, gen_rtx_SET (VOIDmode, target,
+ emit_constant_insn (cond, gen_rtx_SET (target,
gen_rtx_NOT (mode, source)));
insns++;
}
pic_rtx = gen_rtx_CONST (Pmode, pic_rtx);
emit_insn (gen_pic_load_addr_32bit (pic_reg, pic_rtx));
- emit_insn (gen_rtx_SET (Pmode, pic_reg, gen_rtx_MEM (Pmode, pic_reg)));
+ emit_insn (gen_rtx_SET (pic_reg, gen_rtx_MEM (Pmode, pic_reg)));
pic_tmp = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
emit_insn (gen_pic_offset_arm (pic_reg, pic_reg, pic_tmp));
if (all_same && GET_MODE_SIZE (inner_mode) <= 4)
{
x = copy_to_mode_reg (inner_mode, XVECEXP (vals, 0, 0));
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_VEC_DUPLICATE (mode, x)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_VEC_DUPLICATE (mode, x)));
return;
}
if (wback_offset != 0)
{
XVECEXP (result, 0, 0)
- = gen_rtx_SET (VOIDmode, basereg,
- plus_constant (Pmode, basereg, wback_offset));
+ = gen_rtx_SET (basereg, plus_constant (Pmode, basereg, wback_offset));
i = 1;
count++;
}
for (j = 0; i < count; i++, j++)
XVECEXP (result, 0, i)
- = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regs[j]), mems[j]);
+ = gen_rtx_SET (gen_rtx_REG (SImode, regs[j]), mems[j]);
return result;
}
if (wback_offset != 0)
{
XVECEXP (result, 0, 0)
- = gen_rtx_SET (VOIDmode, basereg,
- plus_constant (Pmode, basereg, wback_offset));
+ = gen_rtx_SET (basereg, plus_constant (Pmode, basereg, wback_offset));
i = 1;
count++;
}
for (j = 0; i < count; i++, j++)
XVECEXP (result, 0, i)
- = gen_rtx_SET (VOIDmode, mems[j], gen_rtx_REG (SImode, regs[j]));
+ = gen_rtx_SET (mems[j], gen_rtx_REG (SImode, regs[j]));
return result;
}
scratch = gen_rtx_SCRATCH (SImode);
clobber = gen_rtx_CLOBBER (VOIDmode, scratch);
- set = gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y));
+ set = gen_rtx_SET (cc_reg, gen_rtx_COMPARE (mode, x, y));
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber)));
}
else
dest = copy_rtx (dest);
src = copy_rtx (src);
src = gen_rtx_MINUS (SImode, src, const0_rtx);
- PATTERN (prev) = gen_rtx_SET (VOIDmode, dest, src);
+ PATTERN (prev) = gen_rtx_SET (dest, src);
INSN_CODE (prev) = -1;
/* Set test register in INSN to dest. */
XEXP (XEXP (SET_SRC (pat), 0), 0) = copy_rtx (dest);
src = copy_rtx (src);
XEXP (src, 0) = op1;
XEXP (src, 1) = op0;
- pat = gen_rtx_SET (VOIDmode, dst, src);
+ pat = gen_rtx_SET (dst, src);
vec = gen_rtvec (2, pat, clobber);
}
else /* action == CONV */
base_reg += 2;
XVECEXP (par, 0, 0)
- = gen_rtx_SET (VOIDmode,
- gen_frame_mem
+ = gen_rtx_SET (gen_frame_mem
(BLKmode,
gen_rtx_PRE_MODIFY (Pmode,
stack_pointer_rtx,
gen_rtvec (1, reg),
UNSPEC_PUSH_MULT));
- tmp = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, -(count * 8)));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, 0) = tmp;
- tmp = gen_rtx_SET (VOIDmode,
- gen_frame_mem (DFmode, stack_pointer_rtx),
- reg);
+ tmp = gen_rtx_SET (gen_frame_mem (DFmode, stack_pointer_rtx), reg);
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, 1) = tmp;
base_reg += 2;
XVECEXP (par, 0, i) = gen_rtx_USE (VOIDmode, reg);
- tmp = gen_rtx_SET (VOIDmode,
- gen_frame_mem (DFmode,
+ tmp = gen_rtx_SET (gen_frame_mem (DFmode,
plus_constant (Pmode,
stack_pointer_rtx,
i * 8)),
dwarf = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (num_regs + 1));
/* Describe the stack adjustment. */
- tmp = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
- plus_constant (Pmode, stack_pointer_rtx, -4 * num_regs));
+ tmp = gen_rtx_SET (stack_pointer_rtx,
+ plus_constant (Pmode, stack_pointer_rtx, -4 * num_regs));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, 0) = tmp;
plus_constant (Pmode, stack_pointer_rtx,
-4 * num_regs)));
- tmp = gen_rtx_SET (VOIDmode, mem, reg);
+ tmp = gen_rtx_SET (mem, reg);
RTX_FRAME_RELATED_P (tmp) = 1;
insn = emit_insn (tmp);
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR, dwarf);
- tmp = gen_rtx_SET (VOIDmode, gen_frame_mem (Pmode, stack_pointer_rtx),
- reg);
+ tmp = gen_rtx_SET (gen_frame_mem (Pmode, stack_pointer_rtx), reg);
RTX_FRAME_RELATED_P (tmp) = 1;
i++;
regno++;
mem2 = gen_frame_mem (Pmode, plus_constant (Pmode,
stack_pointer_rtx,
-4 * (num_regs - 1)));
- tmp0 = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ tmp0 = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-4 * (num_regs)));
- tmp1 = gen_rtx_SET (VOIDmode, mem1, reg1);
- tmp2 = gen_rtx_SET (VOIDmode, mem2, reg2);
+ tmp1 = gen_rtx_SET (mem1, reg1);
+ tmp2 = gen_rtx_SET (mem2, reg2);
RTX_FRAME_RELATED_P (tmp0) = 1;
RTX_FRAME_RELATED_P (tmp1) = 1;
RTX_FRAME_RELATED_P (tmp2) = 1;
mem2 = gen_frame_mem (Pmode, plus_constant (Pmode,
stack_pointer_rtx,
4 * (i + 1)));
- tmp1 = gen_rtx_SET (VOIDmode, mem1, reg1);
- tmp2 = gen_rtx_SET (VOIDmode, mem2, reg2);
+ tmp1 = gen_rtx_SET (mem1, reg1);
+ tmp2 = gen_rtx_SET (mem2, reg2);
RTX_FRAME_RELATED_P (tmp1) = 1;
RTX_FRAME_RELATED_P (tmp2) = 1;
par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
}
/* Create unwind information. This is an approximation. */
- tmp1 = gen_rtx_SET (VOIDmode,
- gen_frame_mem (Pmode,
+ tmp1 = gen_rtx_SET (gen_frame_mem (Pmode,
plus_constant (Pmode,
stack_pointer_rtx,
4 * i)),
reg1);
- tmp2 = gen_rtx_SET (VOIDmode,
- gen_frame_mem (Pmode,
+ tmp2 = gen_rtx_SET (gen_frame_mem (Pmode,
plus_constant (Pmode,
stack_pointer_rtx,
4 * (i + 1))),
dwarf = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (num_regs + 1));
/* For dwarf info, we generate explicit stack update. */
- tmp = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, -4 * num_regs));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, dwarf_index++) = tmp;
else
mem = gen_frame_mem (DImode, stack_pointer_rtx);
- tmp = gen_rtx_SET (DImode, mem, gen_rtx_REG (DImode, j));
+ tmp = gen_rtx_SET (mem, gen_rtx_REG (DImode, j));
RTX_FRAME_RELATED_P (tmp) = 1;
tmp = emit_insn (tmp);
plus_constant (Pmode,
stack_pointer_rtx,
offset));
- tmp = gen_rtx_SET (SImode, mem, gen_rtx_REG (SImode, j));
+ tmp = gen_rtx_SET (mem, gen_rtx_REG (SImode, j));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, dwarf_index++) = tmp;
plus_constant (Pmode,
stack_pointer_rtx,
offset + 4));
- tmp = gen_rtx_SET (SImode, mem, gen_rtx_REG (SImode, j + 1));
+ tmp = gen_rtx_SET (mem, gen_rtx_REG (SImode, j + 1));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, dwarf_index++) = tmp;
else
mem = gen_frame_mem (SImode, stack_pointer_rtx);
- tmp = gen_rtx_SET (SImode, mem, gen_rtx_REG (SImode, j));
+ tmp = gen_rtx_SET (mem, gen_rtx_REG (SImode, j));
RTX_FRAME_RELATED_P (tmp) = 1;
tmp = emit_insn (tmp);
plus_constant(Pmode,
stack_pointer_rtx,
offset));
- tmp = gen_rtx_SET (SImode, mem, gen_rtx_REG (SImode, j));
+ tmp = gen_rtx_SET (mem, gen_rtx_REG (SImode, j));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, dwarf_index++) = tmp;
reg = gen_rtx_REG (SImode, i);
XVECEXP (par, 0, 0)
- = gen_rtx_SET (VOIDmode,
- gen_frame_mem
+ = gen_rtx_SET (gen_frame_mem
(BLKmode,
gen_rtx_PRE_MODIFY (Pmode,
stack_pointer_rtx,
if (dwarf_regs_mask & (1 << i))
{
- tmp = gen_rtx_SET (VOIDmode,
- gen_frame_mem (SImode, stack_pointer_rtx),
+ tmp = gen_rtx_SET (gen_frame_mem (SImode, stack_pointer_rtx),
reg);
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, dwarf_par_index++) = tmp;
if (dwarf_regs_mask & (1 << i))
{
tmp
- = gen_rtx_SET (VOIDmode,
- gen_frame_mem
+ = gen_rtx_SET (gen_frame_mem
(SImode,
plus_constant (Pmode, stack_pointer_rtx,
4 * j)),
par = emit_insn (par);
- tmp = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, -4 * num_regs));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (dwarf, 0, 0) = tmp;
rtx dwarf;
RTX_FRAME_RELATED_P (insn) = 1;
- dwarf = gen_rtx_SET (VOIDmode, dest, plus_constant (Pmode, src, size));
+ dwarf = gen_rtx_SET (dest, plus_constant (Pmode, src, size));
add_reg_note (insn, REG_CFA_ADJUST_CFA, dwarf);
}
{
/* Increment the stack pointer, based on there being
num_regs 4-byte registers to restore. */
- tmp = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
4 * num_regs));
tmp = gen_frame_mem (SImode,
gen_rtx_POST_INC (Pmode,
stack_pointer_rtx));
- tmp = emit_insn (gen_rtx_SET (VOIDmode, reg, tmp));
+ tmp = emit_insn (gen_rtx_SET (reg, tmp));
REG_NOTES (tmp) = alloc_reg_note (REG_CFA_RESTORE, reg, dwarf);
return;
}
- tmp = gen_rtx_SET (VOIDmode,
- reg,
+ tmp = gen_rtx_SET (reg,
gen_frame_mem
(SImode,
plus_constant (Pmode, stack_pointer_rtx, 4 * j)));
/* Increment the stack pointer, based on there being
num_regs 8-byte registers to restore. */
- tmp = gen_rtx_SET (VOIDmode,
- base_reg,
- plus_constant (Pmode, base_reg, 8 * num_regs));
+ tmp = gen_rtx_SET (base_reg, plus_constant (Pmode, base_reg, 8 * num_regs));
RTX_FRAME_RELATED_P (tmp) = 1;
XVECEXP (par, 0, 0) = tmp;
{
reg = gen_rtx_REG (DFmode, i);
- tmp = gen_rtx_SET (VOIDmode,
- reg,
+ tmp = gen_rtx_SET (reg,
gen_frame_mem
(DFmode,
plus_constant (Pmode, base_reg, 8 * j)));
{
/* Create RTX for memory load. */
reg = gen_rtx_REG (SImode, j);
- tmp = gen_rtx_SET (SImode,
- reg,
+ tmp = gen_rtx_SET (reg,
gen_frame_mem (SImode,
plus_constant (Pmode,
stack_pointer_rtx, 4 * i)));
/* Increment the stack pointer, based on there being
num_regs 4-byte registers to restore. */
- tmp = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, 4 * i));
RTX_FRAME_RELATED_P (tmp) = 1;
tmp = emit_insn (tmp);
set_mem_alias_set (tmp1, get_frame_alias_set ());
reg = gen_rtx_REG (SImode, j);
- tmp = gen_rtx_SET (SImode, reg, tmp1);
+ tmp = gen_rtx_SET (reg, tmp1);
RTX_FRAME_RELATED_P (tmp) = 1;
dwarf = alloc_reg_note (REG_CFA_RESTORE, reg, dwarf);
else
mem = gen_frame_mem (DImode, stack_pointer_rtx);
- tmp = gen_rtx_SET (DImode, gen_rtx_REG (DImode, j), mem);
+ tmp = gen_rtx_SET (gen_rtx_REG (DImode, j), mem);
tmp = emit_insn (tmp);
RTX_FRAME_RELATED_P (tmp) = 1;
else
mem = gen_frame_mem (SImode, stack_pointer_rtx);
- tmp = gen_rtx_SET (SImode, gen_rtx_REG (SImode, j), mem);
+ tmp = gen_rtx_SET (gen_rtx_REG (SImode, j), mem);
tmp = emit_insn (tmp);
RTX_FRAME_RELATED_P (tmp) = 1;
/* Update the stack. */
if (offset > 0)
{
- tmp = gen_rtx_SET (Pmode,
- stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
offset));
/* Only PC is to be popped. */
par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
XVECEXP (par, 0, 0) = ret_rtx;
- tmp = gen_rtx_SET (SImode,
- gen_rtx_REG (SImode, PC_REGNUM),
+ tmp = gen_rtx_SET (gen_rtx_REG (SImode, PC_REGNUM),
gen_frame_mem (SImode,
gen_rtx_POST_INC (SImode,
stack_pointer_rtx)));
hard_frame_pointer_rtx,
stack_pointer_rtx));
}
- dwarf = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
+ dwarf = gen_rtx_SET (hard_frame_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, amount));
RTX_FRAME_RELATED_P (dwarf) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR, dwarf);
fp_offset = 4;
/* Just tell the dwarf backend that we adjusted SP. */
- dwarf = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ dwarf = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-fp_offset));
RTX_FRAME_RELATED_P (insn) = 1;
/* Just tell the dwarf backend that we adjusted SP. */
dwarf
- = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-args_to_push));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, dwarf);
/* Special case of reversed high/low parts. Use VSWP. */
if (src2 == dest && src1 == dest + halfregs)
{
- rtx x = gen_rtx_SET (VOIDmode, destlo, operands[1]);
- rtx y = gen_rtx_SET (VOIDmode, desthi, operands[2]);
+ rtx x = gen_rtx_SET (destlo, operands[1]);
+ rtx y = gen_rtx_SET (desthi, operands[2]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, x, y)));
return;
}
tmp = plus_constant (Pmode, stack_pointer_rtx, -4 * i);
tmp = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, tmp);
tmp = gen_frame_mem (BLKmode, tmp);
- tmp = gen_rtx_SET (VOIDmode, tmp, par[0]);
+ tmp = gen_rtx_SET (tmp, par[0]);
par[0] = tmp;
tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (i, par));
/* Always build the stack adjustment note for unwind info. */
tmp = plus_constant (Pmode, stack_pointer_rtx, -4 * i);
- tmp = gen_rtx_SET (VOIDmode, stack_pointer_rtx, tmp);
+ tmp = gen_rtx_SET (stack_pointer_rtx, tmp);
par[0] = tmp;
/* Build the parallel of the registers recorded as saved for unwind. */
tmp = plus_constant (Pmode, stack_pointer_rtx, j * 4);
tmp = gen_frame_mem (SImode, tmp);
- tmp = gen_rtx_SET (VOIDmode, tmp, reg);
+ tmp = gen_rtx_SET (tmp, reg);
RTX_FRAME_RELATED_P (tmp) = 1;
par[j + 1] = tmp;
}
insn = emit_insn (gen_addsi3 (stack_pointer_rtx,
stack_pointer_rtx, reg));
- dwarf = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ dwarf = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-amount));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, dwarf);
stack_pointer_rtx));
set_mem_alias_set (addr, get_frame_alias_set ());
XVECEXP (par, 0, 0) = ret_rtx;
- XVECEXP (par, 0, 1) = gen_rtx_SET (SImode, reg, addr);
+ XVECEXP (par, 0, 1) = gen_rtx_SET (reg, addr);
RTX_FRAME_RELATED_P (XVECEXP (par, 0, 1)) = 1;
emit_jump_insn (par);
}
{
insn = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
XVECEXP (insn, 0, 0) = ret_rtx;
- XVECEXP (insn, 0, 1) = gen_rtx_SET (SImode,
- gen_rtx_REG (SImode, i),
+ XVECEXP (insn, 0, 1) = gen_rtx_SET (gen_rtx_REG (SImode, i),
addr);
RTX_FRAME_RELATED_P (XVECEXP (insn, 0, 1)) = 1;
insn = emit_jump_insn (insn);
in a subsequent branch, post optimization. */
x = gen_rtx_REG (CCmode, CC_REGNUM);
x = gen_rtx_EQ (SImode, x, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, bval, x));
+ emit_insn (gen_rtx_SET (bval, x));
}
/* Split a compare and swap pattern. It is IMPLEMENTATION DEFINED whether
x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x,
gen_rtx_LABEL_REF (Pmode, label2), pc_rtx);
- emit_unlikely_jump (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ emit_unlikely_jump (gen_rtx_SET (pc_rtx, x));
arm_emit_store_exclusive (mode, scratch, mem, newval, use_release);
match the flags that we got from the compare above. */
cond = gen_rtx_REG (CCmode, CC_REGNUM);
x = gen_rtx_COMPARE (CCmode, scratch, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, cond, x));
+ emit_insn (gen_rtx_SET (cond, x));
if (!is_weak)
{
x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x,
gen_rtx_LABEL_REF (Pmode, label1), pc_rtx);
- emit_unlikely_jump (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ emit_unlikely_jump (gen_rtx_SET (pc_rtx, x));
}
if (mod_f != MEMMODEL_RELAXED)
case NOT:
x = gen_rtx_AND (wmode, old_out, value);
- emit_insn (gen_rtx_SET (VOIDmode, new_out, x));
+ emit_insn (gen_rtx_SET (new_out, x));
x = gen_rtx_NOT (wmode, new_out);
- emit_insn (gen_rtx_SET (VOIDmode, new_out, x));
+ emit_insn (gen_rtx_SET (new_out, x));
break;
case MINUS:
default:
x = gen_rtx_fmt_ee (code, wmode, old_out, value);
- emit_insn (gen_rtx_SET (VOIDmode, new_out, x));
+ emit_insn (gen_rtx_SET (new_out, x));
break;
}
gen_addsi3_compare0 ((DEST), (SRC), \
GEN_INT (-32))
#define SET(DEST,SRC) \
- gen_rtx_SET (SImode, (DEST), (SRC))
+ gen_rtx_SET ((DEST), (SRC))
#define SHIFT(CODE,SRC,AMOUNT) \
gen_rtx_fmt_ee ((CODE), SImode, (SRC), (AMOUNT))
#define LSHIFT(CODE,SRC,AMOUNT) \
if (operands[2] == const0_rtx || operands[2] == constm1_rtx)
{
/* No need for a clobber of the condition code register here. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_SMAX (SImode, operands[1],
operands[2])));
DONE;
if (operands[2] == const0_rtx)
{
/* No need for a clobber of the condition code register here. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_SMIN (SImode, operands[1],
operands[2])));
DONE;
rsc Rhi, Rhi, #0 (thumb2: sbc Rhi, Rhi, Rhi, lsl #1). */
rtx cc_reg = gen_rtx_REG (CC_Cmode, CC_REGNUM);
- emit_insn (gen_rtx_SET (VOIDmode, high,
+ emit_insn (gen_rtx_SET (high,
gen_rtx_ASHIFTRT (SImode, operands[1],
GEN_INT (31))));
emit_insn (gen_subsi3_compare (low, const0_rtx, operands[1]));
if (TARGET_ARM)
- emit_insn (gen_rtx_SET (VOIDmode, high,
+ emit_insn (gen_rtx_SET (high,
gen_rtx_MINUS (SImode,
gen_rtx_MINUS (SImode,
const0_rtx,
else
{
rtx two_x = gen_rtx_ASHIFT (SImode, high, GEN_INT (1));
- emit_insn (gen_rtx_SET (VOIDmode, high,
+ emit_insn (gen_rtx_SET (high,
gen_rtx_MINUS (SImode,
gen_rtx_MINUS (SImode,
high,
bic Rhi, Rlo, Rin
asr Rhi, Rhi, #31
Flags not needed for this sequence. */
- emit_insn (gen_rtx_SET (VOIDmode, low,
- gen_rtx_NEG (SImode, operands[1])));
- emit_insn (gen_rtx_SET (VOIDmode, high,
+ emit_insn (gen_rtx_SET (low, gen_rtx_NEG (SImode, operands[1])));
+ emit_insn (gen_rtx_SET (high,
gen_rtx_AND (SImode,
gen_rtx_NOT (SImode, operands[1]),
low)));
- emit_insn (gen_rtx_SET (VOIDmode, high,
+ emit_insn (gen_rtx_SET (high,
gen_rtx_ASHIFTRT (SImode, high,
GEN_INT (31))));
}
(cond_exec (lt:CC (reg:CC CC_REGNUM) (const_int 0))
(set (match_dup 0) (minus:SI (const_int 0) (match_dup 1))))]
*/
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_REG (CCmode, CC_REGNUM),
+ emit_insn (gen_rtx_SET (gen_rtx_REG (CCmode, CC_REGNUM),
gen_rtx_COMPARE (CCmode, operands[0], const0_rtx)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
(gen_rtx_LT (SImode,
gen_rtx_REG (CCmode, CC_REGNUM),
const0_rtx)),
- (gen_rtx_SET (VOIDmode,
- operands[0],
+ (gen_rtx_SET (operands[0],
(gen_rtx_MINUS (SImode,
const0_rtx,
operands[1]))))));
(minus:SI (match_dup 0)
(ashiftrt:SI (match_dup 1) (const_int 31))))]
*/
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_XOR (SImode,
gen_rtx_ASHIFTRT (SImode,
operands[1],
GEN_INT (31)),
operands[1])));
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_MINUS (SImode,
operands[0],
gen_rtx_ASHIFTRT (SImode,
/* Emit the pattern:
cmp\\t%0, #0\;rsbgt\\t%0, %0, #0
*/
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_REG (CCmode, CC_REGNUM),
+ emit_insn (gen_rtx_SET (gen_rtx_REG (CCmode, CC_REGNUM),
gen_rtx_COMPARE (CCmode, operands[0], const0_rtx)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_GT (SImode,
gen_rtx_REG (CCmode, CC_REGNUM),
const0_rtx),
- gen_rtx_SET (VOIDmode,
- operands[0],
+ gen_rtx_SET (operands[0],
(gen_rtx_MINUS (SImode,
const0_rtx,
operands[1])))));
/* Emit the pattern:
eor%?\\t%0, %1, %1, asr #31\;rsb%?\\t%0, %0, %1, asr #31
*/
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_XOR (SImode,
gen_rtx_ASHIFTRT (SImode,
operands[1],
GEN_INT (31)),
operands[1])));
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_MINUS (SImode,
gen_rtx_ASHIFTRT (SImode,
operands[1],
if (src_mode == SImode)
emit_move_insn (lo_part, operands[1]);
else
- emit_insn (gen_rtx_SET (VOIDmode, lo_part,
+ emit_insn (gen_rtx_SET (lo_part,
gen_rtx_ZERO_EXTEND (SImode, operands[1])));
operands[1] = lo_part;
}
if (src_mode == SImode)
emit_move_insn (lo_part, operands[1]);
else
- emit_insn (gen_rtx_SET (VOIDmode, lo_part,
+ emit_insn (gen_rtx_SET (lo_part,
gen_rtx_SIGN_EXTEND (SImode, operands[1])));
operands[1] = lo_part;
}
{
if (arm_arch4 && MEM_P (operands[1]))
{
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_SIGN_EXTEND (HImode, operands[1])));
DONE;
}
if (offset < -0x8000 || offset > 0x7fff)
{
arm_emit_movpair (operands[0], operands[1]);
- emit_insn (gen_rtx_SET (SImode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_PLUS (SImode, operands[0], operands[2])));
}
else
emit_insn (gen_addsi3 (operands[2], XEXP (XEXP (operands[0], 0), 0),
XEXP (XEXP (operands[0], 0), 1)));
- emit_insn (gen_rtx_SET (VOIDmode,
- replace_equiv_address (operands[0], operands[2]),
+ emit_insn (gen_rtx_SET (replace_equiv_address (operands[0], operands[2]),
operands[1]));
if (code == POST_DEC)
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
operands[3],
- gen_rtx_SET (VOIDmode,
- operands[0],
- operands[1])));
+ gen_rtx_SET (operands[0], operands[1])));
rev_code = GET_CODE (operands[3]);
mode = GET_MODE (operands[4]);
const0_rtx);
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
rev_cond,
- gen_rtx_SET (VOIDmode,
- operands[0],
- operands[2])));
+ gen_rtx_SET (operands[0], operands[2])));
DONE;
}
[(set_attr "length" "4,4,4,4,8,8,8,8")
if (GET_CODE (operands[3]) == LT && operands[2] == const0_rtx)
{
/* Emit mov\\t%0, %1, asr #31 */
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_ASHIFTRT (SImode,
operands[1],
GEN_INT (31))));
gen_rtx_NE (SImode,
cc_reg,
const0_rtx),
- gen_rtx_SET (SImode,
- operands[0],
+ gen_rtx_SET (operands[0],
GEN_INT (~0))));
DONE;
}
else
{
/* Emit: cmp\\t%1, %2\;mov%D3\\t%0, #0\;mvn%d3\\t%0, #0 */
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
+ emit_insn (gen_rtx_SET (cc_reg,
gen_rtx_COMPARE (CCmode, operands[1], operands[2])));
enum rtx_code rc = GET_CODE (operands[3]);
VOIDmode,
cc_reg,
const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0], const0_rtx)));
+ gen_rtx_SET (operands[0], const0_rtx)));
rc = GET_CODE (operands[3]);
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_fmt_ee (rc,
VOIDmode,
cc_reg,
const0_rtx),
- gen_rtx_SET (VOIDmode,
- operands[0],
+ gen_rtx_SET (operands[0],
GEN_INT (~0))));
DONE;
}
emit_move_insn (scratch1, op2_high);
emit_move_insn (scratch2, op1_high);
- emit_insn(gen_rtx_SET(SImode, scratch1,
+ emit_insn(gen_rtx_SET(scratch1,
gen_rtx_LSHIFTRT (SImode, op2_high, GEN_INT(31))));
emit_insn(gen_insv_t2(scratch2, GEN_INT(1), GEN_INT(31), scratch1));
emit_move_insn (op0_low, op1_low);
operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
operands[2] = adjust_address (operands[2], DImode, 0);
/* Emit [(set (match_dup 0) (match_dup 2))] */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[2]));
+ emit_insn (gen_rtx_SET (operands[0], operands[2]));
DONE;
}
else if (TARGET_THUMB2)
/* Emit the pattern:
[(parallel [(set (match_dup 0) (match_dup 2))
(set (match_dup 1) (match_dup 3))])] */
- rtx t1 = gen_rtx_SET (VOIDmode, operands[0], operands[2]);
- rtx t2 = gen_rtx_SET (VOIDmode, operands[1], operands[3]);
+ rtx t1 = gen_rtx_SET (operands[0], operands[2]);
+ rtx t2 = gen_rtx_SET (operands[1], operands[3]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, t1, t2)));
DONE;
}
operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
operands[2] = adjust_address (operands[2], DImode, 0);
/* Emit [(set (match_dup 2) (match_dup 0))] */
- emit_insn (gen_rtx_SET (VOIDmode, operands[2], operands[0]));
+ emit_insn (gen_rtx_SET (operands[2], operands[0]));
DONE;
}
else if (TARGET_THUMB2)
/* Emit the pattern:
[(parallel [(set (match_dup 2) (match_dup 0))
(set (match_dup 3) (match_dup 1))])] */
- rtx t1 = gen_rtx_SET (VOIDmode, operands[2], operands[0]);
- rtx t2 = gen_rtx_SET (VOIDmode, operands[3], operands[1]);
+ rtx t1 = gen_rtx_SET (operands[2], operands[0]);
+ rtx t2 = gen_rtx_SET (operands[3], operands[1]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, t1, t2)));
DONE;
}
[(set (match_dup 0) (match_dup 4))
(set (match_dup 1) (match_dup 5))
(set (match_dup 2) tmp)] */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[4]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[1], operands[5]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[2], tmp));
+ emit_insn (gen_rtx_SET (operands[0], operands[4]));
+ emit_insn (gen_rtx_SET (operands[1], operands[5]));
+ emit_insn (gen_rtx_SET (operands[2], tmp));
DONE;
}
else if (TARGET_THUMB2)
(set (match_dup 1) (match_dup 5))
(parallel [(set (match_dup 2) (match_dup 0))
(set (match_dup 3) (match_dup 1))])] */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[4]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[1], operands[5]));
- rtx t1 = gen_rtx_SET (VOIDmode, operands[2], operands[0]);
- rtx t2 = gen_rtx_SET (VOIDmode, operands[3], operands[1]);
+ emit_insn (gen_rtx_SET (operands[0], operands[4]));
+ emit_insn (gen_rtx_SET (operands[1], operands[5]));
+ rtx t1 = gen_rtx_SET (operands[2], operands[0]);
+ rtx t2 = gen_rtx_SET (operands[3], operands[1]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, t1, t2)));
DONE;
}
[(set (match_dup 0) (match_dup 4))
(set (match_dup 1) (match_dup 5))
(set (match_dup 2) tmp)] */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[4]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[1], operands[5]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[2], tmp));
+ emit_insn (gen_rtx_SET (operands[0], operands[4]));
+ emit_insn (gen_rtx_SET (operands[1], operands[5]));
+ emit_insn (gen_rtx_SET (operands[2], tmp));
DONE;
}
else if (TARGET_THUMB2)
(set (match_dup 1) (match_dup 5))
(parallel [(set (match_dup 2) (match_dup 0))
(set (match_dup 3) (match_dup 1))])] */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[4]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[1], operands[5]));
- rtx t1 = gen_rtx_SET (VOIDmode, operands[2], operands[0]);
- rtx t2 = gen_rtx_SET (VOIDmode, operands[3], operands[1]);
+ emit_insn (gen_rtx_SET (operands[0], operands[4]));
+ emit_insn (gen_rtx_SET (operands[1], operands[5]));
+ rtx t1 = gen_rtx_SET (operands[2], operands[0]);
+ rtx t2 = gen_rtx_SET (operands[3], operands[1]);
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, t1, t2)));
DONE;
}
{
rtx cc_reg = gen_rtx_REG (CCmode, CC_REGNUM);
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
- gen_rtx_COMPARE (CCmode, operands[0], const0_rtx)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (CCmode, operands[0],
+ const0_rtx)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
(gen_rtx_LT (SImode,
cc_reg,
const0_rtx)),
- (gen_rtx_SET (VOIDmode,
- operands[0],
+ (gen_rtx_SET (operands[0],
(gen_rtx_MINUS (SImode,
const0_rtx,
operands[1]))))));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_XOR (SImode,
gen_rtx_ASHIFTRT (SImode,
operands[1],
GEN_INT (31)),
operands[1])));
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_MINUS (SImode,
operands[0],
gen_rtx_ASHIFTRT (SImode,
{
rtx cc_reg = gen_rtx_REG (CCmode, CC_REGNUM);
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
- gen_rtx_COMPARE (CCmode, operands[0], const0_rtx)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (CCmode, operands[0],
+ const0_rtx)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
(gen_rtx_GT (SImode,
cc_reg,
const0_rtx)),
- (gen_rtx_SET (VOIDmode,
- operands[0],
+ (gen_rtx_SET (operands[0],
(gen_rtx_MINUS (SImode,
const0_rtx,
operands[1]))))));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_XOR (SImode,
gen_rtx_ASHIFTRT (SImode,
operands[1],
GEN_INT (31)),
operands[1])));
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_MINUS (SImode,
gen_rtx_ASHIFTRT (SImode,
operands[1],
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
operands[3],
- gen_rtx_SET (VOIDmode,
- operands[0],
- operands[1])));
+ gen_rtx_SET (operands[0], operands[1])));
rev_code = GET_CODE (operands[3]);
mode = GET_MODE (operands[4]);
if (mode == CCFPmode || mode == CCFPEmode)
const0_rtx);
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
rev_cond,
- gen_rtx_SET (VOIDmode,
- operands[0],
- operands[2])));
+ gen_rtx_SET (operands[0], operands[2])));
DONE;
}
[(set_attr "length" "4,4,6,6,6,6,10,8,10,10,10,6")
break;
default: gcc_unreachable ();
}
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], op));
+ emit_insn (gen_rtx_SET (operands[0], op));
DONE;
}
/* "cmp %2, %3" */
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_REG (CCmode, CC_REGNUM),
- gen_rtx_COMPARE (CCmode, operands[2], operands[3])));
+ emit_insn (gen_rtx_SET (gen_rtx_REG (CCmode, CC_REGNUM),
+ gen_rtx_COMPARE (CCmode, operands[2],
+ operands[3])));
if (GET_CODE (operands[5]) == AND)
{
it%D4
mov%D4 %0, #0 */
enum rtx_code rc = reverse_condition (GET_CODE (operands[4]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], gen_rtx_AND (SImode, operands[1], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (operands[0], gen_rtx_AND (SImode, operands[1],
+ GEN_INT (1))));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_fmt_ee (rc, VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM), const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0], const0_rtx)));
+ gen_rtx_SET (operands[0], const0_rtx)));
DONE;
}
else
emit_insn (gen_rtx_COND_EXEC (VOIDmode, gen_rtx_fmt_ee (GET_CODE (operands[4]),
VOIDmode,
gen_rtx_REG (CCmode, CC_REGNUM), const0_rtx),
- gen_rtx_SET(VOIDmode, operands[0],
+ gen_rtx_SET (operands[0],
gen_rtx_PLUS (SImode,
operands[1],
GEN_INT (1)))));
if (GET_CODE (operands[3]) == LT && operands[2] == const0_rtx)
{
/* Emit asr\\t%0, %1, #31 */
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_ASHIFTRT (SImode,
operands[1],
GEN_INT (31))));
gen_rtx_NE (SImode,
cc_reg,
const0_rtx),
- gen_rtx_SET (SImode,
- operands[0],
+ gen_rtx_SET (operands[0],
GEN_INT (~0))));
DONE;
}
machine_mode mode = SELECT_CC_MODE (rc, operands[1], operands[2]);
rtx tmp1 = gen_rtx_REG (mode, CC_REGNUM);
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
- gen_rtx_COMPARE (CCmode, operands[1], operands[2])));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (CCmode, operands[1],
+ operands[2])));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], GEN_INT (~0)));
+ emit_insn (gen_rtx_SET (operands[0], GEN_INT (~0)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_fmt_ee (rc,
VOIDmode,
tmp1,
const0_rtx),
- gen_rtx_SET (VOIDmode, operands[0], const0_rtx)));
+ gen_rtx_SET (operands[0], const0_rtx)));
DONE;
}
FAIL;
cc_reg = SET_DEST (cmp);
bcomp = gen_rtx_NE (VOIDmode, cc_reg, const0_rtx);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands [1]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
DONE;
if (REGNO (in_lo) == REGNO (out_hi))
{
- emit_insn (gen_rtx_SET (SImode, out_lo, in_lo));
+ emit_insn (gen_rtx_SET (out_lo, in_lo));
operands[0] = out_hi;
operands[1] = in_hi;
}
else
{
- emit_insn (gen_rtx_SET (SImode, out_hi, in_hi));
+ emit_insn (gen_rtx_SET (out_hi, in_hi));
operands[0] = out_lo;
operands[1] = in_lo;
}
mem = gen_frame_mem (QImode, mem);
reg = gen_rtx_REG (QImode, regno);
- insn = emit_insn (gen_rtx_SET (VOIDmode, mem, reg));
+ insn = emit_insn (gen_rtx_SET (mem, reg));
if (frame_related_p)
RTX_FRAME_RELATED_P (insn) = 1;
is going to be permanent in the function is frame_pointer_needed. */
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, (frame_pointer_needed
- ? frame_pointer_rtx
- : stack_pointer_rtx),
+ gen_rtx_SET ((frame_pointer_needed
+ ? frame_pointer_rtx
+ : stack_pointer_rtx),
plus_constant (Pmode, stack_pointer_rtx,
-(size + live_seq))));
m = gen_rtx_MEM (QImode, plus_constant (Pmode, stack_pointer_rtx,
offset));
r = gen_rtx_REG (QImode, reg);
- add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (VOIDmode, m, r));
+ add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (m, r));
}
cfun->machine->stack_usage += size + live_seq;
{
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, fp, stack_pointer_rtx));
+ gen_rtx_SET (fp, stack_pointer_rtx));
}
insn = emit_move_insn (my_fp, plus_constant (GET_MODE (my_fp),
{
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, fp,
- plus_constant (Pmode, fp,
- -size_cfa)));
+ gen_rtx_SET (fp, plus_constant (Pmode, fp,
+ -size_cfa)));
}
/* Copy to stack pointer. Note that since we've already
{
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
-size_cfa)));
-size));
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
-size_cfa)));
mem = gen_frame_mem (QImode, mem);
reg = gen_rtx_REG (QImode, regno);
- emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ emit_insn (gen_rtx_SET (reg, mem));
}
/* Output RTL epilogue. */
xsrc = SIGNED_FIXED_POINT_MODE_P (mode)
? gen_rtx_SS_PLUS (mode, xop[1], xadd)
: gen_rtx_US_PLUS (mode, xop[1], xadd);
- xpattern = gen_rtx_SET (VOIDmode, xop[0], xsrc);
+ xpattern = gen_rtx_SET (xop[0], xsrc);
op[0] = xop[0];
op[1] = xop[1];
rtx xreg = simplify_gen_subreg (imode, xop[0], mode, 0);
rtx xmask = immed_wide_int_const (-wi_add - wi_add, imode);
- xpattern = gen_rtx_SET (VOIDmode, xreg, gen_rtx_AND (imode, xreg, xmask));
+ xpattern = gen_rtx_SET (xreg, gen_rtx_AND (imode, xreg, xmask));
op[0] = xreg;
op[1] = xreg;
XVECEXP (pat, 0, 0) = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, val),
UNSPEC_PUSH_MULTIPLE);
- XVECEXP (pat, 0, total_consec + 1) = gen_rtx_SET (VOIDmode, spreg,
+ XVECEXP (pat, 0, total_consec + 1) = gen_rtx_SET (spreg,
gen_rtx_PLUS (Pmode,
spreg,
val));
rtx subpat;
if (d_to_save > 0)
{
- subpat = gen_rtx_SET (VOIDmode, memref, gen_rtx_REG (word_mode,
- dregno++));
+ subpat = gen_rtx_SET (memref, gen_rtx_REG (word_mode, dregno++));
d_to_save--;
}
else
{
- subpat = gen_rtx_SET (VOIDmode, memref, gen_rtx_REG (word_mode,
- pregno++));
+ subpat = gen_rtx_SET (memref, gen_rtx_REG (word_mode, pregno++));
}
XVECEXP (pat, 0, i + 1) = subpat;
RTX_FRAME_RELATED_P (subpat) = 1;
{
rtx pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_consec + 1));
XVECEXP (pat, 0, 0)
- = gen_rtx_SET (VOIDmode, spreg,
- gen_rtx_PLUS (Pmode, spreg,
- GEN_INT (total_consec * 4)));
+ = gen_rtx_SET (spreg, gen_rtx_PLUS (Pmode, spreg,
+ GEN_INT (total_consec * 4)));
if (npregs_consec > 0)
regno = REG_P5 + 1;
regno--;
XVECEXP (pat, 0, i + 1)
- = gen_rtx_SET (VOIDmode, gen_rtx_REG (word_mode, regno), memref);
+ = gen_rtx_SET (gen_rtx_REG (word_mode, regno), memref);
if (npregs_consec > 0)
{
call = gen_rtx_CALL (VOIDmode, fnaddr, callarg1);
if (retval)
- call = gen_rtx_SET (VOIDmode, retval, call);
+ call = gen_rtx_SET (retval, call);
pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nelts));
n = 0;
code2 = EQ;
break;
}
- emit_insn (gen_rtx_SET (VOIDmode, tem,
- gen_rtx_fmt_ee (code1, BImode, op0, op1)));
+ emit_insn (gen_rtx_SET (tem, gen_rtx_fmt_ee (code1, BImode, op0, op1)));
}
return gen_rtx_fmt_ee (code2, BImode, tem, CONST0_RTX (BImode));
if (retval == NULL_RTX)
call_insn = emit_call_insn (call_insn);
else
- call_insn = emit_call_insn (gen_rtx_SET (GET_MODE (retval), retval,
- call_insn));
+ call_insn = emit_call_insn (gen_rtx_SET (retval, call_insn));
}
if (flag_pic)
use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn), pic_offset_table_rtx);
cmp1 = gen_reg_rtx (SImode);
cmp2 = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (VOIDmode, cmp1,
- gen_rtx_fmt_ee (code, SImode, high[0], high[1])));
+ emit_insn (gen_rtx_SET (cmp1, gen_rtx_fmt_ee (code, SImode,
+ high[0], high[1])));
if (code == EQ)
{
if (c6x_force_op_for_comparison_p (code, lo[1]))
lo[1] = force_reg (SImode, lo[1]);
- emit_insn (gen_rtx_SET (VOIDmode, cmp2,
- gen_rtx_fmt_ee (code, SImode, lo[0], lo[1])));
+ emit_insn (gen_rtx_SET (cmp2, gen_rtx_fmt_ee (code, SImode,
+ lo[0], lo[1])));
emit_insn (gen_andsi3 (cmp1, cmp1, cmp2));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode, cmp2,
- gen_rtx_EQ (SImode, high[0], high[1])));
+ emit_insn (gen_rtx_SET (cmp2, gen_rtx_EQ (SImode, high[0],
+ high[1])));
if (code == GT)
code = GTU;
else if (code == LT)
}
cmp = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (VOIDmode, cmp,
- gen_rtx_fmt_ee (code1, SImode, op0, op1)));
+ emit_insn (gen_rtx_SET (cmp, gen_rtx_fmt_ee (code1, SImode, op0, op1)));
fn = op_mode == DFmode ? gen_cmpdf_ior : gen_cmpsf_ior;
emit_insn (fn (cmp, gen_rtx_fmt_ee (code2, SImode, op0, op1),
op0, op1, cmp));
cmp = gen_reg_rtx (SImode);
if (c6x_force_op_for_comparison_p (code, op1))
op1 = force_reg (SImode, op1);
- emit_insn (gen_rtx_SET (VOIDmode, cmp,
- gen_rtx_fmt_ee (code, SImode, op0, op1)));
+ emit_insn (gen_rtx_SET (cmp, gen_rtx_fmt_ee (code, SImode,
+ op0, op1)));
}
}
{
if (REG_P (to_add))
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
orig_to_add)));
&& type == TYPE_LOAD_SHADOW)
|| (XINT (prev_pat, 1) == UNSPEC_REAL_MULT
&& type == TYPE_MULT_SHADOW)));
- insn_pat = gen_rtx_SET (VOIDmode, SET_DEST (insn_pat),
+ insn_pat = gen_rtx_SET (SET_DEST (insn_pat),
XVECEXP (prev_pat, 0, 1));
insn_pat = duplicate_cond (insn_pat, prev);
PATTERN (insn) = insn_pat;
rtx tmpreg = gen_reg_rtx (SImode);
rtx t = gen_rtx_fmt_ee (reverse_condition (GET_CODE (operands[1])),
SImode, operands[2], operands[3]);
- emit_insn (gen_rtx_SET (VOIDmode, tmpreg, t));
+ emit_insn (gen_rtx_SET (tmpreg, t));
emit_insn (gen_scmpsi_insn (operands[0],
gen_rtx_fmt_ee (EQ, SImode, tmpreg, const0_rtx),
tmpreg, const0_rtx));
}
reg = gen_rtx_REG (mode, j);
offset += 2 * inc;
- tmp = gen_rtx_SET (VOIDmode,
- gen_frame_mem (mode,
+ tmp = gen_rtx_SET (gen_frame_mem (mode,
plus_constant
(Pmode, stack_pointer_rtx,
total_push_bytes - offset)),
from = i--;
}
- tmp = gen_rtx_SET (SImode, stack_pointer_rtx,
+ tmp = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (SImode, stack_pointer_rtx,
GEN_INT (-offset)));
RTX_FRAME_RELATED_P (tmp) = 1;
/* We normally copy the low-numbered register first. However, if
the first register operand 0 is the same as the second register of
operand 1, we must copy in the opposite order. */
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, reverse, TRUE, mode),
operand_subword (src, reverse, TRUE, mode)));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, !reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, !reverse, TRUE, mode),
operand_subword (src, !reverse, TRUE, mode)));
}
/* Constant-to-reg copy. */
{
rtx words[2];
split_double (src, &words[0], &words[1]);
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, 0, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, 0, TRUE, mode),
words[0]));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, 1, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, 1, TRUE, mode),
words[1]));
}
/* Mem-to-reg copy. */
manually. */
mem = change_address (src, SImode, addr);
insn
- = gen_rtx_SET (VOIDmode,
- operand_subword (dest, 0, TRUE, mode), mem);
+ = gen_rtx_SET (operand_subword (dest, 0, TRUE, mode), mem);
insn = emit_insn (insn);
if (GET_CODE (XEXP (mem, 0)) == POST_INC)
REG_NOTES (insn)
mem = copy_rtx (mem);
insn
- = gen_rtx_SET (VOIDmode,
- operand_subword (dest, 1, TRUE, mode), mem);
+ = gen_rtx_SET (operand_subword (dest, 1, TRUE, mode), mem);
insn = emit_insn (insn);
if (GET_CODE (XEXP (mem, 0)) == POST_INC)
REG_NOTES (insn)
fatal_insn ("unexpected side-effects in address", addr);
emit_insn (gen_rtx_SET
- (VOIDmode,
- operand_subword (dest, reverse, TRUE, mode),
+ (operand_subword (dest, reverse, TRUE, mode),
change_address
(src, SImode,
plus_constant (Pmode, addr,
reverse * UNITS_PER_WORD))));
emit_insn (gen_rtx_SET
- (VOIDmode,
- operand_subword (dest, ! reverse, TRUE, mode),
+ (operand_subword (dest, ! reverse, TRUE, mode),
change_address
(src, SImode,
plus_constant (Pmode, addr,
ourselves, we must add a post-inc note manually. */
mem = change_address (dest, SImode, addr);
insn
- = gen_rtx_SET (VOIDmode,
- mem, operand_subword (src, 0, TRUE, mode));
+ = gen_rtx_SET (mem, operand_subword (src, 0, TRUE, mode));
insn = emit_insn (insn);
if (GET_CODE (XEXP (mem, 0)) == POST_INC)
REG_NOTES (insn)
REG_NOTES (insn));
mem = copy_rtx (mem);
- insn
- = gen_rtx_SET (VOIDmode,
- mem,
- operand_subword (src, 1, TRUE, mode));
+ insn = gen_rtx_SET (mem, operand_subword (src, 1, TRUE, mode));
insn = emit_insn (insn);
if (GET_CODE (XEXP (mem, 0)) == POST_INC)
REG_NOTES (insn)
fatal_insn ("unexpected side-effects in address", addr);
emit_insn (gen_rtx_SET
- (VOIDmode,
- change_address (dest, SImode, addr),
+ (change_address (dest, SImode, addr),
operand_subword (src, 0, TRUE, mode)));
emit_insn (gen_rtx_SET
- (VOIDmode,
- change_address (dest, SImode,
+ (change_address (dest, SImode,
plus_constant (Pmode, addr,
UNITS_PER_WORD)),
operand_subword (src, 1, TRUE, mode)));
stdarg_regs > 0;
regno--, pretend -= 4, stdarg_regs--)
{
- insn = emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
-4)));
/* Save SRP if not a leaf function. */
if (return_address_on_stack)
{
- insn = emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-4 - pretend)));
pretend = 0;
/* Set up the frame pointer, if needed. */
if (frame_pointer_needed)
{
- insn = emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-4 - pretend)));
pretend = 0;
else
{
insn
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-(n_saved * 4 + size)));
insn = emit_insn (insn);
size = 0;
}
- insn = emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
-4 - size)));
else
{
insn
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-(n_saved * 4 + size)));
insn = emit_insn (insn);
/* We have to put outgoing argument space after regs. */
if (cfoa_size)
{
- insn = emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
-cfoa_size)));
}
else if ((size + cfoa_size) > 0)
{
- insn = emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
-(cfoa_size + size))));
{
/* There is an area for outgoing parameters located before
the saved registers. We have to adjust for that. */
- emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
argspace_offset)));
/* Make sure we only do this once. */
if (argspace_offset)
{
- emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
argspace_offset)));
argspace_offset = 0;
yet. */
size += argspace_offset;
- emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, size)));
}
= alloc_EXPR_LIST (REG_INC, stack_pointer_rtx, REG_NOTES (insn));
}
- emit_insn (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
pretend)));
}
if (GET_CODE (XEXP (src, 0)) == POST_INC)
{
RTVEC_ELT (vec, nprefix + 1)
- = gen_rtx_SET (VOIDmode, srcreg,
- plus_constant (Pmode, srcreg, nregs * 4));
+ = gen_rtx_SET (srcreg, plus_constant (Pmode, srcreg, nregs * 4));
eltno++;
}
src = replace_equiv_address (src, srcreg);
RTVEC_ELT (vec, nprefix)
- = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno), src);
+ = gen_rtx_SET (gen_rtx_REG (SImode, regno), src);
regno += regno_inc;
for (i = 1; i < nregs; i++, eltno++)
{
RTVEC_ELT (vec, nprefix + eltno)
- = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno),
+ = gen_rtx_SET (gen_rtx_REG (SImode, regno),
adjust_address_nv (src, SImode, i * 4));
regno += regno_inc;
}
registers so there's a three cycles penalty for use. */
if (nregs == 1)
{
- rtx mov = gen_rtx_SET (VOIDmode, dest, gen_rtx_REG (SImode, 0));
+ rtx mov = gen_rtx_SET (dest, gen_rtx_REG (SImode, 0));
if (increment == 0)
{
vec = rtvec_alloc (2);
RTVEC_ELT (vec, 0) = mov;
- RTVEC_ELT (vec, 1) = gen_rtx_SET (VOIDmode, destreg,
- plus_constant (Pmode, destreg,
- increment));
+ RTVEC_ELT (vec, 1) = gen_rtx_SET (destreg, plus_constant (Pmode, destreg,
+ increment));
if (frame_related)
{
RTX_FRAME_RELATED_P (mov) = 1;
{
vec = rtvec_alloc (nregs + (increment != 0 ? 1 : 0));
RTVEC_ELT (vec, 0)
- = gen_rtx_SET (VOIDmode,
- replace_equiv_address (dest,
+ = gen_rtx_SET (replace_equiv_address (dest,
plus_constant (Pmode, destreg,
increment)),
gen_rtx_REG (SImode, regno));
if (increment != 0)
{
RTVEC_ELT (vec, 1)
- = gen_rtx_SET (VOIDmode, destreg,
- plus_constant (Pmode, destreg,
- increment != 0
- ? increment : nregs * 4));
+ = gen_rtx_SET (destreg, plus_constant (Pmode, destreg,
+ increment != 0
+ ? increment : nregs * 4));
eltno++;
if (frame_related)
for (i = 1; i < nregs; i++, eltno++)
{
RTVEC_ELT (vec, eltno)
- = gen_rtx_SET (VOIDmode, adjust_address_nv (dest, SImode, i * 4),
+ = gen_rtx_SET (adjust_address_nv (dest, SImode, i * 4),
gen_rtx_REG (SImode, regno));
if (frame_related)
RTX_FRAME_RELATED_P (RTVEC_ELT (vec, eltno)) = 1;
reg1 = reg0;
}
- emit_insn (gen_rtx_SET (SImode, reg0,
- gen_rtx_AND (SImode, reg1, operands[2])));
+ emit_insn (gen_rtx_SET (reg0, gen_rtx_AND (SImode, reg1, operands[2])));
/* Make sure we get the right *final* destination. */
if (! REG_P (operands[0]))
reg1 = reg0;
}
- emit_insn (gen_rtx_SET (HImode, reg0,
- gen_rtx_AND (HImode, reg1, operands[2])));
+ emit_insn (gen_rtx_SET (reg0, gen_rtx_AND (HImode, reg1, operands[2])));
/* Make sure we get the right destination. */
if (! REG_P (operands[0]))
gcc_assert (reg);
- emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
+ emit_insn (gen_rtx_SET (hi_sum_reg,
gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
gen_rtx_HIGH (Pmode, offset))));
- emit_insn (gen_rtx_SET (Pmode, reg,
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_LO_SUM (Pmode, hi_sum_reg,
copy_rtx (offset))));
{
gcc_assert (reg);
- emit_insn (gen_rtx_SET (VOIDmode, reg,
- gen_rtx_HIGH (Pmode, offset)));
- emit_insn (gen_rtx_SET (VOIDmode, reg,
- gen_rtx_LO_SUM (Pmode, reg,
- copy_rtx (offset))));
+ emit_insn (gen_rtx_SET (reg, gen_rtx_HIGH (Pmode, offset)));
+ emit_insn (gen_rtx_SET (reg, gen_rtx_LO_SUM (Pmode, reg,
+ copy_rtx (offset))));
emit_use (pic_offset_table_rtx);
orig = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, reg);
&& reg
&& MACHO_DYNAMIC_NO_PIC_P)
{
- emit_insn (gen_rtx_SET (Pmode, reg, ptr_ref));
+ emit_insn (gen_rtx_SET (reg, ptr_ref));
ptr_ref = reg;
}
mem = gen_const_mem (GET_MODE (orig),
gen_rtx_LO_SUM (Pmode, temp_reg,
copy_rtx (asym)));
- emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ emit_insn (gen_rtx_SET (reg, mem));
#else
/* Some other CPU -- WriteMe! but right now there are no other
platforms that can use dynamic-no-pic */
if (! MACHO_DYNAMIC_NO_PIC_P)
sum = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, sum);
- emit_insn (gen_rtx_SET (Pmode, hi_sum_reg, sum));
+ emit_insn (gen_rtx_SET (hi_sum_reg, sum));
mem = gen_const_mem (GET_MODE (orig),
gen_rtx_LO_SUM (Pmode,
hi_sum_reg,
copy_rtx (offset)));
- insn = emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ insn = emit_insn (gen_rtx_SET (reg, mem));
set_unique_reg_note (insn, REG_EQUAL, pic_ref);
pic_ref = reg;
#else
emit_use (gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM));
- emit_insn (gen_rtx_SET (VOIDmode, reg,
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_HIGH (Pmode,
gen_rtx_CONST (Pmode,
offset))));
- emit_insn (gen_rtx_SET (VOIDmode, reg,
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_LO_SUM (Pmode, reg,
gen_rtx_CONST (Pmode,
copy_rtx (offset)))));
hi_sum_reg = reg;
- emit_insn (gen_rtx_SET (Pmode, hi_sum_reg,
+ emit_insn (gen_rtx_SET (hi_sum_reg,
(MACHO_DYNAMIC_NO_PIC_P)
? gen_rtx_HIGH (Pmode, offset)
: gen_rtx_PLUS (Pmode,
pic_offset_table_rtx,
gen_rtx_HIGH (Pmode,
offset))));
- emit_insn (gen_rtx_SET (VOIDmode, reg,
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_LO_SUM (Pmode,
hi_sum_reg,
copy_rtx (offset))));
pic_ref = reg;
#else
- emit_insn (gen_rtx_SET (VOIDmode, reg,
- gen_rtx_HIGH (Pmode, offset)));
- emit_insn (gen_rtx_SET (VOIDmode, reg,
+ emit_insn (gen_rtx_SET (reg, gen_rtx_HIGH (Pmode, offset)));
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_LO_SUM (Pmode, reg,
copy_rtx (offset))));
pic_ref = gen_rtx_PLUS (Pmode,
else
x = force_reg (in_mode, x);
- pat = gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y));
+ pat = gen_rtx_SET (cc_reg, gen_rtx_COMPARE (mode, x, y));
if (mode == CC_FP_EQmode || mode == CC_FP_GTEmode)
{
const char *name = mode == CC_FP_EQmode ? "__eqsf2" : "__gtesf2";
rtx src = simplify_gen_subreg (SImode, SET_SRC (set), DImode, offset);
rtx dst = simplify_gen_subreg (SImode, SET_DEST (set), DImode, offset);
- set = gen_rtx_SET (VOIDmode, dst ,src);
+ set = gen_rtx_SET (dst ,src);
RTX_FRAME_RELATED_P (set) = 1;
return set;
}
static rtx_insn *
frame_move_insn (rtx to, rtx from)
{
- return frame_insn (gen_rtx_SET (VOIDmode, to, from));
+ return frame_insn (gen_rtx_SET (to, from));
}
/* Generate a MEM referring to a varargs argument slot. */
/* Instruction scheduling can separate the instruction setting IP from
INSN so that dwarf2out_frame_debug_expr becomes confused what the
temporary register is. Example: _gcov.o */
- note = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ note = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx, off));
note = gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (2, gen_rtx_SET (VOIDmode, mem2, reg),
- note));
+ gen_rtvec (2, gen_rtx_SET (mem2, reg), note));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, note);
}
/* If there is only one or no register to save, yet we have a large frame,
{
if (operands[3] != const0_rtx)
operands[2] = gen_rtx_MINUS (SImode, operands[2], operands[3]);
- operands[2] = gen_rtx_SET (VOIDmode, operands[0], operands[2]);
+ operands[2] = gen_rtx_SET (operands[0], operands[2]);
operands[3] = operands[0];
}
operands[4] = gen_rtx_fmt_ee (cmp_code, SImode,
(gen_rtx_PARALLEL
(VOIDmode,
gen_rtvec (2, gen_rtx_SET
- (VOIDmode, operands[0],
+ (operands[0],
gen_rtx_CALL (VOIDmode, operands[1], operands[2])),
gen_rtx_CLOBBER (VOIDmode,
gen_rtx_REG (SImode, GPR_LR)))));
(gen_rtx_PARALLEL
(VOIDmode,
gen_rtvec (2, gen_rtx_SET
- (VOIDmode, operands[0],
+ (operands[0],
gen_rtx_CALL (VOIDmode, operands[1], operands[2])),
ret_rtx)));
emit_insn (target_uninterruptible ? gen_gie (): gen_gid ());
(VOIDmode,
gen_rtvec
(4,
- gen_rtx_SET (VOIDmode, operands[5],
+ gen_rtx_SET (operands[5],
gen_rtx_MULT (SImode, operands[6], operands[4])),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CC_FPmode, CCFP_REGNUM)),
operands[9], operands[10])));
(VOIDmode,
gen_rtvec
(4,
- gen_rtx_SET (VOIDmode, operands[7],
+ gen_rtx_SET (operands[7],
gen_rtx_MULT (SImode, operands[8], operands[4])),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CC_FPmode, CCFP_REGNUM)),
operands[9], operands[10])));
/* We normally copy the low-numbered register first. However, if
the first register of operand 0 is the same as the second register
of operand 1, we must copy in the opposite order. */
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, reverse, TRUE, mode),
operand_subword (src, reverse, TRUE, mode)));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, !reverse, TRUE, mode),
- operand_subword (src, !reverse, TRUE, mode)));
+ emit_insn
+ (gen_rtx_SET (operand_subword (dest, !reverse, TRUE, mode),
+ operand_subword (src, !reverse, TRUE, mode)));
}
else if (src_code == MEM)
{
gcc_assert (GET_CODE (addr) == REG);
/* Copy the address before clobbering it. See PR 34174. */
- emit_insn (gen_rtx_SET (SImode, dest1, addr));
- emit_insn (gen_rtx_SET (VOIDmode, dest0,
- adjust_address (src, SImode, 0)));
- emit_insn (gen_rtx_SET (SImode, dest1,
- plus_constant (SImode, dest1,
- UNITS_PER_WORD)));
+ emit_insn (gen_rtx_SET (dest1, addr));
+ emit_insn (gen_rtx_SET (dest0, adjust_address (src, SImode, 0)));
+ emit_insn (gen_rtx_SET (dest1, plus_constant (SImode, dest1,
+ UNITS_PER_WORD)));
new_mem = gen_rtx_MEM (SImode, dest1);
MEM_COPY_ATTRIBUTES (new_mem, src);
- emit_insn (gen_rtx_SET (VOIDmode, dest1, new_mem));
+ emit_insn (gen_rtx_SET (dest1, new_mem));
}
else if (src_code == CONST_INT || src_code == CONST_DOUBLE)
{
rtx words[2];
split_double (src, &words[0], &words[1]);
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, 0, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, 0, TRUE, mode),
words[0]));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, 1, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, 1, TRUE, mode),
words[1]));
}
}
if (REGNO (addr) == STACK_POINTER_REGNUM
|| REGNO (addr) == FRAME_POINTER_REGNUM)
- emit_insn (gen_rtx_SET (VOIDmode,
- adjust_address (dest, SImode, UNITS_PER_WORD),
+ emit_insn (gen_rtx_SET (adjust_address (dest, SImode, UNITS_PER_WORD),
src1));
else
{
static rtx
frv_dwarf_store (rtx reg, int offset)
{
- rtx set = gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (GET_MODE (reg),
+ rtx set = gen_rtx_SET (gen_rtx_MEM (GET_MODE (reg),
plus_constant (Pmode, stack_pointer_rtx,
offset)),
reg);
if (SPR_P (REGNO (reg)))
{
rtx temp = gen_rtx_REG (mode, TEMP_REGNO);
- emit_insn (gen_rtx_SET (VOIDmode, temp, mem));
- emit_insn (gen_rtx_SET (VOIDmode, reg, temp));
+ emit_insn (gen_rtx_SET (temp, mem));
+ emit_insn (gen_rtx_SET (reg, temp));
}
else
{
XEXP (XEXP (mem, 0), 1)));
mem = gen_rtx_MEM (DImode, temp);
}
- emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ emit_insn (gen_rtx_SET (reg, mem));
}
emit_use (reg);
}
if (SPR_P (REGNO (reg)))
{
rtx temp = gen_rtx_REG (mode, TEMP_REGNO);
- emit_insn (gen_rtx_SET (VOIDmode, temp, reg));
- frv_frame_insn (gen_rtx_SET (Pmode, mem, temp),
+ emit_insn (gen_rtx_SET (temp, reg));
+ frv_frame_insn (gen_rtx_SET (mem, temp),
frv_dwarf_store (reg, stack_offset));
}
else if (mode == DImode)
mem = gen_rtx_MEM (DImode, temp);
}
- frv_frame_insn (gen_rtx_SET (Pmode, mem, reg),
+ frv_frame_insn (gen_rtx_SET (mem, reg),
gen_rtx_PARALLEL (VOIDmode,
gen_rtvec (2, set1, set2)));
}
else
- frv_frame_insn (gen_rtx_SET (Pmode, mem, reg),
+ frv_frame_insn (gen_rtx_SET (mem, reg),
frv_dwarf_store (reg, stack_offset));
}
}
rtx dwarf_offset = GEN_INT (-info->total_size);
frv_frame_insn (gen_stack_adjust (sp, sp, asm_offset),
- gen_rtx_SET (Pmode,
- sp,
- gen_rtx_PLUS (Pmode, sp, dwarf_offset)));
+ gen_rtx_SET (sp, gen_rtx_PLUS (Pmode, sp, dwarf_offset)));
}
/* If the frame pointer is needed, store the old one at (sp + FP_OFFSET)
frv_frame_access (&accessor, fp, fp_offset);
/* Set up the new frame pointer. */
- frv_frame_insn (gen_rtx_SET (VOIDmode, fp, asm_src),
- gen_rtx_SET (VOIDmode, fp, dwarf_src));
+ frv_frame_insn (gen_rtx_SET (fp, asm_src),
+ gen_rtx_SET (fp, dwarf_src));
/* Access region C from the frame pointer. */
accessor.base = fp;
/* Load the old link register into a GPR. */
return_addr = gen_rtx_REG (Pmode, TEMP_REGNO);
- emit_insn (gen_rtx_SET (VOIDmode, return_addr, mem));
+ emit_insn (gen_rtx_SET (return_addr, mem));
}
else
return_addr = gen_rtx_REG (Pmode, LR_REGNO);
the load is preserved. */
if (frame_pointer_needed)
{
- emit_insn (gen_rtx_SET (VOIDmode, fp, gen_rtx_MEM (Pmode, fp)));
+ emit_insn (gen_rtx_SET (fp, gen_rtx_MEM (Pmode, fp)));
emit_use (fp);
}
tmp_reg = gen_reg_rtx (mode);
src_mem = change_address (orig_src, mode, src_addr);
dest_mem = change_address (orig_dest, mode, dest_addr);
- emit_insn (gen_rtx_SET (VOIDmode, tmp_reg, src_mem));
- stores[num_reg++] = gen_rtx_SET (VOIDmode, dest_mem, tmp_reg);
+ emit_insn (gen_rtx_SET (tmp_reg, src_mem));
+ stores[num_reg++] = gen_rtx_SET (dest_mem, tmp_reg);
if (num_reg >= MAX_MOVE_REG)
{
clear_bytes = GET_MODE_SIZE (mode);
dest_mem = change_address (orig_dest, mode, dest_addr);
- emit_insn (gen_rtx_SET (VOIDmode, dest_mem, const0_rtx));
+ emit_insn (gen_rtx_SET (dest_mem, const0_rtx));
}
return TRUE;
}
reg = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, reg,
- gen_rtx_PLUS (Pmode,
- retval, tp)));
+ emit_insn (gen_rtx_SET (reg, gen_rtx_PLUS (Pmode, retval, tp)));
dest = gen_tlsmoff (addr, reg);
gcc_unreachable ();
}
- emit_insn (gen_rtx_SET (VOIDmode, dest, src));
+ emit_insn (gen_rtx_SET (dest, src));
}
/* Emit code to handle a MOVSI, adding in the small data register or pic
FIRST_VIRTUAL_REGISTER,
LAST_VIRTUAL_POINTER_REGISTER))))
{
- emit_insn (gen_rtx_SET (VOIDmode, dest, copy_to_mode_reg (SImode, src)));
+ emit_insn (gen_rtx_SET (dest, copy_to_mode_reg (SImode, src)));
return TRUE;
}
: gen_rtx_REG (cc_mode,
(cc_mode == CC_FPmode) ? FCC_FIRST : ICC_FIRST));
- emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
- gen_rtx_COMPARE (cc_mode, op0, op1)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (cc_mode, op0, op1)));
return cc_reg;
}
label_ref = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
test_rtx = gen_rtx_fmt_ee (test, cc_mode, cc_reg, const0_rtx);
if_else = gen_rtx_IF_THEN_ELSE (cc_mode, test_rtx, label_ref, pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, if_else));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, if_else));
return TRUE;
}
(parallel [(set <target> (<test>, <cc_reg>, (const_int 0))
(clobber (<ccr_reg>))]) */
test_rtx = gen_rtx_fmt_ee (test, SImode, cc_reg, const0_rtx);
- set = gen_rtx_SET (VOIDmode, operands[0], test_rtx);
+ set = gen_rtx_SET (operands[0], test_rtx);
cr_reg = ((TARGET_ALLOC_CC)
? gen_reg_rtx (CC_CCRmode)
start_sequence ();
/* Set the appropriate CCR bit. */
- emit_insn (gen_rtx_SET (VOIDmode,
- cr_reg,
+ emit_insn (gen_rtx_SET (cr_reg,
gen_rtx_fmt_ee (GET_CODE (test),
GET_MODE (cr_reg),
cc_reg,
gen_rtx_EQ (GET_MODE (cr_reg),
cr_reg,
const0_rtx),
- gen_rtx_SET (VOIDmode, dest, const0_rtx)));
+ gen_rtx_SET (dest, const0_rtx)));
/* Finish up, return sequence. */
ret = get_insns ();
test2 = gen_rtx_fmt_ee (test, cc_mode, cc_reg, const0_rtx);
if_rtx = gen_rtx_IF_THEN_ELSE (GET_MODE (dest), test2, src1, src2);
- set = gen_rtx_SET (VOIDmode, dest, if_rtx);
+ set = gen_rtx_SET (dest, if_rtx);
cr_reg = ((TARGET_ALLOC_CC)
? gen_reg_rtx (CC_CCRmode)
start_sequence ();
/* Set the appropriate CCR bit. */
- emit_insn (gen_rtx_SET (VOIDmode,
- cr_reg,
+ emit_insn (gen_rtx_SET (cr_reg,
gen_rtx_fmt_ee (GET_CODE (test),
GET_MODE (cr_reg),
cc_reg,
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (cr_mode, cr_reg,
const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src1)));
+ gen_rtx_SET (dest, src1)));
}
else if (value2 == 0)
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_EQ (cr_mode, cr_reg,
const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src2)));
+ gen_rtx_SET (dest, src2)));
}
/* If the first value is within an addi range and also the difference
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (cr_mode, cr_reg,
const0_rtx),
- gen_rtx_SET (VOIDmode, dest_si,
- const0_rtx)));
+ gen_rtx_SET (dest_si, const0_rtx)));
emit_insn (gen_addsi3 (dest_si, dest_si, src1));
}
if (! rtx_equal_p (dest, src1))
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (cr_mode, cr_reg, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src1)));
+ gen_rtx_SET (dest, src1)));
/* Emit the conditional move for the test being false if needed. */
if (! rtx_equal_p (dest, src2))
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_EQ (cr_mode, cr_reg, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src2)));
+ gen_rtx_SET (dest, src2)));
}
/* Finish up, return sequence. */
}
/* Issue the compare instruction. */
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
- gen_rtx_COMPARE (GET_MODE (cc_reg),
- src1, src2)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (GET_MODE (cc_reg),
+ src1, src2)));
/* Set the appropriate CCR bit. */
- emit_insn (gen_rtx_SET (VOIDmode,
- cr_reg,
- gen_rtx_fmt_ee (test_code,
- GET_MODE (cr_reg),
- cc_reg,
- const0_rtx)));
+ emit_insn (gen_rtx_SET (cr_reg, gen_rtx_fmt_ee (test_code,
+ GET_MODE (cr_reg),
+ cc_reg,
+ const0_rtx)));
/* If are taking the min/max of a nonzero constant, load that first, and
then do a conditional move of the other value. */
emit_move_insn (dest, src2);
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (cr_mode, cr_reg, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src1)));
+ gen_rtx_SET (dest, src1)));
}
/* Otherwise, do each half of the move. */
if (! rtx_equal_p (dest, src1))
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (cr_mode, cr_reg, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src1)));
+ gen_rtx_SET (dest, src1)));
/* Emit the conditional move for the test being false if needed. */
if (! rtx_equal_p (dest, src2))
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_EQ (cr_mode, cr_reg, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src2)));
+ gen_rtx_SET (dest, src2)));
}
/* Finish up, return sequence. */
start_sequence ();
/* Issue the compare < 0 instruction. */
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
- gen_rtx_COMPARE (CCmode, src, const0_rtx)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (CCmode, src, const0_rtx)));
/* Set the appropriate CCR bit. */
- emit_insn (gen_rtx_SET (VOIDmode,
- cr_reg,
- gen_rtx_fmt_ee (LT, CC_CCRmode, cc_reg, const0_rtx)));
+ emit_insn (gen_rtx_SET (cr_reg, gen_rtx_fmt_ee (LT, CC_CCRmode,
+ cc_reg, const0_rtx)));
/* Emit the conditional negate if the value is negative. */
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
if (! rtx_equal_p (dest, src))
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_EQ (CC_CCRmode, cr_reg, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, src)));
+ gen_rtx_SET (dest, src)));
/* Finish up, return sequence. */
ret = get_insns ();
code_false = EQ;
}
- check_insn = gen_rtx_SET (VOIDmode, cr,
- gen_rtx_fmt_ee (code, CC_CCRmode, cc, const0_rtx));
+ check_insn = gen_rtx_SET (cr, gen_rtx_fmt_ee (code, CC_CCRmode,
+ cc, const0_rtx));
/* Record the check insn to be inserted later. */
frv_ifcvt_add_insn (check_insn, BB_END (test_bb), TRUE);
compare = gen_rtx_fmt_ee (GET_CODE (test_expr), CC_CCRmode, cc, const0_rtx);
if_else = gen_rtx_IF_THEN_ELSE (CC_CCRmode, old_test, compare, const0_rtx);
- check_insn = gen_rtx_SET (VOIDmode, new_cr, if_else);
+ check_insn = gen_rtx_SET (new_cr, if_else);
/* Add the new check insn to the list of check insns that need to be
inserted. */
}
frv_ifcvt.cur_scratch_regs++;
- frv_ifcvt.scratch_regs[num_alloc] = gen_rtx_SET (VOIDmode, reg, value);
+ frv_ifcvt.scratch_regs[num_alloc] = gen_rtx_SET (reg, value);
if (dump_file)
{
op1 = frv_ifcvt_load_value (op1, insn);
if (op1)
COND_EXEC_CODE (pattern)
- = gen_rtx_SET (VOIDmode, dest, gen_rtx_fmt_ee (GET_CODE (src),
- GET_MODE (src),
- op0, op1));
+ = gen_rtx_SET (dest, gen_rtx_fmt_ee (GET_CODE (src),
+ GET_MODE (src),
+ op0, op1));
else
goto fail;
}
{
op1 = gen_rtx_SIGN_EXTEND (DImode, op1);
COND_EXEC_CODE (pattern)
- = gen_rtx_SET (VOIDmode, dest,
- gen_rtx_MULT (DImode, op0, op1));
+ = gen_rtx_SET (dest, gen_rtx_MULT (DImode, op0, op1));
}
else
goto fail;
/* If either src or destination changed, redo SET. */
if (changed_p)
- COND_EXEC_CODE (pattern) = gen_rtx_SET (VOIDmode, dest, src);
+ COND_EXEC_CODE (pattern) = gen_rtx_SET (dest, src);
}
/* Rewrite a nested set cccr in terms of IF_THEN_ELSE. Also deal with
}
if_else = gen_rtx_IF_THEN_ELSE (CC_CCRmode, test, src, const0_rtx);
- pattern = gen_rtx_SET (VOIDmode, dest, if_else);
+ pattern = gen_rtx_SET (dest, if_else);
}
/* Remap a nested compare instruction to use the paired CC/CR reg. */
{
PUT_MODE (frv_ifcvt.nested_cc_reg, GET_MODE (dest));
COND_EXEC_CODE (pattern)
- = gen_rtx_SET (VOIDmode, frv_ifcvt.nested_cc_reg, copy_rtx (src));
+ = gen_rtx_SET (frv_ifcvt.nested_cc_reg, copy_rtx (src));
}
}
if (! offsettable_address_p (0, mode0, op0))
{
reg = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, reg, op0));
+ emit_insn (gen_rtx_SET (reg, op0));
}
op0 = gen_rtx_MEM (SImode, reg);
start_sequence ();
- emit_insn (gen_rtx_SET (VOIDmode, icr,
- gen_rtx_LT (CC_CCRmode, icc, const0_rtx)));
+ emit_insn (gen_rtx_SET (icr, gen_rtx_LT (CC_CCRmode, icc, const0_rtx)));
emit_insn (gen_movsi (dest, const1_rtx));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (CC_CCRmode, icr, const0_rtx),
- gen_rtx_SET (VOIDmode, dest,
+ gen_rtx_SET (dest,
gen_rtx_NEG (SImode, dest))));
- emit_insn (gen_rtx_SET (VOIDmode, icr,
- gen_rtx_EQ (CC_CCRmode, icc, const0_rtx)));
+ emit_insn (gen_rtx_SET (icr, gen_rtx_EQ (CC_CCRmode, icc, const0_rtx)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (CC_CCRmode, icr, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, const0_rtx)));
+ gen_rtx_SET (dest, const0_rtx)));
operands[3] = get_insns ();
end_sequence ();
start_sequence ();
- emit_insn (gen_rtx_SET (VOIDmode, icr,
- gen_rtx_GTU (CC_CCRmode, icc, const0_rtx)));
+ emit_insn (gen_rtx_SET (icr, gen_rtx_GTU (CC_CCRmode, icc, const0_rtx)));
emit_insn (gen_movsi (dest, const1_rtx));
gen_rtx_NE (CC_CCRmode, icr, const0_rtx),
gen_addsi3 (dest, dest, dest)));
- emit_insn (gen_rtx_SET (VOIDmode, icr,
- gen_rtx_LTU (CC_CCRmode, icc, const0_rtx)));
+ emit_insn (gen_rtx_SET (icr, gen_rtx_LTU (CC_CCRmode, icc, const0_rtx)));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_NE (CC_CCRmode, icr, const0_rtx),
- gen_rtx_SET (VOIDmode, dest, const0_rtx)));
+ gen_rtx_SET (dest, const0_rtx)));
operands[3] = get_insns ();
end_sequence ();
gen_rtx_EQ (CC_CCRmode,
operands[1],
const0_rtx),
- gen_rtx_SET (VOIDmode, int_op0,
- const0_rtx)));
+ gen_rtx_SET (int_op0, const0_rtx)));
operands[2] = get_insns ();
end_sequence ();
lhs = gen_rtx_MEM (SImode, plus_constant (Pmode, sp, (j + 1) * -4));
rhs = gen_rtx_REG (SImode, regno + j);
}
- RTVEC_ELT (vec, i + j) = gen_rtx_SET (VOIDmode, lhs, rhs);
+ RTVEC_ELT (vec, i + j) = gen_rtx_SET (lhs, rhs);
}
/* Add the stack adjustment. */
offset = GEN_INT ((pop_p ? nregs : -nregs) * 4);
- RTVEC_ELT (vec, i + j) = gen_rtx_SET (VOIDmode, sp,
- gen_rtx_PLUS (Pmode, sp, offset));
+ RTVEC_ELT (vec, i + j) = gen_rtx_SET (sp, gen_rtx_PLUS (Pmode, sp, offset));
x = gen_rtx_PARALLEL (VOIDmode, vec);
if (!pop_p)
2 * UNITS_PER_WORD));
else
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, 4)));
emit_move_insn (hard_frame_pointer_rtx, addr);
2 * UNITS_PER_WORD));
else
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, -4)));
}
\f
rtx tmp;
tmp = gen_rtx_COMPARE (VOIDmode, op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx, tmp));
+ emit_insn (gen_rtx_SET (cc0_rtx, tmp));
tmp = gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, label),
pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
}
rtx tmp;
tmp = gen_rtx_COMPARE (VOIDmode, op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx, tmp));
+ emit_insn (gen_rtx_SET (cc0_rtx, tmp));
tmp = gen_rtx_fmt_ee (code, GET_MODE (dest), cc0_rtx, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
+ emit_insn (gen_rtx_SET (dest, tmp));
}
\f
/* Shifts.
emit_insn (gen_rtx_PARALLEL
(VOIDmode,
gen_rtvec (2,
- gen_rtx_SET (VOIDmode, copy_rtx (operands[0]),
+ gen_rtx_SET (copy_rtx (operands[0]),
gen_rtx_fmt_ee (code, mode,
copy_rtx (operands[0]), operands[2])),
gen_rtx_CLOBBER (VOIDmode,
if (REG_P (arg) && GET_MODE (arg) != word_mode)
arg = gen_rtx_REG (word_mode, REGNO (arg));
- return gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (word_mode,
+ return gen_rtx_SET (gen_rtx_MEM (word_mode,
gen_rtx_PRE_DEC (Pmode,
stack_pointer_rtx)),
arg);
if (REG_P (arg) && GET_MODE (arg) != word_mode)
arg = gen_rtx_REG (word_mode, REGNO (arg));
- return gen_rtx_SET (VOIDmode,
- arg,
+ return gen_rtx_SET (arg,
gen_rtx_MEM (word_mode,
gen_rtx_POST_INC (Pmode,
stack_pointer_rtx)));
addr = plus_constant (Pmode, hard_frame_pointer_rtx,
cfun->machine->fs.fp_offset - cfa_offset);
mem = gen_rtx_MEM (mode, addr);
- add_reg_note (insn, REG_CFA_EXPRESSION,
- gen_rtx_SET (VOIDmode, mem, reg));
+ add_reg_note (insn, REG_CFA_EXPRESSION, gen_rtx_SET (mem, reg));
}
}
addr = plus_constant (Pmode, m->fs.cfa_reg,
m->fs.cfa_offset - cfa_offset);
mem = gen_rtx_MEM (mode, addr);
- add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (VOIDmode, mem, reg));
+ add_reg_note (insn, REG_CFA_OFFSET, gen_rtx_SET (mem, reg));
}
}
&& dest != hard_frame_pointer_rtx);
tmp = hard_frame_pointer_rtx;
}
- insn = emit_insn (gen_rtx_SET (DImode, tmp, offset));
+ insn = emit_insn (gen_rtx_SET (tmp, offset));
if (style < 0)
add_frame_related_expr = true;
m->fs.cfa_reg = dest;
r = gen_rtx_PLUS (Pmode, src, offset);
- r = gen_rtx_SET (VOIDmode, dest, r);
+ r = gen_rtx_SET (dest, r);
add_reg_note (insn, REG_CFA_ADJUST_CFA, r);
RTX_FRAME_RELATED_P (insn) = 1;
}
if (add_frame_related_expr)
{
rtx r = gen_rtx_PLUS (Pmode, src, offset);
- r = gen_rtx_SET (VOIDmode, dest, r);
+ r = gen_rtx_SET (dest, r);
add_reg_note (insn, REG_FRAME_RELATED_EXPR, r);
}
}
/* The RTX_FRAME_RELATED_P mechanism doesn't know about pop. */
RTX_FRAME_RELATED_P (insn) = 1;
x = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (UNITS_PER_WORD));
- x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
+ x = gen_rtx_SET (stack_pointer_rtx, x);
add_reg_note (insn, REG_FRAME_RELATED_EXPR, x);
m->fs.sp_offset -= UNITS_PER_WORD;
}
else
adjust = PROBE_INTERVAL;
- emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-adjust)));
emit_stack_probe (stack_pointer_rtx);
else
adjust = size + PROBE_INTERVAL - i;
- emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-adjust)));
emit_stack_probe (stack_pointer_rtx);
/* Adjust back to account for the additional first interval. */
- last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ last = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
PROBE_INTERVAL + dope)));
}
/* Step 2: compute initial and final value of the loop counter. */
/* SP = SP_0 + PROBE_INTERVAL. */
- emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
- (PROBE_INTERVAL + dope))));
/* LAST_ADDR = SP_0 + PROBE_INTERVAL + ROUNDED_SIZE. */
emit_move_insn (sr.reg, GEN_INT (-rounded_size));
- emit_insn (gen_rtx_SET (VOIDmode, sr.reg,
+ emit_insn (gen_rtx_SET (sr.reg,
gen_rtx_PLUS (Pmode, sr.reg,
stack_pointer_rtx)));
if (size != rounded_size)
{
- emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
rounded_size - size)));
emit_stack_probe (stack_pointer_rtx);
}
/* Adjust back to account for the additional first interval. */
- last = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ last = emit_insn (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
PROBE_INTERVAL + dope)));
{
rtx expr = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
XVECEXP (expr, 0, 0)
- = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, -size));
XVECEXP (expr, 0, 1)
- = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
PROBE_INTERVAL + dope + size));
add_reg_note (last, REG_FRAME_RELATED_EXPR, expr);
insn = emit_insn (gen_blockage ());
push = gen_push (hard_frame_pointer_rtx);
- mov = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
+ mov = gen_rtx_SET (hard_frame_pointer_rtx,
stack_pointer_rtx);
RTX_FRAME_RELATED_P (push) = 1;
RTX_FRAME_RELATED_P (mov) = 1;
only as a stack adjustment. The real copy of the register as
a save will be done later, if needed. */
t = plus_constant (Pmode, stack_pointer_rtx, -UNITS_PER_WORD);
- t = gen_rtx_SET (VOIDmode, stack_pointer_rtx, t);
+ t = gen_rtx_SET (stack_pointer_rtx, t);
add_reg_note (insn, REG_CFA_ADJUST_CFA, t);
RTX_FRAME_RELATED_P (insn) = 1;
}
/* Grab the argument pointer. */
t = plus_constant (Pmode, stack_pointer_rtx, m->fs.sp_offset);
- insn = emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
+ insn = emit_insn (gen_rtx_SET (crtl->drap_reg, t));
RTX_FRAME_RELATED_P (insn) = 1;
m->fs.cfa_reg = crtl->drap_reg;
m->fs.cfa_offset = 0;
m->fs.cfa_offset += UNITS_PER_WORD;
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-UNITS_PER_WORD)));
}
m->fs.cfa_offset += UNITS_PER_WORD;
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-UNITS_PER_WORD)));
}
m->fs.cfa_offset += allocate;
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-allocate)));
}
isn't necessary, here we will emit prologue to setup DRAP
without stack realign adjustment */
t = choose_baseaddr (0);
- emit_insn (gen_rtx_SET (VOIDmode, crtl->drap_reg, t));
+ emit_insn (gen_rtx_SET (crtl->drap_reg, t));
}
/* Prevent instructions from being scheduled into register save push
if (m->fs.cfa_reg == stack_pointer_rtx)
{
rtx x = plus_constant (Pmode, stack_pointer_rtx, UNITS_PER_WORD);
- x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
+ x = gen_rtx_SET (stack_pointer_rtx, x);
add_reg_note (insn, REG_CFA_ADJUST_CFA, x);
RTX_FRAME_RELATED_P (insn) = 1;
{
t = gen_rtx_PLUS (Pmode, hard_frame_pointer_rtx, sa);
t = plus_constant (Pmode, t, m->fs.fp_offset - UNITS_PER_WORD);
- emit_insn (gen_rtx_SET (VOIDmode, sa, t));
+ emit_insn (gen_rtx_SET (sa, t));
t = gen_frame_mem (Pmode, hard_frame_pointer_rtx);
insn = emit_move_insn (hard_frame_pointer_rtx, t);
{
t = gen_rtx_PLUS (Pmode, stack_pointer_rtx, sa);
t = plus_constant (Pmode, t, m->fs.sp_offset - UNITS_PER_WORD);
- insn = emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx, t));
+ insn = emit_insn (gen_rtx_SET (stack_pointer_rtx, t));
ix86_add_queued_cfa_restore_notes (insn);
gcc_assert (m->fs.cfa_reg == stack_pointer_rtx);
param_ptr_offset += UNITS_PER_WORD;
insn = emit_insn (gen_rtx_SET
- (VOIDmode, stack_pointer_rtx,
+ (stack_pointer_rtx,
gen_rtx_PLUS (Pmode,
crtl->drap_reg,
GEN_INT (-param_ptr_offset))));
m->fs.sp_offset -= UNITS_PER_WORD;
rtx x = plus_constant (Pmode, stack_pointer_rtx, UNITS_PER_WORD);
- x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
+ x = gen_rtx_SET (stack_pointer_rtx, x);
add_reg_note (insn, REG_CFA_ADJUST_CFA, x);
- add_reg_note (insn, REG_CFA_REGISTER,
- gen_rtx_SET (VOIDmode, ecx, pc_rtx));
+ add_reg_note (insn, REG_CFA_REGISTER, gen_rtx_SET (ecx, pc_rtx));
RTX_FRAME_RELATED_P (insn) = 1;
pro_epilogue_adjust_stack (stack_pointer_rtx, stack_pointer_rtx,
/* We don't use ix86_gen_add3 in this case because it will
want to split to lea, but when not optimizing the insn
will not be split after this point. */
- emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
+ emit_insn (gen_rtx_SET (scratch_reg,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
offset)));
}
So we add five words to get to the stack arguments.
*/
words = TARGET_64BIT ? 3 : 5;
- emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
+ emit_insn (gen_rtx_SET (scratch_reg,
gen_rtx_PLUS (Pmode, frame_reg,
GEN_INT (words * UNITS_PER_WORD))));
case we need to set it based on the stack pointer. */
if (cfun->machine->split_stack_varargs_pointer != NULL_RTX)
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch_reg,
+ emit_insn (gen_rtx_SET (scratch_reg,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
GEN_INT (UNITS_PER_WORD))));
/* Avoid HImode and its attendant prefix byte. */
if (GET_MODE_SIZE (GET_MODE (dest)) < 4)
dest = gen_rtx_REG (SImode, REGNO (dest));
- tmp = gen_rtx_SET (VOIDmode, dest, const0_rtx);
+ tmp = gen_rtx_SET (dest, const0_rtx);
if (!TARGET_USE_MOV0 || optimize_insn_for_size_p ())
{
}
if (op0 != op1 && GET_CODE (op0) != MEM)
{
- rtx insn = gen_rtx_SET (VOIDmode, op0, op1);
+ rtx insn = gen_rtx_SET (op0, op1);
emit_insn (insn);
return;
}
if (!register_operand (op0, mode))
{
rtx temp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp, op1));
+ emit_insn (gen_rtx_SET (temp, op1));
emit_move_insn (op0, temp);
return;
}
}
}
- emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (op0, op1));
}
void
return;
}
- emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (op0, op1));
}
/* Split 32-byte AVX unaligned load and store if needed. */
is true, and without the UNSPEC it can be combined
with arithmetic instructions. */
else if (misaligned_operand (op1, GET_MODE (op1)))
- emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (op0, op1));
else
emit_insn (load_unaligned (op0, op1));
}
&& (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
|| GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
&& misaligned_operand (op1, GET_MODE (op1)))
- emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (op0, op1));
/* ??? If we have typed data, then it would appear that using
movdqu is the only way to get unaligned data loaded with
integer type. */
/* Emit the instruction. */
- op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, src1, src2));
+ op = gen_rtx_SET (dst, gen_rtx_fmt_ee (code, mode, src1, src2));
if (reload_completed
&& code == PLUS
op1 = SUBREG_REG (op1);
if (!nonimmediate_operand (op1, GET_MODE (dst)))
op1 = force_reg (GET_MODE (dst), op1);
- emit_insn (gen_rtx_SET (VOIDmode, dst,
+ emit_insn (gen_rtx_SET (dst,
gen_rtx_fmt_ee (code, GET_MODE (dst),
op1, op2)));
emit_move_insn (operands[0], gen_lowpart (mode, dst));
if (!nonimmediate_operand (operands[2], mode))
operands[2] = force_reg (mode, operands[2]);
ix86_fixup_binary_operands_no_copy (code, mode, operands);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_fmt_ee (code, mode, operands[1],
operands[2])));
}
/* Emit the instruction. */
- op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_e (code, mode, src));
+ op = gen_rtx_SET (dst, gen_rtx_fmt_e (code, mode, src));
if (code == NOT)
emit_insn (op);
tmp0 = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp0,
gen_rtx_LABEL_REF (VOIDmode, qimode_label),
pc_rtx);
- insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp0));
+ insn = emit_jump_insn (gen_rtx_SET (pc_rtx, tmp0));
predict_jump (REG_BR_PROB_BASE * 50 / 100);
JUMP_LABEL (insn) = qimode_label;
{
rtx op, clob;
- op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, mode, dst, src));
+ op = gen_rtx_SET (dst, gen_rtx_fmt_ee (code, mode, dst, src));
clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, FLAGS_REG));
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
{
/* r1 = r2 + r3 * C case. Need to move r3 into r1. */
if (regno0 != regno2)
- emit_insn (gen_rtx_SET (VOIDmode, target, parts.index));
+ emit_insn (gen_rtx_SET (target, parts.index));
/* Use shift for scaling. */
ix86_emit_binop (ASHIFT, mode, target,
else if (!parts.base && !parts.index)
{
gcc_assert(parts.disp);
- emit_insn (gen_rtx_SET (VOIDmode, target, parts.disp));
+ emit_insn (gen_rtx_SET (target, parts.disp));
}
else
{
if (!parts.base)
{
if (regno0 != regno2)
- emit_insn (gen_rtx_SET (VOIDmode, target, parts.index));
+ emit_insn (gen_rtx_SET (target, parts.index));
}
else if (!parts.index)
{
if (regno0 != regno1)
- emit_insn (gen_rtx_SET (VOIDmode, target, parts.base));
+ emit_insn (gen_rtx_SET (target, parts.base));
}
else
{
else
tmp = parts.base, tmp1 = parts.index;
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
if (parts.disp && parts.disp != const0_rtx)
ix86_emit_binop (PLUS, mode, target, parts.disp);
emit_move_insn (zero_or_two31, MEM_P (two31) ? large : two31);
x = gen_rtx_fmt_ee (LE, vecmode, large, value);
- emit_insn (gen_rtx_SET (VOIDmode, large, x));
+ emit_insn (gen_rtx_SET (large, x));
x = gen_rtx_AND (vecmode, zero_or_two31, large);
- emit_insn (gen_rtx_SET (VOIDmode, zero_or_two31, x));
+ emit_insn (gen_rtx_SET (zero_or_two31, x));
x = gen_rtx_MINUS (vecmode, value, zero_or_two31);
- emit_insn (gen_rtx_SET (VOIDmode, value, x));
+ emit_insn (gen_rtx_SET (value, x));
large = gen_rtx_REG (V4SImode, REGNO (large));
emit_insn (gen_ashlv4si3 (large, large, GEN_INT (31)));
src = operands[1];
set = gen_rtx_fmt_e (code, mode, src);
- set = gen_rtx_SET (VOIDmode, dst, set);
+ set = gen_rtx_SET (dst, set);
if (mask)
{
dest = simplify_gen_subreg (vmode, dest, mode, 0);
x = gen_rtx_AND (vmode, dest, mask);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
if (op0 != CONST0_RTX (vmode))
{
x = gen_rtx_IOR (vmode, dest, op0);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
}
gcc_assert (REGNO (op1) == REGNO (scratch));
x = gen_rtx_AND (vmode, scratch, mask);
- emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
+ emit_insn (gen_rtx_SET (scratch, x));
dest = mask;
op0 = simplify_gen_subreg (vmode, op0, mode, 0);
x = gen_rtx_NOT (vmode, dest);
x = gen_rtx_AND (vmode, x, op0);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
else
{
op1 = simplify_gen_subreg (vmode, op1, mode, 0);
x = gen_rtx_AND (vmode, scratch, op1);
}
- emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
+ emit_insn (gen_rtx_SET (scratch, x));
if (REGNO (op0) == REGNO (dest)) /* alternative 1,2 */
{
op0 = simplify_gen_subreg (vmode, op0, mode, 0);
x = gen_rtx_AND (vmode, dest, op0);
}
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
x = gen_rtx_IOR (vmode, dest, scratch);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
/* Return TRUE or FALSE depending on whether the first SET in INSN
/* This is very simple, but making the interface the same as in the
FP case makes the rest of the code easier. */
tmp = gen_rtx_COMPARE (cmpmode, op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, flags, tmp));
+ emit_insn (gen_rtx_SET (flags, tmp));
/* Return the test that should be put into the flags user, i.e.
the bcc, scc, or cmov instruction. */
case IX86_FPCMP_COMI:
intcmp_mode = fpcmp_mode;
tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
- tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
- tmp);
+ tmp = gen_rtx_SET (gen_rtx_REG (fpcmp_mode, FLAGS_REG), tmp);
emit_insn (tmp);
break;
case IX86_FPCMP_SAHF:
intcmp_mode = fpcmp_mode;
tmp = gen_rtx_COMPARE (fpcmp_mode, op0, op1);
- tmp = gen_rtx_SET (VOIDmode, gen_rtx_REG (fpcmp_mode, FLAGS_REG),
- tmp);
+ tmp = gen_rtx_SET (gen_rtx_REG (fpcmp_mode, FLAGS_REG), tmp);
if (!scratch)
scratch = gen_reg_rtx (HImode);
tmp2 = gen_rtx_UNSPEC (HImode, gen_rtvec (1, tmp), UNSPEC_FNSTSW);
if (!scratch)
scratch = gen_reg_rtx (HImode);
- emit_insn (gen_rtx_SET (VOIDmode, scratch, tmp2));
+ emit_insn (gen_rtx_SET (scratch, tmp2));
/* In the unordered case, we have to check C2 for NaN's, which
doesn't happen to work out to anything nice combination-wise.
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, label),
pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
return;
case DImode:
tmp);
i = emit_jump_insn (gen_rtx_SET
- (VOIDmode, pc_rtx,
+ (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
condition, target1, target2)));
if (split_branch_probability >= 0)
ret = ix86_expand_compare (code, op0, op1);
PUT_MODE (ret, QImode);
- emit_insn (gen_rtx_SET (VOIDmode, dest, ret));
+ emit_insn (gen_rtx_SET (dest, ret));
}
/* Expand comparison setting or clearing carry flag. Return true when
if (nops == 1)
out = force_operand (tmp, copy_rtx (out));
else
- emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (out), copy_rtx (tmp)));
+ emit_insn (gen_rtx_SET (copy_rtx (out), copy_rtx (tmp)));
}
if (!rtx_equal_p (out, operands[0]))
emit_move_insn (operands[0], copy_rtx (out));
operands[3] = force_reg (mode, operands[3]);
emit_insn (compare_seq);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_IF_THEN_ELSE (mode,
compare_op, operands[2],
operands[3])));
tmp = gen_rtx_fmt_ee (code, mode, if_true, if_false);
}
- emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
+ emit_insn (gen_rtx_SET (dest, tmp));
return true;
}
convert_move (dest, x, false);
}
else
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
return dest;
}
&& rtx_equal_p (op_false, CONST0_RTX (mode))
&& !maskcmp)
{
- emit_insn (gen_rtx_SET (VOIDmode, dest, cmp));
+ emit_insn (gen_rtx_SET (dest, cmp));
}
else if (op_false == CONST0_RTX (mode)
&& !maskcmp)
{
op_true = force_reg (mode, op_true);
x = gen_rtx_AND (mode, cmp, op_true);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
else if (op_true == CONST0_RTX (mode)
&& !maskcmp)
op_false = force_reg (mode, op_false);
x = gen_rtx_NOT (mode, cmp);
x = gen_rtx_AND (mode, x, op_false);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
else if (INTEGRAL_MODE_P (mode) && op_true == CONSTM1_RTX (mode)
&& !maskcmp)
{
op_false = force_reg (mode, op_false);
x = gen_rtx_IOR (mode, cmp, op_false);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
else if (TARGET_XOP
&& !maskcmp)
if (!nonimmediate_operand (op_false, mode))
op_false = force_reg (mode, op_false);
- emit_insn (gen_rtx_SET (mode, dest,
- gen_rtx_IF_THEN_ELSE (mode, cmp,
- op_true,
- op_false)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_IF_THEN_ELSE (mode, cmp,
+ op_true,
+ op_false)));
}
else
{
t3 = dest;
x = gen_rtx_AND (mode, op_true, cmp);
- emit_insn (gen_rtx_SET (VOIDmode, t2, x));
+ emit_insn (gen_rtx_SET (t2, x));
x = gen_rtx_NOT (mode, cmp);
x = gen_rtx_AND (mode, x, op_false);
- emit_insn (gen_rtx_SET (VOIDmode, t3, x));
+ emit_insn (gen_rtx_SET (t3, x));
x = gen_rtx_IOR (mode, t3, t2);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
}
}
compare_op = ix86_expand_compare (NE, tmp, const0_rtx);
}
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_IF_THEN_ELSE (mode, compare_op,
operands[2], operands[3])));
case V8HImode:
/* Perform a parallel unsigned saturating subtraction. */
x = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, x,
- gen_rtx_US_MINUS (mode, cop0, cop1)));
+ emit_insn (gen_rtx_SET (x, gen_rtx_US_MINUS (mode, cop0, cop1)));
cop0 = x;
cop1 = CONST0_RTX (mode);
if (GET_MODE (base) != Pmode)
base = gen_rtx_REG (Pmode, REGNO (base));
- emit_insn (gen_rtx_SET (VOIDmode, base, XEXP (part[1][0], 0)));
+ emit_insn (gen_rtx_SET (base, XEXP (part[1][0], 0)));
part[1][0] = replace_equiv_address (part[1][0], base);
for (i = 1; i < nparts; i++)
{
d = gen_lowpart (QImode, low[0]);
d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
s = gen_rtx_EQ (QImode, flags, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, d, s));
+ emit_insn (gen_rtx_SET (d, s));
d = gen_lowpart (QImode, high[0]);
d = gen_rtx_STRICT_LOW_PART (VOIDmode, d);
s = gen_rtx_NE (QImode, flags, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, d, s));
+ emit_insn (gen_rtx_SET (d, s));
}
/* Otherwise, we can get the same results by manually performing
x = gen_rtx_ZERO_EXTEND (half_mode, operands[2]);
else
x = gen_lowpart (half_mode, operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, high[0], x));
+ emit_insn (gen_rtx_SET (high[0], x));
emit_insn (gen_lshr3 (high[0], high[0], GEN_INT (bits)));
emit_insn (gen_and3 (high[0], high[0], const1_rtx));
emit_insn (gen_testsi_ccno_1 (tmpreg, GEN_INT (0x8080)));
tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, tmpreg,
+ emit_insn (gen_rtx_SET (tmpreg,
gen_rtx_IF_THEN_ELSE (SImode, tmp,
reg,
tmpreg)));
/* Emit lea manually to avoid clobbering of flags. */
- emit_insn (gen_rtx_SET (SImode, reg2,
- gen_rtx_PLUS (Pmode, out, const2_rtx)));
+ emit_insn (gen_rtx_SET (reg2, gen_rtx_PLUS (Pmode, out, const2_rtx)));
tmp = gen_rtx_REG (CCNOmode, FLAGS_REG);
tmp = gen_rtx_EQ (VOIDmode, tmp, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, out,
+ emit_insn (gen_rtx_SET (out,
gen_rtx_IF_THEN_ELSE (Pmode, tmp,
reg2,
out)));
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, end_2_label),
pc_rtx);
- tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ tmp = emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
JUMP_LABEL (tmp) = end_2_label;
/* Not in the first two. Move two bytes forward. */
}
}
- call = gen_rtx_SET (VOIDmode, retval, call);
+ call = gen_rtx_SET (retval, call);
}
vec[vec_len++] = call;
if (pop)
{
pop = gen_rtx_PLUS (Pmode, stack_pointer_rtx, pop);
- pop = gen_rtx_SET (VOIDmode, stack_pointer_rtx, pop);
+ pop = gen_rtx_SET (stack_pointer_rtx, pop);
vec[vec_len++] = pop;
}
if (! pat)
return 0;
emit_insn (pat);
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_STRICT_LOW_PART (VOIDmode, target),
+ emit_insn (gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode, target),
gen_rtx_fmt_ee (comparison, QImode,
SET_DEST (pat),
const0_rtx)));
if (! pat)
return 0;
emit_insn (pat);
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_STRICT_LOW_PART (VOIDmode, target),
+ emit_insn (gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode, target),
gen_rtx_fmt_ee (comparison, QImode,
SET_DEST (pat),
const0_rtx)));
target = gen_rtx_SUBREG (QImode, target, 0);
emit_insn
- (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
+ (gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode, target),
gen_rtx_fmt_ee (EQ, QImode,
gen_rtx_REG ((machine_mode) d->flag,
FLAGS_REG),
target = gen_rtx_SUBREG (QImode, target, 0);
emit_insn
- (gen_rtx_SET (VOIDmode, gen_rtx_STRICT_LOW_PART (VOIDmode, target),
+ (gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode, target),
gen_rtx_fmt_ee (EQ, QImode,
gen_rtx_REG ((machine_mode) d->flag,
FLAGS_REG),
}
emit_insn (pat);
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_STRICT_LOW_PART (VOIDmode, target),
+ emit_insn (gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode, target),
gen_rtx_fmt_ee (comparison, QImode,
set_dst,
const0_rtx)));
if (TARGET_CMOVE)
{
t = ix86_expand_compare (code, op1, op2);
- emit_insn (gen_rtx_SET (VOIDmode, dst,
- gen_rtx_IF_THEN_ELSE (GET_MODE (dst), t,
- src, dst)));
+ emit_insn (gen_rtx_SET (dst, gen_rtx_IF_THEN_ELSE (GET_MODE (dst), t,
+ src, dst)));
}
else
{
pat = gen_rtx_GEU (VOIDmode, gen_rtx_REG (CCCmode, FLAGS_REG),
const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, target,
+ emit_insn (gen_rtx_SET (target,
gen_rtx_IF_THEN_ELSE (SImode, pat, op2, op1)));
return target;
pat = gen_rtx_LTU (QImode, gen_rtx_REG (CCCmode, FLAGS_REG),
const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, op2, pat));
+ emit_insn (gen_rtx_SET (op2, pat));
if (target == 0
|| !register_operand (target, SImode))
target = gen_reg_rtx (QImode);
PUT_MODE (pat, QImode);
- emit_insn (gen_rtx_SET (VOIDmode, target, pat));
+ emit_insn (gen_rtx_SET (target, pat));
return target;
case IX86_BUILTIN_READ_FLAGS:
op1 = simplify_gen_subreg (mode0, op1, GET_MODE (op1), 0);
target = gen_reg_rtx (QImode);
- emit_insn (gen_rtx_SET (mode0, target, const0_rtx));
+ emit_insn (gen_rtx_SET (target, const0_rtx));
/* Emit kortest. */
emit_insn (GEN_FCN (icode) (op0, op1));
expand_float (f0, i0, 0);
- emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
+ emit_insn (gen_rtx_SET (out, gen_rtx_PLUS (mode, f0, f0)));
emit_label (donelab);
}
/* First attempt to recognize VAL as-is. */
dup = gen_rtx_VEC_DUPLICATE (mode, val);
- insn = emit_insn (gen_rtx_SET (VOIDmode, target, dup));
+ insn = emit_insn (gen_rtx_SET (target, dup));
if (recog_memoized (insn) < 0)
{
rtx_insn *seq;
val = gen_lowpart (SImode, val);
x = gen_rtx_TRUNCATE (HImode, val);
x = gen_rtx_VEC_DUPLICATE (mode, x);
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
return true;
}
goto widen;
gcc_assert (ok);
x = gen_rtx_VEC_CONCAT (mode, x, x);
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
}
return true;
gcc_assert (ok);
x = gen_rtx_VEC_CONCAT (mode, x, x);
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
}
return true;
if (use_vector_set)
{
- emit_insn (gen_rtx_SET (VOIDmode, target, CONST0_RTX (mode)));
+ emit_insn (gen_rtx_SET (target, CONST0_RTX (mode)));
var = force_reg (GET_MODE_INNER (mode), var);
ix86_expand_vector_set (mmx_ok, target, var, one_var);
return true;
return false;
var = force_reg (GET_MODE_INNER (mode), var);
x = gen_rtx_VEC_CONCAT (mode, var, CONST0_RTX (GET_MODE_INNER (mode)));
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
return true;
case V4SFmode:
var = force_reg (GET_MODE_INNER (mode), var);
x = gen_rtx_VEC_DUPLICATE (mode, var);
x = gen_rtx_VEC_MERGE (mode, x, CONST0_RTX (mode), const1_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, new_target, x));
+ emit_insn (gen_rtx_SET (new_target, x));
if (one_var != 0)
{
/* We need to shuffle the value to the correct position, so
ops[1] = force_reg (cmode, ops[1]);
if (!register_operand (ops[0], cmode))
ops[0] = force_reg (cmode, ops[0]);
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_VEC_CONCAT (mode, ops[0],
- ops[1])));
+ emit_insn (gen_rtx_SET (target, gen_rtx_VEC_CONCAT (mode, ops[0],
+ ops[1])));
break;
case 4:
op0),
CONST0_RTX (V4SImode),
const1_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, op1, op0));
+ emit_insn (gen_rtx_SET (op1, op0));
/* Cast the V4SImode vector back to a vector in orignal mode. */
op0 = gen_reg_rtx (mode);
/* Cast the SECOND_IMODE vector back to a vector on original
mode. */
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_lowpart (mode, op0)));
+ emit_insn (gen_rtx_SET (target, gen_lowpart (mode, op0)));
break;
default:
n >> 2);
ix86_expand_vector_init_interleave (half_mode, op1,
&ops [n >> 1], n >> 2);
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_VEC_CONCAT (mode, op0, op1)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_VEC_CONCAT (mode, op0, op1)));
return;
case V64QImode:
&ops [n >> 1], n >> 3);
ix86_expand_vector_init_interleave (quarter_mode, op3,
&ops [(n >> 1) | (n >> 2)], n >> 3);
- emit_insn (gen_rtx_SET (VOIDmode, op4,
- gen_rtx_VEC_CONCAT (half_mode, op0, op1)));
- emit_insn (gen_rtx_SET (VOIDmode, op5,
- gen_rtx_VEC_CONCAT (half_mode, op2, op3)));
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_VEC_CONCAT (mode, op4, op5)));
+ emit_insn (gen_rtx_SET (op4, gen_rtx_VEC_CONCAT (half_mode, op0, op1)));
+ emit_insn (gen_rtx_SET (op5, gen_rtx_VEC_CONCAT (half_mode, op2, op3)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_VEC_CONCAT (mode, op4, op5)));
return;
case V16QImode:
tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
else
tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
return;
}
break;
tmp = gen_rtx_VEC_CONCAT (mode, val, tmp);
else
tmp = gen_rtx_VEC_CONCAT (mode, tmp, val);
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
return;
case V2DFmode:
op0 = tmp, op1 = val;
tmp = gen_rtx_VEC_CONCAT (mode, op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
}
return;
if (TARGET_AVX512F)
{
tmp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_VEC_DUPLICATE (mode, val)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_VEC_DUPLICATE (mode, val)));
emit_insn (gen_avx512f_blendmv8df (target, tmp, target,
force_reg (QImode, GEN_INT (1 << elt))));
return;
if (TARGET_AVX512F)
{
tmp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_VEC_DUPLICATE (mode, val)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_VEC_DUPLICATE (mode, val)));
emit_insn (gen_avx512f_blendmv8di (target, tmp, target,
force_reg (QImode, GEN_INT (1 << elt))));
return;
if (TARGET_AVX512F)
{
tmp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_VEC_DUPLICATE (mode, val)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_VEC_DUPLICATE (mode, val)));
emit_insn (gen_avx512f_blendmv16sf (target, tmp, target,
force_reg (HImode, GEN_INT (1 << elt))));
return;
if (TARGET_AVX512F)
{
tmp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_VEC_DUPLICATE (mode, val)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_VEC_DUPLICATE (mode, val)));
emit_insn (gen_avx512f_blendmv16si (target, tmp, target,
force_reg (HImode, GEN_INT (1 << elt))));
return;
if (TARGET_AVX512F && TARGET_AVX512BW)
{
tmp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_VEC_DUPLICATE (mode, val)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_VEC_DUPLICATE (mode, val)));
emit_insn (gen_avx512bw_blendmv32hi (target, tmp, target,
force_reg (SImode, GEN_INT (1 << elt))));
return;
if (TARGET_AVX512F && TARGET_AVX512BW)
{
tmp = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_VEC_DUPLICATE (mode, val)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_VEC_DUPLICATE (mode, val)));
emit_insn (gen_avx512bw_blendmv64qi (target, tmp, target,
force_reg (DImode, GEN_INT (1 << elt))));
return;
{
tmp = gen_rtx_VEC_DUPLICATE (mode, val);
tmp = gen_rtx_VEC_MERGE (mode, tmp, target, GEN_INT (1 << elt));
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
}
else
{
target = gen_lowpart (SImode, target);
}
- emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
+ emit_insn (gen_rtx_SET (target, tmp));
}
else
{
temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
gen_rtx_LABEL_REF (VOIDmode, label),
pc_rtx);
- temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
+ temp = gen_rtx_SET (pc_rtx, temp);
emit_jump_insn (temp);
predict_jump (REG_BR_PROB_BASE * 10 / 100);
/* round(a) = sgn(a) * floor(fabs(a) + 0.5) */
/* scratch = fxam(op1) */
- emit_insn (gen_rtx_SET (VOIDmode, scratch,
+ emit_insn (gen_rtx_SET (scratch,
gen_rtx_UNSPEC (HImode, gen_rtvec (1, op1),
UNSPEC_FXAM)));
/* e1 = fabs(op1) */
/* e2 = e1 + 0.5 */
half = force_reg (inmode, half);
- emit_insn (gen_rtx_SET (VOIDmode, e2,
- gen_rtx_PLUS (inmode, e1, half)));
+ emit_insn (gen_rtx_SET (e2, gen_rtx_PLUS (inmode, e1, half)));
/* res = floor(e2) */
if (inmode != XFmode)
{
tmp1 = gen_reg_rtx (XFmode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp1,
- gen_rtx_FLOAT_EXTEND (XFmode, e2)));
+ emit_insn (gen_rtx_SET (tmp1, gen_rtx_FLOAT_EXTEND (XFmode, e2)));
}
else
tmp1 = e2;
emit_insn (gen_frndintxf2_floor (tmp0, tmp1));
- emit_insn (gen_rtx_SET (VOIDmode, res,
+ emit_insn (gen_rtx_SET (res,
gen_rtx_UNSPEC (outmode, gen_rtvec (1, tmp0),
UNSPEC_TRUNC_NOOP)));
}
gen_rtx_EQ (VOIDmode, flags, const0_rtx),
gen_rtx_LABEL_REF (VOIDmode, jump_label),
pc_rtx);
- insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ insn = emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
predict_jump (REG_BR_PROB_BASE * 50 / 100);
JUMP_LABEL (insn) = jump_label;
/* x0 = rcp(b) estimate */
if (mode == V16SFmode || mode == V8DFmode)
- emit_insn (gen_rtx_SET (VOIDmode, x0,
- gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
- UNSPEC_RCP14)));
+ emit_insn (gen_rtx_SET (x0, gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
+ UNSPEC_RCP14)));
else
- emit_insn (gen_rtx_SET (VOIDmode, x0,
- gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
- UNSPEC_RCP)));
+ emit_insn (gen_rtx_SET (x0, gen_rtx_UNSPEC (mode, gen_rtvec (1, b),
+ UNSPEC_RCP)));
/* e0 = x0 * b */
- emit_insn (gen_rtx_SET (VOIDmode, e0,
- gen_rtx_MULT (mode, x0, b)));
+ emit_insn (gen_rtx_SET (e0, gen_rtx_MULT (mode, x0, b)));
/* e0 = x0 * e0 */
- emit_insn (gen_rtx_SET (VOIDmode, e0,
- gen_rtx_MULT (mode, x0, e0)));
+ emit_insn (gen_rtx_SET (e0, gen_rtx_MULT (mode, x0, e0)));
/* e1 = x0 + x0 */
- emit_insn (gen_rtx_SET (VOIDmode, e1,
- gen_rtx_PLUS (mode, x0, x0)));
+ emit_insn (gen_rtx_SET (e1, gen_rtx_PLUS (mode, x0, x0)));
/* x1 = e1 - e0 */
- emit_insn (gen_rtx_SET (VOIDmode, x1,
- gen_rtx_MINUS (mode, e1, e0)));
+ emit_insn (gen_rtx_SET (x1, gen_rtx_MINUS (mode, e1, e0)));
/* res = a * x1 */
- emit_insn (gen_rtx_SET (VOIDmode, res,
- gen_rtx_MULT (mode, a, x1)));
+ emit_insn (gen_rtx_SET (res, gen_rtx_MULT (mode, a, x1)));
}
/* Output code to perform a Newton-Rhapson approximation of a
a = force_reg (mode, a);
/* x0 = rsqrt(a) estimate */
- emit_insn (gen_rtx_SET (VOIDmode, x0,
- gen_rtx_UNSPEC (mode, gen_rtvec (1, a),
- unspec)));
+ emit_insn (gen_rtx_SET (x0, gen_rtx_UNSPEC (mode, gen_rtvec (1, a),
+ unspec)));
/* If (a == 0.0) Filter out infinity to prevent NaN for sqrt(0.0). */
if (!recip)
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode, mask,
- gen_rtx_NE (mode, zero, a)));
+ emit_insn (gen_rtx_SET (mask, gen_rtx_NE (mode, zero, a)));
- emit_insn (gen_rtx_SET (VOIDmode, x0,
- gen_rtx_AND (mode, x0, mask)));
+ emit_insn (gen_rtx_SET (x0, gen_rtx_AND (mode, x0, mask)));
}
}
/* e0 = x0 * a */
- emit_insn (gen_rtx_SET (VOIDmode, e0,
- gen_rtx_MULT (mode, x0, a)));
+ emit_insn (gen_rtx_SET (e0, gen_rtx_MULT (mode, x0, a)));
/* e1 = e0 * x0 */
- emit_insn (gen_rtx_SET (VOIDmode, e1,
- gen_rtx_MULT (mode, e0, x0)));
+ emit_insn (gen_rtx_SET (e1, gen_rtx_MULT (mode, e0, x0)));
/* e2 = e1 - 3. */
mthree = force_reg (mode, mthree);
- emit_insn (gen_rtx_SET (VOIDmode, e2,
- gen_rtx_PLUS (mode, e1, mthree)));
+ emit_insn (gen_rtx_SET (e2, gen_rtx_PLUS (mode, e1, mthree)));
mhalf = force_reg (mode, mhalf);
if (recip)
/* e3 = -.5 * x0 */
- emit_insn (gen_rtx_SET (VOIDmode, e3,
- gen_rtx_MULT (mode, x0, mhalf)));
+ emit_insn (gen_rtx_SET (e3, gen_rtx_MULT (mode, x0, mhalf)));
else
/* e3 = -.5 * e0 */
- emit_insn (gen_rtx_SET (VOIDmode, e3,
- gen_rtx_MULT (mode, e0, mhalf)));
+ emit_insn (gen_rtx_SET (e3, gen_rtx_MULT (mode, e0, mhalf)));
/* ret = e2 * e3 */
- emit_insn (gen_rtx_SET (VOIDmode, res,
- gen_rtx_MULT (mode, e2, e3)));
+ emit_insn (gen_rtx_SET (res, gen_rtx_MULT (mode, e2, e3)));
}
#ifdef TARGET_SOLARIS
rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
mask = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
+ emit_insn (gen_rtx_SET (mask, tmp));
}
}
else
mask = gen_rtx_NOT (mode, mask);
- emit_insn (gen_rtx_SET (VOIDmode, sgn,
- gen_rtx_AND (mode, mask, sign)));
- emit_insn (gen_rtx_SET (VOIDmode, result,
- gen_rtx_IOR (mode, abs_value, sgn)));
+ emit_insn (gen_rtx_SET (sgn, gen_rtx_AND (mode, mask, sign)));
+ emit_insn (gen_rtx_SET (result, gen_rtx_IOR (mode, abs_value, sgn)));
}
/* Expand fabs (OP0) and return a new rtx that holds the result. The
rtx tmp = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
tmp = gen_rtx_VEC_SELECT (mode, mask, tmp);
mask = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, mask, tmp));
+ emit_insn (gen_rtx_SET (mask, tmp));
}
- emit_insn (gen_rtx_SET (VOIDmode, xa,
- gen_rtx_AND (mode, op0, mask)));
+ emit_insn (gen_rtx_SET (xa, gen_rtx_AND (mode, op0, mask)));
if (smask)
*smask = mask;
label = gen_label_rtx ();
tmp = gen_rtx_REG (fpcmp_mode, FLAGS_REG);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_COMPARE (fpcmp_mode, op0, op1)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_COMPARE (fpcmp_mode, op0, op1)));
tmp = gen_rtx_fmt_ee (code, VOIDmode, tmp, const0_rtx);
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, label), pc_rtx);
- tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ tmp = emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
JUMP_LABEL (tmp) = label;
return label;
/* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_AND (mode, one, tmp)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_AND (mode, one, tmp)));
/* We always need to subtract here to preserve signed zero. */
tmp = expand_simple_binop (mode, MINUS,
xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
/* Compensate: xa = xa - (xa > operand1 ? 1 : 0) */
tmp = ix86_expand_sse_compare_mask (UNGT, xa, res, !do_floor);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_AND (mode, one, tmp)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_AND (mode, one, tmp)));
tmp = expand_simple_binop (mode, do_floor ? MINUS : PLUS,
xa, tmp, NULL_RTX, 0, OPTAB_DIRECT);
emit_move_insn (res, tmp);
tmp = gen_reg_rtx (mode);
/* xa2 = xa2 - (dxa > 0.5 ? 1 : 0) */
tmp = ix86_expand_sse_compare_mask (UNGT, dxa, half, false);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_AND (mode, one, tmp)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_AND (mode, one, tmp)));
xa2 = expand_simple_binop (mode, MINUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
/* xa2 = xa2 + (dxa <= -0.5 ? 1 : 0) */
tmp = ix86_expand_sse_compare_mask (UNGE, mhalf, dxa, false);
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_AND (mode, one, tmp)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_AND (mode, one, tmp)));
xa2 = expand_simple_binop (mode, PLUS, xa2, tmp, NULL_RTX, 0, OPTAB_DIRECT);
/* res = copysign (xa2, operand1) */
/* Compensate: res = xa2 - (res > xa ? 1 : 0) */
mask = ix86_expand_sse_compare_mask (UNGT, res, xa, false);
- emit_insn (gen_rtx_SET (VOIDmode, mask,
- gen_rtx_AND (mode, mask, one)));
+ emit_insn (gen_rtx_SET (mask, gen_rtx_AND (mode, mask, one)));
tmp = expand_simple_binop (mode, MINUS,
res, mask, NULL_RTX, 0, OPTAB_DIRECT);
emit_move_insn (res, tmp);
XVECEXP (x, 0, i) = const0_rtx;
x = gen_rtx_VEC_SELECT (V2DFmode, gen_rtx_VEC_CONCAT (V4DFmode, const0_rtx,
const0_rtx), x);
- x = gen_rtx_SET (VOIDmode, const0_rtx, x);
+ x = gen_rtx_SET (const0_rtx, x);
start_sequence ();
vselect_insn = emit_insn (x);
end_sequence ();
/* This matches five different patterns with the different modes. */
x = gen_rtx_VEC_MERGE (vmode, op1, op0, GEN_INT (mask));
- x = gen_rtx_SET (VOIDmode, target, x);
+ x = gen_rtx_SET (target, x);
emit_insn (x);
if (target != d->target)
emit_move_insn (d->target, gen_lowpart (d->vmode, target));
ix86_expand_sse_unpack (t1, op1, uns_p, high_p);
ix86_expand_sse_unpack (t2, op2, uns_p, high_p);
- emit_insn (gen_rtx_SET (VOIDmode, dest, gen_rtx_MULT (wmode, t1, t2)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_MULT (wmode, t1, t2)));
break;
default:
emit_move_insn (operands[2], addr);
mem = replace_equiv_address_nv (mem, operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, mem, operands[1]));
+ emit_insn (gen_rtx_SET (mem, operands[1]));
DONE;
})
emit_move_insn (operands[2], addr);
mem = replace_equiv_address_nv (mem, operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], mem));
+ emit_insn (gen_rtx_SET (operands[0], mem));
DONE;
})
t = gen_rtx_FLOAT (mode, operands[1]);
t = gen_rtx_VEC_DUPLICATE (vmode, t);
t = gen_rtx_VEC_MERGE (vmode, t, op0, const1_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, op0, t));
+ emit_insn (gen_rtx_SET (op0, t));
DONE;
})
pat = gen_rtx_PLUS (mode, operands[1], operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], pat));
+ emit_insn (gen_rtx_SET (operands[0], pat));
DONE;
})
pat = gen_rtx_PLUS (mode, gen_rtx_PLUS (mode, operands[1], operands[2]),
operands[3]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], pat));
+ emit_insn (gen_rtx_SET (operands[0], pat));
DONE;
}
[(set_attr "type" "lea")
pat = gen_rtx_PLUS (mode, gen_rtx_MULT (mode, operands[1], operands[2]),
operands[3]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], pat));
+ emit_insn (gen_rtx_SET (operands[0], pat));
DONE;
}
[(set_attr "type" "lea")
operands[3]),
operands[4]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], pat));
+ emit_insn (gen_rtx_SET (operands[0], pat));
DONE;
}
[(set_attr "type" "lea")
pat = plus_constant (mode, gen_rtx_MULT (mode, operands[1], operands[2]),
INTVAL (operands[3]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], pat));
+ emit_insn (gen_rtx_SET (operands[0], pat));
DONE;
}
[(set_attr "type" "lea")
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, label),
pc_rtx);
- tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ tmp = emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
JUMP_LABEL (tmp) = label;
emit_move_insn (operands[0], operands[1]);
pat = gen_rtx_MULT (mode, operands[1], operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], pat));
+ emit_insn (gen_rtx_SET (operands[0], pat));
DONE;
})
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, label),
pc_rtx);
- tmp = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ tmp = emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
JUMP_LABEL (tmp) = label;
emit_move_insn (operands[0], operands[1]);
cond = gen_rtx_fmt_ee (ORDERED, QImode,
gen_rtx_REG (CCmode, FLAGS_REG),
const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, scratch, cond));
+ emit_insn (gen_rtx_SET (scratch, cond));
if (TARGET_64BIT)
emit_insn (gen_zero_extendqidi2 (operands[0], scratch));
cond = gen_rtx_fmt_ee (ORDERED, QImode,
gen_rtx_REG (CCmode, FLAGS_REG),
const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, scratch, cond));
+ emit_insn (gen_rtx_SET (scratch, cond));
emit_insn (gen_zero_extendqisi2 (operands[0], scratch));
DONE;
cond = gen_rtx_fmt_ee (EQ, QImode,
gen_rtx_REG (CCmode, FLAGS_REG),
const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, res, cond));
+ emit_insn (gen_rtx_SET (res, cond));
emit_insn (gen_zero_extendqisi2 (operands[0], res));
DONE;
})
cond = gen_rtx_fmt_ee (EQ, QImode,
gen_rtx_REG (CCmode, FLAGS_REG),
const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, res, cond));
+ emit_insn (gen_rtx_SET (res, cond));
emit_insn (gen_zero_extendqisi2 (operands[0], res));
DONE;
})
src = gen_rtx_VEC_MERGE (<MODE>mode, operands[1],
operands[2 * <mask_applied>],
operands[3 * <mask_applied>]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], src));
+ emit_insn (gen_rtx_SET (operands[0], src));
DONE;
}
})
src = gen_rtx_VEC_MERGE (<MODE>mode, operands[1],
operands[2 * <mask_applied>],
operands[3 * <mask_applied>]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], src));
+ emit_insn (gen_rtx_SET (operands[0], src));
DONE;
}
})
src = gen_rtx_VEC_MERGE (<MODE>mode, operands[1],
operands[2 * <mask_applied>],
operands[3 * <mask_applied>]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], src));
+ emit_insn (gen_rtx_SET (operands[0], src));
DONE;
}
})
src = gen_rtx_VEC_MERGE (<MODE>mode, operands[1],
operands[2 * <mask_applied>],
operands[3 * <mask_applied>]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], src));
+ emit_insn (gen_rtx_SET (operands[0], src));
DONE;
}
})
absneg_op = GET_CODE (operands[3]) == NEG ? XOR : AND;
t = gen_rtx_fmt_ee (absneg_op, <MODE>mode, op1, op2);
- t = gen_rtx_SET (VOIDmode, operands[0], t);
+ t = gen_rtx_SET (operands[0], t);
emit_insn (t);
DONE;
}
rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
emit_insn (gen_vec_unpacks_hi_<mode> (tmp, operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
DONE;
})
rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
emit_insn (gen_vec_unpacks_lo_<mode> (tmp, operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
DONE;
})
rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
emit_insn (gen_vec_unpacku_hi_<mode> (tmp, operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
DONE;
})
rtx tmp = gen_reg_rtx (<sseunpackmode>mode);
emit_insn (gen_vec_unpacku_lo_<mode> (tmp, operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_FLOAT (<sseunpackfltmode>mode, tmp)));
DONE;
})
tmp[i] = gen_reg_rtx (V4DFmode);
emit_insn (gen_vec_extract_hi_v8si (tmp[5], operands[1]));
emit_insn (gen_floatv4siv4df2 (tmp[2], tmp[5]));
- emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
- gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
+ emit_insn (gen_rtx_SET (tmp[3], gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
DONE;
emit_insn (gen_vec_extract_hi_v16si (tmp[3], operands[1]));
emit_insn (gen_floatv8siv8df2 (tmp[2], tmp[3]));
- emit_insn (gen_rtx_SET (VOIDmode, k,
- gen_rtx_LT (QImode, tmp[2], tmp[0])));
+ emit_insn (gen_rtx_SET (k, gen_rtx_LT (QImode, tmp[2], tmp[0])));
emit_insn (gen_addv8df3_mask (tmp[2], tmp[2], tmp[1], tmp[2], k));
emit_move_insn (operands[0], tmp[2]);
DONE;
for (i = 2; i < 5; i++)
tmp[i] = gen_reg_rtx (V4DFmode);
emit_insn (gen_avx_cvtdq2pd256_2 (tmp[2], operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, tmp[3],
- gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
+ emit_insn (gen_rtx_SET (tmp[3], gen_rtx_LT (V4DFmode, tmp[2], tmp[0])));
emit_insn (gen_andv4df3 (tmp[4], tmp[3], tmp[1]));
emit_insn (gen_addv4df3 (operands[0], tmp[2], tmp[4]));
DONE;
k = gen_reg_rtx (QImode);
emit_insn (gen_avx512f_cvtdq2pd512_2 (tmp[2], operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, k,
- gen_rtx_LT (QImode, tmp[2], tmp[0])));
+ emit_insn (gen_rtx_SET (k, gen_rtx_LT (QImode, tmp[2], tmp[0])));
emit_insn (gen_addv8df3_mask (tmp[2], tmp[2], tmp[1], tmp[2], k));
emit_move_insn (operands[0], tmp[2]);
DONE;
{
rtx t = gen_reg_rtx (<sseunpackmode>mode);
emit_insn (gen_<sse2_avx2>_pmaddwd<SDOT_PMADD_SUF> (t, operands[1], operands[2]));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_PLUS (<sseunpackmode>mode,
operands[3], t)));
DONE;
for (regno = 0; regno < nregs; regno++)
XVECEXP (operands[0], 0, regno + 1)
- = gen_rtx_SET (VOIDmode,
- gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
+ = gen_rtx_SET (gen_rtx_REG (V8SImode, SSE_REGNO (regno)),
CONST0_RTX (V8SImode));
})
operands[1], operands[2]);
t1 = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, perm));
t2 = gen_rtx_VEC_SELECT (<MODE>mode, t2, t1);
- t2 = gen_rtx_SET (VOIDmode, operands[0], t2);
+ t2 = gen_rtx_SET (operands[0], t2);
emit_insn (t2);
DONE;
}
tmp = gen_rtx_HIGH (Pmode, src);
tmp = gen_rtx_PLUS (Pmode, tmp, pic_offset_table_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
+ emit_insn (gen_rtx_SET (dest, tmp));
tmp = gen_rtx_LO_SUM (Pmode, gen_const_mem (Pmode, dest), src);
- emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
+ emit_insn (gen_rtx_SET (dest, tmp));
if (addend)
{
tmp = gen_rtx_PLUS (Pmode, dest, GEN_INT (addend));
- emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
+ emit_insn (gen_rtx_SET (dest, tmp));
}
}
{
rtx subtarget = !can_create_pseudo_p () ? op0 : gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, subtarget, op1));
+ emit_insn (gen_rtx_SET (subtarget, op1));
op1 = expand_simple_binop (mode, PLUS, subtarget,
GEN_INT (addend), op0, 1, OPTAB_DIRECT);
|| GET_CODE (XEXP (EXP, 0)) == POST_DEC)) \
add_reg_note (insn, REG_INC, XEXP (XEXP (EXP, 0), 0))
- insn = emit_insn (gen_rtx_SET (VOIDmode, out[0], in[0]));
+ insn = emit_insn (gen_rtx_SET (out[0], in[0]));
MAYBE_ADD_REG_INC_NOTE (insn, in[0]);
MAYBE_ADD_REG_INC_NOTE (insn, out[0]);
- insn = emit_insn (gen_rtx_SET (VOIDmode, out[1], in[1]));
+ insn = emit_insn (gen_rtx_SET (out[1], in[1]));
MAYBE_ADD_REG_INC_NOTE (insn, in[1]);
MAYBE_ADD_REG_INC_NOTE (insn, out[1]);
*op0, TFmode, *op1, TFmode,
GEN_INT (magic), DImode);
cmp = gen_reg_rtx (BImode);
- emit_insn (gen_rtx_SET (VOIDmode, cmp,
- gen_rtx_fmt_ee (ncode, BImode,
- ret, const0_rtx)));
+ emit_insn (gen_rtx_SET (cmp, gen_rtx_fmt_ee (ncode, BImode,
+ ret, const0_rtx)));
insns = get_insns ();
end_sequence ();
else
{
cmp = gen_reg_rtx (BImode);
- emit_insn (gen_rtx_SET (VOIDmode, cmp,
- gen_rtx_fmt_ee (code, BImode, *op0, *op1)));
+ emit_insn (gen_rtx_SET (cmp, gen_rtx_fmt_ee (code, BImode, *op0, *op1)));
code = NE;
}
case V4HImode:
/* Perform a parallel unsigned saturating subtraction. */
x = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, x,
- gen_rtx_US_MINUS (mode, op0, op1)));
+ emit_insn (gen_rtx_SET (x, gen_rtx_US_MINUS (mode, op0, op1)));
code = EQ;
op0 = x;
}
x = gen_rtx_fmt_ee (code, mode, op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
return negate;
}
x = gen_rtx_NOT (mode, cmp);
x = gen_rtx_AND (mode, x, of);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
}
else if (of == CONST0_RTX (mode))
{
x = gen_rtx_AND (mode, cmp, ot);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
}
else
{
t = gen_reg_rtx (mode);
x = gen_rtx_AND (mode, cmp, operands[1+negate]);
- emit_insn (gen_rtx_SET (VOIDmode, t, x));
+ emit_insn (gen_rtx_SET (t, x));
f = gen_reg_rtx (mode);
x = gen_rtx_NOT (mode, cmp);
x = gen_rtx_AND (mode, x, operands[2-negate]);
- emit_insn (gen_rtx_SET (VOIDmode, f, x));
+ emit_insn (gen_rtx_SET (f, x));
x = gen_rtx_IOR (mode, t, f);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
}
}
rtx x, tmp = gen_reg_rtx (mode);
x = gen_rtx_US_MINUS (mode, operands[1], operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, x));
+ emit_insn (gen_rtx_SET (tmp, x));
emit_insn (gen_addv4hi3 (operands[0], tmp, operands[2]));
return true;
}
add_reg_note (insn, REG_CFA_OFFSET,
- gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (GET_MODE (reg),
+ gen_rtx_SET (gen_rtx_MEM (GET_MODE (reg),
plus_constant (Pmode,
base, off)),
frame_reg));
emit_move_insn (r2, GEN_INT (-(first + size)));
/* Compare current value of BSP and SP registers. */
- emit_insn (gen_rtx_SET (VOIDmode, p6,
- gen_rtx_fmt_ee (LTU, BImode,
- r3, stack_pointer_rtx)));
+ emit_insn (gen_rtx_SET (p6, gen_rtx_fmt_ee (LTU, BImode,
+ r3, stack_pointer_rtx)));
/* Compute the address of the probe for the Backing Store (which grows
towards higher addresses). We probe only at the first offset of
size is at least 4096 - (96 + 2) * 8 = 3312 bytes, which is enough.
Also compute the address of the last probe for the memory stack
(which grows towards lower addresses). */
- emit_insn (gen_rtx_SET (VOIDmode, r3, plus_constant (Pmode, r3, 4095)));
- emit_insn (gen_rtx_SET (VOIDmode, r2,
- gen_rtx_PLUS (Pmode, stack_pointer_rtx, r2)));
+ emit_insn (gen_rtx_SET (r3, plus_constant (Pmode, r3, 4095)));
+ emit_insn (gen_rtx_SET (r2, gen_rtx_PLUS (Pmode, stack_pointer_rtx, r2)));
/* Compare them and raise SEGV if the former has topped the latter. */
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
gen_rtx_fmt_ee (NE, VOIDmode, p6, const0_rtx),
- gen_rtx_SET (VOIDmode, p6,
- gen_rtx_fmt_ee (GEU, BImode,
- r3, r2))));
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_ZERO_EXTRACT (DImode, r3, GEN_INT (12),
+ gen_rtx_SET (p6, gen_rtx_fmt_ee (GEU, BImode,
+ r3, r2))));
+ emit_insn (gen_rtx_SET (gen_rtx_ZERO_EXTRACT (DImode, r3, GEN_INT (12),
const0_rtx),
const0_rtx));
emit_insn (gen_rtx_COND_EXEC (VOIDmode,
HOST_WIDE_INT i;
emit_move_insn (r2, GEN_INT (-(first + PROBE_INTERVAL)));
- emit_insn (gen_rtx_SET (VOIDmode, r2,
+ emit_insn (gen_rtx_SET (r2,
gen_rtx_PLUS (Pmode, stack_pointer_rtx, r2)));
emit_stack_probe (r2);
generate any code. Then probe at FIRST + SIZE. */
for (i = 2 * PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
{
- emit_insn (gen_rtx_SET (VOIDmode, r2,
+ emit_insn (gen_rtx_SET (r2,
plus_constant (Pmode, r2, -PROBE_INTERVAL)));
emit_stack_probe (r2);
}
- emit_insn (gen_rtx_SET (VOIDmode, r2,
+ emit_insn (gen_rtx_SET (r2,
plus_constant (Pmode, r2,
(i - PROBE_INTERVAL) - size)));
emit_stack_probe (r2);
/* Step 2: compute initial and final value of the loop counter. */
/* TEST_ADDR = SP + FIRST. */
- emit_insn (gen_rtx_SET (VOIDmode, r2,
+ emit_insn (gen_rtx_SET (r2,
gen_rtx_PLUS (Pmode, stack_pointer_rtx, r2)));
/* LAST_ADDR = SP + FIRST + ROUNDED_SIZE. */
if (rounded_size > (1 << 21))
{
emit_move_insn (r3, GEN_INT (-rounded_size));
- emit_insn (gen_rtx_SET (VOIDmode, r3, gen_rtx_PLUS (Pmode, r2, r3)));
+ emit_insn (gen_rtx_SET (r3, gen_rtx_PLUS (Pmode, r2, r3)));
}
else
- emit_insn (gen_rtx_SET (VOIDmode, r3,
- gen_rtx_PLUS (Pmode, r2,
- GEN_INT (-rounded_size))));
+ emit_insn (gen_rtx_SET (r3, gen_rtx_PLUS (Pmode, r2,
+ GEN_INT (-rounded_size))));
/* Step 3: the loop
/* TEMP = SIZE - ROUNDED_SIZE. */
if (size != rounded_size)
{
- emit_insn (gen_rtx_SET (VOIDmode, r2,
- plus_constant (Pmode, r2,
- rounded_size - size)));
+ emit_insn (gen_rtx_SET (r2, plus_constant (Pmode, r2,
+ rounded_size - size)));
emit_stack_probe (r2);
}
}
{
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_REGISTER,
- gen_rtx_SET (VOIDmode,
- ar_pfs_save_reg,
+ gen_rtx_SET (ar_pfs_save_reg,
gen_rtx_REG (DImode, AR_PFS_REGNUM)));
}
}
{
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (DImode,
stack_pointer_rtx,
frame_size_rtx)));
reg_emitted (reg_save_b0);
insn = emit_move_insn (alt_reg, reg);
RTX_FRAME_RELATED_P (insn) = 1;
- add_reg_note (insn, REG_CFA_REGISTER,
- gen_rtx_SET (VOIDmode, alt_reg, pc_rtx));
+ add_reg_note (insn, REG_CFA_REGISTER, gen_rtx_SET (alt_reg, pc_rtx));
/* Even if we're not going to generate an epilogue, we still
need to save the register so that EH works. */
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (DImode,
stack_pointer_rtx,
frame_size_rtx)));
x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm));
x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x);
- x = gen_rtx_SET (VOIDmode, target, x);
+ x = gen_rtx_SET (target, x);
rtx_insn *insn = emit_insn (x);
if (recog_memoized (insn) < 0)
gcc_assert (ok);
x = gen_rtx_AND (V4HImode, mask, t0);
- emit_insn (gen_rtx_SET (VOIDmode, t0, x));
+ emit_insn (gen_rtx_SET (t0, x));
x = gen_rtx_NOT (V4HImode, mask);
x = gen_rtx_AND (V4HImode, x, t1);
- emit_insn (gen_rtx_SET (VOIDmode, t1, x));
+ emit_insn (gen_rtx_SET (t1, x));
x = gen_rtx_IOR (V4HImode, t0, t1);
- emit_insn (gen_rtx_SET (VOIDmode, d->target, x));
+ emit_insn (gen_rtx_SET (d->target, x));
return true;
}
x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (4, const1_rtx, const0_rtx,
GEN_INT (3), const2_rtx));
x = gen_rtx_VEC_SELECT (V4HImode, op1h, x);
- emit_insn (gen_rtx_SET (VOIDmode, t0, x));
+ emit_insn (gen_rtx_SET (t0, x));
/* T1 = DZ.l, CY.l, BX.l, AW.l. */
emit_insn (gen_mulv4hi3 (t1, op1h, op2h));
op2 = force_reg (SImode, op2);
x = gen_rtx_VEC_CONCAT (V2SImode, op1, op2);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
cmp = gen_reg_rtx (V2SFmode);
PUT_MODE (operands[3], V2SFmode);
- emit_insn (gen_rtx_SET (VOIDmode, cmp, operands[3]));
+ emit_insn (gen_rtx_SET (cmp, operands[3]));
x = gen_rtx_IF_THEN_ELSE (V2SFmode, cmp, operands[1], operands[2]);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
label1 = pc_rtx;
}
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
gen_rtx_fmt_ee (test_code,
VOIDmode,
rtx dwarf_mem = gen_rtx_MEM (GET_MODE (reg), dwarf_address);
iq2000_annotate_frame_insn (emit_move_insn (mem, reg),
- gen_rtx_SET (GET_MODE (reg), dwarf_mem, reg));
+ gen_rtx_SET (dwarf_mem, reg));
}
/* Emit instructions to save/restore registers, as determined by STORE_P. */
insn = emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx,
adjustment_rtx));
- dwarf_pattern = gen_rtx_SET (Pmode, stack_pointer_rtx,
+ dwarf_pattern = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-tsize));
emit_move_insn (int_reg,
GEN_INT (INTVAL (xplus1) & ~ 0x7fff));
- emit_insn (gen_rtx_SET (VOIDmode,
- ptr_reg,
+ emit_insn (gen_rtx_SET (ptr_reg,
gen_rtx_PLUS (Pmode, xplus0, int_reg)));
return plus_constant (Pmode, ptr_reg, INTVAL (xplus1) & 0x7fff);
rtx tem = ((reload_in_progress | reload_completed)
? operands[0] : gen_reg_rtx (mode));
- emit_insn (gen_rtx_SET (VOIDmode, tem,
- gen_rtx_HIGH (mode, operands[1])));
+ emit_insn (gen_rtx_SET (tem, gen_rtx_HIGH (mode, operands[1])));
operands[1] = gen_rtx_LO_SUM (mode, tem, operands[1]);
}
rtx tem = ((reload_in_progress | reload_completed)
? operands[0] : gen_reg_rtx (SImode));
- emit_insn (gen_rtx_SET (VOIDmode, tem,
- gen_rtx_HIGH (SImode, operands[1])));
+ emit_insn (gen_rtx_SET (tem, gen_rtx_HIGH (SImode, operands[1])));
operands[1] = gen_rtx_LO_SUM (SImode, tem, operands[1]);
}
}")
/* Generate conditional branch instruction. */
cond = gen_rtx_fmt_ee (code, mode, cmp0, cmp1);
label = gen_rtx_LABEL_REF (VOIDmode, destination);
- insn = gen_rtx_SET (VOIDmode, pc_rtx,
- gen_rtx_IF_THEN_ELSE (VOIDmode,
- cond, label, pc_rtx));
+ insn = gen_rtx_SET (pc_rtx, gen_rtx_IF_THEN_ELSE (VOIDmode,
+ cond, label, pc_rtx));
emit_jump_insn (insn);
}
else
}
else if (!flag_pic && reloc_operand (operands[1], GET_MODE (operands[1])))
{
- emit_insn (gen_rtx_SET (SImode, operands[0], gen_rtx_HIGH (SImode, operands[1])));
- emit_insn (gen_rtx_SET (SImode, operands[0], gen_rtx_LO_SUM (SImode, operands[0], operands[1])));
+ emit_insn (gen_rtx_SET (operands[0], gen_rtx_HIGH (SImode, operands[1])));
+ emit_insn (gen_rtx_SET (operands[0], gen_rtx_LO_SUM (SImode, operands[0],
+ operands[1])));
DONE;
}
else if (GET_CODE (operands[1]) == CONST_INT)
addr = gen_rtx_PLUS (GET_MODE (addr), addr, GEN_INT (byte_count));
dwarf_set[n_dwarfs++] =
- gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (mode, addr),
+ gen_rtx_SET (gen_rtx_MEM (mode, addr),
gen_rtx_REG (mode, pushm_info[i].reg1));
F (dwarf_set[n_dwarfs - 1]);
if (reg_mask)
{
XVECEXP (note, 0, 0)
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (GET_MODE (stack_pointer_rtx),
stack_pointer_rtx,
GEN_INT (-byte_count)));
/* reload FB to A_REGS */
rtx temp = gen_reg_rtx (Pmode);
x = copy_rtx (x);
- emit_insn (gen_rtx_SET (VOIDmode, temp, XEXP (x, 0)));
+ emit_insn (gen_rtx_SET (temp, XEXP (x, 0)));
XEXP (x, 0) = temp;
}
rtx dest_reg = XEXP (pmv, 0);
rtx dest_mod = XEXP (pmv, 1);
- emit_insn (gen_rtx_SET (Pmode, dest_reg, dest_mod));
+ emit_insn (gen_rtx_SET (dest_reg, dest_mod));
operands[0] = gen_rtx_MEM (mode, dest_reg);
}
if (can_create_pseudo_p () && MEM_P (operands[0]) && MEM_P (operands[1]))
/* We normally copy the low-numbered register first. However, if
the first register operand 0 is the same as the second register of
operand 1, we must copy in the opposite order. */
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, reverse, TRUE, mode),
operand_subword (src, reverse, TRUE, mode)));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, !reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, !reverse, TRUE, mode),
operand_subword (src, !reverse, TRUE, mode)));
}
{
rtx words[2];
split_double (src, &words[0], &words[1]);
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, 0, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, 0, TRUE, mode),
words[0]));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, 1, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, 1, TRUE, mode),
words[1]));
}
ld r1,r3+; ld r2,r3; addi r3,-4
which saves 2 bytes and doesn't force longword alignment. */
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, reverse, TRUE, mode),
adjust_address (src, SImode,
reverse * UNITS_PER_WORD)));
- emit_insn (gen_rtx_SET (VOIDmode,
- operand_subword (dest, !reverse, TRUE, mode),
+ emit_insn (gen_rtx_SET (operand_subword (dest, !reverse, TRUE, mode),
adjust_address (src, SImode,
!reverse * UNITS_PER_WORD)));
}
which saves 2 bytes and doesn't force longword alignment. */
else if (MEM_P (dest) && REG_P (src))
{
- emit_insn (gen_rtx_SET (VOIDmode,
- adjust_address (dest, SImode, 0),
+ emit_insn (gen_rtx_SET (adjust_address (dest, SImode, 0),
operand_subword (src, 0, TRUE, mode)));
- emit_insn (gen_rtx_SET (VOIDmode,
- adjust_address (dest, SImode, UNITS_PER_WORD),
+ emit_insn (gen_rtx_SET (adjust_address (dest, SImode, UNITS_PER_WORD),
operand_subword (src, 1, TRUE, mode)));
}
(count
* GET_MODE_SIZE (mode)
* (HOST_WIDE_INT) (store_p ? -1 : 1)));
- XVECEXP (body, 0, i++) = gen_rtx_SET (VOIDmode, base, src);
+ XVECEXP (body, 0, i++) = gen_rtx_SET (base, src);
}
for (; mask != 0; mask >>= 1, regno++)
operands[!store_p] = gen_frame_mem (mode, addr);
operands[store_p] = gen_rtx_REG (mode, regno);
XVECEXP (body, 0, i++)
- = gen_rtx_SET (VOIDmode, operands[0], operands[1]);
+ = gen_rtx_SET (operands[0], operands[1]);
offset += GET_MODE_SIZE (mode);
}
gcc_assert (i == XVECLEN (body, 0));
}
else
emit_move_insn (scratch_reg, XEXP (operand1, 0));
- emit_insn (gen_rtx_SET (VOIDmode, operand0,
- gen_rtx_MEM (mode, scratch_reg)));
+ emit_insn (gen_rtx_SET (operand0, gen_rtx_MEM (mode, scratch_reg)));
return 1;
}
else if (fp_reg_operand (operand1, mode)
}
else
emit_move_insn (scratch_reg, XEXP (operand0, 0));
- emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_MEM (mode, scratch_reg),
- operand1));
+ emit_insn (gen_rtx_SET (gen_rtx_MEM (mode, scratch_reg), operand1));
return 1;
}
/* Handle secondary reloads for loads of FP registers from constant
memory location into scratch_reg. */
xoperands[0] = scratch_reg;
xoperands[1] = XEXP (force_const_mem (mode, operand1), 0);
- emit_insn (gen_rtx_SET (mode, scratch_reg, xoperands[1]));
+ emit_insn (gen_rtx_SET (scratch_reg, xoperands[1]));
/* Now load the destination register. */
- emit_insn (gen_rtx_SET (mode, operand0,
- gen_rtx_MEM (mode, scratch_reg)));
+ emit_insn (gen_rtx_SET (operand0, gen_rtx_MEM (mode, scratch_reg)));
return 1;
}
addr = plus_constant (Pmode, tmp, vcall_offset);
if (!m68k_legitimate_address_p (Pmode, addr, true))
{
- emit_insn (gen_rtx_SET (VOIDmode, tmp, addr));
+ emit_insn (gen_rtx_SET (tmp, addr));
addr = tmp;
}
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
})
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
})
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
})
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
})
break;
}
- emit_insn (gen_rtx_SET (VOIDmode,
- cc_reg,
- gen_rtx_fmt_ee (code, CCmode, op0, op1)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_fmt_ee (code, CCmode, op0, op1)));
return invert;
}
if ((INTVAL (operands[3]) & 1) == 0)
{
mask = ~(1 << posn);
- emit_insn (gen_rtx_SET (SImode, operands[0],
- gen_rtx_AND (SImode, operands[0], GEN_INT (mask))));
+ emit_insn (gen_rtx_SET (operands[0],
+ gen_rtx_AND (SImode, operands[0],
+ GEN_INT (mask))));
}
else
{
mask = 1 << posn;
- emit_insn (gen_rtx_SET (SImode, operands[0],
- gen_rtx_IOR (SImode, operands[0], GEN_INT (mask))));
+ emit_insn (gen_rtx_SET (operands[0],
+ gen_rtx_IOR (SImode, operands[0],
+ GEN_INT (mask))));
}
return 1;
&& INTVAL (operands[3]) == ((1 << width) - 1))
{
mreg = force_reg (SImode, GEN_INT (INTVAL (operands[3]) << posn));
- emit_insn (gen_rtx_SET (SImode, operands[0],
- gen_rtx_IOR (SImode, operands[0], mreg)));
+ emit_insn (gen_rtx_SET (operands[0],
+ gen_rtx_IOR (SImode, operands[0], mreg)));
return 1;
}
mreg = force_reg (SImode, GEN_INT (~(((1 << width) - 1) << posn)));
/* Clear the field, to overlay it later with the source. */
- emit_insn (gen_rtx_SET (SImode, operands[0],
- gen_rtx_AND (SImode, operands[0], mreg)));
+ emit_insn (gen_rtx_SET (operands[0],
+ gen_rtx_AND (SImode, operands[0], mreg)));
/* If the source is constant 0, we've nothing to add back. */
if (GET_CODE (operands[3]) == CONST_INT && INTVAL (operands[3]) == 0)
if (width + posn != (int) GET_MODE_SIZE (SImode))
{
ereg = force_reg (SImode, GEN_INT ((1 << width) - 1));
- emit_insn (gen_rtx_SET (SImode, sreg,
- gen_rtx_AND (SImode, sreg, ereg)));
+ emit_insn (gen_rtx_SET (sreg, gen_rtx_AND (SImode, sreg, ereg)));
}
/* Insert source value in dest. */
if (posn != 0)
- emit_insn (gen_rtx_SET (SImode, sreg,
- gen_rtx_ASHIFT (SImode, sreg, GEN_INT (posn))));
+ emit_insn (gen_rtx_SET (sreg, gen_rtx_ASHIFT (SImode, sreg,
+ GEN_INT (posn))));
- emit_insn (gen_rtx_SET (SImode, operands[0],
- gen_rtx_IOR (SImode, operands[0], sreg)));
+ emit_insn (gen_rtx_SET (operands[0],
+ gen_rtx_IOR (SImode, operands[0], sreg)));
return 1;
}
temp[next] = gen_reg_rtx (mode[next]);
x = adjust_address (src_mem, mode[next], offset_ld);
- emit_insn (gen_rtx_SET (VOIDmode, temp[next], x));
+ emit_insn (gen_rtx_SET (temp[next], x));
offset_ld += next_amount;
size -= next_amount;
active[phase] = false;
x = adjust_address (dst_mem, mode[phase], offset_st);
- emit_insn (gen_rtx_SET (VOIDmode, x, temp[phase]));
+ emit_insn (gen_rtx_SET (x, temp[phase]));
offset_st += amount[phase];
}
else
low = 4, high = 0;
- emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_SUBREG (SImode, operands[0], low),
+ emit_insn (gen_rtx_SET (gen_rtx_SUBREG (SImode, operands[0], low),
operands[1]));
- emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_SUBREG (SImode, operands[0], high),
+ emit_insn (gen_rtx_SET (gen_rtx_SUBREG (SImode, operands[0], high),
gen_rtx_ASHIFTRT (SImode,
gen_rtx_SUBREG (SImode, operands[0], low),
GEN_INT (31))));
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
- = gen_rtx_SET (VOIDmode,
- gen_rtx_REG (SImode, regno + i),
+ = gen_rtx_SET (gen_rtx_REG (SImode, regno + i),
gen_rtx_MEM (SImode, plus_constant (Pmode, stack_pointer_rtx,
i * 4)));
}")
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
- = gen_rtx_SET (VOIDmode,
+ = gen_rtx_SET (
gen_rtx_MEM (SImode, plus_constant (Pmode, stack_pointer_rtx,
i * 4)),
gen_rtx_REG (SImode, regno + i));
; rtx lshft = GEN_INT (32 - (INTVAL (operands[2]) + INTVAL (operands[3])));
; rtx rshft = GEN_INT (32 - INTVAL (operands[2]));
;
-; emit_insn (gen_rtx_SET (SImode, operands[0], operands[1]));
-; emit_insn (gen_rtx_SET (SImode, operands[0],
+; emit_insn (gen_rtx_SET (operands[0], operands[1]));
+; emit_insn (gen_rtx_SET (operands[0],
; gen_rtx_ASHIFT (SImode, operands[0], lshft)));
-; emit_insn (gen_rtx_SET (SImode, operands[0],
+; emit_insn (gen_rtx_SET (operands[0],
; gen_rtx_ASHIFTRT (SImode, operands[0], rshft)));
; DONE;
; }
rtx tmp1 = gen_reg_rtx (SImode);
rtx tmp2 = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (SImode, tmp1, operands[1]));
- emit_insn (gen_rtx_SET (SImode, tmp2,
+ emit_insn (gen_rtx_SET (tmp1, operands[1]));
+ emit_insn (gen_rtx_SET (tmp2,
gen_rtx_ASHIFT (SImode, tmp1, lshft)));
- emit_insn (gen_rtx_SET (SImode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_ASHIFTRT (SImode, tmp2, rshft)));
DONE;
}
{
rtx rshft = GEN_INT (INTVAL (operands[3]));
shifted = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (SImode, shifted,
+ emit_insn (gen_rtx_SET (shifted,
gen_rtx_LSHIFTRT (SImode, operands[1], rshft)));
}
- emit_insn (gen_rtx_SET (SImode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_AND (SImode, shifted, mask)));
DONE;
}
rtx tmp1 = gen_reg_rtx (SImode);
rtx tmp2 = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (SImode, tmp1, operands[1]));
- emit_insn (gen_rtx_SET (SImode, tmp2,
+ emit_insn (gen_rtx_SET (tmp1, operands[1]));
+ emit_insn (gen_rtx_SET (tmp2,
gen_rtx_ASHIFT (SImode, tmp1, lshft)));
- emit_insn (gen_rtx_SET (SImode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_LSHIFTRT (SImode, tmp2, rshft)));
DONE;
}
n = gen_rtx_PLUS (mode, (t == 'b' ? mep_tp_rtx ()
: mep_gp_rtx ()), n);
- n = emit_insn (gen_rtx_SET (mode, operands[0], n));
+ n = emit_insn (gen_rtx_SET (operands[0], n));
#if DEBUG_EXPAND_MOV
fprintf(stderr, "mep_expand_mov emitting ");
debug_rtx(n);
case LT:
case LTU:
op1 = force_reg (SImode, op1);
- emit_insn (gen_rtx_SET (VOIDmode, dest,
- gen_rtx_fmt_ee (code, SImode, op1, op2)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_fmt_ee (code, SImode, op1, op2)));
return true;
case EQ:
op2 = gen_reg_rtx (SImode);
mep_expand_setcc_1 (LTU, op2, op1, const1_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, dest,
- gen_rtx_XOR (SImode, op2, const1_rtx)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_XOR (SImode, op2, const1_rtx)));
return true;
case LE:
{
RTX_FRAME_RELATED_P(insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (SImode,
- gen_rtx_REG (SImode, dest),
+ gen_rtx_SET (gen_rtx_REG (SImode, dest),
gen_rtx_PLUS (SImode,
gen_rtx_REG (SImode, dest),
GEN_INT (value))));
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode,
- copy_rtx (mem),
+ gen_rtx_SET (copy_rtx (mem),
gen_rtx_REG (rmode, i)));
mem = gen_rtx_MEM (SImode,
plus_constant (Pmode, stack_pointer_rtx,
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode,
- copy_rtx (mem),
+ gen_rtx_SET (copy_rtx (mem),
gen_rtx_REG (rmode, i)));
}
}
tmp = gen_rtx_CONST (Pmode, x);
- emit_insn (gen_rtx_SET (VOIDmode, reg,
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmp)));
return reg;
emit_move_insn (int_reg, GEN_INT (INTVAL (xplus1) & ~0x7fff));
- emit_insn (gen_rtx_SET (VOIDmode,
- ptr_reg,
+ emit_insn (gen_rtx_SET (ptr_reg,
gen_rtx_PLUS (Pmode, xplus0, int_reg)));
result = gen_rtx_PLUS (Pmode, ptr_reg,
static void
mips_emit_unary (enum rtx_code code, rtx target, rtx op0)
{
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_fmt_e (code, GET_MODE (op0), op0)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_fmt_e (code, GET_MODE (op0), op0)));
}
/* Compute (CODE OP0) and store the result in a new register of mode MODE.
void
mips_emit_binary (enum rtx_code code, rtx target, rtx op0, rtx op1)
{
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_fmt_ee (code, GET_MODE (target), op0, op1)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_fmt_ee (code, GET_MODE (target),
+ op0, op1)));
}
/* Compute (CODE OP0 OP1) and store the result in a new register
start_sequence ();
- emit_insn (gen_rtx_SET (Pmode, a0,
- gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, loc)));
+ emit_insn (gen_rtx_SET (a0, gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx,
+ loc)));
insn = mips_expand_call (MIPS_CALL_NORMAL, v0, mips_tls_symbol,
const0_rtx, NULL_RTX, false);
RTL_CONST_CALL_P (insn) = 1;
{
if (!can_create_pseudo_p ())
{
- emit_insn (gen_rtx_SET (VOIDmode, temp, x));
+ emit_insn (gen_rtx_SET (temp, x));
x = temp;
}
else
x = gen_rtx_fmt_ee (codes[i].code, mode, x, GEN_INT (codes[i].value));
}
- emit_insn (gen_rtx_SET (VOIDmode, dest, x));
+ emit_insn (gen_rtx_SET (dest, x));
}
/* Subroutine of mips_legitimize_move. Move constant SRC into register
/* Split moves of symbolic constants into high/low pairs. */
if (mips_split_symbol (dest, src, MAX_MACHINE_MODE, &src))
{
- emit_insn (gen_rtx_SET (VOIDmode, dest, src));
+ emit_insn (gen_rtx_SET (dest, src));
return;
}
rtx temp = gen_reg_rtx (mode);
rtx temp2 = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp,
+ emit_insn (gen_rtx_SET (temp,
gen_rtx_IF_THEN_ELSE (mode, cond,
operands[2], const0_rtx)));
/* Flip the test for the second operand. */
cond = gen_rtx_fmt_ee ((code == EQ) ? NE : EQ, GET_MODE (op0), op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, temp2,
+ emit_insn (gen_rtx_SET (temp2,
gen_rtx_IF_THEN_ELSE (mode, cond,
operands[3], const0_rtx)));
/* Merge the two results, at least one is guaranteed to be zero. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
- gen_rtx_IOR (mode, temp, temp2)));
+ emit_insn (gen_rtx_SET (operands[0], gen_rtx_IOR (mode, temp, temp2)));
}
else
{
operands[3] = force_reg (GET_MODE (operands[0]), operands[3]);
}
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_IF_THEN_ELSE (GET_MODE (operands[0]), cond,
operands[2], operands[3])));
}
&& mips_ok_for_lazy_binding_p (addr))
{
addr = mips_got_load (dest, addr, SYMBOL_GOTOFF_CALL);
- emit_insn (gen_rtx_SET (VOIDmode, dest, addr));
+ emit_insn (gen_rtx_SET (dest, addr));
return true;
}
else
/* Compute the equivalent exclusive mask. */
inverted_mask = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (VOIDmode, inverted_mask,
- gen_rtx_NOT (SImode, mask)));
+ emit_insn (gen_rtx_SET (inverted_mask, gen_rtx_NOT (SImode, mask)));
/* Shift the old value into place. */
if (oldval != const0_rtx)
{
rtx set;
- set = gen_rtx_SET (VOIDmode, mem, reg);
+ set = gen_rtx_SET (mem, reg);
RTX_FRAME_RELATED_P (set) = 1;
return set;
if (restore_p)
{
mips_add_cfa_restore (reg);
- return gen_rtx_SET (VOIDmode, reg, mem);
+ return gen_rtx_SET (reg, mem);
}
if (reg_parm_p)
- return gen_rtx_SET (VOIDmode, mem, reg);
+ return gen_rtx_SET (mem, reg);
return mips_frame_set (mem, reg);
}
n = 0;
/* Add the stack pointer adjustment. */
- set = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ set = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
restore_p ? size : -size));
RTX_FRAME_RELATED_P (set) = 1;
set = mips_frame_set (mem, reg);
else
{
- set = gen_rtx_SET (VOIDmode, reg, mem);
+ set = gen_rtx_SET (reg, mem);
mips_add_cfa_restore (reg);
}
XVECEXP (pattern, 0, j) = set;
set = mips_frame_set (mem, reg);
else
{
- set = gen_rtx_SET (VOIDmode, reg, mem);
+ set = gen_rtx_SET (reg, mem);
mips_add_cfa_restore (reg);
}
XVECEXP (pattern, 0, j) = set;
/* Step 2: compute initial and final value of the loop counter. */
/* TEST_ADDR = SP + FIRST. */
- emit_insn (gen_rtx_SET (VOIDmode, r3,
- plus_constant (Pmode, stack_pointer_rtx,
- -first)));
+ emit_insn (gen_rtx_SET (r3, plus_constant (Pmode, stack_pointer_rtx,
+ -first)));
/* LAST_ADDR = SP + FIRST + ROUNDED_SIZE. */
if (rounded_size > 32768)
{
emit_move_insn (r12, GEN_INT (rounded_size));
- emit_insn (gen_rtx_SET (VOIDmode, r12,
- gen_rtx_MINUS (Pmode, r3, r12)));
+ emit_insn (gen_rtx_SET (r12, gen_rtx_MINUS (Pmode, r3, r12)));
}
else
- emit_insn (gen_rtx_SET (VOIDmode, r12,
- plus_constant (Pmode, r3, -rounded_size)));
+ emit_insn (gen_rtx_SET (r12, plus_constant (Pmode, r3,
+ -rounded_size)));
/* Step 3: the loop
/* Describe the combined effect of the previous instructions. */
mips_set_frame_expr
- (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ (gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, -size)));
}
mips_frame_barrier ();
hard_frame_pointer_rtx,
MIPS_PROLOGUE_TEMP (Pmode)));
mips_set_frame_expr
- (gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
+ (gen_rtx_SET (hard_frame_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, offset)));
}
}
mips_emit_move (dest, pic_offset_table_rtx);
page = mips_unspec_address (src, SYMBOL_GOTOFF_PAGE);
low = mips_unspec_address (src, SYMBOL_GOT_PAGE_OFST);
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
PMODE_INSN (gen_unspec_got, (dest, page))));
- emit_insn (gen_rtx_SET (VOIDmode, dest,
- gen_rtx_LO_SUM (Pmode, dest, low)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_LO_SUM (Pmode, dest, low)));
}
else
{
x = gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelt, rperm));
x = gen_rtx_VEC_SELECT (GET_MODE (target), op0, x);
- x = gen_rtx_SET (VOIDmode, target, x);
+ x = gen_rtx_SET (target, x);
insn = emit_insn (x);
if (recog_memoized (insn) < 0)
merge = force_reg (V4HImode, merge);
x = gen_rtx_AND (V4HImode, merge, t1);
- emit_insn (gen_rtx_SET (VOIDmode, t1, x));
+ emit_insn (gen_rtx_SET (t1, x));
x = gen_rtx_NOT (V4HImode, merge);
x = gen_rtx_AND (V4HImode, x, t0);
- emit_insn (gen_rtx_SET (VOIDmode, t0, x));
+ emit_insn (gen_rtx_SET (t0, x));
x = gen_rtx_IOR (V4HImode, t0, t1);
- emit_insn (gen_rtx_SET (VOIDmode, d->target, x));
+ emit_insn (gen_rtx_SET (d->target, x));
}
return true;
rtx op0 = force_reg (imode, XVECEXP (vals, 0, 0));
rtx op1 = force_reg (imode, XVECEXP (vals, 0, 1));
x = gen_rtx_VEC_CONCAT (vmode, op0, op1);
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
return;
}
emit_insn (cmp (tc, op0, op1));
x = gen_rtx_AND (vmode, tc, (min_p ? op1 : op0));
- emit_insn (gen_rtx_SET (VOIDmode, t0, x));
+ emit_insn (gen_rtx_SET (t0, x));
x = gen_rtx_NOT (vmode, tc);
x = gen_rtx_AND (vmode, x, (min_p ? op0 : op1));
- emit_insn (gen_rtx_SET (VOIDmode, t1, x));
+ emit_insn (gen_rtx_SET (t1, x));
x = gen_rtx_IOR (vmode, t0, t1);
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
}
/* Implement HARD_REGNO_CALLER_SAVE_MODE. */
emit_jump_insn (gen_cbranchdf4 (test, operands[1], reg1, label1));
emit_insn (gen_fix_truncdfsi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
- gen_rtx_LABEL_REF (VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
+ gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
emit_jump_insn (gen_cbranchdf4 (test, operands[1], reg1, label1));
emit_insn (gen_fix_truncdfdi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
- gen_rtx_LABEL_REF (VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
emit_jump_insn (gen_cbranchsf4 (test, operands[1], reg1, label1));
emit_insn (gen_fix_truncsfsi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
- gen_rtx_LABEL_REF (VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
emit_jump_insn (gen_cbranchsf4 (test, operands[1], reg1, label1));
emit_insn (gen_fix_truncsfdi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
- gen_rtx_LABEL_REF (VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
tmpreg);
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (DImode,
+ gen_rtx_SET (gen_rtx_MEM (DImode,
plus_constant (Pmode,
stack_pointer_rtx,
offset)),
++count;
x = plus_constant (Pmode, stack_pointer_rtx, count * -4);
x = gen_frame_mem (SImode, x);
- x = gen_rtx_SET (VOIDmode, x, gen_rtx_REG (SImode, regno));
+ x = gen_rtx_SET (x, gen_rtx_REG (SImode, regno));
elts[count] = F(x);
/* Remove the register from the mask so that... */
/* Create the instruction that updates the stack pointer. */
x = plus_constant (Pmode, stack_pointer_rtx, count * -4);
- x = gen_rtx_SET (VOIDmode, stack_pointer_rtx, x);
+ x = gen_rtx_SET (stack_pointer_rtx, x);
elts[0] = F(x);
/* We need one PARALLEL element to update the stack pointer and
flags = gen_rtx_REG (cmp_mode, CC_REG);
x = gen_rtx_COMPARE (cmp_mode, XEXP (cmp_op, 0), XEXP (cmp_op, 1));
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
x = gen_rtx_fmt_ee (GET_CODE (cmp_op), VOIDmode, flags, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x, label_ref, pc_rtx);
- x = gen_rtx_SET (VOIDmode, pc_rtx, x);
+ x = gen_rtx_SET (pc_rtx, x);
emit_jump_insn (x);
}
p = emit_insn (gen_grow_and_swap ());
/* Document the stack decrement... */
- note = F (gen_rtx_SET (Pmode, stack_pointer_rtx,
+ note = F (gen_rtx_SET (stack_pointer_rtx,
gen_rtx_MINUS (Pmode, stack_pointer_rtx, GEN_INT (2))));
add_reg_note (p, REG_FRAME_RELATED_EXPR, note);
/* ...and the establishment of a new location for the return address. */
- note = F (gen_rtx_SET (Pmode, gen_rtx_MEM (Pmode,
- gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (-2))),
+ note = F (gen_rtx_SET (gen_rtx_MEM (Pmode,
+ gen_rtx_PLUS (Pmode,
+ stack_pointer_rtx,
+ GEN_INT (-2))),
pc_rtx));
add_reg_note (p, REG_CFA_OFFSET, note);
F (p);
note = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (count + 1));
XVECEXP (note, 0, 0)
- = F (gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
- gen_rtx_PLUS (Pmode,
- stack_pointer_rtx,
- GEN_INT (count * (TARGET_LARGE ? -4 : -2)))));
+ = F (gen_rtx_SET (stack_pointer_rtx,
+ gen_rtx_PLUS (Pmode,
+ stack_pointer_rtx,
+ GEN_INT (count * (TARGET_LARGE ? -4 : -2)))));
/* *sp-- = R[i-j] */
/* sp+N R10
addr = stack_pointer_rtx;
XVECEXP (note, 0, j + 1) =
- F (gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (Pmode, addr),
+ F (gen_rtx_SET (gen_rtx_MEM (Pmode, addr),
gen_rtx_REG (Pmode, i - j)) );
}
new_addr, offset);
reg = gen_rtx_REG (SImode, base_regno + par_index);
- XVECEXP (result, 0, par_index) = gen_rtx_SET (VOIDmode, reg, mem);
+ XVECEXP (result, 0, par_index) = gen_rtx_SET (reg, mem);
}
return result;
new_addr, offset);
reg = gen_rtx_REG (SImode, base_regno + par_index);
- XVECEXP (result, 0, par_index) = gen_rtx_SET (VOIDmode, mem, reg);
+ XVECEXP (result, 0, par_index) = gen_rtx_SET (mem, reg);
}
return result;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
/* We need to re-calculate the offset value again for adjustment. */
offset = -(num_use_regs * 4);
adjust_sp_rtx
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, offset));
XVECEXP (parallel_insn, 0, par_index) = adjust_sp_rtx;
RTX_FRAME_RELATED_P (adjust_sp_rtx) = 1;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
/* The offset value is already in place. No need to re-calculate it. */
adjust_sp_rtx
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, offset));
XVECEXP (parallel_insn, 0, par_index) = adjust_sp_rtx;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- push_rtx = gen_rtx_SET (VOIDmode, mem, reg);
+ push_rtx = gen_rtx_SET (mem, reg);
XVECEXP (parallel_insn, 0, par_index) = push_rtx;
RTX_FRAME_RELATED_P (push_rtx) = 1;
offset = offset + 4;
/* We need to re-calculate the offset value again for adjustment. */
offset = -(num_use_regs * 4);
adjust_sp_rtx
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
offset - INTVAL (imm8u)));
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
mem = gen_frame_mem (SImode, plus_constant (Pmode,
stack_pointer_rtx,
offset));
- pop_rtx = gen_rtx_SET (VOIDmode, reg, mem);
+ pop_rtx = gen_rtx_SET (reg, mem);
XVECEXP (parallel_insn, 0, par_index) = pop_rtx;
RTX_FRAME_RELATED_P (pop_rtx) = 1;
offset = offset + 4;
/* The offset value is already in place. No need to re-calculate it. */
adjust_sp_rtx
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
offset + INTVAL (imm8u)));
rtx set_rtx;
plus_rtx = plus_constant (Pmode, stack_pointer_rtx, full_value);
- set_rtx = gen_rtx_SET (VOIDmode, stack_pointer_rtx, plus_rtx);
+ set_rtx = gen_rtx_SET (stack_pointer_rtx, plus_rtx);
add_reg_note (sp_adjust_insn, REG_FRAME_RELATED_EXPR, set_rtx);
RTX_FRAME_RELATED_P (sp_adjust_insn) = 1;
}
else
/* This emit_insn will create corresponding 'slt/slts' insturction. */
- emit_insn (gen_rtx_SET (VOIDmode, tmp,
- gen_rtx_fmt_ee (new_code, SImode,
- cmp_op0, cmp_op1)));
+ emit_insn (gen_rtx_SET (tmp, gen_rtx_fmt_ee (new_code, SImode,
+ cmp_op0, cmp_op1)));
/* Change comparison semantic into (eq X 0) or (ne X 0) behavior
so that cmovz or cmovn will be matched later.
if (sp_offset)
{
rtx sp_adjust
- = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, sp_offset));
if (SMALL_INT (sp_offset))
insn = emit_insn (sp_adjust);
emit_move_insn (tmp, gen_int_mode (cfun->machine->save_regs_offset,
Pmode));
insn = emit_insn (gen_add2_insn (stack_pointer_rtx, tmp));
- cfa_adj = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ cfa_adj = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
cfun->machine->save_regs_offset));
add_reg_note (insn, REG_CFA_ADJUST_CFA, cfa_adj);
{
insn = emit_insn (gen_add2_insn (stack_pointer_rtx,
gen_int_mode (sp_adjust, Pmode)));
- cfa_adj = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ cfa_adj = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
sp_adjust));
add_reg_note (insn, REG_CFA_ADJUST_CFA, cfa_adj);
if (!reg)
reg = gen_reg_rtx (Pmode);
addr = nios2_load_pic_address (addr, UNSPEC_PIC_CALL_SYM, tmp);
- emit_insn (gen_rtx_SET (VOIDmode, reg, addr));
+ emit_insn (gen_rtx_SET (reg, addr));
*call_op = reg;
}
}
unspec_args[argno] = const0_rtx;
insn = (has_target_p
- ? gen_rtx_SET (VOIDmode, target,
+ ? gen_rtx_SET (target,
gen_rtx_UNSPEC_VOLATILE (tmode,
gen_rtvec_v (3, unspec_args),
UNSPECV_CUSTOM_XNXX))
{
if (!nvptx_register_operand (retval, GET_MODE (retval)))
tmp_retval = gen_reg_rtx (GET_MODE (retval));
- t = gen_rtx_SET (VOIDmode, tmp_retval, t);
+ t = gen_rtx_SET (tmp_retval, t);
}
XVECEXP (pat, 0, 0) = t;
if (!REG_P (callee)
rtx pred = gen_reg_rtx (BImode);
rtx cmp = gen_rtx_fmt_ee (GET_CODE (compare), BImode,
XEXP (compare, 0), XEXP (compare, 1));
- emit_insn (gen_rtx_SET (VOIDmode, pred, cmp));
+ emit_insn (gen_rtx_SET (pred, cmp));
return gen_rtx_NE (BImode, pred, const0_rtx);
}
: as == ADDR_SPACE_CONST ? UNSPEC_FROM_CONST
: UNSPEC_FROM_PARAM);
rtx dest = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, dest,
- gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig_op),
- code)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_UNSPEC (Pmode, gen_rtvec (1, orig_op),
+ code)));
return dest;
}
\f
else
code = TRUNCATE;
- rtx pat = gen_rtx_SET (VOIDmode, new_reg,
+ rtx pat = gen_rtx_SET (new_reg,
gen_rtx_fmt_e (code, outer_mode, inner));
emit_insn_before (pat, insn);
}
else
code = ZERO_EXTEND;
- rtx pat = gen_rtx_SET (VOIDmode, inner,
+ rtx pat = gen_rtx_SET (inner,
gen_rtx_fmt_e (code, inner_mode, new_reg));
emit_insn_after (pat, insn);
}
So instead we just emit the raw set, which avoids the movXX
expanders completely. */
mark_reg_pointer (reg, BITS_PER_UNIT);
- insn = emit_insn (gen_rtx_SET (VOIDmode, reg, orig));
+ insn = emit_insn (gen_rtx_SET (reg, orig));
/* Put a REG_EQUAL note on this insn, so that it can be optimized. */
add_reg_note (insn, REG_EQUAL, orig);
}
else
emit_move_insn (scratch_reg, XEXP (operand1, 0));
- emit_insn (gen_rtx_SET (VOIDmode, operand0,
+ emit_insn (gen_rtx_SET (operand0,
replace_equiv_address (operand1, scratch_reg)));
return 1;
}
}
else
emit_move_insn (scratch_reg, XEXP (operand0, 0));
- emit_insn (gen_rtx_SET (VOIDmode,
- replace_equiv_address (operand0, scratch_reg),
+ emit_insn (gen_rtx_SET (replace_equiv_address (operand0, scratch_reg),
operand1));
return 1;
}
if (operand1 == CONST0_RTX (mode))
{
- emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
+ emit_insn (gen_rtx_SET (operand0, operand1));
return 1;
}
pa_emit_move_sequence (xoperands, Pmode, 0);
/* Now load the destination register. */
- emit_insn (gen_rtx_SET (mode, operand0,
+ emit_insn (gen_rtx_SET (operand0,
replace_equiv_address (const_mem, scratch_reg)));
return 1;
}
}
}
- emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
+ emit_insn (gen_rtx_SET (operand0, operand1));
return 1;
}
}
{
rtx temp = gen_reg_rtx (DFmode);
- emit_insn (gen_rtx_SET (VOIDmode, temp, operand1));
- emit_insn (gen_rtx_SET (VOIDmode, operand0, temp));
+ emit_insn (gen_rtx_SET (temp, operand1));
+ emit_insn (gen_rtx_SET (operand0, temp));
return 1;
}
if (register_operand (operand1, mode) || operand1 == CONST0_RTX (mode))
{
/* Run this case quickly. */
- emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
+ emit_insn (gen_rtx_SET (operand0, operand1));
return 1;
}
if (! (reload_in_progress || reload_completed))
mark_reg_pointer (temp, BITS_PER_UNIT);
if (ishighonly)
- set = gen_rtx_SET (mode, operand0, temp);
+ set = gen_rtx_SET (operand0, temp);
else
- set = gen_rtx_SET (VOIDmode,
- operand0,
+ set = gen_rtx_SET (operand0,
gen_rtx_LO_SUM (mode, temp, operand1));
- emit_insn (gen_rtx_SET (VOIDmode,
- temp,
- gen_rtx_HIGH (mode, operand1)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_HIGH (mode, operand1)));
emit_insn (set);
}
low = value - high;
- emit_insn (gen_rtx_SET (VOIDmode, temp, GEN_INT (high)));
+ emit_insn (gen_rtx_SET (temp, GEN_INT (high)));
operands[1] = gen_rtx_PLUS (mode, temp, GEN_INT (low));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode, temp,
- gen_rtx_HIGH (mode, operand1)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_HIGH (mode, operand1)));
operands[1] = gen_rtx_LO_SUM (mode, temp, operand1);
}
{
operand1 = GEN_INT (insv);
- emit_insn (gen_rtx_SET (VOIDmode, temp,
+ emit_insn (gen_rtx_SET (temp,
gen_rtx_HIGH (mode, operand1)));
emit_move_insn (temp, gen_rtx_LO_SUM (mode, temp, operand1));
if (mode == DImode)
if (DO_FRAME_NOTES)
{
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, tmpreg,
+ gen_rtx_SET (tmpreg,
gen_rtx_PLUS (Pmode, basereg, delta)));
RTX_FRAME_RELATED_P (insn) = 1;
}
insn = emit_move_insn (dest, src);
if (DO_FRAME_NOTES)
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (word_mode,
+ gen_rtx_SET (gen_rtx_MEM (word_mode,
gen_rtx_PLUS (word_mode,
basereg,
delta)),
gen_rtx_PLUS (Pmode, tmpreg, basereg));
if (DO_FRAME_NOTES)
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, tmpreg,
+ gen_rtx_SET (tmpreg,
gen_rtx_PLUS (Pmode, basereg, delta)));
}
else
plus_constant (Pmode, base,
offset));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, mem, reg));
+ gen_rtx_SET (mem, reg));
}
else
{
offset + 4));
rtx regl = gen_rtx_REG (SFmode, i);
rtx regr = gen_rtx_REG (SFmode, i + 1);
- rtx setl = gen_rtx_SET (VOIDmode, meml, regl);
- rtx setr = gen_rtx_SET (VOIDmode, memr, regr);
+ rtx setl = gen_rtx_SET (meml, regl);
+ rtx setr = gen_rtx_SET (memr, regr);
rtvec vec;
RTX_FRAME_RELATED_P (setl) = 1;
rtx operand1 = operands[2];
rtx label = operands[3];
- emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_REG (CCFPmode, 0),
+ emit_insn (gen_rtx_SET (gen_rtx_REG (CCFPmode, 0),
gen_rtx_fmt_ee (code, CCFPmode, operand0, operand1)));
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
gen_rtx_fmt_ee (NE,
VOIDmode,
emit
(gen_rtx_PARALLEL
(VOIDmode,
- gen_rtvec (6, gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, 29),
+ gen_rtvec (6, gen_rtx_SET (gen_rtx_REG (SImode, 29),
gen_rtx_fmt_ee (unsignedp ? UDIV : DIV,
SImode,
gen_rtx_REG (SImode, 26),
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
operands[7] = addr;
else
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[7], addr));
+ emit_insn (gen_rtx_SET (operands[7], addr));
operands[0] = replace_equiv_address (operands[0], operands[7]);
}
operands[8] = addr;
else
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[8], addr));
+ emit_insn (gen_rtx_SET (operands[8], addr));
operands[1] = replace_equiv_address (operands[1], operands[8]);
}
}")
operands[7] = addr;
else
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[7], addr));
+ emit_insn (gen_rtx_SET (operands[7], addr));
operands[0] = replace_equiv_address (operands[0], operands[7]);
}
operands[8] = addr;
else
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[8], addr));
+ emit_insn (gen_rtx_SET (operands[8], addr));
operands[1] = replace_equiv_address (operands[1], operands[8]);
}
}")
operands[4] = addr;
else
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[4], addr));
+ emit_insn (gen_rtx_SET (operands[4], addr));
operands[0] = replace_equiv_address (operands[0], operands[4]);
}
}")
operands[4] = addr;
else
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[4], addr));
+ emit_insn (gen_rtx_SET (operands[4], addr));
operands[0] = replace_equiv_address (operands[0], operands[4]);
}
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
DONE;
}")
}
else if (pa_cint_ok_for_move (-intval))
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[4], GEN_INT (-intval)));
+ emit_insn (gen_rtx_SET (operands[4], GEN_INT (-intval)));
emit_insn (gen_subsi3 (operands[0], operands[1], operands[4]));
DONE;
}
emit_insn (gen_subhi3 (ax, ax, GEN_INT (fs)));
insn = F (emit_move_insn (sp, ax));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (SImode, sp,
- gen_rtx_PLUS (HImode, sp, GEN_INT (-fs))));
+ gen_rtx_SET (sp, gen_rtx_PLUS (HImode, sp,
+ GEN_INT (-fs))));
}
else
{
RTVEC_ELT (v, i) = constm1_rtx;
emit_insn (gen_vec_initv4si (dest, gen_rtx_PARALLEL (mode, v)));
- emit_insn (gen_rtx_SET (VOIDmode, dest, gen_rtx_ASHIFT (mode, dest, dest)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_ASHIFT (mode, dest, dest)));
DONE;
})
}
x = gen_rtx_VEC_SELECT (V16QImode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
}
x = gen_rtx_VEC_SELECT (V8HImode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
}
x = gen_rtx_VEC_SELECT (V4SImode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
}
x = gen_rtx_VEC_SELECT (V16QImode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
}
x = gen_rtx_VEC_SELECT (V8HImode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
}
x = gen_rtx_VEC_SELECT (V4SImode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
v = gen_rtvec (1, operands[2]);
x = gen_rtx_VEC_SELECT (QImode, operands[1], gen_rtx_PARALLEL (VOIDmode, v));
x = gen_rtx_VEC_DUPLICATE (V16QImode, x);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
v = gen_rtvec (1, operands[2]);
x = gen_rtx_VEC_SELECT (HImode, operands[1], gen_rtx_PARALLEL (VOIDmode, v));
x = gen_rtx_VEC_DUPLICATE (V8HImode, x);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
v = gen_rtvec (1, operands[2]);
x = gen_rtx_VEC_SELECT (SImode, operands[1], gen_rtx_PARALLEL (VOIDmode, v));
x = gen_rtx_VEC_DUPLICATE (V4SImode, x);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
v = gen_rtvec (1, operands[2]);
x = gen_rtx_VEC_SELECT (SFmode, operands[1], gen_rtx_PARALLEL (VOIDmode, v));
x = gen_rtx_VEC_DUPLICATE (V4SFmode, x);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
constv = force_reg (V16QImode, constv);
vperm = gen_rtx_UNSPEC (V16QImode, gen_rtvec (3, mask, mask, constv),
UNSPEC_VPERM);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], vperm));
+ emit_insn (gen_rtx_SET (operands[0], vperm));
}
DONE;
})
constv = force_reg (V16QImode, constv);
vperm = gen_rtx_UNSPEC (V16QImode, gen_rtvec (3, mask, mask, constv),
UNSPEC_VPERM);
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], vperm));
+ emit_insn (gen_rtx_SET (operands[0], vperm));
}
DONE;
})
addr = XEXP (operands[1], 0);
temp = gen_reg_rtx (GET_MODE (addr));
- emit_insn (gen_rtx_SET (VOIDmode, temp,
- gen_rtx_NEG (GET_MODE (addr), addr)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_NEG (GET_MODE (addr), addr)));
emit_insn (gen_altivec_lvsr (operands[0],
replace_equiv_address (operands[1], temp)));
DONE;
if ((int_vector_p || TARGET_VSX) && all_const_zero)
{
/* Zero register. */
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_XOR (mode, target, target)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_XOR (mode, target, target)));
return;
}
else if (int_vector_p && easy_vector_constant (const_vec, mode))
{
/* Splat immediate. */
- emit_insn (gen_rtx_SET (VOIDmode, target, const_vec));
+ emit_insn (gen_rtx_SET (target, const_vec));
return;
}
else
gen_rtvec (1, const0_rtx), UNSPEC_LVE);
emit_insn (gen_rtx_PARALLEL (VOIDmode,
gen_rtvec (2,
- gen_rtx_SET (VOIDmode,
- target, mem),
+ gen_rtx_SET (target, mem),
x)));
x = gen_rtx_VEC_SELECT (inner_mode, target,
gen_rtx_PARALLEL (VOIDmode,
gen_rtvec (1, const0_rtx)));
- emit_insn (gen_rtx_SET (VOIDmode, target,
- gen_rtx_VEC_DUPLICATE (mode, x)));
+ emit_insn (gen_rtx_SET (target, gen_rtx_VEC_DUPLICATE (mode, x)));
return;
}
gen_rtvec (1, const0_rtx), UNSPEC_LVE);
emit_insn (gen_rtx_PARALLEL (VOIDmode,
gen_rtvec (2,
- gen_rtx_SET (VOIDmode,
- reg, mem),
+ gen_rtx_SET (reg, mem),
x)));
/* Linear sequence. */
? gen_rtx_IOR (V16QImode, notx, notx)
: gen_rtx_AND (V16QImode, notx, notx));
rtx tmp = gen_reg_rtx (V16QImode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, iorx));
+ emit_insn (gen_rtx_SET (tmp, iorx));
/* Permute with operands reversed and adjusted selector. */
x = gen_rtx_UNSPEC (mode, gen_rtvec (3, reg, target, tmp),
UNSPEC_VPERM);
}
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
}
/* Extract field ELT from VEC into TARGET. */
{
fprintf (stderr, "\n========== quad_load_store, return %s\n",
ret ? "true" : "false");
- debug_rtx (gen_rtx_SET (VOIDmode, op0, op1));
+ debug_rtx (gen_rtx_SET (op0, op1));
}
return ret;
set_mem_alias_set (modmem, get_TOC_alias_set ());
rtx modreg = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, modreg, modmem));
+ emit_insn (gen_rtx_SET (modreg, modmem));
tmpreg = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, tmpreg, mem));
+ emit_insn (gen_rtx_SET (tmpreg, mem));
dest = gen_reg_rtx (Pmode);
if (TARGET_32BIT)
/* Load the TOC value into temporary register. */
tmpreg = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, tmpreg, mem));
+ emit_insn (gen_rtx_SET (tmpreg, mem));
set_unique_reg_note (get_last_insn (), REG_EQUAL,
gen_rtx_MINUS (Pmode, addr, tlsreg));
else
insn = gen_tls_got_dtprel_32 (tmp2, got, addr);
emit_insn (insn);
- insn = gen_rtx_SET (Pmode, dest,
- gen_rtx_PLUS (Pmode, tmp2, tmp1));
+ insn = gen_rtx_SET (dest, gen_rtx_PLUS (Pmode, tmp2, tmp1));
}
emit_insn (insn);
}
{
case QImode:
case HImode:
- emit_insn (gen_rtx_SET (VOIDmode, dest, source));
+ emit_insn (gen_rtx_SET (dest, source));
return true;
case SImode:
temp = !can_create_pseudo_p () ? dest : gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (temp),
+ emit_insn (gen_rtx_SET (copy_rtx (temp),
GEN_INT (c & ~(HOST_WIDE_INT) 0xffff)));
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
gen_rtx_IOR (SImode, copy_rtx (temp),
GEN_INT (c & 0xffff))));
break;
tmp = can_create_pseudo_p () ? gen_reg_rtx_and_attrs (dest) : dest;
permute_mem = rs6000_gen_le_vsx_permute (source, mode);
permute_reg = rs6000_gen_le_vsx_permute (tmp, mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, permute_mem));
- emit_insn (gen_rtx_SET (VOIDmode, dest, permute_reg));
+ emit_insn (gen_rtx_SET (tmp, permute_mem));
+ emit_insn (gen_rtx_SET (dest, permute_reg));
}
/* Emit a little-endian store to vector memory location DEST from VSX
tmp = can_create_pseudo_p () ? gen_reg_rtx_and_attrs (source) : source;
permute_src = rs6000_gen_le_vsx_permute (source, mode);
permute_tmp = rs6000_gen_le_vsx_permute (tmp, mode);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, permute_src));
- emit_insn (gen_rtx_SET (VOIDmode, dest, permute_tmp));
+ emit_insn (gen_rtx_SET (tmp, permute_src));
+ emit_insn (gen_rtx_SET (dest, permute_tmp));
}
/* Emit a sequence representing a little-endian VSX load or store,
|| GET_CODE (operands[1]) == CONST)
&& small_data_operand (operands[1], mode))
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
return;
}
operands[1] = rs6000_machopic_legitimize_pic_address (
operands[1], mode, operands[0]);
if (operands[0] != operands[1])
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
return;
}
#endif
rs6000_machopic_legitimize_pic_address (operands[1], mode,
operands[0]);
if (operands[0] != operands[1])
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
return;
}
#endif
break;
default:
- fatal_insn ("bad move", gen_rtx_SET (VOIDmode, dest, source));
+ fatal_insn ("bad move", gen_rtx_SET (dest, source));
}
/* Above, we may have called force_const_mem which may have returned
operands[1] = validize_mem (operands[1]);
emit_set:
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (operands[0], operands[1]));
}
/* Return true if a structure, union or array containing FIELD should be
* UNITS_PER_FP_WORD);
emit_jump_insn
- (gen_rtx_SET (VOIDmode,
- pc_rtx,
+ (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
gen_rtx_NE (VOIDmode, cr1,
const0_rtx),
altivec_expand_lvx_be (rtx op0, rtx op1, machine_mode mode, unsigned unspec)
{
rtx tmp = gen_reg_rtx (mode);
- rtx load = gen_rtx_SET (VOIDmode, tmp, op1);
+ rtx load = gen_rtx_SET (tmp, op1);
rtx lvx = gen_rtx_UNSPEC (mode, gen_rtvec (1, const0_rtx), unspec);
rtx par = gen_rtx_PARALLEL (mode, gen_rtvec (2, load, lvx));
rtx sel = swap_selector_for_mode (mode);
gcc_assert (REG_P (op0));
emit_insn (par);
- emit_insn (gen_rtx_SET (VOIDmode, op0, vperm));
+ emit_insn (gen_rtx_SET (op0, vperm));
}
/* Generate code for a "stvx" or "stvxl" built-in for a little endian target
altivec_expand_stvx_be (rtx op0, rtx op1, machine_mode mode, unsigned unspec)
{
rtx tmp = gen_reg_rtx (mode);
- rtx store = gen_rtx_SET (VOIDmode, op0, tmp);
+ rtx store = gen_rtx_SET (op0, tmp);
rtx stvx = gen_rtx_UNSPEC (mode, gen_rtvec (1, const0_rtx), unspec);
rtx par = gen_rtx_PARALLEL (mode, gen_rtvec (2, store, stvx));
rtx sel = swap_selector_for_mode (mode);
gcc_assert (REG_P (op1));
vperm = gen_rtx_UNSPEC (mode, gen_rtvec (3, op1, op1, sel), UNSPEC_VPERM);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, vperm));
+ emit_insn (gen_rtx_SET (tmp, vperm));
emit_insn (par);
}
gcc_assert (REG_P (op1));
vperm = gen_rtx_UNSPEC (mode, gen_rtvec (3, op1, op1, sel), UNSPEC_VPERM);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, vperm));
- emit_insn (gen_rtx_SET (VOIDmode, op0, stvx));
+ emit_insn (gen_rtx_SET (tmp, vperm));
+ emit_insn (gen_rtx_SET (op0, stvx));
}
static rtx
to start a transaction. We do this by placing the 1's
complement of CR's EQ bit into TARGET. */
rtx scratch = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (VOIDmode, scratch,
+ emit_insn (gen_rtx_SET (scratch,
gen_rtx_EQ (SImode, cr,
const0_rtx)));
- emit_insn (gen_rtx_SET (VOIDmode, target,
+ emit_insn (gen_rtx_SET (target,
gen_rtx_XOR (SImode, scratch,
GEN_INT (1))));
}
{
/* For the load case need to negate the address. */
op = gen_reg_rtx (GET_MODE (addr));
- emit_insn (gen_rtx_SET (VOIDmode, op,
- gen_rtx_NEG (GET_MODE (addr), addr)));
+ emit_insn (gen_rtx_SET (op, gen_rtx_NEG (GET_MODE (addr), addr)));
}
op = gen_rtx_MEM (mode, op);
store_p ? "store" : "load");
if (store_p)
- set = gen_rtx_SET (VOIDmode, mem, reg);
+ set = gen_rtx_SET (mem, reg);
else
- set = gen_rtx_SET (VOIDmode, reg, mem);
+ set = gen_rtx_SET (reg, mem);
clobber = gen_rtx_CLOBBER (VOIDmode, scratch);
debug_rtx (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber)));
if ((addr_mask & RELOAD_REG_PRE_MODIFY) == 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (op0, op1));
new_addr = reg;
}
break;
else if (GET_CODE (op1) == PLUS)
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch, op1));
+ emit_insn (gen_rtx_SET (scratch, op1));
op_reg = scratch;
}
and_op = gen_rtx_AND (GET_MODE (scratch), op_reg, op1);
cc_clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (CCmode));
- rv = gen_rtvec (2, gen_rtx_SET (VOIDmode, scratch, and_op), cc_clobber);
+ rv = gen_rtvec (2, gen_rtx_SET (scratch, and_op), cc_clobber);
emit_insn (gen_rtx_PARALLEL (VOIDmode, rv));
new_addr = scratch;
}
case SUBREG:
if (!base_reg_operand (addr, GET_MODE (addr)))
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch, addr));
+ emit_insn (gen_rtx_SET (scratch, addr));
new_addr = scratch;
}
break;
{
if ((addr_mask & RELOAD_REG_INDEXED) == 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch, addr));
+ emit_insn (gen_rtx_SET (scratch, addr));
new_addr = scratch;
}
}
{
if ((addr_mask & RELOAD_REG_OFFSET) == 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch, addr));
+ emit_insn (gen_rtx_SET (scratch, addr));
new_addr = scratch;
}
}
{
if ((addr_mask & RELOAD_REG_INDEXED) == 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch, addr));
+ emit_insn (gen_rtx_SET (scratch, addr));
new_addr = scratch;
}
}
{
if ((addr_mask & RELOAD_REG_OFFSET) == 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, scratch, addr));
+ emit_insn (gen_rtx_SET (scratch, addr));
new_addr = scratch;
}
}
/* Now create the move. */
if (store_p)
- emit_insn (gen_rtx_SET (VOIDmode, mem, reg));
+ emit_insn (gen_rtx_SET (mem, reg));
else
- emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ emit_insn (gen_rtx_SET (reg, mem));
return;
}
/* Now create the move. */
if (store_p)
- emit_insn (gen_rtx_SET (VOIDmode, mem, reg));
+ emit_insn (gen_rtx_SET (mem, reg));
else
- emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
+ emit_insn (gen_rtx_SET (reg, mem));
return;
}
if (TARGET_DEBUG_ADDR)
{
fprintf (stderr, "\n===== Bad 128 bit move:\n");
- debug_rtx (gen_rtx_SET (VOIDmode, dest, src));
+ debug_rtx (gen_rtx_SET (dest, src));
}
gcc_unreachable ();
&& TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128)
emit_insn (gen_rtx_PARALLEL (VOIDmode,
gen_rtvec (10,
- gen_rtx_SET (VOIDmode,
- compare_result,
+ gen_rtx_SET (compare_result,
gen_rtx_COMPARE (comp_mode, op0, op1)),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
emit_insn (gen_stack_protect_testsi (compare_result, op0, op1b));
}
else
- emit_insn (gen_rtx_SET (VOIDmode, compare_result,
+ emit_insn (gen_rtx_SET (compare_result,
gen_rtx_COMPARE (comp_mode, op0, op1)));
}
compare2_rtx = gen_rtx_COMPARE (CCEQmode,
gen_rtx_IOR (SImode, or1_rtx, or2_rtx),
const_true_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, or_result, compare2_rtx));
+ emit_insn (gen_rtx_SET (or_result, compare2_rtx));
compare_result = or_result;
code = EQ;
scratch = gen_reg_rtx (mode);
if (logical_operand (op2, mode))
- emit_insn (gen_rtx_SET (VOIDmode, scratch, gen_rtx_XOR (mode, op1, op2)));
+ emit_insn (gen_rtx_SET (scratch, gen_rtx_XOR (mode, op1, op2)));
else
- emit_insn (gen_rtx_SET (VOIDmode, scratch,
+ emit_insn (gen_rtx_SET (scratch,
gen_rtx_PLUS (mode, op1, negate_rtx (mode, op2))));
return scratch;
rev_cond_rtx = gen_rtx_fmt_ee (rs6000_reverse_condition (cc_mode, cond_code),
SImode, XEXP (condition_rtx, 0), const0_rtx);
not_op = gen_rtx_COMPARE (CCEQmode, rev_cond_rtx, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, not_result, not_op));
+ emit_insn (gen_rtx_SET (not_result, not_op));
condition_rtx = gen_rtx_EQ (VOIDmode, not_result, const0_rtx);
}
else
{
PUT_MODE (condition_rtx, SImode);
- emit_insn (gen_rtx_SET (VOIDmode, result, condition_rtx));
+ emit_insn (gen_rtx_SET (result, condition_rtx));
}
}
condition_rtx = rs6000_generate_compare (operands[0], mode);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, condition_rtx,
loc_ref, pc_rtx)));
}
case UNEQ:
case LTGT:
mask = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode,
- mask,
- gen_rtx_fmt_ee (code, mode, op0, op1)));
+ emit_insn (gen_rtx_SET (mask, gen_rtx_fmt_ee (code, mode, op0, op1)));
return mask;
}
cond2 = gen_rtx_fmt_ee (NE, cc_mode, gen_lowpart (dest_mode, mask),
CONST0_RTX (dest_mode));
- emit_insn (gen_rtx_SET (VOIDmode,
- dest,
+ emit_insn (gen_rtx_SET (dest,
gen_rtx_IF_THEN_ELSE (dest_mode,
cond2,
op_true,
if (! is_against_zero)
{
temp = gen_reg_rtx (compare_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp,
- gen_rtx_MINUS (compare_mode, op0, op1)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_MINUS (compare_mode, op0, op1)));
op0 = temp;
op1 = CONST0_RTX (compare_mode);
}
case LE:
temp = gen_reg_rtx (compare_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_NEG (compare_mode, op0)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_NEG (compare_mode, op0)));
op0 = temp;
break;
case ORDERED:
temp = gen_reg_rtx (compare_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_ABS (compare_mode, op0)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_ABS (compare_mode, op0)));
op0 = temp;
break;
case EQ:
temp = gen_reg_rtx (compare_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp,
+ emit_insn (gen_rtx_SET (temp,
gen_rtx_NEG (compare_mode,
gen_rtx_ABS (compare_mode, op0))));
op0 = temp;
case UNGE:
/* a UNGE 0 <-> (a GE 0 || -a UNLT 0) */
temp = gen_reg_rtx (result_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp,
+ emit_insn (gen_rtx_SET (temp,
gen_rtx_IF_THEN_ELSE (result_mode,
gen_rtx_GE (VOIDmode,
op0, op1),
true_cond = temp;
temp = gen_reg_rtx (compare_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_NEG (compare_mode, op0)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_NEG (compare_mode, op0)));
op0 = temp;
break;
case GT:
/* a GT 0 <-> (a GE 0 && -a UNLT 0) */
temp = gen_reg_rtx (result_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp,
+ emit_insn (gen_rtx_SET (temp,
gen_rtx_IF_THEN_ELSE (result_mode,
gen_rtx_GE (VOIDmode,
op0, op1),
false_cond = temp;
temp = gen_reg_rtx (compare_mode);
- emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_NEG (compare_mode, op0)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_NEG (compare_mode, op0)));
op0 = temp;
break;
gcc_unreachable ();
}
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
gen_rtx_IF_THEN_ELSE (result_mode,
gen_rtx_GE (VOIDmode,
op0, op1),
&& (VECTOR_UNIT_ALTIVEC_OR_VSX_P (mode)
|| (mode == SFmode && VECTOR_UNIT_VSX_P (DFmode))))
{
- emit_insn (gen_rtx_SET (VOIDmode,
- dest,
- gen_rtx_fmt_ee (code, mode, op0, op1)));
+ emit_insn (gen_rtx_SET (dest, gen_rtx_fmt_ee (code, mode, op0, op1)));
return;
}
rtx x;
x = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, label, pc_rtx);
- x = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, x));
+ x = emit_jump_insn (gen_rtx_SET (pc_rtx, x));
add_int_reg_note (x, REG_BR_PROB, very_unlikely);
}
rtx x;
x = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (VOIDmode, x,
- gen_rtx_AND (SImode,
- gen_rtx_NOT (SImode, mask),
- oldval)));
+ emit_insn (gen_rtx_SET (x, gen_rtx_AND (SImode,
+ gen_rtx_NOT (SImode, mask),
+ oldval)));
x = expand_simple_binop (SImode, IOR, newval, x, x, 1, OPTAB_LIB_WIDEN);
x = gen_rtx_COMPARE (CCmode, or_result, const0_rtx);
}
- emit_insn (gen_rtx_SET (VOIDmode, cond, x));
+ emit_insn (gen_rtx_SET (cond, x));
x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
emit_unlikely_jump (x, label2);
/* In all cases, CR0 contains EQ on success, and NE on failure. */
x = gen_rtx_EQ (SImode, cond, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, boolval, x));
+ emit_insn (gen_rtx_SET (boolval, x));
}
/* Expand an atomic exchange operation. */
set, that will be sufficient to not affect other bits. */
x = gen_rtx_NOT (SImode, mask);
x = gen_rtx_IOR (SImode, x, val);
- emit_insn (gen_rtx_SET (VOIDmode, val, x));
+ emit_insn (gen_rtx_SET (val, x));
mask = NULL;
break;
p_dst = simplify_gen_subreg (reg_mode, dst, mode,
i * reg_mode_size);
- emit_insn (gen_rtx_SET (VOIDmode, p_dst, p_src));
+ emit_insn (gen_rtx_SET (p_dst, p_src));
}
return;
overlap. */
int i;
for (i = nregs - 1; i >= 0; i--)
- emit_insn (gen_rtx_SET (VOIDmode,
- simplify_gen_subreg (reg_mode, dst, mode,
+ emit_insn (gen_rtx_SET (simplify_gen_subreg (reg_mode, dst, mode,
i * reg_mode_size),
simplify_gen_subreg (reg_mode, src, mode,
i * reg_mode_size)));
if (TARGET_UPDATE)
{
rtx ndst = simplify_gen_subreg (reg_mode, dst, mode, 0);
- emit_insn (gen_rtx_SET (VOIDmode, ndst,
- gen_rtx_MEM (reg_mode, XEXP (src, 0))));
+ emit_insn (gen_rtx_SET (ndst,
+ gen_rtx_MEM (reg_mode,
+ XEXP (src, 0))));
used_update = true;
}
else
- emit_insn (gen_rtx_SET (VOIDmode, basereg,
- XEXP (XEXP (src, 0), 1)));
+ emit_insn (gen_rtx_SET (basereg,
+ XEXP (XEXP (src, 0), 1)));
src = replace_equiv_address (src, basereg);
}
else
{
rtx basereg = gen_rtx_REG (Pmode, reg);
- emit_insn (gen_rtx_SET (VOIDmode, basereg, XEXP (src, 0)));
+ emit_insn (gen_rtx_SET (basereg, XEXP (src, 0)));
src = replace_equiv_address (src, basereg);
}
}
if (TARGET_UPDATE)
{
rtx nsrc = simplify_gen_subreg (reg_mode, src, mode, 0);
- emit_insn (gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (reg_mode, XEXP (dst, 0)), nsrc));
+ emit_insn (gen_rtx_SET (gen_rtx_MEM (reg_mode,
+ XEXP (dst, 0)),
+ nsrc));
used_update = true;
}
else
- emit_insn (gen_rtx_SET (VOIDmode, basereg,
- XEXP (XEXP (dst, 0), 1)));
+ emit_insn (gen_rtx_SET (basereg,
+ XEXP (XEXP (dst, 0), 1)));
dst = replace_equiv_address (dst, basereg);
}
else
if (j == 0 && used_update)
continue;
- emit_insn (gen_rtx_SET (VOIDmode,
- simplify_gen_subreg (reg_mode, dst, mode,
+ emit_insn (gen_rtx_SET (simplify_gen_subreg (reg_mode, dst, mode,
j * reg_mode_size),
simplify_gen_subreg (reg_mode, src, mode,
j * reg_mode_size)));
while (--i >= 0)
{
rtx mem = gen_frame_mem (BLKmode, regs[i]);
- RTVEC_ELT (p, i) = gen_rtx_SET (VOIDmode, mem, const0_rtx);
+ RTVEC_ELT (p, i) = gen_rtx_SET (mem, const0_rtx);
}
emit_insn (gen_stack_tie (gen_rtx_PARALLEL (VOIDmode, p)));
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_reg,
- gen_rtx_PLUS (Pmode, stack_reg,
- GEN_INT (-size))));
+ gen_rtx_SET (stack_reg, gen_rtx_PLUS (Pmode, stack_reg,
+ GEN_INT (-size))));
}
#define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
/* Step 2: compute initial and final value of the loop counter. */
/* TEST_ADDR = SP + FIRST. */
- emit_insn (gen_rtx_SET (VOIDmode, r12,
- plus_constant (Pmode, stack_pointer_rtx,
- -first)));
+ emit_insn (gen_rtx_SET (r12, plus_constant (Pmode, stack_pointer_rtx,
+ -first)));
/* LAST_ADDR = SP + FIRST + ROUNDED_SIZE. */
if (rounded_size > 32768)
{
emit_move_insn (r0, GEN_INT (-rounded_size));
- emit_insn (gen_rtx_SET (VOIDmode, r0,
- gen_rtx_PLUS (Pmode, r12, r0)));
+ emit_insn (gen_rtx_SET (r0, gen_rtx_PLUS (Pmode, r12, r0)));
}
else
- emit_insn (gen_rtx_SET (VOIDmode, r0,
- plus_constant (Pmode, r12, -rounded_size)));
+ emit_insn (gen_rtx_SET (r0, plus_constant (Pmode, r12,
+ -rounded_size)));
/* Step 3: the loop
rtx vrsave = gen_rtx_REG (SImode, VRSAVE_REGNO);
clobs[0]
- = gen_rtx_SET (VOIDmode,
- vrsave,
+ = gen_rtx_SET (vrsave,
gen_rtx_UNSPEC_VOLATILE (SImode,
gen_rtvec (2, reg, vrsave),
UNSPECV_SET_VRSAVE));
rtx reg = gen_rtx_REG (V4SImode, i);
clobs[nclobs++]
- = gen_rtx_SET (VOIDmode,
- reg,
+ = gen_rtx_SET (reg,
gen_rtx_UNSPEC (V4SImode,
gen_rtvec (1, reg), 27));
}
addr = gen_rtx_PLUS (Pmode, frame_reg, GEN_INT (offset));
mem = gen_frame_mem (GET_MODE (reg), addr);
- return gen_rtx_SET (VOIDmode, store ? mem : reg, store ? reg : mem);
+ return gen_rtx_SET (store ? mem : reg, store ? reg : mem);
}
static rtx
RTVEC_ELT (r, 0) = gen_rtx_REG (CCmode, CR0_REGNO + cr_reg[0]);
RTVEC_ELT (r, 1) = GEN_INT (1 << (7 - cr_reg[0]));
RTVEC_ELT (p, 0)
- = gen_rtx_SET (VOIDmode, reg,
+ = gen_rtx_SET (reg,
gen_rtx_UNSPEC (SImode, r, UNSPEC_MOVESI_FROM_CR));
emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
/* Explain what happens to the stack pointer. */
{
rtx newval = gen_rtx_PLUS (Pmode, sp_reg_rtx, treg);
- RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, sp_reg_rtx, newval);
+ RTVEC_ELT (p, j++) = gen_rtx_SET (sp_reg_rtx, newval);
}
insn = emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
compare_result = gen_rtx_REG (CCUNSmode, CR0_REGNO);
validate_condition_mode (EQ, CCUNSmode);
lo = gen_int_mode (toc_restore_insn & 0xffff, SImode);
- emit_insn (gen_rtx_SET (VOIDmode, compare_result,
+ emit_insn (gen_rtx_SET (compare_result,
gen_rtx_COMPARE (CCUNSmode, tmp_reg_si, lo)));
toc_save_done = gen_label_rtx ();
jump = gen_rtx_IF_THEN_ELSE (VOIDmode,
const0_rtx),
gen_rtx_LABEL_REF (VOIDmode, toc_save_done),
pc_rtx);
- jump = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, jump));
+ jump = emit_jump_insn (gen_rtx_SET (pc_rtx, jump));
JUMP_LABEL (jump) = toc_save_done;
LABEL_NUSES (toc_save_done) += 1;
int n_crsave = 0;
int i;
- crsave_v[n_crsave++] = gen_rtx_SET (VOIDmode, mem, cr_save_rtx);
+ crsave_v[n_crsave++] = gen_rtx_SET (mem, cr_save_rtx);
for (i = 0; i < 8; i++)
if (save_reg_p (CR0_REGNO + i))
crsave_v[n_crsave++]
if (save_reg_p (CR0_REGNO + i))
{
crframe[n_crframe]
- = gen_rtx_SET (VOIDmode, mem,
- gen_rtx_REG (SImode, CR0_REGNO + i));
+ = gen_rtx_SET (mem, gen_rtx_REG (SImode, CR0_REGNO + i));
RTX_FRAME_RELATED_P (crframe[n_crframe]) = 1;
n_crframe++;
/* In other ABIs, by convention, we use a single CR regnum to
represent the fact that all call-saved CR fields are saved.
We use CR2_REGNO to be compatible with gcc-2.95 on Linux. */
- rtx set = gen_rtx_SET (VOIDmode, mem,
- gen_rtx_REG (SImode, CR2_REGNO));
+ rtx set = gen_rtx_SET (mem, gen_rtx_REG (SImode, CR2_REGNO));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
}
}
if (TARGET_MACHO)
emit_insn (gen_get_vrsave_internal (reg));
else
- emit_insn (gen_rtx_SET (VOIDmode, reg, vrsave));
+ emit_insn (gen_rtx_SET (reg, vrsave));
/* Save VRSAVE. */
offset = info->vrsave_save_offset + frame_off;
if (!exit_func && DEFAULT_ABI == ABI_V4)
{
rtx cr = gen_rtx_REG (SImode, CR2_REGNO);
- rtx set = gen_rtx_SET (VOIDmode, reg, cr);
+ rtx set = gen_rtx_SET (reg, cr);
add_reg_note (insn, REG_CFA_REGISTER, set);
RTX_FRAME_RELATED_P (insn) = 1;
RTVEC_ELT (r, 0) = reg;
RTVEC_ELT (r, 1) = GEN_INT (1 << (7-i));
RTVEC_ELT (p, ndx) =
- gen_rtx_SET (VOIDmode, gen_rtx_REG (CCmode, CR0_REGNO + i),
+ gen_rtx_SET (gen_rtx_REG (CCmode, CR0_REGNO + i),
gen_rtx_UNSPEC (CCmode, r, UNSPEC_MOVESI_TO_CR));
ndx++;
}
r = gen_rtx_NEG (mode, a);
r = gen_rtx_FMA (mode, m1, m2, r);
r = gen_rtx_NEG (mode, r);
- emit_insn (gen_rtx_SET (VOIDmode, dst, r));
+ emit_insn (gen_rtx_SET (dst, r));
}
/* Newton-Raphson approximation of floating point divide DST = N/D. If NOTE_P,
/* x0 = 1./d estimate */
x0 = gen_reg_rtx (mode);
- emit_insn (gen_rtx_SET (VOIDmode, x0,
- gen_rtx_UNSPEC (mode, gen_rtvec (1, d),
- UNSPEC_FRES)));
+ emit_insn (gen_rtx_SET (x0, gen_rtx_UNSPEC (mode, gen_rtvec (1, d),
+ UNSPEC_FRES)));
/* Each iteration but the last calculates x_(i+1) = x_i * (2 - d * x_i). */
if (passes > 1) {
halfthree = rs6000_load_constant_and_splat (mode, dconst3_2);
/* x0 = rsqrt estimate */
- emit_insn (gen_rtx_SET (VOIDmode, x0,
- gen_rtx_UNSPEC (mode, gen_rtvec (1, src),
- UNSPEC_RSQRT)));
+ emit_insn (gen_rtx_SET (x0, gen_rtx_UNSPEC (mode, gen_rtvec (1, src),
+ UNSPEC_RSQRT)));
/* y = 0.5 * src = 1.5 * src - src -> fewer constants */
rs6000_emit_msub (y, src, halfthree, src);
iorx = (TARGET_P8_VECTOR
? gen_rtx_IOR (V16QImode, notx, notx)
: gen_rtx_AND (V16QImode, notx, notx));
- emit_insn (gen_rtx_SET (VOIDmode, norreg, iorx));
+ emit_insn (gen_rtx_SET (norreg, iorx));
/* Permute with operands reversed and adjusted selector. */
unspec = gen_rtx_UNSPEC (mode, gen_rtvec (3, op1, op0, norreg),
x = gen_rtx_VEC_CONCAT (dmode, op0, op1);
v = gen_rtvec (2, GEN_INT (perm0), GEN_INT (perm1));
x = gen_rtx_VEC_SELECT (vmode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, target, x));
+ emit_insn (gen_rtx_SET (target, x));
}
return true;
}
rtx stack_toc_unspec = gen_rtx_UNSPEC (Pmode,
gen_rtvec (1, stack_toc_offset),
UNSPEC_TOCSLOT);
- toc_restore = gen_rtx_SET (VOIDmode, toc_reg, stack_toc_unspec);
+ toc_restore = gen_rtx_SET (toc_reg, stack_toc_unspec);
/* Can we optimize saving the TOC in the prologue or
do we need to do it at every call? */
/* Create the call. */
call[0] = gen_rtx_CALL (VOIDmode, gen_rtx_MEM (SImode, func_addr), flag);
if (value != NULL_RTX)
- call[0] = gen_rtx_SET (VOIDmode, value, call[0]);
+ call[0] = gen_rtx_SET (value, call[0]);
n_call = 1;
if (toc_load)
/* Create the call. */
call[0] = gen_rtx_CALL (VOIDmode, gen_rtx_MEM (SImode, func_desc), flag);
if (value != NULL_RTX)
- call[0] = gen_rtx_SET (VOIDmode, value, call[0]);
+ call[0] = gen_rtx_SET (value, call[0]);
call[1] = simple_return_rtx;
{
if (value == 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
+ emit_insn (gen_rtx_SET (dest, const0_rtx));
return;
}
else if (value == mask)
{
if (!rtx_equal_p (dest, op1))
- emit_insn (gen_rtx_SET (VOIDmode, dest, op1));
+ emit_insn (gen_rtx_SET (dest, op1));
return;
}
}
if (value == 0)
{
if (!rtx_equal_p (dest, op1))
- emit_insn (gen_rtx_SET (VOIDmode, dest, op1));
+ emit_insn (gen_rtx_SET (dest, op1));
return;
}
}
if (complement_final_p)
bool_rtx = gen_rtx_NOT (mode, bool_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, dest, bool_rtx));
+ emit_insn (gen_rtx_SET (dest, bool_rtx));
}
/* Split a DImode AND/IOR/XOR with a constant on a 32-bit system. These
new_mem = gen_rtx_UNSPEC (extend_mode, gen_rtvec (1, new_mem),
UNSPEC_FUSION_GPR);
- emit_insn (gen_rtx_SET (VOIDmode, target, new_mem));
+ emit_insn (gen_rtx_SET (target, new_mem));
if (extend == SIGN_EXTEND)
{
rtx sign_reg
= simplify_subreg (target_mode, target, extend_mode, sub_off);
- emit_insn (gen_rtx_SET (VOIDmode, target,
+ emit_insn (gen_rtx_SET (target,
gen_rtx_SIGN_EXTEND (extend_mode, sign_reg)));
}
rtx_insn *insn = insn_entry[i].insn;
rtx body = PATTERN (insn);
rtx src_reg = XEXP (SET_SRC (body), 0);
- rtx copy = gen_rtx_SET (VOIDmode, SET_DEST (body), src_reg);
+ rtx copy = gen_rtx_SET (SET_DEST (body), src_reg);
rtx_insn *new_insn = emit_insn_before (copy, insn);
set_block_for_insn (new_insn, BLOCK_FOR_INSN (insn));
df_insn_rescan (new_insn);
cr0 = gen_rtx_REG (CCmode, CR0_REGNO);
emit_insn (gen_dlmzb (scratch_dlmzb, word1, word2, cr0));
cond = gen_rtx_NE (VOIDmode, cr0, const0_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode,
- pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
cond,
gen_rtx_LABEL_REF
end_label),
pc_rtx)));
emit_insn (gen_addsi3 (scratch_string, scratch_string, GEN_INT (8)));
- emit_jump_insn (gen_rtx_SET (VOIDmode,
- pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_LABEL_REF (VOIDmode, loop_label)));
emit_barrier ();
emit_label (end_label);
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
- = gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno + i),
+ = gen_rtx_SET (gen_rtx_REG (SImode, regno + i),
adjust_address_nv (op1, SImode, i * 4));
}")
op0 = replace_equiv_address (operands[0], to);
XVECEXP (operands[3], 0, 0)
- = gen_rtx_SET (VOIDmode, adjust_address_nv (op0, SImode, 0), operands[1]);
+ = gen_rtx_SET (adjust_address_nv (op0, SImode, 0), operands[1]);
XVECEXP (operands[3], 0, 1) = gen_rtx_CLOBBER (VOIDmode,
gen_rtx_SCRATCH (SImode));
for (i = 1; i < count; i++)
XVECEXP (operands[3], 0, i + 1)
- = gen_rtx_SET (VOIDmode,
- adjust_address_nv (op0, SImode, i * 4),
+ = gen_rtx_SET (adjust_address_nv (op0, SImode, i * 4),
gen_rtx_REG (SImode, regno + i));
}")
operands[3] = gen_frame_mem (Pmode, operands[0]);
operands[4] = gen_frame_mem (Pmode, operands[1]);
p = rtvec_alloc (1);
- RTVEC_ELT (p, 0) = gen_rtx_SET (VOIDmode,
- gen_frame_mem (BLKmode, operands[0]),
+ RTVEC_ELT (p, 0) = gen_rtx_SET (gen_frame_mem (BLKmode, operands[0]),
const0_rtx);
operands[5] = gen_rtx_PARALLEL (VOIDmode, p);
}")
operands[4] = adjust_address_nv (operands[1], Pmode, units_per_word);
operands[5] = gen_frame_mem (Pmode, operands[3]);
p = rtvec_alloc (1);
- RTVEC_ELT (p, 0) = gen_rtx_SET (VOIDmode,
- gen_frame_mem (BLKmode, operands[0]),
+ RTVEC_ELT (p, 0) = gen_rtx_SET (gen_frame_mem (BLKmode, operands[0]),
const0_rtx);
operands[6] = gen_rtx_PARALLEL (VOIDmode, p);
}")
/* We need to make a note that we clobber SPEFSCR. */
rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
- XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
+ XVECEXP (par, 0, 0) = gen_rtx_SET (operands[0],
gen_rtx_PLUS (V2SFmode, operands[1], operands[2]));
XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
emit_insn (par);
/* We need to make a note that we clobber SPEFSCR. */
rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
- XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
+ XVECEXP (par, 0, 0) = gen_rtx_SET (operands[0],
gen_rtx_MINUS (V2SFmode, operands[1], operands[2]));
XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
emit_insn (par);
/* We need to make a note that we clobber SPEFSCR. */
rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
- XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
+ XVECEXP (par, 0, 0) = gen_rtx_SET (operands[0],
gen_rtx_MULT (V2SFmode, operands[1], operands[2]));
XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
emit_insn (par);
/* We need to make a note that we clobber SPEFSCR. */
rtx par = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
- XVECEXP (par, 0, 0) = gen_rtx_SET (VOIDmode, operands[0],
+ XVECEXP (par, 0, 0) = gen_rtx_SET (operands[0],
gen_rtx_DIV (V2SFmode, operands[1], operands[2]));
XVECEXP (par, 0, 1) = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, SPEFSCR_REGNO));
emit_insn (par);
}
x = gen_rtx_VEC_SELECT (<MODE>mode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
}
x = gen_rtx_VEC_SELECT (<MODE>mode, x, gen_rtx_PARALLEL (VOIDmode, v));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
+ emit_insn (gen_rtx_SET (operands[0], x));
DONE;
})
vector = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
XVECEXP (vector, 0, 0) =
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_MINUS (SImode, stack_pointer_rtx,
GEN_INT ((count - 1) * UNITS_PER_WORD)));
for (i = 0; i < count - 1; i++)
XVECEXP (vector, 0, i + 1) =
- gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (SImode,
+ gen_rtx_SET (gen_rtx_MEM (SImode,
gen_rtx_MINUS (SImode, stack_pointer_rtx,
GEN_INT ((i + 1) * UNITS_PER_WORD))),
gen_rtx_REG (SImode, high - i));
as the dwarf2out code cannot be expected to grok
our unspec. */
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (SImode, dest,
- gen_rtx_PLUS (SImode, src, val)));
+ gen_rtx_SET (dest, gen_rtx_PLUS (SImode, src, val)));
return;
}
vector = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
XVECEXP (vector, 0, 0) =
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx, adjust));
for (i = 0; i < count - 2; i++)
XVECEXP (vector, 0, i + 1) =
- gen_rtx_SET (VOIDmode,
- gen_rtx_REG (SImode, low + i),
+ gen_rtx_SET (gen_rtx_REG (SImode, low + i),
gen_rtx_MEM (SImode,
i == 0 ? stack_pointer_rtx
: plus_constant (Pmode, stack_pointer_rtx,
vector = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count));
XVECEXP (vector, 0, 0) =
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
(count - 1) * UNITS_PER_WORD));
for (i = 0; i < count - 1; i++)
XVECEXP (vector, 0, i + 1) =
- gen_rtx_SET (VOIDmode,
- gen_rtx_REG (SImode, low + i),
+ gen_rtx_SET (gen_rtx_REG (SImode, low + i),
gen_rtx_MEM (SImode,
i == 0 ? stack_pointer_rtx
: plus_constant (Pmode, stack_pointer_rtx,
flags = gen_rtx_REG (cc_mode, CC_REG);
x = gen_rtx_COMPARE (cc_mode, c1, c2);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
x = gen_rtx_fmt_ee (cmp1, VOIDmode, flags, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x, label, pc_rtx);
- x = gen_rtx_SET (VOIDmode, pc_rtx, x);
+ x = gen_rtx_SET (pc_rtx, x);
emit_jump_insn (x);
}
flags = gen_rtx_REG (CCmode, CC_REG);
x = gen_rtx_COMPARE (CCmode, operands[2], operands[3]);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
x = gen_rtx_fmt_ee (GET_CODE (operands[1]), SImode, flags, const0_rtx);
- x = gen_rtx_SET (VOIDmode, operands[0], x);
+ x = gen_rtx_SET (operands[0], x);
emit_insn (x);
DONE;
})
flags = gen_rtx_REG (CC_Fmode, CC_REG);
x = gen_rtx_COMPARE (CC_Fmode, operands[2], operands[3]);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
x = gen_rtx_fmt_ee (GET_CODE (operands[1]), SImode, flags, const0_rtx);
- x = gen_rtx_SET (VOIDmode, operands[0], x);
+ x = gen_rtx_SET (operands[0], x);
emit_insn (x);
DONE;
})
flags = gen_rtx_REG (CCmode, CC_REG);
x = gen_rtx_COMPARE (CCmode, operands[3], operands[4]);
- emit_insn (gen_rtx_SET (VOIDmode, flags, x));
+ emit_insn (gen_rtx_SET (flags, x));
cmp_code = GET_CODE (operands[5]);
op0 = operands[0];
x = gen_rtx_fmt_ee (cmp_code, VOIDmode, flags, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (SImode, x, op1, op0);
- emit_insn (gen_rtx_SET (VOIDmode, op0, x));
+ emit_insn (gen_rtx_SET (op0, x));
DONE;
})
flags = gen_rtx_REG (CC_ZSmode, CC_REG);
x = gen_rtx_AND (SImode, operands[2], const1_rtx);
x = gen_rtx_COMPARE (CC_ZSmode, x, const0_rtx);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
/* Emit bmne. */
flags = gen_rtx_REG (CCmode, CC_REG);
x = gen_rtx_COMPARE (CCmode, operands[2], operands[3]);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
operands[4] = gen_rtx_fmt_ee (GET_CODE (operands[4]), SImode,
else
{
cc = gen_rtx_REG (mode, CC_REGNUM);
- emit_insn (gen_rtx_SET (VOIDmode, cc, gen_rtx_COMPARE (mode, op0, op1)));
+ emit_insn (gen_rtx_SET (cc, gen_rtx_COMPARE (mode, op0, op1)));
}
return gen_rtx_fmt_ee (code, VOIDmode, cc, const0_rtx);
if (cond)
target = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, target, pc_rtx);
- insn = gen_rtx_SET (VOIDmode, pc_rtx, target);
+ insn = gen_rtx_SET (pc_rtx, target);
return emit_jump_insn (insn);
}
}
/* Emit the instruction. */
- op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, wmode, src1, src2));
+ op = gen_rtx_SET (dst, gen_rtx_fmt_ee (code, wmode, src1, src2));
clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new_rtx, addr), UNSPEC_TLS_LOAD);
temp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (Pmode, temp, new_rtx));
+ emit_insn (gen_rtx_SET (temp, new_rtx));
}
else
{
new_rtx = gen_const_mem (Pmode, new_rtx);
new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new_rtx, addr), UNSPEC_TLS_LOAD);
temp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (Pmode, temp, new_rtx));
+ emit_insn (gen_rtx_SET (temp, new_rtx));
}
new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
temp = gen_rtx_NE (VOIDmode, ccreg, const0_rtx);
temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
gen_rtx_LABEL_REF (VOIDmode, end_label), pc_rtx);
- temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
+ temp = gen_rtx_SET (pc_rtx, temp);
emit_jump_insn (temp);
s390_load_address (addr0,
if (!register_operand (cmp_op0, cmp_mode))
cmp_op0 = force_reg (cmp_mode, cmp_op0);
- insn = gen_rtx_SET (VOIDmode, gen_rtx_REG (cc_mode, CC_REGNUM),
+ insn = gen_rtx_SET (gen_rtx_REG (cc_mode, CC_REGNUM),
gen_rtx_COMPARE (cc_mode, cmp_op0, cmp_op1));
/* We use insn_invalid_p here to add clobbers if required. */
ret = insn_invalid_p (emit_insn (insn), false);
p = rtvec_alloc (2);
RTVEC_ELT (p, 0) =
- gen_rtx_SET (VOIDmode, dst, op_res);
+ gen_rtx_SET (dst, op_res);
RTVEC_ELT (p, 1) =
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
if (!register_operand (cmp_op0, cmp_mode))
cmp_op0 = force_reg (cmp_mode, cmp_op0);
- insn = gen_rtx_SET (VOIDmode, gen_rtx_REG (cc_mode, CC_REGNUM),
+ insn = gen_rtx_SET (gen_rtx_REG (cc_mode, CC_REGNUM),
gen_rtx_COMPARE (cc_mode, cmp_op0, cmp_op1));
/* We use insn_invalid_p here to add clobbers if required. */
ret = insn_invalid_p (emit_insn (insn), false);
const0_rtx));
p = rtvec_alloc (2);
RTVEC_ELT (p, 0) =
- gen_rtx_SET (VOIDmode, dst, op_res);
+ gen_rtx_SET (dst, op_res);
RTVEC_ELT (p, 1) =
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
if (smode_bsize == bitsize && bitpos == mode_bsize - smode_bsize)
{
op = gen_rtx_STRICT_LOW_PART (VOIDmode, gen_lowpart (smode, dest));
- op = gen_rtx_SET (VOIDmode, op, gen_lowpart (smode, src));
+ op = gen_rtx_SET (op, gen_lowpart (smode, src));
clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clobber)));
return true;
}
op = gen_rtx_ZERO_EXTRACT (mode, dest, op1, op2),
- op = gen_rtx_SET (VOIDmode, op, src);
+ op = gen_rtx_SET (op, src);
if (!TARGET_ZEC12)
{
{
new_literal = 1;
rtx mem = force_const_mem (Pmode, *label);
- rtx_insn *set_insn = emit_insn_before (gen_rtx_SET (Pmode, temp_reg, mem), insn);
+ rtx_insn *set_insn = emit_insn_before (gen_rtx_SET (temp_reg, mem),
+ insn);
INSN_ADDRESSES_NEW (set_insn, -1);
annotate_constant_pool_refs (&PATTERN (set_insn));
UNSPEC_LTREL_OFFSET);
target = gen_rtx_CONST (Pmode, target);
target = force_const_mem (Pmode, target);
- rtx_insn *set_insn = emit_insn_before (gen_rtx_SET (Pmode, temp_reg, target), insn);
+ rtx_insn *set_insn = emit_insn_before (gen_rtx_SET (temp_reg, target),
+ insn);
INSN_ADDRESSES_NEW (set_insn, -1);
annotate_constant_pool_refs (&PATTERN (set_insn));
if (DISP_IN_RANGE (INTVAL (frame_off)))
{
- insn = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ insn = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
frame_off));
insn = emit_insn (insn);
RTX_FRAME_RELATED_P (insn) = 1;
real_frame_off = GEN_INT (-cfun_frame_layout.frame_size);
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
real_frame_off)));
offset += 8;
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (DFmode, addr),
+ gen_rtx_SET (gen_rtx_MEM (DFmode, addr),
gen_rtx_REG (DFmode, i)));
}
}
offset = area_bottom < 0 ? -area_bottom : 0;
frame_off = GEN_INT (cfun_frame_layout.frame_size - offset);
- cfa = gen_rtx_SET (VOIDmode, frame_pointer,
+ cfa = gen_rtx_SET (frame_pointer,
gen_rtx_PLUS (Pmode, frame_pointer, frame_off));
if (DISP_IN_RANGE (INTVAL (frame_off)))
{
- insn = gen_rtx_SET (VOIDmode, frame_pointer,
+ insn = gen_rtx_SET (frame_pointer,
gen_rtx_PLUS (Pmode, frame_pointer, frame_off));
insn = emit_insn (insn);
}
call = gen_rtx_CALL (VOIDmode, addr_location, const0_rtx);
if (result_reg != NULL_RTX)
- call = gen_rtx_SET (VOIDmode, result_reg, call);
+ call = gen_rtx_SET (result_reg, call);
if (retaddr_reg != NULL_RTX)
{
new_label = gen_label_rtx ();
uncond_jump = emit_jump_insn_after (
- gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_SET (pc_rtx,
gen_rtx_LABEL_REF (VOIDmode, code_label)),
insn);
emit_label_after (new_label, uncond_jump);
{
rtx tmp = gen_reg_rtx (SImode);
rtx ext = gen_rtx_SIGN_EXTEND (SImode, operands[1]);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
+ emit_insn (gen_rtx_SET (tmp, ext));
operands[1] = gen_lowpart (HImode, tmp);
}
})
{
rtx tmp = gen_reg_rtx (DImode);
rtx ext = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
- emit_insn (gen_rtx_SET (VOIDmode, tmp, ext));
+ emit_insn (gen_rtx_SET (tmp, ext));
operands[1] = gen_lowpart (QImode, tmp);
}
})
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
- = gen_rtx_SET (VOIDmode, gen_rtx_REG (mode, regno + i),
+ = gen_rtx_SET (gen_rtx_REG (mode, regno + i),
change_address (operands[1], mode,
plus_constant (Pmode, from,
off + i * GET_MODE_SIZE (mode))));
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
- = gen_rtx_SET (VOIDmode,
- change_address (operands[0], mode,
+ = gen_rtx_SET (change_address (operands[0], mode,
plus_constant (Pmode, to,
off + i * GET_MODE_SIZE (mode))),
gen_rtx_REG (mode, regno + i));
branch_expander = gen_branch_false;
default: ;
}
- emit_insn (gen_rtx_SET (VOIDmode, get_t_reg_rtx (),
+ emit_insn (gen_rtx_SET (get_t_reg_rtx (),
gen_rtx_fmt_ee (comparison, SImode,
operands[1], operands[2])));
rtx_insn *jump = emit_jump_insn (branch_expander (operands[3]));
|| (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
op1 = force_reg (mode, op1);
- sh_emit_set_t_insn (gen_rtx_SET (VOIDmode, t_reg,
+ sh_emit_set_t_insn (gen_rtx_SET (t_reg,
gen_rtx_fmt_ee (code, SImode, op0, op1)),
mode);
}
gcc_unreachable ();
}
- insn = gen_rtx_SET (VOIDmode,
- get_t_reg_rtx (),
+ insn = gen_rtx_SET (get_t_reg_rtx (),
gen_rtx_fmt_ee (branch_code, SImode, op0, op1));
sh_emit_set_t_insn (insn, mode);
/* This can happen even when optimizing, if there were subregs before
reload. Don't output a nop here, as this is never optimized away;
use a no-op move instead. */
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[0]));
+ emit_insn (gen_rtx_SET (operands[0], operands[0]));
return;
}
newsrc = gen_rtx_LABEL_REF (VOIDmode, lab);
newsrc = gen_const_mem (mode, newsrc);
}
- *patp = gen_rtx_SET (VOIDmode, dst, newsrc);
+ *patp = gen_rtx_SET (dst, newsrc);
INSN_CODE (scan) = -1;
}
}
insn = emit_fn (GEN_ADD3 (reg, reg, const_reg));
}
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, reg,
- gen_rtx_PLUS (SImode, reg,
- GEN_INT (size))));
+ gen_rtx_SET (reg, gen_rtx_PLUS (SImode, reg,
+ GEN_INT (size))));
}
}
}
: SET_DEST (PATTERN (x)));
add_reg_note (x, REG_CFA_RESTORE, reg);
add_reg_note (x, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (SImode, sp_reg,
+ gen_rtx_SET (sp_reg,
plus_constant (SImode, sp_reg,
GET_MODE_SIZE (GET_MODE (reg)))));
add_reg_note (x, REG_INC, gen_rtx_REG (SImode, STACK_POINTER_REGNUM));
{
mem = gen_rtx_MEM (SImode, plus_constant (Pmode, sp_reg, i * 4));
reg = gen_rtx_REG (SImode, i);
- add_reg_note (x, REG_CFA_OFFSET, gen_rtx_SET (SImode, mem, reg));
+ add_reg_note (x, REG_CFA_OFFSET, gen_rtx_SET (mem, reg));
}
- set = gen_rtx_SET (SImode, sp_reg,
- plus_constant (Pmode, sp_reg, - 32));
+ set = gen_rtx_SET (sp_reg, plus_constant (Pmode, sp_reg, - 32));
add_reg_note (x, REG_CFA_ADJUST_CFA, set);
emit_insn (gen_blockage ());
}
{
rtx set;
- set = gen_rtx_SET (VOIDmode, mem_rtx, orig_reg_rtx);
+ set = gen_rtx_SET (mem_rtx, orig_reg_rtx);
add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
}
stack_pointer_rtx,
GEN_INT (offset)));
- set = gen_rtx_SET (VOIDmode, mem_rtx, reg_rtx);
+ set = gen_rtx_SET (mem_rtx, reg_rtx);
add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
}
}
have to capture its current state and restore it afterwards. */
recog_data_d prev_recog_data = recog_data;
- rtx_insn* i = make_insn_raw (gen_rtx_SET (VOIDmode, get_t_reg_rtx (), op));
+ rtx_insn* i = make_insn_raw (gen_rtx_SET (get_t_reg_rtx (), op));
SET_PREV_INSN (i) = NULL;
SET_NEXT_INSN (i) = NULL;
scope_counter in_treg_set_expr (sh_recog_treg_set_expr_reent_count);
- rtx_insn* i = make_insn_raw (gen_rtx_SET (VOIDmode, get_t_reg_rtx (), x));
+ rtx_insn* i = make_insn_raw (gen_rtx_SET (get_t_reg_rtx (), x));
SET_PREV_INSN (i) = NULL;
SET_NEXT_INSN (i) = NULL;
mach as operand 2, so let the instructions that
preserve r0 be optimized away if r0 turns out to be
dead. */
- emit_insn_before (gen_rtx_SET (SImode, tmp, r0), insn);
+ emit_insn_before (gen_rtx_SET (tmp, r0), insn);
emit_move_insn (r0, tmp);
break;
}
start_sequence ();
- emit_insn (gen_rtx_SET (VOIDmode, m_ccreg,
- gen_rtx_fmt_ee (EQ, SImode, src_reg, const0_rtx)));
+ emit_insn (gen_rtx_SET (m_ccreg, gen_rtx_fmt_ee (EQ, SImode,
+ src_reg, const0_rtx)));
if (GET_MODE (dst_reg) == SImode)
emit_move_insn (dst_reg, m_ccreg);
sh_treg_combine::make_inv_ccreg_insn (void) const
{
start_sequence ();
- rtx_insn *i = emit_insn (gen_rtx_SET (VOIDmode, m_ccreg,
+ rtx_insn *i = emit_insn (gen_rtx_SET (m_ccreg,
gen_rtx_fmt_ee (XOR, GET_MODE (m_ccreg),
m_ccreg, const1_rtx)));
end_sequence ();
/* Emit them as real moves instead of a HIGH/LO_SUM,
this way CSE can see everything and reuse intermediate
values if it wants. */
- emit_insn (gen_rtx_SET (VOIDmode, temp,
- GEN_INT (INTVAL (op1)
- & ~(HOST_WIDE_INT)0x3ff)));
+ emit_insn (gen_rtx_SET (temp, GEN_INT (INTVAL (op1)
+ & ~(HOST_WIDE_INT) 0x3ff)));
- emit_insn (gen_rtx_SET (VOIDmode,
- op0,
+ emit_insn (gen_rtx_SET (op0,
gen_rtx_IOR (mode, temp,
GEN_INT (INTVAL (op1) & 0x3ff))));
}
else
{
/* A symbol, emit in the traditional way. */
- emit_insn (gen_rtx_SET (VOIDmode, temp,
- gen_rtx_HIGH (mode, op1)));
- emit_insn (gen_rtx_SET (VOIDmode,
- op0, gen_rtx_LO_SUM (mode, temp, op1)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_HIGH (mode, op1)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_LO_SUM (mode, temp, op1)));
}
}
else
temp1 = gen_reg_rtx (DImode);
- emit_insn (gen_rtx_SET (VOIDmode, temp1, gen_rtx_HIGH (DImode, op1)));
- emit_insn (gen_rtx_SET (VOIDmode, op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
+ emit_insn (gen_rtx_SET (temp1, gen_rtx_HIGH (DImode, op1)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
break;
case CM_MEDMID:
emit_insn (gen_seth44 (temp1, op1));
emit_insn (gen_setm44 (temp2, temp1, op1));
- emit_insn (gen_rtx_SET (VOIDmode, temp3,
+ emit_insn (gen_rtx_SET (temp3,
gen_rtx_ASHIFT (DImode, temp2, GEN_INT (12))));
emit_insn (gen_setl44 (op0, temp3, op1));
break;
emit_insn (gen_sethh (temp1, op1));
emit_insn (gen_setlm (temp2, op1));
emit_insn (gen_sethm (temp3, temp1, op1));
- emit_insn (gen_rtx_SET (VOIDmode, temp4,
+ emit_insn (gen_rtx_SET (temp4,
gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
- emit_insn (gen_rtx_SET (VOIDmode, temp5,
- gen_rtx_PLUS (DImode, temp4, temp2)));
+ emit_insn (gen_rtx_SET (temp5, gen_rtx_PLUS (DImode, temp4, temp2)));
emit_insn (gen_setlo (op0, temp5, op1));
break;
emit_insn (gen_embmedany_textuhi (temp1, op1));
emit_insn (gen_embmedany_texthi (temp2, op1));
emit_insn (gen_embmedany_textulo (temp3, temp1, op1));
- emit_insn (gen_rtx_SET (VOIDmode, temp4,
+ emit_insn (gen_rtx_SET (temp4,
gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
- emit_insn (gen_rtx_SET (VOIDmode, temp5,
- gen_rtx_PLUS (DImode, temp4, temp2)));
+ emit_insn (gen_rtx_SET (temp5, gen_rtx_PLUS (DImode, temp4, temp2)));
emit_insn (gen_embmedany_textlo (op0, temp5, op1));
}
break;
static rtx
gen_safe_HIGH64 (rtx dest, HOST_WIDE_INT val)
{
- return gen_rtx_SET (VOIDmode, dest, GEN_INT (val & ~(HOST_WIDE_INT)0x3ff));
+ return gen_rtx_SET (dest, GEN_INT (val & ~(HOST_WIDE_INT)0x3ff));
}
static rtx
gen_safe_SET64 (rtx dest, HOST_WIDE_INT val)
{
- return gen_rtx_SET (VOIDmode, dest, GEN_INT (val));
+ return gen_rtx_SET (dest, GEN_INT (val));
}
static rtx
emit_insn (gen_safe_HIGH64 (temp, high_bits));
if (!is_neg)
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_safe_OR64 (temp, (high_bits & 0x3ff))));
+ emit_insn (gen_rtx_SET (op0, gen_safe_OR64 (temp, (high_bits & 0x3ff))));
}
else
{
such as ANDN later on and substitute. */
if ((low_bits & 0x3ff) == 0x3ff)
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_NOT (DImode, temp)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_NOT (DImode, temp)));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
+ emit_insn (gen_rtx_SET (op0,
gen_safe_XOR64 (temp,
(-(HOST_WIDE_INT)0x400
| (low_bits & 0x3ff)))));
{
emit_insn (gen_safe_HIGH64 (temp, high_bits));
if ((high_bits & ~0xfffffc00) != 0)
- emit_insn (gen_rtx_SET (VOIDmode, op0,
+ emit_insn (gen_rtx_SET (op0,
gen_safe_OR64 (temp, (high_bits & 0x3ff))));
else
temp2 = temp;
}
/* Now shift it up into place. */
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_ASHIFT (DImode, temp2,
- GEN_INT (shift_count))));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_ASHIFT (DImode, temp2,
+ GEN_INT (shift_count))));
/* If there is a low immediate part piece, finish up by
putting that in as well. */
if (low_immediate != 0)
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_safe_OR64 (op0, low_immediate)));
+ emit_insn (gen_rtx_SET (op0, gen_safe_OR64 (op0, low_immediate)));
}
static void sparc_emit_set_const64_longway (rtx, rtx, unsigned HOST_WIDE_INT,
{
emit_insn (gen_safe_HIGH64 (temp, high_bits));
if ((high_bits & ~0xfffffc00) != 0)
- emit_insn (gen_rtx_SET (VOIDmode,
- sub_temp,
+ emit_insn (gen_rtx_SET (sub_temp,
gen_safe_OR64 (temp, (high_bits & 0x3ff))));
else
sub_temp = temp;
rtx temp3 = gen_reg_rtx (DImode);
rtx temp4 = gen_reg_rtx (DImode);
- emit_insn (gen_rtx_SET (VOIDmode, temp4,
- gen_rtx_ASHIFT (DImode, sub_temp,
- GEN_INT (32))));
+ emit_insn (gen_rtx_SET (temp4, gen_rtx_ASHIFT (DImode, sub_temp,
+ GEN_INT (32))));
emit_insn (gen_safe_HIGH64 (temp2, low_bits));
if ((low_bits & ~0xfffffc00) != 0)
{
- emit_insn (gen_rtx_SET (VOIDmode, temp3,
+ emit_insn (gen_rtx_SET (temp3,
gen_safe_OR64 (temp2, (low_bits & 0x3ff))));
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_PLUS (DImode, temp4, temp3)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_PLUS (DImode, temp4, temp3)));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_PLUS (DImode, temp4, temp2)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_PLUS (DImode, temp4, temp2)));
}
}
else
avoid emitting truly stupid code. */
if (low1 != const0_rtx)
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_ASHIFT (DImode, sub_temp,
- GEN_INT (to_shift))));
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_IOR (DImode, op0, low1)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_ASHIFT (DImode, sub_temp,
+ GEN_INT (to_shift))));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_IOR (DImode, op0, low1)));
sub_temp = op0;
to_shift = 12;
}
}
if (low2 != const0_rtx)
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_ASHIFT (DImode, sub_temp,
- GEN_INT (to_shift))));
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_IOR (DImode, op0, low2)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_ASHIFT (DImode, sub_temp,
+ GEN_INT (to_shift))));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_IOR (DImode, op0, low2)));
sub_temp = op0;
to_shift = 8;
}
{
to_shift += 8;
}
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_ASHIFT (DImode, sub_temp,
- GEN_INT (to_shift))));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_ASHIFT (DImode, sub_temp,
+ GEN_INT (to_shift))));
if (low3 != const0_rtx)
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_IOR (DImode, op0, low3)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_IOR (DImode, op0, low3)));
/* phew... */
}
}
emit_insn (gen_safe_SET64 (temp, the_const));
if (shift > 0)
- emit_insn (gen_rtx_SET (VOIDmode,
- op0,
- gen_rtx_ASHIFT (DImode,
- temp,
- GEN_INT (shift))));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_ASHIFT (DImode, temp,
+ GEN_INT (shift))));
else if (shift < 0)
- emit_insn (gen_rtx_SET (VOIDmode,
- op0,
- gen_rtx_LSHIFTRT (DImode,
- temp,
- GEN_INT (-shift))));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_LSHIFTRT (DImode, temp,
+ GEN_INT (-shift))));
return;
}
/* If lowest_bit_set == 10 then a sethi alone could have done it. */
if (lowest_bit_set < 10)
- emit_insn (gen_rtx_SET (VOIDmode,
- op0,
+ emit_insn (gen_rtx_SET (op0,
gen_rtx_LSHIFTRT (DImode, temp,
GEN_INT (10 - lowest_bit_set))));
else if (lowest_bit_set > 10)
- emit_insn (gen_rtx_SET (VOIDmode,
- op0,
+ emit_insn (gen_rtx_SET (op0,
gen_rtx_ASHIFT (DImode, temp,
GEN_INT (lowest_bit_set - 10))));
return;
such as ANDN later on and substitute. */
if (trailing_bits == 0x3ff)
{
- emit_insn (gen_rtx_SET (VOIDmode, op0,
- gen_rtx_NOT (DImode, temp)));
+ emit_insn (gen_rtx_SET (op0, gen_rtx_NOT (DImode, temp)));
}
else
{
- emit_insn (gen_rtx_SET (VOIDmode,
- op0,
+ emit_insn (gen_rtx_SET (op0,
gen_safe_XOR64 (temp,
(-0x400 | trailing_bits))));
}
/* We shouldn't get there for TFmode if !TARGET_HARD_QUAD. If we do, this
will only result in an unrecognizable insn so no point in asserting. */
- emit_insn (gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_COMPARE (mode, x, y)));
return cc_reg;
}
&& GET_MODE (dest) == DImode
&& rtx_equal_p (op0, dest))
{
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
gen_rtx_IF_THEN_ELSE (DImode,
gen_rtx_fmt_ee (compare_code, DImode,
op0, const0_rtx),
emit_move_insn (op0, x);
}
- emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
+ emit_insn (gen_rtx_SET (dest, const0_rtx));
if (GET_MODE (op0) != DImode)
{
temp = gen_reg_rtx (DImode);
}
else
temp = op0;
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest,
gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
gen_rtx_fmt_ee (compare_code, DImode,
temp, const0_rtx),
gcc_assert (GET_MODE (x) != CC_NOOVmode
&& GET_MODE (x) != CCX_NOOVmode);
- emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
- emit_insn (gen_rtx_SET (VOIDmode, dest,
+ emit_insn (gen_rtx_SET (dest, const0_rtx));
+ emit_insn (gen_rtx_SET (dest,
gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
gen_rtx_fmt_ee (compare_code,
GET_MODE (x), x, y),
if (code == LTU
|| (!TARGET_VIS3 && code == GEU))
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
gen_compare_reg_1 (code, x, y),
const0_rtx)));
static void
emit_v9_brxx_insn (enum rtx_code code, rtx op0, rtx label)
{
- emit_jump_insn (gen_rtx_SET (VOIDmode,
- pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
gen_rtx_fmt_ee (code, GET_MODE (op0),
op0, const0_rtx),
gen_rtx_LABEL_REF (VOIDmode, label),
pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, if_then_else));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, if_then_else));
}
void
else
dest = gen_reg_rtx (GET_MODE (operands[0]));
- emit_insn (gen_rtx_SET (VOIDmode, dest, op));
+ emit_insn (gen_rtx_SET (dest, op));
if (dest != operands[0])
emit_move_insn (operands[0], dest);
if (size <= PROBE_INTERVAL)
{
emit_move_insn (g1, GEN_INT (first));
- emit_insn (gen_rtx_SET (VOIDmode, g1,
+ emit_insn (gen_rtx_SET (g1,
gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
emit_stack_probe (plus_constant (Pmode, g1, -size));
}
HOST_WIDE_INT i;
emit_move_insn (g1, GEN_INT (first + PROBE_INTERVAL));
- emit_insn (gen_rtx_SET (VOIDmode, g1,
+ emit_insn (gen_rtx_SET (g1,
gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
emit_stack_probe (g1);
generate any code. Then probe at FIRST + SIZE. */
for (i = 2 * PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
{
- emit_insn (gen_rtx_SET (VOIDmode, g1,
+ emit_insn (gen_rtx_SET (g1,
plus_constant (Pmode, g1, -PROBE_INTERVAL)));
emit_stack_probe (g1);
}
/* Step 2: compute initial and final value of the loop counter. */
/* TEST_ADDR = SP + FIRST. */
- emit_insn (gen_rtx_SET (VOIDmode, g1,
+ emit_insn (gen_rtx_SET (g1,
gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
/* LAST_ADDR = SP + FIRST + ROUNDED_SIZE. */
- emit_insn (gen_rtx_SET (VOIDmode, g4, gen_rtx_MINUS (Pmode, g1, g4)));
+ emit_insn (gen_rtx_SET (g4, gen_rtx_MINUS (Pmode, g1, g4)));
/* Step 3: the loop
rtx set1, set2;
mem = gen_frame_mem (SImode, plus_constant (Pmode, base,
offset));
- set1 = gen_rtx_SET (VOIDmode, mem,
- gen_rtx_REG (SImode, regno));
+ set1 = gen_rtx_SET (mem, gen_rtx_REG (SImode, regno));
RTX_FRAME_RELATED_P (set1) = 1;
mem
= gen_frame_mem (SImode, plus_constant (Pmode, base,
offset + 4));
- set2 = gen_rtx_SET (VOIDmode, mem,
- gen_rtx_REG (SImode, regno + 1));
+ set2 = gen_rtx_SET (mem, gen_rtx_REG (SImode, regno + 1));
RTX_FRAME_RELATED_P (set2) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
gen_rtx_PARALLEL (VOIDmode,
lose (the result will be clobbered). */
rtx new_base = gen_rtx_REG (Pmode, 1);
emit_move_insn (new_base, GEN_INT (offset));
- emit_insn (gen_rtx_SET (VOIDmode,
- new_base, gen_rtx_PLUS (Pmode, base, new_base)));
+ emit_insn (gen_rtx_SET (new_base, gen_rtx_PLUS (Pmode, base, new_base)));
return new_base;
}
/* The incoming return address (%o7) is saved in %i7. */
add_reg_note (insn, REG_CFA_REGISTER,
- gen_rtx_SET (VOIDmode,
- gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM),
+ gen_rtx_SET (gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM),
gen_rtx_REG (Pmode,
INCOMING_RETURN_ADDR_REGNUM)));
static rtx
gen_stack_pointer_inc (rtx increment)
{
- return gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ return gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode,
stack_pointer_rtx,
increment));
if (frame_pointer_needed)
{
- insn = emit_insn (gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
+ insn = emit_insn (gen_rtx_SET (hard_frame_pointer_rtx,
gen_rtx_MINUS (Pmode,
stack_pointer_rtx,
size_rtx)));
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
+ gen_rtx_SET (hard_frame_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
size)));
}
insn = emit_move_insn (i7, o7);
RTX_FRAME_RELATED_P (insn) = 1;
- add_reg_note (insn, REG_CFA_REGISTER,
- gen_rtx_SET (VOIDmode, i7, o7));
+ add_reg_note (insn, REG_CFA_REGISTER, gen_rtx_SET (i7, o7));
/* Prevent this instruction from ever being considered dead,
even if this function has no epilogue. */
emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
- emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
+ emit_insn (gen_rtx_SET (out, gen_rtx_FLOAT (mode, in)));
emit_jump_insn (gen_jump (donelab));
emit_barrier ();
emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
emit_insn (gen_anddi3 (i1, in, const1_rtx));
emit_insn (gen_iordi3 (i0, i0, i1));
- emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
- emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
+ emit_insn (gen_rtx_SET (f0, gen_rtx_FLOAT (mode, i0)));
+ emit_insn (gen_rtx_SET (out, gen_rtx_PLUS (mode, f0, f0)));
emit_label (donelab);
}
REAL_VALUE_ATOF ("9223372036854775808.0", mode), mode));
emit_cmp_and_jump_insns (in, limit, GE, NULL_RTX, mode, 0, neglab);
- emit_insn (gen_rtx_SET (VOIDmode,
- out,
+ emit_insn (gen_rtx_SET (out,
gen_rtx_FIX (DImode, gen_rtx_FIX (mode, in))));
emit_jump_insn (gen_jump (donelab));
emit_barrier ();
emit_label (neglab);
- emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_MINUS (mode, in, limit)));
- emit_insn (gen_rtx_SET (VOIDmode,
- i0,
+ emit_insn (gen_rtx_SET (f0, gen_rtx_MINUS (mode, in, limit)));
+ emit_insn (gen_rtx_SET (i0,
gen_rtx_FIX (DImode, gen_rtx_FIX (mode, f0))));
emit_insn (gen_movdi (i1, const1_rtx));
emit_insn (gen_ashldi3 (i1, i1, GEN_INT (63)));
SPARC_STACK_BIAS + offset));
emit_insn (gen_stack_pointer_inc (GEN_INT (-size)));
- emit_insn (gen_rtx_SET (VOIDmode, slot, reg));
+ emit_insn (gen_rtx_SET (slot, reg));
if (reg2)
- emit_insn (gen_rtx_SET (VOIDmode,
- adjust_address (slot, word_mode, UNITS_PER_WORD),
+ emit_insn (gen_rtx_SET (adjust_address (slot, word_mode, UNITS_PER_WORD),
reg2));
emit_insn (seq);
if (reg2)
- emit_insn (gen_rtx_SET (VOIDmode,
- reg2,
+ emit_insn (gen_rtx_SET (reg2,
adjust_address (slot, word_mode, UNITS_PER_WORD)));
- emit_insn (gen_rtx_SET (VOIDmode, reg, slot));
+ emit_insn (gen_rtx_SET (reg, slot));
emit_insn (gen_stack_pointer_inc (GEN_INT (size)));
}
}
else if (TARGET_ARCH32)
{
- emit_insn (gen_rtx_SET (VOIDmode,
- scratch,
+ emit_insn (gen_rtx_SET (scratch,
gen_rtx_HIGH (SImode, funexp)));
- emit_insn (gen_rtx_SET (VOIDmode,
- scratch,
+ emit_insn (gen_rtx_SET (scratch,
gen_rtx_LO_SUM (SImode, scratch, funexp)));
}
else /* TARGET_ARCH64 */
rtx resv = gen_reg_rtx (SImode);
rtx memsi, val, mask, cc;
- emit_insn (gen_rtx_SET (VOIDmode, addr,
- gen_rtx_AND (Pmode, addr1, GEN_INT (-4))));
+ emit_insn (gen_rtx_SET (addr, gen_rtx_AND (Pmode, addr1, GEN_INT (-4))));
if (Pmode != SImode)
addr1 = gen_lowpart (SImode, addr1);
- emit_insn (gen_rtx_SET (VOIDmode, off,
- gen_rtx_AND (SImode, addr1, GEN_INT (3))));
+ emit_insn (gen_rtx_SET (off, gen_rtx_AND (SImode, addr1, GEN_INT (3))));
memsi = gen_rtx_MEM (SImode, addr);
set_mem_alias_set (memsi, ALIAS_SET_MEMORY_BARRIER);
val = copy_to_reg (memsi);
- emit_insn (gen_rtx_SET (VOIDmode, off,
+ emit_insn (gen_rtx_SET (off,
gen_rtx_XOR (SImode, off,
GEN_INT (GET_MODE (mem) == QImode
? 3 : 2))));
- emit_insn (gen_rtx_SET (VOIDmode, off,
- gen_rtx_ASHIFT (SImode, off, GEN_INT (3))));
+ emit_insn (gen_rtx_SET (off, gen_rtx_ASHIFT (SImode, off, GEN_INT (3))));
if (GET_MODE (mem) == QImode)
mask = force_reg (SImode, GEN_INT (0xff));
else
mask = force_reg (SImode, GEN_INT (0xffff));
- emit_insn (gen_rtx_SET (VOIDmode, mask,
- gen_rtx_ASHIFT (SImode, mask, off)));
+ emit_insn (gen_rtx_SET (mask, gen_rtx_ASHIFT (SImode, mask, off)));
- emit_insn (gen_rtx_SET (VOIDmode, val,
+ emit_insn (gen_rtx_SET (val,
gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
val)));
oldval = gen_lowpart (SImode, oldval);
- emit_insn (gen_rtx_SET (VOIDmode, oldv,
- gen_rtx_ASHIFT (SImode, oldval, off)));
+ emit_insn (gen_rtx_SET (oldv, gen_rtx_ASHIFT (SImode, oldval, off)));
newval = gen_lowpart_common (SImode, newval);
- emit_insn (gen_rtx_SET (VOIDmode, newv,
- gen_rtx_ASHIFT (SImode, newval, off)));
+ emit_insn (gen_rtx_SET (newv, gen_rtx_ASHIFT (SImode, newval, off)));
- emit_insn (gen_rtx_SET (VOIDmode, oldv,
- gen_rtx_AND (SImode, oldv, mask)));
+ emit_insn (gen_rtx_SET (oldv, gen_rtx_AND (SImode, oldv, mask)));
- emit_insn (gen_rtx_SET (VOIDmode, newv,
- gen_rtx_AND (SImode, newv, mask)));
+ emit_insn (gen_rtx_SET (newv, gen_rtx_AND (SImode, newv, mask)));
rtx_code_label *end_label = gen_label_rtx ();
rtx_code_label *loop_label = gen_label_rtx ();
emit_label (loop_label);
- emit_insn (gen_rtx_SET (VOIDmode, oldvalue,
- gen_rtx_IOR (SImode, oldv, val)));
+ emit_insn (gen_rtx_SET (oldvalue, gen_rtx_IOR (SImode, oldv, val)));
- emit_insn (gen_rtx_SET (VOIDmode, newvalue,
- gen_rtx_IOR (SImode, newv, val)));
+ emit_insn (gen_rtx_SET (newvalue, gen_rtx_IOR (SImode, newv, val)));
emit_move_insn (bool_result, const1_rtx);
emit_cmp_and_jump_insns (res, oldvalue, EQ, NULL, SImode, 0, end_label);
- emit_insn (gen_rtx_SET (VOIDmode, resv,
+ emit_insn (gen_rtx_SET (resv,
gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
res)));
emit_move_insn (bool_result, const0_rtx);
cc = gen_compare_reg_1 (NE, resv, val);
- emit_insn (gen_rtx_SET (VOIDmode, val, resv));
+ emit_insn (gen_rtx_SET (val, resv));
/* Use cbranchcc4 to separate the compare and branch! */
emit_jump_insn (gen_cbranchcc4 (gen_rtx_NE (VOIDmode, cc, const0_rtx),
emit_label (end_label);
- emit_insn (gen_rtx_SET (VOIDmode, res,
- gen_rtx_AND (SImode, res, mask)));
+ emit_insn (gen_rtx_SET (res, gen_rtx_AND (SImode, res, mask)));
- emit_insn (gen_rtx_SET (VOIDmode, res,
- gen_rtx_LSHIFTRT (SImode, res, off)));
+ emit_insn (gen_rtx_SET (res, gen_rtx_LSHIFTRT (SImode, res, off)));
emit_move_insn (result, gen_lowpart (GET_MODE (result), res));
}
cmp = gen_rtx_fmt_ee (rc, GET_MODE (cc_reg), cc_reg, const0_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, dst,
+ emit_insn (gen_rtx_SET (dst,
gen_rtx_IF_THEN_ELSE (mode, cmp, operands[2], dst)));
if (dst != operands[0])
gen_rtvec (3, operands[1], operands[2], gsr),
UNSPEC_BSHUFFLE);
- emit_insn (gen_rtx_SET (VOIDmode, mask, fcmp));
- emit_insn (gen_rtx_SET (VOIDmode, gsr, cmask));
+ emit_insn (gen_rtx_SET (mask, fcmp));
+ emit_insn (gen_rtx_SET (gsr, cmask));
- emit_insn (gen_rtx_SET (VOIDmode, operands[0], bshuf));
+ emit_insn (gen_rtx_SET (operands[0], bshuf));
}
/* On sparc, any mode which naturally allocates into the float
if (! TARGET_ARCH64)
{
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2,
- gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_SET (operands[0],
gen_rtx_PLUS (DImode, operands[1],
operands[2])),
gen_rtx_CLOBBER (VOIDmode,
if (! TARGET_ARCH64)
{
emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2,
- gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_SET (operands[0],
gen_rtx_MINUS (DImode, operands[1],
operands[2])),
gen_rtx_CLOBBER (VOIDmode,
emit_insn (gen_rtx_PARALLEL
(VOIDmode,
gen_rtvec (2,
- gen_rtx_SET (VOIDmode, operand0,
+ gen_rtx_SET (operand0,
gen_rtx_NEG (DImode, operand1)),
gen_rtx_CLOBBER (VOIDmode,
gen_rtx_REG (CCmode,
(gen_rtx_PARALLEL
(VOIDmode,
gen_rtvec (3,
- gen_rtx_SET (VOIDmode, pc_rtx, XEXP (operands[0], 0)),
+ gen_rtx_SET (pc_rtx, XEXP (operands[0], 0)),
operands[3],
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)))));
else
(gen_rtx_PARALLEL
(VOIDmode,
gen_rtvec (2,
- gen_rtx_SET (VOIDmode, pc_rtx, XEXP (operands[0], 0)),
+ gen_rtx_SET (pc_rtx, XEXP (operands[0], 0)),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)))));
goto finish_call;
}
fn_rtx = operands[1];
vec = gen_rtvec (2,
- gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_SET (operands[0],
gen_rtx_CALL (VOIDmode, fn_rtx, const0_rtx)),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)));
gcc_assert (REG_P (r) && SCALAR_INT_MODE_P (GET_MODE (r)));
s0 = gen_reg_rtx (TImode);
if (GET_MODE_SIZE (GET_MODE (r)) < GET_MODE_SIZE (TImode))
- emit_insn (gen_rtx_SET (VOIDmode, s0, gen_rtx_ZERO_EXTEND (TImode, r)));
+ emit_insn (gen_rtx_SET (s0, gen_rtx_ZERO_EXTEND (TImode, r)));
else
emit_move_insn (s0, src);
}
bcomp = gen_rtx_NE (comp_mode, compare_result, const0_rtx);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
}
{
rtx target = operands[0];
if (reverse_test)
- emit_insn (gen_rtx_SET (VOIDmode, compare_result,
+ emit_insn (gen_rtx_SET (compare_result,
gen_rtx_NOT (comp_mode, compare_result)));
if (GET_MODE (target) == SImode && GET_MODE (compare_result) == HImode)
emit_insn (gen_extendhisi2 (target, compare_result));
hi = array_to_constant (imode, arrhi);
lo = array_to_constant (imode, arrlo);
emit_move_insn (temp, hi);
- emit_insn (gen_rtx_SET
- (VOIDmode, to, gen_rtx_IOR (imode, temp, lo)));
+ emit_insn (gen_rtx_SET (to, gen_rtx_IOR (imode, temp, lo)));
return 1;
}
case IC_FSMBI2:
reg_fsmbi = array_to_constant (imode, arr_fsmbi);
reg_and = array_to_constant (imode, arr_andbi);
emit_move_insn (to, reg_fsmbi);
- emit_insn (gen_rtx_SET
- (VOIDmode, to, gen_rtx_AND (imode, to, reg_and)));
+ emit_insn (gen_rtx_SET (to, gen_rtx_AND (imode, to, reg_and)));
return 1;
}
case IC_POOL:
hit_label = gen_label_rtx ();
hit_ref = gen_rtx_LABEL_REF (VOIDmode, hit_label);
bcomp = gen_rtx_NE (SImode, tag_eq_pack_si, const0_rtx);
- insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ insn = emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
hit_ref, pc_rtx)));
/* Say that this branch is very likely to happen. */
rtx reg;
gcc_assert (GET_MODE (src) == TImode);
reg = int_mode != mode ? gen_reg_rtx (int_mode) : dst;
- emit_insn (gen_rtx_SET (VOIDmode, reg,
+ emit_insn (gen_rtx_SET (reg,
gen_rtx_TRUNCATE (int_mode,
gen_rtx_LSHIFTRT (TImode, src,
GEN_INT (int_mode == DImode ? 64 : 96)))));
/* negate addr */
op = gen_reg_rtx (GET_MODE (addr));
- emit_insn (gen_rtx_SET (VOIDmode, op,
- gen_rtx_NEG (GET_MODE (addr), addr)));
+ emit_insn (gen_rtx_SET (op, gen_rtx_NEG (GET_MODE (addr), addr)));
op = gen_rtx_MEM (mode, op);
pat = GEN_FCN (icode) (target, op);
(unspec [(match_operand 1 "spu_reg_operand" "r")] UNSPEC_EXTEND_CMP))]
""
{
- emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ emit_insn (gen_rtx_SET (operands[0],
gen_rtx_UNSPEC (GET_MODE (operands[0]),
gen_rtvec (1, operands[1]),
UNSPEC_EXTEND_CMP)));
emit_move_insn (s0, gen_rtx_PLUS (SImode, s0, GEN_INT (-1)));
bcomp = gen_rtx_NE(SImode, s0, const0_rtx);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands [1]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[2]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
- gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
- loc_ref, pc_rtx)));
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
+ gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
+ loc_ref, pc_rtx)));
DONE;
})
condition_rtx = gen_rtx_fmt_ee (code, mode, op0, op1);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, loc);
- branch = gen_rtx_SET (VOIDmode, pc_rtx,
+ branch = gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, condition_rtx,
loc_ref, pc_rtx));
{
rtx sub;
#if 0
- sub = gen_rtx_SET (VOIDmode, op0, gen_rtx_MINUS (SImode, op0, op1));
+ sub = gen_rtx_SET (op0, gen_rtx_MINUS (SImode, op0, op1));
#else
sub = gen_rtx_CLOBBER (SImode, op0);
#endif
gcc_assert (GET_CODE (w_src) != SUBREG
&& GET_CODE (w_dest) != SUBREG);
- insn = emit_insn (gen_rtx_SET (VOIDmode, w_dest, w_src));
+ insn = emit_insn (gen_rtx_SET (w_dest, w_src));
if (auto_inc_reg_rtx)
REG_NOTES (insn) = alloc_EXPR_LIST (REG_INC,
auto_inc_reg_rtx,
rtx pmv = XEXP (dest, 0);
rtx dest_reg = XEXP (pmv, 0);
rtx dest_mod = XEXP (pmv, 1);
- rtx set = gen_rtx_SET (Pmode, dest_reg, dest_mod);
+ rtx set = gen_rtx_SET (dest_reg, dest_mod);
rtx clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (BImode, CARRY_REGNUM));
dest = gen_rtx_MEM (mode, dest_reg);
rtx pmv = XEXP (src, 0);
rtx src_reg = XEXP (pmv, 0);
rtx src_mod = XEXP (pmv, 1);
- rtx set = gen_rtx_SET (Pmode, src_reg, src_mod);
+ rtx set = gen_rtx_SET (src_reg, src_mod);
rtx clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (BImode, CARRY_REGNUM));
src = gen_rtx_MEM (mode, src_reg);
return;
}
- emit_insn (gen_rtx_SET (VOIDmode, dest, src));
+ emit_insn (gen_rtx_SET (dest, src));
}
\f
/* Stack Layout:
{
rtx set, clobber, insn;
- set = gen_rtx_SET (VOIDmode, dest, gen_rtx_PLUS (HImode, src0, src1));
+ set = gen_rtx_SET (dest, gen_rtx_PLUS (HImode, src0, src1));
clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (BImode, CARRY_REGNUM));
insn = emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber)));
return insn;
dwarf = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
- XVECEXP (dwarf, 0, 0) = gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (Pmode, stack_pointer_rtx),
+ XVECEXP (dwarf, 0, 0) = gen_rtx_SET (gen_rtx_MEM (Pmode, stack_pointer_rtx),
reg);
- XVECEXP (dwarf, 0, 1) = gen_rtx_SET (Pmode, stack_pointer_rtx,
+ XVECEXP (dwarf, 0, 1) = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
GET_MODE_SIZE (Pmode)));
dwarf = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (2));
- XVECEXP (dwarf, 0, 0) = gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (Pmode, stack_pointer_rtx),
+ XVECEXP (dwarf, 0, 0) = gen_rtx_SET (gen_rtx_MEM (Pmode, stack_pointer_rtx),
reg);
- XVECEXP (dwarf, 0, 1) = gen_rtx_SET (Pmode, stack_pointer_rtx,
+ XVECEXP (dwarf, 0, 1) = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode,
stack_pointer_rtx,
GET_MODE_SIZE (Pmode)));
call = gen_rtx_CALL (mode, gen_rtx_MEM (FUNCTION_MODE, dest),
counter);
if (retval)
- call = gen_rtx_SET (VOIDmode, retval, call);
+ call = gen_rtx_SET (retval, call);
if (! CONSTANT_P (dest))
{
sub_1 = gen_rtx_MINUS (HImode, w_src0,
gen_rtx_ZERO_EXTEND (HImode, gen_rtx_REG (BImode, CARRY_REGNUM)));
- sub = gen_rtx_SET (VOIDmode, w_dest,
+ sub = gen_rtx_SET (w_dest,
gen_rtx_MINUS (HImode, sub_1, w_src1));
clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (BImode, CARRY_REGNUM));
- branch = gen_rtx_SET (VOIDmode, pc_rtx,
+ branch = gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode,
gen_rtx_EQ (HImode,
sub_1,
&& INTVAL (w_src1) == -(code == AND))
continue;
- insn = gen_rtx_SET (VOIDmode, w_dest, gen_rtx_fmt_ee (code, mode,
- w_src0, w_src1));
+ insn = gen_rtx_SET (w_dest, gen_rtx_fmt_ee (code, mode,
+ w_src0, w_src1));
break;
case NOT:
- insn = gen_rtx_SET (VOIDmode, w_dest, gen_rtx_NOT (mode, w_src0));
+ insn = gen_rtx_SET (w_dest, gen_rtx_NOT (mode, w_src0));
break;
default:
op1 = force_reg (cmp_mode, op1);
/* Return the setcc comparison. */
- emit_insn (gen_rtx_SET (VOIDmode, res,
- gen_rtx_fmt_ee (code, DImode, op0, op1)));
+ emit_insn (gen_rtx_SET (res, gen_rtx_fmt_ee (code, DImode, op0, op1)));
return true;
}
rtx cmp_rtx =
tilegx_emit_cc_test (GET_CODE (operands[0]), operands[1], operands[2],
cmp_mode, false);
- rtx branch_rtx = gen_rtx_SET (VOIDmode, pc_rtx,
+ rtx branch_rtx = gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, cmp_rtx,
gen_rtx_LABEL_REF
(VOIDmode,
rtx reg_note = gen_rtx_REG (DImode, regno_note);
rtx cfa_relative_addr = gen_rtx_PLUS (Pmode, cfa, GEN_INT (cfa_offset));
rtx cfa_relative_mem = gen_frame_mem (DImode, cfa_relative_addr);
- rtx real = gen_rtx_SET (VOIDmode, cfa_relative_mem, reg_note);
+ rtx real = gen_rtx_SET (cfa_relative_mem, reg_note);
add_reg_note (mov, REG_CFA_OFFSET, real);
return emit_insn (mov);
/* Describe what just happened in a way that dwarf understands. */
if (frame_related)
{
- rtx real = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ rtx real = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
imm_rtx));
RTX_FRAME_RELATED_P (insn) = 1;
offset_rtx = tmp_reg_rtx;
}
- emit_insn (gen_rtx_SET (VOIDmode, tmp_reg_rtx,
+ emit_insn (gen_rtx_SET (tmp_reg_rtx,
gen_rtx_PLUS (Pmode, base_reg_rtx, offset_rtx)));
return tmp_reg_rtx;
original stack pointer, not the one after we have pushed
the frame. */
rtx p = gen_rtx_PLUS (Pmode, stack_pointer_rtx, size_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, chain_addr, p));
+ emit_insn (gen_rtx_SET (chain_addr, p));
emit_sp_adjust (-total_size, &next_scratch_regno,
!frame_pointer_needed, NULL_RTX);
}
!frame_pointer_needed, NULL_RTX);
p = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
GEN_INT (UNITS_PER_WORD));
- emit_insn (gen_rtx_SET (VOIDmode, chain_addr, p));
+ emit_insn (gen_rtx_SET (chain_addr, p));
}
/* Save our frame pointer for backtrace chaining. */
register. */
int stride = ROUND_ROBIN_SIZE * -UNITS_PER_WORD;
rtx p = gen_rtx_PLUS (Pmode, r, GEN_INT (stride));
- emit_insn (gen_rtx_SET (VOIDmode, r, p));
+ emit_insn (gen_rtx_SET (r, p));
}
/* Save this register to the stack (but use the old fp value
/* Advance to the next stack slot to store this register. */
int stride = ROUND_ROBIN_SIZE * -UNITS_PER_WORD;
rtx p = gen_rtx_PLUS (Pmode, r, GEN_INT (stride));
- emit_insn (gen_rtx_SET (VOIDmode, r, p));
+ emit_insn (gen_rtx_SET (r, p));
}
if (fp_copy_regno >= 0 && regno == HARD_FRAME_POINTER_REGNUM)
emit_move_insn (s0, gen_rtx_PLUS (mode, s0, GEN_INT (-1)));
bcomp = gen_rtx_NE(mode, s0, const0_rtx);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands [1]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
DONE;
rtx ssp_addr = gen_rtx_PLUS (Pmode, tp, GEN_INT (TARGET_THREAD_SSP_OFFSET));
rtx ssp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, ssp, ssp_addr));
+ emit_insn (gen_rtx_SET (ssp, ssp_addr));
operands[1] = gen_rtx_MEM (Pmode, ssp);
#endif
rtx ssp_addr = gen_rtx_PLUS (Pmode, tp, GEN_INT (TARGET_THREAD_SSP_OFFSET));
rtx ssp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, ssp, ssp_addr));
+ emit_insn (gen_rtx_SET (ssp, ssp_addr));
operands[1] = gen_rtx_MEM (Pmode, ssp);
#endif
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[2]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
op1 = force_reg (SImode, op1);
/* Return the setcc comparison. */
- emit_insn (gen_rtx_SET (VOIDmode, res,
- gen_rtx_fmt_ee (code, SImode, op0, op1)));
+ emit_insn (gen_rtx_SET (res, gen_rtx_fmt_ee (code, SImode, op0, op1)));
return true;
}
rtx cmp_rtx =
tilepro_emit_cc_test (GET_CODE (operands[0]), operands[1], operands[2],
cmp_mode, false);
- rtx branch_rtx = gen_rtx_SET (VOIDmode, pc_rtx,
+ rtx branch_rtx = gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, cmp_rtx,
gen_rtx_LABEL_REF
(VOIDmode,
rtx reg_note = gen_rtx_REG (Pmode, regno_note);
rtx cfa_relative_addr = gen_rtx_PLUS (Pmode, cfa, gen_int_si (cfa_offset));
rtx cfa_relative_mem = gen_frame_mem (Pmode, cfa_relative_addr);
- rtx real = gen_rtx_SET (VOIDmode, cfa_relative_mem, reg_note);
+ rtx real = gen_rtx_SET (cfa_relative_mem, reg_note);
add_reg_note (mov, REG_CFA_OFFSET, real);
return emit_insn (mov);
/* Describe what just happened in a way that dwarf understands. */
if (frame_related)
{
- rtx real = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ rtx real = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
imm_rtx));
RTX_FRAME_RELATED_P (insn) = 1;
if (!tilepro_expand_addsi (tmp_reg_rtx, base_reg_rtx, offset_rtx))
{
- emit_insn (gen_rtx_SET (VOIDmode, tmp_reg_rtx,
+ emit_insn (gen_rtx_SET (tmp_reg_rtx,
gen_rtx_PLUS (Pmode, base_reg_rtx,
offset_rtx)));
}
original stack pointer, not the one after we have pushed
the frame. */
rtx p = gen_rtx_PLUS (Pmode, stack_pointer_rtx, size_rtx);
- emit_insn (gen_rtx_SET (VOIDmode, chain_addr, p));
+ emit_insn (gen_rtx_SET (chain_addr, p));
emit_sp_adjust (-total_size, &next_scratch_regno,
!frame_pointer_needed, NULL_RTX);
}
!frame_pointer_needed, NULL_RTX);
p = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
GEN_INT (UNITS_PER_WORD));
- emit_insn (gen_rtx_SET (VOIDmode, chain_addr, p));
+ emit_insn (gen_rtx_SET (chain_addr, p));
}
/* Save our frame pointer for backtrace chaining. */
r = gen_rtx_REG (word_mode, next_scratch_regno--);
reg_save_addr[which_scratch] = r;
- emit_insn (gen_rtx_SET (VOIDmode, r, p));
+ emit_insn (gen_rtx_SET (r, p));
}
else
{
/* Advance to the next stack slot to store this register. */
int stride = ROUND_ROBIN_SIZE * -UNITS_PER_WORD;
rtx p = gen_rtx_PLUS (Pmode, r, GEN_INT (stride));
- emit_insn (gen_rtx_SET (VOIDmode, r, p));
+ emit_insn (gen_rtx_SET (r, p));
}
/* Save this register to the stack (but use the old fp value
register. */
int stride = ROUND_ROBIN_SIZE * -UNITS_PER_WORD;
rtx p = gen_rtx_PLUS (Pmode, r, GEN_INT (stride));
- emit_insn (gen_rtx_SET (VOIDmode, r, p));
+ emit_insn (gen_rtx_SET (r, p));
}
if (fp_copy_regno >= 0 && regno == HARD_FRAME_POINTER_REGNUM)
emit_move_insn (s0, gen_rtx_PLUS (SImode, s0, GEN_INT (-1)));
bcomp = gen_rtx_NE(SImode, s0, const0_rtx);
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands [1]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
DONE;
rtx ssp_addr = gen_rtx_PLUS (Pmode, tp, GEN_INT (TARGET_THREAD_SSP_OFFSET));
rtx ssp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, ssp, ssp_addr));
+ emit_insn (gen_rtx_SET (ssp, ssp_addr));
operands[1] = gen_rtx_MEM (Pmode, ssp);
#endif
rtx ssp_addr = gen_rtx_PLUS (Pmode, tp, GEN_INT (TARGET_THREAD_SSP_OFFSET));
rtx ssp = gen_reg_rtx (Pmode);
- emit_insn (gen_rtx_SET (VOIDmode, ssp, ssp_addr));
+ emit_insn (gen_rtx_SET (ssp, ssp_addr));
operands[1] = gen_rtx_MEM (Pmode, ssp);
#endif
loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[2]);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
loc_ref, pc_rtx)));
return "%S0st%W0 %.,%0";
}
- fatal_insn ("output_move_single:", gen_rtx_SET (VOIDmode, dst, src));
+ fatal_insn ("output_move_single:", gen_rtx_SET (dst, src));
return "";
}
rtx cc_reg;
mode = v850_gen_float_compare (cond, mode, op0, op1);
cc_reg = gen_rtx_REG (mode, CC_REGNUM);
- emit_insn (gen_rtx_SET(mode, cc_reg, gen_rtx_REG (mode, FCC_REGNUM)));
+ emit_insn (gen_rtx_SET (cc_reg, gen_rtx_REG (mode, FCC_REGNUM)));
return gen_rtx_fmt_ee (cond, mode, cc_reg, const0_rtx);
}
&& SET_SRC (PATTERN (insn)) == *p_r1)
delete_insn (insn);
else
- emit_insn_before (gen_rtx_SET (Pmode, *p_r1, *p_ep), first_insn);
+ emit_insn_before (gen_rtx_SET (*p_r1, *p_ep), first_insn);
- emit_insn_before (gen_rtx_SET (Pmode, *p_ep, reg), first_insn);
- emit_insn_before (gen_rtx_SET (Pmode, *p_ep, *p_r1), last_insn);
+ emit_insn_before (gen_rtx_SET (*p_ep, reg), first_insn);
+ emit_insn_before (gen_rtx_SET (*p_ep, *p_r1), last_insn);
}
\f
+ (TARGET_DISABLE_CALLT ? (TARGET_LONG_CALLS ? 2 : 1) : 0)));
XVECEXP (save_all, 0, 0)
- = gen_rtx_SET (VOIDmode,
- stack_pointer_rtx,
+ = gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode,
stack_pointer_rtx,
GEN_INT(-alloc_stack)));
{
offset -= 4;
XVECEXP (save_all, 0, i+1)
- = gen_rtx_SET (VOIDmode,
- gen_rtx_MEM (Pmode,
+ = gen_rtx_SET (gen_rtx_MEM (Pmode,
gen_rtx_PLUS (Pmode,
stack_pointer_rtx,
GEN_INT(offset))),
rtvec_alloc (num_restore + 2));
XVECEXP (restore_all, 0, 0) = ret_rtx;
XVECEXP (restore_all, 0, 1)
- = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
- gen_rtx_PLUS (Pmode,
- stack_pointer_rtx,
- GEN_INT (alloc_stack)));
+ = gen_rtx_SET (stack_pointer_rtx,
+ gen_rtx_PLUS (Pmode,
+ stack_pointer_rtx,
+ GEN_INT (alloc_stack)));
offset = alloc_stack - 4;
for (i = 0; i < num_restore; i++)
{
XVECEXP (restore_all, 0, i+2)
- = gen_rtx_SET (VOIDmode,
- restore_regs[i],
+ = gen_rtx_SET (restore_regs[i],
gen_rtx_MEM (Pmode,
gen_rtx_PLUS (Pmode,
stack_pointer_rtx,
else
temp = gen_reg_rtx (SImode);
- emit_insn (gen_rtx_SET (SImode, temp,
- gen_rtx_HIGH (SImode, operand1)));
- emit_insn (gen_rtx_SET (SImode, operand0,
+ emit_insn (gen_rtx_SET (temp, gen_rtx_HIGH (SImode, operand1)));
+ emit_insn (gen_rtx_SET (operand0,
gen_rtx_LO_SUM (SImode, temp, operand1)));
DONE;
}
mode = v850_gen_float_compare (cond, VOIDmode, v850_compare_op0, v850_compare_op1);
fcc_reg = gen_rtx_REG (mode, FCC_REGNUM);
cc_reg = gen_rtx_REG (mode, CC_REGNUM);
- emit_insn(gen_rtx_SET (mode, cc_reg, fcc_reg));
+ emit_insn (gen_rtx_SET (cc_reg, fcc_reg));
tmp = gen_rtx_fmt_ee (cond, mode, cc_reg, const0_rtx);
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, operands[3]), pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
DONE;
})
mode = v850_gen_float_compare (cond, VOIDmode, v850_compare_op0, v850_compare_op1);
fcc_reg = gen_rtx_REG (mode, FCC_REGNUM);
cc_reg = gen_rtx_REG (mode, CC_REGNUM);
- emit_insn(gen_rtx_SET (mode, cc_reg, fcc_reg));
+ emit_insn (gen_rtx_SET (cc_reg, fcc_reg));
tmp = gen_rtx_fmt_ee (cond, mode, cc_reg, const0_rtx);
tmp = gen_rtx_IF_THEN_ELSE (VOIDmode, tmp,
gen_rtx_LABEL_REF (VOIDmode, operands[3]), pc_rtx);
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, tmp));
+ emit_jump_insn (gen_rtx_SET (pc_rtx, tmp));
DONE;
})
x = plus_constant (Pmode, frame_pointer_rtx, offset);
x = gen_rtx_MEM (SImode, x);
- x = gen_rtx_SET (VOIDmode, x, src);
+ x = gen_rtx_SET (x, src);
add_reg_note (insn, REG_CFA_OFFSET, x);
}
x = force_reg (SImode, gen_rtx_IOR (SImode, op0, op1));
/* And move the result to the destination. */
- emit_insn (gen_rtx_SET (VOIDmode, dest, gen_lowpart (SFmode, x)));
+ emit_insn (gen_rtx_SET (dest, gen_lowpart (SFmode, x)));
}
/* Expand a cstore of OPERANDS in MODE for EQ/NE/LTU/GTU/GEU/LEU. We generate
emit_insn (gen_add3_insn (op0, tmp, const1_rtx));
}
else
- emit_insn (gen_rtx_SET (VOIDmode, op0, sltu));
+ emit_insn (gen_rtx_SET (op0, sltu));
}
/* Expand a cstore of OPERANDS in MODE for LT/GT/UNGE/UNLE. We generate the
emit_insn (gen_add3_insn (op0, tmp, const1_rtx));
}
else
- emit_insn (gen_rtx_SET (VOIDmode, op0, slt));
+ emit_insn (gen_rtx_SET (op0, slt));
}
/* Split a compare-and-store with CODE, operands OP2 and OP3, combined with
rtx flags = gen_rtx_REG (cc_mode, FLAGS_REGNUM);
rtx x = gen_rtx_COMPARE (cc_mode, op2, op3);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
x = gen_rtx_fmt_ee (code, SImode, flags, const0_rtx);
}
rtx pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
- XVECEXP (pat, 0, 0) = gen_rtx_SET (VOIDmode, op0, x);
+ XVECEXP (pat, 0, 0) = gen_rtx_SET (op0, x);
flags = gen_rtx_REG (CCmode, FLAGS_REGNUM);
XVECEXP (pat, 0, 1) = gen_rtx_CLOBBER (VOIDmode, flags);
emit_insn (pat);
insn = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (8));
XVECEXP (insn, 0, 0)
- = gen_rtx_SET (VOIDmode,
- replace_equiv_address_nv (dst, regno_reg_rtx[1]),
+ = gen_rtx_SET (replace_equiv_address_nv (dst, regno_reg_rtx[1]),
replace_equiv_address_nv (src, regno_reg_rtx[2]));
XVECEXP (insn, 0, 1) = gen_rtx_USE (VOIDmode, regno_reg_rtx[3]);
for (i = 1; i <= 6; i++)
rtx flags = gen_rtx_REG (cc_mode, FLAGS_REGNUM);
rtx x = gen_rtx_COMPARE (cc_mode, op0, op1);
- x = gen_rtx_SET (VOIDmode, flags, x);
+ x = gen_rtx_SET (flags, x);
emit_insn (x);
x = gen_rtx_fmt_ee (code, VOIDmode, flags, const0_rtx);
x = gen_rtx_IF_THEN_ELSE (VOIDmode, x, gen_rtx_LABEL_REF (Pmode, label),
pc_rtx);
- x = gen_rtx_SET (VOIDmode, pc_rtx, x);
+ x = gen_rtx_SET (pc_rtx, x);
emit_jump_insn (x);
visium_flags_exposed = true;
{
insn = emit_frame_insn (gen_movdi (mem, tmp));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, mem, reg));
+ gen_rtx_SET (mem, reg));
}
}
break;
emit_insn (gen_movsi (tmp, reg));
insn = emit_frame_insn (gen_movsi (mem, tmp));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, mem, reg));
+ gen_rtx_SET (mem, reg));
}
break;
emit_insn (gen_movsf (tmp, reg));
insn = emit_frame_insn (gen_movsf (mem, tmp));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, mem, reg));
+ gen_rtx_SET (mem, reg));
}
break;
stack_pointer_rtx,
tmp));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
GEN_INT (-alloc_size))));
}
/* Deallocate the stack space. */
rtx insn = emit_frame_insn (gen_stack_pop (GEN_INT (dealloc)));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
GEN_INT (dealloc))));
visium_add_queued_cfa_restore_notes (insn);
rtx insn = emit_frame_insn (gen_movsi (hard_frame_pointer_rtx, src));
add_reg_note (insn, REG_CFA_ADJUST_CFA,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
hard_frame_pointer_rtx));
visium_add_cfa_restore_note (hard_frame_pointer_rtx);
}
else
insn = emit_frame_insn (gen_stack_pop (GEN_INT (pop_size)));
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_SET (stack_pointer_rtx,
gen_rtx_PLUS (Pmode, stack_pointer_rtx,
GEN_INT (pop_size))));
visium_add_queued_cfa_restore_notes (insn);
label1 = pc_rtx;
}
- emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ emit_jump_insn (gen_rtx_SET (pc_rtx,
gen_rtx_IF_THEN_ELSE (VOIDmode, cmp,
label1,
label2)));
temp[next] = gen_reg_rtx (mode[next]);
x = adjust_address (src_mem, mode[next], offset_ld);
- emit_insn (gen_rtx_SET (VOIDmode, temp[next], x));
+ emit_insn (gen_rtx_SET (temp[next], x));
offset_ld += next_amount;
bytes -= next_amount;
active[phase] = false;
x = adjust_address (dst_mem, mode[phase], offset_st);
- emit_insn (gen_rtx_SET (VOIDmode, x, temp[phase]));
+ emit_insn (gen_rtx_SET (x, temp[phase]));
offset_st += amount[phase];
}
{
rtx temp = gen_reg_rtx (Pmode);
rtx addmi_offset = GEN_INT (INTVAL (plus1) & ~0xff);
- emit_insn (gen_rtx_SET (Pmode, temp,
- gen_rtx_PLUS (Pmode, plus0, addmi_offset)));
+ emit_insn (gen_rtx_SET (temp, gen_rtx_PLUS (Pmode, plus0,
+ addmi_offset)));
return gen_rtx_PLUS (Pmode, temp, GEN_INT (INTVAL (plus1) & 0xff));
}
}
insn = emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
GEN_INT (-total_size)));
RTX_FRAME_RELATED_P (insn) = 1;
- note_rtx = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ note_rtx = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-total_size));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, note_rtx);
insn = emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
GEN_INT (-xtensa_callee_save_size)));
RTX_FRAME_RELATED_P (insn) = 1;
- note_rtx = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ note_rtx = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-xtensa_callee_save_size));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, note_rtx);
insn = emit_insn (gen_subsi3 (stack_pointer_rtx,
stack_pointer_rtx, tmp_reg));
RTX_FRAME_RELATED_P (insn) = 1;
- note_rtx = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ note_rtx = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
-total_size));
add_reg_note (insn, REG_FRAME_RELATED_EXPR, note_rtx);
insn = emit_move_insn (mem, reg);
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR,
- gen_rtx_SET (VOIDmode, mem, reg));
+ gen_rtx_SET (mem, reg));
}
}
if (total_size > 1024)
insn = emit_insn (gen_subsi3 (stack_pointer_rtx,
stack_pointer_rtx, tmp_reg));
RTX_FRAME_RELATED_P (insn) = 1;
- note_rtx = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ note_rtx = gen_rtx_SET (stack_pointer_rtx,
plus_constant (Pmode, stack_pointer_rtx,
xtensa_callee_save_size -
total_size));
stack_pointer_rtx));
if (!TARGET_WINDOWED_ABI)
{
- note_rtx = gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
+ note_rtx = gen_rtx_SET (hard_frame_pointer_rtx,
stack_pointer_rtx);
RTX_FRAME_RELATED_P (insn) = 1;
add_reg_note (insn, REG_FRAME_RELATED_EXPR, note_rtx);
/* Create a note to describe the CFA. Because this is only used to set
DW_AT_frame_base for debug info, don't bother tracking changes through
each instruction in the prologue. It just takes up space. */
- note_rtx = gen_rtx_SET (VOIDmode, (frame_pointer_needed
- ? hard_frame_pointer_rtx
- : stack_pointer_rtx),
+ note_rtx = gen_rtx_SET ((frame_pointer_needed
+ ? hard_frame_pointer_rtx
+ : stack_pointer_rtx),
plus_constant (Pmode, stack_pointer_rtx,
-total_size));
RTX_FRAME_RELATED_P (insn) = 1;
hard_frame_pointer_rtx : stack_pointer_rtx;
rtx a0_addr = plus_constant (Pmode, frame,
total_size - UNITS_PER_WORD);
- rtx note = gen_rtx_SET (VOIDmode,
- gen_frame_mem (SImode, a0_addr),
+ rtx note = gen_rtx_SET (gen_frame_mem (SImode, a0_addr),
gen_rtx_REG (SImode, A0_REG));
rtx insn;
&& REG_NOTE_KIND (note) == REG_EQUAL
&& !REG_P (src)
&& cprop_constant_p (XEXP (note, 0)))
- src = XEXP (note, 0), set = gen_rtx_SET (VOIDmode, dest, src);
+ src = XEXP (note, 0), set = gen_rtx_SET (dest, src);
/* Record sets for constant/copy propagation. */
if ((cprop_reg_p (src)
(implicit_sets_size - old_implicit_sets_size) * sizeof (rtx));
}
- new_rtx = gen_rtx_SET (VOIDmode, XEXP (cond, 0),
- XEXP (cond, 1));
+ new_rtx = gen_rtx_SET (XEXP (cond, 0), XEXP (cond, 1));
implicit_sets[dest->index] = new_rtx;
if (dump_file)
{
{
rtx mem = gen_rtx_MEM (BLKmode, args[0]);
set_mem_size (mem, INTVAL (args[2]));
- body = gen_rtx_SET (VOIDmode, mem, args[1]);
+ body = gen_rtx_SET (mem, args[1]);
mems_found += record_store (body, bb_info);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "handling memset as BLKmode store\n");
reg = gen_rtx_REG (VOIDmode, -1);
insn = rtx_alloc (INSN);
- pat = gen_rtx_SET (VOIDmode, NULL_RTX, NULL_RTX);
+ pat = gen_rtx_SET (NULL_RTX, NULL_RTX);
PATTERN (insn) = pat;
for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
can_copy[i] = 0;
#else
reg = gen_rtx_REG ((machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
- insn = emit_insn (gen_rtx_SET (VOIDmode, reg, reg));
+ insn = emit_insn (gen_rtx_SET (reg, reg));
if (recog (PATTERN (insn), insn, NULL) >= 0)
can_copy[i] = 1;
#endif
if (test_insn == 0)
{
test_insn
- = make_insn_raw (gen_rtx_SET (VOIDmode,
- gen_rtx_REG (word_mode,
+ = make_insn_raw (gen_rtx_SET (gen_rtx_REG (word_mode,
FIRST_PSEUDO_REGISTER * 2),
const0_rtx));
SET_NEXT_INSN (test_insn) = SET_PREV_INSN (test_insn) = 0;
&& REG_NOTE_KIND (note) == REG_EQUAL
&& !REG_P (src)
&& want_to_gcse_p (XEXP (note, 0), NULL))
- src = XEXP (note, 0), set = gen_rtx_SET (VOIDmode, dest, src);
+ src = XEXP (note, 0), set = gen_rtx_SET (dest, src);
/* Only record sets of pseudo-regs in the hash table. */
if (regno >= FIRST_PSEUDO_REGISTER
insn will be recognized (this also adds any needed CLOBBERs). */
else
{
- rtx_insn *insn = emit_insn (gen_rtx_SET (VOIDmode, reg, exp));
+ rtx_insn *insn = emit_insn (gen_rtx_SET (reg, exp));
if (insn_invalid_p (insn, false))
gcc_unreachable ();
int i;
int len;
const char *fmt;
+ const char *sep = "";
if (x == 0)
{
printf ("gen_rtx_");
print_code (code);
- printf (" (%smode", GET_MODE_NAME (GET_MODE (x)));
+ printf (" (");
+ if (!always_void_p (code))
+ {
+ printf ("%smode", GET_MODE_NAME (GET_MODE (x)));
+ sep = ",\n\t";
+ }
fmt = GET_RTX_FORMAT (code);
len = GET_RTX_LENGTH (code);
{
if (fmt[i] == '0')
break;
- printf (",\n\t");
+ fputs (sep, stdout);
switch (fmt[i])
{
case 'e': case 'u':
default:
gcc_unreachable ();
}
+ sep = ",\n\t";
}
printf (")");
}
|| strchr (fmt, 'n') != 0);
}
+/* Return true if CODE always has VOIDmode. */
+
+static inline bool
+always_void_p (int idx)
+{
+ return strcmp (defs[idx].enumname, "SET") == 0;
+}
+
/* Return nonzero if the RTL code given by index IDX is one that we should
generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO
is a wrapper in emit-rtl.c). */
genmacro (int idx)
{
const char *p;
+ const char *sep = "";
int i;
/* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
/* Don't define a macro for this code. */
return;
- printf ("#define gen_rtx_%s%s(MODE",
+ bool has_mode_p = !always_void_p (idx);
+ printf ("#define gen_rtx_%s%s(",
special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
+ if (has_mode_p)
+ {
+ printf ("MODE");
+ sep = ", ";
+ }
for (p = defs[idx].format, i = 0; *p != 0; p++)
if (*p != '0')
- printf (", ARG%d", i++);
-
- printf (") \\\n gen_rtx_fmt_%s (%s, (MODE)",
- defs[idx].format, defs[idx].enumname);
+ {
+ printf ("%sARG%d", sep, i++);
+ sep = ", ";
+ }
+
+ printf (") \\\n gen_rtx_fmt_%s (%s, %s",
+ defs[idx].format, defs[idx].enumname,
+ has_mode_p ? "(MODE)" : "VOIDmode");
for (p = defs[idx].format, i = 0; *p != 0; p++)
if (*p != '0')
{
rtx src = gen_rtx_fmt_ee (code, GET_MODE (x), XEXP (cond, 0),
XEXP (cond, 1));
- rtx set = gen_rtx_SET (VOIDmode, x, src);
+ rtx set = gen_rtx_SET (x, src);
start_sequence ();
rtx_insn *insn = emit_insn (set);
otherwise construct a suitable SET pattern ourselves. */
insn = (OBJECT_P (y) || CONSTANT_P (y) || GET_CODE (y) == SUBREG)
? emit_move_insn (x, y)
- : emit_insn (gen_rtx_SET (VOIDmode, x, y));
+ : emit_insn (gen_rtx_SET (x, y));
seq = get_insns ();
end_sequence ();
rtx cond = gen_rtx_fmt_ee (code, GET_MODE (if_info->cond), cmp_a, cmp_b);
rtx if_then_else = gen_rtx_IF_THEN_ELSE (GET_MODE (x),
cond, vtrue, vfalse);
- rtx set = gen_rtx_SET (VOIDmode, x, if_then_else);
+ rtx set = gen_rtx_SET (x, if_then_else);
start_sequence ();
rtx_insn *insn = emit_insn (set);
if (is_mem)
{
rtx reg = gen_reg_rtx (GET_MODE (a));
- insn = emit_insn (gen_rtx_SET (VOIDmode, reg, a));
+ insn = emit_insn (gen_rtx_SET (reg, a));
}
else if (! insn_a)
goto end_seq_and_fail;
if (is_mem)
{
rtx reg = gen_reg_rtx (GET_MODE (b));
- pat = gen_rtx_SET (VOIDmode, reg, b);
+ pat = gen_rtx_SET (reg, b);
}
else if (! insn_b)
goto end_seq_and_fail;
ira_prohibited_mode_move_regs_initialized_p = true;
test_reg1 = gen_rtx_REG (VOIDmode, 0);
test_reg2 = gen_rtx_REG (VOIDmode, 0);
- move_pat = gen_rtx_SET (VOIDmode, test_reg1, test_reg2);
+ move_pat = gen_rtx_SET (test_reg1, test_reg2);
move_insn = gen_rtx_INSN (VOIDmode, 0, 0, 0, move_pat, 0, -1, 0);
for (i = 0; i < NUM_MACHINE_MODES; i++)
{
{
x = redirect_target (nlabel);
if (GET_CODE (x) == LABEL_REF && loc == &PATTERN (insn))
- x = gen_rtx_SET (VOIDmode, pc_rtx, x);
+ x = gen_rtx_SET (pc_rtx, x);
validate_change (insn, loc, x, 1);
return;
}
rtxes.target = gen_rtx_REG (word_mode, FIRST_PSEUDO_REGISTER);
rtxes.source = gen_rtx_REG (word_mode, FIRST_PSEUDO_REGISTER + 1);
- rtxes.set = gen_rtx_SET (VOIDmode, rtxes.target, rtxes.source);
+ rtxes.set = gen_rtx_SET (rtxes.target, rtxes.source);
rtxes.zext = gen_rtx_ZERO_EXTEND (twice_word_mode, rtxes.source);
rtxes.shift = gen_rtx_ASHIFT (twice_word_mode, rtxes.source, const0_rtx);
: *ad->disp_term);
if (!valid_address_p (ad->mode, new_inner, ad->as))
return NULL_RTX;
- insn = emit_insn (gen_rtx_SET (ad->mode, new_reg, *ad->base_term));
+ insn = emit_insn (gen_rtx_SET (new_reg, *ad->base_term));
code = recog_memoized (insn);
if (code < 0)
{
/* addr => lo_sum (new_base, addr), case (2) above. */
insn = emit_insn (gen_rtx_SET
- (VOIDmode, new_reg,
+ (new_reg,
gen_rtx_HIGH (Pmode, copy_rtx (addr))));
code = recog_memoized (insn);
if (code >= 0)
{
/* Try to put lo_sum into register. */
insn = emit_insn (gen_rtx_SET
- (VOIDmode, new_reg,
+ (new_reg,
gen_rtx_LO_SUM (Pmode, new_reg, addr)));
code = recog_memoized (insn);
if (code >= 0)
constraint pass fix it up. */
if (! validate_change (insn, &SET_SRC (old_set), new_src, 0))
{
- rtx new_pat = gen_rtx_SET (VOIDmode,
- SET_DEST (old_set), new_src);
+ rtx new_pat = gen_rtx_SET (SET_DEST (old_set), new_src);
if (! validate_change (insn, &PATTERN (insn), new_pat, 0))
SET_SRC (old_set) = new_src;
return insn;
}
- rtx_insn *insn = emit_insn (gen_rtx_SET (VOIDmode, x,
- gen_rtx_PLUS (GET_MODE (y), y, z)));
+ rtx_insn *insn = emit_insn (gen_rtx_SET (x, gen_rtx_PLUS (GET_MODE (y),
+ y, z)));
if (recog_memoized (insn) < 0)
{
delete_insns_since (last);
rtx narrow_src = gen_int_mode (INTVAL (off),
narrow_mode);
rtx new_set
- = gen_rtx_SET (VOIDmode,
- gen_rtx_STRICT_LOW_PART (VOIDmode,
+ = gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode,
narrow_reg),
narrow_src);
get_full_set_rtx_cost (new_set, &newcst);
if (costs_lt_p (&newcst, &oldcst, speed)
&& have_add2_insn (reg, new_src))
{
- rtx newpat = gen_rtx_SET (VOIDmode, reg, tem);
+ rtx newpat = gen_rtx_SET (reg, tem);
success
= validate_change (next, &PATTERN (next),
newpat, 0);
&& CONST_INT_P (XEXP (cnd, 1)))
{
rtx implicit_set =
- gen_rtx_SET (VOIDmode, XEXP (cnd, 0), XEXP (cnd, 1));
+ gen_rtx_SET (XEXP (cnd, 0), XEXP (cnd, 1));
move2add_note_store (SET_DEST (implicit_set), implicit_set, insn);
}
}
&& HOST_BITS_PER_WIDE_INT >= GET_MODE_BITSIZE (cand->mode))
{
if (INTVAL (orig_src) >= 0 || cand->code == SIGN_EXTEND)
- new_set = gen_rtx_SET (VOIDmode, new_reg, orig_src);
+ new_set = gen_rtx_SET (new_reg, orig_src);
else
{
/* Zero-extend the negative constant by masking out the bits outside
rtx new_const_int
= gen_int_mode (INTVAL (orig_src) & GET_MODE_MASK (orig_mode),
GET_MODE (new_reg));
- new_set = gen_rtx_SET (VOIDmode, new_reg, new_const_int);
+ new_set = gen_rtx_SET (new_reg, new_const_int);
}
}
else if (GET_MODE (orig_src) == VOIDmode)
rtx simplified_temp_extension = simplify_rtx (temp_extension);
if (simplified_temp_extension)
temp_extension = simplified_temp_extension;
- new_set = gen_rtx_SET (VOIDmode, new_reg, temp_extension);
+ new_set = gen_rtx_SET (new_reg, temp_extension);
}
else if (GET_CODE (orig_src) == IF_THEN_ELSE)
{
rtx simplified_temp_extension = simplify_rtx (temp_extension);
if (simplified_temp_extension)
temp_extension = simplified_temp_extension;
- new_set = gen_rtx_SET (VOIDmode, new_reg, temp_extension);
+ new_set = gen_rtx_SET (new_reg, temp_extension);
}
/* This change is a part of a group of changes. Hence,
map_srcreg2 = gen_rtx_REG (cand->mode, REGNO (srcreg2));
map_dstreg = gen_rtx_REG (cand->mode, REGNO (dstreg));
ifexpr = gen_rtx_IF_THEN_ELSE (cand->mode, cond, map_srcreg, map_srcreg2);
- new_set = gen_rtx_SET (VOIDmode, map_dstreg, ifexpr);
+ new_set = gen_rtx_SET (map_dstreg, ifexpr);
if (validate_change (def_insn, &PATTERN (def_insn), new_set, true)
&& update_reg_equal_equiv_notes (def_insn, cand->mode, GET_MODE (dstreg),
REGNO (XEXP (SET_SRC (pat), 0)));
rtx new_src = gen_rtx_REG (GET_MODE (SET_DEST (sub_rtx)),
REGNO (SET_DEST (pat)));
- rtx set = gen_rtx_SET (VOIDmode, new_dst, new_src);
+ rtx set = gen_rtx_SET (new_dst, new_src);
emit_insn_after (set, def_insn);
}
gcc_assert (hard_regno >= FIRST_STACK_REG);
- pop_rtx = gen_rtx_SET (VOIDmode, FP_MODE_REG (hard_regno, DFmode),
+ pop_rtx = gen_rtx_SET (FP_MODE_REG (hard_regno, DFmode),
FP_MODE_REG (FIRST_STACK_REG, DFmode));
if (where == EMIT_AFTER)
rtx pat;
dest = FP_MODE_REG (REGNO (dest), SFmode);
- pat = gen_rtx_SET (VOIDmode, dest, not_a_num);
+ pat = gen_rtx_SET (dest, not_a_num);
PATTERN (insn) = pat;
INSN_CODE (insn) = -1;
{
old->reg[++old->top] = i;
SET_HARD_REG_BIT (old->reg_set, i);
- emit_insn_before (gen_rtx_SET (VOIDmode,
- FP_MODE_REG (i, SFmode), not_a_num), insn);
+ emit_insn_before (gen_rtx_SET (FP_MODE_REG (i, SFmode), not_a_num),
+ insn);
}
/* Pop any registers that are not needed in the new block. */
bi->stack_in.reg[++top] = reg;
- init = gen_rtx_SET (VOIDmode,
- FP_MODE_REG (FIRST_STACK_REG, SFmode),
+ init = gen_rtx_SET (FP_MODE_REG (FIRST_STACK_REG, SFmode),
not_a_num);
insert_insn_on_edge (init, e);
inserted = 1;
if (dump_file)
fprintf (dump_file, "Emitting insn initializing reg %d\n", reg);
- set = gen_rtx_SET (VOIDmode, FP_MODE_REG (reg, SFmode), not_a_num);
+ set = gen_rtx_SET (FP_MODE_REG (reg, SFmode), not_a_num);
insn = emit_insn_after (set, insn);
control_flow_insn_deleted |= subst_stack_regs (insn, ®stack);
}
/* If we can make a simple SET insn that does the job, everything should
be fine. */
dst = gen_rtx_REG (mode, regno);
- test_insn = make_insn_raw (gen_rtx_SET (VOIDmode, dst, in));
+ test_insn = make_insn_raw (gen_rtx_SET (dst, in));
save_recog_data = recog_data;
if (recog_memoized (test_insn) >= 0)
{
the INSN_CODE the same and let reload fix it up. */
if (!validate_change (insn, &SET_SRC (old_set), new_src, 0))
{
- rtx new_pat = gen_rtx_SET (VOIDmode,
- SET_DEST (old_set), new_src);
+ rtx new_pat = gen_rtx_SET (SET_DEST (old_set), new_src);
if (!validate_change (insn, &PATTERN (insn), new_pat, 0))
SET_SRC (old_set) = new_src;
|| CONSTANT_P (XEXP (in, 1))
|| MEM_P (XEXP (in, 1))))
{
- insn = emit_insn (gen_rtx_SET (VOIDmode, out, in));
+ insn = emit_insn (gen_rtx_SET (out, in));
code = recog_memoized (insn);
result = false;
if (op0 != XEXP (in, 0) || op1 != XEXP (in, 1))
in = gen_rtx_PLUS (GET_MODE (in), op0, op1);
- insn = emit_insn_if_valid_for_reload (gen_rtx_SET (VOIDmode, out, in));
+ insn = emit_insn_if_valid_for_reload (gen_rtx_SET (out, in));
if (insn)
return insn;
in = gen_rtx_fmt_e (GET_CODE (in), GET_MODE (in), op1);
/* First, try a plain SET. */
- set = emit_insn_if_valid_for_reload (gen_rtx_SET (VOIDmode, out, in));
+ set = emit_insn_if_valid_for_reload (gen_rtx_SET (out, in));
if (set)
return set;
gen_reload (out_moded, op1, opnum, type);
- insn
- = gen_rtx_SET (VOIDmode, out,
- gen_rtx_fmt_e (GET_CODE (in), GET_MODE (in),
- out_moded));
+ insn = gen_rtx_SET (out, gen_rtx_fmt_e (GET_CODE (in), GET_MODE (in),
+ out_moded));
insn = emit_insn_if_valid_for_reload (insn);
if (insn)
{
/* Otherwise, just write (set OUT IN) and hope for the best. */
else
- emit_insn (gen_rtx_SET (VOIDmode, out, in));
+ emit_insn (gen_rtx_SET (out, in));
/* Return the first insn emitted.
We can not just return get_last_insn, because there may have
that in gen_reload. */
last = get_last_insn ();
- add_insn = emit_insn (gen_rtx_SET (VOIDmode, incloc,
+ add_insn = emit_insn (gen_rtx_SET (incloc,
gen_rtx_PLUS (GET_MODE (incloc),
incloc, inc)));
new_arith = gen_rtx_fmt_ee (GET_CODE (src) == PLUS ? MINUS : PLUS,
GET_MODE (src), dest, other);
- ninsn = emit_insn_after (gen_rtx_SET (VOIDmode, dest, new_arith),
- insn);
+ ninsn = emit_insn_after (gen_rtx_SET (dest, new_arith), insn);
if (recog_memoized (ninsn) < 0
|| (extract_insn (ninsn),
not to use an rtx with this cost under any circumstances. */
#define MAX_COST INT_MAX
+/* Return true if CODE always has VOIDmode. */
+
+static inline bool
+always_void_p (enum rtx_code code)
+{
+ return code == SET;
+}
+
/* A structure to hold all available cost information about an rtl
expression. */
struct full_rtx_costs
/* reginfo.c */
extern tree GTY(()) global_regs_decl[FIRST_PSEUDO_REGISTER];
-
#endif /* ! GCC_RTL_H */
lhs_rtx = copy_rtx (VINSN_LHS (vi));
- pattern = gen_rtx_SET (VOIDmode, lhs_rtx, rhs_rtx);
+ pattern = gen_rtx_SET (lhs_rtx, rhs_rtx);
insn_rtx = create_insn_rtx_from_pattern (pattern, NULL_RTX);
return insn_rtx;
rhs_rtx = copy_rtx (VINSN_RHS (vi));
- pattern = gen_rtx_SET (VOIDmode, lhs_rtx, rhs_rtx);
+ pattern = gen_rtx_SET (lhs_rtx, rhs_rtx);
insn_rtx = create_insn_rtx_from_pattern (pattern, NULL_RTX);
return insn_rtx;
/* Make a new insn with it. */
rhs = copy_rtx (VINSN_RHS (EXPR_VINSN (expr)));
- pat = gen_rtx_SET (VOIDmode, reg, rhs);
+ pat = gen_rtx_SET (reg, rhs);
start_sequence ();
insn = emit_insn (pat);
end_sequence ();
tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
amd->store = store_save;
amd->side_effects = alloc_EXPR_LIST (0,
- gen_rtx_SET (VOIDmode,
- XEXP (loc, 0), tem),
+ gen_rtx_SET (XEXP (loc, 0), tem),
amd->side_effects);
return addr;
case PRE_MODIFY:
adjust_mems, data);
amd->store = store_save;
amd->side_effects = alloc_EXPR_LIST (0,
- gen_rtx_SET (VOIDmode,
- XEXP (loc, 0), tem),
+ gen_rtx_SET (XEXP (loc, 0), tem),
amd->side_effects);
return addr;
case SUBREG:
FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs, i, p)
{
XVECEXP (rtl, 0, i * 2)
- = gen_rtx_SET (VOIDmode, p->incoming, p->outgoing);
+ = gen_rtx_SET (p->incoming, p->outgoing);
/* Do not clobber the attached DECL, but only the REG. */
XVECEXP (rtl, 0, i * 2 + 1)
= gen_rtx_CLOBBER (GET_MODE (p->outgoing),
&& find_use_val (loc, mode, cui))
{
gcc_checking_assert (type == MO_VAL_SET);
- mo.u.loc = gen_rtx_SET (VOIDmode, loc, SET_SRC (expr));
+ mo.u.loc = gen_rtx_SET (loc, SET_SRC (expr));
}
}
else
}
else
{
- rtx xexpr = gen_rtx_SET (VOIDmode, loc, src);
+ rtx xexpr = gen_rtx_SET (loc, src);
if (same_variable_part_p (src, REG_EXPR (loc), REG_OFFSET (loc)))
{
/* If this is an instruction copying (part of) a parameter
}
else
{
- rtx xexpr = gen_rtx_SET (VOIDmode, loc, src);
+ rtx xexpr = gen_rtx_SET (loc, src);
if (same_variable_part_p (SET_SRC (xexpr),
MEM_EXPR (loc),
INT_MEM_OFFSET (loc)))
}
if (nloc && nloc != SET_SRC (mo.u.loc))
- oloc = gen_rtx_SET (GET_MODE (mo.u.loc), oloc, nloc);
+ oloc = gen_rtx_SET (oloc, nloc);
else
{
if (oloc == SET_DEST (mo.u.loc))
projects / gcc.git / commitdiff