Fix another mips typo.

[pf3gnuchains/gcc-fork.git] / gcc / explow.c

diff --git a/gcc/explow.c b/gcc/explow.c
index 50556e8..47cb867 100644 (file)
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -1,6 +1,6 @@
 /* Subroutines for manipulating rtx's in semantically interesting ways.
    Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998,
 /* Subroutines for manipulating rtx's in semantically interesting ways.
    Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998,

-   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

 
 This file is part of GCC.
 
 
 This file is part of GCC.
 


@@ -38,16 +38,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "recog.h"
 #include "langhooks.h"
 
 #include "recog.h"
 #include "langhooks.h"
 

-static rtx break_out_memory_refs       PARAMS ((rtx));
-static void emit_stack_probe           PARAMS ((rtx));
+static rtx break_out_memory_refs (rtx);
+static void emit_stack_probe (rtx);

 
 
 /* Truncate and perhaps sign-extend C as appropriate for MODE.  */
 
 HOST_WIDE_INT
 
 
 /* Truncate and perhaps sign-extend C as appropriate for MODE.  */
 
 HOST_WIDE_INT

-trunc_int_for_mode (c, mode)
-     HOST_WIDE_INT c;
-     enum machine_mode mode;
+trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode)

 {
   int width = GET_MODE_BITSIZE (mode);
 
 {
   int width = GET_MODE_BITSIZE (mode);
 


@@ -73,14 +71,10 @@ trunc_int_for_mode (c, mode)
   return c;
 }
 
   return c;
 }
 

-/* Return an rtx for the sum of X and the integer C.
-
-   This function should be used via the `plus_constant' macro.  */
+/* Return an rtx for the sum of X and the integer C.  */

 
 rtx
 
 rtx

