X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm68k-tdep.c;h=28e38eb44259d197a994070bc9e3045d12afa72f;hb=904001b085513a5d6b7734275f6fb90c860cf3be;hp=f26e1a6fb4a4f936024a7056b46d2c91982e1b13;hpb=a9762ec78a53fbe9209fe1654db42df0cd328d50;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c index f26e1a6fb4..28e38eb442 100644 --- a/gdb/m68k-tdep.c +++ b/gdb/m68k-tdep.c @@ -1,7 +1,8 @@ /* Target-dependent code for the Motorola 68000 series. Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001, - 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. + 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + Free Software Foundation, Inc. This file is part of GDB. @@ -61,7 +62,8 @@ #endif static const gdb_byte * -m68k_local_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) +m68k_local_breakpoint_from_pc (struct gdbarch *gdbarch, + CORE_ADDR *pcptr, int *lenptr) { static gdb_byte break_insn[] = {0x4e, (0x40 | BPT_VECTOR)}; *lenptr = sizeof (break_insn); @@ -105,12 +107,12 @@ m68k_init_types (void) static struct type * m68k_register_type (struct gdbarch *gdbarch, int regnum) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->fpregs_present) { - if (regnum >= gdbarch_fp0_regnum (current_gdbarch) - && regnum <= gdbarch_fp0_regnum (current_gdbarch) + 7) + if (regnum >= gdbarch_fp0_regnum (gdbarch) + && regnum <= gdbarch_fp0_regnum (gdbarch) + 7) { if (tdep->flavour == m68k_coldfire_flavour) return builtin_type (gdbarch)->builtin_double; @@ -119,7 +121,7 @@ m68k_register_type (struct gdbarch *gdbarch, int regnum) } if (regnum == M68K_FPI_REGNUM) - return builtin_type_void_func_ptr; + return builtin_type (gdbarch)->builtin_func_ptr; if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM) return builtin_type_int32; @@ -130,11 +132,11 @@ m68k_register_type (struct gdbarch *gdbarch, int regnum) return builtin_type_int0; } - if (regnum == gdbarch_pc_regnum (current_gdbarch)) - return builtin_type_void_func_ptr; + if (regnum == gdbarch_pc_regnum (gdbarch)) + return builtin_type (gdbarch)->builtin_func_ptr; if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7) - return builtin_type_void_data_ptr; + return builtin_type (gdbarch)->builtin_data_ptr; if (regnum == M68K_PS_REGNUM) return m68k_ps_type; @@ -154,7 +156,7 @@ static const char *m68k_register_names[] = { Returns the name of the standard m68k register regnum. */ static const char * -m68k_register_name (int regnum) +m68k_register_name (struct gdbarch *gdbarch, int regnum) { if (regnum < 0 || regnum >= ARRAY_SIZE (m68k_register_names)) internal_error (__FILE__, __LINE__, @@ -167,11 +169,12 @@ m68k_register_name (int regnum) needs any special handling. */ static int -m68k_convert_register_p (int regnum, struct type *type) +m68k_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type) { - if (!gdbarch_tdep (current_gdbarch)->fpregs_present) + if (!gdbarch_tdep (gdbarch)->fpregs_present) return 0; - return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7); + return (regnum >= M68K_FP0_REGNUM && regnum <= M68K_FP0_REGNUM + 7 + && type != builtin_type_m68881_ext); } /* Read a value of type TYPE from register REGNUM in frame FRAME, and @@ -182,7 +185,8 @@ m68k_register_to_value (struct frame_info *frame, int regnum, struct type *type, gdb_byte *to) { gdb_byte from[M68K_MAX_REGISTER_SIZE]; - struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM); + struct type *fpreg_type = register_type (get_frame_arch (frame), + M68K_FP0_REGNUM); /* We only support floating-point values. */ if (TYPE_CODE (type) != TYPE_CODE_FLT) @@ -192,8 +196,7 @@ m68k_register_to_value (struct frame_info *frame, int regnum, return; } - /* Convert to TYPE. This should be a no-op if TYPE is equivalent to - the extended floating-point format used by the FPU. */ + /* Convert to TYPE. */ get_frame_register (frame, regnum, from); convert_typed_floating (from, fpreg_type, to, type); } @@ -206,7 +209,8 @@ m68k_value_to_register (struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from) { gdb_byte to[M68K_MAX_REGISTER_SIZE]; - struct type *fpreg_type = register_type (current_gdbarch, M68K_FP0_REGNUM); + struct type *fpreg_type = register_type (get_frame_arch (frame), + M68K_FP0_REGNUM); /* We only support floating-point values. */ if (TYPE_CODE (type) != TYPE_CODE_FLT) @@ -216,8 +220,7 @@ m68k_value_to_register (struct frame_info *frame, int regnum, return; } - /* Convert from TYPE. This should be a no-op if TYPE is equivalent - to the extended floating-point format used by the FPU. */ + /* Convert from TYPE. */ convert_typed_floating (from, type, to, fpreg_type); put_frame_register (frame, regnum, to); } @@ -284,12 +287,12 @@ m68k_svr4_extract_return_value (struct type *type, struct regcache *regcache, { int len = TYPE_LENGTH (type); gdb_byte buf[M68K_MAX_REGISTER_SIZE]; - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT) { - struct type *fpreg_type = register_type - (current_gdbarch, M68K_FP0_REGNUM); + struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); regcache_raw_read (regcache, M68K_FP0_REGNUM, buf); convert_typed_floating (buf, fpreg_type, valbuf, type); } @@ -325,12 +328,12 @@ m68k_svr4_store_return_value (struct type *type, struct regcache *regcache, const gdb_byte *valbuf) { int len = TYPE_LENGTH (type); - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep->float_return && TYPE_CODE (type) == TYPE_CODE_FLT) { - struct type *fpreg_type = register_type - (current_gdbarch, M68K_FP0_REGNUM); + struct type *fpreg_type = register_type (gdbarch, M68K_FP0_REGNUM); gdb_byte buf[M68K_MAX_REGISTER_SIZE]; convert_typed_floating (valbuf, type, buf, fpreg_type); regcache_raw_write (regcache, M68K_FP0_REGNUM, buf); @@ -370,9 +373,9 @@ m68k_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type) from WRITEBUF into REGCACHE. */ static enum return_value_convention -m68k_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, gdb_byte *readbuf, - const gdb_byte *writebuf) +m68k_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *type, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) { enum type_code code = TYPE_CODE (type); @@ -405,9 +408,9 @@ m68k_return_value (struct gdbarch *gdbarch, struct type *type, } static enum return_value_convention -m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, gdb_byte *readbuf, - const gdb_byte *writebuf) +m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *type, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) { enum type_code code = TYPE_CODE (type); @@ -444,7 +447,7 @@ m68k_svr4_return_value (struct gdbarch *gdbarch, struct type *type, if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1) { type = check_typedef (TYPE_FIELD_TYPE (type, 0)); - return m68k_svr4_return_value (gdbarch, type, regcache, + return m68k_svr4_return_value (gdbarch, func_type, type, regcache, readbuf, writebuf); } @@ -525,7 +528,7 @@ m68k_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Convert a dwarf or dwarf2 regnumber to a GDB regnum. */ static int -m68k_dwarf_reg_to_regnum (int num) +m68k_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int num) { if (num < 8) /* d0..7 */ @@ -533,15 +536,14 @@ m68k_dwarf_reg_to_regnum (int num) else if (num < 16) /* a0..7 */ return (num - 8) + M68K_A0_REGNUM; - else if (num < 24 && gdbarch_tdep (current_gdbarch)->fpregs_present) + else if (num < 24 && gdbarch_tdep (gdbarch)->fpregs_present) /* fp0..7 */ return (num - 16) + M68K_FP0_REGNUM; else if (num == 25) /* pc */ return M68K_PC_REGNUM; else - return gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch); + return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); } @@ -689,7 +691,8 @@ m68k_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, smaller. Otherwise, return PC. */ static CORE_ADDR -m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc, +m68k_analyze_register_saves (struct gdbarch *gdbarch, CORE_ADDR pc, + CORE_ADDR current_pc, struct m68k_frame_cache *cache) { if (cache->locals >= 0) @@ -703,7 +706,7 @@ m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc, { op = read_memory_unsigned_integer (pc, 2); if (op == P_FMOVEMX_SP - && gdbarch_tdep (current_gdbarch)->fpregs_present) + && gdbarch_tdep (gdbarch)->fpregs_present) { /* fmovem.x REGS,-(%sp) */ op = read_memory_unsigned_integer (pc + 2, 2); @@ -787,13 +790,13 @@ m68k_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc, */ static CORE_ADDR -m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, - struct m68k_frame_cache *cache) +m68k_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, + CORE_ADDR current_pc, struct m68k_frame_cache *cache) { unsigned int op; pc = m68k_analyze_frame_setup (pc, current_pc, cache); - pc = m68k_analyze_register_saves (pc, current_pc, cache); + pc = m68k_analyze_register_saves (gdbarch, pc, current_pc, cache); if (pc >= current_pc) return current_pc; @@ -802,7 +805,7 @@ m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, if (op == P_LEA_PC_A5) { /* lea (%pc,N),%a5 */ - return pc + 6; + return pc + 8; } return pc; @@ -811,14 +814,14 @@ m68k_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, /* Return PC of first real instruction. */ static CORE_ADDR -m68k_skip_prologue (CORE_ADDR start_pc) +m68k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc) { struct m68k_frame_cache cache; CORE_ADDR pc; int op; cache.locals = -1; - pc = m68k_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache); + pc = m68k_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache); if (cache.locals < 0) return start_pc; return pc; @@ -829,14 +832,14 @@ m68k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) { gdb_byte buf[8]; - frame_unwind_register (next_frame, gdbarch_pc_regnum (current_gdbarch), buf); - return extract_typed_address (buf, builtin_type_void_func_ptr); + frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf); + return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr); } /* Normal frames. */ static struct m68k_frame_cache * -m68k_frame_cache (struct frame_info *next_frame, void **this_cache) +m68k_frame_cache (struct frame_info *this_frame, void **this_cache) { struct m68k_frame_cache *cache; gdb_byte buf[4]; @@ -857,7 +860,7 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache) 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); + get_frame_register (this_frame, M68K_FP_REGNUM, buf); cache->base = extract_unsigned_integer (buf, 4); if (cache->base == 0) return cache; @@ -865,9 +868,10 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache) /* For normal frames, %pc is stored at 4(%fp). */ cache->saved_regs[M68K_PC_REGNUM] = 4; - cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); + cache->pc = get_frame_func (this_frame); if (cache->pc != 0) - m68k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); + m68k_analyze_prologue (get_frame_arch (this_frame), cache->pc, + get_frame_pc (this_frame), cache); if (cache->locals < 0) { @@ -879,7 +883,7 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache) frame by looking at the stack pointer. For truly "frameless" functions this might work too. */ - frame_unwind_register (next_frame, M68K_SP_REGNUM, buf); + get_frame_register (this_frame, M68K_SP_REGNUM, buf); cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset; } @@ -897,10 +901,10 @@ m68k_frame_cache (struct frame_info *next_frame, void **this_cache) } static void -m68k_frame_this_id (struct frame_info *next_frame, void **this_cache, +m68k_frame_this_id (struct frame_info *this_frame, void **this_cache, struct frame_id *this_id) { - struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache); + struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache); /* This marks the outermost frame. */ if (cache->base == 0) @@ -910,70 +914,37 @@ m68k_frame_this_id (struct frame_info *next_frame, void **this_cache, *this_id = frame_id_build (cache->base + 8, cache->pc); } -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, gdb_byte *valuep) +static struct value * +m68k_frame_prev_register (struct frame_info *this_frame, void **this_cache, + int regnum) { - struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache); + struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache); gdb_assert (regnum >= 0); if (regnum == M68K_SP_REGNUM && cache->saved_sp) - { - *optimizedp = 0; - *lvalp = not_lval; - *addrp = 0; - *realnump = -1; - if (valuep) - { - /* Store the value. */ - store_unsigned_integer (valuep, 4, cache->saved_sp); - } - return; - } + return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp); if (regnum < M68K_NUM_REGS && cache->saved_regs[regnum] != -1) - { - *optimizedp = 0; - *lvalp = lval_memory; - *addrp = cache->saved_regs[regnum]; - *realnump = -1; - if (valuep) - { - /* Read the value in from memory. */ - read_memory (*addrp, valuep, - register_size (current_gdbarch, regnum)); - } - return; - } + return frame_unwind_got_memory (this_frame, regnum, + cache->saved_regs[regnum]); - *optimizedp = 0; - *lvalp = lval_register; - *addrp = 0; - *realnump = regnum; - if (valuep) - frame_unwind_register (next_frame, (*realnump), valuep); + return frame_unwind_got_register (this_frame, regnum, regnum); } static const struct frame_unwind m68k_frame_unwind = { NORMAL_FRAME, m68k_frame_this_id, - m68k_frame_prev_register + m68k_frame_prev_register, + NULL, + default_frame_sniffer }; - -static const struct frame_unwind * -m68k_frame_sniffer (struct frame_info *next_frame) -{ - return &m68k_frame_unwind; -} static CORE_ADDR -m68k_frame_base_address (struct frame_info *next_frame, void **this_cache) +m68k_frame_base_address (struct frame_info *this_frame, void **this_cache) { - struct m68k_frame_cache *cache = m68k_frame_cache (next_frame, this_cache); + struct m68k_frame_cache *cache = m68k_frame_cache (this_frame, this_cache); return cache->base; } @@ -987,16 +958,14 @@ static const struct frame_base m68k_frame_base = }; static struct frame_id -m68k_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +m68k_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { - gdb_byte buf[4]; CORE_ADDR fp; - frame_unwind_register (next_frame, M68K_FP_REGNUM, buf); - fp = extract_unsigned_integer (buf, 4); + fp = get_frame_register_unsigned (this_frame, M68K_FP_REGNUM); /* See the end of m68k_push_dummy_call. */ - return frame_id_build (fp + 8, frame_pc_unwind (next_frame)); + return frame_id_build (fp + 8, get_frame_pc (this_frame)); } @@ -1010,6 +979,7 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) { gdb_byte *buf; CORE_ADDR sp, jb_addr; + struct gdbarch *gdbarch = get_frame_arch (frame); struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame)); if (tdep->jb_pc < 0) @@ -1019,22 +989,21 @@ m68k_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) return 0; } - buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT); - sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (current_gdbarch)); + buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT); + sp = get_frame_register_unsigned (frame, gdbarch_sp_regnum (gdbarch)); if (target_read_memory (sp + SP_ARG0, /* Offset of first arg on stack */ - buf, - gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT)) + buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT)) return 0; - jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (current_gdbarch) + jb_addr = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT); if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf, - gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT)) + gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT)) return 0; - *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (current_gdbarch) + *pc = extract_unsigned_integer (buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT); return 1; } @@ -1184,7 +1153,6 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_decr_pc_after_break (gdbarch, 2); set_gdbarch_frame_args_skip (gdbarch, 8); - set_gdbarch_dwarf_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, m68k_dwarf_reg_to_regnum); set_gdbarch_register_type (gdbarch, m68k_register_type); @@ -1235,11 +1203,11 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep->struct_return = reg_struct_return; /* Frame unwinder. */ - set_gdbarch_unwind_dummy_id (gdbarch, m68k_unwind_dummy_id); + set_gdbarch_dummy_id (gdbarch, m68k_dummy_id); set_gdbarch_unwind_pc (gdbarch, m68k_unwind_pc); /* Hook in the DWARF CFI frame unwinder. */ - frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); + dwarf2_append_unwinders (gdbarch); frame_base_set_default (gdbarch, &m68k_frame_base); @@ -1252,19 +1220,19 @@ 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_sniffer (gdbarch, m68k_frame_sniffer); + frame_unwind_append_unwinder (gdbarch, &m68k_frame_unwind); if (tdesc_data) - tdesc_use_registers (gdbarch, tdesc_data); + tdesc_use_registers (gdbarch, info.target_desc, tdesc_data); return gdbarch; } static void -m68k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file) +m68k_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (tdep == NULL) return;