OSDN Git Service

* ifcvt.c (find_if_case_1): Reinstate 2005-01-04 change, now that
[pf3gnuchains/gcc-fork.git] / gcc / calls.c
index c48fd82..0d0c0f2 100644 (file)
@@ -64,6 +64,9 @@ struct arg_data
      This is not the same register as for normal calls on machines with
      register windows.  */
   rtx tail_call_reg;
+  /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
+     form for emit_group_move.  */
+  rtx parallel_value;
   /* If REG was promoted from the actual mode of the argument expression,
      indicates whether the promotion is sign- or zero-extended.  */
   int unsignedp;
@@ -143,9 +146,9 @@ static int check_sibcall_argument_overlap_1 (rtx);
 static int check_sibcall_argument_overlap (rtx, struct arg_data *, int);
 
 static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
-                                                     int);
-static tree fix_unsafe_tree (tree);
-static bool shift_returned_value (tree, rtx *);
+                                                     unsigned int);
+static tree split_complex_values (tree);
+static tree split_complex_types (tree);
 
 #ifdef REG_PARM_STACK_SPACE
 static rtx save_fixed_argument_area (int, rtx, int *, int *);
@@ -350,7 +353,7 @@ emit_call_1 (rtx funexp, tree fntree, tree fndecl ATTRIBUTE_UNUSED,
     }
   else
 #endif
-    abort ();
+    gcc_unreachable ();
 
   /* Find the call we just emitted.  */
   call_insn = last_call_insn ();
