X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Favr-tdep.c;h=814e8a65e3da3e19dde47fe18872848be9382268;hb=ae4a729bff61b571c63a35ffa265d321cf8f9c89;hp=108732b4081caed485b16a3d0ab42e977a035dd8;hpb=5867a2fbbf54ec0d6290c2967e78d4fc0c8f6fa9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c index 108732b408..814e8a65e3 100644 --- a/gdb/avr-tdep.c +++ b/gdb/avr-tdep.c @@ -1,6 +1,7 @@ /* Target-dependent code for Atmel AVR, for GDB. - Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + + Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, + 2006, 2007 Free Software Foundation, Inc. This file is part of GDB. @@ -16,8 +17,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /* Contributed by Theodore A. Roth, troth@openavr.org */ @@ -31,6 +32,7 @@ #include "trad-frame.h" #include "gdbcmd.h" #include "gdbcore.h" +#include "gdbtypes.h" #include "inferior.h" #include "symfile.h" #include "arch-utils.h" @@ -278,7 +280,7 @@ avr_convert_saddr_to_raw (CORE_ADDR x) /* Convert from address to pointer and vice-versa. */ static void -avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) +avr_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) { /* Is it a code address? */ if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC @@ -296,7 +298,7 @@ avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) } static CORE_ADDR -avr_pointer_to_address (struct type *type, const void *buf) +avr_pointer_to_address (struct type *type, const gdb_byte *buf) { CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type)); @@ -310,38 +312,18 @@ avr_pointer_to_address (struct type *type, const void *buf) } static CORE_ADDR -avr_read_pc (ptid_t ptid) +avr_read_pc (struct regcache *regcache) { - ptid_t save_ptid; ULONGEST pc; - CORE_ADDR retval; - - save_ptid = inferior_ptid; - inferior_ptid = ptid; - regcache_cooked_read_unsigned (current_regcache, AVR_PC_REGNUM, &pc); - inferior_ptid = save_ptid; - retval = avr_make_iaddr (pc); - return retval; + regcache_cooked_read_unsigned (regcache, AVR_PC_REGNUM, &pc); + return avr_make_iaddr (pc); } static void -avr_write_pc (CORE_ADDR val, ptid_t ptid) -{ - ptid_t save_ptid; - - save_ptid = inferior_ptid; - inferior_ptid = ptid; - write_register (AVR_PC_REGNUM, avr_convert_iaddr_to_raw (val)); - inferior_ptid = save_ptid; -} - -static CORE_ADDR -avr_read_sp (void) +avr_write_pc (struct regcache *regcache, CORE_ADDR val) { - ULONGEST sp; - - regcache_cooked_read_unsigned (current_regcache, AVR_SP_REGNUM, &sp); - return (avr_make_saddr (sp)); + regcache_cooked_write_unsigned (regcache, AVR_PC_REGNUM, + avr_convert_iaddr_to_raw (val)); } static int @@ -588,7 +570,7 @@ avr_scan_prologue (CORE_ADDR pc, struct avr_unwind_cache *info) if (num_pushes > AVR_MAX_PUSHES) { - fprintf_unfiltered (gdb_stderr, "Num pushes too large: %d\n", + fprintf_unfiltered (gdb_stderr, _("Num pushes too large: %d\n"), num_pushes); num_pushes = 0; } @@ -667,7 +649,7 @@ avr_scan_prologue (CORE_ADDR pc, struct avr_unwind_cache *info) if (vpc >= AVR_MAX_PROLOGUE_SIZE) fprintf_unfiltered (gdb_stderr, - "Hit end of prologue while scanning pushes\n"); + _("Hit end of prologue while scanning pushes\n")); /* Second stage of the prologue scanning. Scan: @@ -822,7 +804,7 @@ avr_breakpoint_from_pc (CORE_ADDR * pcptr, int *lenptr) static void avr_extract_return_value (struct type *type, struct regcache *regcache, - void *valbuf) + gdb_byte *valbuf) { ULONGEST r24, r25; ULONGEST c; @@ -873,7 +855,7 @@ avr_frame_unwind_cache (struct frame_info *next_frame, info->size = 0; info->prologue_type = AVR_PROLOGUE_NONE; - pc = frame_func_unwind (next_frame); + pc = frame_func_unwind (next_frame, NORMAL_FRAME); if ((pc > 0) && (pc < frame_pc_unwind (next_frame))) avr_scan_prologue (pc, info); @@ -910,7 +892,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 < NUM_REGS - 1; i++) + for (i = 0; i < gdbarch_num_regs (current_gdbarch) - 1; i++) if (info->saved_regs[i].addr) { info->saved_regs[i].addr = (info->prev_sp - info->saved_regs[i].addr); @@ -941,6 +923,16 @@ avr_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) return avr_make_iaddr (pc); } +static CORE_ADDR +avr_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + ULONGEST sp; + + frame_unwind_unsigned_register (next_frame, AVR_SP_REGNUM, &sp); + + return avr_make_saddr (sp); +} + /* Given a GDB frame, determine the address of the calling function's frame. This will be used to create a new GDB frame struct. */ @@ -956,7 +948,7 @@ avr_frame_this_id (struct frame_info *next_frame, struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* Hopefully the prologue analysis either correctly determined the frame's base (which is the SP from the previous frame), or set @@ -966,16 +958,6 @@ avr_frame_this_id (struct frame_info *next_frame, return; id = frame_id_build (base, func); - - /* Check that we're not going round in circles with the same frame - ID (but avoid applying the test to sentinel frames which do go - round in circles). Can't use frame_id_eq() as that doesn't yet - compare the frame's PC value. */ - if (frame_relative_level (next_frame) >= 0 - && get_frame_type (next_frame) != DUMMY_FRAME - && frame_id_eq (get_frame_id (next_frame), id)) - return; - (*this_id) = id; } @@ -984,7 +966,7 @@ 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, void *bufferp) + int *realnump, gdb_byte *bufferp) { struct avr_unwind_cache *info = avr_frame_unwind_cache (next_frame, this_prologue_cache); @@ -1035,8 +1017,8 @@ avr_frame_prev_register (struct frame_info *next_frame, } } else - trad_frame_prev_register (next_frame, info->saved_regs, regnum, - optimizedp, lvalp, addrp, realnump, bufferp); + trad_frame_get_prev_register (next_frame, info->saved_regs, regnum, + optimizedp, lvalp, addrp, realnump, bufferp); } static const struct frame_unwind avr_frame_unwind = { @@ -1091,10 +1073,8 @@ struct stack_item void *data; }; -static struct stack_item *push_stack_item (struct stack_item *prev, - void *contents, int len); static struct stack_item * -push_stack_item (struct stack_item *prev, void *contents, int len) +push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len) { struct stack_item *si; si = xmalloc (sizeof (struct stack_item)); @@ -1156,7 +1136,7 @@ pop_stack_item (struct stack_item *si) registers R0 to R2. */ static CORE_ADDR -avr_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, +avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) @@ -1172,8 +1152,8 @@ avr_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, if (struct_return) { fprintf_unfiltered (gdb_stderr, "struct_return: 0x%lx\n", struct_addr); - write_register (argreg--, struct_addr & 0xff); - write_register (argreg--, (struct_addr >>8) & 0xff); + regcache_cooked_write_unsigned (regcache, argreg--, struct_addr & 0xff); + regcache_cooked_write_unsigned (regcache, argreg--, (struct_addr >>8) & 0xff); } #endif @@ -1182,8 +1162,8 @@ avr_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, int last_regnum; int j; struct value *arg = args[i]; - struct type *type = check_typedef (VALUE_TYPE (arg)); - char *contents = VALUE_CONTENTS (arg); + struct type *type = check_typedef (value_type (arg)); + const bfd_byte *contents = value_contents (arg); int len = TYPE_LENGTH (type); /* Calculate the potential last register needed. */ @@ -1278,13 +1258,12 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); - set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little); - set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little); - set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_single_little); + set_gdbarch_float_format (gdbarch, floatformats_ieee_single); + set_gdbarch_double_format (gdbarch, floatformats_ieee_single); + set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single); set_gdbarch_read_pc (gdbarch, avr_read_pc); set_gdbarch_write_pc (gdbarch, avr_write_pc); - set_gdbarch_read_sp (gdbarch, avr_read_sp); set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS); @@ -1302,22 +1281,18 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer); set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address); - set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention); - set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue); set_gdbarch_inner_than (gdbarch, core_addr_lessthan); set_gdbarch_breakpoint_from_pc (gdbarch, avr_breakpoint_from_pc); - set_gdbarch_frameless_function_invocation (gdbarch, - frameless_look_for_prologue); - frame_unwind_append_sniffer (gdbarch, avr_frame_sniffer); frame_base_set_default (gdbarch, &avr_frame_base); set_gdbarch_unwind_dummy_id (gdbarch, avr_unwind_dummy_id); set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc); + set_gdbarch_unwind_sp (gdbarch, avr_unwind_sp); return gdbarch; } @@ -1339,48 +1314,38 @@ static void avr_io_reg_read_command (char *args, int from_tty) { LONGEST bufsiz = 0; - char buf[400]; + gdb_byte *buf; char query[400]; char *p; unsigned int nreg = 0; unsigned int val; int i, j, k, step; - /* Just get the maximum buffer size. */ - bufsiz = target_read_partial (¤t_target, TARGET_OBJECT_AVR, - NULL, NULL, 0, 0); - if (bufsiz < 0) - { - fprintf_unfiltered (gdb_stderr, - "ERR: info io_registers NOT supported by current " - "target\n"); - return; - } - if (bufsiz > sizeof (buf)) - bufsiz = sizeof (buf); - /* Find out how many io registers the target has. */ - strcpy (query, "avr.io_reg"); - target_read_partial (¤t_target, TARGET_OBJECT_AVR, query, buf, 0, - bufsiz); + bufsiz = target_read_alloc (¤t_target, TARGET_OBJECT_AVR, + "avr.io_reg", &buf); - if (strncmp (buf, "", bufsiz) == 0) + if (bufsiz <= 0) { fprintf_unfiltered (gdb_stderr, - "info io_registers NOT supported by target\n"); + _("ERR: info io_registers NOT supported " + "by current target\n")); return; } if (sscanf (buf, "%x", &nreg) != 1) { fprintf_unfiltered (gdb_stderr, - "Error fetching number of io registers\n"); + _("Error fetching number of io registers\n")); + xfree (buf); return; } + xfree (buf); + reinitialize_more_filter (); - printf_unfiltered ("Target has %u io registers:\n\n", nreg); + printf_unfiltered (_("Target has %u io registers:\n\n"), nreg); /* only fetch up to 8 registers at a time to keep the buffer small */ step = 8; @@ -1393,8 +1358,8 @@ avr_io_reg_read_command (char *args, int from_tty) j = nreg - i; /* last block is less than 8 registers */ snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j); - target_read_partial (¤t_target, TARGET_OBJECT_AVR, query, buf, - 0, bufsiz); + bufsiz = target_read_alloc (¤t_target, TARGET_OBJECT_AVR, + query, &buf); p = buf; for (k = i; k < (i + j); k++) @@ -1409,6 +1374,8 @@ avr_io_reg_read_command (char *args, int from_tty) break; } } + + xfree (buf); } } @@ -1427,5 +1394,6 @@ _initialize_avr_tdep (void) io_registers' to signify it is not available on other platforms. */ add_cmd ("io_registers", class_info, avr_io_reg_read_command, - "query remote avr target for io space register values", &infolist); + _("query remote avr target for io space register values"), + &infolist); }