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 * 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 ): 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 * 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