This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [RFA] Convert sparc64 fully to entry point call dummy
- From: Michael Snyder <msnyder at redhat dot com>
- To: "David S. Miller" <davem at redhat dot com>
- Cc: gdb-patches at sources dot redhat dot com
- Date: Tue, 23 Apr 2002 13:00:59 -0700
- Subject: Re: [RFA] Convert sparc64 fully to entry point call dummy
- Organization: Red Hat, Inc.
- References: <20020420.040115.44265606.davem@redhat.com>
"David S. Miller" wrote:
>
> Basically:
>
> 1) Sparc32 can never use anything other than ON_STACK for call
> dummys. This is in order to get proper nesting of functions
> returning structures, ie. the unimp after call convention.
>
> There is no reason to keep around code that supports entry
> point call dummys because it can never work.
>
> 2) Sparc64 basically has to use entry point call dummys or something
> similar. Luckily it can as it lacks the silly unimp after call
> convention for functions returning structures.
>
> The reason it cannot use ON_STACK is because many systems protect
> the process stack such that you cannot execute code on it.
> Solaris is one such Sparc system that configures by default to do
> this for 64-bit applications.
>
> There is a dummy frame tracking mechanism added here, and as I
> mentioned on this list the other day one of the first things I'm going
> to do once all my bits are reviewed and installed is to convert this
> to use the generic call dummy bits as much as possible.
After you convert this to use the generic call dummy method,
I expect I'll approve it. The basic idea is sound, but I
see no reason to check in a method that duplicates the
generic code.
>
> sparc32 sparc64
> failures before 83 105
> failures after 83 101
>
> 2002-04-20 David S. Miller <davem@redhat.com>
>
> Convert sparc64 to use AT_ENTRY_POINT call dummy.
> * config/sparc/tm-sp64.h (CALL_DUMMY): Delete.
> (CALL_DUMMY_LENGTH, CALL_DUMMY_START_OFFSET,
> CALL_DUMMY_CALL_OFFSET, CALL_DUMMY_BREAKPOINT_OFFSET): Set all to
> zero.
> (CALL_DUMMY_LOCATION): Set to AT_ENTRY_POINT.
> (FIX_CALL_DUMMY): Now a nop.
> (PUSH_RETURN_ADDRESS): Define.
> (FRAME_ARGS_SKIP): Fix, should be 128
> * sparc-tdep.c (dummy_frame_desc): New struct.
> (frame_extra_info): Add dummy_info entry.
> (dummy_frames): List of dummy frames.
> (new_dummy_frame, dummy_frame_for_sp, destroy_dummy_frame): New
> functions.
> (sparc_init_extra_frame_info): Check dummy_info to determine if
> a dummy frame. Initialize extra_info->dummy_info for new frame.
> (sparc_frame_saved_pc): Check dummy_info to determine if a dummy
> frame.
> (sparc_get_saved_register): Likewise.
> (sparc_frame_find_saved_regs): Likewise.
> (sparc_pop_frame): If dummy frame, call destroy_dummy_frame.
> (sparc_fix_call_dummy): Verify !arch64.
> (sparc_push_return_address): Call new_dummy_frame. Verify we are
> arch64 if AT_ENTRY_POINT, else ON_STACK and !arch64.
> (sparc32_store_struct_return): Delete AT_ENTRY_POINT code.
> (sparc64_store_struct_return): Likewise.
> (sparc_gdbarch_fix_call_dummy): If !ON_STACK verify we are arch64.
> (SPARC32_CALL_DUMMY_ON_STACK): Delete.
> (call_dummy_64): Delete.
> (bfd_mach_sparc 32-bit cases): Document why ON_STACK is the only
> method that will work on 32-bit sparc. Delete all code protected
> by !SPARC32_CALL_DUMMY_ON_STACK.
> (bfd_mach_sparc 64-bit cases): Delete all ON_STACK support, it
> cannot work this way because many platform execute protect
> the stack. Initialize for AT_ENTRY_POINT values.
>
> --- config/sparc/tm-sp64.h.~1~ Sat Apr 20 01:55:05 2002
> +++ config/sparc/tm-sp64.h Sat Apr 20 03:19:12 2002
> @@ -31,135 +31,33 @@
>
> #include "sparc/tm-sparc.h"
>
> -/* Eeeew. Ok, we have to assume (for now) that the processor really is
> - in sparc64 mode. While this is the same instruction sequence as
> - on the Sparc, the stack frames are offset by +2047 (and the arguments
> - are 8 bytes instead of 4). */
> -/* Instructions are:
> - std %f10, [ %fp + 0x7a7 ]
> - std %f8, [ %fp + 0x79f ]
> - std %f6, [ %fp + 0x797 ]
> - std %f4, [ %fp + 0x78f ]
> - std %f2, [ %fp + 0x787 ]
> - std %f0, [ %fp + 0x77f ]
> - std %g6, [ %fp + 0x777 ]
> - std %g4, [ %fp + 0x76f ]
> - std %g2, [ %fp + 0x767 ]
> - std %g0, [ %fp + 0x75f ]
> - std %fp, [ %fp + 0x757 ]
> - std %i4, [ %fp + 0x74f ]
> - std %i2, [ %fp + 0x747 ]
> - std %i0, [ %fp + 0x73f ]
> - nop
> - nop
> - nop
> - nop
> - rd %tbr, %o0
> - st %o0, [ %fp + 0x72b ]
> - rd %tpc, %o0
> - st %o0, [ %fp + 0x727 ]
> - rd %psr, %o0
> - st %o0, [ %fp + 0x723 ]
> - rd %y, %o0
> - st %o0, [ %fp + 0x71f ]
> - ldx [ %sp + 0x8a7 ], %o5
> - ldx [ %sp + 0x89f ], %o4
> - ldx [ %sp + 0x897 ], %o3
> - ldx [ %sp + 0x88f ], %o2
> - ldx [ %sp + 0x887 ], %o1
> - call %g0
> - ldx [ %sp + 0x87f ], %o0
> - nop
> - ta 1
> - nop
> - nop
> - */
> +/* For the dummy call on sparc64, we don't have the 'unimp' instruction
> + after calls to functions returning structures, so we can just
> + us AT_ENTRY_POINT for CALL_DUMMY. */
>
> #if !defined (GDB_MULTI_ARCH) || (GDB_MULTI_ARCH == 0)
> -/*
> - * The following defines must go away for MULTI_ARCH.
> - */
> -
> -#ifndef DO_CALL_DUMMY_ON_STACK
> -
> -/*
> - * These defines will suffice for the AT_ENTRY_POINT call dummy method.
> - */
> -
> -#undef CALL_DUMMY
> -#define CALL_DUMMY {0}
> -#undef CALL_DUMMY_LENGTH
> -#define CALL_DUMMY_LENGTH 0
> -#undef CALL_DUMMY_CALL_OFFSET
> -#define CALL_DUMMY_CALL_OFFSET 0
> -#undef CALL_DUMMY_START_OFFSET
> -#define CALL_DUMMY_START_OFFSET 0
> -#undef CALL_DUMMY_BREAKPOINT_OFFSET
> -#define CALL_DUMMY_BREAKPOINT_OFFSET 0
> -#undef CALL_DUMMY_BREAKPOINT_OFFSET_P
> -#define CALL_DUMMY_BREAKPOINT_OFFSET_P 1
> -#undef CALL_DUMMY_LOCATION
> -#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
> -#undef CALL_DUMMY_STACK_ADJUST
> -#define CALL_DUMMY_STACK_ADJUST 128
> -#undef SIZEOF_CALL_DUMMY_WORDS
> -#define SIZEOF_CALL_DUMMY_WORDS 0
> -#undef CALL_DUMMY_ADDRESS
> -#define CALL_DUMMY_ADDRESS() entry_point_address()
> -#undef FIX_CALL_DUMMY
> -#define FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P)
> -#undef PUSH_RETURN_ADDRESS
> -#define PUSH_RETURN_ADDRESS(PC, SP) sparc_at_entry_push_return_address (PC, SP)
> -extern CORE_ADDR
> -sparc_at_entry_push_return_address (CORE_ADDR pc, CORE_ADDR sp);
> -
> -#undef STORE_STRUCT_RETURN
> -#define STORE_STRUCT_RETURN(ADDR, SP) \
> - sparc_at_entry_store_struct_return (ADDR, SP)
> -extern void
> -sparc_at_entry_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
> -
> -
> -#else
> -/*
> - * Old call dummy method, with CALL_DUMMY on the stack.
> - */
> -
> -#undef CALL_DUMMY
> -#define CALL_DUMMY { 0x9de3bec0fd3fa7f7LL, 0xf93fa7eff53fa7e7LL,\
> - 0xf13fa7dfed3fa7d7LL, 0xe93fa7cfe53fa7c7LL,\
> - 0xe13fa7bfdd3fa7b7LL, 0xd93fa7afd53fa7a7LL,\
> - 0xd13fa79fcd3fa797LL, 0xc93fa78fc53fa787LL,\
> - 0xc13fa77fcc3fa777LL, 0xc83fa76fc43fa767LL,\
> - 0xc03fa75ffc3fa757LL, 0xf83fa74ff43fa747LL,\
> - 0xf03fa73f01000000LL, 0x0100000001000000LL,\
> - 0x0100000091580000LL, 0xd027a72b93500000LL,\
> - 0xd027a72791480000LL, 0xd027a72391400000LL,\
> - 0xd027a71fda5ba8a7LL, 0xd85ba89fd65ba897LL,\
> - 0xd45ba88fd25ba887LL, 0x9fc02000d05ba87fLL,\
> - 0x0100000091d02001LL, 0x0100000001000000LL }
>
>
> /* 128 is to reserve space to write the %i/%l registers that will be restored
> - when we resume. */
> + when we resume. */
> #undef CALL_DUMMY_STACK_ADJUST
> #define CALL_DUMMY_STACK_ADJUST 128
>
> /* Size of the call dummy in bytes. */
> #undef CALL_DUMMY_LENGTH
> -#define CALL_DUMMY_LENGTH 192
> +#define CALL_DUMMY_LENGTH 0x0
>
> /* Offset within CALL_DUMMY of the 'call' instruction. */
> #undef CALL_DUMMY_START_OFFSET
> -#define CALL_DUMMY_START_OFFSET 148
> +#define CALL_DUMMY_START_OFFSET 0x0
>
> /* Offset within CALL_DUMMY of the 'call' instruction. */
> #undef CALL_DUMMY_CALL_OFFSET
> -#define CALL_DUMMY_CALL_OFFSET (CALL_DUMMY_START_OFFSET + (5 * 4))
> +#define CALL_DUMMY_CALL_OFFSET (CALL_DUMMY_START_OFFSET + 0x0)
>
> /* Offset within CALL_DUMMY of the 'ta 1' instruction. */
> #undef CALL_DUMMY_BREAKPOINT_OFFSET
> -#define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + (8 * 4))
> +#define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + 0x0)
>
> /* Let's GDB know that it can make a call_dummy breakpoint. */
> #undef CALL_DUMMY_BREAKPOINT_OFFSET_P
> @@ -167,24 +65,21 @@ sparc_at_entry_store_struct_return (CORE
>
> /* Call dummy will be located on the stack. */
> #undef CALL_DUMMY_LOCATION
> -#define CALL_DUMMY_LOCATION ON_STACK
> +#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
>
> /* Insert the function address into the call dummy. */
> #undef FIX_CALL_DUMMY
> #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
> - sparc_fix_call_dummy (dummyname, pc, fun, type, gcc_p)
> -void sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
> - struct type *value_type, int using_gcc);
> + do { } while (0)
>
> +#define PUSH_RETURN_ADDRESS(PC, SP) \
> + write_register (O7_REGNUM, CALL_DUMMY_ADDRESS() - 8)
>
> /* The remainder of these will accept the default definition. */
> #undef SIZEOF_CALL_DUMMY_WORDS
> -#undef PUSH_RETURN_ADDRESS
> #undef CALL_DUMMY_ADDRESS
> #undef STORE_STRUCT_RETURN
>
> -#endif
> -
> /* Does the specified function use the "struct returning" convention
> or the "value returning" convention? The "value returning" convention
> almost invariably returns the entire value in registers. The
> @@ -434,7 +329,7 @@ extern void sp64_extract_return_value (s
> /* Return number of bytes at start of arglist that are not really args. */
>
> #undef FRAME_ARGS_SKIP
> -#define FRAME_ARGS_SKIP 136
> +#define FRAME_ARGS_SKIP 128
>
> #endif /* GDB_MULTI_ARCH */
>
> --- sparc-tdep.c.~1~ Sat Apr 20 02:22:28 2002
> +++ sparc-tdep.c Sat Apr 20 03:23:24 2002
> @@ -267,11 +267,19 @@ sparc_software_single_step (enum target_
> }
> }
>
> +struct dummy_frame_desc
> + {
> + struct dummy_frame_desc *next;
> + CORE_ADDR sp;
> + };
> +
> struct frame_extra_info
> {
> CORE_ADDR bottom;
> int in_prologue;
> int flat;
> + /* This field non-NULL for a dummy frame. */
> + struct dummy_frame_desc *dummy_info;
> /* Following fields only relevant for flat frames. */
> CORE_ADDR pc_addr;
> CORE_ADDR fp_addr;
> @@ -280,6 +288,53 @@ struct frame_extra_info
> int sp_offset;
> };
>
> +static struct dummy_frame_desc *dummy_frames;
> +
> +static void
> +new_dummy_frame (CORE_ADDR sp)
> +{
> + struct dummy_frame_desc *dp = (struct dummy_frame_desc *)xmalloc (sizeof (*dp));
> +
> + dp->sp = sp;
> + dp->next = dummy_frames;
> + dummy_frames = dp;
> +}
> +
> +static struct dummy_frame_desc *
> +dummy_frame_for_sp(CORE_ADDR sp)
> +{
> + struct dummy_frame_desc *dp;
> +
> + for (dp = dummy_frames; dp != NULL; dp = dp->next)
> + {
> + if (dp->sp == sp)
> + break;
> + }
> +
> + return dp;
> +}
> +
> +static void
> +destroy_dummy_frame (struct frame_info *fi)
> +{
> + struct dummy_frame_desc *dp, **dpp;
> +
> + dpp = &dummy_frames;
> + while ((dp = *dpp) != NULL)
> + {
> + if (dp->sp == fi->extra_info->bottom)
> + break;
> + dpp = &dp->next;
> + }
> +
> + gdb_assert (dp != NULL && dp == fi->extra_info->dummy_info);
> +
> + *dpp = dp->next;
> + fi->extra_info->dummy_info = NULL;
> +
> + xfree (dp);
> +}
> +
> static CORE_ADDR examine_prologue (CORE_ADDR, int, struct frame_info *,
> CORE_ADDR *);
>
> @@ -317,7 +372,7 @@ sparc_init_extra_frame_info (int fromlea
> it later. */
> if (fi->next->next != NULL
> && (fi->next->next->signal_handler_caller
> - || frame_in_dummy (fi->next->next))
> + || fi->next->next->extra_info->dummy_info != NULL)
> && frameless_look_for_prologue (fi->next))
> {
> /* A frameless function interrupted by a signal did not change
> @@ -336,6 +391,8 @@ sparc_init_extra_frame_info (int fromlea
> }
> }
>
> + fi->extra_info->dummy_info = dummy_frame_for_sp (fi->extra_info->bottom);
> +
> /* Decide whether this is a function with a ``flat register window''
> frame. For such functions, the frame pointer is actually in %i7. */
> fi->extra_info->flat = 0;
> @@ -485,7 +542,7 @@ sparc_frame_saved_pc (struct frame_info
> else if (frame->extra_info->in_prologue ||
> (frame->next != NULL &&
> (frame->next->signal_handler_caller ||
> - frame_in_dummy (frame->next)) &&
> + frame->next->extra_info->dummy_info != NULL) &&
> frameless_look_for_prologue (frame)))
> {
> /* A frameless function interrupted by a signal did not save
> @@ -826,11 +883,7 @@ sparc_get_saved_register (char *raw_buff
>
> while (frame1 != NULL)
> {
> - /* FIXME MVS: wrong test for dummy frame at entry. */
> -
> - if (frame1->pc >= (frame1->extra_info->bottom ?
> - frame1->extra_info->bottom : read_sp ())
> - && frame1->pc <= FRAME_FP (frame1))
> + if (frame1->extra_info->dummy_info != NULL)
> {
> /* Dummy frame. All but the window regs are in there somewhere.
> The window registers are saved on the stack, just like in a
> @@ -1087,9 +1140,7 @@ sparc_frame_find_saved_regs (struct fram
>
> memset (saved_regs_addr, 0, NUM_REGS * sizeof (CORE_ADDR));
>
> - if (fi->pc >= (fi->extra_info->bottom ?
> - fi->extra_info->bottom : read_sp ())
> - && fi->pc <= FRAME_FP (fi))
> + if (fi->extra_info->dummy_info != NULL)
> {
> /* Dummy frame. All but the window regs are in there somewhere. */
> for (regnum = G1_REGNUM; regnum < G1_REGNUM + 7; regnum++)
> @@ -1349,6 +1400,10 @@ sparc_pop_frame (void)
> write_register (PC_REGNUM, pc);
> write_register (NPC_REGNUM, pc + 4);
> }
> +
> + if (frame->extra_info->dummy_info != NULL)
> + destroy_dummy_frame (frame);
> +
> flush_cached_frames ();
> }
>
> @@ -2181,6 +2236,8 @@ sparc_fix_call_dummy (char *dummy, CORE_
> {
> int i;
>
> + gdb_assert (! GDB_TARGET_IS_SPARC64);
> +
> /* Store the relative adddress of the target function into the
> 'call' instruction. */
> store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET, 4,
> @@ -3112,8 +3169,12 @@ sparclet_register_name (int regno)
> CORE_ADDR
> sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
> {
> + new_dummy_frame (sp - CALL_DUMMY_STACK_ADJUST);
> +
> if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
> {
> + gdb_assert (GDB_TARGET_IS_SPARC64);
> +
> /* The return PC of the dummy_frame is the former 'current' PC
> (where we were before we made the target function call).
> This is saved in %i7 by push_dummy_frame.
> @@ -3126,6 +3187,11 @@ sparc_push_return_address (CORE_ADDR pc_
> write_register (O7_REGNUM,
> CALL_DUMMY_ADDRESS () - 8);
> }
> + else
> + {
> + gdb_assert (! GDB_TARGET_IS_SPARC64
> + && CALL_DUMMY_LOCATION == ON_STACK);
> + }
>
> return sp;
> }
> @@ -3154,17 +3220,6 @@ sparc32_store_struct_return (CORE_ADDR a
> val = alloca (SPARC_INTREG_SIZE);
> store_unsigned_integer (val, SPARC_INTREG_SIZE, addr);
> write_memory (sp + (16 * SPARC_INTREG_SIZE), val, SPARC_INTREG_SIZE);
> -
> - if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
> - {
> - /* Now adjust the value of the link register, which was previously
> - stored by push_return_address. Functions that return structs are
> - peculiar in that they return to link register + 12, rather than
> - link register + 8. */
> -
> - o7 = read_register (O7_REGNUM);
> - write_register (O7_REGNUM, o7 - 4);
> - }
> }
>
> static void
> @@ -3175,17 +3230,6 @@ sparc64_store_struct_return (CORE_ADDR a
>
> target_write_memory (sp + (16 * SPARC_INTREG_SIZE),
> (char *) &addr, SPARC_INTREG_SIZE);
> -#if 0
> - if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
> - {
> - /* Now adjust the value of the link register, which was previously
> - stored by push_return_address. Functions that return structs are
> - peculiar in that they return to link register + 12, rather than
> - link register + 8. */
> -
> - write_register (O7_REGNUM, read_register (O7_REGNUM) - 4);
> - }
> -#endif
> }
>
> /* Default target data type for register REGNO. */
> @@ -3325,6 +3369,8 @@ sparc_gdbarch_fix_call_dummy (char *dumm
> {
> if (CALL_DUMMY_LOCATION == ON_STACK)
> sparc_fix_call_dummy (dummy, pc, fun, type, gcc_p);
> + else
> + gdb_assert (GDB_TARGET_IS_SPARC64);
> }
>
> /* Coerce float to double: a no-op. */
> @@ -3380,8 +3426,6 @@ sparc_return_value_on_stack (struct type
> * Gdbarch "constructor" function.
> */
>
> -#define SPARC32_CALL_DUMMY_ON_STACK
> -
> #define SPARC_SP_REGNUM 14
> #define SPARC_FP_REGNUM 30
> #define SPARC_FP0_REGNUM 32
> @@ -3404,20 +3448,6 @@ sparc_gdbarch_init (struct gdbarch_info
> 0xd203a048, 0x40000000, 0xd003a044, 0x01000000,
> 0x91d02001, 0x01000000
> };
> - static LONGEST call_dummy_64[] =
> - { 0x9de3bec0fd3fa7f7LL, 0xf93fa7eff53fa7e7LL,
> - 0xf13fa7dfed3fa7d7LL, 0xe93fa7cfe53fa7c7LL,
> - 0xe13fa7bfdd3fa7b7LL, 0xd93fa7afd53fa7a7LL,
> - 0xd13fa79fcd3fa797LL, 0xc93fa78fc53fa787LL,
> - 0xc13fa77fcc3fa777LL, 0xc83fa76fc43fa767LL,
> - 0xc03fa75ffc3fa757LL, 0xf83fa74ff43fa747LL,
> - 0xf03fa73f01000000LL, 0x0100000001000000LL,
> - 0x0100000091580000LL, 0xd027a72b93500000LL,
> - 0xd027a72791480000LL, 0xd027a72391400000LL,
> - 0xd027a71fda5ba8a7LL, 0xd85ba89fd65ba897LL,
> - 0xd45ba88fd25ba887LL, 0x9fc02000d05ba87fLL,
> - 0x0100000091d02001LL, 0x0100000001000000LL
> - };
> static LONGEST call_dummy_nil[] = {0};
>
> /* First see if there is already a gdbarch that can satisfy the request. */
> @@ -3496,21 +3526,16 @@ sparc_gdbarch_init (struct gdbarch_info
> case bfd_mach_sparc_sparclite_le:
> /* 32-bit machine types: */
>
> -#ifdef SPARC32_CALL_DUMMY_ON_STACK
> + /* This is no way we could ever use AT_ENTRY_POINT for call dummy
> + on 32-bit Sparc targets. The reason is for proper nested handling
> + of the unimp-after-call convention used when returning structures
> + from functions. */
> set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
> set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
> set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0x30);
> set_gdbarch_call_dummy_length (gdbarch, 0x38);
> set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
> set_gdbarch_call_dummy_words (gdbarch, call_dummy_32);
> -#else
> - set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
> - set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
> - set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
> - set_gdbarch_call_dummy_length (gdbarch, 0);
> - set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
> - set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
> -#endif
> set_gdbarch_call_dummy_stack_adjust (gdbarch, 68);
> set_gdbarch_call_dummy_start_offset (gdbarch, 0);
> set_gdbarch_frame_args_skip (gdbarch, 68);
> @@ -3529,11 +3554,7 @@ sparc_gdbarch_init (struct gdbarch_info
> set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
> set_gdbarch_register_virtual_type (gdbarch,
> sparc32_register_virtual_type);
> -#ifdef SPARC32_CALL_DUMMY_ON_STACK
> set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
> -#else
> - set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
> -#endif
> set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
> set_gdbarch_store_struct_return (gdbarch, sparc32_store_struct_return);
> set_gdbarch_use_struct_convention (gdbarch,
> @@ -3551,15 +3572,6 @@ sparc_gdbarch_init (struct gdbarch_info
> /* 64-bit machine types: */
> default: /* Any new machine type is likely to be 64-bit. */
>
> -#ifdef SPARC64_CALL_DUMMY_ON_STACK
> - set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
> - set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
> - set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
> - set_gdbarch_call_dummy_length (gdbarch, 192);
> - set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
> - set_gdbarch_call_dummy_start_offset (gdbarch, 148);
> - set_gdbarch_call_dummy_words (gdbarch, call_dummy_64);
> -#else
> set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
> set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
> set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
> @@ -3567,9 +3579,10 @@ sparc_gdbarch_init (struct gdbarch_info
> set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
> set_gdbarch_call_dummy_start_offset (gdbarch, 0);
> set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
> -#endif
> set_gdbarch_call_dummy_stack_adjust (gdbarch, 128);
> - set_gdbarch_frame_args_skip (gdbarch, 136);
> + set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
> +
> + set_gdbarch_frame_args_skip (gdbarch, 128);
> set_gdbarch_function_start_offset (gdbarch, 0);
> set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
> set_gdbarch_npc_regnum (gdbarch, SPARC64_NPC_REGNUM);
> @@ -3587,11 +3600,6 @@ sparc_gdbarch_init (struct gdbarch_info
> set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
> set_gdbarch_register_virtual_type (gdbarch,
> sparc64_register_virtual_type);
> -#ifdef SPARC64_CALL_DUMMY_ON_STACK
> - set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
> -#else
> - set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
> -#endif
> set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
> set_gdbarch_store_struct_return (gdbarch, sparc64_store_struct_return);
> set_gdbarch_use_struct_convention (gdbarch,
> @@ -3602,7 +3610,7 @@ sparc_gdbarch_init (struct gdbarch_info
> tdep->fp_max_regnum = SPARC_FP0_REGNUM + 48;
> tdep->intreg_size = 8;
> tdep->reg_save_offset = 0x90;
> - tdep->call_dummy_call_offset = 148 + 4 * 5;
> + tdep->call_dummy_call_offset = 0x0;
> break;
> }
>