@@ -431,7 +434,7 @@ emit_call_1 (rtx funexp, tree fntree, tree fndecl ATTRIBUTE_UNUSED,
 
       if (rounded_stack_size != 0)
        {
-         if (ecf_flags & (ECF_SP_DEPRESSED | ECF_NORETURN | ECF_LONGJMP))
+         if (ecf_flags & (ECF_SP_DEPRESSED | ECF_NORETURN))
            /* Just pretend we did the pop.  */
            stack_pointer_delta -= rounded_stack_size;
          else if (flag_defer_pop && inhibit_defer_pop == 0
@@ -521,7 +524,7 @@ special_function_p (tree fndecl, int flags)
 
          if (tname[1] == 'i'
              && ! strcmp (tname, "siglongjmp"))
-           flags |= ECF_LONGJMP;
+           flags |= ECF_NORETURN;
        }
       else if ((tname[0] == 'q' && tname[1] == 's'
                && ! strcmp (tname, "qsetjmp"))
@@ -531,7 +534,7 @@ special_function_p (tree fndecl, int flags)
 
       else if (tname[0] == 'l' && tname[1] == 'o'
               && ! strcmp (tname, "longjmp"))
-       flags |= ECF_LONGJMP;
+       flags |= ECF_NORETURN;
     }
 
   return flags;
@@ -643,7 +646,8 @@ call_expr_flags (tree t)
    Set REG_PARM_SEEN if we encounter a register parameter.  */
 
 static void
-precompute_register_parameters (int num_actuals, struct arg_data *args, int *reg_parm_seen)
+precompute_register_parameters (int num_actuals, struct arg_data *args,
+                               int *reg_parm_seen)
 {
   int i;
 
@@ -678,6 +682,17 @@ precompute_register_parameters (int num_actuals, struct arg_data *args, int *reg
                             TYPE_MODE (TREE_TYPE (args[i].tree_value)),
                             args[i].value, args[i].unsignedp);
 
+       /* If we're going to have to load the value by parts, pull the
+          parts into pseudos.  The part extraction process can involve
+          non-trivial computation.  */
+       if (GET_CODE (args[i].reg) == PARALLEL)
+         {
+           tree type = TREE_TYPE (args[i].tree_value);
+           args[i].parallel_value
+             = emit_group_load_into_temps (args[i].reg, args[i].value,
+                                           type, int_size_in_bytes (type));
+         }
+
        /* If the value is expensive, and we are inside an appropriately
           short loop, put the value into a pseudo and then put the pseudo
           into the hard reg.
@@ -686,13 +701,13 @@ precompute_register_parameters (int num_actuals, struct arg_data *args, int *reg
           register parameters.  This is to avoid reload conflicts while
           loading the parameters registers.  */
 
-       if ((! (REG_P (args[i].value)
-               || (GET_CODE (args[i].value) == SUBREG
-                   && REG_P (SUBREG_REG (args[i].value)))))
-           && args[i].mode != BLKmode
-           && rtx_cost (args[i].value, SET) > COSTS_N_INSNS (1)
-           && ((SMALL_REGISTER_CLASSES && *reg_parm_seen)
-               || preserve_subexpressions_p ()))
+       else if ((! (REG_P (args[i].value)
+                    || (GET_CODE (args[i].value) == SUBREG
+                        && REG_P (SUBREG_REG (args[i].value)))))
+                && args[i].mode != BLKmode
+                && rtx_cost (args[i].value, SET) > COSTS_N_INSNS (1)
+                && ((SMALL_REGISTER_CLASSES && *reg_parm_seen)
+                    || optimize))
          args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
       }
 }
@@ -817,10 +832,19 @@ store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
            < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
       {
        int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
-       int nregs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
        int endian_correction = 0;
 
-       args[i].n_aligned_regs = args[i].partial ? args[i].partial : nregs;
+       if (args[i].partial)
+         {
+           gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
+           args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
+         }
+       else
+         {
+           args[i].n_aligned_regs
+             = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
+         }
+
        args[i].aligned_regs = xmalloc (sizeof (rtx) * args[i].n_aligned_regs);
 
        /* Structures smaller than a word are normally aligned to the
@@ -958,7 +982,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
         args[i].reg is nonzero if all or part is passed in registers.
 
         args[i].partial is nonzero if part but not all is passed in registers,
-        and the exact value says how many words are passed in registers.
+        and the exact value says how many bytes are passed in registers.
 
         args[i].pass_on_stack is nonzero if the argument must at least be
         computed on the stack.  It may then be loaded back into registers
@@ -971,54 +995,30 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
       if (pass_by_reference (args_so_far, TYPE_MODE (type),
                             type, argpos < n_named_args))
        {
-         /* If we're compiling a thunk, pass through invisible
-             references instead of making a copy.  */
+         bool callee_copies;
+         tree base;
+
+         callee_copies
+           = reference_callee_copied (args_so_far, TYPE_MODE (type),
+                                      type, argpos < n_named_args);
+
+         /* If we're compiling a thunk, pass through invisible references
+            instead of making a copy.  */
          if (call_from_thunk_p
-             || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far, TYPE_MODE (type),
-                                            type, argpos < n_named_args)
-                 /* If it's in a register, we must make a copy of it too.  */
-                 /* ??? Is this a sufficient test?  Is there a better one? */
-                 && !(TREE_CODE (args[i].tree_value) == VAR_DECL
-                      && REG_P (DECL_RTL (args[i].tree_value)))
-                 && ! TREE_ADDRESSABLE (type))
-             )
+             || (callee_copies
+                 && !TREE_ADDRESSABLE (type)
+                 && (base = get_base_address (args[i].tree_value))
+                 && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
            {
-             /* C++ uses a TARGET_EXPR to indicate that we want to make a
-                new object from the argument.  If we are passing by
-                invisible reference, the callee will do that for us, so we
-                can strip off the TARGET_EXPR.  This is not always safe,
-                but it is safe in the only case where this is a useful
-                optimization; namely, when the argument is a plain object.
-                In that case, the frontend is just asking the backend to
-                make a bitwise copy of the argument.  */
-
-             if (TREE_CODE (args[i].tree_value) == TARGET_EXPR
-                 && (DECL_P (TREE_OPERAND (args[i].tree_value, 1)))
-                 && ! REG_P (DECL_RTL (TREE_OPERAND (args[i].tree_value, 1))))
-               args[i].tree_value = TREE_OPERAND (args[i].tree_value, 1);
-
-             /* We can't use sibcalls if a callee-copied argument is stored
-                in the current function's frame.  */
-             if (!call_from_thunk_p
-                 && (!DECL_P (args[i].tree_value)
-                     || !TREE_STATIC (args[i].tree_value)))
+             /* We can't use sibcalls if a callee-copied argument is
+                stored in the current function's frame.  */
+             if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
                *may_tailcall = false;
 
-             args[i].tree_value = build1 (ADDR_EXPR,
-                                          build_pointer_type (type),
-                                          args[i].tree_value);
-             type = build_pointer_type (type);
-           }
-         else if (TREE_CODE (args[i].tree_value) == TARGET_EXPR)
-           {
-             /* In the V3 C++ ABI, parameters are destroyed in the caller.
-                We implement this by passing the address of the temporary
-                rather than expanding it into another allocated slot.  */
-             args[i].tree_value = build1 (ADDR_EXPR,
-                                          build_pointer_type (type),
-                                          args[i].tree_value);
-             type = build_pointer_type (type);
-             *may_tailcall = false;
+             args[i].tree_value = build_fold_addr_expr (args[i].tree_value);
+             type = TREE_TYPE (args[i].tree_value);
+
+             *ecf_flags &= ~(ECF_CONST | ECF_LIBCALL_BLOCK);
            }
          else
            {
@@ -1052,12 +1052,15 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
                copy = assign_temp (type, 0, 1, 0);
 
              store_expr (args[i].tree_value, copy, 0);
-             *ecf_flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
 
-             args[i].tree_value = build1 (ADDR_EXPR,
-                                          build_pointer_type (type),
-                                          make_tree (type, copy));
-             type = build_pointer_type (type);
+             if (callee_copies)
+               *ecf_flags &= ~(ECF_CONST | ECF_LIBCALL_BLOCK);
+             else
+               *ecf_flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
+
+             args[i].tree_value
+               = build_fold_addr_expr (make_tree (type, copy));
+             type = TREE_TYPE (args[i].tree_value);
              *may_tailcall = false;
            }
        }
