FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2003-09-11 Andrew Cagney <cagney@redhat.com>

Browse source 
* gdbarch.sh (DEPRECATED_STACK_ALIGN): Rename STACK_ALIGN.
	* gdbarch.h, gdbarch.c: Re-generate.
	* infcall.c (call_function_by_hand): Update.
	* hppa-tdep.c (hppa_push_arguments): Update.
	* ada-lang.c (place_on_stack): Update.
	* xstormy16-tdep.c (xstormy16_gdbarch_init): Update.
	* sparc-tdep.c (sparc_gdbarch_init): Update.
	* m68hc11-tdep.c (m68hc11_gdbarch_init): Update.
	* hppa-tdep.c (hppa_gdbarch_init): Update.
	* h8300-tdep.c (h8300_gdbarch_init): Delete comment refering to
	stack_align.
This commit is contained in:
Andrew Cagney 2003-09-11 15:17:18 +00:00
parent f630a401b4
commit f27dd7fde7
13 changed files with 101 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

14
gdb/ChangeLog
View file

@ -1,3 +1,17 @@
2003-09-11 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_STACK_ALIGN): Rename STACK_ALIGN.
* gdbarch.h, gdbarch.c: Re-generate.
* infcall.c (call_function_by_hand): Update.
* hppa-tdep.c (hppa_push_arguments): Update.
* ada-lang.c (place_on_stack): Update.
* xstormy16-tdep.c (xstormy16_gdbarch_init): Update.
* sparc-tdep.c (sparc_gdbarch_init): Update.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Update.
* hppa-tdep.c (hppa_gdbarch_init): Update.
* h8300-tdep.c (h8300_gdbarch_init): Delete comment refering to
stack_align.
2003-09-11 Daniel Jacobowitz <drow@mvista.com> 2003-09-11 Daniel Jacobowitz <drow@mvista.com>
* dwarf2loc.c (dwarf2_loc_desc_needs_frame): Variables in a * dwarf2loc.c (dwarf2_loc_desc_needs_frame): Variables in a

4
gdb/ada-lang.c
View file

