Changeset 1394 for trunk/src/gcc/gcc/calls.c

Timestamp:

Apr 28, 2004, 6:58:06 AM (21 years ago)

Author:

bird

Message:

#1040: Joined the GCC 3.3.3 with the trunk.

File:

• trunk/src/gcc/gcc/calls.c (modified) (59 diffs, 1 prop)

trunk/src/gcc/gcc/calls.c

@@ -1 +1 @@
 /* Convert function calls to rtl insns, for GNU C compiler.
    Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998
-   1999, 2000, 2001 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -34 +34 @@
 #include "timevar.h"
 #include "sbitmap.h"
+#include "langhooks.h"
+#include "target.h"
+#include "except.h"
 
 #if !defined FUNCTION_OK_FOR_SIBCALL
@@ -92 +95 @@
      Also 0 if not passed in registers.  */
   int partial;
-  /* Non-zero if argument must be passed on stack.
+  /* Nonzero if argument must be passed on stack.
      Note that some arguments may be passed on the stack
      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
@@ -127 +130 @@
 };
 
-/* A vector of one char per byte of stack space.  A byte if non-zero if
+/* A vector of one char per byte of stack space.  A byte if nonzero if
    the corresponding stack location has been used.
    This vector is used to prevent a function call within an argument from
@@ -226 +229 @@
 static int combine_pending_stack_adjustment_and_call
                                                 PARAMS ((int, struct args_size *, int));
+static tree fix_unsafe_tree             PARAMS ((tree));
 
 #ifdef REG_PARM_STACK_SPACE
@@ -617 +621 @@
     REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_EH_REGION, const0_rtx,
                                                REG_NOTES (call_insn));
+  else
+    note_eh_region_may_contain_throw ();
 
   if (ecf_flags & ECF_NORETURN)
@@ -637 +643 @@
      if the context of the call as a whole permits.  */
   inhibit_defer_pop = old_inhibit_defer_pop;
+
+  /* Don't bother cleaning up after a noreturn function.  */
+  if (ecf_flags & (ECF_NORETURN | ECF_LONGJMP))
+    return;
 
   if (n_popped > 0)
@@ -802 +812 @@
 }
 
+/* Return true when exp contains alloca call.  */
+bool
+alloca_call_p (exp)
+     tree exp;
+{
+  if (TREE_CODE (exp) == CALL_EXPR
+      && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
+      && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
+          == FUNCTION_DECL)
+      && (special_function_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
+                              0) & ECF_MAY_BE_ALLOCA))
+    return true;
+  return false;
+}
+
 /* Detect flags (function attributes) from the function decl or type node.  */
 
@@ -825 +850 @@
       if (TREE_NOTHROW (exp))
         flags |= ECF_NOTHROW;
+
+      if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
+        flags |= ECF_LIBCALL_BLOCK;
     }
 
   if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
-    flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
+    flags |= ECF_CONST;
 
   if (TREE_THIS_VOLATILE (exp))
@@ -878 +906 @@
             emit_queue ();
           }
+
+        /* If the value is a non-legitimate constant, force it into a
+           pseudo now.  TLS symbols sometimes need a call to resolve.  */
+        if (CONSTANT_P (args[i].value)
+            && !LEGITIMATE_CONSTANT_P (args[i].value))
+          args[i].value = force_reg (args[i].mode, args[i].value);
 
         /* If we are to promote the function arg to a wider mode,
@@ -970 +1004 @@
         {
           save_area = assign_stack_temp (BLKmode, num_to_save, 0);
-          /* Cannot use emit_block_move here because it can be done by a
-             library call which in turn gets into this place again and deadly
-             infinite recursion happens.  */
-          move_by_pieces (validize_mem (save_area), stack_area, num_to_save,
-                          PARM_BOUNDARY);
+          emit_block_move (validize_mem (save_area), stack_area,
+                           GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
         }
       else
@@ -1011 +1042 @@
     emit_move_insn (stack_area, save_area);
   else
