diff options
Diffstat (limited to 'gdb/m68k-tdep.c')
| -rw-r--r-- | gdb/m68k-tdep.c | 1061 |
1 files changed, 611 insertions, 450 deletions
diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c index c8158c4..2a675e0 100644 --- a/gdb/m68k-tdep.c +++ b/gdb/m68k-tdep.c @@ -22,10 +22,13 @@ #include "defs.h" #include "frame.h" +#include "frame-base.h" +#include "frame-unwind.h" #include "symtab.h" #include "gdbcore.h" #include "value.h" #include "gdb_string.h" +#include "gdb_assert.h" #include "inferior.h" #include "regcache.h" #include "arch-utils.h" @@ -37,37 +40,24 @@ #define P_LINKL_FP 0x480e #define P_LINKW_FP 0x4e56 #define P_PEA_FP 0x4856 -#define P_MOVL_SP_FP 0x2c4f -#define P_MOVL 0x207c -#define P_JSR 0x4eb9 -#define P_BSR 0x61ff -#define P_LEAL 0x43fb -#define P_MOVML 0x48ef -#define P_FMOVM 0xf237 -#define P_TRAP 0x4e40 +#define P_MOVEAL_SP_FP 0x2c4f +#define P_ADDAW_SP 0xdefc +#define P_ADDAL_SP 0xdffc +#define P_SUBQW_SP 0x514f +#define P_SUBQL_SP 0x518f +#define P_LEA_SP_SP 0x4fef +#define P_LEA_PC_A5 0x4bfb0170 +#define P_FMOVEMX_SP 0xf227 +#define P_MOVEL_SP 0x2f00 +#define P_MOVEML_SP 0x48e7 #define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4) #define REGISTER_BYTES_NOFP (16*4 + 8) -#define NUM_FREGS (NUM_REGS-24) - /* Offset from SP to first arg on stack at first instruction of a function */ - #define SP_ARG0 (1 * 4) -/* This was determined by experimentation on hp300 BSD 4.3. Perhaps - it corresponds to some offset in /usr/include/sys/user.h or - something like that. Using some system include file would - have the advantage of probably being more robust in the face - of OS upgrades, but the disadvantage of being wrong for - cross-debugging. */ - -#define SIG_PC_FP_OFFSET 530 - -#define TARGET_M68K - - #if !defined (BPT_VECTOR) #define BPT_VECTOR 0xf #endif @@ -77,9 +67,6 @@ #endif -static void m68k_frame_init_saved_regs (struct frame_info *frame_info); - - /* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc so m68k_remote_breakpoint_from_pc is currently not used. */ @@ -107,26 +94,6 @@ m68k_register_bytes_ok (long numbytes) || (numbytes == REGISTER_BYTES_NOFP)); } -/* Number of bytes of storage in the actual machine representation - for register regnum. On the 68000, all regs are 4 bytes - except the floating point regs which are 12 bytes. */ - -static int -m68k_register_raw_size (int regnum) -{ - return (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 8 ? 12 : 4); -} - -/* Number of bytes of storage in the program's representation - for register regnum. On the 68000, all regs are 4 bytes - except the floating point regs which are 12-byte long doubles. */ - -static int -m68k_register_virtual_size (int regnum) -{ - return (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 8 ? 12 : 4); -} - /* Return the GDB type object for the "standard" data type of data in register N. This should be int for D0-D7, SR, FPCONTROL and FPSTATUS, long double for FP0-FP7, and void pointer for all others @@ -136,7 +103,7 @@ m68k_register_virtual_size (int regnum) address. */ static struct type * -m68k_register_virtual_type (int regnum) +m68k_register_type (struct gdbarch *gdbarch, int regnum) { if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7) return builtin_type_m68881_ext; @@ -189,71 +156,83 @@ m68k_register_byte (int regnum) else return (regnum * 4); } - -/* Store the address of the place in which to copy the structure the - subroutine will return. This is called from call_function. */ - -static void -m68k_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) -{ - write_register (M68K_A1_REGNUM, 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. This is assuming that floating point values are returned - as doubles in d0/d1. */ + +/* Extract from an array REGBUF containing the (raw) register state, a + function return value of TYPE, and copy that, in virtual format, + into VALBUF. */ static void -m68k_deprecated_extract_return_value (struct type *type, char *regbuf, - char *valbuf) +m68k_extract_return_value (struct type *type, struct regcache *regcache, + void *valbuf) { - int offset = 0; - int typeLength = TYPE_LENGTH (type); + int len = TYPE_LENGTH (type); + char buf[M68K_MAX_REGISTER_SIZE]; - if (typeLength < 4) - offset = 4 - typeLength; - - memcpy (valbuf, regbuf + offset, typeLength); -} + if (TYPE_CODE (type) == TYPE_CODE_STRUCT + && TYPE_NFIELDS (type) == 1) + { + m68k_extract_return_value (TYPE_FIELD_TYPE (type, 0), regcache, valbuf); + return; + } -static CORE_ADDR -m68k_deprecated_extract_struct_value_address (char *regbuf) -{ - return (*(CORE_ADDR *) (regbuf)); + if (len <= 4) + { + regcache_raw_read (regcache, M68K_D0_REGNUM, buf); + memcpy (valbuf, buf + (4 - len), len); + } + else if (len <= 8) + { + regcache_raw_read (regcache, M68K_D0_REGNUM, buf); + memcpy (valbuf, buf + (8 - len), len - 4); + regcache_raw_read (regcache, M68K_D1_REGNUM, + (char *) valbuf + (len - 4)); + } + else + internal_error (__FILE__, __LINE__, + "Cannot extract return value of %d bytes long.", len); } -/* Write into appropriate registers a function return value - of type TYPE, given in virtual format. Assumes floats are passed - in d0/d1. */ +/* Write into the appropriate registers a function return value stored + in VALBUF of type TYPE, given in virtual format. */ static void -m68k_store_return_value (struct type *type, char *valbuf) +m68k_store_return_value (struct type *type, struct regcache *regcache, + const void *valbuf) { - deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (type)); -} + int len = TYPE_LENGTH (type); -/* Describe the pointer in each stack frame to the previous stack frame - (its caller). */ + if (TYPE_CODE (type) == TYPE_CODE_STRUCT + && TYPE_NFIELDS (type) == 1) + { + m68k_store_return_value (TYPE_FIELD_TYPE (type, 0), regcache, valbuf); + return; + } -/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces - the frame's chain-pointer. In the case of the 68000, the frame's - nominal address is the address of a 4-byte word containing the - calling frame's address. */ + if (len <= 4) + regcache_raw_write_part (regcache, M68K_D0_REGNUM, 4 - len, len, valbuf); + else if (len <= 8) + { + regcache_raw_write_part (regcache, M68K_D1_REGNUM, 8 - len, + len - 4, valbuf); + regcache_raw_write (regcache, M68K_D0_REGNUM, + (char *) valbuf + (len - 4)); + } + else + internal_error (__FILE__, __LINE__, + "Cannot store return value of %d bytes long.", len); +} -/* If we are chaining from sigtramp, then manufacture a sigtramp frame - (which isn't really on the stack. I'm not sure this is right for anything - but BSD4.3 on an hp300. */ +/* Extract from REGCACHE, which contains the (raw) register state, the + address in which a function should return its structure value, as a + CORE_ADDR. */ static CORE_ADDR -m68k_frame_chain (struct frame_info *thisframe) +m68k_extract_struct_value_address (struct regcache *regcache) { - if (get_frame_type (thisframe) == SIGTRAMP_FRAME) - return get_frame_base (thisframe); - else if (!inside_entry_file (get_frame_pc (thisframe))) - return read_memory_unsigned_integer (get_frame_base (thisframe), 4); - else - return 0; + char buf[4]; + + regcache_cooked_read (regcache, M68K_D0_REGNUM, buf); + return extract_unsigned_integer (buf, 4); } /* A function that tells us whether the function invocation represented @@ -269,23 +248,6 @@ m68k_frameless_function_invocation (struct frame_info *fi) return frameless_look_for_prologue (fi); } -static CORE_ADDR -m68k_frame_saved_pc (struct frame_info *frame) -{ - if (get_frame_type (frame) == SIGTRAMP_FRAME) - { - if (get_next_frame (frame)) - return read_memory_unsigned_integer (get_frame_base (get_next_frame (frame)) - + SIG_PC_FP_OFFSET, 4); - else - return read_memory_unsigned_integer (read_register (SP_REGNUM) - + SIG_PC_FP_OFFSET - 8, 4); - } - else - return read_memory_unsigned_integer (get_frame_base (frame) + 4, 4); -} - - int delta68_in_sigtramp (CORE_ADDR pc, char *name) { @@ -343,339 +305,578 @@ delta68_frame_num_args (struct frame_info *fi) return val; } -/* Insert the specified number of args and function address - into a call sequence of the above form stored at DUMMYNAME. - We use the BFD routines to store a big-endian value of known size. */ - -static void -m68k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, - struct value **args, struct type *type, int gcc_p) +static CORE_ADDR +m68k_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, + struct regcache *regcache, CORE_ADDR bp_addr, int nargs, + struct value **args, CORE_ADDR sp, int struct_return, + CORE_ADDR struct_addr) { - bfd_putb32 (fun, (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 2); - bfd_putb32 (nargs * 4, - (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 8); + char buf[4]; + int i; + + /* Push arguments in reverse order. */ + for (i = nargs - 1; i >= 0; i--) + { + int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); + int container_len = (len + 3) & ~3; + int offset = container_len - len; + + sp -= container_len; + write_memory (sp + offset, VALUE_CONTENTS_ALL (args[i]), len); + } + + /* Push value address. */ + if (struct_return) + { + sp -= 4; + store_unsigned_integer (buf, 4, struct_addr); + write_memory (sp, buf, 4); + } + + /* Store return address. */ + sp -= 4; + store_unsigned_integer (buf, 4, bp_addr); + write_memory (sp, buf, 4); + + /* Finally, update the stack pointer... */ + store_unsigned_integer (buf, 4, sp); + regcache_cooked_write (regcache, M68K_SP_REGNUM, buf); + + /* ...and fake a frame pointer. */ + regcache_cooked_write (regcache, M68K_FP_REGNUM, buf); + + /* DWARF2/GCC uses the stack address *before* the function call as a + frame's CFA. */ + return sp + 8; } + +struct m68k_frame_cache +{ + /* Base address. */ + CORE_ADDR base; + CORE_ADDR sp_offset; + CORE_ADDR pc; + /* Saved registers. */ + CORE_ADDR saved_regs[M68K_NUM_REGS]; + CORE_ADDR saved_sp; -/* Push an empty stack frame, to record the current PC, etc. */ + /* Stack space reserved for local variables. */ + long locals; +}; -static void -m68k_push_dummy_frame (void) +/* Allocate and initialize a frame cache. */ + +static struct m68k_frame_cache * +m68k_alloc_frame_cache (void) { - register CORE_ADDR sp = read_register (SP_REGNUM); - register int regnum; - char raw_buffer[12]; + struct m68k_frame_cache *cache; + int i; - sp = push_word (sp, read_register (PC_REGNUM)); - sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM)); - write_register (DEPRECATED_FP_REGNUM, sp); + cache = FRAME_OBSTACK_ZALLOC (struct m68k_frame_cache); - /* Always save the floating-point registers, whether they exist on - this target or not. */ - for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) - { - deprecated_read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); - sp = push_bytes (sp, raw_buffer, 12); - } + /* Base address. */ + cache->base = 0; + cache->sp_offset = -4; + cache->pc = 0; - for (regnum = DEPRECATED_FP_REGNUM - 1; regnum >= 0; regnum--) - { - sp = push_word (sp, read_register (regnum)); - } - sp = push_word (sp, read_register (PS_REGNUM)); - write_register (SP_REGNUM, sp); + /* Saved registers. We initialize these to -1 since zero is a valid + offset (that's where %fp is supposed to be stored). */ + for (i = 0; i < M68K_NUM_REGS; i++) + cache->saved_regs[i] = -1; + + /* Frameless until proven otherwise. */ + cache->locals = -1; + + return cache; } -/* Discard from the stack the innermost frame, - restoring all saved registers. */ +/* Check whether PC points at a code that sets up a new stack frame. + If so, it updates CACHE and returns the address of the first + instruction after the sequence that sets removes the "hidden" + argument from the stack or CURRENT_PC, whichever is smaller. + Otherwise, return PC. */ -static void -m68k_pop_frame (void) +static CORE_ADDR +m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, + struct m68k_frame_cache *cache) { - register struct frame_info *frame = get_current_frame (); - register CORE_ADDR fp; - register int regnum; - char raw_buffer[12]; + int op; + + if (pc >= current_pc) + return current_pc; - fp = get_frame_base (frame); - m68k_frame_init_saved_regs (frame); - for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) + op = read_memory_unsigned_integer (pc, 2); + + if (op == P_LINKW_FP || op == P_LINKL_FP || op == P_PEA_FP) { - if (get_frame_saved_regs (frame)[regnum]) + cache->saved_regs[M68K_FP_REGNUM] = 0; + cache->sp_offset += 4; + if (op == P_LINKW_FP) + { + /* link.w %fp, #-N */ + /* link.w %fp, #0; adda.l #-N, %sp */ + cache->locals = -read_memory_integer (pc + 2, 2); + + if (pc + 4 < current_pc && cache->locals == 0) + { + op = read_memory_unsigned_integer (pc + 4, 2); + if (op == P_ADDAL_SP) + { + cache->locals = read_memory_integer (pc + 6, 4); + return pc + 10; + } + } + + return pc + 4; + } + else if (op == P_LINKL_FP) { - read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, 12); - deprecated_write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, - 12); + /* link.l %fp, #-N */ + cache->locals = -read_memory_integer (pc + 2, 4); + return pc + 6; + } + else + { + /* pea (%fp); movea.l %sp, %fp */ + cache->locals = 0; + + if (pc + 2 < current_pc) + { + op = read_memory_unsigned_integer (pc + 2, 2); + + if (op == P_MOVEAL_SP_FP) + { + /* move.l %sp, %fp */ + return pc + 4; + } + } + + return pc + 2; } } - for (regnum = DEPRECATED_FP_REGNUM - 1; regnum >= 0; regnum--) + else if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP) { - if (get_frame_saved_regs (frame)[regnum]) + /* subq.[wl] #N,%sp */ + /* subq.[wl] #8,%sp; subq.[wl] #N,%sp */ + cache->locals = (op & 07000) == 0 ? 8 : (op & 07000) >> 9; + if (pc + 2 < current_pc) { - write_register (regnum, - read_memory_integer (get_frame_saved_regs (frame)[regnum], 4)); + op = read_memory_unsigned_integer (pc + 2, 2); + if ((op & 0170777) == P_SUBQW_SP || (op & 0170777) == P_SUBQL_SP) + { + cache->locals += (op & 07000) == 0 ? 8 : (op & 07000) >> 9; + return pc + 4; + } } + return pc + 2; + } + else if (op == P_ADDAW_SP || op == P_LEA_SP_SP) + { + /* adda.w #-N,%sp */ + /* lea (-N,%sp),%sp */ + cache->locals = -read_memory_integer (pc + 2, 2); + return pc + 4; } - if (get_frame_saved_regs (frame)[PS_REGNUM]) + else if (op == P_ADDAL_SP) { - write_register (PS_REGNUM, - read_memory_integer (get_frame_saved_regs (frame)[PS_REGNUM], 4)); + /* adda.l #-N,%sp */ + cache->locals = -read_memory_integer (pc + 2, 4); + return pc + 6; } - write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4)); - write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); - write_register (SP_REGNUM, fp + 8); - flush_cached_frames (); + + return pc; } - -/* Given an ip value corresponding to the start of a function, - return the ip of the first instruction after the function - prologue. This is the generic m68k support. Machines which - require something different can override the SKIP_PROLOGUE - macro to point elsewhere. +/* Check whether PC points at code that saves registers on the stack. + If so, it updates CACHE and returns the address of the first + instruction after the register saves or CURRENT_PC, whichever is + smaller. Otherwise, return PC. */ - Some instructions which typically may appear in a function - prologue include: +static CORE_ADDR +m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc, + struct m68k_frame_cache *cache) +{ + if (cache->locals >= 0) + { + CORE_ADDR offset; + int op; + int i, mask, regno; - A link instruction, word form: + offset = -4 - cache->locals; + while (pc < current_pc) + { + op = read_memory_unsigned_integer (pc, 2); + if (op == P_FMOVEMX_SP) + { + /* fmovem.x REGS,-(%sp) */ + op = read_memory_unsigned_integer (pc + 2, 2); + if ((op & 0xff00) == 0xe000) + { + mask = op & 0xff; + for (i = 0; i < 16; i++, mask >>= 1) + { + if (mask & 1) + { + cache->saved_regs[i + M68K_FP0_REGNUM] = offset; + offset -= 12; + } + } + pc += 4; + } + else + break; + } + else if ((op & 0170677) == P_MOVEL_SP) + { + /* move.l %R,-(%sp) */ + regno = ((op & 07000) >> 9) | ((op & 0100) >> 3); + cache->saved_regs[regno] = offset; + offset -= 4; + pc += 2; + } + else if (op == P_MOVEML_SP) + { + /* movem.l REGS,-(%sp) */ + mask = read_memory_unsigned_integer (pc + 2, 2); + for (i = 0; i < 16; i++, mask >>= 1) + { + if (mask & 1) + { + cache->saved_regs[15 - i] = offset; + offset -= 4; + } + } + pc += 4; + } + else + break; + } + } + + return pc; +} - link.w %a6,&0 4e56 XXXX - A link instruction, long form: +/* Do a full analysis of the prologue at PC and update CACHE + accordingly. Bail out early if CURRENT_PC is reached. Return the + address where the analysis stopped. - link.l %fp,&F%1 480e XXXX XXXX + We handle all cases that can be generated by gcc. - A movm instruction to preserve integer regs: + For allocating a stack frame: - movm.l &M%1,(4,%sp) 48ef XXXX XXXX + link.w %a6,#-N + link.l %a6,#-N + pea (%fp); move.l %sp,%fp + link.w %a6,#0; add.l #-N,%sp + subq.l #N,%sp + subq.w #N,%sp + subq.w #8,%sp; subq.w #N-8,%sp + add.w #-N,%sp + lea (-N,%sp),%sp + add.l #-N,%sp - A fmovm instruction to preserve float regs: + For saving registers: - fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX + fmovem.x REGS,-(%sp) + move.l R1,-(%sp) + move.l R1,-(%sp); move.l R2,-(%sp) + movem.l REGS,-(%sp) - Some profiling setup code (FIXME, not recognized yet): + For setting up the PIC register: - lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX - bsr _mcount 61ff XXXX XXXX + lea (%pc,N),%a5 - */ + */ static CORE_ADDR -m68k_skip_prologue (CORE_ADDR ip) +m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, + struct m68k_frame_cache *cache) { - register CORE_ADDR limit; - struct symtab_and_line sal; - register int op; + unsigned int op; - /* Find out if there is a known limit for the extent of the prologue. - If so, ensure we don't go past it. If not, assume "infinity". */ + pc = m68k_analyze_frame_setup (pc, current_pc, cache); + pc = m68k_analyze_register_saves (pc, current_pc, cache); + if (pc >= current_pc) + return current_pc; - sal = find_pc_line (ip, 0); - limit = (sal.end) ? sal.end : (CORE_ADDR) ~0; - - while (ip < limit) + /* Check for GOT setup. */ + op = read_memory_unsigned_integer (pc, 4); + if (op == P_LEA_PC_A5) { - op = read_memory_unsigned_integer (ip, 2); - - if (op == P_LINKW_FP) - ip += 4; /* Skip link.w */ - else if (op == P_PEA_FP) - ip += 2; /* Skip pea %fp */ - else if (op == P_MOVL_SP_FP) - ip += 2; /* Skip move.l %sp, %fp */ - else if (op == P_LINKL_FP) - ip += 6; /* Skip link.l */ - else if (op == P_MOVML) - ip += 6; /* Skip movm.l */ - else if (op == P_FMOVM) - ip += 10; /* Skip fmovm */ - else - break; /* Found unknown code, bail out. */ + /* lea (%pc,N),%a5 */ + return pc + 6; } - return (ip); + + return pc; } -/* Store the addresses of the saved registers of the frame described by - FRAME_INFO in its saved_regs field. - 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. */ +/* Return PC of first real instruction. */ -static void -m68k_frame_init_saved_regs (struct frame_info *frame_info) +static CORE_ADDR +m68k_skip_prologue (CORE_ADDR start_pc) { - register int regnum; - register int regmask; - register CORE_ADDR next_addr; - register CORE_ADDR pc; + struct m68k_frame_cache cache; + CORE_ADDR pc; + int op; - /* First possible address for a pc in a call dummy for this frame. */ - CORE_ADDR possible_call_dummy_start = - get_frame_base (frame_info) - 28 - DEPRECATED_FP_REGNUM * 4 - 4 - 8 * 12; + cache.locals = -1; + pc = m68k_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache); + if (cache.locals < 0) + return start_pc; + return pc; +} - int nextinsn; +static CORE_ADDR +m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + char buf[8]; - if (get_frame_saved_regs (frame_info)) - return; + frame_unwind_register (next_frame, PC_REGNUM, buf); + return extract_typed_address (buf, builtin_type_void_func_ptr); +} + +/* Normal frames. */ - frame_saved_regs_zalloc (frame_info); +static struct m68k_frame_cache * +m68k_frame_cache (struct frame_info *next_frame, void **this_cache) +{ + struct m68k_frame_cache *cache; + char buf[4]; + int i; + + if (*this_cache) + return *this_cache; + + cache = m68k_alloc_frame_cache (); + *this_cache = cache; + + /* In principle, for normal frames, %fp holds the frame pointer, + which holds the base address for the current stack frame. + However, for functions that don't need it, the frame pointer is + optional. For these "frameless" functions the frame pointer is + actually the frame pointer of the calling frame. Signal + trampolines are just a special case of a "frameless" function. + They (usually) share their frame pointer with the frame that was + in progress when the signal occurred. */ + + frame_unwind_register (next_frame, M68K_FP_REGNUM, buf); + cache->base = extract_unsigned_integer (buf, 4); + if (cache->base == 0) + return cache; + + /* For normal frames, %pc is stored at 4(%fp). */ + cache->saved_regs[M68K_PC_REGNUM] = 4; + + cache->pc = frame_func_unwind (next_frame); + if (cache->pc != 0) + m68k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); + + if (cache->locals < 0) + { + /* We didn't find a valid frame, which means that CACHE->base + currently holds the frame pointer for our calling frame. If + we're at the start of a function, or somewhere half-way its + prologue, the function's frame probably hasn't been fully + setup yet. Try to reconstruct the base address for the stack + frame by looking at the stack pointer. For truly "frameless" + functions this might work too. */ + + frame_unwind_register (next_frame, M68K_SP_REGNUM, buf); + cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset; + } - memset (get_frame_saved_regs (frame_info), 0, SIZEOF_FRAME_SAVED_REGS); + /* Now that we have the base address for the stack frame we can + calculate the value of %sp in the calling frame. */ + cache->saved_sp = cache->base + 8; - if (get_frame_pc (frame_info) >= possible_call_dummy_start - && get_frame_pc (frame_info) <= get_frame_base (frame_info)) - { + /* Adjust all the saved registers such that they contain addresses + instead of offsets. */ + for (i = 0; i < M68K_NUM_REGS; i++) + if (cache->saved_regs[i] != -1) + cache->saved_regs[i] += cache->base; - /* It is a call dummy. We could just stop now, since we know - what the call dummy saves and where. But this code proceeds - to parse the "prologue" which is part of the call dummy. - This is needlessly complex and confusing. FIXME. */ + return cache; +} - next_addr = get_frame_base (frame_info); - pc = possible_call_dummy_start; - } - else - { - pc = get_frame_func (frame_info); +static void +m68k_frame_this_id (struct frame_info *next_frame, void **this_cache, + struct frame_id *this_id) +{ + struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache); - nextinsn = read_memory_unsigned_integer (pc, 2); - if (P_PEA_FP == nextinsn - && P_MOVL_SP_FP == read_memory_unsigned_integer (pc + 2, 2)) - { - /* pea %fp - move.l %sp, %fp */ - next_addr = get_frame_base (frame_info); - pc += 4; - } - else if (P_LINKL_FP == nextinsn) - /* link.l %fp */ - /* Find the address above the saved - regs using the amount of storage from the link instruction. */ - { - next_addr = get_frame_base (frame_info) + read_memory_integer (pc + 2, 4); - pc += 6; - } - else if (P_LINKW_FP == nextinsn) - /* link.w %fp */ - /* Find the address above the saved - regs using the amount of storage from the link instruction. */ - { - next_addr = get_frame_base (frame_info) + read_memory_integer (pc + 2, 2); - pc += 4; - } - else - goto lose; + /* This marks the outermost frame. */ + if (cache->base == 0) + return; - /* If have an addal #-n, sp next, adjust next_addr. */ - if (read_memory_unsigned_integer (pc, 2) == 0157774) - next_addr += read_memory_integer (pc += 2, 4), pc += 4; - } + /* See the end of m68k_push_dummy_call. */ + *this_id = frame_id_build (cache->base + 8, cache->pc); +} - for (;;) +static void +m68k_frame_prev_register (struct frame_info *next_frame, void **this_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, void *valuep) +{ + struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache); + + gdb_assert (regnum >= 0); + + if (regnum == M68K_SP_REGNUM && cache->saved_sp) { - nextinsn = read_memory_unsigned_integer (pc, 2); - regmask = read_memory_unsigned_integer (pc + 2, 2); - /* fmovemx to -(sp) */ - if (0xf227 == nextinsn && (regmask & 0xff00) == 0xe000) + *optimizedp = 0; + *lvalp = not_lval; + *addrp = 0; + *realnump = -1; + if (valuep) { - /* Regmask's low bit is for register fp7, the first pushed */ - for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1) - if (regmask & 1) - get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 12); - pc += 4; + /* Store the value. */ + store_unsigned_integer (valuep, 4, cache->saved_sp); } - /* fmovemx to (fp + displacement) */ - else if (0171056 == nextinsn && (regmask & 0xff00) == 0xf000) - { - register CORE_ADDR addr; - - addr = get_frame_base (frame_info) + read_memory_integer (pc + 4, 2); - /* Regmask's low bit is for register fp7, the first pushed */ - for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1) - if (regmask & 1) - { - get_frame_saved_regs (frame_info)[regnum] = addr; - addr += 12; - } - pc += 6; - } - /* moveml to (sp) */ - else if (0044327 == nextinsn) - { - /* Regmask's low bit is for register 0, the first written */ - for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) - if (regmask & 1) - { - get_frame_saved_regs (frame_info)[regnum] = next_addr; - next_addr += 4; - } - pc += 4; - } - /* moveml to (fp + displacement) */ - else if (0044356 == nextinsn) - { - register CORE_ADDR addr; - - addr = get_frame_base (frame_info) + read_memory_integer (pc + 4, 2); - /* Regmask's low bit is for register 0, the first written */ - for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) - if (regmask & 1) - { - get_frame_saved_regs (frame_info)[regnum] = addr; - addr += 4; - } - pc += 6; - } - /* moveml to -(sp) */ - else if (0044347 == nextinsn) - { - /* Regmask's low bit is for register 15, the first pushed */ - for (regnum = 16; --regnum >= 0; regmask >>= 1) - if (regmask & 1) - get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4); - pc += 4; - } - /* movl r,-(sp) */ - else if (0x2f00 == (0xfff0 & nextinsn)) - { - regnum = 0xf & nextinsn; - get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4); - pc += 2; - } - /* fmovemx to index of sp */ - else if (0xf236 == nextinsn && (regmask & 0xff00) == 0xf000) - { - /* Regmask's low bit is for register fp0, the first written */ - for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1) - if (regmask & 1) - { - get_frame_saved_regs (frame_info)[regnum] = next_addr; - next_addr += 12; - } - pc += 10; - } - /* clrw -(sp); movw ccr,-(sp) */ - else if (0x4267 == nextinsn && 0x42e7 == regmask) + return; + } + + if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1) + { + *optimizedp = 0; + *lvalp = lval_memory; + *addrp = cache->saved_regs[regnum]; + *realnump = -1; + if (valuep) { - get_frame_saved_regs (frame_info)[PS_REGNUM] = (next_addr -= 4); - pc += 4; + /* Read the value in from memory. */ + read_memory (*addrp, valuep, + register_size (current_gdbarch, regnum)); } - else - break; + return; } -lose:; - get_frame_saved_regs (frame_info)[SP_REGNUM] = get_frame_base (frame_info) + 8; - get_frame_saved_regs (frame_info)[DEPRECATED_FP_REGNUM] = get_frame_base (frame_info); - get_frame_saved_regs (frame_info)[PC_REGNUM] = get_frame_base (frame_info) + 4; -#ifdef SIG_SP_FP_OFFSET - /* Adjust saved SP_REGNUM for fake _sigtramp frames. */ - if ((get_frame_type (frame_info) == SIGTRAMP_FRAME) && frame_info->next) - frame_info->saved_regs[SP_REGNUM] = - frame_info->next->frame + SIG_SP_FP_OFFSET; -#endif + + frame_register_unwind (next_frame, regnum, + optimizedp, lvalp, addrp, realnump, valuep); +} + +static const struct frame_unwind m68k_frame_unwind = +{ + NORMAL_FRAME, + m68k_frame_this_id, + m68k_frame_prev_register +}; + +static const struct frame_unwind * +m68k_frame_p (CORE_ADDR pc) +{ + return &m68k_frame_unwind; +} + +/* Signal trampolines. */ + +static struct m68k_frame_cache * +m68k_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache) +{ + struct m68k_frame_cache *cache; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct m68k_sigtramp_info info; + char buf[4]; + int i; + + if (*this_cache) + return *this_cache; + + cache = m68k_alloc_frame_cache (); + + frame_unwind_register (next_frame, M68K_SP_REGNUM, buf); + cache->base = extract_unsigned_integer (buf, 4) - 4; + + info = tdep->get_sigtramp_info (next_frame); + + for (i = 0; i < M68K_NUM_REGS; i++) + if (info.sc_reg_offset[i] != -1) + cache->saved_regs[i] = info.sigcontext_addr + info.sc_reg_offset[i]; + + *this_cache = cache; + return cache; +} + +static void +m68k_sigtramp_frame_this_id (struct frame_info *next_frame, void **this_cache, + struct frame_id *this_id) +{ + struct m68k_frame_cache *cache = + m68k_sigtramp_frame_cache (next_frame, this_cache); + + /* See the end of m68k_push_dummy_call. */ + *this_id = frame_id_build (cache->base + 8, frame_pc_unwind (next_frame)); +} + +static void +m68k_sigtramp_frame_prev_register (struct frame_info *next_frame, + void **this_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, void *valuep) +{ + /* Make sure we've initialized the cache. */ + m68k_sigtramp_frame_cache (next_frame, this_cache); + + m68k_frame_prev_register (next_frame, this_cache, regnum, + optimizedp, lvalp, addrp, realnump, valuep); +} + +static const struct frame_unwind m68k_sigtramp_frame_unwind = +{ + SIGTRAMP_FRAME, + m68k_sigtramp_frame_this_id, + m68k_sigtramp_frame_prev_register +}; + +static const struct frame_unwind * +m68k_sigtramp_frame_p (CORE_ADDR pc) +{ + char *name; + + /* We shouldn't even bother to try if the OSABI didn't register + a get_sigtramp_info handler. */ + if (!gdbarch_tdep (current_gdbarch)->get_sigtramp_info) + return NULL; + + find_pc_partial_function (pc, &name, NULL, NULL); + if (PC_IN_SIGTRAMP (pc, name)) + return &m68k_sigtramp_frame_unwind; + + return NULL; } + +static CORE_ADDR +m68k_frame_base_address (struct frame_info *next_frame, void **this_cache) +{ + struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache); + + return cache->base; +} + +static const struct frame_base m68k_frame_base = +{ + &m68k_frame_unwind, + m68k_frame_base_address, + m68k_frame_base_address, + m68k_frame_base_address +}; + +static struct frame_id +m68k_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + char buf[4]; + CORE_ADDR fp; + frame_unwind_register (next_frame, M68K_FP_REGNUM, buf); + fp = extract_unsigned_integer (buf, 4); + /* See the end of m68k_push_dummy_call. */ + return frame_id_build (fp + 8, frame_pc_unwind (next_frame)); +} + #ifdef USE_PROC_FS /* Target dependent support for /proc */ #include <sys/procfs.h> @@ -745,19 +946,13 @@ fill_gregset (gregset_t *gregsetp, int regno) for (regi = 0; regi < R_PC; regi++) { - if ((regno == -1) || (regno == regi)) - { - *(regp + regi) = *(int *) &deprecated_registers[REGISTER_BYTE (regi)]; - } - } - if ((regno == -1) || (regno == PS_REGNUM)) - { - *(regp + R_PS) = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)]; - } - if ((regno == -1) || (regno == PC_REGNUM)) - { - *(regp + R_PC) = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)]; + if (regno == -1 || regno == regi) + regcache_collect (regi, regp + regi); } + if (regno == -1 || regno == PS_REGNUM) + regcache_collect (PS_REGNUM, regp + R_PS); + if (regno == -1 || regno == PC_REGNUM) + regcache_collect (PC_REGNUM, regp + R_PC); } #if defined (FP0_REGNUM) @@ -791,30 +986,18 @@ void fill_fpregset (fpregset_t *fpregsetp, int regno) { int regi; - char *to; - char *from; for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++) { - if ((regno == -1) || (regno == regi)) - { - from = (char *) &deprecated_registers[REGISTER_BYTE (regi)]; - to = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]); - memcpy (to, from, REGISTER_RAW_SIZE (regi)); - } - } - if ((regno == -1) || (regno == M68K_FPC_REGNUM)) - { - fpregsetp->f_pcr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPC_REGNUM)]; - } - if ((regno == -1) || (regno == M68K_FPS_REGNUM)) - { - fpregsetp->f_psr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPS_REGNUM)]; - } - if ((regno == -1) || (regno == M68K_FPI_REGNUM)) - { - fpregsetp->f_fpiaddr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPI_REGNUM)]; + if (regno == -1 || regno == regi) + regcache_collect (regi, &fpregsetp->f_fpregs[regi - FP0_REGNUM][0]); } + if (regno == -1 || regno == M68K_FPC_REGNUM) + regcache_collect (M68K_FPC_REGNUM, &fpregsetp->f_pcr); + if (regno == -1 || regno == M68K_FPS_REGNUM) + regcache_collect (M68K_FPS_REGNUM, &fpregsetp->f_psr); + if (regno == -1 || regno == M68K_FPI_REGNUM) + regcache_collect (M68K_FPI_REGNUM, &fpregsetp->f_fpiaddr); } #endif /* defined (FP0_REGNUM) */ @@ -857,6 +1040,7 @@ m68k_get_longjmp_target (CORE_ADDR *pc) return 1; } +#ifdef SYSCALL_TRAP /* Immediately after a function call, return the saved pc before the frame is setup. For sun3's, we check for the common case of being inside of a system call, and if so, we know that Sun pushes the call # on the stack @@ -865,7 +1049,6 @@ m68k_get_longjmp_target (CORE_ADDR *pc) static CORE_ADDR m68k_saved_pc_after_call (struct frame_info *frame) { -#ifdef SYSCALL_TRAP int op; op = read_memory_unsigned_integer (frame->pc - SYSCALL_TRAP_OFFSET, 2); @@ -873,9 +1056,9 @@ m68k_saved_pc_after_call (struct frame_info *frame) if (op == SYSCALL_TRAP) return read_memory_unsigned_integer (read_register (SP_REGNUM) + 4, 4); else -#endif /* SYSCALL_TRAP */ return read_memory_unsigned_integer (read_register (SP_REGNUM), 4); } +#endif /* SYSCALL_TRAP */ /* Function: m68k_gdbarch_init Initializer function for the m68k gdbarch vector. @@ -884,10 +1067,6 @@ m68k_saved_pc_after_call (struct frame_info *frame) static struct gdbarch * m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { - static LONGEST call_dummy_words[7] = { 0xf227e0ff, 0x48e7fffc, 0x426742e7, - 0x4eb93232, 0x3232dffc, 0x69696969, - (0x4e404e71 | (BPT_VECTOR << 16)) - }; struct gdbarch_tdep *tdep = NULL; struct gdbarch *gdbarch; @@ -899,17 +1078,15 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep = xmalloc (sizeof (struct gdbarch_tdep)); gdbarch = gdbarch_alloc (&info, tdep); - /* NOTE: cagney/2002-12-06: This can be deleted when this arch is - ready to unwind the PC first (see frame.c:get_prev_frame()). */ - set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default); - set_gdbarch_long_double_format (gdbarch, &floatformat_m68881_ext); set_gdbarch_long_double_bit (gdbarch, 96); set_gdbarch_function_start_offset (gdbarch, 0); set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue); +#ifdef SYSCALL_TRAP set_gdbarch_deprecated_saved_pc_after_call (gdbarch, m68k_saved_pc_after_call); +#endif set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc); /* Stack grows down. */ @@ -919,50 +1096,25 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_believe_pcc_promotion (gdbarch, 1); set_gdbarch_decr_pc_after_break (gdbarch, 2); - set_gdbarch_deprecated_store_struct_return (gdbarch, m68k_store_struct_return); - set_gdbarch_deprecated_extract_return_value (gdbarch, - m68k_deprecated_extract_return_value); - set_gdbarch_deprecated_store_return_value (gdbarch, m68k_store_return_value); + set_gdbarch_extract_return_value (gdbarch, m68k_extract_return_value); + set_gdbarch_store_return_value (gdbarch, m68k_store_return_value); + set_gdbarch_extract_struct_value_address (gdbarch, + m68k_extract_struct_value_address); - set_gdbarch_deprecated_frame_chain (gdbarch, m68k_frame_chain); - set_gdbarch_deprecated_frame_saved_pc (gdbarch, m68k_frame_saved_pc); - set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, m68k_frame_init_saved_regs); set_gdbarch_frameless_function_invocation (gdbarch, m68k_frameless_function_invocation); set_gdbarch_frame_args_skip (gdbarch, 8); - set_gdbarch_deprecated_register_raw_size (gdbarch, m68k_register_raw_size); - set_gdbarch_deprecated_register_virtual_size (gdbarch, m68k_register_virtual_size); - set_gdbarch_deprecated_max_register_raw_size (gdbarch, 12); - set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 12); - set_gdbarch_deprecated_register_virtual_type (gdbarch, m68k_register_virtual_type); + set_gdbarch_register_type (gdbarch, m68k_register_type); set_gdbarch_register_name (gdbarch, m68k_register_name); - set_gdbarch_deprecated_register_size (gdbarch, 4); - set_gdbarch_deprecated_register_byte (gdbarch, m68k_register_byte); set_gdbarch_num_regs (gdbarch, 29); set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok); - set_gdbarch_deprecated_register_bytes (gdbarch, (16 * 4 + 8 + 8 * 12 + 3 * 4)); set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM); - set_gdbarch_deprecated_fp_regnum (gdbarch, M68K_FP_REGNUM); set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM); set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM); set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM); - set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0); - set_gdbarch_call_dummy_location (gdbarch, ON_STACK); - set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 24); - set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack); - set_gdbarch_deprecated_call_dummy_length (gdbarch, 28); - set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 12); - - set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words); - set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words)); - set_gdbarch_deprecated_fix_call_dummy (gdbarch, m68k_fix_call_dummy); - set_gdbarch_deprecated_push_dummy_frame (gdbarch, m68k_push_dummy_frame); - set_gdbarch_deprecated_pop_frame (gdbarch, m68k_pop_frame); - - /* Should be using push_dummy_call. */ - set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp); + set_gdbarch_push_dummy_call (gdbarch, m68k_push_dummy_call); /* Disassembler. */ set_gdbarch_print_insn (gdbarch, print_insn_m68k); @@ -973,6 +1125,12 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) #else tdep->jb_pc = -1; #endif + tdep->get_sigtramp_info = NULL; + + /* Frame unwinder. */ + set_gdbarch_unwind_dummy_id (gdbarch, m68k_unwind_dummy_id); + set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc); + frame_base_set_default (gdbarch, &m68k_frame_base); /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); @@ -983,6 +1141,9 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) if (tdep->jb_pc >= 0) set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target); + frame_unwind_append_predicate (gdbarch, m68k_sigtramp_frame_p); + frame_unwind_append_predicate (gdbarch, m68k_frame_p); + return gdbarch; } |