X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Favr-tdep.c;h=85f3c0a580942c01cbd56e4749d9f017331135fd;hb=94afd7a6d348a66ea3fb35fdb8234b050ec8c779;hp=a19e927b41d39a48422d8d146bdca7162d1a7567;hpb=11411de309ed70574799872f9b3bec1b18bb66cf;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c index a19e927b41..85f3c0a580 100644 --- a/gdb/avr-tdep.c +++ b/gdb/avr-tdep.c @@ -1,7 +1,7 @@ /* Target-dependent code for Atmel AVR, for GDB. Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, - 2006, 2007 Free Software Foundation, Inc. + 2006, 2007, 2008 Free Software Foundation, Inc. This file is part of GDB. @@ -188,7 +188,7 @@ struct gdbarch_tdep /* Lookup the name of a register given it's number. */ static const char * -avr_register_name (int regnum) +avr_register_name (struct gdbarch *gdbarch, int regnum) { static char *register_names[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", @@ -744,7 +744,7 @@ avr_scan_prologue (CORE_ADDR pc, struct avr_unwind_cache *info) } static CORE_ADDR -avr_skip_prologue (CORE_ADDR pc) +avr_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) { CORE_ADDR func_addr, func_end; CORE_ADDR prologue_end = pc; @@ -788,7 +788,7 @@ avr_skip_prologue (CORE_ADDR pc) only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */ static const unsigned char * -avr_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr) +avr_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr) { static unsigned char avr_break_insn [] = { 0x98, 0x95 }; *lenptr = sizeof (avr_break_insn); @@ -834,9 +834,9 @@ avr_extract_return_value (struct type *type, struct regcache *regcache, from WRITEBUF into REGCACHE. */ enum return_value_convention -avr_return_value (struct gdbarch *gdbarch, struct type *valtype, - struct regcache *regcache, gdb_byte *readbuf, - const gdb_byte *writebuf) +avr_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *valtype, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) { int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT || TYPE_CODE (valtype) == TYPE_CODE_UNION @@ -872,7 +872,7 @@ avr_return_value (struct gdbarch *gdbarch, struct type *valtype, for it IS the sp for the next frame. */ struct avr_unwind_cache * -avr_frame_unwind_cache (struct frame_info *next_frame, +avr_frame_unwind_cache (struct frame_info *this_frame, void **this_prologue_cache) { CORE_ADDR pc; @@ -886,14 +886,14 @@ avr_frame_unwind_cache (struct frame_info *next_frame, info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache); (*this_prologue_cache) = info; - info->saved_regs = trad_frame_alloc_saved_regs (next_frame); + info->saved_regs = trad_frame_alloc_saved_regs (this_frame); info->size = 0; info->prologue_type = AVR_PROLOGUE_NONE; - pc = frame_func_unwind (next_frame, NORMAL_FRAME); + pc = get_frame_func (this_frame); - if ((pc > 0) && (pc < frame_pc_unwind (next_frame))) + if ((pc > 0) && (pc < get_frame_pc (this_frame))) avr_scan_prologue (pc, info); if ((info->prologue_type != AVR_PROLOGUE_NONE) @@ -904,8 +904,8 @@ avr_frame_unwind_cache (struct frame_info *next_frame, /* The SP was moved to the FP. This indicates that a new frame was created. Get THIS frame's FP value by unwinding it from the next frame. */ - this_base = frame_unwind_register_unsigned (next_frame, AVR_FP_REGNUM); - high_base = frame_unwind_register_unsigned (next_frame, AVR_FP_REGNUM+1); + this_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM); + high_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM+1); this_base += (high_base << 8); /* The FP points at the last saved register. Adjust the FP back @@ -916,7 +916,7 @@ avr_frame_unwind_cache (struct frame_info *next_frame, { /* Assume that the FP is this frame's SP but with that pushed stack space added back. */ - this_base = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM); + this_base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM); prev_sp = this_base + info->size; } @@ -928,7 +928,7 @@ avr_frame_unwind_cache (struct frame_info *next_frame, /* Adjust all the saved registers so that they contain addresses and not offsets. */ - for (i = 0; i < gdbarch_num_regs (current_gdbarch) - 1; i++) + for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++) if (info->saved_regs[i].addr) { info->saved_regs[i].addr = (info->prev_sp - info->saved_regs[i].addr); @@ -973,18 +973,18 @@ avr_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) frame. This will be used to create a new GDB frame struct. */ static void -avr_frame_this_id (struct frame_info *next_frame, +avr_frame_this_id (struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id) { struct avr_unwind_cache *info - = avr_frame_unwind_cache (next_frame, this_prologue_cache); + = avr_frame_unwind_cache (this_frame, this_prologue_cache); CORE_ADDR base; CORE_ADDR func; struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame, NORMAL_FRAME); + func = get_frame_func (this_frame); /* Hopefully the prologue analysis either correctly determined the frame's base (which is the SP from the previous frame), or set @@ -997,83 +997,69 @@ avr_frame_this_id (struct frame_info *next_frame, (*this_id) = id; } -static void -avr_frame_prev_register (struct frame_info *next_frame, - void **this_prologue_cache, - int regnum, int *optimizedp, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, gdb_byte *bufferp) +static struct value * +avr_frame_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, int regnum) { struct avr_unwind_cache *info - = avr_frame_unwind_cache (next_frame, this_prologue_cache); + = avr_frame_unwind_cache (this_frame, this_prologue_cache); if (regnum == AVR_PC_REGNUM) { if (trad_frame_addr_p (info->saved_regs, regnum)) { - *optimizedp = 0; - *lvalp = lval_memory; - *addrp = info->saved_regs[regnum].addr; - *realnump = -1; - if (bufferp != NULL) - { - /* Reading the return PC from the PC register is slightly - abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes, - but in reality, only two bytes (3 in upcoming mega256) are - stored on the stack. - - Also, note that the value on the stack is an addr to a word - not a byte, so we will need to multiply it by two at some - point. - - And to confuse matters even more, the return address stored - on the stack is in big endian byte order, even though most - everything else about the avr is little endian. Ick! */ - - /* FIXME: number of bytes read here will need updated for the - mega256 when it is available. */ - - ULONGEST pc; - unsigned char tmp; - unsigned char buf[2]; - - read_memory (info->saved_regs[regnum].addr, buf, 2); - - /* Convert the PC read from memory as a big-endian to - little-endian order. */ - tmp = buf[0]; - buf[0] = buf[1]; - buf[1] = tmp; - - pc = (extract_unsigned_integer (buf, 2) * 2); - store_unsigned_integer (bufferp, - register_size (current_gdbarch, regnum), - pc); - } + /* Reading the return PC from the PC register is slightly + abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes, + but in reality, only two bytes (3 in upcoming mega256) are + stored on the stack. + + Also, note that the value on the stack is an addr to a word + not a byte, so we will need to multiply it by two at some + point. + + And to confuse matters even more, the return address stored + on the stack is in big endian byte order, even though most + everything else about the avr is little endian. Ick! */ + + /* FIXME: number of bytes read here will need updated for the + mega256 when it is available. */ + + ULONGEST pc; + unsigned char tmp; + unsigned char buf[2]; + + read_memory (info->saved_regs[regnum].addr, buf, 2); + + /* Convert the PC read from memory as a big-endian to + little-endian order. */ + tmp = buf[0]; + buf[0] = buf[1]; + buf[1] = tmp; + + pc = (extract_unsigned_integer (buf, 2) * 2); + + return frame_unwind_got_constant (this_frame, regnum, pc); } + + return frame_unwind_got_optimized (this_frame, regnum); } - else - trad_frame_get_prev_register (next_frame, info->saved_regs, regnum, - optimizedp, lvalp, addrp, realnump, bufferp); + + return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum); } static const struct frame_unwind avr_frame_unwind = { NORMAL_FRAME, avr_frame_this_id, - avr_frame_prev_register + avr_frame_prev_register, + NULL, + default_frame_sniffer }; -const struct frame_unwind * -avr_frame_sniffer (struct frame_info *next_frame) -{ - return &avr_frame_unwind; -} - static CORE_ADDR -avr_frame_base_address (struct frame_info *next_frame, void **this_cache) +avr_frame_base_address (struct frame_info *this_frame, void **this_cache) { struct avr_unwind_cache *info - = avr_frame_unwind_cache (next_frame, this_cache); + = avr_frame_unwind_cache (this_frame, this_cache); return info->base; } @@ -1085,18 +1071,17 @@ static const struct frame_base avr_frame_base = { avr_frame_base_address }; -/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that - dummy frame. The frame ID's base needs to match the TOS value - saved by save_dummy_frame_tos(), and the PC match the dummy frame's - breakpoint. */ +/* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy + frame. The frame ID's base needs to match the TOS value saved by + save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */ static struct frame_id -avr_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +avr_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) { ULONGEST base; - base = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM); - return frame_id_build (avr_make_saddr (base), frame_pc_unwind (next_frame)); + base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM); + return frame_id_build (avr_make_saddr (base), get_frame_pc (this_frame)); } /* When arguments must be pushed onto the stack, they go on in reverse @@ -1322,10 +1307,10 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_breakpoint_from_pc (gdbarch, avr_breakpoint_from_pc); - frame_unwind_append_sniffer (gdbarch, avr_frame_sniffer); + frame_unwind_append_unwinder (gdbarch, &avr_frame_unwind); frame_base_set_default (gdbarch, &avr_frame_base); - set_gdbarch_unwind_dummy_id (gdbarch, avr_unwind_dummy_id); + set_gdbarch_dummy_id (gdbarch, avr_dummy_id); set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc); set_gdbarch_unwind_sp (gdbarch, avr_unwind_sp);