-    /* Cannot use emit_block_move here because it can be done by a library
-       call which in turn gets into this place again and deadly infinite
-       recursion happens.  */
-    move_by_pieces (stack_area, validize_mem (save_area),
-                    high_to_save - low_to_save + 1, PARM_BOUNDARY);
+    emit_block_move (stack_area, validize_mem (save_area),
+                     GEN_INT (high_to_save - low_to_save + 1),
+                     BLOCK_OP_CALL_PARM);
 }
 #endif /* REG_PARM_STACK_SPACE */
@@ -1056 +1085 @@
            calculating the bit offset.  */
         if (BYTES_BIG_ENDIAN
-            && !FUNCTION_ARG_REG_LITTLE_ENDIAN
             && bytes < UNITS_PER_WORD)
           big_endian_correction = (BITS_PER_WORD  - (bytes * BITS_PER_UNIT));
@@ -1542 +1570 @@
                   = gen_lowpart_SUBREG (mode, args[i].value);
                 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
-                SUBREG_PROMOTED_UNSIGNED_P (args[i].initial_value)
-                  = args[i].unsignedp;
+                SUBREG_PROMOTED_UNSIGNED_SET (args[i].initial_value,
+                  args[i].unsignedp);
               }
 #endif
@@ -1648 +1676 @@
           addr = plus_constant (addr, arg_offset);
           args[i].stack = gen_rtx_MEM (args[i].mode, addr);
+          set_mem_align (args[i].stack, PARM_BOUNDARY);
           set_mem_attributes (args[i].stack,
                               TREE_TYPE (args[i].tree_value), 1);
@@ -1658 +1687 @@
           addr = plus_constant (addr, arg_offset);
           args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
+          set_mem_align (args[i].stack_slot, PARM_BOUNDARY);
           set_mem_attributes (args[i].stack_slot,
                               TREE_TYPE (args[i].tree_value), 1);
@@ -1677 +1707 @@
    FNDECL will be NULL_TREE.
 
-   EXP is the CALL_EXPR for this call.  */
+   ADDR is the operand 0 of CALL_EXPR for this call.  */
 
 static rtx
-rtx_for_function_call (fndecl, exp)
+rtx_for_function_call (fndecl, addr)
      tree fndecl;
-     tree exp;
+     tree addr;
 {
   rtx funexp;
@@ -1706 +1736 @@
       push_temp_slots ();
       funaddr = funexp
-        = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
+        = expand_expr (addr, NULL_RTX, VOIDmode, 0);
       pop_temp_slots ();        /* FUNEXP can't be BLKmode.  */
       emit_queue ();
@@ -1884 +1914 @@
                   seq = get_insns ();
                   end_sequence ();
-                  emit_insns_before (seq, first_insn);
+                  emit_insn_before (seq, first_insn);
                   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
                 }
@@ -1907 +1937 @@
       warning ("called from here");
     }
-  mark_addressable (fndecl);
+  (*lang_hooks.mark_addressable) (fndecl);
   return (rtx) (size_t) - 1;
 }
@@ -1973 +2003 @@
    we already clobbered by tail call arguments (as noted in stored_args_map
    bitmap).
-   Return non-zero if X expression dereferences such argument slots,
+   Return nonzero if X expression dereferences such argument slots,
    zero otherwise.  */
 
@@ -2036 +2066 @@
    we already clobbered by tail call arguments (as noted in stored_args_map
    bitmap).  Add stack slots for ARG to stored_args_map bitmap afterwards.
-   Return non-zero if sequence after INSN dereferences such argument slots,
+   Return nonzero if sequence after INSN dereferences such argument slots,
    zero otherwise.  */
 
@@ -2207 +2237 @@
   rtx call_fusage;
   tree p = TREE_OPERAND (exp, 0);
+  tree addr = TREE_OPERAND (exp, 0);
   int i;
   /* The alignment of the stack, in bits.  */
@@ -2242 +2273 @@
               warning ("called from here");
             }
-          mark_addressable (fndecl);
+          (*lang_hooks.mark_addressable) (fndecl);
         }
 
@@ -2288 +2319 @@
                used.  */
             if (! TREE_ADDRESSABLE (fndecl))
-              mark_addressable (fndecl);
+              (*lang_hooks.mark_addressable) (fndecl);
             is_integrable = 0;
           }
