aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJason Thorpe <thorpej@netbsd.org>2002-04-21 16:52:39 +0000
committerJason Thorpe <thorpej@netbsd.org>2002-04-21 16:52:39 +0000
commitdc129d82386b3ae4a511f9f60a76ac481d33d304 (patch)
tree8f169296cfc5c4d9a425e852e9d686026ad05c22
parentd49d1e0a2f67889077fff8ad80e9ed5e43ff169f (diff)
downloadgdb-dc129d82386b3ae4a511f9f60a76ac481d33d304.zip
gdb-dc129d82386b3ae4a511f9f60a76ac481d33d304.tar.gz
gdb-dc129d82386b3ae4a511f9f60a76ac481d33d304.tar.bz2
* alpha-tdep.h: New file. Includes several Alpha target constants
taken from... * config/alpha/tm-alpha.h: ...here. Remove macros that we now let gdbarch deal with. (GDB_MULTI_ARCH): Define as GDB_MULTI_ARCH_PARTIAL. * Makefile.in (alpha-nat.o): Add alpha-tdep.h and $(BFD_SRC)/elf-bfd to dependency list. * alpha-nat.c: Include alpha-tdep.h. Update for adjusted Alpha target register names. * alphabsd-nat.c: Likewise. * alpha-tdep.c: Include alpha-tdep.h. Update for adjusted Alpha target register names. Make serveral routines static. (alpha_get_saved_register): New function. (alpha_abi_names): New. (process_note_abi_tag_sections): New function. (get_elfosabi): New function. (alpha_gdbarch_init): New function. (alpha_dump_tdep): New function. (_initialize_alpha_tdep): Register alpha_gdbarch_init.
-rw-r--r--gdb/ChangeLog22
-rw-r--r--gdb/Makefile.in4
-rw-r--r--gdb/alpha-nat.c14
-rw-r--r--gdb/alpha-tdep.c515
-rw-r--r--gdb/alpha-tdep.h99
-rw-r--r--gdb/alphabsd-nat.c10
-rw-r--r--gdb/config/alpha/tm-alpha.h321
7 files changed, 606 insertions, 379 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ec6276c..1909f75 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,25 @@
+2002-04-21 Jason Thorpe <thorpej@wasabisystems.com>
+
+ * alpha-tdep.h: New file. Includes several Alpha target constants
+ taken from...
+ * config/alpha/tm-alpha.h: ...here. Remove macros that we now
+ let gdbarch deal with.
+ (GDB_MULTI_ARCH): Define as GDB_MULTI_ARCH_PARTIAL.
+ * Makefile.in (alpha-nat.o): Add alpha-tdep.h and $(BFD_SRC)/elf-bfd
+ to dependency list.
+ * alpha-nat.c: Include alpha-tdep.h. Update for adjusted
+ Alpha target register names.
+ * alphabsd-nat.c: Likewise.
+ * alpha-tdep.c: Include alpha-tdep.h. Update for adjusted
+ Alpha target register names. Make serveral routines static.
+ (alpha_get_saved_register): New function.
+ (alpha_abi_names): New.
+ (process_note_abi_tag_sections): New function.
+ (get_elfosabi): New function.
+ (alpha_gdbarch_init): New function.
+ (alpha_dump_tdep): New function.
+ (_initialize_alpha_tdep): Register alpha_gdbarch_init.
+
2002-04-21 Andrew Cagney <ac131313@redhat.com>
* frame.c (find_saved_register): Delete #ifdef
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 7c56bcc..266ce14 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -1238,11 +1238,11 @@ a68v-nat.o: a68v-nat.c $(defs_h) $(gdbcore_h) $(inferior_h) \
$(regcache_h)
alpha-nat.o: alpha-nat.c $(defs_h) $(gdbcore_h) $(inferior_h) $(target_h) \
- $(regcache_h)
+ $(regcache_h) alpha-tdep.h
alpha-tdep.o: alpha-tdep.c $(defs_h) $(gdbcmd_h) $(gdbcore_h) \
$(inferior_h) $(symtab_h) $(dis_asm_h) $(gdb_string_h) $(linespec_h) \
- $(regcache_h) $(doublest_h)
+ $(regcache_h) $(doublest_h) $(BFD_SRC)/elf-bfd.h alpha-tdep.h
annotate.o: annotate.c $(defs_h) $(annotate_h) $(value_h) $(target_h) $(gdbtypes_h)
diff --git a/gdb/alpha-nat.c b/gdb/alpha-nat.c
index f7e565b..fbf8155 100644
--- a/gdb/alpha-nat.c
+++ b/gdb/alpha-nat.c
@@ -24,6 +24,9 @@
#include "gdbcore.h"
#include "target.h"
#include "regcache.h"
+
+#include "alpha-tdep.h"
+
#include <sys/ptrace.h>
#ifdef __linux__
#include <asm/reg.h>
@@ -62,7 +65,7 @@ get_longjmp_target (CORE_ADDR *pc)
CORE_ADDR jb_addr;
char raw_buffer[MAX_REGISTER_RAW_SIZE];
- jb_addr = read_register (A0_REGNUM);
+ jb_addr = read_register (ALPHA_A0_REGNUM);
if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, raw_buffer,
sizeof (CORE_ADDR)))
@@ -171,10 +174,11 @@ fetch_elf_core_registers (char *core_reg_sect, unsigned core_reg_size,
else
{
/* The General Registers. */
- memcpy (&registers[REGISTER_BYTE (V0_REGNUM)], core_reg_sect, 31 * 8);
+ memcpy (&registers[REGISTER_BYTE (ALPHA_V0_REGNUM)], core_reg_sect,
+ 31 * 8);
memcpy (&registers[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8);
- memset (&registers[REGISTER_BYTE (ZERO_REGNUM)], 0, 8);
- memset (&register_valid[V0_REGNUM], 1, 32);
+ memset (&registers[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8);
+ memset (&register_valid[ALPHA_V0_REGNUM], 1, 32);
register_valid[PC_REGNUM] = 1;
}
}
@@ -227,7 +231,7 @@ supply_gregset (gdb_gregset_t *gregsetp)
supply_register (PC_REGNUM, (char *) (regp + 31));
/* Fill inaccessible registers with zero. */
- supply_register (ZERO_REGNUM, zerobuf);
+ supply_register (ALPHA_ZERO_REGNUM, zerobuf);
supply_register (FP_REGNUM, zerobuf);
}
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 1a81ec8..7d99cf5 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -33,6 +33,48 @@
#include "linespec.h"
#include "regcache.h"
#include "doublest.h"
+#include "arch-utils.h"
+
+#include "elf-bfd.h"
+
+#include "alpha-tdep.h"
+
+static gdbarch_init_ftype alpha_gdbarch_init;
+
+static gdbarch_register_name_ftype alpha_register_name;
+static gdbarch_register_raw_size_ftype alpha_register_raw_size;
+static gdbarch_register_virtual_size_ftype alpha_register_virtual_size;
+static gdbarch_register_virtual_type_ftype alpha_register_virtual_type;
+static gdbarch_register_byte_ftype alpha_register_byte;
+static gdbarch_cannot_fetch_register_ftype alpha_cannot_fetch_register;
+static gdbarch_cannot_store_register_ftype alpha_cannot_store_register;
+static gdbarch_register_convertible_ftype alpha_register_convertible;
+static gdbarch_register_convert_to_virtual_ftype
+ alpha_register_convert_to_virtual;
+static gdbarch_register_convert_to_raw_ftype alpha_register_convert_to_raw;
+static gdbarch_store_struct_return_ftype alpha_store_struct_return;
+static gdbarch_extract_return_value_ftype alpha_extract_return_value;
+static gdbarch_store_return_value_ftype alpha_store_return_value;
+static gdbarch_extract_struct_value_address_ftype
+ alpha_extract_struct_value_address;
+static gdbarch_use_struct_convention_ftype alpha_use_struct_convention;
+
+static gdbarch_frame_args_address_ftype alpha_frame_args_address;
+static gdbarch_frame_locals_address_ftype alpha_frame_locals_address;
+
+static gdbarch_skip_prologue_ftype alpha_skip_prologue;
+static gdbarch_get_saved_register_ftype alpha_get_saved_register;
+static gdbarch_saved_pc_after_call_ftype alpha_saved_pc_after_call;
+static gdbarch_frame_chain_ftype alpha_frame_chain;
+static gdbarch_frame_saved_pc_ftype alpha_frame_saved_pc;
+static gdbarch_frame_init_saved_regs_ftype alpha_frame_init_saved_regs;
+
+static gdbarch_push_arguments_ftype alpha_push_arguments;
+static gdbarch_push_dummy_frame_ftype alpha_push_dummy_frame;
+static gdbarch_pop_frame_ftype alpha_pop_frame;
+static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy;
+static gdbarch_init_frame_pc_first_ftype alpha_init_frame_pc_first;
+static gdbarch_init_extra_frame_info_ftype alpha_init_extra_frame_info;
struct frame_extra_info
{
@@ -275,7 +317,7 @@ push_sigtramp_desc (CORE_ADDR low_addr)
}
-char *
+static char *
alpha_register_name (int regno)
{
static char *register_names[] =
@@ -298,44 +340,44 @@ alpha_register_name (int regno)
return (register_names[regno]);
}
-int
+static int
alpha_cannot_fetch_register (int regno)
{
- return (regno == FP_REGNUM || regno == ZERO_REGNUM);
+ return (regno == FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
}
-int
+static int
alpha_cannot_store_register (int regno)
{
- return (regno == FP_REGNUM || regno == ZERO_REGNUM);
+ return (regno == FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
}
-int
+static int
alpha_register_convertible (int regno)
{
return (regno >= FP0_REGNUM && regno <= FP0_REGNUM + 31);
}
-struct type *
+static struct type *
alpha_register_virtual_type (int regno)
{
return ((regno >= FP0_REGNUM && regno < (FP0_REGNUM+31))
? builtin_type_double : builtin_type_long);
}
-int
+static int
alpha_register_byte (int regno)
{
return (regno * 8);
}
-int
+static int
alpha_register_raw_size (int regno)
{
return 8;
}
-int
+static int
alpha_register_virtual_size (int regno)
{
return 8;
@@ -433,7 +475,7 @@ alpha_find_saved_regs (struct frame_info *frame)
frame->saved_regs[PC_REGNUM] = frame->saved_regs[returnreg];
}
-void
+static void
alpha_frame_init_saved_regs (struct frame_info *fi)
{
if (fi->saved_regs == NULL)
@@ -441,7 +483,7 @@ alpha_frame_init_saved_regs (struct frame_info *fi)
fi->saved_regs[SP_REGNUM] = fi->frame;
}
-void
+static void
alpha_init_frame_pc_first (int fromleaf, struct frame_info *prev)
{
prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) :
@@ -468,7 +510,7 @@ read_next_frame_reg (struct frame_info *fi, int regno)
return read_register (regno);
}
-CORE_ADDR
+static CORE_ADDR
alpha_frame_saved_pc (struct frame_info *frame)
{
alpha_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
@@ -483,7 +525,55 @@ alpha_frame_saved_pc (struct frame_info *frame)
return read_next_frame_reg (frame, pcreg);
}
-CORE_ADDR
+static void
+alpha_get_saved_register (char *raw_buffer,
+ int *optimized,
+ CORE_ADDR *addrp,
+ struct frame_info *frame,
+ int regnum,
+ enum lval_type *lval)
+{
+ CORE_ADDR addr;
+
+ if (!target_has_registers)
+ error ("No registers.");
+
+ /* Normal systems don't optimize out things with register numbers. */
+ if (optimized != NULL)
+ *optimized = 0;
+ addr = find_saved_register (frame, regnum);
+ if (addr != 0)
+ {
+ if (lval != NULL)
+ *lval = lval_memory;
+ if (regnum == SP_REGNUM)
+ {
+ if (raw_buffer != NULL)
+ {
+ /* Put it back in target format. */
+ store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
+ (LONGEST) addr);
+ }
+ if (addrp != NULL)
+ *addrp = 0;
+ return;
+ }
+ if (raw_buffer != NULL)
+ target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
+ }
+ else
+ {
+ if (lval != NULL)
+ *lval = lval_register;
+ addr = REGISTER_BYTE (regnum);
+ if (raw_buffer != NULL)
+ read_register_gen (regnum, raw_buffer);
+ }
+ if (addrp != NULL)
+ *addrp = addr;
+}
+
+static CORE_ADDR
alpha_saved_pc_after_call (struct frame_info *frame)
{
CORE_ADDR pc = frame->pc;
@@ -497,7 +587,7 @@ alpha_saved_pc_after_call (struct frame_info *frame)
pc = tmp;
proc_desc = find_proc_desc (pc, frame->next);
- pcreg = proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM;
+ pcreg = proc_desc ? PROC_PC_REG (proc_desc) : ALPHA_RA_REGNUM;
if (frame->signal_handler_caller)
return alpha_frame_saved_pc (frame);
@@ -507,7 +597,7 @@ alpha_saved_pc_after_call (struct frame_info *frame)
static struct alpha_extra_func_info temp_proc_desc;
-static CORE_ADDR temp_saved_regs[NUM_REGS];
+static CORE_ADDR temp_saved_regs[ALPHA_NUM_REGS];
/* Nonzero if instruction at PC is a return instruction. "ret
$zero,($ra),1" on alpha. */
@@ -646,7 +736,8 @@ heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
e.g. via the minimal symbol table, might obviate this hack. */
if (pcreg == -1
&& cur_pc < (start_pc + 80)
- && (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM))
+ && (reg == ALPHA_T7_REGNUM || reg == ALPHA_T9_REGNUM
+ || reg == ALPHA_RA_REGNUM))
pcreg = reg;
}
else if ((word & 0xffe0ffff) == 0x6be08001) /* ret zero,reg,1 */
@@ -672,7 +763,8 @@ heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
&& (word & 0xffff0000) != 0xb7fe0000) /* reg != $zero */
{
int reg = (word & 0x03e00000) >> 21;
- if (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM)
+ if (reg == ALPHA_T7_REGNUM || reg == ALPHA_T9_REGNUM
+ || reg == ALPHA_RA_REGNUM)
{
pcreg = reg;
break;
@@ -687,12 +779,12 @@ heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
}
if (has_frame_reg)
- PROC_FRAME_REG (&temp_proc_desc) = GCC_FP_REGNUM;
+ PROC_FRAME_REG (&temp_proc_desc) = ALPHA_GCC_FP_REGNUM;
else
PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;
PROC_FRAME_OFFSET (&temp_proc_desc) = frame_size;
PROC_REG_MASK (&temp_proc_desc) = reg_mask;
- PROC_PC_REG (&temp_proc_desc) = (pcreg == -1) ? RA_REGNUM : pcreg;
+ PROC_PC_REG (&temp_proc_desc) = (pcreg == -1) ? ALPHA_RA_REGNUM : pcreg;
PROC_LOCALOFF (&temp_proc_desc) = 0; /* XXX - bogus */
return &temp_proc_desc;
}
@@ -874,7 +966,7 @@ find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame)
alpha_extra_func_info_t cached_proc_desc;
-CORE_ADDR
+static CORE_ADDR
alpha_frame_chain (struct frame_info *frame)
{
alpha_extra_func_info_t proc_desc;
@@ -920,7 +1012,7 @@ alpha_print_extra_frame_info (struct frame_info *fi)
paddr_d (fi->extra_info->proc_desc->pdr.frameoffset));
}
-void
+static void
alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
{
/* Use proc_desc calculated in frame_chain */
@@ -932,7 +1024,7 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
frame->saved_regs = NULL;
frame->extra_info->localoff = 0;
- frame->extra_info->pc_reg = RA_REGNUM;
+ frame->extra_info->pc_reg = ALPHA_RA_REGNUM;
frame->extra_info->proc_desc = proc_desc == &temp_proc_desc ? 0 : proc_desc;
if (proc_desc)
{
@@ -975,19 +1067,19 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
memcpy (frame->saved_regs, temp_saved_regs,
SIZEOF_FRAME_SAVED_REGS);
frame->saved_regs[PC_REGNUM]
- = frame->saved_regs[RA_REGNUM];
+ = frame->saved_regs[ALPHA_RA_REGNUM];
}
}
}
}
-CORE_ADDR
+static CORE_ADDR
alpha_frame_locals_address (struct frame_info *fi)
{
return (fi->frame - fi->extra_info->localoff);
}
-CORE_ADDR
+static CORE_ADDR
alpha_frame_args_address (struct frame_info *fi)
{
return (fi->frame - (ALPHA_NUM_ARG_REGS * 8));
@@ -1027,7 +1119,7 @@ alpha_setup_arbitrary_frame (int argc, CORE_ADDR *argv)
If the called function is returning a structure, the address of the
structure to be returned is passed as a hidden first argument. */
-CORE_ADDR
+static CORE_ADDR
alpha_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
@@ -1102,14 +1194,14 @@ alpha_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
LONGEST val;
val = read_memory_integer (sp + i * 8, 8);
- write_register (A0_REGNUM + i, val);
- write_register (FPA0_REGNUM + i, val);
+ write_register (ALPHA_A0_REGNUM + i, val);
+ write_register (ALPHA_FPA0_REGNUM + i, val);
}
return sp + arg_regs_size;
}
-void
+static void
alpha_push_dummy_frame (void)
{
int ireg;
@@ -1117,7 +1209,7 @@ alpha_push_dummy_frame (void)
alpha_extra_func_info_t proc_desc;
CORE_ADDR sp = read_register (SP_REGNUM);
CORE_ADDR save_address;
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
+ char raw_buffer[ALPHA_MAX_REGISTER_RAW_SIZE];
unsigned long mask;
link = (struct linked_proc_info *) xmalloc (sizeof (struct linked_proc_info));
@@ -1172,14 +1264,14 @@ alpha_push_dummy_frame (void)
registers follow in ascending order.
The PC is saved immediately below the SP. */
save_address = sp + PROC_REG_OFFSET (proc_desc);
- store_address (raw_buffer, 8, read_register (RA_REGNUM));
+ store_address (raw_buffer, 8, read_register (ALPHA_RA_REGNUM));
write_memory (save_address, raw_buffer, 8);
save_address += 8;
mask = PROC_REG_MASK (proc_desc) & 0xffffffffL;
for (ireg = 0; mask; ireg++, mask >>= 1)
if (mask & 1)
{
- if (ireg == RA_REGNUM)
+ if (ireg == ALPHA_RA_REGNUM)
continue;
store_address (raw_buffer, 8, read_register (ireg));
write_memory (save_address, raw_buffer, 8);
@@ -1222,10 +1314,10 @@ alpha_push_dummy_frame (void)
PROC_HIGH_ADDR (proc_desc) = PROC_LOW_ADDR (proc_desc) + 4;
SET_PROC_DESC_IS_DUMMY (proc_desc);
- PROC_PC_REG (proc_desc) = RA_REGNUM;
+ PROC_PC_REG (proc_desc) = ALPHA_RA_REGNUM;
}
-void
+static void
alpha_pop_frame (void)
{
register int regnum;
@@ -1368,7 +1460,7 @@ alpha_skip_prologue_internal (CORE_ADDR pc, int lenient)
return pc + offset;
}
-CORE_ADDR
+static CORE_ADDR
alpha_skip_prologue (CORE_ADDR addr)
{
return (alpha_skip_prologue_internal (addr, 0));
@@ -1392,7 +1484,7 @@ alpha_in_lenient_prologue (CORE_ADDR startaddr, CORE_ADDR pc)
or
memory format is an integer with 4 bytes or less, as the representation
of integers in floating point registers is different. */
-void
+static void
alpha_register_convert_to_virtual (int regnum, struct type *valtype,
char *raw_buffer, char *virtual_buffer)
{
@@ -1418,7 +1510,7 @@ alpha_register_convert_to_virtual (int regnum, struct type *valtype,
error ("Cannot retrieve value from floating point register");
}
-void
+static void
alpha_register_convert_to_raw (struct type *valtype, int regnum,
char *virtual_buffer, char *raw_buffer)
{
@@ -1450,7 +1542,7 @@ alpha_register_convert_to_raw (struct type *valtype, int regnum,
/* Given a return value in `regbuf' with a type `valtype',
extract and copy its value into `valbuf'. */
-void
+static void
alpha_extract_return_value (struct type *valtype,
char regbuf[REGISTER_BYTES], char *valbuf)
{
@@ -1459,17 +1551,18 @@ alpha_extract_return_value (struct type *valtype,
regbuf + REGISTER_BYTE (FP0_REGNUM),
valbuf);
else
- memcpy (valbuf, regbuf + REGISTER_BYTE (V0_REGNUM), TYPE_LENGTH (valtype));
+ memcpy (valbuf, regbuf + REGISTER_BYTE (ALPHA_V0_REGNUM),
+ TYPE_LENGTH (valtype));
}
/* Given a return value in `regbuf' with a type `valtype',
write its value into the appropriate register. */
-void
+static void
alpha_store_return_value (struct type *valtype, char *valbuf)
{
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
- int regnum = V0_REGNUM;
+ char raw_buffer[ALPHA_MAX_REGISTER_RAW_SIZE];
+ int regnum = ALPHA_V0_REGNUM;
int length = TYPE_LENGTH (valtype);
if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
@@ -1517,7 +1610,7 @@ alpha_call_dummy_address (void)
return SYMBOL_VALUE_ADDRESS (sym) + 4;
}
-void
+static void
alpha_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
struct value **args, struct type *type, int gcc_p)
{
@@ -1525,8 +1618,8 @@ alpha_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
if (bp_address == 0)
error ("no place to put call");
- write_register (RA_REGNUM, bp_address);
- write_register (T12_REGNUM, fun);
+ write_register (ALPHA_RA_REGNUM, bp_address);
+ write_register (ALPHA_T12_REGNUM, fun);
}
/* On the Alpha, the call dummy code is nevery copied to user space
@@ -1534,25 +1627,25 @@ alpha_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
matter. */
LONGEST alpha_call_dummy_words[] = { 0 };
-int
+static int
alpha_use_struct_convention (int gcc_p, struct type *type)
{
/* Structures are returned by ref in extra arg0. */
return 1;
}
-void
+static void
alpha_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
/* Store the address of the place in which to copy the structure the
subroutine will return. Handled by alpha_push_arguments. */
}
-CORE_ADDR
+static CORE_ADDR
alpha_extract_struct_value_address (char *regbuf)
{
- return (extract_address (regbuf + REGISTER_BYTE (V0_REGNUM),
- REGISTER_RAW_SIZE (V0_REGNUM)));
+ return (extract_address (regbuf + REGISTER_BYTE (ALPHA_V0_REGNUM),
+ REGISTER_RAW_SIZE (ALPHA_V0_REGNUM)));
}
/* alpha_software_single_step() is called just before we want to resume
@@ -1664,11 +1757,331 @@ alpha_software_single_step (enum target_signal sig, int insert_breakpoints_p)
}
}
+
+/* This table matches the indices assigned to enum alpha_abi. Keep
+ them in sync. */
+static const char * const alpha_abi_names[] =
+{
+ "<unknown>",
+ "OSF/1",
+ "GNU/Linux",
+ "FreeBSD",
+ "NetBSD",
+ NULL
+};
+
+static void
+process_note_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
+{
+ enum alpha_abi *os_ident_ptr = obj;
+ const char *name;
+ unsigned int sectsize;
+
+ name = bfd_get_section_name (abfd, sect);
+ sectsize = bfd_section_size (abfd, sect);
+
+ if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
+ {
+ unsigned int name_length, data_length, note_type;
+ char *note;
+
+ /* If the section is larger than this, it's probably not what we are
+ looking for. */
+ if (sectsize > 128)
+ sectsize = 128;
+
+ note = alloca (sectsize);
+
+ bfd_get_section_contents (abfd, sect, note,
+ (file_ptr) 0, (bfd_size_type) sectsize);
+
+ name_length = bfd_h_get_32 (abfd, note);
+ data_length = bfd_h_get_32 (abfd, note + 4);
+ note_type = bfd_h_get_32 (abfd, note + 8);
+
+ if (name_length == 4 && data_length == 16 && note_type == 1
+ && strcmp (note + 12, "GNU") == 0)
+ {
+ int os_number = bfd_h_get_32 (abfd, note + 16);
+
+ /* The case numbers are from abi-tags in glibc. */
+ switch (os_number)
+ {
+ case 0 :
+ *os_ident_ptr = ALPHA_ABI_LINUX;
+ break;
+
+ case 1 :
+ internal_error
+ (__FILE__, __LINE__,
+ "process_note_abi_sections: Hurd objects not supported");
+ break;
+
+ case 2 :
+ internal_error
+ (__FILE__, __LINE__,
+ "process_note_abi_sections: Solaris objects not supported");
+ break;
+
+ default :
+ internal_error
+ (__FILE__, __LINE__,
+ "process_note_abi_sections: unknown OS number %d",
+ os_number);
+ break;
+ }
+ }
+ }
+ /* NetBSD uses a similar trick. */
+ else if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
+ {
+ unsigned int name_length, desc_length, note_type;
+ char *note;
+
+ /* If the section is larger than this, it's probably not what we are
+ looking for. */
+ if (sectsize > 128)
+ sectsize = 128;
+
+ note = alloca (sectsize);
+
+ bfd_get_section_contents (abfd, sect, note,
+ (file_ptr) 0, (bfd_size_type) sectsize);
+
+ name_length = bfd_h_get_32 (abfd, note);
+ desc_length = bfd_h_get_32 (abfd, note + 4);
+ note_type = bfd_h_get_32 (abfd, note + 8);
+
+ if (name_length == 7 && desc_length == 4 && note_type == 1
+ && strcmp (note + 12, "NetBSD") == 0)
+ /* XXX Should we check the version here?
+ Probably not necessary yet. */
+ *os_ident_ptr = ALPHA_ABI_NETBSD;
+ }
+}
+
+static int
+get_elfosabi (bfd *abfd)
+{
+ int elfosabi;
+ enum alpha_abi alpha_abi = ALPHA_ABI_UNKNOWN;
+
+ elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
+
+ /* When elfosabi is 0 (ELFOSABI_NONE), this is supposed to indicate
+ what we're on a SYSV system. However, GNU/Linux uses a note section
+ to record OS/ABI info, but leaves e_ident[EI_OSABI] zero. So we
+ have to check the note sections too. */
+ if (elfosabi == 0)
+ {
+ bfd_map_over_sections (abfd,
+ process_note_abi_tag_sections,
+ &alpha_abi);
+ }
+
+ if (alpha_abi != ALPHA_ABI_UNKNOWN)
+ return alpha_abi;
+
+ switch (elfosabi)
+ {
+ case ELFOSABI_NONE:
+ /* Leave it as unknown. */
+ break;
+
+ case ELFOSABI_NETBSD:
+ return ALPHA_ABI_NETBSD;
+
+ case ELFOSABI_FREEBSD:
+ return ALPHA_ABI_FREEBSD;
+
+ case ELFOSABI_LINUX:
+ return ALPHA_ABI_LINUX;
+ }
+
+ return ALPHA_ABI_UNKNOWN;
+}
+
+/* Initialize the current architecture based on INFO. If possible, re-use an
+ architecture from ARCHES, which is a list of architectures already created
+ during this debugging session.
+
+ Called e.g. at program startup, when reading a core file, and when reading
+ a binary file. */
+
+static struct gdbarch *
+alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+{
+ struct gdbarch_tdep *tdep;
+ struct gdbarch *gdbarch;
+ enum alpha_abi alpha_abi = ALPHA_ABI_UNKNOWN;
+
+ /* Try to determine the ABI of the object we are loading. */
+
+ if (info.abfd != NULL)
+ {
+ switch (bfd_get_flavour (info.abfd))
+ {
+ case bfd_target_elf_flavour:
+ alpha_abi = get_elfosabi (info.abfd);
+ break;
+
+ case bfd_target_ecoff_flavour:
+ /* Assume it's OSF/1. */
+ alpha_abi = ALPHA_ABI_OSF1;
+ break;
+
+ default:
+ /* Not sure what to do here, leave the ABI as unknown. */
+ break;
+ }
+ }
+
+ /* Find a candidate among extant architectures. */
+ for (arches = gdbarch_list_lookup_by_info (arches, &info);
+ arches != NULL;
+ arches = gdbarch_list_lookup_by_info (arches->next, &info))
+ {
+ /* Make sure the ABI selection matches. */
+ tdep = gdbarch_tdep (arches->gdbarch);
+ if (tdep && tdep->alpha_abi == alpha_abi)
+ return arches->gdbarch;
+ }
+
+ tdep = xmalloc (sizeof (struct gdbarch_tdep));
+ gdbarch = gdbarch_alloc (&info, tdep);
+
+ tdep->alpha_abi = alpha_abi;
+ if (alpha_abi < ALPHA_ABI_INVALID)
+ tdep->abi_name = alpha_abi_names[alpha_abi];
+ else
+ {
+ internal_error (__FILE__, __LINE__, "Invalid setting of alpha_abi %d",
+ (int) alpha_abi);
+ tdep->abi_name = "<invalid>";
+ }
+
+ /* Type sizes */
+ set_gdbarch_short_bit (gdbarch, 16);
+ set_gdbarch_int_bit (gdbarch, 32);
+ set_gdbarch_long_bit (gdbarch, 64);
+ set_gdbarch_long_long_bit (gdbarch, 64);
+ set_gdbarch_float_bit (gdbarch, 32);
+ set_gdbarch_double_bit (gdbarch, 64);
+ set_gdbarch_long_double_bit (gdbarch, 64);
+ set_gdbarch_ptr_bit (gdbarch, 64);
+
+ /* Register info */
+ set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
+ set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
+ set_gdbarch_fp_regnum (gdbarch, ALPHA_FP_REGNUM);
+ set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
+ set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
+
+ set_gdbarch_register_name (gdbarch, alpha_register_name);
+ set_gdbarch_register_size (gdbarch, ALPHA_REGISTER_SIZE);
+ set_gdbarch_register_bytes (gdbarch, ALPHA_REGISTER_BYTES);
+ set_gdbarch_register_byte (gdbarch, alpha_register_byte);
+ set_gdbarch_register_raw_size (gdbarch, alpha_register_raw_size);
+ set_gdbarch_max_register_raw_size (gdbarch, ALPHA_MAX_REGISTER_RAW_SIZE);
+ set_gdbarch_register_virtual_size (gdbarch, alpha_register_virtual_size);
+ set_gdbarch_max_register_virtual_size (gdbarch,
+ ALPHA_MAX_REGISTER_VIRTUAL_SIZE);
+ set_gdbarch_register_virtual_type (gdbarch, alpha_register_virtual_type);
+
+ set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
+ set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
+
+ set_gdbarch_register_convertible (gdbarch, alpha_register_convertible);
+ set_gdbarch_register_convert_to_virtual (gdbarch,
+ alpha_register_convert_to_virtual);
+ set_gdbarch_register_convert_to_raw (gdbarch, alpha_register_convert_to_raw);
+
+ set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
+
+ set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
+ set_gdbarch_frameless_function_invocation (gdbarch,
+ generic_frameless_function_invocation_not);
+
+ set_gdbarch_saved_pc_after_call (gdbarch, alpha_saved_pc_after_call);
+
+ set_gdbarch_frame_chain (gdbarch, alpha_frame_chain);
+ set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
+ set_gdbarch_frame_saved_pc (gdbarch, alpha_frame_saved_pc);
+
+ set_gdbarch_frame_init_saved_regs (gdbarch, alpha_frame_init_saved_regs);
+ set_gdbarch_get_saved_register (gdbarch, alpha_get_saved_register);
+
+ set_gdbarch_use_struct_convention (gdbarch, alpha_use_struct_convention);
+ set_gdbarch_extract_return_value (gdbarch, alpha_extract_return_value);
+
+ set_gdbarch_store_struct_return (gdbarch, alpha_store_struct_return);
+ set_gdbarch_store_return_value (gdbarch, alpha_store_return_value);
+ set_gdbarch_extract_struct_value_address (gdbarch,
+ alpha_extract_struct_value_address);
+
+ /* Settings for calling functions in the inferior. */
+ set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_call_dummy_length (gdbarch, 0);
+ set_gdbarch_push_arguments (gdbarch, alpha_push_arguments);
+ set_gdbarch_pop_frame (gdbarch, alpha_pop_frame);
+
+ /* On the Alpha, the call dummy code is never copied to user space,
+ stopping the user call is achieved via a bp_call_dummy breakpoint.
+ But we need a fake CALL_DUMMY definition to enable the proper
+ call_function_by_hand and to avoid zero length array warnings. */
+ set_gdbarch_call_dummy_p (gdbarch, 1);
+ set_gdbarch_call_dummy_words (gdbarch, alpha_call_dummy_words);
+ set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+ set_gdbarch_frame_args_address (gdbarch, alpha_frame_args_address);
+ set_gdbarch_frame_locals_address (gdbarch, alpha_frame_locals_address);
+ set_gdbarch_init_extra_frame_info (gdbarch, alpha_init_extra_frame_info);
+
+ /* Alpha OSF/1 inhibits execution of code on the stack. But there is
+ no need for a dummy on the Alpha. PUSH_ARGUMENTS takes care of all
+ argument handling and bp_call_dummy takes care of stopping the dummy. */
+ set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
+ set_gdbarch_call_dummy_address (gdbarch, alpha_call_dummy_address);
+ set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
+ set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
+ set_gdbarch_call_dummy_start_offset (gdbarch, 0);
+ set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
+ set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
+ set_gdbarch_push_dummy_frame (gdbarch, alpha_push_dummy_frame);
+ set_gdbarch_fix_call_dummy (gdbarch, alpha_fix_call_dummy);
+ set_gdbarch_init_frame_pc (gdbarch, init_frame_pc_noop);
+ set_gdbarch_init_frame_pc_first (gdbarch, alpha_init_frame_pc_first);
+
+ set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+
+ set_gdbarch_decr_pc_after_break (gdbarch, 4);
+ set_gdbarch_frame_args_skip (gdbarch, 0);
+
+ return gdbarch;
+}
+
+static void
+alpha_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+ if (tdep == NULL)
+ return;
+
+ if (tdep->abi_name != NULL)
+ fprintf_unfiltered (file, "alpha_dump_tdep: ABI = %s\n", tdep->abi_name);
+ else
+ internal_error (__FILE__, __LINE__,
+ "alpha_dump_tdep: illegal setting of tdep->alpha_abi (%d)",
+ (int) tdep->alpha_abi);
+}
+
void
_initialize_alpha_tdep (void)
{
struct cmd_list_element *c;
+ gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, alpha_dump_tdep);
+
tm_print_insn = print_insn_alpha;
/* Let the user set the fence post for heuristic_proc_start. */
diff --git a/gdb/alpha-tdep.h b/gdb/alpha-tdep.h
new file mode 100644
index 0000000..fe2716e
--- /dev/null
+++ b/gdb/alpha-tdep.h
@@ -0,0 +1,99 @@
+/* Common target dependent code for GDB on Alpha systems.
+ Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002 Free
+ Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#ifndef ALPHA_TDEP_H
+#define ALPHA_TDEP_H
+
+/* Say how long (ordinary) registers are. This is a piece of bogosity
+ used in push_word and a few other places; REGISTER_RAW_SIZE is the
+ real way to know how big a register is. */
+#define ALPHA_REGISTER_SIZE 8
+
+/* Number of machine registers. */
+#define ALPHA_NUM_REGS 66
+
+/* Total amount of space needed to store our copies of the machine's
+ register state. */
+#define ALPHA_REGISTER_BYTES (ALPHA_NUM_REGS * 8)
+
+/* Largest value REGISTER_RAW_SIZE can have. */
+#define ALPHA_MAX_REGISTER_RAW_SIZE 8
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have. */
+#define ALPHA_MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Register numbers of various important registers.
+ Note that most of these values are "real" register numbers,
+ and correspond to the general registers of the machine,
+ and FP_REGNUM is a "phony" register number which is too large
+ to be an actual register number as far as the user is concerned
+ but serves to get the desired value when passed to read_register. */
+
+#define ALPHA_V0_REGNUM 0 /* Function integer return value */
+#define ALPHA_T7_REGNUM 8 /* Return address register for OSF/1 __add* */
+#define ALPHA_GCC_FP_REGNUM 15 /* Used by gcc as frame register */
+#define ALPHA_A0_REGNUM 16 /* Loc of first arg during a subr call */
+#define ALPHA_T9_REGNUM 23 /* Return address register for OSF/1 __div* */
+#define ALPHA_T12_REGNUM 27 /* Contains start addr of current proc */
+#define ALPHA_SP_REGNUM 30 /* Contains address of top of stack */
+#define ALPHA_RA_REGNUM 26 /* Contains return address value */
+#define ALPHA_ZERO_REGNUM 31 /* Read-only register, always 0 */
+#define ALPHA_FP0_REGNUM 32 /* Floating point register 0 */
+#define ALPHA_FPA0_REGNUM 48 /* First float arg during a subr call */
+#define ALPHA_FPCR_REGNUM 63 /* Floating point control register */
+#define ALPHA_PC_REGNUM 64 /* Contains program counter */
+#define ALPHA_FP_REGNUM 65 /* Virtual frame pointer */
+
+/* The alpha has two different virtual pointers for arguments and locals.
+
+ The virtual argument pointer is pointing to the bottom of the argument
+ transfer area, which is located immediately below the virtual frame
+ pointer. Its size is fixed for the native compiler, it is either zero
+ (for the no arguments case) or large enough to hold all argument registers.
+ gcc uses a variable sized argument transfer area. As it has
+ to stay compatible with the native debugging tools it has to use the same
+ virtual argument pointer and adjust the argument offsets accordingly.
+
+ The virtual local pointer is localoff bytes below the virtual frame
+ pointer, the value of localoff is obtained from the PDR. */
+#define ALPHA_NUM_ARG_REGS 6
+
+/* ABI variants that we know about. If you add to this enum, please
+ update the table of names in alpha-tdep.c. */
+enum alpha_abi
+{
+ ALPHA_ABI_UNKNOWN = 0,
+ ALPHA_ABI_OSF1,
+ ALPHA_ABI_LINUX,
+ ALPHA_ABI_FREEBSD,
+ ALPHA_ABI_NETBSD,
+
+ ALPHA_ABI_INVALID /* Keep this last. */
+};
+
+/* Target-dependent structure in gdbarch. */
+struct gdbarch_tdep
+{
+ enum alpha_abi alpha_abi; /* OS/ABI of inferior. */
+ const char *abi_name; /* Name of the above. */
+};
+
+#endif /* ALPHA_TDEP_H */
diff --git a/gdb/alphabsd-nat.c b/gdb/alphabsd-nat.c
index d7ad3a7..92b0fc2 100644
--- a/gdb/alphabsd-nat.c
+++ b/gdb/alphabsd-nat.c
@@ -22,6 +22,8 @@
#include "inferior.h"
#include "regcache.h"
+#include "alpha-tdep.h"
+
#include <sys/types.h>
#include <sys/ptrace.h>
#include <machine/reg.h>
@@ -103,7 +105,7 @@ supply_fpregset (fpregset_t *fpregsetp)
supply_register (i, (char *) &fpregsetp->fpr_regs[i - FP0_REGNUM]);
}
- supply_register (FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
+ supply_register (ALPHA_FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
}
/* Fill register REGNO (if it is a floating-point register) in
@@ -119,8 +121,8 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
if ((regno == -1 || regno == i) && ! CANNOT_STORE_REGISTER (i))
regcache_collect (i, (char *) &fpregsetp->fpr_regs[i - FP0_REGNUM]);
- if (regno == -1 || regno == FPCR_REGNUM)
- regcache_collect (FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
+ if (regno == -1 || regno == ALPHA_FPCR_REGNUM)
+ regcache_collect (ALPHA_FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
}
@@ -130,7 +132,7 @@ static int
getregs_supplies (int regno)
{
- return ((regno >= V0_REGNUM && regno <= ZERO_REGNUM)
+ return ((regno >= ALPHA_V0_REGNUM && regno <= ALPHA_ZERO_REGNUM)
|| regno >= PC_REGNUM);
}
diff --git a/gdb/config/alpha/tm-alpha.h b/gdb/config/alpha/tm-alpha.h
index 316fb15..286f672 100644
--- a/gdb/config/alpha/tm-alpha.h
+++ b/gdb/config/alpha/tm-alpha.h
@@ -24,6 +24,8 @@
#ifndef TM_ALPHA_H
#define TM_ALPHA_H
+#define GDB_MULTI_ARCH GDB_MULTI_ARCH_PARTIAL
+
#include "regcache.h"
#include "bfd.h"
#include "coff/sym.h" /* Needed for PDR below. */
@@ -34,12 +36,6 @@ struct type;
struct value;
struct symbol;
-/* Redefine some target bit sizes from the default. */
-
-#define TARGET_LONG_BIT 64
-#define TARGET_LONG_LONG_BIT 64
-#define TARGET_PTR_BIT 64
-
/* Number of traps that happen between exec'ing the shell
* to run an inferior, and when we finally get to
* the inferior code. This is 2 on most implementations.
@@ -51,326 +47,21 @@ struct symbol;
#define FUNCTION_START_OFFSET 0
-/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
-
-#define SKIP_PROLOGUE(pc) alpha_skip_prologue((pc))
-extern CORE_ADDR alpha_skip_prologue (CORE_ADDR addr);
-
-/* Immediately after a function call, return the saved pc.
- Can't always go through the frames for this because on some machines
- the new frame is not set up until the new function executes
- some instructions. */
-
-#define SAVED_PC_AFTER_CALL(frame) alpha_saved_pc_after_call(frame)
-extern CORE_ADDR alpha_saved_pc_after_call (struct frame_info *);
-
/* Are we currently handling a signal ? */
#define IN_SIGTRAMP(pc, name) alpha_osf_in_sigtramp ((pc), (name))
extern int alpha_osf_in_sigtramp (CORE_ADDR, char *);
-/* Stack grows downward. */
-
-#define INNER_THAN(lhs,rhs) core_addr_lessthan ((lhs), (rhs))
-
#define BREAKPOINT {0x80, 0, 0, 0} /* call_pal bpt */
-/* Amount PC must be decremented by after a breakpoint.
- This is often the number of bytes in BREAKPOINT
- but not always. */
-
-#ifndef DECR_PC_AFTER_BREAK
-#define DECR_PC_AFTER_BREAK 4
-#endif
-
-/* Say how long (ordinary) registers are. This is a piece of bogosity
- used in push_word and a few other places; REGISTER_RAW_SIZE is the
- real way to know how big a register is. */
-
-#define REGISTER_SIZE 8
-
-/* Number of machine registers */
-
-#define NUM_REGS 66
-
-
-/* Return the name of register REGNO. */
-
-#define REGISTER_NAME(regno) alpha_register_name ((regno))
-extern char *alpha_register_name (int);
-
-
-/* Register numbers of various important registers.
- Note that most of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and FP_REGNUM is a "phony" register number which is too large
- to be an actual register number as far as the user is concerned
- but serves to get the desired value when passed to read_register. */
-
-#define V0_REGNUM 0 /* Function integer return value */
-#define T7_REGNUM 8 /* Return address register for OSF/1 __add* */
-#define GCC_FP_REGNUM 15 /* Used by gcc as frame register */
-#define A0_REGNUM 16 /* Loc of first arg during a subr call */
-#define T9_REGNUM 23 /* Return address register for OSF/1 __div* */
-#define T12_REGNUM 27 /* Contains start addr of current proc */
-#define SP_REGNUM 30 /* Contains address of top of stack */
-#define RA_REGNUM 26 /* Contains return address value */
-#define ZERO_REGNUM 31 /* Read-only register, always 0 */
-#define FP0_REGNUM 32 /* Floating point register 0 */
-#define FPA0_REGNUM 48 /* First float arg during a subr call */
-#define FPCR_REGNUM 63 /* Floating point control register */
-#define PC_REGNUM 64 /* Contains program counter */
-#define FP_REGNUM 65 /* Virtual frame pointer */
-
-#define CANNOT_FETCH_REGISTER(regno) \
- alpha_cannot_fetch_register ((regno))
-extern int alpha_cannot_fetch_register (int);
-
-#define CANNOT_STORE_REGISTER(regno) \
- alpha_cannot_store_register ((regno))
-extern int alpha_cannot_store_register (int);
-
-/* Total amount of space needed to store our copies of the machine's
- register state, the array `registers'. */
-#define REGISTER_BYTES (NUM_REGS * 8)
-
-/* Index within `registers' of the first byte of the space for
- register N. */
-
-#define REGISTER_BYTE(N) alpha_register_byte ((N))
-extern int alpha_register_byte (int);
-
-/* Number of bytes of storage in the actual machine representation
- for register N. On Alphas, all regs are 8 bytes. */
-
-#define REGISTER_RAW_SIZE(N) alpha_register_raw_size ((N))
-extern int alpha_register_raw_size (int);
-
-/* Number of bytes of storage in the program's representation
- for register N. On Alphas, all regs are 8 bytes. */
-
-#define REGISTER_VIRTUAL_SIZE(N) alpha_register_virtual_size ((N))
-extern int alpha_register_virtual_size (int);
-
-/* Largest value REGISTER_RAW_SIZE can have. */
-
-#define MAX_REGISTER_RAW_SIZE 8
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have. */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
- from raw format to virtual format.
- The alpha needs a conversion between register and memory format if
- the register is a floating point register and
- memory format is float, as the register format must be double
- or
- memory format is an integer with 4 bytes or less, as the representation
- of integers in floating point registers is different. */
-
-#define REGISTER_CONVERTIBLE(N) alpha_register_convertible ((N))
-extern int alpha_register_convertible (int);
-
-/* Convert data from raw format for register REGNUM in buffer FROM
- to virtual format with type TYPE in buffer TO. */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM, TYPE, FROM, TO) \
- alpha_register_convert_to_virtual (REGNUM, TYPE, FROM, TO)
-extern void
-alpha_register_convert_to_virtual (int, struct type *, char *, char *);
-
-/* Convert data from virtual format with type TYPE in buffer FROM
- to raw format for register REGNUM in buffer TO. */
-
-#define REGISTER_CONVERT_TO_RAW(TYPE, REGNUM, FROM, TO) \
- alpha_register_convert_to_raw (TYPE, REGNUM, FROM, TO)
-extern void
-alpha_register_convert_to_raw (struct type *, int, char *, char *);
-
-/* Return the GDB type object for the "standard" data type
- of data in register N. */
-
-#define REGISTER_VIRTUAL_TYPE(N) alpha_register_virtual_type ((N))
-extern struct type * alpha_register_virtual_type (int);
-
-/* Store the address of the place in which to copy the structure the
- subroutine will return. Handled by alpha_push_arguments. */
-
-#define STORE_STRUCT_RETURN(addr, sp) \
- alpha_store_struct_return ((addr), (sp))
-extern void alpha_store_struct_return (CORE_ADDR, CORE_ADDR);
-/**/
-
-/* Extract from an array REGBUF containing the (raw) register state
- a function return value of type TYPE, and copy that, in virtual format,
- into VALBUF. */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- alpha_extract_return_value(TYPE, REGBUF, VALBUF)
-extern void alpha_extract_return_value (struct type *, char *, char *);
-
-/* Write into appropriate registers a function return value
- of type TYPE, given in virtual format. */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
- alpha_store_return_value(TYPE, VALBUF)
-extern void alpha_store_return_value (struct type *, char *);
-
-/* Extract from an array REGBUF containing the (raw) register state
- the address in which a function should return its structure value,
- as a CORE_ADDR (or an expression that can be used as one). */
-/* The address is passed in a0 upon entry to the function, but when
- the function exits, the compiler has copied the value to v0. This
- convention is specified by the System V ABI, so I think we can rely
- on it. */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
- alpha_extract_struct_value_address (REGBUF)
-extern CORE_ADDR alpha_extract_struct_value_address (char *);
-
-/* Structures are returned by ref in extra arg0 */
-#define USE_STRUCT_CONVENTION(gcc_p, type) \
- alpha_use_struct_convention ((gcc_p), (type))
-extern int alpha_use_struct_convention (int, struct type *);
-
-
-/* Describe the pointer in each stack frame to the previous stack frame
- (its caller). */
-
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer. */
-
-#define FRAME_CHAIN(thisframe) alpha_frame_chain (thisframe)
-extern CORE_ADDR alpha_frame_chain (struct frame_info *);
-
-/* Define other aspects of the stack frame. */
-
-
-/* An expression that tells us whether the function invocation represented
- by FI does not have a frame on the stack associated with it. */
-/* We handle this differently for alpha, and maybe we should not */
-
-#define FRAMELESS_FUNCTION_INVOCATION(FI) \
- generic_frameless_function_invocation_not ((FI))
-
-/* Saved Pc. */
-
-#define FRAME_SAVED_PC(FRAME) alpha_frame_saved_pc(FRAME)
-extern CORE_ADDR alpha_frame_saved_pc (struct frame_info *);
-
-/* The alpha has two different virtual pointers for arguments and locals.
-
- The virtual argument pointer is pointing to the bottom of the argument
- transfer area, which is located immediately below the virtual frame
- pointer. Its size is fixed for the native compiler, it is either zero
- (for the no arguments case) or large enough to hold all argument registers.
- gcc uses a variable sized argument transfer area. As it has
- to stay compatible with the native debugging tools it has to use the same
- virtual argument pointer and adjust the argument offsets accordingly.
-
- The virtual local pointer is localoff bytes below the virtual frame
- pointer, the value of localoff is obtained from the PDR. */
-
-#define ALPHA_NUM_ARG_REGS 6
-
-#define FRAME_ARGS_ADDRESS(fi) alpha_frame_args_address ((fi))
-extern CORE_ADDR alpha_frame_args_address (struct frame_info *);
-
-#define FRAME_LOCALS_ADDRESS(fi) alpha_frame_locals_address ((fi))
-extern CORE_ADDR alpha_frame_locals_address (struct frame_info *);
-
-/* Return number of args passed to a frame.
- Can return -1, meaning no way to tell. */
-
-#define FRAME_NUM_ARGS(fi) frame_num_args_unknown ((fi))
-
-/* Return number of bytes at start of arglist that are not really args. */
-
-#define FRAME_ARGS_SKIP 0
-
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
-
-#define FRAME_INIT_SAVED_REGS(frame_info) \
- alpha_frame_init_saved_regs (frame_info)
-extern void alpha_frame_init_saved_regs (struct frame_info *);
-
-
-/* Things needed for making the inferior call functions. */
-
-#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
- (alpha_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
-extern CORE_ADDR
-alpha_push_arguments (int, struct value **, CORE_ADDR, int, CORE_ADDR);
-
-/* Push an empty stack frame, to record the current PC, etc. */
-
-#define PUSH_DUMMY_FRAME alpha_push_dummy_frame()
-extern void alpha_push_dummy_frame (void);
-
-/* Discard from the stack the innermost frame, restoring all registers. */
-
-#define POP_FRAME alpha_pop_frame()
-extern void alpha_pop_frame (void);
-
-/* Alpha OSF/1 inhibits execution of code on the stack.
- But there is no need for a dummy on the alpha. PUSH_ARGUMENTS
- takes care of all argument handling and bp_call_dummy takes care
- of stopping the dummy. */
-
-#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
-
-/* On the Alpha the call dummy code is never copied to user space,
- stopping the user call is achieved via a bp_call_dummy breakpoint.
- But we need a fake CALL_DUMMY definition to enable the proper
- call_function_by_hand and to avoid zero length array warnings
- in valops.c */
-
-#define CALL_DUMMY_P (1)
-
-#define CALL_DUMMY_WORDS alpha_call_dummy_words
-extern LONGEST alpha_call_dummy_words[];
-
-#define SIZEOF_CALL_DUMMY_WORDS 0
-
-#define CALL_DUMMY_START_OFFSET (0)
-
-#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
-
-#define CALL_DUMMY_ADDRESS() alpha_call_dummy_address()
-extern CORE_ADDR alpha_call_dummy_address (void);
-
-/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME.
- We only have to set RA_REGNUM to the dummy breakpoint address
- and T12_REGNUM (the `procedure value register') to the function address. */
-
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
- alpha_fix_call_dummy ((dummyname), (pc), (fun), (nargs), (args), \
- (type), (gcc_p))
-extern void alpha_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
- struct value **, struct type *, int);
-
-/* There's a mess in stack frame creation. See comments in blockframe.c
- near reference to INIT_FRAME_PC_FIRST. */
-
-#define INIT_FRAME_PC(fromleaf, prev) init_frame_pc_noop ((fromleaf), (prev))
-
-#define INIT_FRAME_PC_FIRST(fromleaf, prev) \
- alpha_init_frame_pc_first ((fromleaf), (prev))
-extern void alpha_init_frame_pc_first (int, struct frame_info *);
-
/* Special symbol found in blocks associated with routines. We can hang
alpha_extra_func_info_t's off of this. */
#define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
extern void ecoff_relocate_efi (struct symbol *, CORE_ADDR);
+#define RA_REGNUM 26 /* XXXJRT needed by mdebugread.c */
+
/* Specific information about a procedure.
This overlays the ALPHA's PDR records,
alpharead.c (ab)uses this to save memory */
@@ -390,10 +81,6 @@ typedef struct alpha_extra_func_info
#define mips_extra_func_info_t alpha_extra_func_info_t
-#define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \
- alpha_init_extra_frame_info(fromleaf, fci)
-extern void alpha_init_extra_frame_info (int, struct frame_info *);
-
#define PRINT_EXTRA_FRAME_INFO(fi) alpha_print_extra_frame_info ((fi))
extern void alpha_print_extra_frame_info (struct frame_info *);