@@ -1085,8 +1088,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
 
       if (args[i].reg)
        args[i].partial
-         = FUNCTION_ARG_PARTIAL_NREGS (*args_so_far, mode, type,
-                                       argpos < n_named_args);
+         = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
+                                            argpos < n_named_args);
 
       args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
 
@@ -1180,8 +1183,7 @@ compute_argument_block_size (int reg_parm_stack_space,
          /* We don't handle this case yet.  To handle it correctly we have
             to add the delta, round and subtract the delta.
             Currently no machine description requires this support.  */
-         if (stack_pointer_delta & (preferred_stack_boundary - 1))
-           abort ();
+         gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1)));
          args_size->var = round_up (args_size->var, preferred_stack_boundary);
        }
 
@@ -1247,8 +1249,7 @@ precompute_arguments (int flags, int num_actuals, struct arg_data *args)
       enum machine_mode mode;
 
       /* If this is an addressable type, we cannot pre-evaluate it.  */
-      if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
-       abort ();
+      gcc_assert (!TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)));
 
       args[i].initial_value = args[i].value
        = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
@@ -1462,8 +1463,13 @@ load_register_parameters (struct arg_data *args, int num_actuals,
             we just use a normal move insn.  This value can be zero if the
             argument is a zero size structure with no fields.  */
          nregs = -1;
-         if (partial)
-           nregs = partial;
+         if (GET_CODE (reg) == PARALLEL)
+           ;
+         else if (partial)
+           {
+             gcc_assert (partial % UNITS_PER_WORD == 0);
+             nregs = partial / UNITS_PER_WORD;
+           }
          else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
            {
              size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
@@ -1476,11 +1482,7 @@ load_register_parameters (struct arg_data *args, int num_actuals,
             locations.  The Irix 6 ABI has examples of this.  */
 
          if (GET_CODE (reg) == PARALLEL)
-           {
-             tree type = TREE_TYPE (args[i].tree_value);
-             emit_group_load (reg, args[i].value, type,
-                              int_size_in_bytes (type));
-           }
+           emit_group_move (reg, args[i].parallel_value);
 
          /* If simple case, just do move.  If normal partial, store_one_arg
             has already loaded the register for us.  In all other cases,
@@ -1506,7 +1508,8 @@ load_register_parameters (struct arg_data *args, int num_actuals,
                     seem worth generating rtl to say that.  */
                  reg = gen_rtx_REG (word_mode, REGNO (reg));
                  x = expand_shift (LSHIFT_EXPR, word_mode, reg,
-                                   build_int_2 (shift, 0), reg, 1);
+                                   build_int_cst (NULL_TREE, shift),
+                                   reg, 1);
                  if (x != reg)
                    emit_move_insn (reg, x);
                }
@@ -1543,7 +1546,8 @@ load_register_parameters (struct arg_data *args, int num_actuals,
 
                  emit_move_insn (x, tem);
                  x = expand_shift (dir, word_mode, x,
-                                   build_int_2 (shift, 0), ri, 1);
+                                   build_int_cst (NULL_TREE, shift),
+                                   ri, 1);
                  if (x != ri)
                    emit_move_insn (ri, x);
                }
@@ -1564,8 +1568,8 @@ load_register_parameters (struct arg_data *args, int num_actuals,
            use_group_regs (call_fusage, reg);
          else if (nregs == -1)
            use_reg (call_fusage, reg);
-         else
-           use_regs (call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
+         else if (nregs > 0)
+           use_regs (call_fusage, REGNO (reg), nregs);
        }
     }
 }