@@ -2328 +2359 @@
 
   /* Operand 0 is a pointer-to-function; get the type of the function.  */
-  funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
+  funtype = TREE_TYPE (addr);
   if (! POINTER_TYPE_P (funtype))
     abort ();
@@ -2465 +2496 @@
   /* Tail recursion fails, when we are not dealing with recursive calls.  */
   if (!try_tail_recursion
-      || TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR
-      || TREE_OPERAND (TREE_OPERAND (exp, 0), 0) != current_function_decl)
+      || TREE_CODE (addr) != ADDR_EXPR
+      || TREE_OPERAND (addr, 0) != current_function_decl)
     try_tail_recursion = 0;
 
@@ -2490 +2521 @@
          before the sibcall_epilogue.  */
       || fndecl == NULL_TREE
-      || (flags & (ECF_RETURNS_TWICE | ECF_LONGJMP))
-      || TREE_THIS_VOLATILE (fndecl)
+      || (flags & (ECF_RETURNS_TWICE | ECF_LONGJMP | ECF_NORETURN))
       || !FUNCTION_OK_FOR_SIBCALL (fndecl)
       /* If this function requires more stack slots than the current
@@ -2498 +2528 @@
       /* If the callee pops its own arguments, then it must pop exactly
          the same number of arguments as the current function.  */
-      || RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
-         != RETURN_POPS_ARGS (current_function_decl,
-                              TREE_TYPE (current_function_decl),
-                              current_function_args_size))
-  try_tail_call = 0;
+      || (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
+          != RETURN_POPS_ARGS (current_function_decl,
+                               TREE_TYPE (current_function_decl),
+                               current_function_args_size))
+      || !(*lang_hooks.decls.ok_for_sibcall) (fndecl))
+    try_tail_call = 0;
 
   if (try_tail_call || try_tail_recursion)
@@ -2547 +2578 @@
       /* Do the same for the function address if it is an expression. */
       if (!fndecl)
-        TREE_OPERAND (exp, 0) = fix_unsafe_tree (TREE_OPERAND (exp, 0));
+        addr = fix_unsafe_tree (addr);
       /* Expanding one of those dangerous arguments could have added
          cleanups, but otherwise give it a whirl.  */
@@ -2941 +2972 @@
       NO_DEFER_POP;
 
-      funexp = rtx_for_function_call (fndecl, exp);
+      funexp = rtx_for_function_call (fndecl, addr);
 
       /* Figure out the register where the value, if any, will come back.  */
@@ -3077 +3108 @@
       /* Verify that we've deallocated all the stack we used.  */
       if (pass
+          && ! (flags & (ECF_NORETURN | ECF_LONGJMP))
           && old_stack_allocated != stack_pointer_delta - pending_stack_adjust)
         abort ();
@@ -3092 +3124 @@
               insns = get_insns ();
               end_sequence ();
-              emit_insns (insns);
+              emit_insn (insns);
             }
           else
@@ -3146 +3178 @@
           insns = get_insns ();
           end_sequence ();
-          emit_insns (insns);
+          emit_insn (insns);
           valreg = temp;
         }
@@ -3170 +3202 @@
 
           emit_barrier_after (last);
+
+          /* Stack adjustments after a noreturn call are dead code.  */
+          stack_pointer_delta = old_stack_allocated;
+          pending_stack_adjust = 0;
         }
 
@@ -3291 +3327 @@
           target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
           SUBREG_PROMOTED_VAR_P (target) = 1;
-          SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
+          SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
         }
 #endif
@@ -3330 +3366 @@
                   emit_move_insn (stack_area, args[i].save_area);
                 else
-                  emit_block_move (stack_area,
-                                   validize_mem (args[i].save_area),
-                                   GEN_INT (args[i].size.constant));
+                  emit_block_move (stack_area, args[i].save_area,
+                                   GEN_INT (args[i].size.constant),
+                                   BLOCK_OP_CALL_PARM);
               }
 
@@ -3433 +3469 @@
     }
   else
-    emit_insns (normal_call_insns);
+    emit_insn (normal_call_insns);
 
   currently_expanding_call--;
