X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fh8300-tdep.c;h=b569a23f2631cfb1f69d16e639734070b2b24cca;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=390f92f667cb37ee032f09dca1de7c3ba99ce62b;hpb=a9762ec78a53fbe9209fe1654db42df0cd328d50;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c index 390f92f667..b569a23f26 100644 --- a/gdb/h8300-tdep.c +++ b/gdb/h8300-tdep.c @@ -1,7 +1,6 @@ /* Target-machine dependent code for Renesas H8/300, for GDB. - Copyright (C) 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, - 2000, 2001, 2002, 2003, 2005, 2007 Free Software Foundation, Inc. + Copyright (C) 1988-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -29,9 +28,8 @@ #include "regcache.h" #include "gdbcore.h" #include "objfiles.h" -#include "gdb_assert.h" #include "dis-asm.h" -#include "dwarf2-frame.h" +#include "dwarf2/frame.h" #include "frame-base.h" #include "frame-unwind.h" @@ -60,8 +58,8 @@ enum gdb_regnum #define H8300_MAX_NUM_REGS 18 -#define E_PSEUDO_CCR_REGNUM (gdbarch_num_regs (current_gdbarch)) -#define E_PSEUDO_EXR_REGNUM (gdbarch_num_regs (current_gdbarch)+1) +#define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)) +#define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1) struct h8300_frame_cache { @@ -70,7 +68,7 @@ struct h8300_frame_cache CORE_ADDR sp_offset; CORE_ADDR pc; - /* Flag showing that a frame has been created in the prologue code. */ + /* Flag showing that a frame has been created in the prologue code. */ int uses_fp; /* Saved registers. */ @@ -90,35 +88,17 @@ static int is_h8300smode (struct gdbarch *gdbarch); static int is_h8300sxmode (struct gdbarch *gdbarch); static int is_h8300_normal_mode (struct gdbarch *gdbarch); -#define BINWORD ((is_h8300hmode (current_gdbarch) \ - && !is_h8300_normal_mode (current_gdbarch)) \ +#define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \ + && !is_h8300_normal_mode (gdbarch)) \ ? h8300h_reg_size : h8300_reg_size) -static CORE_ADDR -h8300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) -{ - return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM); -} - -static CORE_ADDR -h8300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) -{ - return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM); -} - -static struct frame_id -h8300_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) -{ - return frame_id_build (h8300_unwind_sp (gdbarch, next_frame), - frame_pc_unwind (next_frame)); -} - /* Normal frames. */ /* Allocate and initialize a frame cache. */ static void -h8300_init_frame_cache (struct h8300_frame_cache *cache) +h8300_init_frame_cache (struct gdbarch *gdbarch, + struct h8300_frame_cache *cache) { int i; @@ -132,7 +112,7 @@ h8300_init_frame_cache (struct h8300_frame_cache *cache) /* 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 < gdbarch_num_regs (current_gdbarch); i++) + for (i = 0; i < gdbarch_num_regs (gdbarch); i++) cache->saved_regs[i] = -1; } @@ -145,7 +125,7 @@ h8300_init_frame_cache (struct h8300_frame_cache *cache) #define IS_MOVW_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0) #define IS_MOVW_EXT(x) ((x) == 0x78e0) #define IS_MOVW_Rn24_SP(x) (((x) & 0xfff0) == 0x6ba0) -/* Same instructions as mov.w, just prefixed with 0x0100 */ +/* Same instructions as mov.w, just prefixed with 0x0100. */ #define IS_MOVL_PRE(x) ((x) == 0x0100) #define IS_MOVL_Rn16_SP(x) (((x) & 0xfff0) == 0x6fe0) #define IS_MOVL_EXT(x) ((x) == 0x78e0) @@ -176,9 +156,10 @@ h8300_init_frame_cache (struct h8300_frame_cache *cache) is used, it could be a byte, word or long move to registers r3-r5. */ static int -h8300_is_argument_spill (CORE_ADDR pc) +h8300_is_argument_spill (struct gdbarch *gdbarch, CORE_ADDR pc) { - int w = read_memory_unsigned_integer (pc, 2); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + int w = read_memory_unsigned_integer (pc, 2, byte_order); if ((IS_MOVB_RnRm (w) || IS_MOVW_RnRm (w) || IS_MOVL_RnRm (w)) && (w & 0x70) <= 0x20 /* Rs is R0, R1 or R2 */ @@ -188,17 +169,19 @@ h8300_is_argument_spill (CORE_ADDR pc) if (IS_MOVB_Rn16_SP (w) && 8 <= (w & 0xf) && (w & 0xf) <= 10) /* Rs is R0L, R1L, or R2L */ { - if (read_memory_integer (pc + 2, 2) < 0) /* ... and d:16 is negative. */ + /* ... and d:16 is negative. */ + if (read_memory_integer (pc + 2, 2, byte_order) < 0) return 4; } else if (IS_MOVB_EXT (w)) { - if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc + 2, 2))) + if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc + 2, + 2, byte_order))) { - LONGEST disp = read_memory_integer (pc + 4, 4); + ULONGEST disp = read_memory_unsigned_integer (pc + 4, 4, byte_order); /* ... and d:24 is negative. */ - if (disp < 0 && disp > 0xffffff) + if ((disp & 0x00800000) != 0) return 8; } } @@ -206,41 +189,41 @@ h8300_is_argument_spill (CORE_ADDR pc) && (w & 0xf) <= 2) /* Rs is R0, R1, or R2 */ { /* ... and d:16 is negative. */ - if (read_memory_integer (pc + 2, 2) < 0) + if (read_memory_integer (pc + 2, 2, byte_order) < 0) return 4; } else if (IS_MOVW_EXT (w)) { - if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc + 2, 2))) + if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc + 2, + 2, byte_order))) { - LONGEST disp = read_memory_integer (pc + 4, 4); + ULONGEST disp = read_memory_unsigned_integer (pc + 4, 4, byte_order); /* ... and d:24 is negative. */ - if (disp < 0 && disp > 0xffffff) + if ((disp & 0x00800000) != 0) return 8; } } else if (IS_MOVL_PRE (w)) { - int w2 = read_memory_integer (pc + 2, 2); + int w2 = read_memory_integer (pc + 2, 2, byte_order); if (IS_MOVL_Rn16_SP (w2) && (w2 & 0xf) <= 2) /* Rs is ER0, ER1, or ER2 */ { /* ... and d:16 is negative. */ - if (read_memory_integer (pc + 4, 2) < 0) + if (read_memory_integer (pc + 4, 2, byte_order) < 0) return 6; } else if (IS_MOVL_EXT (w2)) { - int w3 = read_memory_integer (pc + 4, 2); - - if (IS_MOVL_Rn24_SP (read_memory_integer (pc + 4, 2))) + if (IS_MOVL_Rn24_SP (read_memory_integer (pc + 4, 2, byte_order))) { - LONGEST disp = read_memory_integer (pc + 6, 4); + ULONGEST disp = read_memory_unsigned_integer (pc + 6, 4, + byte_order); /* ... and d:24 is negative. */ - if (disp < 0 && disp > 0xffffff) + if ((disp & 0x00800000) != 0) return 10; } } @@ -285,9 +268,11 @@ h8300_is_argument_spill (CORE_ADDR pc) */ static CORE_ADDR -h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, +h8300_analyze_prologue (struct gdbarch *gdbarch, + CORE_ADDR pc, CORE_ADDR current_pc, struct h8300_frame_cache *cache) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); unsigned int op; int regno, i, spill_size; @@ -296,7 +281,7 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, if (pc >= current_pc) return current_pc; - op = read_memory_unsigned_integer (pc, 4); + op = read_memory_unsigned_integer (pc, 4, byte_order); if (IS_PUSHFP_MOVESPFP (op)) { @@ -310,7 +295,7 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, pc += 4; if (pc >= current_pc) return current_pc; - op = read_memory_unsigned_integer (pc, 2); + op = read_memory_unsigned_integer (pc, 2, byte_order); if (IS_MOV_SP_FP (op)) { cache->uses_fp = 1; @@ -320,7 +305,7 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, while (pc < current_pc) { - op = read_memory_unsigned_integer (pc, 2); + op = read_memory_unsigned_integer (pc, 2, byte_order); if (IS_SUB2_SP (op)) { cache->sp_offset += 2; @@ -333,12 +318,12 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, } else if (IS_ADD_IMM_SP (op)) { - cache->sp_offset += -read_memory_integer (pc + 2, 2); + cache->sp_offset += -read_memory_integer (pc + 2, 2, byte_order); pc += 4; } else if (IS_SUB_IMM_SP (op)) { - cache->sp_offset += read_memory_integer (pc + 2, 2); + cache->sp_offset += read_memory_integer (pc + 2, 2, byte_order); pc += 4; } else if (IS_SUBL4_SP (op)) @@ -348,9 +333,9 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, } else if (IS_MOV_IMM_Rn (op)) { - int offset = read_memory_integer (pc + 2, 2); + int offset = read_memory_integer (pc + 2, 2, byte_order); regno = op & 0x000f; - op = read_memory_unsigned_integer (pc + 4, 2); + op = read_memory_unsigned_integer (pc + 4, 2, byte_order); if (IS_ADD_RnSP (op) && (op & 0x00f0) == regno) { cache->sp_offset -= offset; @@ -373,7 +358,7 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, } else if (op == 0x0100) { - op = read_memory_unsigned_integer (pc + 2, 2); + op = read_memory_unsigned_integer (pc + 2, 2, byte_order); if (IS_PUSH (op)) { regno = op & 0x000f; @@ -387,7 +372,7 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, else if ((op & 0xffcf) == 0x0100) { int op1; - op1 = read_memory_unsigned_integer (pc + 2, 2); + op1 = read_memory_unsigned_integer (pc + 2, 2, byte_order); if (IS_PUSH (op1)) { /* Since the prefix is 0x01x0, this is not a simple pushm but a @@ -411,7 +396,7 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, /* Check for spilling an argument register to the stack frame. This could also be an initializing store from non-prologue code, but I don't think there's any harm in skipping that. */ - while ((spill_size = h8300_is_argument_spill (pc)) > 0 + while ((spill_size = h8300_is_argument_spill (gdbarch, pc)) > 0 && pc + spill_size <= current_pc) pc += spill_size; @@ -419,18 +404,18 @@ h8300_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, } static struct h8300_frame_cache * -h8300_frame_cache (struct frame_info *next_frame, void **this_cache) +h8300_frame_cache (struct frame_info *this_frame, void **this_cache) { + struct gdbarch *gdbarch = get_frame_arch (this_frame); struct h8300_frame_cache *cache; - char buf[4]; int i; CORE_ADDR current_pc; if (*this_cache) - return *this_cache; + return (struct h8300_frame_cache *) *this_cache; cache = FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache); - h8300_init_frame_cache (cache); + h8300_init_frame_cache (gdbarch, cache); *this_cache = cache; /* In principle, for normal frames, %fp holds the frame pointer, @@ -439,16 +424,16 @@ h8300_frame_cache (struct frame_info *next_frame, void **this_cache) optional. For these "frameless" functions the frame pointer is actually the frame pointer of the calling frame. */ - cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM); + cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM); if (cache->base == 0) return cache; - cache->saved_regs[E_PC_REGNUM] = -BINWORD; + cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch); - cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); - current_pc = frame_pc_unwind (next_frame); + cache->pc = get_frame_func (this_frame); + current_pc = get_frame_pc (this_frame); if (cache->pc != 0) - h8300_analyze_prologue (cache->pc, current_pc, cache); + h8300_analyze_prologue (gdbarch, cache->pc, current_pc, cache); if (!cache->uses_fp) { @@ -460,20 +445,20 @@ h8300_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. */ - cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM) + cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM) + cache->sp_offset; - cache->saved_sp = cache->base + BINWORD; + cache->saved_sp = cache->base + BINWORD (gdbarch); cache->saved_regs[E_PC_REGNUM] = 0; } else { - cache->saved_sp = cache->base + 2 * BINWORD; - cache->saved_regs[E_PC_REGNUM] = -BINWORD; + cache->saved_sp = cache->base + 2 * BINWORD (gdbarch); + cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch); } /* Adjust all the saved registers such that they contain addresses instead of offsets. */ - for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++) + for (i = 0; i < gdbarch_num_regs (gdbarch); i++) if (cache->saved_regs[i] != -1) cache->saved_regs[i] = cache->base - cache->saved_regs[i]; @@ -481,11 +466,11 @@ h8300_frame_cache (struct frame_info *next_frame, void **this_cache) } static void -h8300_frame_this_id (struct frame_info *next_frame, void **this_cache, +h8300_frame_this_id (struct frame_info *this_frame, void **this_cache, struct frame_id *this_id) { struct h8300_frame_cache *cache = - h8300_frame_cache (next_frame, this_cache); + h8300_frame_cache (this_frame, this_cache); /* This marks the outermost frame. */ if (cache->base == 0) @@ -494,64 +479,40 @@ h8300_frame_this_id (struct frame_info *next_frame, void **this_cache, *this_id = frame_id_build (cache->saved_sp, cache->pc); } -static void -h8300_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 * +h8300_frame_prev_register (struct frame_info *this_frame, void **this_cache, + int regnum) { + struct gdbarch *gdbarch = get_frame_arch (this_frame); struct h8300_frame_cache *cache = - h8300_frame_cache (next_frame, this_cache); + h8300_frame_cache (this_frame, this_cache); gdb_assert (regnum >= 0); if (regnum == E_SP_REGNUM && cache->saved_sp) - { - *optimizedp = 0; - *lvalp = not_lval; - *addrp = 0; - *realnump = -1; - if (valuep) - store_unsigned_integer (valuep, BINWORD, cache->saved_sp); - return; - } + return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp); - if (regnum < gdbarch_num_regs (current_gdbarch) + if (regnum < gdbarch_num_regs (gdbarch) && cache->saved_regs[regnum] != -1) - { - *optimizedp = 0; - *lvalp = lval_memory; - *addrp = cache->saved_regs[regnum]; - *realnump = -1; - if (valuep) - 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 h8300_frame_unwind = { NORMAL_FRAME, + default_frame_unwind_stop_reason, h8300_frame_this_id, - h8300_frame_prev_register + h8300_frame_prev_register, + NULL, + default_frame_sniffer }; -static const struct frame_unwind * -h8300_frame_sniffer (struct frame_info *next_frame) -{ - return &h8300_frame_unwind; -} - static CORE_ADDR -h8300_frame_base_address (struct frame_info *next_frame, void **this_cache) +h8300_frame_base_address (struct frame_info *this_frame, void **this_cache) { - struct h8300_frame_cache *cache = h8300_frame_cache (next_frame, this_cache); + struct h8300_frame_cache *cache = h8300_frame_cache (this_frame, this_cache); return cache->base; } @@ -563,7 +524,7 @@ static const struct frame_base h8300_frame_base = { }; static CORE_ADDR -h8300_skip_prologue (CORE_ADDR pc) +h8300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) { CORE_ADDR func_addr = 0 , func_end = 0; @@ -579,8 +540,8 @@ h8300_skip_prologue (CORE_ADDR pc) return sal.end; /* No useable line symbol. Use prologue parsing method. */ - h8300_init_frame_cache (&cache); - return h8300_analyze_prologue (func_addr, func_end, &cache); + h8300_init_frame_cache (gdbarch, &cache); + return h8300_analyze_prologue (gdbarch, func_addr, func_end, &cache); } /* No function symbol -- just return the PC. */ @@ -655,10 +616,12 @@ static CORE_ADDR h8300_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 stack_alloc = 0, stack_offset = 0; - int wordsize = BINWORD; + int wordsize = BINWORD (gdbarch); int reg = E_ARG0_REGNUM; int argument; @@ -677,7 +640,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, If we're returning a structure by value, then we must pass a pointer to the buffer for the return value as an invisible first argument. */ - if (struct_return) + if (return_method == return_method_struct) regcache_cooked_write_unsigned (regcache, reg++, struct_addr); for (argument = 0; argument < nargs; argument++) @@ -688,10 +651,11 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Pad the argument appropriately. */ int padded_len = align_up (len, wordsize); - gdb_byte *padded = alloca (padded_len); + /* Use std::vector here to get zero initialization. */ + std::vector padded (padded_len); - memset (padded, 0, padded_len); - memcpy (len < wordsize ? padded + padded_len - len : padded, + memcpy ((len < wordsize ? padded.data () + padded_len - len + : padded.data ()), contents, len); /* Could the argument fit in the remaining registers? */ @@ -702,7 +666,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, if (len > wordsize && len % wordsize) { /* I feel so unclean. */ - write_memory (sp + stack_offset, padded, padded_len); + write_memory (sp + stack_offset, padded.data (), padded_len); stack_offset += padded_len; /* That's right --- even though we passed the argument @@ -713,15 +677,15 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, else { /* Heavens to Betsy --- it's really going in registers! - It would be nice if we could use write_register_bytes - here, but on the h8/300s, there are gaps between - the registers in the register file. */ + Note that on the h8/300s, there are gaps between the + registers in the register file. */ int offset; for (offset = 0; offset < padded_len; offset += wordsize) { - ULONGEST word = extract_unsigned_integer (padded + offset, - wordsize); + ULONGEST word + = extract_unsigned_integer (&padded[offset], + wordsize, byte_order); regcache_cooked_write_unsigned (regcache, reg++, word); } } @@ -729,7 +693,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, else { /* It doesn't fit in registers! Onto the stack it goes. */ - write_memory (sp + stack_offset, padded, padded_len); + write_memory (sp + stack_offset, padded.data (), padded_len); stack_offset += padded_len; /* Once one argument has spilled onto the stack, all @@ -740,7 +704,7 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Store return address. */ sp -= wordsize; - write_memory_unsigned_integer (sp, wordsize, bp_addr); + write_memory_unsigned_integer (sp, wordsize, byte_order, bp_addr); /* Update stack pointer. */ regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp); @@ -756,8 +720,10 @@ h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function, static void h8300_extract_return_value (struct type *type, struct regcache *regcache, - void *valbuf) + gdb_byte *valbuf) { + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int len = TYPE_LENGTH (type); ULONGEST c, addr; @@ -766,24 +732,24 @@ h8300_extract_return_value (struct type *type, struct regcache *regcache, case 1: case 2: regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c); - store_unsigned_integer (valbuf, len, c); + store_unsigned_integer (valbuf, len, byte_order, c); break; case 4: /* Needs two registers on plain H8/300 */ regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c); - store_unsigned_integer (valbuf, 2, c); + store_unsigned_integer (valbuf, 2, byte_order, c); regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c); - store_unsigned_integer ((void *) ((char *) valbuf + 2), 2, c); + store_unsigned_integer (valbuf + 2, 2, byte_order, c); break; case 8: /* long long is now 8 bytes. */ - if (TYPE_CODE (type) == TYPE_CODE_INT) + if (type->code () == TYPE_CODE_INT) { regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr); - c = read_memory_unsigned_integer ((CORE_ADDR) addr, len); - store_unsigned_integer (valbuf, len, c); + c = read_memory_unsigned_integer ((CORE_ADDR) addr, len, byte_order); + store_unsigned_integer (valbuf, len, byte_order, c); } else { - error ("I don't know how this 8 byte value is returned."); + error (_("I don't know how this 8 byte value is returned.")); } break; } @@ -791,62 +757,63 @@ h8300_extract_return_value (struct type *type, struct regcache *regcache, static void h8300h_extract_return_value (struct type *type, struct regcache *regcache, - void *valbuf) + gdb_byte *valbuf) { - int len = TYPE_LENGTH (type); - ULONGEST c, addr; + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + ULONGEST c; - switch (len) + switch (TYPE_LENGTH (type)) { case 1: case 2: case 4: regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c); - store_unsigned_integer (valbuf, len, c); + store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c); break; case 8: /* long long is now 8 bytes. */ - if (TYPE_CODE (type) == TYPE_CODE_INT) + if (type->code () == TYPE_CODE_INT) { regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c); - store_unsigned_integer (valbuf, 4, c); + store_unsigned_integer (valbuf, 4, byte_order, c); regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c); - store_unsigned_integer ((void *) ((char *) valbuf + 4), 4, c); + store_unsigned_integer (valbuf + 4, 4, byte_order, c); } else { - error ("I don't know how this 8 byte value is returned."); + error (_("I don't know how this 8 byte value is returned.")); } break; } } -int +static int h8300_use_struct_convention (struct type *value_type) { /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the - stack. */ + stack. */ - if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT - || TYPE_CODE (value_type) == TYPE_CODE_UNION) + if (value_type->code () == TYPE_CODE_STRUCT + || value_type->code () == TYPE_CODE_UNION) return 1; return !(TYPE_LENGTH (value_type) == 1 || TYPE_LENGTH (value_type) == 2 || TYPE_LENGTH (value_type) == 4); } -int +static int h8300h_use_struct_convention (struct type *value_type) { /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are - returned in R0/R1, everything else on the stack. */ - if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT - || TYPE_CODE (value_type) == TYPE_CODE_UNION) + returned in R0/R1, everything else on the stack. */ + if (value_type->code () == TYPE_CODE_STRUCT + || value_type->code () == TYPE_CODE_UNION) return 1; return !(TYPE_LENGTH (value_type) == 1 || TYPE_LENGTH (value_type) == 2 || TYPE_LENGTH (value_type) == 4 || (TYPE_LENGTH (value_type) == 8 - && TYPE_CODE (value_type) == TYPE_CODE_INT)); + && value_type->code () == TYPE_CODE_INT)); } /* Function: store_return_value @@ -855,48 +822,51 @@ h8300h_use_struct_convention (struct type *value_type) static void h8300_store_return_value (struct type *type, struct regcache *regcache, - const void *valbuf) + const gdb_byte *valbuf) { - int len = TYPE_LENGTH (type); + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); ULONGEST val; - switch (len) + switch (TYPE_LENGTH (type)) { case 1: - case 2: /* short... */ - val = extract_unsigned_integer (valbuf, len); + case 2: /* short... */ + val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order); regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val); break; case 4: /* long, float */ - val = extract_unsigned_integer (valbuf, len); + val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order); regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, (val >> 16) & 0xffff); regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff); break; - case 8: /* long long, double and long double are all defined - as 4 byte types so far so this shouldn't happen. */ - error ("I don't know how to return an 8 byte value."); + case 8: /* long long, double and long double + are all defined as 4 byte types so + far so this shouldn't happen. */ + error (_("I don't know how to return an 8 byte value.")); break; } } static void h8300h_store_return_value (struct type *type, struct regcache *regcache, - const void *valbuf) + const gdb_byte *valbuf) { - int len = TYPE_LENGTH (type); + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); ULONGEST val; - switch (len) + switch (TYPE_LENGTH (type)) { case 1: case 2: case 4: /* long, float */ - val = extract_unsigned_integer (valbuf, len); + val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order); regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val); break; case 8: - val = extract_unsigned_integer (valbuf, len); + val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order); regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, (val >> 32) & 0xffffffff); regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, @@ -906,8 +876,8 @@ h8300h_store_return_value (struct type *type, struct regcache *regcache, } static enum return_value_convention -h8300_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, +h8300_return_value (struct gdbarch *gdbarch, struct value *function, + struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { if (h8300_use_struct_convention (type)) @@ -920,8 +890,8 @@ h8300_return_value (struct gdbarch *gdbarch, struct type *type, } static enum return_value_convention -h8300h_return_value (struct gdbarch *gdbarch, struct type *type, - struct regcache *regcache, +h8300h_return_value (struct gdbarch *gdbarch, struct value *function, + struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf) { if (h8300h_use_struct_convention (type)) @@ -943,60 +913,85 @@ h8300h_return_value (struct gdbarch *gdbarch, struct type *type, return RETURN_VALUE_REGISTER_CONVENTION; } -static struct cmd_list_element *setmachinelist; +/* Implementation of 'register_sim_regno' gdbarch method. */ + +static int +h8300_register_sim_regno (struct gdbarch *gdbarch, int regnum) +{ + /* Only makes sense to supply raw registers. */ + gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)); + + /* We hide the raw ccr from the user by making it nameless. Because + the default register_sim_regno hook returns + LEGACY_SIM_REGNO_IGNORE for unnamed registers, we need to + override it. The sim register numbering is compatible with + gdb's. */ + return regnum; +} static const char * -h8300_register_name (int regno) +h8300_register_name_common (const char *regnames[], int numregs, + struct gdbarch *gdbarch, int regno) +{ + if (regno < 0 + || regno >= numregs) + internal_error (__FILE__, __LINE__, + _("h8300_register_name_common: illegal register number %d"), + regno); + else + return regnames[regno]; +} + +static const char * +h8300_register_name (struct gdbarch *gdbarch, int regno) { /* The register names change depending on which h8300 processor - type is selected. */ - static char *register_names[] = { + type is selected. */ + static const char *register_names[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "sp", "", "pc", "cycles", "tick", "inst", "ccr", /* pseudo register */ }; - if (regno < 0 - || regno >= (sizeof (register_names) / sizeof (*register_names))) - internal_error (__FILE__, __LINE__, - "h8300_register_name: illegal register number %d", regno); - else - return register_names[regno]; + return h8300_register_name_common(register_names, ARRAY_SIZE(register_names), + gdbarch, regno); } static const char * -h8300s_register_name (int regno) +h8300h_register_name (struct gdbarch *gdbarch, int regno) { - static char *register_names[] = { + static const char *register_names[] = { + "er0", "er1", "er2", "er3", "er4", "er5", "er6", + "sp", "", "pc", "cycles", "tick", "inst", + "ccr", /* pseudo register */ + }; + return h8300_register_name_common(register_names, ARRAY_SIZE(register_names), + gdbarch, regno); +} + +static const char * +h8300s_register_name (struct gdbarch *gdbarch, int regno) +{ + static const char *register_names[] = { "er0", "er1", "er2", "er3", "er4", "er5", "er6", "sp", "", "pc", "cycles", "", "tick", "inst", "mach", "macl", "ccr", "exr" /* pseudo registers */ }; - if (regno < 0 - || regno >= (sizeof (register_names) / sizeof (*register_names))) - internal_error (__FILE__, __LINE__, - "h8300s_register_name: illegal register number %d", - regno); - else - return register_names[regno]; + return h8300_register_name_common(register_names, ARRAY_SIZE(register_names), + gdbarch, regno); } static const char * -h8300sx_register_name (int regno) +h8300sx_register_name (struct gdbarch *gdbarch, int regno) { - static char *register_names[] = { + static const char *register_names[] = { "er0", "er1", "er2", "er3", "er4", "er5", "er6", "sp", "", "pc", "cycles", "", "tick", "inst", "mach", "macl", "sbr", "vbr", "ccr", "exr" /* pseudo registers */ }; - if (regno < 0 - || regno >= (sizeof (register_names) / sizeof (*register_names))) - internal_error (__FILE__, __LINE__, - "h8300sx_register_name: illegal register number %d", - regno); - else - return register_names[regno]; + return h8300_register_name_common(register_names, ARRAY_SIZE(register_names), + gdbarch, regno); } static void @@ -1012,18 +1007,19 @@ h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file, rval = get_frame_register_signed (frame, regno); fprintf_filtered (file, "%-14s ", name); - if ((regno == E_PSEUDO_CCR_REGNUM) || \ - (regno == E_PSEUDO_EXR_REGNUM && is_h8300smode (current_gdbarch))) + if ((regno == E_PSEUDO_CCR_REGNUM (gdbarch)) || \ + (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch))) { fprintf_filtered (file, "0x%02x ", (unsigned char) rval); print_longest (file, 'u', 1, rval); } else { - fprintf_filtered (file, "0x%s ", phex ((ULONGEST) rval, BINWORD)); + fprintf_filtered (file, "0x%s ", phex ((ULONGEST) rval, + BINWORD (gdbarch))); print_longest (file, 'd', 1, rval); } - if (regno == E_PSEUDO_CCR_REGNUM) + if (regno == E_PSEUDO_CCR_REGNUM (gdbarch)) { /* CCR register */ int C, Z, N, V; @@ -1045,7 +1041,7 @@ h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file, fprintf_filtered (file, "u> "); if ((C | Z) == 1) fprintf_filtered (file, "u<= "); - if ((C == 0)) + if (C == 0) fprintf_filtered (file, "u>= "); if (C == 1) fprintf_filtered (file, "u< "); @@ -1062,7 +1058,7 @@ h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file, if ((Z | (N ^ V)) == 1) fprintf_filtered (file, "<= "); } - else if (regno == E_PSEUDO_EXR_REGNUM && is_h8300smode (current_gdbarch)) + else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch)) { /* EXR register */ unsigned char l = rval & 0xff; @@ -1083,12 +1079,14 @@ h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, { for (regno = E_R0_REGNUM; regno <= E_SP_REGNUM; ++regno) h8300_print_register (gdbarch, file, frame, regno); - h8300_print_register (gdbarch, file, frame, E_PSEUDO_CCR_REGNUM); + h8300_print_register (gdbarch, file, frame, + E_PSEUDO_CCR_REGNUM (gdbarch)); h8300_print_register (gdbarch, file, frame, E_PC_REGNUM); - if (is_h8300smode (current_gdbarch)) + if (is_h8300smode (gdbarch)) { - h8300_print_register (gdbarch, file, frame, E_PSEUDO_EXR_REGNUM); - if (is_h8300sxmode (current_gdbarch)) + h8300_print_register (gdbarch, file, frame, + E_PSEUDO_EXR_REGNUM (gdbarch)); + if (is_h8300sxmode (gdbarch)) { h8300_print_register (gdbarch, file, frame, E_SBR_REGNUM); h8300_print_register (gdbarch, file, frame, E_VBR_REGNUM); @@ -1109,10 +1107,12 @@ h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, else { if (regno == E_CCR_REGNUM) - h8300_print_register (gdbarch, file, frame, E_PSEUDO_CCR_REGNUM); - else if (regno == E_PSEUDO_EXR_REGNUM - && is_h8300smode (current_gdbarch)) - h8300_print_register (gdbarch, file, frame, E_PSEUDO_EXR_REGNUM); + h8300_print_register (gdbarch, file, frame, + E_PSEUDO_CCR_REGNUM (gdbarch)); + else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch) + && is_h8300smode (gdbarch)) + h8300_print_register (gdbarch, file, frame, + E_PSEUDO_EXR_REGNUM (gdbarch)); else h8300_print_register (gdbarch, file, frame, regno); } @@ -1121,43 +1121,83 @@ h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file, static struct type * h8300_register_type (struct gdbarch *gdbarch, int regno) { - if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch) - + gdbarch_num_pseudo_regs (current_gdbarch)) + if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch)) internal_error (__FILE__, __LINE__, - "h8300_register_type: illegal register number %d", regno); + _("h8300_register_type: illegal register number %d"), + regno); else { switch (regno) { case E_PC_REGNUM: - return builtin_type_void_func_ptr; + return builtin_type (gdbarch)->builtin_func_ptr; case E_SP_REGNUM: case E_FP_REGNUM: - return builtin_type_void_data_ptr; + return builtin_type (gdbarch)->builtin_data_ptr; default: - if (regno == E_PSEUDO_CCR_REGNUM) - return builtin_type_uint8; - else if (regno == E_PSEUDO_EXR_REGNUM) - return builtin_type_uint8; - else if (is_h8300hmode (current_gdbarch)) - return builtin_type_int32; + if (regno == E_PSEUDO_CCR_REGNUM (gdbarch)) + return builtin_type (gdbarch)->builtin_uint8; + else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch)) + return builtin_type (gdbarch)->builtin_uint8; + else if (is_h8300hmode (gdbarch)) + return builtin_type (gdbarch)->builtin_int32; else - return builtin_type_int16; + return builtin_type (gdbarch)->builtin_int16; } } } +/* Helpers for h8300_pseudo_register_read. We expose ccr/exr as + pseudo-registers to users with smaller sizes than the corresponding + raw registers. These helpers extend/narrow the values. */ + +static enum register_status +pseudo_from_raw_register (struct gdbarch *gdbarch, readable_regcache *regcache, + gdb_byte *buf, int pseudo_regno, int raw_regno) +{ + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum register_status status; + ULONGEST val; + + status = regcache->raw_read (raw_regno, &val); + if (status == REG_VALID) + store_unsigned_integer (buf, + register_size (gdbarch, pseudo_regno), + byte_order, val); + return status; +} + +/* See pseudo_from_raw_register. */ + static void +raw_from_pseudo_register (struct gdbarch *gdbarch, struct regcache *regcache, + const gdb_byte *buf, int raw_regno, int pseudo_regno) +{ + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + ULONGEST val; + + val = extract_unsigned_integer (buf, register_size (gdbarch, pseudo_regno), + byte_order); + regcache_raw_write_unsigned (regcache, raw_regno, val); +} + +static enum register_status h8300_pseudo_register_read (struct gdbarch *gdbarch, - struct regcache *regcache, int regno, + readable_regcache *regcache, int regno, gdb_byte *buf) { - if (regno == E_PSEUDO_CCR_REGNUM) - regcache_raw_read (regcache, E_CCR_REGNUM, buf); - else if (regno == E_PSEUDO_EXR_REGNUM) - regcache_raw_read (regcache, E_EXR_REGNUM, buf); + if (regno == E_PSEUDO_CCR_REGNUM (gdbarch)) + { + return pseudo_from_raw_register (gdbarch, regcache, buf, + regno, E_CCR_REGNUM); + } + else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch)) + { + return pseudo_from_raw_register (gdbarch, regcache, buf, + regno, E_EXR_REGNUM); + } else - regcache_raw_read (regcache, regno, buf); + return regcache->raw_read (regno, buf); } static void @@ -1165,93 +1205,72 @@ h8300_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int regno, const gdb_byte *buf) { - if (regno == E_PSEUDO_CCR_REGNUM) - regcache_raw_write (regcache, E_CCR_REGNUM, buf); - else if (regno == E_PSEUDO_EXR_REGNUM) - regcache_raw_write (regcache, E_EXR_REGNUM, buf); + if (regno == E_PSEUDO_CCR_REGNUM (gdbarch)) + raw_from_pseudo_register (gdbarch, regcache, buf, E_CCR_REGNUM, regno); + else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch)) + raw_from_pseudo_register (gdbarch, regcache, buf, E_EXR_REGNUM, regno); else - regcache_raw_write (regcache, regno, buf); + regcache->raw_write (regno, buf); } static int -h8300_dbg_reg_to_regnum (int regno) +h8300_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno) { if (regno == E_CCR_REGNUM) - return E_PSEUDO_CCR_REGNUM; + return E_PSEUDO_CCR_REGNUM (gdbarch); return regno; } static int -h8300s_dbg_reg_to_regnum (int regno) +h8300s_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno) { if (regno == E_CCR_REGNUM) - return E_PSEUDO_CCR_REGNUM; + return E_PSEUDO_CCR_REGNUM (gdbarch); if (regno == E_EXR_REGNUM) - return E_PSEUDO_EXR_REGNUM; + return E_PSEUDO_EXR_REGNUM (gdbarch); return regno; } -const static unsigned char * -h8300_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) -{ - /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */ - static unsigned char breakpoint[] = { 0x01, 0x80 }; /* Sleep */ - - *lenptr = sizeof (breakpoint); - return breakpoint; -} +/*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */ +constexpr gdb_byte h8300_break_insn[] = { 0x01, 0x80 }; /* Sleep */ -static void -h8300_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, - struct frame_info *frame, const char *args) -{ - fprintf_filtered (file, "\ -No floating-point info available for this processor.\n"); -} +typedef BP_MANIPULATION (h8300_break_insn) h8300_breakpoint; static struct gdbarch * h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { - struct gdbarch_tdep *tdep = NULL; struct gdbarch *gdbarch; arches = gdbarch_list_lookup_by_info (arches, &info); if (arches != NULL) return arches->gdbarch; -#if 0 - tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep)); -#endif - if (info.bfd_arch_info->arch != bfd_arch_h8300) return NULL; gdbarch = gdbarch_alloc (&info, 0); + set_gdbarch_register_sim_regno (gdbarch, h8300_register_sim_regno); + switch (info.bfd_arch_info->mach) { case bfd_mach_h8300: set_gdbarch_num_regs (gdbarch, 13); set_gdbarch_num_pseudo_regs (gdbarch, 1); - set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); - set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); set_gdbarch_register_name (gdbarch, h8300_register_name); set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT); set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT); set_gdbarch_return_value (gdbarch, h8300_return_value); - set_gdbarch_print_insn (gdbarch, print_insn_h8300); break; case bfd_mach_h8300h: case bfd_mach_h8300hn: set_gdbarch_num_regs (gdbarch, 13); set_gdbarch_num_pseudo_regs (gdbarch, 1); - set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); - set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum); - set_gdbarch_register_name (gdbarch, h8300_register_name); + set_gdbarch_register_name (gdbarch, h8300h_register_name); if (info.bfd_arch_info->mach != bfd_mach_h8300hn) { set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT); @@ -1263,14 +1282,11 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT); } set_gdbarch_return_value (gdbarch, h8300h_return_value); - set_gdbarch_print_insn (gdbarch, print_insn_h8300h); break; case bfd_mach_h8300s: case bfd_mach_h8300sn: set_gdbarch_num_regs (gdbarch, 16); set_gdbarch_num_pseudo_regs (gdbarch, 2); - set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); - set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); set_gdbarch_register_name (gdbarch, h8300s_register_name); @@ -1285,14 +1301,11 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT); } set_gdbarch_return_value (gdbarch, h8300h_return_value); - set_gdbarch_print_insn (gdbarch, print_insn_h8300s); break; case bfd_mach_h8300sx: case bfd_mach_h8300sxn: set_gdbarch_num_regs (gdbarch, 18); set_gdbarch_num_pseudo_regs (gdbarch, 2); - set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); - set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum); set_gdbarch_register_name (gdbarch, h8300sx_register_name); @@ -1307,7 +1320,6 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT); } set_gdbarch_return_value (gdbarch, h8300h_return_value); - set_gdbarch_print_insn (gdbarch, print_insn_h8300s); break; } @@ -1322,7 +1334,6 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM); set_gdbarch_register_type (gdbarch, h8300_register_type); set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info); - set_gdbarch_print_float_info (gdbarch, h8300_print_float_info); /* * Frame Info @@ -1330,41 +1341,46 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue); /* Frame unwinder. */ - set_gdbarch_unwind_pc (gdbarch, h8300_unwind_pc); - set_gdbarch_unwind_sp (gdbarch, h8300_unwind_sp); - set_gdbarch_unwind_dummy_id (gdbarch, h8300_unwind_dummy_id); frame_base_set_default (gdbarch, &h8300_frame_base); /* - * Miscelany + * Miscellany */ - /* Stack grows up. */ + /* Stack grows up. */ set_gdbarch_inner_than (gdbarch, core_addr_lessthan); - set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, + h8300_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, + h8300_breakpoint::bp_from_kind); set_gdbarch_push_dummy_call (gdbarch, h8300_push_dummy_call); set_gdbarch_char_signed (gdbarch, 0); set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT); set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT); set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT); + + set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT); + set_gdbarch_wchar_signed (gdbarch, 0); + set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); + set_gdbarch_double_format (gdbarch, floatformats_ieee_single); set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT); + set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single); set_gdbarch_believe_pcc_promotion (gdbarch, 1); /* Hook in the DWARF CFI frame unwinder. */ - frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); - frame_unwind_append_sniffer (gdbarch, h8300_frame_sniffer); + dwarf2_append_unwinders (gdbarch); + frame_unwind_append_unwinder (gdbarch, &h8300_frame_unwind); return gdbarch; } -extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */ - +void _initialize_h8300_tdep (); void -_initialize_h8300_tdep (void) +_initialize_h8300_tdep () { register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init); }