[commit] Delete legacy_push_dummy_code

[Andrew Cagney <cagney at gnu dot org>]

legacy_push_dummy_code() pushes a non- generic dummy frame call/return 
sequence onto the stack.  With generic dummy frames, this isn't needed.

committed,
Andrew

2004-05-08  Andrew Cagney  <cagney@redhat.com>

	* infcall.c (legacy_push_dummy_code): Delete function.
	(push_dummy_code): Delete call.

Index: infcall.c
===================================================================
RCS file: /cvs/src/src/gdb/infcall.c,v
retrieving revision 1.43
diff -p -u -r1.43 infcall.c
--- infcall.c	8 May 2004 19:03:05 -0000	1.43
+++ infcall.c	8 May 2004 19:37:32 -0000
@@ -219,84 +219,6 @@ breakpoint_auto_delete_contents (void *a
 }
 
 static CORE_ADDR
-legacy_push_dummy_code (struct gdbarch *gdbarch,
-			CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
-			struct value **args, int nargs,
-			struct type *value_type,
-			CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
-{
-  /* CALL_DUMMY is an array of words (DEPRECATED_REGISTER_SIZE), but
-     each word is in host byte order.  Before calling
-     DEPRECATED_FIX_CALL_DUMMY, we byteswap it and remove any extra
-     bytes which might exist because ULONGEST is bigger than
-     DEPRECATED_REGISTER_SIZE.  */
-  /* NOTE: This is pretty wierd, as the call dummy is actually a
-     sequence of instructions.  But CISC machines will have to pack
-     the instructions into DEPRECATED_REGISTER_SIZE units (and so will
-     RISC machines for which INSTRUCTION_SIZE is not
-     DEPRECATED_REGISTER_SIZE).  */
-  /* NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
-     target byte order. */
-  CORE_ADDR start_sp;
-  ULONGEST *dummy = alloca (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
-  int sizeof_dummy1 = (DEPRECATED_REGISTER_SIZE
-		       * DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
-		       / sizeof (ULONGEST));
-  char *dummy1 = alloca (sizeof_dummy1);
-  memcpy (dummy, DEPRECATED_CALL_DUMMY_WORDS,
-	  DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
-  if (INNER_THAN (1, 2))
-    {
-      /* Stack grows down */
-      sp -= sizeof_dummy1;
-      start_sp = sp;
-    }
-  else
-    {
-      /* Stack grows up */
-      start_sp = sp;
-      sp += sizeof_dummy1;
-    }
-  /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack
-     after allocating space for the call dummy.  A target can specify
-     a SIZEOF_DUMMY1 (via DEPRECATED_SIZEOF_CALL_DUMMY_WORDS) such
-     that all local alignment requirements are met.  */
-  /* Create a call sequence customized for this function and the
-     number of arguments for it.  */
-  {
-    int i;
-    for (i = 0; i < (int) (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0]));
-	 i++)
-      store_unsigned_integer (&dummy1[i * DEPRECATED_REGISTER_SIZE],
-			      DEPRECATED_REGISTER_SIZE,
-			      (ULONGEST) dummy[i]);
-  }
-  /* NOTE: cagney/2003-04-22: This computation of REAL_PC, BP_ADDR and
-     DUMMY_ADDR is pretty messed up.  It comes from constant tinkering
-     with the values.  Instead a DEPRECATED_FIX_CALL_DUMMY replacement
-     (PUSH_DUMMY_BREAKPOINT?) should just do everything.  */
-  if (!gdbarch_push_dummy_call_p (current_gdbarch))
-    {
-      if (DEPRECATED_FIX_CALL_DUMMY_P ())
-	{
-	  /* gdb_assert (CALL_DUMMY_LOCATION == ON_STACK) true?  */
-	  DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
-				     value_type, using_gcc);
-	}
-      (*real_pc) = start_sp;
-    }
-  /* Yes, the offset is applied to the real_pc and not the dummy addr.
-     Ulgh!  Blame the HP/UX target.  */
-  (*bp_addr) = (*real_pc) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
-  /* Yes, the offset is applied to the real_pc and not the
-     dummy_addr.  Ulgh!  Blame the HP/UX target.  */
-  (*real_pc) += DEPRECATED_CALL_DUMMY_START_OFFSET;
-  write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
-  generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
-  return sp;
-}
-
-static CORE_ADDR
 generic_push_dummy_code (struct gdbarch *gdbarch,
 			 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
 			 struct value **args, int nargs,
@@ -332,8 +254,8 @@ generic_push_dummy_code (struct gdbarch 
   return sp;
 }
 
-/* Provide backward compatibility.  Once DEPRECATED_FIX_CALL_DUMMY is
-   eliminated, this can be simplified.  */
+/* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
+   function returns to.  */
 
 static CORE_ADDR
 push_dummy_code (struct gdbarch *gdbarch,
@@ -345,10 +267,6 @@ push_dummy_code (struct gdbarch *gdbarch
   if (gdbarch_push_dummy_code_p (gdbarch))
     return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
 				    args, nargs, value_type, real_pc, bp_addr);
-  else if (DEPRECATED_FIX_CALL_DUMMY_P ()
-	   && !gdbarch_push_dummy_call_p (gdbarch))
-    return legacy_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
-				   args, nargs, value_type, real_pc, bp_addr);
   else    
     return generic_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
 				    args, nargs, value_type, real_pc, bp_addr);