@@ -3498 +3534 @@
   int needed;
   rtx before_call;
+  tree tfom;                    /* type_for_mode (outmode, 0) */
 
 #ifdef REG_PARM_STACK_SPACE
@@ -3559 +3596 @@
   /* If this kind of value comes back in memory,
      decide where in memory it should come back.  */
-  if (outmode != VOIDmode && aggregate_value_p (type_for_mode (outmode, 0)))
-    {
+  if (outmode != VOIDmode)
+    {
+      tfom = (*lang_hooks.types.type_for_mode) (outmode, 0);
+      if (aggregate_value_p (tfom))    
+        {
 #ifdef PCC_STATIC_STRUCT_RETURN
-      rtx pointer_reg
-        = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)),
-                               0, 0);
-      mem_value = gen_rtx_MEM (outmode, pointer_reg);
-      pcc_struct_value = 1;
-      if (value == 0)
-        value = gen_reg_rtx (outmode);
+          rtx pointer_reg
+            = hard_function_value (build_pointer_type (tfom), 0, 0);
+          mem_value = gen_rtx_MEM (outmode, pointer_reg);
+          pcc_struct_value = 1;
+          if (value == 0)
+            value = gen_reg_rtx (outmode);
 #else /* not PCC_STATIC_STRUCT_RETURN */
-      struct_value_size = GET_MODE_SIZE (outmode);
-      if (value != 0 && GET_CODE (value) == MEM)
-        mem_value = value;
-      else
-        mem_value = assign_temp (type_for_mode (outmode, 0), 0, 1, 1);
-#endif
-
-      /* This call returns a big structure.  */
-      flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
-    }
+          struct_value_size = GET_MODE_SIZE (outmode);
+          if (value != 0 && GET_CODE (value) == MEM)
+            mem_value = value;
+          else
+            mem_value = assign_temp (tfom, 0, 1, 1);
+#endif
+          /* This call returns a big structure.  */
+          flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
+        }
+    }
+  else
+    tfom = void_type_node;
 
   /* ??? Unfinished: must pass the memory address as an argument.  */
@@ -3687 +3728 @@
 #endif
             ;
