dwarf2out.c (stack_adjust_offset): New function.

2000-09-01  Andrew Haley  <aph@redhat.com>

        * dwarf2out.c (stack_adjust_offset): New function.
        (dwarf2out_stack_adjust): Break out stack adjust logic into
        new stack_adjust_offset function.  Look inside parallels and
        sequences for stack adjustments.

From-SVN: r36098

2 files changed, 64 insertions, 33 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4c36d7c..d82386a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2000-09-01  Andrew Haley  <aph@redhat.com>
+
+        * dwarf2out.c (stack_adjust_offset): New function.
+        (dwarf2out_stack_adjust): Break out stack adjust logic into
+        new stack_adjust_offset function.  Look inside parallels and
+        sequences for stack adjustments.
+
 2000-08-31  Jeff Law <law@cygnus.com>
 
 	* arm.md: Use no_new_pseudos to determine when it is safe
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index de81db0..1b55383 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -1093,6 +1093,49 @@ initial_return_save (rtl)
   reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
 }
 
+/* Given a SET, calculate the amount of stack adjustment it
+   contains. */
+
+static long stack_adjust_offset (pattern)
+  rtx pattern;
+{
+  rtx src = SET_SRC (pattern);
+  rtx dest = SET_DEST (pattern);
+  long offset = 0;
+  enum rtx_code code;
+
+  if (dest == stack_pointer_rtx)
+    {
+      /* (set (reg sp) (plus (reg sp) (const_int))) */
+      code = GET_CODE (src);
+      if (! (code == PLUS || code == MINUS)
+	  || XEXP (src, 0) != stack_pointer_rtx
+	  || GET_CODE (XEXP (src, 1)) != CONST_INT)
+	return 0;
+
+      offset = INTVAL (XEXP (src, 1));
+    }
+  else if (GET_CODE (dest) == MEM)
+    {
+      /* (set (mem (pre_dec (reg sp))) (foo)) */
+      src = XEXP (dest, 0);
+      code = GET_CODE (src);
+
+      if (! (code == PRE_DEC || code == PRE_INC)
+	  || XEXP (src, 0) != stack_pointer_rtx)
+	return 0;
+
+      offset = GET_MODE_SIZE (GET_MODE (dest));
+    }
+  else
+    return 0;
+
+  if (code == PLUS || code == PRE_INC)
+    offset = -offset;
+
+  return offset;
+}
+
 /* Check INSN to see if it looks like a push or a stack adjustment, and
    make a note of it if it does.  EH uses this information to find out how
    much extra space it needs to pop off the stack.  */
@@ -1138,45 +1181,26 @@ dwarf2out_stack_adjust (insn)
     }
   else if (GET_CODE (PATTERN (insn)) == SET)
     {
-      rtx src, dest;
-      enum rtx_code code;
-
-      insn = PATTERN (insn);
-      src = SET_SRC (insn);
-      dest = SET_DEST (insn);
-
-      if (dest == stack_pointer_rtx)
-	{
-	  /* (set (reg sp) (plus (reg sp) (const_int))) */
-	  code = GET_CODE (src);
-	  if (! (code == PLUS || code == MINUS)
-	      || XEXP (src, 0) != stack_pointer_rtx
-	      || GET_CODE (XEXP (src, 1)) != CONST_INT)
-	    return;
+      offset = stack_adjust_offset (PATTERN (insn));
+    }
+  else if (GET_CODE (PATTERN (insn)) == PARALLEL
+	   || GET_CODE (PATTERN (insn)) == SEQUENCE)
+    {
+      /* There may be stack adjustments inside compound insns.  Search
+         for them. */
+      int j;
 
-	  offset = INTVAL (XEXP (src, 1));
-	}
-      else if (GET_CODE (dest) == MEM)
+      offset = 0;
+      for (j = XVECLEN (PATTERN (insn), 0) - 1; j >= 0; j--)
 	{
-	  /* (set (mem (pre_dec (reg sp))) (foo)) */
-	  src = XEXP (dest, 0);
-	  code = GET_CODE (src);
-
-	  if (! (code == PRE_DEC || code == PRE_INC)
-	      || XEXP (src, 0) != stack_pointer_rtx)
-	    return;
-
-	  offset = GET_MODE_SIZE (GET_MODE (dest));
+	  rtx pattern = XVECEXP (PATTERN (insn), 0, j);
+	  if (GET_CODE (pattern) == SET)
+	    offset += stack_adjust_offset (pattern);
 	}
-      else
-	return;
-
-      if (code == PLUS || code == PRE_INC)
-	offset = -offset;
     }
   else
     return;
-
+  
   if (offset == 0)
     return;