@ -3022,9 +3022,9 @@ place_on_stack (struct value *val, CORE_ADDR *sp)
{ {
CORE_ADDR old_sp = *sp; CORE_ADDR old_sp = *sp;
#ifdef STACK_ALIGN #ifdef DEPRECATED_STACK_ALIGN
*sp = push_bytes (*sp, VALUE_CONTENTS_RAW (val), *sp = push_bytes (*sp, VALUE_CONTENTS_RAW (val),
STACK_ALIGN (TYPE_LENGTH DEPRECATED_STACK_ALIGN (TYPE_LENGTH
(check_typedef (VALUE_TYPE (val))))); (check_typedef (VALUE_TYPE (val)))));
#else #else
*sp = push_bytes (*sp, VALUE_CONTENTS_RAW (val), *sp = push_bytes (*sp, VALUE_CONTENTS_RAW (val),

5
gdb/doc/ChangeLog
View file

@ -1,3 +1,8 @@
2003-09-11 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Replace
STACK_ALIGN with DEPRECATED_STACK_ALIGN.
2003-08-18 Andrew Cagney <cagney@redhat.com> 2003-08-18 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Document * gdbint.texinfo (Target Architecture Definition): Document

12
gdb/doc/gdbint.texinfo
View file

@ -3218,14 +3218,14 @@ Otherwise return 0.
Define this to adjust @var{address} so that it meets the alignment Define this to adjust @var{address} so that it meets the alignment
requirements for the start of a new stack frame. A stack frame's requirements for the start of a new stack frame. A stack frame's
alignment requirements are typically stronger than a target processors alignment requirements are typically stronger than a target processors
stack alignment requirements (@pxref{STACK_ALIGN}). stack alignment requirements (@pxref{DEPRECATED_STACK_ALIGN}).
This function is used to ensure that, when creating a dummy frame, both This function is used to ensure that, when creating a dummy frame, both
the initial stack pointer and (if needed) the address of the return the initial stack pointer and (if needed) the address of the return
value are correctly aligned. value are correctly aligned.
Unlike @code{STACK_ALIGN}, this function always adjusts the address in Unlike @code{DEPRECATED_STACK_ALIGN}, this function always adjusts the
the direction of stack growth. address in the direction of stack growth.
By default, no frame based stack alignment is performed. By default, no frame based stack alignment is performed.
@ -3812,9 +3812,9 @@ Define this to convert stab register numbers (as gotten from `r'
declarations) into @value{GDBN} regnums. If not defined, no conversion will be declarations) into @value{GDBN} regnums. If not defined, no conversion will be
done. done.
@item STACK_ALIGN (@var{addr}) @item DEPRECATED_STACK_ALIGN (@var{addr})
@anchor{STACK_ALIGN} @anchor{DEPRECATED_STACK_ALIGN}
@findex STACK_ALIGN @findex DEPRECATED_STACK_ALIGN
Define this to increase @var{addr} so that it meets the alignment Define this to increase @var{addr} so that it meets the alignment
requirements for the processor's stack. requirements for the processor's stack.

62
gdb/gdbarch.c
View file

@ -235,7 +235,7 @@ struct gdbarch
gdbarch_deprecated_frame_locals_address_ftype *deprecated_frame_locals_address; gdbarch_deprecated_frame_locals_address_ftype *deprecated_frame_locals_address;
gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call; gdbarch_deprecated_saved_pc_after_call_ftype *deprecated_saved_pc_after_call;
gdbarch_frame_num_args_ftype *frame_num_args; gdbarch_frame_num_args_ftype *frame_num_args;
gdbarch_stack_align_ftype *stack_align; gdbarch_deprecated_stack_align_ftype *deprecated_stack_align;
gdbarch_frame_align_ftype *frame_align; gdbarch_frame_align_ftype *frame_align;
gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr; gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
int frame_red_zone_size; int frame_red_zone_size;
@ -403,7 +403,7 @@ struct gdbarch startup_gdbarch =
get_frame_base, /* deprecated_frame_locals_address */ get_frame_base, /* deprecated_frame_locals_address */
0, /* deprecated_saved_pc_after_call */ 0, /* deprecated_saved_pc_after_call */
0, /* frame_num_args */ 0, /* frame_num_args */
0, /* stack_align */ 0, /* deprecated_stack_align */
0, /* frame_align */ 0, /* frame_align */
0, /* reg_struct_has_addr */ 0, /* reg_struct_has_addr */
0, /* frame_red_zone_size */ 0, /* frame_red_zone_size */
@ -727,7 +727,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
/* Skip verify of deprecated_frame_locals_address, has predicate */ /* Skip verify of deprecated_frame_locals_address, has predicate */
/* Skip verify of deprecated_saved_pc_after_call, has predicate */ /* Skip verify of deprecated_saved_pc_after_call, has predicate */
/* Skip verify of frame_num_args, has predicate */ /* Skip verify of frame_num_args, has predicate */
/* Skip verify of stack_align, has predicate */ /* Skip verify of deprecated_stack_align, has predicate */
/* Skip verify of frame_align, has predicate */ /* Skip verify of frame_align, has predicate */
/* Skip verify of reg_struct_has_addr, has predicate */ /* Skip verify of reg_struct_has_addr, has predicate */
if (gdbarch->float_format == 0) if (gdbarch->float_format == 0)
@ -1544,6 +1544,25 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
"gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n", "gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n",
DEPRECATED_SIZEOF_CALL_DUMMY_WORDS); DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
#endif #endif
#ifdef DEPRECATED_STACK_ALIGN_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"DEPRECATED_STACK_ALIGN_P()",
XSTRING (DEPRECATED_STACK_ALIGN_P ()));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_STACK_ALIGN_P() = %d\n",
DEPRECATED_STACK_ALIGN_P ());
#endif
#ifdef DEPRECATED_STACK_ALIGN
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"DEPRECATED_STACK_ALIGN(sp)",
XSTRING (DEPRECATED_STACK_ALIGN (sp)));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_STACK_ALIGN = <0x%08lx>\n",
(long) current_gdbarch->deprecated_stack_align
/*DEPRECATED_STACK_ALIGN ()*/);
#endif
#ifdef DEPRECATED_STORE_RETURN_VALUE #ifdef DEPRECATED_STORE_RETURN_VALUE
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n", "gdbarch_dump: %s # %s\n",
@ -2236,25 +2255,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->stab_reg_to_regnum (long) current_gdbarch->stab_reg_to_regnum
/*STAB_REG_TO_REGNUM ()*/); /*STAB_REG_TO_REGNUM ()*/);
#endif #endif
#ifdef STACK_ALIGN_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"STACK_ALIGN_P()",
XSTRING (STACK_ALIGN_P ()));
fprintf_unfiltered (file,
"gdbarch_dump: STACK_ALIGN_P() = %d\n",
STACK_ALIGN_P ());
#endif
#ifdef STACK_ALIGN
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"STACK_ALIGN(sp)",
XSTRING (STACK_ALIGN (sp)));
fprintf_unfiltered (file,
"gdbarch_dump: STACK_ALIGN = <0x%08lx>\n",
(long) current_gdbarch->stack_align
/*STACK_ALIGN ()*/);
#endif
#ifdef STORE_RETURN_VALUE #ifdef STORE_RETURN_VALUE
fprintf_unfiltered (file, fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n", "gdbarch_dump: %s # %s\n",
@ -4859,27 +4859,27 @@ set_gdbarch_frame_num_args (struct gdbarch *gdbarch,
} }
int int
gdbarch_stack_align_p (struct gdbarch *gdbarch) gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch)
{ {
gdb_assert (gdbarch != NULL); gdb_assert (gdbarch != NULL);
return gdbarch->stack_align != NULL; return gdbarch->deprecated_stack_align != NULL;
} }
CORE_ADDR CORE_ADDR
gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp) gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp)
{ {
gdb_assert (gdbarch != NULL); gdb_assert (gdbarch != NULL);
gdb_assert (gdbarch->stack_align != NULL); gdb_assert (gdbarch->deprecated_stack_align != NULL);
if (gdbarch_debug >= 2) if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_stack_align called\n"); fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_stack_align called\n");
return gdbarch->stack_align (sp); return gdbarch->deprecated_stack_align (sp);
} }
void void
set_gdbarch_stack_align (struct gdbarch *gdbarch, set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch,
gdbarch_stack_align_ftype stack_align) gdbarch_deprecated_stack_align_ftype deprecated_stack_align)
{ {
gdbarch->stack_align = stack_align; gdbarch->deprecated_stack_align = deprecated_stack_align;
} }
int int

37
gdb/gdbarch.h
View file

@ -1900,29 +1900,34 @@ extern void set_gdbarch_frame_num_args (struct gdbarch *gdbarch, gdbarch_frame_n
#define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame)) #define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame))
#endif #endif
#if defined (STACK_ALIGN) /* DEPRECATED_STACK_ALIGN has been replaced by an initial aligning call
/* Legacy for systems yet to multi-arch STACK_ALIGN */ to frame_align and the requirement that methods such as
#if !defined (STACK_ALIGN_P) push_dummy_call and frame_red_zone_size maintain correct stack/frame
#define STACK_ALIGN_P() (1) alignment. */
#if defined (DEPRECATED_STACK_ALIGN)
/* Legacy for systems yet to multi-arch DEPRECATED_STACK_ALIGN */
#if !defined (DEPRECATED_STACK_ALIGN_P)
#define DEPRECATED_STACK_ALIGN_P() (1)
#endif #endif
#endif #endif
extern int gdbarch_stack_align_p (struct gdbarch *gdbarch); extern int gdbarch_deprecated_stack_align_p (struct gdbarch *gdbarch);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STACK_ALIGN_P) #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_STACK_ALIGN_P)
#error "Non multi-arch definition of STACK_ALIGN" #error "Non multi-arch definition of DEPRECATED_STACK_ALIGN"
#endif #endif
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (STACK_ALIGN_P) #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_STACK_ALIGN_P)
#define STACK_ALIGN_P() (gdbarch_stack_align_p (current_gdbarch)) #define DEPRECATED_STACK_ALIGN_P() (gdbarch_deprecated_stack_align_p (current_gdbarch))
#endif #endif
typedef CORE_ADDR (gdbarch_stack_align_ftype) (CORE_ADDR sp); typedef CORE_ADDR (gdbarch_deprecated_stack_align_ftype) (CORE_ADDR sp);
extern CORE_ADDR gdbarch_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp); extern CORE_ADDR gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, CORE_ADDR sp);
extern void set_gdbarch_stack_align (struct gdbarch *gdbarch, gdbarch_stack_align_ftype *stack_align); extern void set_gdbarch_deprecated_stack_align (struct gdbarch *gdbarch, gdbarch_deprecated_stack_align_ftype *deprecated_stack_align);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (STACK_ALIGN) #if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_STACK_ALIGN)
#error "Non multi-arch definition of STACK_ALIGN" #error "Non multi-arch definition of DEPRECATED_STACK_ALIGN"
#endif #endif
#if !defined (STACK_ALIGN) #if !defined (DEPRECATED_STACK_ALIGN)
#define STACK_ALIGN(sp) (gdbarch_stack_align (current_gdbarch, sp)) #define DEPRECATED_STACK_ALIGN(sp) (gdbarch_deprecated_stack_align (current_gdbarch, sp))
#endif #endif
extern int gdbarch_frame_align_p (struct gdbarch *gdbarch); extern int gdbarch_frame_align_p (struct gdbarch *gdbarch);

6
gdb/gdbarch.sh
View file

@ -640,7 +640,11 @@ F::DEPRECATED_FRAME_LOCALS_ADDRESS:CORE_ADDR:deprecated_frame_locals_address:str
F::DEPRECATED_SAVED_PC_AFTER_CALL:CORE_ADDR:deprecated_saved_pc_after_call:struct frame_info *frame:frame F::DEPRECATED_SAVED_PC_AFTER_CALL:CORE_ADDR:deprecated_saved_pc_after_call:struct frame_info *frame:frame
F:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame F:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame
# #
F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp # DEPRECATED_STACK_ALIGN has been replaced by an initial aligning call
# to frame_align and the requirement that methods such as
# push_dummy_call and frame_red_zone_size maintain correct stack/frame
# alignment.
F:2:DEPRECATED_STACK_ALIGN:CORE_ADDR:deprecated_stack_align:CORE_ADDR sp:sp
M:::CORE_ADDR:frame_align:CORE_ADDR address:address M:::CORE_ADDR:frame_align:CORE_ADDR address:address
F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type
v::FRAME_RED_ZONE_SIZE:int:frame_red_zone_size v::FRAME_RED_ZONE_SIZE:int:frame_red_zone_size

1
gdb/h8300-tdep.c
View file

@ -1331,7 +1331,6 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
/* set_gdbarch_stack_align (gdbarch, SOME_stack_align); */
set_gdbarch_believe_pcc_promotion (gdbarch, 1); set_gdbarch_believe_pcc_promotion (gdbarch, 1);
/* Char is unsigned. */ /* Char is unsigned. */

10
gdb/hppa-tdep.c
View file

@ -1870,7 +1870,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* The value of SP as it was passed into this function after /* The value of SP as it was passed into this function after
aligning. */ aligning. */
CORE_ADDR orig_sp = STACK_ALIGN (sp); CORE_ADDR orig_sp = DEPRECATED_STACK_ALIGN (sp);
/* The number of stack bytes occupied by the current argument. */ /* The number of stack bytes occupied by the current argument. */
int bytes_reserved; int bytes_reserved;
@ -1933,7 +1933,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
The ABIs also mandate minimum stack alignments which we must The ABIs also mandate minimum stack alignments which we must
preserve. */ preserve. */
cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved); cum_bytes_aligned = DEPRECATED_STACK_ALIGN (cum_bytes_reserved);
sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE); sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
/* Now write each of the args at the proper offset down the stack. */ /* Now write each of the args at the proper offset down the stack. */
@ -2040,7 +2040,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
The ABI also mandates minimum stack alignments which we must The ABI also mandates minimum stack alignments which we must
preserve. */ preserve. */
cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved); cum_bytes_aligned = DEPRECATED_STACK_ALIGN (cum_bytes_reserved);
sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE); sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
/* Now write each of the args at the proper offset down the stack. /* Now write each of the args at the proper offset down the stack.
@ -5118,7 +5118,7 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
(gdbarch, hppa32_register_virtual_type); (gdbarch, hppa32_register_virtual_type);
set_gdbarch_deprecated_call_dummy_length set_gdbarch_deprecated_call_dummy_length
(gdbarch, hppa32_call_dummy_length); (gdbarch, hppa32_call_dummy_length);
set_gdbarch_stack_align (gdbarch, hppa32_stack_align); set_gdbarch_deprecated_stack_align (gdbarch, hppa32_stack_align);
set_gdbarch_reg_struct_has_addr (gdbarch, hppa_reg_struct_has_addr); set_gdbarch_reg_struct_has_addr (gdbarch, hppa_reg_struct_has_addr);
set_gdbarch_deprecated_extract_return_value set_gdbarch_deprecated_extract_return_value
(gdbarch, hppa32_extract_return_value); (gdbarch, hppa32_extract_return_value);
@ -5136,7 +5136,7 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
(gdbarch, hppa64_call_dummy_breakpoint_offset); (gdbarch, hppa64_call_dummy_breakpoint_offset);
set_gdbarch_deprecated_call_dummy_length set_gdbarch_deprecated_call_dummy_length
(gdbarch, hppa64_call_dummy_length); (gdbarch, hppa64_call_dummy_length);
set_gdbarch_stack_align (gdbarch, hppa64_stack_align); set_gdbarch_deprecated_stack_align (gdbarch, hppa64_stack_align);
set_gdbarch_deprecated_extract_return_value set_gdbarch_deprecated_extract_return_value
(gdbarch, hppa64_extract_return_value); (gdbarch, hppa64_extract_return_value);
set_gdbarch_use_struct_convention set_gdbarch_use_struct_convention

16
gdb/infcall.c
View file

@ -689,12 +689,12 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i])); arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
len = TYPE_LENGTH (arg_type); len = TYPE_LENGTH (arg_type);
if (STACK_ALIGN_P ()) if (DEPRECATED_STACK_ALIGN_P ())
/* MVS 11/22/96: I think at least some of this /* MVS 11/22/96: I think at least some of this
stack_align code is really broken. Better to let stack_align code is really broken. Better to let
PUSH_ARGUMENTS adjust the stack in a target-defined PUSH_ARGUMENTS adjust the stack in a target-defined
manner. */ manner. */
aligned_len = STACK_ALIGN (len); aligned_len = DEPRECATED_STACK_ALIGN (len);
else else
aligned_len = len; aligned_len = len;
if (INNER_THAN (1, 2)) if (INNER_THAN (1, 2))
@ -732,10 +732,10 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
if (struct_return) if (struct_return)
{ {
int len = TYPE_LENGTH (value_type); int len = TYPE_LENGTH (value_type);
if (STACK_ALIGN_P ()) if (DEPRECATED_STACK_ALIGN_P ())
/* NOTE: cagney/2003-03-22: Should rely on frame align, rather /* NOTE: cagney/2003-03-22: Should rely on frame align, rather
than stack align to force the alignment of the stack. */ than stack align to force the alignment of the stack. */
len = STACK_ALIGN (len); len = DEPRECATED_STACK_ALIGN (len);
if (INNER_THAN (1, 2)) if (INNER_THAN (1, 2))
{ {
/* Stack grows downward. Align STRUCT_ADDR and SP after /* Stack grows downward. Align STRUCT_ADDR and SP after
@ -770,7 +770,7 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
/* MVS 11/22/96: I think at least some of this stack_align code /* MVS 11/22/96: I think at least some of this stack_align code
is really broken. Better to let push_dummy_call() adjust the is really broken. Better to let push_dummy_call() adjust the
stack in a target-defined manner. */ stack in a target-defined manner. */
if (STACK_ALIGN_P () && INNER_THAN (1, 2)) if (DEPRECATED_STACK_ALIGN_P () && INNER_THAN (1, 2))
{ {
/* If stack grows down, we must leave a hole at the top. */ /* If stack grows down, we must leave a hole at the top. */
int len = 0; int len = 0;
@ -779,7 +779,7 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()) if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
len += DEPRECATED_CALL_DUMMY_STACK_ADJUST; len += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
sp -= STACK_ALIGN (len) - len; sp -= DEPRECATED_STACK_ALIGN (len) - len;
} }
} }
@ -824,13 +824,13 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
handled any alignment issues, the code below is entirely handled any alignment issues, the code below is entirely
redundant. */ redundant. */
if (!gdbarch_push_dummy_call_p (current_gdbarch) if (!gdbarch_push_dummy_call_p (current_gdbarch)
&& STACK_ALIGN_P () && !INNER_THAN (1, 2)) && DEPRECATED_STACK_ALIGN_P () && !INNER_THAN (1, 2))
{ {
/* If stack grows up, we must leave a hole at the bottom, note /* If stack grows up, we must leave a hole at the bottom, note
that sp already has been advanced for the arguments! */ that sp already has been advanced for the arguments! */
if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()) if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ())
sp += DEPRECATED_CALL_DUMMY_STACK_ADJUST; sp += DEPRECATED_CALL_DUMMY_STACK_ADJUST;
sp = STACK_ALIGN (sp); sp = DEPRECATED_STACK_ALIGN (sp);
} }
/* XXX This seems wrong. For stacks that grow down we shouldn't do /* XXX This seems wrong. For stacks that grow down we shouldn't do

2
gdb/m68hc11-tdep.c
View file

@ -1572,7 +1572,7 @@ m68hc11_gdbarch_init (struct gdbarch_info info,
set_gdbarch_decr_pc_after_break (gdbarch, 0); set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_function_start_offset (gdbarch, 0); set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_breakpoint_from_pc (gdbarch, m68hc11_breakpoint_from_pc); set_gdbarch_breakpoint_from_pc (gdbarch, m68hc11_breakpoint_from_pc);
set_gdbarch_stack_align (gdbarch, m68hc11_stack_align); set_gdbarch_deprecated_stack_align (gdbarch, m68hc11_stack_align);
set_gdbarch_print_insn (gdbarch, gdb_print_insn_m68hc11); set_gdbarch_print_insn (gdbarch, gdb_print_insn_m68hc11);
m68hc11_add_reggroups (gdbarch); m68hc11_add_reggroups (gdbarch);

4
gdb/sparc-tdep.c
View file

@ -3398,7 +3398,7 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
#else #else
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0); set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif #endif
set_gdbarch_stack_align (gdbarch, sparc32_stack_align); set_gdbarch_deprecated_stack_align (gdbarch, sparc32_stack_align);
set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1); set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return); set_gdbarch_deprecated_store_struct_return (gdbarch, sparc32_store_struct_return);
set_gdbarch_use_struct_convention (gdbarch, set_gdbarch_use_struct_convention (gdbarch,
@ -3451,7 +3451,7 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
#else #else
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0); set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif #endif
set_gdbarch_stack_align (gdbarch, sparc64_stack_align); set_gdbarch_deprecated_stack_align (gdbarch, sparc64_stack_align);
set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1); set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return); set_gdbarch_deprecated_store_struct_return (gdbarch, sparc64_store_struct_return);
set_gdbarch_use_struct_convention (gdbarch, set_gdbarch_use_struct_convention (gdbarch,

2
gdb/xstormy16-tdep.c
View file

@ -1103,7 +1103,7 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer); set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address); set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
set_gdbarch_stack_align (gdbarch, xstormy16_stack_align); set_gdbarch_deprecated_stack_align (gdbarch, xstormy16_stack_align);
set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos); set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);