+
+          /* loop.c won't look at CALL_INSN_FUNCTION_USAGE of const/pure
+             functions, so we have to pretend this isn't such a function.  */
+          if (flags & ECF_LIBCALL_BLOCK)
+            {
+              rtx insns = get_insns ();
+              end_sequence ();
+              emit_insn (insns);
+            }
+          flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
 
           /* If this was a CONST function, it is now PURE since
@@ -3700 +3751 @@
           else if (must_copy)
             {
-              slot = assign_temp (type_for_mode (mode, 0), 0, 1, 1);
+              slot = assign_temp ((*lang_hooks.types.type_for_mode) (mode, 0),
+                                  0, 1, 1);
               emit_move_insn (slot, val);
             }
           else
             {
-              tree type = type_for_mode (mode, 0);
+              tree type = (*lang_hooks.types.type_for_mode) (mode, 0);
 
               slot = gen_rtx_MEM (mode,
@@ -3915 +3967 @@
               save_area = assign_stack_temp (BLKmode, num_to_save, 0);
               set_mem_align (save_area, PARM_BOUNDARY);
-              emit_block_move (validize_mem (save_area), stack_area,
-                               GEN_INT (num_to_save));
+              emit_block_move (save_area, stack_area, GEN_INT (num_to_save),
+                               BLOCK_OP_CALL_PARM);
             }
           else
@@ -3978 +4030 @@
                         plus_constant (argblock,
                                        argvec[argnum].offset.constant)));
-                  argvec[argnum].save_area = gen_reg_rtx (save_mode);
-
-                  emit_move_insn (argvec[argnum].save_area, stack_area);
+                  if (save_mode == BLKmode)
+                    {
+                      argvec[argnum].save_area
+                        = assign_stack_temp (BLKmode,
+                                             argvec[argnum].size.constant, 0);
+
+                      emit_block_move (validize_mem (argvec[argnum].save_area),
+                                       stack_area,
+                                       GEN_INT (argvec[argnum].size.constant),
+                                       BLOCK_OP_CALL_PARM);
+                    }
+                  else
+                    {
+                      argvec[argnum].save_area = gen_reg_rtx (save_mode);
+
+                      emit_move_insn (argvec[argnum].save_area, stack_area);
+                    }
                 }
             }
 
-          emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
-                          argblock, GEN_INT (argvec[argnum].offset.constant),
+          emit_push_insn (val, mode, NULL_TREE, NULL_RTX, PARM_BOUNDARY,
+                          partial, reg, 0, argblock,
+                          GEN_INT (argvec[argnum].offset.constant),
                           reg_parm_stack_space, ARGS_SIZE_RTX (alignment_pad));
 
@@ -4072 +4139 @@
   emit_call_1 (fun,
                get_identifier (XSTR (orgfun, 0)),
-               build_function_type (outmode == VOIDmode ? void_type_node
-                                    : type_for_mode (outmode, 0), NULL_TREE),
+               build_function_type (tfom, NULL_TREE),
                original_args_size.constant, args_size.constant,
                struct_value_size,
@@ -4113 +4179 @@
       rtx insns;
 
-      if (valreg == 0 || GET_CODE (valreg) == PARALLEL)
+      if (valreg == 0)
         {
           insns = get_insns ();
           end_sequence ();
-          emit_insns (insns);
+          emit_insn (insns);
         }
       else
         {
           rtx note = 0;
-          rtx temp = gen_reg_rtx (GET_MODE (valreg));
+          rtx temp;
           int i;
+
+          if (GET_CODE (valreg) == PARALLEL)
+            {
+              temp = gen_reg_rtx (outmode);
+              emit_group_store (temp, valreg, outmode);
+              valreg = temp;
+            }
+
+          temp = gen_reg_rtx (GET_MODE (valreg));
 
           /* Construct an "equal form" for the value which mentions all the
@@ -4158 +4233 @@
             emit_move_insn (value, mem_value);
         }
+      else if (GET_CODE (valreg) == PARALLEL)
+        {
+          if (value == 0)
+            value = gen_reg_rtx (outmode);
+          emit_group_store (value, valreg, outmode);
+        }
       else if (value != 0)
-        emit_move_insn (value, hard_libcall_value (outmode));
+        emit_move_insn (value, valreg);
       else
-        value = hard_libcall_value (outmode);
+        value = valreg;
     }
 
@@ -4187 +4268 @@
             emit_move_insn (stack_area, save_area);
           else
-            emit_block_move (stack_area, validize_mem (save_area),
-                             GEN_INT (high_to_save - low_to_save + 1));
+            emit_block_move (stack_area, save_area,
+                             GEN_INT (high_to_save - low_to_save + 1),
+                             BLOCK_OP_CALL_PARM);
         }
 #endif
@@ -4204 +4286 @@
                                              argvec[count].offset.constant)));
 
-            emit_move_insn (stack_area, argvec[count].save_area);
+            if (save_mode == BLKmode)
+              emit_block_move (stack_area,
+                               validize_mem (argvec[count].save_area),
+                               GEN_INT (argvec[count].size.constant),
+                               BLOCK_OP_CALL_PARM);
+            else
+              emit_move_insn (stack_area, argvec[count].save_area);
           }
 
@@ -4293 +4381 @@
    FNDECL is the declaration of the function we are calling.
 
-   Return non-zero if this arg should cause sibcall failure,
+   Return nonzero if this arg should cause sibcall failure,
    zero otherwise.  */
 
@@ -4301 +4389 @@
      rtx argblock;
      int flags;
-     int variable_size;
+     int variable_size ATTRIBUTE_UNUSED;
      int reg_parm_stack_space;
 {
@@ -4368 +4456 @@
                   preserve_temp_slots (arg->save_area);
                   emit_block_move (validize_mem (arg->save_area), stack_area,
-                                   expr_size (arg->tree_value));
+                                   expr_size (arg->tree_value),
+                                   BLOCK_OP_CALL_PARM);
                 }
               else
@@ -4376 +4465 @@
                 }
             }
