This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Remove the postincrement queue
- From: Paolo Bonzini <bonzini at gnu dot org>
- To: gcc-patches at gcc dot gnu dot org
- Date: Thu, 08 Jul 2004 16:35:24 +0200
- Subject: [PATCH] Remove the postincrement queue
As mentioned a few days ago, a very nice thing that we can do with
tree-ssa is eliminating all the messy handling of postincrements and the
pending postincrement chain; and a RTL code that I had just learnt
about, QUEUED. :-)
~700 lines go away, and many comments like "the caller should have done
so" and "the callee will do so", which is quite nice.
Unfortunately (but quite understandably), va_arg expanders are heavy
users of {pre,post}{in,de}crements, which means that this patch has
ramifications in backend code. The obvious solution is to expand
preincrements and predecrements manually, and for postincrements use
(x+N)-N; of course the real solution would be to transition these
backends to using gimplifiers for va_arg: these could well use the
now-banned tree codes, but this is well above my abilities.
This patch bootstrapped/regtested all languages on i686-pc-linux-gnu. I
also built cc1 for c4x-elf, fr30-elf, iq2000-elf, mn10300-elf, m32r-elf,
mips-elf, hppa-linux, i860-sysv4, s390-linux.
Ok for mainline?
Paolo
As mentioned a few days ago, a very nice thing that we can do with
tree-ssa is eliminating all the messy handling of postincrements and
the pending postincrement chain; and a RTL code that I just learnt
about, QUEUED. :-)
~700 lines go away, and many comments like "the caller should have
done so" and "the callee will do so", which is quite nice.
Unfortunately (but quite understandably), va_arg expanders are heavy
users of {pre,post}{in,de}crements, which means that this patch has
ramifications in backend code. The obvious solution is to expand
preincrements and predecrements manually, and for postincrements use
(x + N) - N; of course the real solution would be to transition these
backends to using gimplifiers for va_arg: these could well use the
now-banned tree codes, but this is well above my abilities.
This patch bootstrapped/regtested all languages on i686-pc-linux-gnu.
I also built cc1 for c4x-elf, fr30-elf, iq2000-elf, mn10300-elf,
m32r-elf, mips-elf, hppa-linux, i860-sysv4, s390-linux.
Ok for mainline?
Paolo
2004-07-08 Paolo Bonzini <bonzini@gnu.org>
* expr.c (enqueue_insn, finish_expr_for_function,
protect_from_queue, queued_subexp_p, mark_queue,
emit_insns_enqueued_after_mark, emit_queue): Remove.
(expand_increment): Accept source and destination,
only expand preincrement.
(store_constructor): Adjust parameters to expand_increment.
(expand_expr_real_1 <case PREINCREMENT_EXPR,
case PREDECREMENT_EXPR, case POSTINCREMENT_EXPR,
case POSTDECREMENT_EXPR>): Abort.
* expr.h (QUEUED_VAR, QUEUED_INSN, QUEUED_COPY,
QUEUED_BODY, QUEUED_NEXT, finish_expr_for_function,
protect_from_queue, emit_queue, queued_subexp_p): Remove.
* function.h (pending_chain, x_pending_chain): Remove.
* rtl.def (QUEUED): Remove.
* emit-rtl.c (copy_insn_1, copy_most_rtx,
set_used_flags, verify_rtx_sharing): Remove references to QUEUED.
* genattrtab.c (attr_copy_rtx, clear_struct_flag,
encode_units_mask): Likewise.
* local-alloc.c (equiv_init_varies_p): Likewise.
* rtl.c (copy_rtx): Likewise.
* rtlanal.c (rtx_unstable_p, rtx_varies_p): Likewise.
* simplify-rtx.c (simplify_gen_subreg): Likewise.
* config/mn10300/mn10300.c (legitimate_pic_operand_p): Likewise.
* builtins.c (expand_builtin, expand_builtin_apply,
expand_builtin_mathfn, expand_builtin_mathfn_2,
expand_builtin_mathfn_3, expand_builtin_setjmp_setup):
Remove calls to emit_queue and protect_from_queue.
* c-typeck.c (c_expand_asm_operands): Likewise.
* calls.c (expand_call, precompute_arguments,
precompute_register_parameters, rtx_for_function_call,
store_one_arg): Likewise.
* dojump.c (do_compare_and_jump, do_jump): Likewise.
* explow.c (memory_address): Likewise.
* expmed.c (clear_by_pieces_1, clear_storage,
clear_storage_via_libcall, emit_group_load,
emit_group_store, emit_store_flag,
expand_expr_real_1, store_by_pieces,
store_constructor, store_expr, try_casesi,
try_tablejump): Likewise.
* function.c (expand_pending_sizes): Likewise.
* optabs.c (emit_cmp_and_jump_insns,
emit_conditional_add, emit_conditional_move,
expand_fix, expand_float, prepare_cmp_insn): Likewise.
* stmt.c (emit_case_bit_tests,
expand_asm_expr, expand_computed_goto,
expand_decl_init, expand_end_case_type,
expand_end_stmt_expr, expand_expr_stmt_value,
expand_return, expand_start_case,
optimize_tail_recursion): Likewise.
* config/c4x/c4x.c (c4x_expand_builtin): Likewise.
* config/s390/s390.c (s390_expand_cmpmem): Likewise.
* config/c4x/c4x.c (c4x_va_arg): Do not pass
increments/decrements to the expander.
* config/fr30/fr30.c (fr30_pass_by_reference,
fr30_pass_by_value): Likewise.
* config/i860/i860.c (i860_va_arg): Likewise.
* config/iq2000/iq2000.c (iq2000_va_arg): Likewise.
* config/m32r/m32r.c (m32r_va_arg): Likewise.
* config/mips/mips.c (mips_va_arg): Likewise.
* config/mn10300/mn10300.c (mn10300_va_arg): Likewise.
* config/pa/pa.c (hppa_va_arg): Likewise.
cp/ChangeLog:
2004-07-03 Paolo Bonzini <bonzini@gnu.org>
* typeck.c (c_expand_asm_operands): Do not call emit_queue.
Index: builtins.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/builtins.c,v
retrieving revision 1.348
diff -u -r1.348 builtins.c
--- builtins.c 8 Jul 2004 03:40:29 -0000 1.348
+++ builtins.c 8 Jul 2004 14:27:39 -0000
@@ -525,8 +525,6 @@
buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
- emit_queue ();
-
/* We store the frame pointer and the address of receiver_label in
the buffer and use the rest of it for the stack save area, which
is machine-dependent. */
@@ -960,9 +958,8 @@
}
emit_insn (gen_prefetch (op0, op1, op2));
}
- else
#endif
- op0 = protect_from_queue (op0, 0);
+
/* Don't do anything with direct references to volatile memory, but
generate code to handle other side effects. */
if (!MEM_P (op0) && side_effects_p (op0))
@@ -1271,9 +1268,6 @@
incoming_args, 0, OPTAB_LIB_WIDEN);
#endif
- /* Perform postincrements before actually calling the function. */
- emit_queue ();
-
/* Push a new argument block and copy the arguments. Do not allow
the (potential) memcpy call below to interfere with our stack
manipulations. */
@@ -1777,7 +1771,6 @@
op0 = expand_expr (arg, subtarget, VOIDmode, 0);
- emit_queue ();
start_sequence ();
/* Compute into TARGET.
@@ -1932,7 +1925,6 @@
op0 = expand_expr (arg0, subtarget, VOIDmode, 0);
op1 = expand_expr (arg1, 0, VOIDmode, 0);
- emit_queue ();
start_sequence ();
/* Compute into TARGET.
@@ -2037,7 +2029,6 @@
op0 = expand_expr (arg, subtarget, VOIDmode, 0);
- emit_queue ();
start_sequence ();
/* Compute into TARGET.
@@ -5694,9 +5685,6 @@
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
- /* Perform postincrements before expanding builtin functions. */
- emit_queue ();
-
if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
Index: c-typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
retrieving revision 1.336
diff -u -r1.336 c-typeck.c
--- c-typeck.c 4 Jul 2004 17:28:55 -0000 1.336
+++ c-typeck.c 8 Jul 2004 14:27:40 -0000
@@ -6242,9 +6242,6 @@
readonly_error (o[i], "modification by `asm'");
}
}
-
- /* Those MODIFY_EXPRs could do autoincrements. */
- emit_queue ();
}
/* Generate a goto statement to LABEL. */
Index: calls.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/calls.c,v
retrieving revision 1.345
diff -u -r1.345 calls.c
--- calls.c 8 Jul 2004 07:45:32 -0000 1.345
+++ calls.c 8 Jul 2004 14:27:40 -0000
@@ -163,8 +163,6 @@
prepare_call_address (rtx funexp, rtx static_chain_value,
rtx *call_fusage, int reg_parm_seen, int sibcallp)
{
- funexp = protect_from_queue (funexp, 0);
-
/* Make a valid memory address and copy constants through pseudo-regs,
but not for a constant address if -fno-function-cse. */
if (GET_CODE (funexp) != SYMBOL_REF)
@@ -662,10 +660,6 @@
VOIDmode, 0);
preserve_temp_slots (args[i].value);
pop_temp_slots ();
-
- /* ANSI doesn't require a sequence point here,
- but PCC has one, so this will avoid some problems. */
- emit_queue ();
}
/* If the value is a non-legitimate constant, force it into a
@@ -1264,15 +1258,8 @@
if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
abort ();
- args[i].value
- = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
-
- /* ANSI doesn't require a sequence point here,
- but PCC has one, so this will avoid some problems. */
- emit_queue ();
-
args[i].initial_value = args[i].value
- = protect_from_queue (args[i].value, 0);
+ = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
mode = TYPE_MODE (TREE_TYPE (args[i].tree_value));
if (mode != args[i].mode)
@@ -1447,7 +1434,6 @@
push_temp_slots ();
funexp = expand_expr (addr, NULL_RTX, VOIDmode, 0);
pop_temp_slots (); /* FUNEXP can't be BLKmode. */
- emit_queue ();
}
return funexp;
}
@@ -2373,10 +2359,6 @@
if (pass == 0)
{
- /* Emit any queued insns now; otherwise they would end up in
- only one of the alternates. */
- emit_queue ();
-
/* State variables we need to save and restore between
iterations. */
save_pending_stack_adjust = pending_stack_adjust;
@@ -2798,9 +2780,6 @@
load_register_parameters (args, num_actuals, &call_fusage, flags,
pass == 0, &sibcall_failure);
- /* Perform postincrements before actually calling the function. */
- emit_queue ();
-
/* Save a pointer to the last insn before the call, so that we can
later safely search backwards to find the CALL_INSN. */
before_call = get_last_insn ();
@@ -3558,9 +3537,6 @@
|| (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
abort ();
- /* There's no need to call protect_from_queue, because
- either emit_move_insn or emit_push_insn will do that. */
-
/* Make sure it is a reasonable operand for a move or push insn. */
if (!REG_P (val) && !MEM_P (val)
&& ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
@@ -4076,7 +4052,6 @@
for a value of mode OUTMODE,
with NARGS different arguments, passed as alternating rtx values
and machine_modes to convert them to.
- The rtx values should have been passed through protect_from_queue already.
FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for `const'
calls, LCT_PURE for `pure' calls, LCT_CONST_MAKE_BLOCK for `const' calls
@@ -4448,10 +4423,6 @@
be deferred during the rest of the arguments. */
NO_DEFER_POP;
- /* ANSI doesn't require a sequence point here,
- but PCC has one, so this will avoid some problems. */
- emit_queue ();
-
/* Free any temporary slots made in processing this argument. Show
that we might have taken the address of something and pushed that
as an operand. */
Index: dojump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dojump.c,v
retrieving revision 1.23
diff -u -r1.23 dojump.c
--- dojump.c 8 Jul 2004 07:45:33 -0000 1.23
+++ dojump.c 8 Jul 2004 14:27:42 -0000
@@ -167,8 +167,6 @@
tree type;
enum machine_mode mode;
- emit_queue ();
-
switch (code)
{
case ERROR_MARK:
@@ -306,7 +304,6 @@
preserve_temp_slots (NULL_RTX);
free_temp_slots ();
pop_temp_slots ();
- emit_queue ();
do_pending_stack_adjust ();
do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
break;
@@ -619,8 +616,6 @@
temp = copy_to_reg (temp);
#endif
do_pending_stack_adjust ();
- /* Do any postincrements in the expression that was tested. */
- emit_queue ();
if (GET_CODE (temp) == CONST_INT
|| (GET_CODE (temp) == CONST_DOUBLE && GET_MODE (temp) == VOIDmode)
@@ -1018,9 +1013,6 @@
}
#endif
- /* Do any postincrements in the expression that was tested. */
- emit_queue ();
-
do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
((mode == BLKmode)
? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.401
diff -u -r1.401 emit-rtl.c
--- emit-rtl.c 4 Jul 2004 08:06:54 -0000 1.401
+++ emit-rtl.c 8 Jul 2004 14:27:42 -0000
@@ -2227,7 +2227,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -2408,7 +2407,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -2525,7 +2523,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -2651,7 +2648,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -2721,7 +2717,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -5005,7 +5000,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
Index: explow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/explow.c,v
retrieving revision 1.131
diff -u -r1.131 explow.c
--- explow.c 8 Jul 2004 07:41:58 -0000 1.131
+++ explow.c 8 Jul 2004 14:27:42 -0000
@@ -443,14 +443,6 @@
if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
x = force_reg (Pmode, x);
- /* Accept a QUEUED that refers to a REG
- even though that isn't a valid address.
- On attempting to put this in an insn we will call protect_from_queue
- which will turn it into a REG, which is valid. */
- else if (GET_CODE (x) == QUEUED
- && REG_P (QUEUED_VAR (x)))
- ;
-
/* We get better cse by rejecting indirect addressing at this stage.
Let the combiner create indirect addresses where appropriate.
For now, generate the code so that the subexpressions useful to share
@@ -855,7 +847,6 @@
adjust_stack (rtx adjust)
{
rtx temp;
- adjust = protect_from_queue (adjust, 0);
if (adjust == const0_rtx)
return;
@@ -885,7 +876,6 @@
anti_adjust_stack (rtx adjust)
{
rtx temp;
- adjust = protect_from_queue (adjust, 0);
if (adjust == const0_rtx)
return;
Index: expmed.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expmed.c,v
retrieving revision 1.178
diff -u -r1.178 expmed.c
--- expmed.c 8 Jul 2004 06:08:52 -0000 1.178
+++ expmed.c 8 Jul 2004 14:27:42 -0000
@@ -327,8 +327,6 @@
op0 = SUBREG_REG (op0);
}
- value = protect_from_queue (value, 0);
-
/* Use vec_extract patterns for extracting parts of vectors whenever
available. */
if (VECTOR_MODE_P (GET_MODE (op0))
@@ -577,8 +575,6 @@
}
offset = 0;
}
- else
- op0 = protect_from_queue (op0, 1);
/* If VALUE is a floating-point mode, access it as an integer of the
corresponding size. This can occur on a machine with 64 bit registers
@@ -747,9 +743,7 @@
The field starts at position BITPOS within the byte.
(If OP0 is a register, it may be a full word or a narrower mode,
but BITPOS still counts within a full word,
- which is significant on bigendian machines.)
-
- Note that protect_from_queue has already been done on OP0 and VALUE. */
+ which is significant on bigendian machines.) */
static void
store_fixed_bit_field (rtx op0, unsigned HOST_WIDE_INT offset,
@@ -1352,8 +1346,6 @@
}
offset = 0;
}
- else
- op0 = protect_from_queue (str_rtx, 1);
/* Now OFFSET is nonzero only for memory operands. */
@@ -1470,8 +1462,7 @@
bitsize_rtx = GEN_INT (bitsize);
bitpos_rtx = GEN_INT (xbitpos);
- pat = gen_extzv (protect_from_queue (xtarget, 1),
- xop0, bitsize_rtx, bitpos_rtx);
+ pat = gen_extzv (xtarget, xop0, bitsize_rtx, bitpos_rtx);
if (pat)
{
emit_insn (pat);
@@ -1599,8 +1590,7 @@
bitsize_rtx = GEN_INT (bitsize);
bitpos_rtx = GEN_INT (xbitpos);
- pat = gen_extv (protect_from_queue (xtarget, 1),
- xop0, bitsize_rtx, bitpos_rtx);
+ pat = gen_extv (xtarget, xop0, bitsize_rtx, bitpos_rtx);
if (pat)
{
emit_insn (pat);
@@ -2506,10 +2496,6 @@
int opno;
enum machine_mode nmode;
- /* op0 must be register to make mult_cost match the precomputed
- shiftadd_cost array. */
- op0 = protect_from_queue (op0, 0);
-
/* Avoid referencing memory over and over.
For speed, but also for correctness when mem is volatile. */
if (MEM_P (op0))
@@ -4547,10 +4533,6 @@
rtx last = get_last_insn ();
rtx pattern, comparison;
- /* ??? Ok to do this and then fail? */
- op0 = protect_from_queue (op0, 0);
- op1 = protect_from_queue (op1, 0);
-
if (unsignedp)
code = unsigned_condition (code);
@@ -4655,7 +4637,6 @@
first. */
if (GET_MODE_SIZE (target_mode) > GET_MODE_SIZE (mode))
{
- op0 = protect_from_queue (op0, 0);
op0 = convert_modes (target_mode, mode, op0, 0);
mode = target_mode;
}
@@ -4687,13 +4668,8 @@
insn_operand_predicate_fn pred;
/* We think we may be able to do this with a scc insn. Emit the
- comparison and then the scc insn.
-
- compare_from_rtx may call emit_queue, which would be deleted below
- if the scc insn fails. So call it ourselves before setting LAST.
- Likewise for do_pending_stack_adjust. */
+ comparison and then the scc insn. */
- emit_queue ();
do_pending_stack_adjust ();
last = get_last_insn ();
@@ -4930,7 +4906,6 @@
tem = expand_unop (mode, ffs_optab, op0, subtarget, 1);
else if (GET_MODE_SIZE (mode) < UNITS_PER_WORD)
{
- op0 = protect_from_queue (op0, 0);
tem = convert_modes (word_mode, mode, op0, 1);
mode = word_mode;
}
Index: expr.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.c,v
retrieving revision 1.673
diff -u -r1.673 expr.c
--- expr.c 8 Jul 2004 07:45:35 -0000 1.673
+++ expr.c 8 Jul 2004 14:27:43 -0000
@@ -119,7 +119,6 @@
int reverse;
};
-static rtx enqueue_insn (rtx, rtx);
static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,
unsigned int);
static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode,
@@ -151,7 +150,6 @@
static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);
static int is_aligning_offset (tree, tree);
-static rtx expand_increment (tree, int, int);
static void expand_operands (tree, tree, rtx, rtx*, rtx*,
enum expand_modifier);
static rtx do_store_flag (tree, rtx, enum machine_mode, int);
@@ -311,215 +309,6 @@
{
cfun->expr = ggc_alloc_cleared (sizeof (struct expr_status));
}
-
-/* Small sanity check that the queue is empty at the end of a function. */
-
-void
-finish_expr_for_function (void)
-{
- if (pending_chain)
- abort ();
-}
-
-/* Manage the queue of increment instructions to be output
- for POSTINCREMENT_EXPR expressions, etc. */
-
-/* Queue up to increment (or change) VAR later. BODY says how:
- BODY should be the same thing you would pass to emit_insn
- to increment right away. It will go to emit_insn later on.
-
- The value is a QUEUED expression to be used in place of VAR
- where you want to guarantee the pre-incrementation value of VAR. */
-
-static rtx
-enqueue_insn (rtx var, rtx body)
-{
- pending_chain = gen_rtx_QUEUED (GET_MODE (var), var, NULL_RTX, NULL_RTX,
- body, pending_chain);
- return pending_chain;
-}
-
-/* Use protect_from_queue to convert a QUEUED expression
- into something that you can put immediately into an instruction.
- If the queued incrementation has not happened yet,
- protect_from_queue returns the variable itself.
- If the incrementation has happened, protect_from_queue returns a temp
- that contains a copy of the old value of the variable.
-
- Any time an rtx which might possibly be a QUEUED is to be put
- into an instruction, it must be passed through protect_from_queue first.
- QUEUED expressions are not meaningful in instructions.
-
- Do not pass a value through protect_from_queue and then hold
- on to it for a while before putting it in an instruction!
- If the queue is flushed in between, incorrect code will result. */
-
-rtx
-protect_from_queue (rtx x, int modify)
-{
- RTX_CODE code = GET_CODE (x);
-
-#if 0 /* A QUEUED can hang around after the queue is forced out. */
- /* Shortcut for most common case. */
- if (pending_chain == 0)
- return x;
-#endif
-
- if (code != QUEUED)
- {
- /* A special hack for read access to (MEM (QUEUED ...)) to facilitate
- use of autoincrement. Make a copy of the contents of the memory
- location rather than a copy of the address, but not if the value is
- of mode BLKmode. Don't modify X in place since it might be
- shared. */
- if (code == MEM && GET_MODE (x) != BLKmode
- && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
- {
- rtx y = XEXP (x, 0);
- rtx new = replace_equiv_address_nv (x, QUEUED_VAR (y));
-
- if (QUEUED_INSN (y))
- {
- rtx temp = gen_reg_rtx (GET_MODE (x));
-
- emit_insn_before (gen_move_insn (temp, new),
- QUEUED_INSN (y));
- return temp;
- }
-
- /* Copy the address into a pseudo, so that the returned value
- remains correct across calls to emit_queue. */
- return replace_equiv_address (new, copy_to_reg (XEXP (new, 0)));
- }
-
- /* Otherwise, recursively protect the subexpressions of all
- the kinds of rtx's that can contain a QUEUED. */
- if (code == MEM)
- {
- rtx tem = protect_from_queue (XEXP (x, 0), 0);
- if (tem != XEXP (x, 0))
- {
- x = copy_rtx (x);
- XEXP (x, 0) = tem;
- }
- }
- else if (code == PLUS || code == MULT)
- {
- rtx new0 = protect_from_queue (XEXP (x, 0), 0);
- rtx new1 = protect_from_queue (XEXP (x, 1), 0);
- if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1))
- {
- x = copy_rtx (x);
- XEXP (x, 0) = new0;
- XEXP (x, 1) = new1;
- }
- }
- return x;
- }
- /* If the increment has not happened, use the variable itself. Copy it
- into a new pseudo so that the value remains correct across calls to
- emit_queue. */
- if (QUEUED_INSN (x) == 0)
- return copy_to_reg (QUEUED_VAR (x));
- /* If the increment has happened and a pre-increment copy exists,
- use that copy. */
- if (QUEUED_COPY (x) != 0)
- return QUEUED_COPY (x);
- /* The increment has happened but we haven't set up a pre-increment copy.
- Set one up now, and use it. */
- QUEUED_COPY (x) = gen_reg_rtx (GET_MODE (QUEUED_VAR (x)));
- emit_insn_before (gen_move_insn (QUEUED_COPY (x), QUEUED_VAR (x)),
- QUEUED_INSN (x));
- return QUEUED_COPY (x);
-}
-
-/* Return nonzero if X contains a QUEUED expression:
- if it contains anything that will be altered by a queued increment.
- We handle only combinations of MEM, PLUS, MINUS and MULT operators
- since memory addresses generally contain only those. */
-
-int
-queued_subexp_p (rtx x)
-{
- enum rtx_code code = GET_CODE (x);
- switch (code)
- {
- case QUEUED:
- return 1;
- case MEM:
- return queued_subexp_p (XEXP (x, 0));
- case MULT:
- case PLUS:
- case MINUS:
- return (queued_subexp_p (XEXP (x, 0))
- || queued_subexp_p (XEXP (x, 1)));
- default:
- return 0;
- }
-}
-
-/* Retrieve a mark on the queue. */
-
-static rtx
-mark_queue (void)
-{
- return pending_chain;
-}
-
-/* Perform all the pending incrementations that have been enqueued
- after MARK was retrieved. If MARK is null, perform all the
- pending incrementations. */
-
-static void
-emit_insns_enqueued_after_mark (rtx mark)
-{
- rtx p;
-
- /* The marked incrementation may have been emitted in the meantime
- through a call to emit_queue. In this case, the mark is not valid
- anymore so do nothing. */
- if (mark && ! QUEUED_BODY (mark))
- return;
-
- while ((p = pending_chain) != mark)
- {
- rtx body = QUEUED_BODY (p);
-
- switch (GET_CODE (body))
- {
- case INSN:
- case JUMP_INSN:
- case CALL_INSN:
- case CODE_LABEL:
- case BARRIER:
- case NOTE:
- QUEUED_INSN (p) = body;
- emit_insn (body);
- break;
-
-#ifdef ENABLE_CHECKING
- case SEQUENCE:
- abort ();
- break;
-#endif
-
- default:
- QUEUED_INSN (p) = emit_insn (body);
- break;
- }
-
- QUEUED_BODY (p) = 0;
- pending_chain = QUEUED_NEXT (p);
- }
-}
-
-/* Perform all the pending incrementations. */
-
-void
-emit_queue (void)
-{
- emit_insns_enqueued_after_mark (NULL_RTX);
-}
/* Copy data from FROM to TO, where the machine modes are not the same.
Both modes may be integer, or both may be floating.
@@ -540,8 +329,6 @@
enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN
: (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
if (to_real != from_real)
abort ();
@@ -898,10 +685,7 @@
Both X and MODE may be floating, or both integer.
UNSIGNEDP is nonzero if X is an unsigned value.
This can be done by referring to a part of X in place
- or by copying to a new temporary with conversion.
-
- This function *must not* call protect_from_queue
- except when putting X into an insn (in which case convert_move does it). */
+ or by copying to a new temporary with conversion. */
rtx
convert_to_mode (enum machine_mode mode, rtx x, int unsignedp)
@@ -917,10 +701,7 @@
This can be done by referring to a part of X in place
or by copying to a new temporary with conversion.
- You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode.
-
- This function *must not* call protect_from_queue
- except when putting X into an insn (in which case convert_move does it). */
+ You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode. */
rtx
convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int unsignedp)
@@ -1039,8 +820,7 @@
}
/* Generate several move instructions to copy LEN bytes from block FROM to
- block TO. (These are MEM rtx's with BLKmode). The caller must pass FROM
- and TO through protect_from_queue before calling.
+ block TO. (These are MEM rtx's with BLKmode).
If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is
used to push FROM to the stack.
@@ -1341,10 +1121,6 @@
align = MIN (MEM_ALIGN (x), MEM_ALIGN (y));
- x = protect_from_queue (x, 1);
- y = protect_from_queue (y, 0);
- size = protect_from_queue (size, 0);
-
if (!MEM_P (x))
abort ();
if (!MEM_P (y))
@@ -1514,24 +1290,9 @@
enum machine_mode size_mode;
rtx retval;
- /* DST, SRC, or SIZE may have been passed through protect_from_queue.
-
- It is unsafe to save the value generated by protect_from_queue and reuse
- it later. Consider what happens if emit_queue is called before the
- return value from protect_from_queue is used.
-
- Expansion of the CALL_EXPR below will call emit_queue before we are
- finished emitting RTL for argument setup. So if we are not careful we
- could get the wrong value for an argument.
-
- To avoid this problem we go ahead and emit code to copy the addresses of
- DST and SRC and SIZE into new pseudos.
-
- Note this is not strictly needed for library calls since they do not call
- emit_queue before loading their arguments. However, we may need to have
- library calls call emit_queue in the future since failing to do so could
- cause problems for targets which define SMALL_REGISTER_CLASSES and pass
- arguments in registers. */
+ /* Emit code to copy the addresses of DST and SRC and SIZE into new
+ pseudos. We can then place those new pseudos into a VAR_DECL and
+ use them later. */
dst_addr = copy_to_mode_reg (Pmode, XEXP (dst, 0));
src_addr = copy_to_mode_reg (Pmode, XEXP (src, 0));
@@ -1927,8 +1688,6 @@
build_int_2 (shift, 0), tmps[i], 0);
}
- emit_queue ();
-
/* Copy the extracted pieces into the proper (probable) hard regs. */
for (i = start; i < XVECLEN (dst, 0); i++)
emit_move_insn (XEXP (XVECEXP (dst, 0, i), 0), tmps[i]);
@@ -1983,7 +1742,6 @@
tmps[i] = gen_reg_rtx (GET_MODE (reg));
emit_move_insn (tmps[i], reg);
}
- emit_queue ();
/* If we won't be storing directly into memory, protect the real destination
from strange tricks we might play. */
@@ -2077,8 +1835,6 @@
mode, tmps[i], ssize);
}
- emit_queue ();
-
/* Copy from the pseudo into the (probable) hard reg. */
if (orig_dst != dst)
emit_move_insn (orig_dst, dst);
@@ -2325,7 +2081,6 @@
if (! STORE_BY_PIECES_P (len, align))
abort ();
- to = protect_from_queue (to, 1);
data.constfun = constfun;
data.constfundata = constfundata;
data.len = len;
@@ -2363,8 +2118,7 @@
}
/* Generate several move instructions to clear LEN bytes of block TO. (A MEM
- rtx with BLKmode). The caller must pass TO through protect_from_queue
- before calling. ALIGN is maximum alignment we can assume. */
+ rtx with BLKmode). ALIGN is maximum alignment we can assume. */
static void
clear_by_pieces (rtx to, unsigned HOST_WIDE_INT len, unsigned int align)
@@ -2394,8 +2148,7 @@
/* Subroutine of clear_by_pieces and store_by_pieces.
Generate several move instructions to store LEN bytes of block TO. (A MEM
- rtx with BLKmode). The caller must pass TO through protect_from_queue
- before calling. ALIGN is maximum alignment we can assume. */
+ rtx with BLKmode). ALIGN is maximum alignment we can assume. */
static void
store_by_pieces_1 (struct store_by_pieces *data ATTRIBUTE_UNUSED,
@@ -2535,9 +2288,6 @@
emit_move_insn (object, CONST0_RTX (GET_MODE (object)));
else
{
- object = protect_from_queue (object, 1);
- size = protect_from_queue (size, 0);
-
if (size == const0_rtx)
;
else if (GET_CODE (size) == CONST_INT
@@ -2618,24 +2368,8 @@
enum machine_mode size_mode;
rtx retval;
- /* OBJECT or SIZE may have been passed through protect_from_queue.
-
- It is unsafe to save the value generated by protect_from_queue
- and reuse it later. Consider what happens if emit_queue is
- called before the return value from protect_from_queue is used.
-
- Expansion of the CALL_EXPR below will call emit_queue before
- we are finished emitting RTL for argument setup. So if we are
- not careful we could get the wrong value for an argument.
-
- To avoid this problem we go ahead and emit code to copy OBJECT
- and SIZE into new pseudos.
-
- Note this is not strictly needed for library calls since they
- do not call emit_queue before loading their arguments. However,
- we may need to have library calls call emit_queue in the future
- since failing to do so could cause problems for targets which
- define SMALL_REGISTER_CLASSES and pass arguments in registers. */
+ /* Emit code to copy OBJECT and SIZE into new pseudos. We can then
+ place those into new pseudos into a VAR_DECL and use them later. */
object = copy_to_mode_reg (Pmode, XEXP (object, 0));
@@ -2739,9 +2473,6 @@
rtx y_cst = NULL_RTX;
rtx last_insn, set;
- x = protect_from_queue (x, 1);
- y = protect_from_queue (y, 0);
-
if (mode == BLKmode || (GET_MODE (y) != mode && GET_MODE (y) != VOIDmode))
abort ();
@@ -3406,7 +3137,7 @@
if (where_pad != none)
where_pad = (where_pad == downward ? upward : downward);
- xinner = x = protect_from_queue (x, 0);
+ xinner = x;
if (mode == BLKmode)
{
@@ -3850,8 +3581,6 @@
&& (bitsize != 1 || TREE_CODE (op1) != INTEGER_CST))
break;
value = expand_expr (op1, NULL_RTX, VOIDmode, 0);
- value = protect_from_queue (value, 0);
- to_rtx = protect_from_queue (to_rtx, 1);
binop = TREE_CODE (src) == PLUS_EXPR ? add_optab : sub_optab;
if (bitsize == 1
&& count + bitsize != GET_MODE_BITSIZE (GET_MODE (to_rtx)))
@@ -4033,7 +3762,6 @@
{
rtx temp;
rtx alt_rtl = NULL_RTX;
- rtx mark = mark_queue ();
int dont_return_target = 0;
int dont_store_target = 0;
@@ -4053,7 +3781,6 @@
part. */
expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
want_value & 2 ? EXPAND_STACK_PARM : EXPAND_NORMAL);
- emit_queue ();
return store_expr (TREE_OPERAND (exp, 1), target, want_value);
}
else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
@@ -4065,47 +3792,19 @@
rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
- emit_queue ();
- target = protect_from_queue (target, 1);
-
do_pending_stack_adjust ();
NO_DEFER_POP;
jumpifnot (TREE_OPERAND (exp, 0), lab1);
store_expr (TREE_OPERAND (exp, 1), target, want_value & 2);
- emit_queue ();
emit_jump_insn (gen_jump (lab2));
emit_barrier ();
emit_label (lab1);
store_expr (TREE_OPERAND (exp, 2), target, want_value & 2);
- emit_queue ();
emit_label (lab2);
OK_DEFER_POP;
return want_value & 1 ? target : NULL_RTX;
}
- else if (queued_subexp_p (target))
- /* If target contains a postincrement, let's not risk
- using it as the place to generate the rhs. */
- {
- if (GET_MODE (target) != BLKmode && GET_MODE (target) != VOIDmode)
- {
- /* Expand EXP into a new pseudo. */
- temp = gen_reg_rtx (GET_MODE (target));
- temp = expand_expr (exp, temp, GET_MODE (target),
- (want_value & 2
- ? EXPAND_STACK_PARM : EXPAND_NORMAL));
- }
- else
- temp = expand_expr (exp, NULL_RTX, GET_MODE (target),
- (want_value & 2
- ? EXPAND_STACK_PARM : EXPAND_NORMAL));
-
- /* If target is volatile, ANSI requires accessing the value
- *from* the target, if it is accessed. So make that happen.
- In no case return the target itself. */
- if (! MEM_VOLATILE_P (target) && (want_value & 1) != 0)
- dont_return_target = 1;
- }
else if ((want_value & 1) != 0
&& MEM_P (target)
&& ! MEM_VOLATILE_P (target)
@@ -4273,9 +3972,6 @@
bit-initialized. */
&& expr_size (exp) != const0_rtx)
{
- emit_insns_enqueued_after_mark (mark);
- target = protect_from_queue (target, 1);
- temp = protect_from_queue (temp, 0);
if (GET_MODE (temp) != GET_MODE (target)
&& GET_MODE (temp) != VOIDmode)
{
@@ -5031,7 +4727,6 @@
/* Build the head of the loop. */
do_pending_stack_adjust ();
- emit_queue ();
emit_label (loop_start);
/* Assign value to element index. */
@@ -5060,9 +4755,7 @@
/* Update the loop counter, and jump to the head of
the loop. */
- expand_increment (build (PREINCREMENT_EXPR,
- TREE_TYPE (index),
- index, integer_one_node), 0, 0);
+ expand_increment (index, integer_one_node);
emit_jump (loop_start);
/* Build the end of the loop. */
@@ -8121,7 +7814,6 @@
case COMPOUND_EXPR:
expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode, 0);
- emit_queue ();
return expand_expr_real (TREE_OPERAND (exp, 1),
(ignore ? const0_rtx : target),
VOIDmode, modifier, alt_rtl);
@@ -8460,7 +8152,6 @@
else
expand_expr (TREE_OPERAND (exp, 1),
ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
- emit_queue ();
emit_jump_insn (gen_jump (op1));
emit_barrier ();
emit_label (op0);
@@ -8473,7 +8164,6 @@
ignore ? const0_rtx : NULL_RTX, VOIDmode, 0);
}
- emit_queue ();
emit_label (op1);
OK_DEFER_POP;
@@ -8548,15 +8238,6 @@
expand_return (TREE_OPERAND (exp, 0));
return const0_rtx;
- case PREINCREMENT_EXPR:
- case PREDECREMENT_EXPR:
- return expand_increment (exp, 0, ignore);
-
- case POSTINCREMENT_EXPR:
- case POSTDECREMENT_EXPR:
- /* Faster to treat as pre-increment if result is not used. */
- return expand_increment (exp, ! ignore, ignore);
-
case ADDR_EXPR:
if (modifier == EXPAND_STACK_PARM)
target = 0;
@@ -8587,10 +8268,6 @@
if (ignore)
return op0;
- /* Pass 1 for MODIFY, so that protect_from_queue doesn't get
- clever and returns a REG when given a MEM. */
- op0 = protect_from_queue (op0, 1);
-
/* We would like the object in memory. If it is a constant, we can
have it be statically allocated into memory. For a non-constant,
we need to allocate some memory and store the value into it. */
@@ -8804,6 +8481,10 @@
case FILTER_EXPR:
return get_exception_filter (cfun);
+ case PREINCREMENT_EXPR:
+ case PREDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
case FDESC_EXPR:
/* Function descriptors are not valid except for as
initialization constants, and should not be expanded. */
@@ -9013,15 +8694,14 @@
and return the RTX for the result.
POST is 1 for postinc/decrements and 0 for preinc/decrements. */
-static rtx
-expand_increment (tree exp, int post, int ignore)
+rtx
+expand_increment (tree incremented, tree amount)
{
rtx op0, op1;
rtx temp, value;
- tree incremented = TREE_OPERAND (exp, 0);
- optab this_optab = add_optab;
+ optab this_optab;
int icode;
- enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
+ enum machine_mode mode = TYPE_MODE (TREE_TYPE (incremented));
int op0_is_copy = 0;
int single_insn = 0;
/* 1 means we can't store into OP0 directly,
@@ -9031,18 +8711,7 @@
/* Stabilize any component ref that might need to be
evaluated more than once below. */
- if (!post
- || TREE_CODE (incremented) == BIT_FIELD_REF
- || (TREE_CODE (incremented) == COMPONENT_REF
- && (TREE_CODE (TREE_OPERAND (incremented, 0)) != INDIRECT_REF
- || DECL_BIT_FIELD (TREE_OPERAND (incremented, 1)))))
- incremented = stabilize_reference (incremented);
- /* Nested *INCREMENT_EXPRs can happen in C++. We must force innermost
- ones into save exprs so that they don't accidentally get evaluated
- more than once by the code below. */
- if (TREE_CODE (incremented) == PREINCREMENT_EXPR
- || TREE_CODE (incremented) == PREDECREMENT_EXPR)
- incremented = save_expr (incremented);
+ incremented = stabilize_reference (incremented);
/* Compute the operands as RTX.
Note whether OP0 is the actual lvalue or a copy of it:
@@ -9060,156 +8729,66 @@
Note that we can safely modify this SUBREG since it is know not to be
shared (it was made by the expand_expr call above). */
- if (GET_CODE (op0) == SUBREG && SUBREG_PROMOTED_VAR_P (op0))
- {
- if (post)
- SUBREG_REG (op0) = copy_to_reg (SUBREG_REG (op0));
- else
- bad_subreg = 1;
- }
- else if (GET_CODE (op0) == SUBREG
- && GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD)
- {
- /* We cannot increment this SUBREG in place. If we are
- post-incrementing, get a copy of the old value. Otherwise,
- just mark that we cannot increment in place. */
- if (post)
- op0 = copy_to_reg (op0);
- else
- bad_subreg = 1;
- }
+ if (GET_CODE (op0) == SUBREG
+ && (SUBREG_PROMOTED_VAR_P (op0)
+ || GET_MODE_BITSIZE (GET_MODE (op0)) < BITS_PER_WORD))
+ bad_subreg = 1;
op0_is_copy = ((GET_CODE (op0) == SUBREG || REG_P (op0))
&& temp != get_last_insn ());
- op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
-
- /* Decide whether incrementing or decrementing. */
- if (TREE_CODE (exp) == POSTDECREMENT_EXPR
- || TREE_CODE (exp) == PREDECREMENT_EXPR)
- this_optab = sub_optab;
-
- /* Convert decrement by a constant into a negative increment. */
- if (this_optab == sub_optab
- && GET_CODE (op1) == CONST_INT)
- {
- op1 = GEN_INT (-INTVAL (op1));
- this_optab = add_optab;
- }
+ op1 = expand_expr (amount, NULL_RTX, VOIDmode, 0);
- if (TYPE_TRAP_SIGNED (TREE_TYPE (exp)))
- this_optab = this_optab == add_optab ? addv_optab : subv_optab;
+ this_optab = TYPE_TRAP_SIGNED (TREE_TYPE (incremented))
+ ? addv_optab : add_optab;
/* For a preincrement, see if we can do this with a single instruction. */
- if (!post)
- {
- icode = (int) this_optab->handlers[(int) mode].insn_code;
- if (icode != (int) CODE_FOR_nothing
- /* Make sure that OP0 is valid for operands 0 and 1
- of the insn we want to queue. */
- && (*insn_data[icode].operand[0].predicate) (op0, mode)
- && (*insn_data[icode].operand[1].predicate) (op0, mode)
- && (*insn_data[icode].operand[2].predicate) (op1, mode))
- single_insn = 1;
- }
+ icode = (int) this_optab->handlers[(int) mode].insn_code;
+ if (icode != (int) CODE_FOR_nothing
+ /* Make sure that OP0 is valid for operands 0 and 1
+ of the insn we want to queue. */
+ && (*insn_data[icode].operand[0].predicate) (op0, mode)
+ && (*insn_data[icode].operand[1].predicate) (op0, mode)
+ && (*insn_data[icode].operand[2].predicate) (op1, mode))
+ single_insn = 1;
/* If OP0 is not the actual lvalue, but rather a copy in a register,
then we cannot just increment OP0. We must therefore contrive to
- increment the original value. Then, for postincrement, we can return
- OP0 since it is a copy of the old value. For preincrement, expand here
+ increment the original value. For preincrement, expand here
unless we can do it with a single insn.
Likewise if storing directly into OP0 would clobber high bits
we need to preserve (bad_subreg). */
- if (op0_is_copy || (!post && !single_insn) || bad_subreg)
+ if (op0_is_copy || !single_insn || bad_subreg)
{
/* This is the easiest way to increment the value wherever it is.
Problems with multiple evaluation of INCREMENTED are prevented
- because either (1) it is a component_ref or preincrement,
- in which case it was stabilized above, or (2) it is an array_ref
- with constant index in an array in a register, which is
- safe to reevaluate. */
- tree newexp = build (((TREE_CODE (exp) == POSTDECREMENT_EXPR
- || TREE_CODE (exp) == PREDECREMENT_EXPR)
- ? MINUS_EXPR : PLUS_EXPR),
- TREE_TYPE (exp),
- incremented,
- TREE_OPERAND (exp, 1));
-
+ because either (1) it is a component_ref, in which case it was
+ stabilized above, or (2) it is an array_ref with constant index
+ in an array in a register, which is safe to reevaluate. */
+ tree newexp = build2 (PLUS_EXPR, TREE_TYPE (incremented),
+ incremented, amount);
while (TREE_CODE (incremented) == NOP_EXPR
|| TREE_CODE (incremented) == CONVERT_EXPR)
{
- newexp = convert (TREE_TYPE (incremented), newexp);
+ newexp = fold_convert (TREE_TYPE (incremented), newexp);
incremented = TREE_OPERAND (incremented, 0);
}
- temp = expand_assignment (incremented, newexp, ! post && ! ignore);
- return post ? op0 : temp;
+ return expand_assignment (incremented, newexp, 1);
}
-
- if (post)
+ else
{
- /* We have a true reference to the value in OP0.
- If there is an insn to add or subtract in this mode, queue it.
- Queuing the increment insn avoids the register shuffling
- that often results if we must increment now and first save
- the old value for subsequent use. */
-
-#if 0 /* Turned off to avoid making extra insn for indexed memref. */
- op0 = stabilize (op0);
-#endif
-
- icode = (int) this_optab->handlers[(int) mode].insn_code;
- if (icode != (int) CODE_FOR_nothing
- /* Make sure that OP0 is valid for operands 0 and 1
- of the insn we want to queue. */
- && (*insn_data[icode].operand[0].predicate) (op0, mode)
- && (*insn_data[icode].operand[1].predicate) (op0, mode))
- {
- if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
- op1 = force_reg (mode, op1);
-
- return enqueue_insn (op0, GEN_FCN (icode) (op0, op0, op1));
- }
- if (icode != (int) CODE_FOR_nothing && MEM_P (op0))
- {
- rtx addr = (general_operand (XEXP (op0, 0), mode)
- ? force_reg (Pmode, XEXP (op0, 0))
- : copy_to_reg (XEXP (op0, 0)));
- rtx temp, result;
+ /* Increment however we can. */
+ value = expand_binop (mode, this_optab, op0, op1, op0,
+ TYPE_UNSIGNED (TREE_TYPE (incremented)),
+ OPTAB_LIB_WIDEN);
+
+ /* Make sure the value is stored into OP0. */
+ if (value != op0)
+ emit_move_insn (op0, value);
- op0 = replace_equiv_address (op0, addr);
- temp = force_reg (GET_MODE (op0), op0);
- if (! (*insn_data[icode].operand[2].predicate) (op1, mode))
- op1 = force_reg (mode, op1);
-
- /* The increment queue is LIFO, thus we have to `queue'
- the instructions in reverse order. */
- enqueue_insn (op0, gen_move_insn (op0, temp));
- result = enqueue_insn (temp, GEN_FCN (icode) (temp, temp, op1));
- return result;
- }
+ return op0;
}
-
- /* Preincrement, or we can't increment with one simple insn. */
- if (post)
- /* Save a copy of the value before inc or dec, to return it later. */
- temp = value = copy_to_reg (op0);
- else
- /* Arrange to return the incremented value. */
- /* Copy the rtx because expand_binop will protect from the queue,
- and the results of that would be invalid for us to return
- if our caller does emit_queue before using our result. */
- temp = copy_rtx (value = op0);
-
- /* Increment however we can. */
- op1 = expand_binop (mode, this_optab, value, op1, op0,
- TYPE_UNSIGNED (TREE_TYPE (exp)), OPTAB_LIB_WIDEN);
-
- /* Make sure the value is stored into OP0. */
- if (op1 != op0)
- emit_move_insn (op0, op1);
-
- return temp;
}
/* Generate code to calculate EXP using a store-flag instruction
@@ -9419,9 +8998,7 @@
because, if the emit_store_flag does anything it will succeed and
OP0 and OP1 will not be used subsequently. */
- result = emit_store_flag (target, code,
- queued_subexp_p (op0) ? copy_rtx (op0) : op0,
- queued_subexp_p (op1) ? copy_rtx (op1) : op1,
+ result = emit_store_flag (target, code, op0, op1,
operand_mode, unsignedp, 1);
if (result)
@@ -9526,8 +9103,7 @@
index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
}
- emit_queue ();
- index = protect_from_queue (index, 0);
+
do_pending_stack_adjust ();
op_mode = insn_data[(int) CODE_FOR_casesi].operand[0].mode;
@@ -9653,8 +9229,6 @@
convert (index_type, index_expr),
convert (index_type, minval)));
index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
- emit_queue ();
- index = protect_from_queue (index, 0);
do_pending_stack_adjust ();
do_tablejump (index, TYPE_MODE (index_type),
Index: expr.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.h,v
retrieving revision 1.160
diff -u -r1.160 expr.h
--- expr.h 7 Jul 2004 19:23:58 -0000 1.160
+++ expr.h 8 Jul 2004 14:27:43 -0000
@@ -39,25 +39,6 @@
#define BRANCH_COST 1
#endif
-/* Macros to access the slots of a QUEUED rtx.
- Here rather than in rtl.h because only the expansion pass
- should ever encounter a QUEUED. */
-
-/* The variable for which an increment is queued. */
-#define QUEUED_VAR(P) XEXP (P, 0)
-/* If the increment has been emitted, this is the insn
- that does the increment. It is zero before the increment is emitted.
- If more than one insn is emitted, this is the first insn. */
-#define QUEUED_INSN(P) XEXP (P, 1)
-/* If a pre-increment copy has been generated, this is the copy
- (it is a temporary reg). Zero if no copy made yet. */
-#define QUEUED_COPY(P) XEXP (P, 2)
-/* This is the body to use for the insn to do the increment.
- It is used to emit the increment. */
-#define QUEUED_BODY(P) XEXP (P, 3)
-/* Next QUEUED in the queue. */
-#define QUEUED_NEXT(P) XEXP (P, 4)
-
/* This is the 4th arg to `expand_expr'.
EXPAND_STACK_PARM means we are possibly expanding a call param onto
the stack. Choosing a value of 2 isn't special; It just allows
@@ -302,8 +283,7 @@
/* Create but don't emit one rtl instruction to perform certain operations.
Modes must match; operands must meet the operation's predicates.
- Likewise for subtraction and for just copying.
- These do not call protect_from_queue; caller must do so. */
+ Likewise for subtraction and for just copying. */
extern rtx gen_add2_insn (rtx, rtx);
extern rtx gen_add3_insn (rtx, rtx, rtx);
extern rtx gen_sub2_insn (rtx, rtx);
@@ -320,6 +300,10 @@
/* Generate code to indirectly jump to a location given in the rtx LOC. */
extern void emit_indirect_jump (rtx);
+/* Arguments VAR, AMOUNT: generate code to increment VAR by AMOUNT.
+ Return the place in which the incremented value is stored. */
+extern rtx expand_increment (tree, tree);
+
#include "insn-config.h"
#ifdef HAVE_conditional_move
@@ -390,19 +374,6 @@
/* This is run at the start of compiling a function. */
extern void init_expr (void);
-/* This is run at the end of compiling a function. */
-extern void finish_expr_for_function (void);
-
-/* Use protect_from_queue to convert a QUEUED expression
- into something that you can put immediately into an instruction. */
-extern rtx protect_from_queue (rtx, int);
-
-/* Perform all the pending incrementations. */
-extern void emit_queue (void);
-
-/* Tell if something has a queued subexpression. */
-extern int queued_subexp_p (rtx);
-
/* Emit some rtl insns to move data between rtx's, converting machine modes.
Both modes must be floating or both fixed. */
extern void convert_move (rtx, rtx, int);
Index: function.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/function.c,v
retrieving revision 1.550
diff -u -r1.550 function.c
--- function.c 8 Jul 2004 07:45:39 -0000 1.550
+++ function.c 8 Jul 2004 14:27:43 -0000
@@ -4066,12 +4066,7 @@
/* Evaluate now the sizes of any types declared among the arguments. */
for (tem = pending_sizes; tem; tem = TREE_CHAIN (tem))
- {
- expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
- /* Flush the queue in case this parameter declaration has
- side-effects. */
- emit_queue ();
- }
+ expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
}
/* Start the RTL for a new function, and set variables used for
@@ -4330,8 +4325,6 @@
{
rtx clobber_after;
- finish_expr_for_function ();
-
/* If arg_pointer_save_area was referenced only from a nested
function, we will not have initialized it yet. Do that now. */
if (arg_pointer_save_area && ! cfun->arg_pointer_save_area_init)
Index: function.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/function.h,v
retrieving revision 1.127
diff -u -r1.127 function.h
--- function.h 4 Jul 2004 08:06:54 -0000 1.127
+++ function.h 8 Jul 2004 14:27:43 -0000
@@ -147,9 +147,6 @@
/* List of labels that must never be deleted. */
rtx x_forced_labels;
-
- /* Postincrements that still need to be expanded. */
- rtx x_pending_chain;
};
#define pending_stack_adjust (cfun->expr->x_pending_stack_adjust)
@@ -157,7 +154,6 @@
#define saveregs_value (cfun->expr->x_saveregs_value)
#define apply_args_value (cfun->expr->x_apply_args_value)
#define forced_labels (cfun->expr->x_forced_labels)
-#define pending_chain (cfun->expr->x_pending_chain)
#define stack_pointer_delta (cfun->expr->x_stack_pointer_delta)
/* This structure can save all the important global and static variables
Index: genattrtab.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/genattrtab.c,v
retrieving revision 1.147
diff -u -r1.147 genattrtab.c
--- genattrtab.c 8 Jul 2004 03:40:29 -0000 1.147
+++ genattrtab.c 8 Jul 2004 14:27:44 -0000
@@ -838,7 +838,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -2218,7 +2217,6 @@
return attr_rtx (CONST_STRING, attr_printf (MAX_DIGITS, "%d", j));
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
@@ -4174,7 +4172,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
Index: local-alloc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/local-alloc.c,v
retrieving revision 1.133
diff -u -r1.133 local-alloc.c
--- local-alloc.c 7 Jul 2004 19:23:59 -0000 1.133
+++ local-alloc.c 8 Jul 2004 14:27:44 -0000
@@ -520,9 +520,6 @@
case MEM:
return ! RTX_UNCHANGING_P (x) || equiv_init_varies_p (XEXP (x, 0));
- case QUEUED:
- return 1;
-
case CONST:
case CONST_INT:
case CONST_DOUBLE:
Index: optabs.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/optabs.c,v
retrieving revision 1.227
diff -u -r1.227 optabs.c
--- optabs.c 7 Jul 2004 19:24:00 -0000 1.227
+++ optabs.c 8 Jul 2004 14:27:44 -0000
@@ -675,11 +675,6 @@
class = GET_MODE_CLASS (mode);
- op0 = protect_from_queue (op0, 0);
- op1 = protect_from_queue (op1, 0);
- if (target)
- target = protect_from_queue (target, 1);
-
if (flag_force_mem)
{
/* Load duplicate non-volatile operands once. */
@@ -2170,20 +2165,12 @@
class = GET_MODE_CLASS (mode);
- op0 = protect_from_queue (op0, 0);
-
if (flag_force_mem)
- {
- op0 = force_not_mem (op0);
- }
+ op0 = force_not_mem (op0);
- if (targ0)
- targ0 = protect_from_queue (targ0, 1);
- else
+ if (!targ0)
targ0 = gen_reg_rtx (mode);
- if (targ1)
- targ1 = protect_from_queue (targ1, 1);
- else
+ if (!targ1)
targ1 = gen_reg_rtx (mode);
/* Record where to go back to if we fail. */
@@ -2274,9 +2261,6 @@
class = GET_MODE_CLASS (mode);
- op0 = protect_from_queue (op0, 0);
- op1 = protect_from_queue (op1, 0);
-
if (flag_force_mem)
{
op0 = force_not_mem (op0);
@@ -2293,13 +2277,9 @@
&& rtx_cost (op1, binoptab->code) > COSTS_N_INSNS (1))
op1 = force_reg (mode, op1);
- if (targ0)
- targ0 = protect_from_queue (targ0, 1);
- else
+ if (!targ0)
targ0 = gen_reg_rtx (mode);
- if (targ1)
- targ1 = protect_from_queue (targ1, 1);
- else
+ if (!targ1)
targ1 = gen_reg_rtx (mode);
/* Record where to go back to if we fail. */
@@ -2502,15 +2482,8 @@
class = GET_MODE_CLASS (mode);
- op0 = protect_from_queue (op0, 0);
-
if (flag_force_mem)
- {
- op0 = force_not_mem (op0);
- }
-
- if (target)
- target = protect_from_queue (target, 1);
+ op0 = force_not_mem (op0);
if (unoptab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
{
@@ -3039,18 +3012,11 @@
if (submode == BLKmode)
abort ();
- op0 = protect_from_queue (op0, 0);
-
if (flag_force_mem)
- {
- op0 = force_not_mem (op0);
- }
+ op0 = force_not_mem (op0);
last = get_last_insn ();
- if (target)
- target = protect_from_queue (target, 1);
-
this_abs_optab = ! unsignedp && flag_trapv
&& (GET_MODE_CLASS(mode) == MODE_INT)
? absv_optab : abs_optab;
@@ -3225,9 +3191,7 @@
enum machine_mode mode0 = insn_data[icode].operand[1].mode;
rtx pat;
- temp = target = protect_from_queue (target, 1);
-
- op0 = protect_from_queue (op0, 0);
+ temp = target;
/* Sign and zero extension from memory is often done specially on
RISC machines, so forcing into a register here can pessimize
@@ -3709,11 +3673,6 @@
if (size == 0)
abort ();
- emit_queue ();
- x = protect_from_queue (x, 0);
- y = protect_from_queue (y, 0);
- size = protect_from_queue (size, 0);
-
/* Try to use a memory block compare insn - either cmpstr
or cmpmem will do. */
for (cmp_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
@@ -3818,8 +3777,6 @@
prepare_operand (int icode, rtx x, int opnum, enum machine_mode mode,
enum machine_mode wider_mode, int unsignedp)
{
- x = protect_from_queue (x, 0);
-
if (mode != wider_mode)
x = convert_modes (wider_mode, mode, x, unsignedp);
@@ -3945,7 +3902,6 @@
op0 = force_reg (mode, op0);
#endif
- emit_queue ();
if (unsignedp)
comparison = unsigned_condition (comparison);
@@ -3972,8 +3928,8 @@
{
enum rtx_code comparison = *pcomparison;
enum rtx_code swapped = swap_condition (comparison);
- rtx x = protect_from_queue (*px, 0);
- rtx y = protect_from_queue (*py, 0);
+ rtx x = *px;
+ rtx y = *py;
enum machine_mode orig_mode = GET_MODE (x);
enum machine_mode mode;
rtx value, target, insns, equiv;
@@ -4164,18 +4120,11 @@
op3 = force_not_mem (op3);
}
- if (target)
- target = protect_from_queue (target, 1);
- else
+ if (!target)
target = gen_reg_rtx (mode);
subtarget = target;
- emit_queue ();
-
- op2 = protect_from_queue (op2, 0);
- op3 = protect_from_queue (op3, 0);
-
/* If the insn doesn't accept these operands, put them in pseudos. */
if (! (*insn_data[icode].operand[0].predicate)
@@ -4305,23 +4254,16 @@
op3 = force_not_mem (op3);
}
- if (target)
- target = protect_from_queue (target, 1);
- else
+ if (!target)
target = gen_reg_rtx (mode);
- subtarget = target;
-
- emit_queue ();
-
- op2 = protect_from_queue (op2, 0);
- op3 = protect_from_queue (op3, 0);
-
/* If the insn doesn't accept these operands, put them in pseudos. */
if (! (*insn_data[icode].operand[0].predicate)
- (subtarget, insn_data[icode].operand[0].mode))
+ (target, insn_data[icode].operand[0].mode))
subtarget = gen_reg_rtx (insn_data[icode].operand[0].mode);
+ else
+ subtarget = target;
if (! (*insn_data[icode].operand[2].predicate)
(op2, insn_data[icode].operand[2].mode))
@@ -4360,11 +4302,7 @@
/* These functions attempt to generate an insn body, rather than
emitting the insn, but if the gen function already emits them, we
- make no attempt to turn them back into naked patterns.
-
- They do not protect from queued increments,
- because they may be used 1) in protect_from_queue itself
- and 2) in other passes where there is no queue. */
+ make no attempt to turn them back into naked patterns. */
/* Generate and return an insn body to add Y to X. */
@@ -4621,9 +4559,6 @@
if (icode != CODE_FOR_nothing)
{
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
-
if (imode != GET_MODE (from))
from = convert_to_mode (imode, from, unsignedp);
@@ -4647,11 +4582,6 @@
rtx temp;
REAL_VALUE_TYPE offset;
- emit_queue ();
-
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
-
if (flag_force_mem)
from = force_not_mem (from);
@@ -4759,9 +4689,6 @@
rtx value;
convert_optab tab = unsignedp ? ufloat_optab : sfloat_optab;
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
-
if (GET_MODE_SIZE (GET_MODE (from)) < GET_MODE_SIZE (SImode))
from = convert_to_mode (SImode, from, unsignedp);
@@ -4827,9 +4754,6 @@
if (icode != CODE_FOR_nothing)
{
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
-
if (fmode != GET_MODE (from))
from = convert_to_mode (fmode, from, 0);
@@ -4889,10 +4813,6 @@
lab1 = gen_label_rtx ();
lab2 = gen_label_rtx ();
- emit_queue ();
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
-
if (flag_force_mem)
from = force_not_mem (from);
@@ -4963,9 +4883,6 @@
if (!libfunc)
abort ();
- to = protect_from_queue (to, 1);
- from = protect_from_queue (from, 0);
-
if (flag_force_mem)
from = force_not_mem (from);
Index: rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.c,v
retrieving revision 1.138
diff -u -r1.138 rtl.c
--- rtl.c 4 Jul 2004 08:06:54 -0000 1.138
+++ rtl.c 8 Jul 2004 14:27:44 -0000
@@ -214,7 +214,6 @@
switch (code)
{
case REG:
- case QUEUED:
case CONST_INT:
case CONST_DOUBLE:
case CONST_VECTOR:
Index: rtl.def
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.def,v
retrieving revision 1.87
diff -u -r1.87 rtl.def
--- rtl.def 4 Jul 2004 08:06:54 -0000 1.87
+++ rtl.def 8 Jul 2004 14:27:44 -0000
@@ -906,24 +906,6 @@
pretend to be looking at the entire value and comparing it. */
DEF_RTL_EXPR(CC0, "cc0", "", RTX_OBJ)
-/* =====================================================================
- A QUEUED expression really points to a member of the queue of instructions
- to be output later for postincrement/postdecrement.
- QUEUED expressions never become part of instructions.
- When a QUEUED expression would be put into an instruction,
- instead either the incremented variable or a copy of its previous
- value is used.
-
- Operands are:
- 0. the variable to be incremented (a REG rtx).
- 1. the incrementing instruction, or 0 if it hasn't been output yet.
- 2. A REG rtx for a copy of the old value of the variable, or 0 if none yet.
- 3. the body to use for the incrementing instruction
- 4. the next QUEUED expression in the queue.
- ====================================================================== */
-
-DEF_RTL_EXPR(QUEUED, "queued", "eeeee", RTX_EXTRA)
-
/* ----------------------------------------------------------------------
Expressions for operators in an rtl pattern
---------------------------------------------------------------------- */
Index: rtlanal.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtlanal.c,v
retrieving revision 1.193
diff -u -r1.193 rtlanal.c
--- rtlanal.c 4 Jul 2004 08:06:54 -0000 1.193
+++ rtlanal.c 8 Jul 2004 14:27:45 -0000
@@ -83,9 +83,6 @@
case MEM:
return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
- case QUEUED:
- return 1;
-
case CONST:
case CONST_INT:
case CONST_DOUBLE:
@@ -161,9 +158,6 @@
case MEM:
return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
- case QUEUED:
- return 1;
-
case CONST:
case CONST_INT:
case CONST_DOUBLE:
Index: simplify-rtx.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/simplify-rtx.c,v
retrieving revision 1.197
diff -u -r1.197 simplify-rtx.c
--- simplify-rtx.c 1 Jul 2004 13:09:39 -0000 1.197
+++ simplify-rtx.c 8 Jul 2004 14:27:45 -0000
@@ -3802,9 +3802,6 @@
|| byte >= GET_MODE_SIZE (innermode))
abort ();
- if (GET_CODE (op) == QUEUED)
- return NULL_RTX;
-
new = simplify_subreg (outermode, op, innermode, byte);
if (new)
return new;
Index: stmt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/stmt.c,v
retrieving revision 1.372
diff -u -r1.372 stmt.c
--- stmt.c 8 Jul 2004 07:45:45 -0000 1.372
+++ stmt.c 8 Jul 2004 14:27:45 -0000
@@ -430,7 +430,6 @@
x = convert_memory_address (Pmode, x);
- emit_queue ();
do_pending_stack_adjust ();
emit_indirect_jump (x);
}
@@ -1060,7 +1059,7 @@
if ((! allows_mem && MEM_P (op))
|| GET_CODE (op) == CONCAT)
{
- real_output_rtx[i] = protect_from_queue (op, 1);
+ real_output_rtx[i] = op;
op = gen_reg_rtx (GET_MODE (op));
if (is_inout)
emit_move_insn (op, real_output_rtx[i]);
@@ -1185,13 +1184,6 @@
generating_concat_p = 0;
- for (i = 0; i < ninputs - ninout; i++)
- ASM_OPERANDS_INPUT (body, i)
- = protect_from_queue (ASM_OPERANDS_INPUT (body, i), 0);
-
- for (i = 0; i < noutputs; i++)
- output_rtx[i] = protect_from_queue (output_rtx[i], 1);
-
/* For in-out operands, copy output rtx to input rtx. */
for (i = 0; i < ninout; i++)
{
@@ -1362,9 +1354,6 @@
TREE_VALUE (tail) = o[i];
}
}
-
- /* Those MODIFY_EXPRs could do autoincrements. */
- emit_queue ();
}
/* A subroutine of expand_asm_operands. Check that all operands have
@@ -1626,8 +1615,6 @@
/* Free any temporaries used to evaluate this expression. */
free_temp_slots ();
-
- emit_queue ();
}
/* Warn if EXP contains any computations whose results are not used.
@@ -2014,7 +2001,6 @@
if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
{
expand_expr (retval, NULL_RTX, VOIDmode, 0);
- emit_queue ();
expand_null_return ();
return;
}
@@ -2146,7 +2132,6 @@
result_reg_mode = tmpmode;
result_reg = gen_reg_rtx (result_reg_mode);
- emit_queue ();
for (i = 0; i < n_regs; i++)
emit_move_insn (operand_subword (result_reg, i, 0, result_reg_mode),
result_pseudos[i]);
@@ -2169,7 +2154,6 @@
val = assign_temp (nt, 0, 0, 1);
val = expand_expr (retval_rhs, val, GET_MODE (val), 0);
val = force_not_mem (val);
- emit_queue ();
/* Return the calculated value. */
expand_value_return (shift_return_value (val));
}
@@ -2177,7 +2161,6 @@
{
/* No hard reg used; calculate value into hard return reg. */
expand_expr (retval, const0_rtx, VOIDmode, 0);
- emit_queue ();
expand_value_return (result_rtl);
}
}
@@ -2694,13 +2677,11 @@
|| code == POINTER_TYPE || code == REFERENCE_TYPE)
expand_assignment (decl, convert (TREE_TYPE (decl), integer_zero_node),
0);
- emit_queue ();
}
else if (DECL_INITIAL (decl) && TREE_CODE (DECL_INITIAL (decl)) != TREE_LIST)
{
emit_line_note (DECL_SOURCE_LOCATION (decl));
expand_assignment (decl, DECL_INITIAL (decl), 0);
- emit_queue ();
}
/* Don't let the initialization count as "using" the variable. */
@@ -2813,7 +2794,6 @@
nesting_stack = thiscase;
do_pending_stack_adjust ();
- emit_queue ();
/* Make sure case_stmt.start points to something that won't
need any transformation before expand_end_case. */
@@ -3293,8 +3273,6 @@
convert (index_type, index_expr),
convert (index_type, minval)));
index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
- emit_queue ();
- index = protect_from_queue (index, 0);
do_pending_stack_adjust ();
mode = TYPE_MODE (index_type);
@@ -3446,7 +3424,6 @@
if (count == 0)
{
expand_expr (index_expr, const0_rtx, VOIDmode, 0);
- emit_queue ();
emit_jump (default_label);
}
@@ -3515,10 +3492,8 @@
}
}
- emit_queue ();
do_pending_stack_adjust ();
- index = protect_from_queue (index, 0);
if (MEM_P (index))
index = copy_to_reg (index);
if (GET_CODE (index) == CONST_INT
Index: config/c4x/c4x.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/c4x/c4x.c,v
retrieving revision 1.151
diff -u -r1.151 c4x.c
--- config/c4x/c4x.c 7 Jul 2004 19:24:11 -0000 1.151
+++ config/c4x/c4x.c 8 Jul 2004 14:27:46 -0000
@@ -725,13 +725,8 @@
rtx
c4x_va_arg (tree valist, tree type)
{
- tree t;
-
- t = build (PREDECREMENT_EXPR, TREE_TYPE (valist), valist,
- build_int_2 (int_size_in_bytes (type), 0));
- TREE_SIDE_EFFECTS (t) = 1;
-
- return expand_expr (t, NULL_RTX, Pmode, EXPAND_NORMAL);
+ return expand_increment (valist,
+ build_int_2 (-int_size_in_bytes (type), 0));
}
@@ -4807,7 +4802,6 @@
case C4X_BUILTIN_FIX:
arg0 = TREE_VALUE (arglist);
r0 = expand_expr (arg0, NULL_RTX, QFmode, 0);
- r0 = protect_from_queue (r0, 0);
if (! target || ! register_operand (target, QImode))
target = gen_reg_rtx (QImode);
emit_insn (gen_fixqfqi_clobber (target, r0));
@@ -4816,7 +4810,6 @@
case C4X_BUILTIN_FIX_ANSI:
arg0 = TREE_VALUE (arglist);
r0 = expand_expr (arg0, NULL_RTX, QFmode, 0);
- r0 = protect_from_queue (r0, 0);
if (! target || ! register_operand (target, QImode))
target = gen_reg_rtx (QImode);
emit_insn (gen_fix_truncqfqi2 (target, r0));
@@ -4829,8 +4822,6 @@
arg1 = TREE_VALUE (TREE_CHAIN (arglist));
r0 = expand_expr (arg0, NULL_RTX, QImode, 0);
r1 = expand_expr (arg1, NULL_RTX, QImode, 0);
- r0 = protect_from_queue (r0, 0);
- r1 = protect_from_queue (r1, 0);
if (! target || ! register_operand (target, QImode))
target = gen_reg_rtx (QImode);
emit_insn (gen_mulqi3_24_clobber (target, r0, r1));
@@ -4841,7 +4832,6 @@
break;
arg0 = TREE_VALUE (arglist);
r0 = expand_expr (arg0, NULL_RTX, QFmode, 0);
- r0 = protect_from_queue (r0, 0);
if (! target || ! register_operand (target, QFmode))
target = gen_reg_rtx (QFmode);
emit_insn (gen_toieee (target, r0));
@@ -4852,7 +4842,6 @@
break;
arg0 = TREE_VALUE (arglist);
r0 = expand_expr (arg0, NULL_RTX, QFmode, 0);
- r0 = protect_from_queue (r0, 0);
if (register_operand (r0, QFmode))
{
r1 = assign_stack_local (QFmode, GET_MODE_SIZE (QFmode), 0);
@@ -4869,7 +4858,6 @@
break;
arg0 = TREE_VALUE (arglist);
r0 = expand_expr (arg0, NULL_RTX, QFmode, 0);
- r0 = protect_from_queue (r0, 0);
if (! target || ! register_operand (target, QFmode))
target = gen_reg_rtx (QFmode);
emit_insn (gen_rcpfqf_clobber (target, r0));
Index: config/fr30/fr30.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/fr30/fr30.c,v
retrieving revision 1.41
diff -u -r1.41 fr30.c
--- config/fr30/fr30.c 7 Jul 2004 09:27:55 -0000 1.41
+++ config/fr30/fr30.c 8 Jul 2004 14:27:46 -0000
@@ -722,12 +722,11 @@
type_ptr = build_pointer_type (type);
type_ptr_ptr = build_pointer_type (type_ptr);
- t = build (POSTINCREMENT_EXPR, va_list_type_node, valist, build_int_2 (UNITS_PER_WORD, 0));
- TREE_SIDE_EFFECTS (t) = 1;
+ expand_increment (valist, build_int_2 (UNITS_PER_WORD, 0));
+
+ t = build2 (MINUS_EXPR, va_list_type_node, valist, build_int_2 (UNITS_PER_WORD, 0));
t = build1 (NOP_EXPR, type_ptr_ptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
t = build1 (INDIRECT_REF, type_ptr, t);
-
return expand_expr (t, NULL_RTX, Pmode, EXPAND_NORMAL);
}
@@ -741,9 +740,8 @@
if ((size % UNITS_PER_WORD) == 0)
{
- t = build (POSTINCREMENT_EXPR, va_list_type_node, valist, build_int_2 (size, 0));
- TREE_SIDE_EFFECTS (t) = 1;
-
+ expand_increment (valist, build_int_2 (size, 0));
+ t = build2 (MINUS_EXPR, va_list_type_node, valist, build_int_2 (size, 0));
return expand_expr (t, NULL_RTX, Pmode, EXPAND_NORMAL);
}
Index: config/i860/i860.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/i860/i860.c,v
retrieving revision 1.45
diff -u -r1.45 i860.c
--- config/i860/i860.c 7 Jul 2004 19:24:24 -0000 1.45
+++ config/i860/i860.c 8 Jul 2004 14:27:46 -0000
@@ -2043,10 +2043,7 @@
emit_label (lab_over);
/* Increment either the ireg_used or freg_used field. */
-
- u = build (PREINCREMENT_EXPR, TREE_TYPE (reg), reg, build_int_2 (n_reg, 0));
- TREE_SIDE_EFFECTS (u) = 1;
- expand_expr (u, const0_rtx, VOIDmode, EXPAND_NORMAL);
+ expand_increment (reg, build_int_2 (n_reg, 0));
return addr_rtx;
}
Index: config/iq2000/iq2000.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/iq2000/iq2000.c,v
retrieving revision 1.19
diff -u -r1.19 iq2000.c
--- config/iq2000/iq2000.c 4 Jul 2004 20:58:46 -0000 1.19
+++ config/iq2000/iq2000.c 8 Jul 2004 14:27:46 -0000
@@ -1629,15 +1629,12 @@
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
}
- t = build (POSTINCREMENT_EXPR, TREE_TYPE (gpr), gpr,
- size_int (rsize));
- r = expand_expr (t, addr_rtx, Pmode, EXPAND_NORMAL);
+ r = expand_increment (gpr, size_int (rsize));
+ t = build (MINUS_EXPR, TREE_TYPE (gpr), gpr, size_int (rsize));
+ r = expand_expr (t, r, Pmode, EXPAND_NORMAL);
if (r != addr_rtx)
emit_move_insn (addr_rtx, r);
- /* Flush the POSTINCREMENT. */
- emit_queue();
-
if (indirect)
{
r = gen_rtx_MEM (Pmode, addr_rtx);
@@ -1688,7 +1685,6 @@
t = build (MODIFY_EXPR, TREE_TYPE (foff), foff, t);
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
- emit_queue ();
emit_jump (lab_over);
emit_barrier ();
emit_label (lab_false);
@@ -1704,13 +1700,12 @@
/* Emit code for addr_rtx = the ovfl pointer into overflow area.
Postincrement the ovfl pointer by 8. */
- t = build (POSTINCREMENT_EXPR, TREE_TYPE(ovfl), ovfl,
- size_int (8));
- r = expand_expr (t, addr_rtx, Pmode, EXPAND_NORMAL);
+ r = expand_increment (ovfl, size_int (8));
+ t = build (MINUS_EXPR, TREE_TYPE (ovfl), ovfl, size_int (8));
+ r = expand_expr (t, r, Pmode, EXPAND_NORMAL);
if (r != addr_rtx)
- emit_move_insn (addr_rtx, r);
+ emit_move_insn (addr_rtx, r);
- emit_queue();
emit_label (lab_over);
return addr_rtx;
}
@@ -1756,19 +1751,17 @@
t = build (MODIFY_EXPR, TREE_TYPE (goff), goff, t);
expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
- emit_queue();
emit_jump (lab_over);
emit_barrier ();
emit_label (lab_false);
/* Emit code for addr_rtx -> overflow area, postinc by step_size. */
- t = build (POSTINCREMENT_EXPR, TREE_TYPE(ovfl), ovfl,
- size_int (step_size));
- r = expand_expr (t, addr_rtx, Pmode, EXPAND_NORMAL);
+ r = expand_increment (ovfl, size_int (step_size));
+ t = build (MINUS_EXPR, TREE_TYPE (ovfl), ovfl, size_int (step_size));
+ r = expand_expr (t, r, Pmode, EXPAND_NORMAL);
if (r != addr_rtx)
- emit_move_insn (addr_rtx, r);
+ emit_move_insn (addr_rtx, r);
- emit_queue();
emit_label (lab_over);
if (indirect)
Index: config/m32r/m32r.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/m32r/m32r.c,v
retrieving revision 1.97
diff -u -r1.97 m32r.c
--- config/m32r/m32r.c 7 Jul 2004 19:24:26 -0000 1.97
+++ config/m32r/m32r.c 8 Jul 2004 14:27:46 -0000
@@ -1412,11 +1412,10 @@
type_ptr = build_pointer_type (type);
type_ptr_ptr = build_pointer_type (type_ptr);
- t = build (POSTINCREMENT_EXPR, va_list_type_node, valist,
- build_int_2 (UNITS_PER_WORD, 0));
- TREE_SIDE_EFFECTS (t) = 1;
+ expand_increment (valist, build_int_2 (UNITS_PER_WORD, 0));
+
+ t = build2 (MINUS_EXPR, va_list_type_node, valist, build_int_2 (UNITS_PER_WORD, 0));
t = build1 (NOP_EXPR, type_ptr_ptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
t = build1 (INDIRECT_REF, type_ptr, t);
addr_rtx = expand_expr (t, NULL_RTX, Pmode, EXPAND_NORMAL);
@@ -1441,9 +1440,9 @@
}
else
{
- t = build (POSTINCREMENT_EXPR, va_list_type_node, valist,
- build_int_2 (rsize, 0));
- TREE_SIDE_EFFECTS (t) = 1;
+ expand_increment (valist, build_int_2 (rsize, 0));
+
+ t = build2 (MINUS_EXPR, va_list_type_node, valist, build_int_2 (rsize, 0));
addr_rtx = expand_expr (t, NULL_RTX, Pmode, EXPAND_NORMAL);
}
}
Index: config/mips/mips.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/mips/mips.c,v
retrieving revision 1.426
diff -u -r1.426 mips.c
--- config/mips/mips.c 7 Jul 2004 19:24:28 -0000 1.426
+++ config/mips/mips.c 8 Jul 2004 14:27:47 -0000
@@ -4145,14 +4145,11 @@
/* Emit code to set addr_rtx to the valist, and postincrement
the valist by the size of the argument, rounded up to the
next word. Account for padding on big-endian targets. */
- t = build (POSTINCREMENT_EXPR, TREE_TYPE (gpr), gpr,
- size_int (rsize));
+ expand_increment (gpr, size_int (rsize));
+ t = build (MINUS_EXPR, TREE_TYPE (gpr), gpr, size_int (rsize));
addr_rtx = expand_expr (t, 0, Pmode, EXPAND_NORMAL);
if (BYTES_BIG_ENDIAN)
addr_rtx = plus_constant (addr_rtx, rsize - size);
-
- /* Flush the POSTINCREMENT. */
- emit_queue();
}
else
{
@@ -4278,7 +4275,6 @@
/* [7] Emit code to jump over the else clause, then the label
that starts it. */
- emit_queue();
emit_jump (lab_over);
emit_barrier ();
emit_label (lab_false);
@@ -4296,17 +4292,19 @@
/* [10, 11]. Emit code to store ovfl in addr_rtx, then
post-increment ovfl by osize. On big-endian machines,
- the argument has OSIZE - SIZE bytes of leading padding. */
- t = build (POSTINCREMENT_EXPR, TREE_TYPE (ovfl), ovfl,
- size_int (osize));
+ the argument has OSIZE - SIZE bytes of leading padding,
+ so we compute (x += osize) - size. Otherwise, compute
+ (x += osize) - osize. */
+ expand_increment (ovfl, size_int (osize));
if (BYTES_BIG_ENDIAN && osize > size)
- t = build (PLUS_EXPR, TREE_TYPE (t), t,
- build_int_2 (osize - size, 0));
+ t = build (MINUS_EXPR, TREE_TYPE (t), t, build_int_2 (size, 0));
+ else
+ t = build (MINUS_EXPR, TREE_TYPE (t), t, build_int_2 (osize, 0));
+
r = expand_expr (t, addr_rtx, Pmode, EXPAND_NORMAL);
if (r != addr_rtx)
emit_move_insn (addr_rtx, r);
- emit_queue();
emit_label (lab_over);
}
if (indirect)
Index: config/mn10300/mn10300.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/mn10300/mn10300.c,v
retrieving revision 1.69
diff -u -r1.69 mn10300.c
--- config/mn10300/mn10300.c 4 Jul 2004 08:07:09 -0000 1.69
+++ config/mn10300/mn10300.c 8 Jul 2004 14:27:47 -0000
@@ -1460,17 +1460,16 @@
rtx
mn10300_va_arg (tree valist, tree type)
{
- HOST_WIDE_INT align, rsize;
+ HOST_WIDE_INT align, rsize, adjust;
tree t, ptr, pptr;
/* Compute the rounded size of the type. */
align = PARM_BOUNDARY / BITS_PER_UNIT;
rsize = (((int_size_in_bytes (type) + align - 1) / align) * align);
+ adjust = rsize > 8 ? 4 : rsize;
- t = build (POSTINCREMENT_EXPR, TREE_TYPE (valist), valist,
- build_int_2 ((rsize > 8 ? 4 : rsize), 0));
- TREE_SIDE_EFFECTS (t) = 1;
-
+ expand_increment (valist, build_int_2 (adjust, 0));
+ t = build (MINUS_EXPR, TREE_TYPE (valist), valist, build_int_2 (adjust, 0));
ptr = build_pointer_type (type);
/* "Large" types are passed by reference. */
@@ -1478,16 +1477,10 @@
{
pptr = build_pointer_type (ptr);
t = build1 (NOP_EXPR, pptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
-
t = build1 (INDIRECT_REF, ptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
}
else
- {
- t = build1 (NOP_EXPR, ptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
- }
+ t = build1 (NOP_EXPR, ptr, t);
/* Calculate! */
return expand_expr (t, NULL_RTX, Pmode, EXPAND_NORMAL);
@@ -1843,9 +1836,6 @@
|| XINT (x, 1) == UNSPEC_PLT))
return 1;
- if (GET_CODE (x) == QUEUED)
- return legitimate_pic_operand_p (QUEUED_VAR (x));
-
fmt = GET_RTX_FORMAT (GET_CODE (x));
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
{
Index: config/pa/pa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/pa/pa.c,v
retrieving revision 1.255
diff -u -r1.255 pa.c
--- config/pa/pa.c 7 Jul 2004 19:24:34 -0000 1.255
+++ config/pa/pa.c 8 Jul 2004 14:27:48 -0000
@@ -5984,18 +5984,17 @@
else
{
ptr = build_pointer_type (type);
+ pptr = build_pointer_type (ptr);
/* Args grow upward. */
- t = build (POSTINCREMENT_EXPR, TREE_TYPE (valist), valist,
+ expand_increment (valist,
+ build_int_2 (POINTER_SIZE / BITS_PER_UNIT, 0));
+
+ t = build (MINUS_EXPR, TREE_TYPE (valist), valist,
build_int_2 (POINTER_SIZE / BITS_PER_UNIT, 0));
- TREE_SIDE_EFFECTS (t) = 1;
- pptr = build_pointer_type (ptr);
t = build1 (NOP_EXPR, pptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
-
t = build1 (INDIRECT_REF, ptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
}
}
else /* !TARGET_64BIT */
@@ -6006,16 +6005,16 @@
if (size > 8 || size <= 0)
{
/* Args grow downward. */
- t = build (PREDECREMENT_EXPR, TREE_TYPE (valist), valist,
+ pptr = build_pointer_type (ptr);
+
+ expand_increment (valist,
+ build_int_2 (-POINTER_SIZE / BITS_PER_UNIT, 0));
+
+ t = build (PLUS_EXPR, TREE_TYPE (valist), valist,
build_int_2 (POINTER_SIZE / BITS_PER_UNIT, 0));
- TREE_SIDE_EFFECTS (t) = 1;
- pptr = build_pointer_type (ptr);
t = build1 (NOP_EXPR, pptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
-
t = build1 (INDIRECT_REF, ptr, t);
- TREE_SIDE_EFFECTS (t) = 1;
}
else
{
Index: config/s390/s390.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/s390/s390.c,v
retrieving revision 1.156
diff -u -r1.156 s390.c
--- config/s390/s390.c 7 Jul 2004 19:24:45 -0000 1.156
+++ config/s390/s390.c 8 Jul 2004 14:27:49 -0000
@@ -3184,10 +3184,6 @@
rtx (*gen_result) (rtx) =
GET_MODE (target) == DImode ? gen_cmpint_di : gen_cmpint_si;
- op0 = protect_from_queue (op0, 0);
- op1 = protect_from_queue (op1, 0);
- len = protect_from_queue (len, 0);
-
if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
{
if (INTVAL (len) > 0)
Index: cp/typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/typeck.c,v
retrieving revision 1.557
diff -u -r1.557 typeck.c
--- cp/typeck.c 7 Jul 2004 10:20:44 -0000 1.557
+++ cp/typeck.c 8 Jul 2004 14:27:51 -0000
@@ -5825,9 +5825,6 @@
readonly_error (o[i], "modification by `asm'", 1);
}
}
-
- /* Those MODIFY_EXPRs could do autoincrements. */
- emit_queue ();
}
/* If RETVAL is the address of, or a reference to, a local variable or