From dc129d82386b3ae4a511f9f60a76ac481d33d304 Mon Sep 17 00:00:00 2001 From: Jason Thorpe Date: Sun, 21 Apr 2002 16:52:39 +0000 Subject: [PATCH] * 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. --- gdb/ChangeLog | 22 ++ gdb/Makefile.in | 4 +- gdb/alpha-nat.c | 14 +- gdb/alpha-tdep.c | 515 ++++++++++++++++++++++++++++++++---- gdb/alpha-tdep.h | 99 +++++++ gdb/alphabsd-nat.c | 10 +- gdb/config/alpha/tm-alpha.h | 321 +--------------------- 7 files changed, 606 insertions(+), 379 deletions(-) create mode 100644 gdb/alpha-tdep.h diff --git a/gdb/ChangeLog b/gdb/ChangeLog index ec6276c3fb..1909f7572f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,25 @@ +2002-04-21 Jason Thorpe + + * 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 * frame.c (find_saved_register): Delete #ifdef diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 7c56bcca8e..266ce14482 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 f7e565b300..fbf8155d68 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 #ifdef __linux__ #include @@ -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 (®isters[REGISTER_BYTE (V0_REGNUM)], core_reg_sect, 31 * 8); + memcpy (®isters[REGISTER_BYTE (ALPHA_V0_REGNUM)], core_reg_sect, + 31 * 8); memcpy (®isters[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8); - memset (®isters[REGISTER_BYTE (ZERO_REGNUM)], 0, 8); - memset (®ister_valid[V0_REGNUM], 1, 32); + memset (®isters[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8); + memset (®ister_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 1a81ec8c31..7d99cf5f44 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[] = +{ + "", + "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 = ""; + } + + /* 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 0000000000..fe2716e002 --- /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 d7ad3a73f3..92b0fc2237 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 #include #include @@ -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 316fb15658..286f672dc0 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 *); -- 2.34.1