-
-          /* Now that we have saved any slots that will be overwritten
-             by this store, mark all slots this store will use.  We
-             must do this before we actually expand the argument since
-             the expansion itself may trigger library calls which might
-             need to use the same stack slot. We only do it if we can't
-             pass all arguments to a library call in registers.  */
-          if (arg->partial)
-            {
-              for (i = lower_bound; i < upper_bound; i++)
-                stack_usage_map[i] = 1;
-
-              /* Set it so that we don't do it again.  */
-              variable_size = 1;
-            }
         }
     }
@@ -4444 +4518 @@
                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
                                 ? NULL_RTX : arg->stack,
-                                VOIDmode, 0);
+                                VOIDmode, EXPAND_STACK_PARM);
 
       /* If we are promoting object (or for any other reason) the mode
@@ -4497 +4571 @@
       /* This isn't already where we want it on the stack, so put it there.
          This can either be done with push or copy insns.  */
-      emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 0,
-                      partial, reg, used - size, argblock,
+      emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 
+                      PARM_BOUNDARY, partial, reg, used - size, argblock,
                       ARGS_SIZE_RTX (arg->offset), reg_parm_stack_space,
                       ARGS_SIZE_RTX (arg->alignment_pad));
@@ -4511 +4585 @@
       /* BLKmode, at least partly to be pushed.  */
 
+      unsigned int parm_align;
       int excess;
       rtx size_rtx;
@@ -4534 +4609 @@
           size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
                                   NULL_RTX, TYPE_MODE (sizetype), 0);
+        }
+
+      /* Some types will require stricter alignment, which will be
+         provided for elsewhere in argument layout.  */
+      parm_align = MAX (PARM_BOUNDARY, TYPE_ALIGN (TREE_TYPE (pval)));
+
+      /* When an argument is padded down, the block is aligned to
+         PARM_BOUNDARY, but the actual argument isn't.  */
+      if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
+        {
+          if (arg->size.var)
+            parm_align = BITS_PER_UNIT;
+          else if (excess)
+            {
+              unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
+              parm_align = MIN (parm_align, excess_align);
+            }
         }
 
@@ -4569 +4661 @@
         }
 
-      /* Special handling is required if part of the parameter lies in the
-         register parameter area.  The argument may be copied into the stack
-         slot using memcpy(), but the original contents of the register
-         parameter area will be restored after the memcpy() call.
-
-         To ensure that the part that lies in the register parameter area
-         is copied correctly, we emit a separate push for that part.  This
-         push should be small enough to avoid a call to memcpy().  */
-#ifndef STACK_PARMS_IN_REG_PARM_AREA
-      if (arg->reg && arg->pass_on_stack)
-#else
-      if (1)
-#endif
-        {
-          if (arg->offset.constant < reg_parm_stack_space && arg->offset.var)
-            error ("variable offset is passed partially in stack and in reg");
-          else if (arg->offset.constant < reg_parm_stack_space && arg->size.var)
-            error ("variable size is passed partially in stack and in reg");
-          else if (arg->offset.constant < reg_parm_stack_space 
-              && ((arg->offset.constant + arg->size.constant) 
-                   > reg_parm_stack_space))
-          {
-            rtx size_rtx1 = GEN_INT (reg_parm_stack_space - arg->offset.constant);
-            emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx1,
-                            TYPE_ALIGN (TREE_TYPE (pval)), partial, reg,
-                            excess, argblock, ARGS_SIZE_RTX (arg->offset),
-                            reg_parm_stack_space,
-                            ARGS_SIZE_RTX (arg->alignment_pad));
-          }
-        }
-        
-
       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
-                      TYPE_ALIGN (TREE_TYPE (pval)), partial, reg, excess,
-                      argblock, ARGS_SIZE_RTX (arg->offset),
-                      reg_parm_stack_space,
+                      parm_align, partial, reg, excess, argblock,
+                      ARGS_SIZE_RTX (arg->offset), reg_parm_stack_space,
                       ARGS_SIZE_RTX (arg->alignment_pad));
 
@@ -4619 +4678 @@
     }
 
+  /* Mark all slots this store used.  */
   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
       && argblock && ! variable_size && arg->stack)