diff options
Diffstat (limited to 'gdb/alpha-tdep.c')
| -rw-r--r-- | gdb/alpha-tdep.c | 819 |
1 files changed, 674 insertions, 145 deletions
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c index 4ca6bcc..f354036 100644 --- a/gdb/alpha-tdep.c +++ b/gdb/alpha-tdep.c @@ -33,6 +33,52 @@ #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_breakpoint_from_pc_ftype alpha_breakpoint_from_pc; + +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; + +static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target; struct frame_extra_info { @@ -125,8 +171,6 @@ static unsigned int heuristic_fence_post = 0; */ /* *INDENT-ON* */ - - #define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */ /* These next two fields are kind of being hijacked. I wonder if iline is too small for the values it needs to hold, if GDB is @@ -153,95 +197,53 @@ struct linked_proc_info } *linked_proc_desc_table = NULL; -int -alpha_osf_in_sigtramp (CORE_ADDR pc, char *func_name) +static CORE_ADDR +alpha_frame_past_sigtramp_frame (struct frame_info *frame, CORE_ADDR pc) { - return (func_name != NULL && STREQ ("__sigtramp", func_name)); -} + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); -/* Under GNU/Linux, signal handler invocations can be identified by the - designated code sequence that is used to return from a signal - handler. In particular, the return address of a signal handler - points to the following sequence (the first instruction is quadword - aligned): - - bis $30,$30,$16 - addq $31,0x67,$0 - call_pal callsys - - Each instruction has a unique encoding, so we simply attempt to - match the instruction the pc is pointing to with any of the above - instructions. If there is a hit, we know the offset to the start - of the designated sequence and can then check whether we really are - executing in a designated sequence. If not, -1 is returned, - otherwise the offset from the start of the desingated sequence is - returned. - - There is a slight chance of false hits: code could jump into the - middle of the designated sequence, in which case there is no - guarantee that we are in the middle of a sigreturn syscall. Don't - think this will be a problem in praxis, though. - */ + if (tdep->skip_sigtramp_frame != NULL) + return (tdep->skip_sigtramp_frame (frame, pc)); -#ifndef TM_LINUXALPHA_H -/* HACK: Provide a prototype when compiling this file for non - linuxalpha targets. */ -long alpha_linux_sigtramp_offset (CORE_ADDR pc); -#endif -long -alpha_linux_sigtramp_offset (CORE_ADDR pc) + return (0); +} + +static LONGEST +alpha_dynamic_sigtramp_offset (CORE_ADDR pc) { - unsigned int i[3], w; - long off; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - if (read_memory_nobpt (pc, (char *) &w, 4) != 0) - return -1; + /* Must be provided by OS/ABI variant code if supported. */ + if (tdep->dynamic_sigtramp_offset != NULL) + return (tdep->dynamic_sigtramp_offset (pc)); - off = -1; - switch (w) - { - case 0x47de0410: - off = 0; - break; /* bis $30,$30,$16 */ - case 0x43ecf400: - off = 4; - break; /* addq $31,0x67,$0 */ - case 0x00000083: - off = 8; - break; /* call_pal callsys */ - default: - return -1; - } - pc -= off; - if (pc & 0x7) - { - /* designated sequence is not quadword aligned */ - return -1; - } + return (-1); +} - if (read_memory_nobpt (pc, (char *) i, sizeof (i)) != 0) - return -1; +#define ALPHA_PROC_SIGTRAMP_MAGIC 0x0e0f0f0f - if (i[0] == 0x47de0410 && i[1] == 0x43ecf400 && i[2] == 0x00000083) - return off; +/* Return TRUE if the procedure descriptor PROC is a procedure + descriptor that refers to a dynamically generated signal + trampoline routine. */ +static int +alpha_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info *proc) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + + if (tdep->dynamic_sigtramp_offset != NULL) + return (proc->pdr.isym == ALPHA_PROC_SIGTRAMP_MAGIC); - return -1; + return (0); } - -/* Under OSF/1, the __sigtramp routine is frameless and has a frame - size of zero, but we are able to backtrace through it. */ -CORE_ADDR -alpha_osf_skip_sigtramp_frame (struct frame_info *frame, CORE_ADDR pc) +static void +alpha_set_proc_desc_is_dyn_sigtramp (struct alpha_extra_func_info *proc) { - char *name; - find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL); - if (IN_SIGTRAMP (pc, name)) - return frame->frame; - else - return 0; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + + if (tdep->dynamic_sigtramp_offset != NULL) + proc->pdr.isym = ALPHA_PROC_SIGTRAMP_MAGIC; } - /* Dynamically create a signal-handler caller procedure descriptor for the signal-handler return code starting at address LOW_ADDR. The @@ -270,12 +272,12 @@ push_sigtramp_desc (CORE_ADDR low_addr) PROC_FREG_MASK (proc_desc) = 0xffff; PROC_PC_REG (proc_desc) = 26; PROC_LOCALOFF (proc_desc) = 0; - SET_PROC_DESC_IS_DYN_SIGTRAMP (proc_desc); + alpha_set_proc_desc_is_dyn_sigtramp (proc_desc); return (proc_desc); } -char * +static char * alpha_register_name (int regno) { static char *register_names[] = @@ -298,50 +300,61 @@ 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; } +static CORE_ADDR +alpha_sigcontext_addr (struct frame_info *fi) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + + if (tdep->sigcontext_addr) + return (tdep->sigcontext_addr (fi)); + + return (0); +} + /* Guaranteed to set frame->saved_regs to some values (it never leaves it NULL). */ @@ -370,7 +383,12 @@ alpha_find_saved_regs (struct frame_info *frame) { CORE_ADDR sigcontext_addr; - sigcontext_addr = SIGCONTEXT_ADDR (frame); + sigcontext_addr = alpha_sigcontext_addr (frame); + if (sigcontext_addr == 0) + { + /* Don't know where the sigcontext is; just bail. */ + return; + } for (ireg = 0; ireg < 32; ireg++) { reg_position = sigcontext_addr + SIGFRAME_REGSAVE_OFF + ireg * 8; @@ -433,7 +451,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 +459,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 +486,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 +501,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 +563,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 +573,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. */ @@ -527,6 +593,7 @@ alpha_about_to_return (CORE_ADDR pc) static CORE_ADDR heuristic_proc_start (CORE_ADDR pc) { + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); CORE_ADDR start_pc = pc; CORE_ADDR fence = start_pc - heuristic_fence_post; @@ -534,8 +601,8 @@ heuristic_proc_start (CORE_ADDR pc) return 0; if (heuristic_fence_post == UINT_MAX - || fence < VM_MIN_ADDRESS) - fence = VM_MIN_ADDRESS; + || fence < tdep->vm_min_address) + fence = tdep->vm_min_address; /* search back for previous return */ for (start_pc -= 4;; start_pc -= 4) @@ -549,7 +616,7 @@ heuristic_proc_start (CORE_ADDR pc) { static int blurb_printed = 0; - if (fence == VM_MIN_ADDRESS) + if (fence == tdep->vm_min_address) warning ("Hit beginning of text section without finding"); else warning ("Hit heuristic-fence-post without finding"); @@ -646,7 +713,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 +740,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 +756,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; } @@ -711,7 +780,7 @@ after_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc) if (proc_desc) { - if (PROC_DESC_IS_DYN_SIGTRAMP (proc_desc)) + if (alpha_proc_desc_is_dyn_sigtramp (proc_desc)) return PROC_LOW_ADDR (proc_desc); /* "prologue" is in kernel */ /* If function is frameless, then we need to do it the hard way. I @@ -853,7 +922,7 @@ find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame) /* If PC is inside a dynamically generated sigtramp handler, create and push a procedure descriptor for that code: */ - offset = DYNAMIC_SIGTRAMP_OFFSET (pc); + offset = alpha_dynamic_sigtramp_offset (pc); if (offset >= 0) return push_sigtramp_desc (pc - offset); @@ -874,7 +943,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; @@ -902,7 +971,7 @@ alpha_frame_chain (struct frame_info *frame) /* The previous frame from a sigtramp frame might be frameless and have frame size zero. */ && !frame->signal_handler_caller) - return FRAME_PAST_SIGTRAMP_FRAME (frame, saved_pc); + return alpha_frame_past_sigtramp_frame (frame, saved_pc); else return read_next_frame_reg (frame, PROC_FRAME_REG (proc_desc)) + PROC_FRAME_OFFSET (proc_desc); @@ -920,7 +989,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 +1001,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) { @@ -953,7 +1022,7 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame) Get the value of the frame relative sp, procedure might have been interrupted by a signal at it's very start. */ else if (frame->pc == PROC_LOW_ADDR (proc_desc) - && !PROC_DESC_IS_DYN_SIGTRAMP (proc_desc)) + && !alpha_proc_desc_is_dyn_sigtramp (proc_desc)) frame->frame = read_next_frame_reg (frame->next, SP_REGNUM); else frame->frame = read_next_frame_reg (frame->next, PROC_FRAME_REG (proc_desc)) @@ -968,26 +1037,26 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame) We can't use frame->signal_handler_caller, it is not yet set. */ find_pc_partial_function (frame->pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL); - if (!IN_SIGTRAMP (frame->pc, name)) + if (!PC_IN_SIGTRAMP (frame->pc, name)) { frame->saved_regs = (CORE_ADDR *) frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS); 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)); @@ -1009,7 +1078,7 @@ alpha_frame_args_address (struct frame_info *fi) arguments without difficulty. */ struct frame_info * -setup_arbitrary_frame (int argc, CORE_ADDR *argv) +alpha_setup_arbitrary_frame (int argc, CORE_ADDR *argv) { if (argc != 2) error ("ALPHA frame specifications require two arguments: sp and pc"); @@ -1027,7 +1096,7 @@ 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 +1171,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 +1186,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 +1241,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 +1291,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; @@ -1262,7 +1331,7 @@ alpha_pop_frame (void) flush_cached_frames (); if (proc_desc && (PROC_DESC_IS_DUMMY (proc_desc) - || PROC_DESC_IS_DYN_SIGTRAMP (proc_desc))) + || alpha_proc_desc_is_dyn_sigtramp (proc_desc))) { struct linked_proc_info *pi_ptr, *prev_ptr; @@ -1303,16 +1372,15 @@ alpha_skip_prologue_internal (CORE_ADDR pc, int lenient) CORE_ADDR post_prologue_pc; char buf[4]; -#ifdef GDB_TARGET_HAS_SHARED_LIBS /* Silently return the unaltered pc upon memory errors. This could happen on OSF/1 if decode_line_1 tries to skip the prologue for quickstarted shared library functions when the shared library is not yet mapped in. Reading target memory is slow over serial lines, so we perform - this check only if the target has shared libraries. */ + this check only if the target has shared libraries (which all + Alpha targets do). */ if (target_read_memory (pc, buf, 4)) return pc; -#endif /* See if we can determine the end of the prologue via the symbol table. If so, then return either PC, or the PC after the prologue, whichever @@ -1368,7 +1436,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 +1460,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 +1486,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) { @@ -1447,29 +1515,40 @@ alpha_register_convert_to_raw (struct type *valtype, int regnum, error ("Cannot store value in floating point register"); } +static const unsigned char * +alpha_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) +{ + static const unsigned char alpha_breakpoint[] = + { 0x80, 0, 0, 0 }; /* call_pal bpt */ + + *lenptr = sizeof(alpha_breakpoint); + return (alpha_breakpoint); +} + /* 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) + char regbuf[ALPHA_REGISTER_BYTES], char *valbuf) { if (TYPE_CODE (valtype) == TYPE_CODE_FLT) alpha_register_convert_to_virtual (FP0_REGNUM, 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 +1596,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 +1604,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 +1613,47 @@ 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))); +} + +/* Figure out where the longjmp will land. + We expect the first arg to be a pointer to the jmp_buf structure from + which we extract the PC (JB_PC) that we will land at. The PC is copied + into the "pc". This routine returns true on success. */ + +static int +alpha_get_longjmp_target (CORE_ADDR *pc) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + CORE_ADDR jb_addr; + char raw_buffer[ALPHA_MAX_REGISTER_RAW_SIZE]; + + jb_addr = read_register (ALPHA_A0_REGNUM); + + if (target_read_memory (jb_addr + (tdep->jb_pc * tdep->jb_elt_size), + raw_buffer, tdep->jb_elt_size)) + return 0; + + *pc = extract_address (raw_buffer, tdep->jb_elt_size); + return 1; } /* alpha_software_single_step() is called just before we want to resume @@ -1664,11 +1765,439 @@ 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; +} + +struct alpha_abi_handler +{ + struct alpha_abi_handler *next; + enum alpha_abi abi; + void (*init_abi)(struct gdbarch_info, struct gdbarch *); +}; + +struct alpha_abi_handler *alpha_abi_handler_list = NULL; + +void +alpha_gdbarch_register_os_abi (enum alpha_abi abi, + void (*init_abi)(struct gdbarch_info, + struct gdbarch *)) +{ + struct alpha_abi_handler **handler_p; + + for (handler_p = &alpha_abi_handler_list; *handler_p != NULL; + handler_p = &(*handler_p)->next) + { + if ((*handler_p)->abi == abi) + { + internal_error + (__FILE__, __LINE__, + "alpha_gdbarch_register_os_abi: A handler for this ABI variant " + "(%d) has already been registered", (int) abi); + /* If user wants to continue, override previous definition. */ + (*handler_p)->init_abi = init_abi; + return; + } + } + + (*handler_p) + = (struct alpha_abi_handler *) xmalloc (sizeof (struct alpha_abi_handler)); + (*handler_p)->next = NULL; + (*handler_p)->abi = abi; + (*handler_p)->init_abi = init_abi; +} + +/* 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; + struct alpha_abi_handler *abi_handler; + + /* 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>"; + } + + /* Lowest text address. This is used by heuristic_proc_start() to + decide when to stop looking. */ + tdep->vm_min_address = (CORE_ADDR) 0x120000000; + + tdep->dynamic_sigtramp_offset = NULL; + tdep->skip_sigtramp_frame = NULL; + tdep->sigcontext_addr = NULL; + + tdep->jb_pc = -1; /* longjmp support not enabled by default */ + + /* 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_skip_trampoline_code (gdbarch, find_solib_trampoline_target); + + /* Floats are always passed as doubles. */ + set_gdbarch_coerce_float_to_double (gdbarch, + standard_coerce_float_to_double); + + set_gdbarch_breakpoint_from_pc (gdbarch, alpha_breakpoint_from_pc); + set_gdbarch_decr_pc_after_break (gdbarch, 4); + + set_gdbarch_function_start_offset (gdbarch, 0); + set_gdbarch_frame_args_skip (gdbarch, 0); + + /* Hook in ABI-specific overrides, if they have been registered. */ + if (alpha_abi == ALPHA_ABI_UNKNOWN) + { + /* Don't complain about not knowing the ABI variant if we don't + have an inferior. */ + if (info.abfd) + fprintf_filtered + (gdb_stderr, "GDB doesn't recognize the ABI of the inferior. " + "Attempting to continue with the default Alpha settings"); + } + else + { + for (abi_handler = alpha_abi_handler_list; abi_handler != NULL; + abi_handler = abi_handler->next) + if (abi_handler->abi == alpha_abi) + break; + + if (abi_handler) + abi_handler->init_abi (info, gdbarch); + else + { + /* We assume that if GDB_MULTI_ARCH is less than + GDB_MULTI_ARCH_TM that an ABI variant can be supported by + overriding definitions in this file. */ + if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) + fprintf_filtered + (gdb_stderr, + "A handler for the ABI variant \"%s\" is not built into this " + "configuration of GDB. " + "Attempting to continue with the default Alpha settings", + alpha_abi_names[alpha_abi]); + } + } + + /* Now that we have tuned the configuration, set a few final things + based on what the OS ABI has told us. */ + + if (tdep->jb_pc >= 0) + set_gdbarch_get_longjmp_target (gdbarch, alpha_get_longjmp_target); + + 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); + + fprintf_unfiltered (file, + "alpha_dump_tdep: vm_min_address = 0x%lx\n", + (long) tdep->vm_min_address); + + fprintf_unfiltered (file, + "alpha_dump_tdep: jb_pc = %d\n", + tdep->jb_pc); + fprintf_unfiltered (file, + "alpha_dump_tdep: jb_elt_size = %ld\n", + (long) tdep->jb_elt_size); +} + 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. */ |