@@ -1582,14 +1586,14 @@ load_register_parameters (struct arg_data *args, int num_actuals,
 static int
 combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
                                           struct args_size *args_size,
-                                          int preferred_unit_stack_boundary)
+                                          unsigned int preferred_unit_stack_boundary)
 {
   /* The number of bytes to pop so that the stack will be
      under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
   HOST_WIDE_INT adjustment;
   /* The alignment of the stack after the arguments are pushed, if we
      just pushed the arguments without adjust the stack here.  */
-  HOST_WIDE_INT unadjusted_alignment;
+  unsigned HOST_WIDE_INT unadjusted_alignment;
 
   unadjusted_alignment
     = ((stack_pointer_delta + unadjusted_args_size)
@@ -1724,68 +1728,27 @@ check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_
   return insn != NULL_RTX;
 }
 
-static tree
-fix_unsafe_tree (tree t)
-{
-  switch (unsafe_for_reeval (t))
-    {
-    case 0: /* Safe.  */
-      break;
-
-    case 1: /* Mildly unsafe.  */
-      t = unsave_expr (t);
-      break;
-
-    case 2: /* Wildly unsafe.  */
-      {
-       tree var = build_decl (VAR_DECL, NULL_TREE,
-                              TREE_TYPE (t));
-       SET_DECL_RTL (var,
-                     expand_expr (t, NULL_RTX, VOIDmode, EXPAND_NORMAL));
-       t = var;
-      }
-      break;
-
-    default:
-      abort ();
-    }
-  return t;
-}
-
-
-/* If function value *VALUE was returned at the most significant end of a
-   register, shift it towards the least significant end and convert it to
-   TYPE's mode.  Return true and update *VALUE if some action was needed.
+/* Given that a function returns a value of mode MODE at the most
+   significant end of hard register VALUE, shift VALUE left or right
+   as specified by LEFT_P.  Return true if some action was needed.  */
 
-   TYPE is the type of the function's return value, which is known not
-   to have mode BLKmode.  */
-
-static bool
-shift_returned_value (tree type, rtx *value)
+bool
+shift_return_value (enum machine_mode mode, bool left_p, rtx value)
 {
-  if (targetm.calls.return_in_msb (type))
-    {
-      HOST_WIDE_INT shift;
+  HOST_WIDE_INT shift;
 
-      shift = (GET_MODE_BITSIZE (GET_MODE (*value))
-              - BITS_PER_UNIT * int_size_in_bytes (type));
-      if (shift > 0)
-       {
-         /* Shift the value into the low part of the register.  */
-         *value = expand_binop (GET_MODE (*value), lshr_optab, *value,
-                                GEN_INT (shift), 0, 1, OPTAB_WIDEN);
-
-         /* Truncate it to the type's mode, or its integer equivalent.
-            This is subject to TRULY_NOOP_TRUNCATION.  */
-         *value = convert_to_mode (int_mode_for_mode (TYPE_MODE (type)),
-                                   *value, 0);
-
-         /* Now convert it to the final form.  */
-         *value = gen_lowpart (TYPE_MODE (type), *value);
-         return true;
-       }
-    }
-  return false;
+  gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
+  shift = GET_MODE_BITSIZE (GET_MODE (value)) - GET_MODE_BITSIZE (mode);
+  if (shift == 0)
+    return false;
+
+  /* Use ashr rather than lshr for right shifts.  This is for the benefit
+     of the MIPS port, which requires SImode values to be sign-extended
+     when stored in 64-bit registers.  */
+  if (!force_expand_binop (GET_MODE (value), left_p ? ashl_optab : ashr_optab,
+                          value, GEN_INT (shift), value, 1, OPTAB_WIDEN))
+    gcc_unreachable ();
+  return true;
 }
 
 /* Remove all REG_EQUIV notes found in the insn chain.  */
@@ -1812,45 +1775,6 @@ purge_reg_equiv_notes (void)
     }
 }
 
-/* Clear RTX_UNCHANGING_P flag of incoming argument MEMs.  */
-
-static void
-purge_mem_unchanging_flag (rtx x)
-{
-  RTX_CODE code;
-  int i, j;
-  const char *fmt;
-
-  if (x == NULL_RTX)
-    return;
-
-  code = GET_CODE (x);
-
-  if (code == MEM)
-    {
-      if (RTX_UNCHANGING_P (x)
-         && (XEXP (x, 0) == current_function_internal_arg_pointer
-             || (GET_CODE (XEXP (x, 0)) == PLUS
-                 && XEXP (XEXP (x, 0), 0) ==
-                    current_function_internal_arg_pointer
-                 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)))
-       RTX_UNCHANGING_P (x) = 0;
-      return;
-    }
-
-  /* Scan all subexpressions.  */
-  fmt = GET_RTX_FORMAT (code);
-  for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
-    {
-      if (*fmt == 'e')
-       purge_mem_unchanging_flag (XEXP (x, i));
-      else if (*fmt == 'E')
-       for (j = 0; j < XVECLEN (x, i); j++)
-         purge_mem_unchanging_flag (XVECEXP (x, i, j));
-    }
-}
-
-
 /* Generate all the code for a function call
    and return an rtx for its value.
    Store the value in TARGET (specified as an rtx) if convenient.
@@ -1968,9 +1892,9 @@ expand_call (tree exp, rtx target, int ignore)
   tree addr = TREE_OPERAND (exp, 0);
   int i;
   /* The alignment of the stack, in bits.  */
-  HOST_WIDE_INT preferred_stack_boundary;
+  unsigned HOST_WIDE_INT preferred_stack_boundary;
   /* The alignment of the stack, in bytes.  */
-  HOST_WIDE_INT preferred_unit_stack_boundary;
+  unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
   /* The static chain value to use for this call.  */
   rtx static_chain_value;
   /* See if this is "nothrow" function call.  */