-plus_constant_wide (x, c)
-     rtx x;
-     HOST_WIDE_INT c;
+plus_constant (rtx x, HOST_WIDE_INT c)

 {
   RTX_CODE code;
   rtx y;
 {
   RTX_CODE code;
   rtx y;


@@ -206,9 +200,7 @@ plus_constant_wide (x, c)
    it is not isomorphic to X.  */
 
 rtx
    it is not isomorphic to X.  */
 
 rtx

-eliminate_constant_term (x, constptr)
-     rtx x;
-     rtx *constptr;
+eliminate_constant_term (rtx x, rtx *constptr)

 {
   rtx x0, x1;
   rtx tem;
 {
   rtx x0, x1;
   rtx tem;


@@ -241,62 +233,17 @@ eliminate_constant_term (x, constptr)
   return x;
 }
 
   return x;
 }
 

-/* Returns the insn that next references REG after INSN, or 0
-   if REG is clobbered before next referenced or we cannot find
-   an insn that references REG in a straight-line piece of code.  */
-
-rtx
-find_next_ref (reg, insn)
-     rtx reg;
-     rtx insn;
-{
-  rtx next;
-
-  for (insn = NEXT_INSN (insn); insn; insn = next)
-    {
-      next = NEXT_INSN (insn);
-      if (GET_CODE (insn) == NOTE)
-       continue;
-      if (GET_CODE (insn) == CODE_LABEL
-         || GET_CODE (insn) == BARRIER)
-       return 0;
-      if (GET_CODE (insn) == INSN
-         || GET_CODE (insn) == JUMP_INSN
-         || GET_CODE (insn) == CALL_INSN)
-       {
-         if (reg_set_p (reg, insn))
-           return 0;
-         if (reg_mentioned_p (reg, PATTERN (insn)))
-           return insn;
-         if (GET_CODE (insn) == JUMP_INSN)
-           {
-             if (any_uncondjump_p (insn))
-               next = JUMP_LABEL (insn);
-             else
-               return 0;
-           }
-         if (GET_CODE (insn) == CALL_INSN
-             && REGNO (reg) < FIRST_PSEUDO_REGISTER
-             && call_used_regs[REGNO (reg)])
-           return 0;
-       }
-      else
-       abort ();
-    }
-  return 0;
-}
-

 /* Return an rtx for the size in bytes of the value of EXP.  */
 
 rtx
 /* Return an rtx for the size in bytes of the value of EXP.  */
 
 rtx

-expr_size (exp)
-     tree exp;
+expr_size (tree exp)

 {
 {

-  tree size = (*lang_hooks.expr_size) (exp);
+  tree size;

 
 

-  if (TREE_CODE (size) != INTEGER_CST
-      && contains_placeholder_p (size))
-    size = build (WITH_RECORD_EXPR, sizetype, size, exp);
+  if (TREE_CODE (exp) == WITH_SIZE_EXPR)
+    size = TREE_OPERAND (exp, 1);
+  else
+    size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (lang_hooks.expr_size (exp), exp);

 
   return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
 }
 
   return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
 }


@@ -305,20 +252,19 @@ expr_size (exp)
    if the size can vary or is larger than an integer.  */
 
 HOST_WIDE_INT
    if the size can vary or is larger than an integer.  */
 
 HOST_WIDE_INT

-int_expr_size (exp)
-     tree exp;
+int_expr_size (tree exp)

 {
 {

-  tree t = (*lang_hooks.expr_size) (exp);
-
-  if (t == 0
-      || TREE_CODE (t) != INTEGER_CST
-      || TREE_OVERFLOW (t)
-      || TREE_INT_CST_HIGH (t) != 0
-      /* If the result would appear negative, it's too big to represent.  */
-      || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
+  tree size;
+
+  if (TREE_CODE (exp) == WITH_SIZE_EXPR)
+    size = TREE_OPERAND (exp, 1);
+  else
+    size = lang_hooks.expr_size (exp);
+
+  if (size == 0 || !host_integerp (size, 0))

     return -1;
 
     return -1;
 

-  return TREE_INT_CST_LOW (t);
+  return tree_low_cst (size, 0);

 }
 \f
 /* Return a copy of X in which all memory references
 }
 \f
 /* Return a copy of X in which all memory references


@@ -338,10 +284,9 @@ int_expr_size (exp)
    Values returned by expand_expr with 1 for sum_ok fit this constraint.  */
 
 static rtx
    Values returned by expand_expr with 1 for sum_ok fit this constraint.  */
 
 static rtx

-break_out_memory_refs (x)
-     rtx x;
+break_out_memory_refs (rtx x)

 {
 {

-  if (GET_CODE (x) == MEM
+  if (MEM_P (x)

       || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
          && GET_MODE (x) != VOIDmode))
     x = force_reg (GET_MODE (x), x);
       || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
          && GET_MODE (x) != VOIDmode))
     x = force_reg (GET_MODE (x), x);


@@ -358,8 +303,6 @@ break_out_memory_refs (x)
   return x;
 }
 
   return x;
 }
 

-#ifdef POINTERS_EXTEND_UNSIGNED
-

 /* Given X, a memory address in ptr_mode, convert it to an address
    in Pmode, or vice versa (TO_MODE says which way).  We take advantage of
    the fact that pointers are not allowed to overflow by commuting arithmetic
 /* Given X, a memory address in ptr_mode, convert it to an address
    in Pmode, or vice versa (TO_MODE says which way).  We take advantage of
    the fact that pointers are not allowed to overflow by commuting arithmetic


@@ -367,14 +310,22 @@ break_out_memory_refs (x)
    used.  */
 
 rtx
    used.  */
 
 rtx

-convert_memory_address (to_mode, x)
-     enum machine_mode to_mode;
-     rtx x;
+convert_memory_address (enum machine_mode to_mode ATTRIBUTE_UNUSED, 
+                       rtx x)

 {
 {

-  enum machine_mode from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
+#ifndef POINTERS_EXTEND_UNSIGNED
+  return x;
+#else /* defined(POINTERS_EXTEND_UNSIGNED) */
+  enum machine_mode from_mode;

   rtx temp;
   enum rtx_code code;
 
   rtx temp;
   enum rtx_code code;
 

+  /* If X already has the right mode, just return it.  */
+  if (GET_MODE (x) == to_mode)
+    return x;
+
+  from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
+

   /* Here we handle some special cases.  If none of them apply, fall through
      to the default case.  */
   switch (GET_CODE (x))
   /* Here we handle some special cases.  If none of them apply, fall through
      to the default case.  */
   switch (GET_CODE (x))


@@ -438,8 +389,8 @@ convert_memory_address (to_mode, x)
 
   return convert_modes (to_mode, from_mode,
                        x, POINTERS_EXTEND_UNSIGNED);
 
   return convert_modes (to_mode, from_mode,
                        x, POINTERS_EXTEND_UNSIGNED);

+#endif /* defined(POINTERS_EXTEND_UNSIGNED) */

 }
 }

-#endif

 
 /* Given a memory address or facsimile X, construct a new address,
    currently equivalent, that is stable: future stores won't change it.
 
 /* Given a memory address or facsimile X, construct a new address,
    currently equivalent, that is stable: future stores won't change it.


@@ -455,10 +406,9 @@ convert_memory_address (to_mode, x)
    but then you wouldn't get indexed addressing in the reference.  */
 
 rtx
    but then you wouldn't get indexed addressing in the reference.  */
 
 rtx

-copy_all_regs (x)
-     rtx x;
+copy_all_regs (rtx x)

 {
 {

-  if (GET_CODE (x) == REG)
+  if (REG_P (x))

     {
       if (REGNO (x) != FRAME_POINTER_REGNUM
 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
     {
       if (REGNO (x) != FRAME_POINTER_REGNUM
 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM


@@ -467,7 +417,7 @@ copy_all_regs (x)
          )
        x = copy_to_reg (x);
     }
          )
        x = copy_to_reg (x);
     }

-  else if (GET_CODE (x) == MEM)
+  else if (MEM_P (x))

     x = copy_to_reg (x);
   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
           || GET_CODE (x) == MULT)
     x = copy_to_reg (x);
   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
           || GET_CODE (x) == MULT)


@@ -485,44 +435,29 @@ copy_all_regs (x)
    works by copying X or subexpressions of it into registers.  */
 
 rtx
    works by copying X or subexpressions of it into registers.  */
 
 rtx

-memory_address (mode, x)
-     enum machine_mode mode;
-     rtx x;
+memory_address (enum machine_mode mode, rtx x)

 {
   rtx oldx = x;
 
 {
   rtx oldx = x;
 

-  if (GET_CODE (x) == ADDRESSOF)
-    return x;
-
-#ifdef POINTERS_EXTEND_UNSIGNED
-  if (GET_MODE (x) != Pmode)
-    x = convert_memory_address (Pmode, x);
-#endif
+  x = convert_memory_address (Pmode, x);

 
 

-  /* By passing constant addresses thru registers
+  /* By passing constant addresses through registers

      we get a chance to cse them.  */
   if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
     x = force_reg (Pmode, x);
 
      we get a chance to cse them.  */
   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
-      && GET_CODE (QUEUED_VAR (x)) == REG)
-    ;
-

   /* 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
      are visible.  But not if cse won't be done!  */
   else
     {
   /* 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
      are visible.  But not if cse won't be done!  */
   else
     {

-      if (! cse_not_expected && GET_CODE (x) != REG)
+      if (! cse_not_expected && !REG_P (x))

        x = break_out_memory_refs (x);
 
       /* At this point, any valid address is accepted.  */
        x = break_out_memory_refs (x);
 
       /* At this point, any valid address is accepted.  */

-      GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
+      if (memory_address_p (mode, x))
+       goto win;

 
       /* If it was valid before but breaking out memory refs invalidated it,
         use it the old way.  */
 
       /* If it was valid before but breaking out memory refs invalidated it,
         use it the old way.  */


@@ -566,7 +501,7 @@ memory_address (mode, x)
 
       /* If we have a register that's an invalid address,
         it must be a hard reg of the wrong class.  Copy it to a pseudo.  */
 
       /* If we have a register that's an invalid address,
         it must be a hard reg of the wrong class.  Copy it to a pseudo.  */

-      else if (GET_CODE (x) == REG)
+      else if (REG_P (x))

        x = copy_to_reg (x);
 
       /* Last resort: copy the value to a register, since
        x = copy_to_reg (x);
 
       /* Last resort: copy the value to a register, since


@@ -579,7 +514,7 @@ memory_address (mode, x)
     win2:
       x = oldx;
     win:
     win2:
       x = oldx;
     win:

-      if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG
+      if (flag_force_addr && ! cse_not_expected && !REG_P (x)

          /* Don't copy an addr via a reg if it is one of our stack slots.  */
          && ! (GET_CODE (x) == PLUS
                && (XEXP (x, 0) == virtual_stack_vars_rtx
          /* Don't copy an addr via a reg if it is one of our stack slots.  */
          && ! (GET_CODE (x) == PLUS
                && (XEXP (x, 0) == virtual_stack_vars_rtx


@@ -598,10 +533,10 @@ memory_address (mode, x)
      a reg as a pointer if we have REG or REG + CONST_INT.  */
   if (oldx == x)
     return x;
      a reg as a pointer if we have REG or REG + CONST_INT.  */
   if (oldx == x)
     return x;

-  else if (GET_CODE (x) == REG)
+  else if (REG_P (x))

     mark_reg_pointer (x, BITS_PER_UNIT);
   else if (GET_CODE (x) == PLUS
     mark_reg_pointer (x, BITS_PER_UNIT);
   else if (GET_CODE (x) == PLUS

-          && GET_CODE (XEXP (x, 0)) == REG
+          && REG_P (XEXP (x, 0))

           && GET_CODE (XEXP (x, 1)) == CONST_INT)
     mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
 
           && GET_CODE (XEXP (x, 1)) == CONST_INT)
     mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
 


@@ -615,9 +550,7 @@ memory_address (mode, x)
 /* Like `memory_address' but pretend `flag_force_addr' is 0.  */
 
 rtx
 /* Like `memory_address' but pretend `flag_force_addr' is 0.  */
 
 rtx

-memory_address_noforce (mode, x)
-     enum machine_mode mode;
-     rtx x;
+memory_address_noforce (enum machine_mode mode, rtx x)

 {
   int ambient_force_addr = flag_force_addr;
   rtx val;
 {
   int ambient_force_addr = flag_force_addr;
   rtx val;


@@ -632,10 +565,9 @@ memory_address_noforce (mode, x)
    Pass through anything else unchanged.  */
 
 rtx
    Pass through anything else unchanged.  */
 
 rtx

-validize_mem (ref)
-     rtx ref;
+validize_mem (rtx ref)

 {
 {

-  if (GET_CODE (ref) != MEM)
+  if (!MEM_P (ref))

     return ref;
   if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
       && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
     return ref;
   if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
       && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))


@@ -645,37 +577,15 @@ validize_mem (ref)
   return replace_equiv_address (ref, XEXP (ref, 0));
 }
 \f
   return replace_equiv_address (ref, XEXP (ref, 0));
 }
 \f

-/* Given REF, either a MEM or a REG, and T, either the type of X or
-   the expression corresponding to REF, set RTX_UNCHANGING_P if
-   appropriate.  */
-
-void
-maybe_set_unchanging (ref, t)
-     rtx ref;
-     tree t;
-{
-  /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
-     initialization is only executed once, or whose initializer always
-     has the same value.  Currently we simplify this to PARM_DECLs in the
-     first case, and decls with TREE_CONSTANT initializers in the second.  */
-  if ((TREE_READONLY (t) && DECL_P (t)
-       && (TREE_CODE (t) == PARM_DECL
-          || (DECL_INITIAL (t) && TREE_CONSTANT (DECL_INITIAL (t)))))
-      || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
-    RTX_UNCHANGING_P (ref) = 1;
-}
-\f

 /* Return a modified copy of X with its memory address copied
    into a temporary register to protect it from side effects.
    If X is not a MEM, it is returned unchanged (and not copied).
    Perhaps even if it is a MEM, if there is no need to change it.  */
 
 rtx
 /* Return a modified copy of X with its memory address copied
    into a temporary register to protect it from side effects.
    If X is not a MEM, it is returned unchanged (and not copied).
    Perhaps even if it is a MEM, if there is no need to change it.  */
 
 rtx

-stabilize (x)
-     rtx x;
+stabilize (rtx x)

 {
 {

-
-  if (GET_CODE (x) != MEM
+  if (!MEM_P (x)

       || ! rtx_unstable_p (XEXP (x, 0)))
     return x;
 
       || ! rtx_unstable_p (XEXP (x, 0)))
     return x;
 


@@ -686,8 +596,7 @@ stabilize (x)
 /* Copy the value or contents of X to a new temp reg and return that reg.  */
 
 rtx
 /* Copy the value or contents of X to a new temp reg and return that reg.  */
 
 rtx

-copy_to_reg (x)
-     rtx x;
+copy_to_reg (rtx x)

 {
   rtx temp = gen_reg_rtx (GET_MODE (x));
 
 {
   rtx temp = gen_reg_rtx (GET_MODE (x));
 


@@ -706,8 +615,7 @@ copy_to_reg (x)
    in case X is a constant.  */
 
 rtx
    in case X is a constant.  */
 
 rtx

-copy_addr_to_reg (x)
-     rtx x;
+copy_addr_to_reg (rtx x)

 {
   return copy_to_mode_reg (Pmode, x);
 }
 {
   return copy_to_mode_reg (Pmode, x);
 }


@@ -716,9 +624,7 @@ copy_addr_to_reg (x)
    in case X is a constant.  */
 
 rtx
    in case X is a constant.  */
 
 rtx

-copy_to_mode_reg (mode, x)
-     enum machine_mode mode;
-     rtx x;
+copy_to_mode_reg (enum machine_mode mode, rtx x)

 {
   rtx temp = gen_reg_rtx (mode);
 
 {
   rtx temp = gen_reg_rtx (mode);
 


@@ -743,13 +649,11 @@ copy_to_mode_reg (mode, x)
    since we mark it as a "constant" register.  */
 
 rtx
    since we mark it as a "constant" register.  */
 
 rtx

-force_reg (mode, x)
-     enum machine_mode mode;
-     rtx x;
+force_reg (enum machine_mode mode, rtx x)

 {
   rtx temp, insn, set;
 
 {
   rtx temp, insn, set;
 

-  if (GET_CODE (x) == REG)
+  if (REG_P (x))

     return x;
 
   if (general_operand (x, mode))
     return x;
 
   if (general_operand (x, mode))


@@ -760,7 +664,7 @@ force_reg (mode, x)
   else
     {
       temp = force_operand (x, NULL_RTX);
   else
     {
       temp = force_operand (x, NULL_RTX);

-      if (GET_CODE (temp) == REG)
+      if (REG_P (temp))

        insn = get_last_insn ();
       else
        {
        insn = get_last_insn ();
       else
        {


@@ -779,6 +683,40 @@ force_reg (mode, x)
       && ! rtx_equal_p (x, SET_SRC (set)))
     set_unique_reg_note (insn, REG_EQUAL, x);
 
       && ! rtx_equal_p (x, SET_SRC (set)))
     set_unique_reg_note (insn, REG_EQUAL, x);
 

+  /* Let optimizers know that TEMP is a pointer, and if so, the
+     known alignment of that pointer.  */
+  {
+    unsigned align = 0;
+    if (GET_CODE (x) == SYMBOL_REF)
+      {
+        align = BITS_PER_UNIT;
+       if (SYMBOL_REF_DECL (x) && DECL_P (SYMBOL_REF_DECL (x)))
+         align = DECL_ALIGN (SYMBOL_REF_DECL (x));
+      }
+    else if (GET_CODE (x) == LABEL_REF)
+      align = BITS_PER_UNIT;
+    else if (GET_CODE (x) == CONST
+            && GET_CODE (XEXP (x, 0)) == PLUS
+            && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
+            && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
+      {
+       rtx s = XEXP (XEXP (x, 0), 0);
+       rtx c = XEXP (XEXP (x, 0), 1);
+       unsigned sa, ca;
+
+       sa = BITS_PER_UNIT;
+       if (SYMBOL_REF_DECL (s) && DECL_P (SYMBOL_REF_DECL (s)))
+         sa = DECL_ALIGN (SYMBOL_REF_DECL (s));
+
+       ca = exact_log2 (INTVAL (c) & -INTVAL (c)) * BITS_PER_UNIT;
+
+       align = MIN (sa, ca);
+      }
+
+    if (align)
+      mark_reg_pointer (temp, align);
+  }
+

   return temp;
 }
 
   return temp;
 }
 


@@ -786,15 +724,18 @@ force_reg (mode, x)
    that reg.  Otherwise, return X.  */
 
 rtx
    that reg.  Otherwise, return X.  */
 
 rtx

-force_not_mem (x)
-     rtx x;
+force_not_mem (rtx x)

 {
   rtx temp;
 
 {
   rtx temp;
 

-  if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
+  if (!MEM_P (x) || GET_MODE (x) == BLKmode)

     return x;
 
   temp = gen_reg_rtx (GET_MODE (x));
     return x;
 
   temp = gen_reg_rtx (GET_MODE (x));

+
+  if (MEM_POINTER (x))
+    REG_POINTER (temp) = 1;
+

   emit_move_insn (temp, x);
   return temp;
 }
   emit_move_insn (temp, x);
   return temp;
 }


@@ -804,13 +745,11 @@ force_not_mem (x)
    MODE is the mode to use for X in case it is a constant.  */
 
 rtx
    MODE is the mode to use for X in case it is a constant.  */
 
 rtx

-copy_to_suggested_reg (x, target, mode)
-     rtx x, target;
-     enum machine_mode mode;
+copy_to_suggested_reg (rtx x, rtx target, enum machine_mode mode)

 {
   rtx temp;
 
 {
   rtx temp;
 

-  if (target && GET_CODE (target) == REG)
+  if (target && REG_P (target))

     temp = target;
   else
     temp = gen_reg_rtx (mode);
     temp = target;
   else
     temp = gen_reg_rtx (mode);


@@ -825,27 +764,39 @@ copy_to_suggested_reg (x, target, mode)
 
    FOR_CALL is nonzero if this call is promoting args for a call.  */
 
 
    FOR_CALL is nonzero if this call is promoting args for a call.  */
 

+#if defined(PROMOTE_MODE) && !defined(PROMOTE_FUNCTION_MODE)
+#define PROMOTE_FUNCTION_MODE PROMOTE_MODE
+#endif
+

 enum machine_mode
 enum machine_mode

-promote_mode (type, mode, punsignedp, for_call)
-     tree type;
-     enum machine_mode mode;
-     int *punsignedp;
-     int for_call ATTRIBUTE_UNUSED;
+promote_mode (tree type, enum machine_mode mode, int *punsignedp,
+             int for_call ATTRIBUTE_UNUSED)

 {
   enum tree_code code = TREE_CODE (type);
   int unsignedp = *punsignedp;
 
 {
   enum tree_code code = TREE_CODE (type);
   int unsignedp = *punsignedp;
 

-#ifdef PROMOTE_FOR_CALL_ONLY
+#ifndef PROMOTE_MODE

   if (! for_call)
     return mode;
 #endif
 
   switch (code)
     {
   if (! for_call)
     return mode;
 #endif
 
   switch (code)
     {

-#ifdef PROMOTE_MODE
+#ifdef PROMOTE_FUNCTION_MODE

     case INTEGER_TYPE:   case ENUMERAL_TYPE:   case BOOLEAN_TYPE:
     case CHAR_TYPE:      case REAL_TYPE:       case OFFSET_TYPE:
     case INTEGER_TYPE:   case ENUMERAL_TYPE:   case BOOLEAN_TYPE:
     case CHAR_TYPE:      case REAL_TYPE:       case OFFSET_TYPE:

-      PROMOTE_MODE (mode, unsignedp, type);
+#ifdef PROMOTE_MODE
+      if (for_call)
+       {
+#endif
+         PROMOTE_FUNCTION_MODE (mode, unsignedp, type);
+#ifdef PROMOTE_MODE
+       }
+      else
+       {
+         PROMOTE_MODE (mode, unsignedp, type);
+       }
+#endif

       break;
 #endif
 
       break;
 #endif
 


@@ -869,11 +820,9 @@ promote_mode (type, mode, punsignedp, for_call)
    This pops when ADJUST is positive.  ADJUST need not be constant.  */
 
 void
    This pops when ADJUST is positive.  ADJUST need not be constant.  */
 
 void

-adjust_stack (adjust)
-     rtx adjust;
+adjust_stack (rtx adjust)

 {
   rtx temp;
 {
   rtx temp;

-  adjust = protect_from_queue (adjust, 0);

 
   if (adjust == const0_rtx)
     return;
 
   if (adjust == const0_rtx)
     return;


@@ -900,11 +849,9 @@ adjust_stack (adjust)
    This pushes when ADJUST is positive.  ADJUST need not be constant.  */
 
 void
    This pushes when ADJUST is positive.  ADJUST need not be constant.  */
 
 void

-anti_adjust_stack (adjust)
-     rtx adjust;
+anti_adjust_stack (rtx adjust)

 {
   rtx temp;
 {
   rtx temp;

-  adjust = protect_from_queue (adjust, 0);

 
   if (adjust == const0_rtx)
     return;
 
   if (adjust == const0_rtx)
     return;


@@ -931,15 +878,17 @@ anti_adjust_stack (adjust)
    by this machine.  SIZE is the desired size, which need not be constant.  */
 
 rtx
    by this machine.  SIZE is the desired size, which need not be constant.  */
 
 rtx

-round_push (size)
-     rtx size;
+round_push (rtx size)

 {
   int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
 {
   int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;

+

   if (align == 1)
     return size;
   if (align == 1)
     return size;

+

   if (GET_CODE (size) == CONST_INT)
     {
   if (GET_CODE (size) == CONST_INT)
     {

-      int new = (INTVAL (size) + align - 1) / align * align;
+      HOST_WIDE_INT new = (INTVAL (size) + align - 1) / align * align;
+

       if (INTVAL (size) != new)
        size = GEN_INT (new);
     }
       if (INTVAL (size) != new)
        size = GEN_INT (new);
     }


@@ -954,6 +903,7 @@ round_push (size)
                            NULL_RTX, 1);
       size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
     }
                            NULL_RTX, 1);
       size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
     }

+

   return size;
 }
 \f
   return size;
 }
 \f


@@ -966,14 +916,11 @@ round_push (size)
    are emitted at the current position.  */
 
 void
    are emitted at the current position.  */
 
 void

-emit_stack_save (save_level, psave, after)
-     enum save_level save_level;
-     rtx *psave;
-     rtx after;
+emit_stack_save (enum save_level save_level, rtx *psave, rtx after)

 {
   rtx sa = *psave;
   /* The default is that we use a move insn and save in a Pmode object.  */
 {
   rtx sa = *psave;
   /* The default is that we use a move insn and save in a Pmode object.  */

-  rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
+  rtx (*fcn) (rtx, rtx) = gen_move_insn;

   enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
 
   /* See if this machine has anything special to do for this kind of save.  */
   enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
 
   /* See if this machine has anything special to do for this kind of save.  */


@@ -1014,11 +961,6 @@ emit_stack_save (save_level, psave, after)
            *psave = sa = gen_reg_rtx (mode);
        }
     }
            *psave = sa = gen_reg_rtx (mode);
        }
     }

-  else
-    {
-      if (mode == VOIDmode || GET_MODE (sa) != mode)
-       abort ();
-    }

 
   if (after)
     {
 
   if (after)
     {


@@ -1049,13 +991,10 @@ emit_stack_save (save_level, psave, after)
    current position.  */
 
 void
    current position.  */
 
 void

-emit_stack_restore (save_level, sa, after)
-     enum save_level save_level;
-     rtx after;
-     rtx sa;
+emit_stack_restore (enum save_level save_level, rtx sa, rtx after)

 {
   /* The default is that we use a move insn.  */
 {
   /* The default is that we use a move insn.  */

-  rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
+  rtx (*fcn) (rtx, rtx) = gen_move_insn;

 
   /* See if this machine has anything special to do for this kind of save.  */
   switch (save_level)
 
   /* See if this machine has anything special to do for this kind of save.  */
   switch (save_level)


@@ -1089,7 +1028,7 @@ emit_stack_restore (save_level, sa, after)
         references to variable arrays below the code
         that deletes (pops) the arrays.  */
       emit_insn (gen_rtx_CLOBBER (VOIDmode,
         references to variable arrays below the code
         that deletes (pops) the arrays.  */
       emit_insn (gen_rtx_CLOBBER (VOIDmode,

-                   gen_rtx_MEM (BLKmode, 
+                   gen_rtx_MEM (BLKmode,

                        gen_rtx_SCRATCH (VOIDmode))));
       emit_insn (gen_rtx_CLOBBER (VOIDmode,
                    gen_rtx_MEM (BLKmode, stack_pointer_rtx)));
                        gen_rtx_SCRATCH (VOIDmode))));
       emit_insn (gen_rtx_CLOBBER (VOIDmode,
                    gen_rtx_MEM (BLKmode, stack_pointer_rtx)));


@@ -1108,6 +1047,27 @@ emit_stack_restore (save_level, sa, after)
   else
     emit_insn (fcn (stack_pointer_rtx, sa));
 }
   else
     emit_insn (fcn (stack_pointer_rtx, sa));
 }

+
+/* Invoke emit_stack_save on the nonlocal_goto_save_area for the current
+   function.  This function should be called whenever we allocate or
+   deallocate dynamic stack space.  */
+
+void
+update_nonlocal_goto_save_area (void)
+{
+  tree t_save;
+  rtx r_save;
+
+  /* The nonlocal_goto_save_area object is an array of N pointers.  The
+     first one is used for the frame pointer save; the rest are sized by
+     STACK_SAVEAREA_MODE.  Create a reference to array index 1, the first
+     of the stack save area slots.  */
+  t_save = build4 (ARRAY_REF, ptr_type_node, cfun->nonlocal_goto_save_area,
+                  integer_one_node, NULL_TREE, NULL_TREE);
+  r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE);
+
+  emit_stack_save (SAVE_NONLOCAL, &r_save, NULL_RTX);
+}

 \f
 #ifdef SETJMP_VIA_SAVE_AREA
 /* Optimize RTL generated by allocate_dynamic_stack_space for targets
 \f
 #ifdef SETJMP_VIA_SAVE_AREA
 /* Optimize RTL generated by allocate_dynamic_stack_space for targets


@@ -1116,16 +1076,15 @@ emit_stack_restore (save_level, sa, after)
    frame, thus causing a crash if a longjmp unwinds to it.  */
 
 void
    frame, thus causing a crash if a longjmp unwinds to it.  */
 
 void

-optimize_save_area_alloca (insns)
-     rtx insns;
+optimize_save_area_alloca (void)

 {
   rtx insn;
 
 {
   rtx insn;
 

-  for (insn = insns; insn; insn = NEXT_INSN(insn))
+  for (insn = get_insns (); insn; insn = NEXT_INSN(insn))

     {
       rtx note;
 
     {
       rtx note;
 

-      if (GET_CODE (insn) != INSN)
+      if (!NONJUMP_INSN_P (insn))

        continue;
 
       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
        continue;
 
       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))


@@ -1201,10 +1160,7 @@ optimize_save_area_alloca (insns)
    KNOWN_ALIGN is the alignment (in bits) that we know SIZE has.  */
 
 rtx
    KNOWN_ALIGN is the alignment (in bits) that we know SIZE has.  */
 
 rtx

-allocate_dynamic_stack_space (size, target, known_align)
-     rtx size;
-     rtx target;
-     int known_align;
+allocate_dynamic_stack_space (rtx size, rtx target, int known_align)

 {
 #ifdef SETJMP_VIA_SAVE_AREA
   rtx setjmpless_size = NULL_RTX;
 {
 #ifdef SETJMP_VIA_SAVE_AREA
   rtx setjmpless_size = NULL_RTX;


@@ -1340,7 +1296,7 @@ allocate_dynamic_stack_space (size, target, known_align)
     probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
 
   /* Don't use a TARGET that isn't a pseudo or is the wrong mode.  */
     probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
 
   /* Don't use a TARGET that isn't a pseudo or is the wrong mode.  */

-  if (target == 0 || GET_CODE (target) != REG
+  if (target == 0 || !REG_P (target)

       || REGNO (target) < FIRST_PSEUDO_REGISTER
       || GET_MODE (target) != Pmode)
     target = gen_reg_rtx (Pmode);
       || REGNO (target) < FIRST_PSEUDO_REGISTER
       || GET_MODE (target) != Pmode)
     target = gen_reg_rtx (Pmode);


@@ -1435,16 +1391,9 @@ allocate_dynamic_stack_space (size, target, known_align)
                            NULL_RTX, 1);
     }
 
                            NULL_RTX, 1);
     }
 

-  /* Some systems require a particular insn to refer to the stack
-     to make the pages exist.  */
-#ifdef HAVE_probe
-  if (HAVE_probe)
-    emit_insn (gen_probe ());
-#endif
-

   /* Record the new stack level for nonlocal gotos.  */
   /* Record the new stack level for nonlocal gotos.  */

-  if (nonlocal_goto_handler_slots != 0)
-    emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
+  if (cfun->nonlocal_goto_save_area != 0)
+    update_nonlocal_goto_save_area ();

 
   return target;
 }
 
   return target;
 }


@@ -1456,8 +1405,7 @@ allocate_dynamic_stack_space (size, target, known_align)
 static GTY(()) rtx stack_check_libfunc;
 
 void
 static GTY(()) rtx stack_check_libfunc;
 
 void

-set_stack_check_libfunc (libfunc)
-     rtx libfunc;
+set_stack_check_libfunc (rtx libfunc)

 {
   stack_check_libfunc = libfunc;
 }
 {
   stack_check_libfunc = libfunc;
 }


@@ -1465,8 +1413,7 @@ set_stack_check_libfunc (libfunc)
 /* Emit one stack probe at ADDRESS, an address within the stack.  */
 
 static void
 /* Emit one stack probe at ADDRESS, an address within the stack.  */
 
 static void

-emit_stack_probe (address)
-     rtx address;
+emit_stack_probe (rtx address)

 {
   rtx memref = gen_rtx_MEM (word_mode, address);
 
 {
   rtx memref = gen_rtx_MEM (word_mode, address);
 


@@ -1491,9 +1438,7 @@ emit_stack_probe (address)
 #endif
 
 void
 #endif
 
 void

-probe_stack_range (first, size)
-     HOST_WIDE_INT first;
-     rtx size;
+probe_stack_range (HOST_WIDE_INT first, rtx size)

 {
   /* First ensure SIZE is Pmode.  */
   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
 {
   /* First ensure SIZE is Pmode.  */
   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)


@@ -1508,11 +1453,7 @@ probe_stack_range (first, size)
                                                 stack_pointer_rtx,
                                                 plus_constant (size, first)));
 
                                                 stack_pointer_rtx,
                                                 plus_constant (size, first)));
 

-#ifdef POINTERS_EXTEND_UNSIGNED
-      if (GET_MODE (addr) != ptr_mode)
-       addr = convert_memory_address (ptr_mode, addr);
-#endif
-
+      addr = convert_memory_address (ptr_mode, addr);

       emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
                         ptr_mode);
     }
       emit_library_call (stack_check_libfunc, LCT_NORMAL, VOIDmode, 1, addr,
                         ptr_mode);
     }


@@ -1579,18 +1520,15 @@ probe_stack_range (first, size)
       rtx end_lab = gen_label_rtx ();
       rtx temp;
 
       rtx end_lab = gen_label_rtx ();
       rtx temp;
 

-      if (GET_CODE (test_addr) != REG
+      if (!REG_P (test_addr)

          || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
        test_addr = force_reg (Pmode, test_addr);
 
          || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
        test_addr = force_reg (Pmode, test_addr);
 

-      emit_note (NULL, NOTE_INSN_LOOP_BEG);

       emit_jump (test_lab);
 
       emit_label (loop_lab);
       emit_stack_probe (test_addr);
 
       emit_jump (test_lab);
 
       emit_label (loop_lab);
       emit_stack_probe (test_addr);
 

-      emit_note (NULL, NOTE_INSN_LOOP_CONT);
-

 #ifdef STACK_GROWS_DOWNWARD
 #define CMP_OPCODE GTU
       temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
 #ifdef STACK_GROWS_DOWNWARD
 #define CMP_OPCODE GTU
       temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,


@@ -1608,7 +1546,6 @@ probe_stack_range (first, size)
       emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
                               NULL_RTX, Pmode, 1, loop_lab);
       emit_jump (end_lab);
       emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
                               NULL_RTX, Pmode, 1, loop_lab);
       emit_jump (end_lab);

-      emit_note (NULL, NOTE_INSN_LOOP_END);

       emit_label (end_lab);
 
       emit_stack_probe (last_addr);
       emit_label (end_lab);
 
       emit_stack_probe (last_addr);


@@ -1625,10 +1562,8 @@ probe_stack_range (first, size)
    and 0 otherwise.  */
 
 rtx
    and 0 otherwise.  */
 
 rtx

-hard_function_value (valtype, func, outgoing)
-     tree valtype;
-     tree func ATTRIBUTE_UNUSED;
-     int outgoing ATTRIBUTE_UNUSED;
+hard_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
+                    int outgoing ATTRIBUTE_UNUSED)

 {
   rtx val;
 
 {
   rtx val;
 


@@ -1639,7 +1574,7 @@ hard_function_value (valtype, func, outgoing)
 #endif
     val = FUNCTION_VALUE (valtype, func);
 
 #endif
     val = FUNCTION_VALUE (valtype, func);
 

-  if (GET_CODE (val) == REG
+  if (REG_P (val)

       && GET_MODE (val) == BLKmode)
     {
       unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
       && GET_MODE (val) == BLKmode)
     {
       unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);


@@ -1671,8 +1606,7 @@ hard_function_value (valtype, func, outgoing)
    in which a scalar value of mode MODE was returned by a library call.  */
 
 rtx
    in which a scalar value of mode MODE was returned by a library call.  */
 
 rtx

-hard_libcall_value (mode)
-     enum machine_mode mode;
+hard_libcall_value (enum machine_mode mode)

 {
   return LIBCALL_VALUE (mode);
 }
 {
   return LIBCALL_VALUE (mode);
 }


@@ -1683,8 +1617,7 @@ hard_libcall_value (mode)
    what `enum tree_code' means.  */
 
 int
    what `enum tree_code' means.  */
 
 int

-rtx_to_tree_code (code)
-     enum rtx_code code;
+rtx_to_tree_code (enum rtx_code code)

 {
   enum tree_code tcode;
 
 {
   enum tree_code tcode;