X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Favr-tdep.c;h=fd602e35e50da18e81a9ea3c69da4b1aab972d05;hb=7813437494ac39f3aef392d06ed5416e84fe386b;hp=4fcae530f51f23edf6562d3cd1f25b18b607235f;hpb=9a3c826307ae6ad4dd6fbd72431e7d9d4947f1dd;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c index 4fcae530f5..fd602e35e5 100644 --- a/gdb/avr-tdep.c +++ b/gdb/avr-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for Atmel AVR, for GDB. - Copyright (C) 1996-2015 Free Software Foundation, Inc. + Copyright (C) 1996-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -36,6 +36,7 @@ #include "regcache.h" #include "dis-asm.h" #include "objfiles.h" +#include /* AVR Background: @@ -111,6 +112,7 @@ enum AVR_ARG1_REGNUM = 24, /* Single byte argument */ AVR_ARGN_REGNUM = 25, /* Multi byte argments */ + AVR_LAST_ARG_REGNUM = 8, /* Last argument register */ AVR_RET1_REGNUM = 24, /* Single byte return value */ AVR_RETN_REGNUM = 25, /* Multi byte return value */ @@ -312,8 +314,8 @@ avr_address_to_pointer (struct gdbarch *gdbarch, avr_convert_iaddr_to_raw (addr)); } /* Is it a code address? */ - else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC - || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD) + else if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC + || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD) { /* A code pointer is word (16 bits) addressed. We shift the address down by 1 bit to convert it to a pointer. */ @@ -343,8 +345,8 @@ avr_pointer_to_address (struct gdbarch *gdbarch, return avr_make_iaddr (addr); } /* Is it a code address? */ - else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC - || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD + else if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC + || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type))) { /* A code pointer is word (16 bits) addressed so we shift it up @@ -365,10 +367,11 @@ avr_integer_to_address (struct gdbarch *gdbarch, } static CORE_ADDR -avr_read_pc (struct regcache *regcache) +avr_read_pc (readable_regcache *regcache) { ULONGEST pc; - regcache_cooked_read_unsigned (regcache, AVR_PC_REGNUM, &pc); + + regcache->cooked_read (AVR_PC_REGNUM, &pc); return avr_make_iaddr (pc); } @@ -380,7 +383,7 @@ avr_write_pc (struct regcache *regcache, CORE_ADDR val) } static enum register_status -avr_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, +avr_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf) { ULONGEST val; @@ -389,7 +392,7 @@ avr_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, switch (regnum) { case AVR_PSEUDO_PC_REGNUM: - status = regcache_raw_read_unsigned (regcache, AVR_PC_REGNUM, &val); + status = regcache->raw_read (AVR_PC_REGNUM, &val); if (status != REG_VALID) return status; val >>= 1; @@ -881,7 +884,7 @@ avr_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr); if (post_prologue_pc != 0) - return max (pc, post_prologue_pc); + return std::max (pc, post_prologue_pc); { CORE_ADDR prologue_end = pc; @@ -911,14 +914,9 @@ avr_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) it as a NOP. Thus, it should be ok. Since the avr is currently a remote only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */ -static const unsigned char * -avr_breakpoint_from_pc (struct gdbarch *gdbarch, - CORE_ADDR *pcptr, int *lenptr) -{ - static const unsigned char avr_break_insn [] = { 0x98, 0x95 }; - *lenptr = sizeof (avr_break_insn); - return avr_break_insn; -} +constexpr gdb_byte avr_break_insn [] = { 0x98, 0x95 }; + +typedef BP_MANIPULATION (avr_break_insn) avr_breakpoint; /* Determine, for architecture GDBARCH, how a return value of TYPE should be returned. If it is supposed to be returned in registers, @@ -937,9 +935,9 @@ avr_return_value (struct gdbarch *gdbarch, struct value *function, register holds the LSB. */ int lsb_reg; - if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT - || TYPE_CODE (valtype) == TYPE_CODE_UNION - || TYPE_CODE (valtype) == TYPE_CODE_ARRAY) + if ((valtype->code () == TYPE_CODE_STRUCT + || valtype->code () == TYPE_CODE_UNION + || valtype->code () == TYPE_CODE_ARRAY) && TYPE_LENGTH (valtype) > 8) return RETURN_VALUE_STRUCT_CONVENTION; @@ -955,13 +953,13 @@ avr_return_value (struct gdbarch *gdbarch, struct value *function, if (writebuf != NULL) { for (i = 0; i < TYPE_LENGTH (valtype); i++) - regcache_cooked_write (regcache, lsb_reg + i, writebuf + i); + regcache->cooked_write (lsb_reg + i, writebuf + i); } if (readbuf != NULL) { for (i = 0; i < TYPE_LENGTH (valtype); i++) - regcache_cooked_read (regcache, lsb_reg + i, readbuf + i); + regcache->cooked_read (lsb_reg + i, readbuf + i); } return RETURN_VALUE_REGISTER_CONVENTION; @@ -1106,8 +1104,6 @@ static struct value * avr_frame_prev_register (struct frame_info *this_frame, void **this_prologue_cache, int regnum) { - struct gdbarch *gdbarch = get_frame_arch (this_frame); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); struct avr_unwind_cache *info = avr_frame_unwind_cache (this_frame, this_prologue_cache); @@ -1198,7 +1194,7 @@ struct stack_item { int len; struct stack_item *prev; - void *data; + gdb_byte *data; }; static struct stack_item * @@ -1206,7 +1202,7 @@ push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len) { struct stack_item *si; si = XNEW (struct stack_item); - si->data = xmalloc (len); + si->data = (gdb_byte *) xmalloc (len); si->len = len; si->prev = prev; memcpy (si->data, contents, len); @@ -1267,9 +1263,9 @@ static CORE_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) + function_call_return_method return_method, + CORE_ADDR struct_addr) { - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int i; gdb_byte buf[3]; int call_length = gdbarch_tdep (gdbarch)->call_length; @@ -1277,7 +1273,7 @@ avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function, int regnum = AVR_ARGN_REGNUM; struct stack_item *si = NULL; - if (struct_return) + if (return_method == return_method_struct) { regcache_cooked_write_unsigned (regcache, regnum--, (struct_addr >> 8) & 0xff); @@ -1298,23 +1294,24 @@ avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function, const bfd_byte *contents = value_contents (arg); int len = TYPE_LENGTH (type); - /* Calculate the potential last register needed. */ - last_regnum = regnum - (len + (len & 1)); + /* Calculate the potential last register needed. + E.g. For length 2, registers regnum and regnum-1 (say 25 and 24) + shall be used. So, last needed register will be regnum-1(24). */ + last_regnum = regnum - (len + (len & 1)) + 1; /* If there are registers available, use them. Once we start putting stuff on the stack, all subsequent args go on stack. */ - if ((si == NULL) && (last_regnum >= 8)) + if ((si == NULL) && (last_regnum >= AVR_LAST_ARG_REGNUM)) { - ULONGEST val; - /* Skip a register for odd length args. */ if (len & 1) regnum--; - val = extract_unsigned_integer (contents, len, byte_order); + /* Write MSB of argument into register and subsequent bytes in + decreasing register numbers. */ for (j = 0; j < len; j++) regcache_cooked_write_unsigned - (regcache, regnum--, val >> (8 * (len - j - 1))); + (regcache, regnum--, contents[len - j - 1]); } /* No registers available, push the args onto the stack. */ else @@ -1364,9 +1361,6 @@ avr_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) return reg; if (reg == 32) return AVR_SP_REGNUM; - - warning (_("Unmapped DWARF Register #%d encountered."), reg); - return -1; } @@ -1461,18 +1455,18 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) } /* None found, create a new architecture from the information provided. */ - tdep = XNEW (struct gdbarch_tdep); + tdep = XCNEW (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); tdep->call_length = call_length; /* Create a type for PC. We can't use builtin types here, as they may not be defined. */ - tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void"); + tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, + "void"); tdep->func_void_type = make_function_type (tdep->void_type, NULL); - tdep->pc_type = arch_type (gdbarch, TYPE_CODE_PTR, 4, NULL); - TYPE_TARGET_TYPE (tdep->pc_type) = tdep->func_void_type; - TYPE_UNSIGNED (tdep->pc_type) = 1; + tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL, + tdep->func_void_type); set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT); set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT); @@ -1481,6 +1475,9 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT); set_gdbarch_addr_bit (gdbarch, 32); + set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT); + set_gdbarch_wchar_signed (gdbarch, 1); + set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); @@ -1505,7 +1502,6 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_pseudo_register_write (gdbarch, avr_pseudo_register_write); set_gdbarch_return_value (gdbarch, avr_return_value); - set_gdbarch_print_insn (gdbarch, print_insn_avr); set_gdbarch_push_dummy_call (gdbarch, avr_push_dummy_call); @@ -1518,7 +1514,8 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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_breakpoint_kind_from_pc (gdbarch, avr_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, avr_breakpoint::bp_from_kind); frame_unwind_append_unwinder (gdbarch, &avr_frame_unwind); frame_base_set_default (gdbarch, &avr_frame_base); @@ -1551,23 +1548,17 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) All io registers are 8-bit. */ static void -avr_io_reg_read_command (char *args, int from_tty) +avr_io_reg_read_command (const char *args, int from_tty) { - LONGEST bufsiz = 0; - gdb_byte *buf; - const char *bufstr; char query[400]; - const char *p; unsigned int nreg = 0; unsigned int val; - int i, j, k, step; /* Find out how many io registers the target has. */ - bufsiz = target_read_alloc (¤t_target, TARGET_OBJECT_AVR, - "avr.io_reg", &buf); - bufstr = (const char *) buf; + gdb::optional buf + = target_read_alloc (current_top_target (), TARGET_OBJECT_AVR, "avr.io_reg"); - if (bufsiz <= 0) + if (!buf) { fprintf_unfiltered (gdb_stderr, _("ERR: info io_registers NOT supported " @@ -1575,36 +1566,42 @@ avr_io_reg_read_command (char *args, int from_tty) return; } + const char *bufstr = (const char *) buf->data (); + if (sscanf (bufstr, "%x", &nreg) != 1) { fprintf_unfiltered (gdb_stderr, _("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); /* only fetch up to 8 registers at a time to keep the buffer small */ - step = 8; + int step = 8; - for (i = 0; i < nreg; i += step) + for (int i = 0; i < nreg; i += step) { /* how many registers this round? */ - j = step; + int j = step; if ((i+j) >= nreg) j = nreg - i; /* last block is less than 8 registers */ snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j); - bufsiz = target_read_alloc (¤t_target, TARGET_OBJECT_AVR, - query, &buf); + buf = target_read_alloc (current_top_target (), TARGET_OBJECT_AVR, query); + + if (!buf) + { + fprintf_unfiltered (gdb_stderr, + _("ERR: error reading avr.io_reg:%x,%x\n"), + i, j); + return; + } - p = (const char *) buf; - for (k = i; k < (i + j); k++) + const char *p = (const char *) buf->data (); + for (int k = i; k < (i + j); k++) { if (sscanf (p, "%[^,],%x;", query, &val) == 2) { @@ -1616,15 +1613,12 @@ avr_io_reg_read_command (char *args, int from_tty) break; } } - - xfree (buf); } } -extern initialize_file_ftype _initialize_avr_tdep; /* -Wmissing-prototypes */ - +void _initialize_avr_tdep (); void -_initialize_avr_tdep (void) +_initialize_avr_tdep () { register_gdbarch_init (bfd_arch_avr, avr_gdbarch_init); @@ -1635,7 +1629,6 @@ _initialize_avr_tdep (void) /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr 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); + add_info ("io_registers", avr_io_reg_read_command, + _("Query remote AVR target for I/O space register values.")); }