@@ -2087,8 +2011,7 @@ expand_call (tree exp, rtx target, int ignore)
 
   /* Operand 0 is a pointer-to-function; get the type of the function.  */
   funtype = TREE_TYPE (addr);
-  if (! POINTER_TYPE_P (funtype))
-    abort ();
+  gcc_assert (POINTER_TYPE_P (funtype));
   funtype = TREE_TYPE (funtype);
 
   /* Munge the tree to split complex arguments into their imaginary
@@ -2226,21 +2149,10 @@ expand_call (tree exp, rtx target, int ignore)
   /* Tail calls can make things harder to debug, and we've traditionally
      pushed these optimizations into -O2.  Don't try if we're already
      expanding a call, as that means we're an argument.  Don't try if
-     there's cleanups, as we know there's code to follow the call.
-
-     If rtx_equal_function_value_matters is false, that means we've
-     finished with regular parsing.  Which means that some of the
-     machinery we use to generate tail-calls is no longer in place.
-     This is most often true of sjlj-exceptions, which we couldn't
-     tail-call to anyway.
+     there's cleanups, as we know there's code to follow the call.  */
 
-     If current_nesting_level () == 0, we're being called after
-     the function body has been expanded.  This can happen when
-     setting up trampolines in expand_function_end.  */
   if (currently_expanding_call++ != 0
       || !flag_optimize_sibling_calls
-      || !rtx_equal_function_value_matters
-      || current_nesting_level () == 0
       || args_size.var
       || lookup_stmt_eh_region (exp) >= 0)
     try_tail_call = 0;
@@ -2263,7 +2175,7 @@ expand_call (tree exp, rtx target, int ignore)
       || !targetm.function_ok_for_sibcall (fndecl, exp)
       /* Functions that do not return exactly once may not be sibcall
          optimized.  */
-      || (flags & (ECF_RETURNS_TWICE | ECF_LONGJMP | ECF_NORETURN))
+      || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
       || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
       /* If the called function is nested in the current one, it might access
          some of the caller's arguments, but could clobber them beforehand if
@@ -2281,48 +2193,6 @@ expand_call (tree exp, rtx target, int ignore)
       || !lang_hooks.decls.ok_for_sibcall (fndecl))
     try_tail_call = 0;
 
-  if (try_tail_call)
-    {
-      int end, inc;
-      actparms = NULL_TREE;
-      /* Ok, we're going to give the tail call the old college try.
-        This means we're going to evaluate the function arguments
-        up to three times.  There are two degrees of badness we can
-        encounter, those that can be unsaved and those that can't.
-        (See unsafe_for_reeval commentary for details.)
-
-        Generate a new argument list.  Pass safe arguments through
-        unchanged.  For the easy badness wrap them in UNSAVE_EXPRs.
-        For hard badness, evaluate them now and put their resulting
-        rtx in a temporary VAR_DECL.
-
-        initialize_argument_information has ordered the array for the
-        order to be pushed, and we must remember this when reconstructing
-        the original argument order.  */
-
-      if (PUSH_ARGS_REVERSED)
-       {
-         inc = 1;
-         i = 0;
-         end = num_actuals;
-       }
-      else
-       {
-         inc = -1;
-         i = num_actuals - 1;
-         end = -1;
-       }
-
-      for (; i != end; i += inc)
-       {
-          args[i].tree_value = fix_unsafe_tree (args[i].tree_value);
-       }
-      /* Do the same for the function address if it is an expression.  */
-      if (!fndecl)
-        addr = fix_unsafe_tree (addr);
-    }
-
-
   /* Ensure current function's preferred stack boundary is at least
      what we need.  We don't have to increase alignment for recursive
      functions.  */
@@ -2372,15 +2242,6 @@ expand_call (tree exp, rtx target, int ignore)
         sibcall_failure instead of continuing the loop.  */
       start_sequence ();
 
-      if (pass == 0)
-       {
-         /* We know at this point that there are not currently any
-            pending cleanups.  If, however, in the process of evaluating
-            the arguments we were to create some, we'll need to be
-            able to get rid of them.  */
-         expand_start_target_temps ();
-       }
-
       /* Don't let pending stack adjusts add up to too much.
         Also, do all pending adjustments now if there is any chance
         this might be a call to alloca or if we are expanding a sibling
@@ -2791,8 +2652,8 @@ expand_call (tree exp, rtx target, int ignore)
         now!  */
 
       /* Stack must be properly aligned now.  */
-      if (pass && stack_pointer_delta % preferred_unit_stack_boundary)
-       abort ();
+      gcc_assert (!pass
+                 || !(stack_pointer_delta % preferred_unit_stack_boundary));
 
       /* Generate the actual call instruction.  */
       emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
@@ -2800,6 +2661,20 @@ expand_call (tree exp, rtx target, int ignore)
                   next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
                   flags, & args_so_far);
 
+      /* If a non-BLKmode value is returned at the most significant end
+        of a register, shift the register right by the appropriate amount
+        and update VALREG accordingly.  BLKmode values are handled by the
+        group load/store machinery below.  */
+      if (!structure_value_addr
+         && !pcc_struct_value
+         && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
+         && targetm.calls.return_in_msb (TREE_TYPE (exp)))
+       {
+         if (shift_return_value (TYPE_MODE (TREE_TYPE (exp)), false, valreg))
+           sibcall_failure = 1;
+         valreg = gen_rtx_REG (TYPE_MODE (TREE_TYPE (exp)), REGNO (valreg));
+       }
+
       /* If call is cse'able, make appropriate pair of reg-notes around it.
         Test valreg so we don't crash; may safely ignore `const'
         if return type is void.  Disable for PARALLEL return values, because
@@ -2893,7 +2768,7 @@ expand_call (tree exp, rtx target, int ignore)
         if nonvolatile values are live.  For functions that cannot return,
         inform flow that control does not fall through.  */
 
-      if ((flags & (ECF_NORETURN | ECF_LONGJMP)) || pass == 0)
+      if ((flags & ECF_NORETURN) || pass == 0)
        {
          /* The barrier must be emitted
             immediately after the CALL_INSN.  Some ports emit more
@@ -2904,8 +2779,7 @@ expand_call (tree exp, rtx target, int ignore)
            {
              last = PREV_INSN (last);
              /* There was no CALL_INSN?  */
-             if (last == before_call)
-               abort ();
+             gcc_assert (last != before_call);
            }
 
          emit_barrier_after (last);
@@ -2920,9 +2794,6 @@ expand_call (tree exp, rtx target, int ignore)
            }
        }
 
-      if (flags & ECF_LONGJMP)
-       current_function_calls_longjmp = 1;
-
       /* If value type not void, return an rtx for the value.  */
 
       if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
@@ -2960,7 +2831,6 @@ expand_call (tree exp, rtx target, int ignore)
                                               | TYPE_QUAL_CONST));
 
              target = assign_temp (nt, 0, 1, 1);
-             preserve_temp_slots (target);
            }
 
          if (! rtx_equal_p (target, valreg))
@@ -2996,45 +2866,40 @@ expand_call (tree exp, rtx target, int ignore)
          sibcall_failure = 1;
        }
       else
-       {
-         if (shift_returned_value (TREE_TYPE (exp), &valreg))
-           sibcall_failure = 1;
-
-         target = copy_to_reg (valreg);
-       }
+       target = copy_to_reg (valreg);
 
       if (targetm.calls.promote_function_return(funtype))
        {
-      /* If we promoted this return value, make the proper SUBREG.  TARGET
-        might be const0_rtx here, so be careful.  */
-      if (REG_P (target)
-         && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
-         && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
-       {
-         tree type = TREE_TYPE (exp);
-         int unsignedp = TYPE_UNSIGNED (type);
-         int offset = 0;
-
-         /* If we don't promote as expected, something is wrong.  */
-         if (GET_MODE (target)
-             != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
-           abort ();
-
-       if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
-           && GET_MODE_SIZE (GET_MODE (target))
-              > GET_MODE_SIZE (TYPE_MODE (type)))
-         {
-           offset = GET_MODE_SIZE (GET_MODE (target))
-                    - GET_MODE_SIZE (TYPE_MODE (type));
-           if (! BYTES_BIG_ENDIAN)
-             offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
-           else if (! WORDS_BIG_ENDIAN)
-             offset %= UNITS_PER_WORD;
-         }
-         target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
-         SUBREG_PROMOTED_VAR_P (target) = 1;
-         SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
-       }
+         /* If we promoted this return value, make the proper SUBREG.
+            TARGET might be const0_rtx here, so be careful.  */
+         if (REG_P (target)
+             && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
+             && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
+           {
+             tree type = TREE_TYPE (exp);
+             int unsignedp = TYPE_UNSIGNED (type);
+             int offset = 0;
+             enum machine_mode pmode;
+             
+             pmode = promote_mode (type, TYPE_MODE (type), &unsignedp, 1);
+             /* If we don't promote as expected, something is wrong.  */
+             gcc_assert (GET_MODE (target) == pmode);
+             
+             if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
+                 && (GET_MODE_SIZE (GET_MODE (target))
+                     > GET_MODE_SIZE (TYPE_MODE (type))))
+               {
+                 offset = GET_MODE_SIZE (GET_MODE (target))
+                   - GET_MODE_SIZE (TYPE_MODE (type));
+                 if (! BYTES_BIG_ENDIAN)
+                   offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
+                 else if (! WORDS_BIG_ENDIAN)
+                   offset %= UNITS_PER_WORD;
+               }
+             target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
+             SUBREG_PROMOTED_VAR_P (target) = 1;
+             SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
+           }
        }
 
       /* If size of args is variable or this was a constructor call for a stack
@@ -3093,30 +2958,6 @@ expand_call (tree exp, rtx target, int ignore)
        if (args[i].aligned_regs)
          free (args[i].aligned_regs);
 
-      if (pass == 0)
-       {
-         /* Undo the fake expand_start_target_temps we did earlier.  If
-            there had been any cleanups created, we've already set
-            sibcall_failure.  */
-         expand_end_target_temps ();
-       }
-
-      /* If this function is returning into a memory location marked as
-        readonly, it means it is initializing that location. We normally treat
-        functions as not clobbering such locations, so we need to specify that
-        this one does. We do this by adding the appropriate CLOBBER to the
-        CALL_INSN function usage list.  This cannot be done by emitting a
-        standalone CLOBBER after the call because the latter would be ignored
-        by at least the delay slot scheduling pass. We do this now instead of
-        adding to call_fusage before the call to emit_call_1 because TARGET
-        may be modified in the meantime.  */
-      if (structure_value_addr != 0 && target != 0
-         && MEM_P (target) && RTX_UNCHANGING_P (target))
-       add_function_usage_to
-         (last_call_insn (),
-          gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_CLOBBER (VOIDmode, target),
-                             NULL_RTX));
-
       insns = get_insns ();
       end_sequence ();
 
@@ -3145,10 +2986,9 @@ expand_call (tree exp, rtx target, int ignore)
          normal_call_insns = insns;
 
          /* Verify that we've deallocated all the stack we used.  */
-         if (! (flags & (ECF_NORETURN | ECF_LONGJMP))
-             && old_stack_allocated != stack_pointer_delta
-                                       - pending_stack_adjust)
-           abort ();
+         gcc_assert ((flags & ECF_NORETURN)
+                     || (old_stack_allocated
+                         == stack_pointer_delta - pending_stack_adjust));
        }
 
       /* If something prevents making this a sibling call,
@@ -3197,37 +3037,12 @@ expand_call (tree exp, rtx target, int ignore)
 void
 fixup_tail_calls (void)
 {
-  rtx insn;
-  tree arg;
-
   purge_reg_equiv_notes ();
-
-  /* A sibling call sequence also may invalidate RTX_UNCHANGING_P
-     flag of some incoming arguments MEM RTLs, because it can write into
-     those slots.  We clear all those bits now.
-
-     This is (slight) overkill, we could keep track of which arguments
-     we actually write into.  */
-  for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
-    {
-      if (INSN_P (insn))
-       purge_mem_unchanging_flag (PATTERN (insn));
-    }
-
-  /* Similarly, invalidate RTX_UNCHANGING_P for any incoming
-     arguments passed in registers.  */
-  for (arg = DECL_ARGUMENTS (current_function_decl);
-       arg;
-       arg = TREE_CHAIN (arg))
-    {
-      if (REG_P (DECL_RTL (arg)))
-       RTX_UNCHANGING_P (DECL_RTL (arg)) = false;
-    }
 }
 
 /* Traverse an argument list in VALUES and expand all complex
    arguments into their components.  */
-tree
+static tree
 split_complex_values (tree values)
 {
   tree p;
@@ -3281,7 +3096,7 @@ split_complex_values (tree values)
 
 /* Traverse a list of TYPES and expand all complex types into their
    components.  */
-tree
+static tree
 split_complex_types (tree types)
 {
   tree p;
@@ -3485,6 +3300,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
   if (mem_value && struct_value == 0 && ! pcc_struct_value)
     {
       rtx addr = XEXP (mem_value, 0);
+      
       nargs++;
 
       /* Make sure it is a reasonable operand for a move or push insn.  */
@@ -3497,8 +3313,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
       argvec[count].partial = 0;
 
       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
-      if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
-       abort ();
+      gcc_assert (targetm.calls.arg_partial_bytes (&args_so_far, Pmode,
+                                                  NULL_TREE, 1) == 0);
 
       locate_and_pad_parm (Pmode, NULL_TREE,
 #ifdef STACK_PARMS_IN_REG_PARM_AREA
@@ -3524,9 +3340,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
 
       /* We cannot convert the arg value to the mode the library wants here;
         must do it earlier where we know the signedness of the arg.  */
-      if (mode == BLKmode
-         || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
-       abort ();
+      gcc_assert (mode != BLKmode
+                 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
 
       /* Make sure it is a reasonable operand for a move or push insn.  */
       if (!REG_P (val) && !MEM_P (val)
@@ -3536,8 +3351,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
       if (pass_by_reference (&args_so_far, mode, NULL_TREE, 1))
        {
          rtx slot;
-         int must_copy = ! FUNCTION_ARG_CALLEE_COPIES (args_so_far, mode,
-                                                       NULL_TREE, 1);
+         int must_copy
+           = !reference_callee_copied (&args_so_far, mode, NULL_TREE, 1);
 
          /* 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.  */
@@ -3557,25 +3372,14 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
              flags |= ECF_PURE;
            }
 
-         if (GET_MODE (val) == MEM && ! must_copy)
+         if (GET_MODE (val) == MEM && !must_copy)
            slot = val;
-         else if (must_copy)
+         else
            {
              slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
                                  0, 1, 1);
              emit_move_insn (slot, val);
            }
-         else
-           {
-             tree type = lang_hooks.types.type_for_mode (mode, 0);
-
-             slot
-               = gen_rtx_MEM (mode,
-                              expand_expr (build1 (ADDR_EXPR,
-                                                   build_pointer_type (type),
-                                                   make_tree (type, val)),
-                                           NULL_RTX, VOIDmode, 0));
-           }
 
          call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
                                           gen_rtx_USE (VOIDmode, slot),
@@ -3596,7 +3400,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
 
       argvec[count].partial
-       = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
+       = targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL_TREE, 1);
 
       locate_and_pad_parm (mode, NULL_TREE,
 #ifdef STACK_PARMS_IN_REG_PARM_AREA
@@ -3607,8 +3411,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
                           argvec[count].partial,
                           NULL_TREE, &args_size, &argvec[count].locate);
 
-      if (argvec[count].locate.size.var)
-       abort ();
+      gcc_assert (!argvec[count].locate.size.var);
 
       if (argvec[count].reg == 0 || argvec[count].partial != 0
          || reg_parm_stack_space > 0)
@@ -3872,8 +3675,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
            ? hard_libcall_value (outmode) : NULL_RTX);
 
   /* Stack must be properly aligned now.  */
-  if (stack_pointer_delta & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))
-    abort ();
+  gcc_assert (!(stack_pointer_delta
+               & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)));
 
   before_call = get_last_insn ();
 
@@ -3897,7 +3700,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
      if nonvolatile values are live.  For functions that cannot return,
      inform flow that control does not fall through.  */
 
-  if (flags & (ECF_NORETURN | ECF_LONGJMP))
+  if (flags & ECF_NORETURN)
     {
       /* The barrier note must be emitted
         immediately after the CALL_INSN.  Some ports emit more than
@@ -3908,8 +3711,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
        {
          last = PREV_INSN (last);
          /* There was no CALL_INSN?  */
-         if (last == before_call)
-           abort ();
+         gcc_assert (last != before_call);
        }
 
       emit_barrier_after (last);
@@ -4185,11 +3987,10 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
       partial = arg->partial;
     }
 
-  if (reg != 0 && partial == 0)
-    /* Being passed entirely in a register.  We shouldn't be called in
-       this case.  */
-    abort ();
-
+  /* Being passed entirely in a register.  We shouldn't be called in
+     this case.  */
+  gcc_assert (reg == 0 || partial != 0);
+  
   /* If this arg needs special alignment, don't load the registers
      here.  */
   if (arg->n_aligned_regs != 0)
@@ -4309,20 +4110,11 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
        }
       else
        {
-         /* PUSH_ROUNDING has no effect on us, because
-            emit_push_insn for BLKmode is careful to avoid it.  */
-         if (reg && GET_CODE (reg) == PARALLEL)
-         {
-           /* Use the size of the elt to compute excess.  */
-           rtx elt = XEXP (XVECEXP (reg, 0, 0), 0);
-           excess = (arg->locate.size.constant
-                     - int_size_in_bytes (TREE_TYPE (pval))
-                     + partial * GET_MODE_SIZE (GET_MODE (elt)));
-         }
-         else
-           excess = (arg->locate.size.constant
-                     - int_size_in_bytes (TREE_TYPE (pval))
-                     + partial * UNITS_PER_WORD);
+         /* PUSH_ROUNDING has no effect on us, because emit_push_insn
+            for BLKmode is careful to avoid it.  */
+         excess = (arg->locate.size.constant
+                   - int_size_in_bytes (TREE_TYPE (pval))
+                   + partial);
          size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
                                  NULL_RTX, TYPE_MODE (sizetype), 0);
        }
@@ -4361,8 +4153,8 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
                i = INTVAL (XEXP (XEXP (x, 0), 1));
 
              /* expand_call should ensure this.  */
-             if (arg->locate.offset.var || GET_CODE (size_rtx) != CONST_INT)
-               abort ();
+             gcc_assert (!arg->locate.offset.var
+                         && GET_CODE (size_rtx) == CONST_INT);
 
              if (arg->locate.offset.constant > i)
                {
@@ -4394,6 +4186,14 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
        arg->value = arg->stack_slot;
     }
 
+  if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
+    {
+      tree type = TREE_TYPE (arg->tree_value);
+      arg->parallel_value
+       = emit_group_load_into_temps (arg->reg, arg->value, type,
+                                     int_size_in_bytes (type));
+    }
+
   /* Mark all slots this store used.  */
   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
       && argblock && ! variable_size && arg->stack)