X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm32c-tdep.c;h=45dc4383fb236cfa1734770076cbb072b7ce4f99;hb=11f57cb67ecf5c69911eff21b54e05e93bbf2734;hp=ab123c8563065ad7e4bdc00dd4b210379e0b7e6d;hpb=6d3d12ebef6fa7dd6bc8c34fbc5e440ac8d0a8c6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index ab123c8563..45dc4383fb 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -1,6 +1,6 @@ /* Renesas M32C target-dependent code for GDB, the GNU debugger. - Copyright (C) 2004-2014 Free Software Foundation, Inc. + Copyright (C) 2004-2018 Free Software Foundation, Inc. This file is part of GDB. @@ -46,9 +46,13 @@ struct m32c_reg; /* The type of a function that moves the value of REG between CACHE or BUF --- in either direction. */ -typedef enum register_status (m32c_move_reg_t) (struct m32c_reg *reg, +typedef enum register_status (m32c_write_reg_t) (struct m32c_reg *reg, + struct regcache *cache, + const gdb_byte *buf); + +typedef enum register_status (m32c_read_reg_t) (struct m32c_reg *reg, struct regcache *cache, - void *buf); + gdb_byte *buf); struct m32c_reg { @@ -78,7 +82,8 @@ struct m32c_reg /* Functions to read its value from a regcache, and write its value to a regcache. */ - m32c_move_reg_t *read, *write; + m32c_read_reg_t *read; + m32c_write_reg_t *write; /* Data for READ and WRITE functions. The exact meaning depends on the specific functions selected; see the comments for those @@ -185,29 +190,20 @@ make_types (struct gdbarch *arch) /* The builtin_type_mumble variables are sometimes uninitialized when this is called, so we avoid using them. */ - tdep->voyd = arch_type (arch, TYPE_CODE_VOID, 1, "void"); + tdep->voyd = arch_type (arch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void"); tdep->ptr_voyd - = arch_type (arch, TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / TARGET_CHAR_BIT, - NULL); - TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd; - TYPE_UNSIGNED (tdep->ptr_voyd) = 1; + = arch_pointer_type (arch, gdbarch_ptr_bit (arch), NULL, tdep->voyd); tdep->func_voyd = lookup_function_type (tdep->voyd); xsnprintf (type_name, sizeof (type_name), "%s_data_addr_t", gdbarch_bfd_arch_info (arch)->printable_name); tdep->data_addr_reg_type - = arch_type (arch, TYPE_CODE_PTR, data_addr_reg_bits / TARGET_CHAR_BIT, - xstrdup (type_name)); - TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd; - TYPE_UNSIGNED (tdep->data_addr_reg_type) = 1; + = arch_pointer_type (arch, data_addr_reg_bits, type_name, tdep->voyd); xsnprintf (type_name, sizeof (type_name), "%s_code_addr_t", gdbarch_bfd_arch_info (arch)->printable_name); tdep->code_addr_reg_type - = arch_type (arch, TYPE_CODE_PTR, code_addr_reg_bits / TARGET_CHAR_BIT, - xstrdup (type_name)); - TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd; - TYPE_UNSIGNED (tdep->code_addr_reg_type) = 1; + = arch_pointer_type (arch, code_addr_reg_bits, type_name, tdep->func_voyd); tdep->uint8 = arch_integer_type (arch, 8, 1, "uint8_t"); tdep->uint16 = arch_integer_type (arch, 16, 1, "uint16_t"); @@ -297,28 +293,35 @@ m32c_register_reggroup_p (struct gdbarch *gdbarch, int regnum, /* Register move functions. We declare them here using - m32c_move_reg_t to check the types. */ -static m32c_move_reg_t m32c_raw_read, m32c_raw_write; -static m32c_move_reg_t m32c_banked_read, m32c_banked_write; -static m32c_move_reg_t m32c_sb_read, m32c_sb_write; -static m32c_move_reg_t m32c_part_read, m32c_part_write; -static m32c_move_reg_t m32c_cat_read, m32c_cat_write; -static m32c_move_reg_t m32c_r3r2r1r0_read, m32c_r3r2r1r0_write; - + m32c_{read,write}_reg_t to check the types. */ +static m32c_read_reg_t m32c_raw_read; +static m32c_read_reg_t m32c_banked_read; +static m32c_read_reg_t m32c_sb_read; +static m32c_read_reg_t m32c_part_read; +static m32c_read_reg_t m32c_cat_read; +static m32c_read_reg_t m32c_r3r2r1r0_read; + +static m32c_write_reg_t m32c_raw_write; +static m32c_write_reg_t m32c_banked_write; +static m32c_write_reg_t m32c_sb_write; +static m32c_write_reg_t m32c_part_write; +static m32c_write_reg_t m32c_cat_write; +static m32c_write_reg_t m32c_r3r2r1r0_write; /* Copy the value of the raw register REG from CACHE to BUF. */ static enum register_status -m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf) { - return regcache_raw_read (cache, reg->num, buf); + return cache->raw_read (reg->num, buf); } /* Copy the value of the raw register REG from BUF to CACHE. */ static enum register_status -m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, + const gdb_byte *buf) { - regcache_raw_write (cache, reg->num, (const void *) buf); + regcache_raw_write (cache, reg->num, buf); return REG_VALID; } @@ -328,9 +331,10 @@ m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, void *buf) static int m32c_read_flg (struct regcache *cache) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (cache)); + struct gdbarch_tdep *tdep = gdbarch_tdep (cache->arch ()); ULONGEST flg; - regcache_raw_read_unsigned (cache, tdep->flg->num, &flg); + + cache->raw_read (tdep->flg->num, &flg); return flg & 0xffff; } @@ -348,10 +352,10 @@ m32c_banked_register (struct m32c_reg *reg, struct regcache *cache) masked in REG->n set, then read REG->ry. Otherwise, read REG->rx. */ static enum register_status -m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf) { struct m32c_reg *bank_reg = m32c_banked_register (reg, cache); - return regcache_raw_read (cache, bank_reg->num, buf); + return cache->raw_read (bank_reg->num, buf); } @@ -360,10 +364,11 @@ m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf) masked in REG->n set, then write REG->ry. Otherwise, write REG->rx. */ static enum register_status -m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, + const gdb_byte *buf) { struct m32c_reg *bank_reg = m32c_banked_register (reg, cache); - regcache_raw_write (cache, bank_reg->num, (const void *) buf); + regcache_raw_write (cache, bank_reg->num, buf); return REG_VALID; } @@ -372,7 +377,7 @@ m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, void *buf) /* Move the value of SB from CACHE to BUF. On bfd_mach_m32c, SB is a banked register; on bfd_mach_m16c, it's not. */ static enum register_status -m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf) { if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c) return m32c_raw_read (reg->rx, cache, buf); @@ -384,7 +389,7 @@ m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, void *buf) /* Move the value of SB from BUF to CACHE. On bfd_mach_m32c, SB is a banked register; on bfd_mach_m16c, it's not. */ static enum register_status -m32c_sb_write (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_sb_write (struct m32c_reg *reg, struct regcache *cache, const gdb_byte *buf) { if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c) m32c_raw_write (reg->rx, cache, buf); @@ -437,13 +442,13 @@ m32c_find_part (struct m32c_reg *reg, int *offset_p, int *len_p) REG->type values, where higher indices refer to more significant bits, read the value of the REG->n'th element. */ static enum register_status -m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_part_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf) { int offset, len; memset (buf, 0, TYPE_LENGTH (reg->type)); m32c_find_part (reg, &offset, &len); - return regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf); + return cache->cooked_read_part (reg->rx->num, offset, len, buf); } @@ -452,7 +457,8 @@ m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf) values, where higher indices refer to more significant bits, write the value of the REG->n'th element. */ static enum register_status -m32c_part_write (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_part_write (struct m32c_reg *reg, struct regcache *cache, + const gdb_byte *buf) { int offset, len; @@ -467,29 +473,26 @@ m32c_part_write (struct m32c_reg *reg, struct regcache *cache, void *buf) concatenation of the values of the registers REG->rx and REG->ry, with REG->rx contributing the more significant bits. */ static enum register_status -m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf) { int high_bytes = TYPE_LENGTH (reg->rx->type); int low_bytes = TYPE_LENGTH (reg->ry->type); - /* For address arithmetic. */ - unsigned char *cbuf = buf; enum register_status status; gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes); if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - status = regcache_cooked_read (cache, reg->rx->num, cbuf); + status = cache->cooked_read (reg->rx->num, buf); if (status == REG_VALID) - status = regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes); + status = cache->cooked_read (reg->ry->num, buf + high_bytes); } else { - status = regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes); + status = cache->cooked_read (reg->rx->num, buf + low_bytes); if (status == REG_VALID) - status = regcache_cooked_read (cache, reg->ry->num, cbuf); + status = cache->cooked_read (reg->ry->num, buf); } - return status; } @@ -498,24 +501,23 @@ m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, void *buf) concatenation of the values of the registers REG->rx and REG->ry, with REG->rx contributing the more significant bits. */ static enum register_status -m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, + const gdb_byte *buf) { int high_bytes = TYPE_LENGTH (reg->rx->type); int low_bytes = TYPE_LENGTH (reg->ry->type); - /* For address arithmetic. */ - unsigned char *cbuf = buf; gdb_assert (TYPE_LENGTH (reg->type) == high_bytes + low_bytes); if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - regcache_cooked_write (cache, reg->rx->num, cbuf); - regcache_cooked_write (cache, reg->ry->num, cbuf + high_bytes); + regcache_cooked_write (cache, reg->rx->num, buf); + regcache_cooked_write (cache, reg->ry->num, buf + high_bytes); } else { - regcache_cooked_write (cache, reg->rx->num, cbuf + low_bytes); - regcache_cooked_write (cache, reg->ry->num, cbuf); + regcache_cooked_write (cache, reg->rx->num, buf + low_bytes); + regcache_cooked_write (cache, reg->ry->num, buf); } return REG_VALID; @@ -526,34 +528,31 @@ m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf) the concatenation (from most significant to least) of r3, r2, r1, and r0. */ static enum register_status -m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, gdb_byte *buf) { struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch); int len = TYPE_LENGTH (tdep->r0->type); enum register_status status; - /* For address arithmetic. */ - unsigned char *cbuf = buf; - if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - status = regcache_cooked_read (cache, tdep->r0->num, cbuf + len * 3); + status = cache->cooked_read (tdep->r0->num, buf + len * 3); if (status == REG_VALID) - status = regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2); + status = cache->cooked_read (tdep->r1->num, buf + len * 2); if (status == REG_VALID) - status = regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1); + status = cache->cooked_read (tdep->r2->num, buf + len * 1); if (status == REG_VALID) - status = regcache_cooked_read (cache, tdep->r3->num, cbuf); + status = cache->cooked_read (tdep->r3->num, buf); } else { - status = regcache_cooked_read (cache, tdep->r0->num, cbuf); + status = cache->cooked_read (tdep->r0->num, buf); if (status == REG_VALID) - status = regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1); + status = cache->cooked_read (tdep->r1->num, buf + len * 1); if (status == REG_VALID) - status = regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2); + status = cache->cooked_read (tdep->r2->num, buf + len * 2); if (status == REG_VALID) - status = regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3); + status = cache->cooked_read (tdep->r3->num, buf + len * 3); } return status; @@ -564,27 +563,25 @@ m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, void *buf) the concatenation (from most significant to least) of r3, r2, r1, and r0. */ static enum register_status -m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, void *buf) +m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, + const gdb_byte *buf) { struct gdbarch_tdep *tdep = gdbarch_tdep (reg->arch); int len = TYPE_LENGTH (tdep->r0->type); - /* For address arithmetic. */ - unsigned char *cbuf = buf; - if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG) { - regcache_cooked_write (cache, tdep->r0->num, cbuf + len * 3); - regcache_cooked_write (cache, tdep->r1->num, cbuf + len * 2); - regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 1); - regcache_cooked_write (cache, tdep->r3->num, cbuf); + regcache_cooked_write (cache, tdep->r0->num, buf + len * 3); + regcache_cooked_write (cache, tdep->r1->num, buf + len * 2); + regcache_cooked_write (cache, tdep->r2->num, buf + len * 1); + regcache_cooked_write (cache, tdep->r3->num, buf); } else { - regcache_cooked_write (cache, tdep->r0->num, cbuf); - regcache_cooked_write (cache, tdep->r1->num, cbuf + len * 1); - regcache_cooked_write (cache, tdep->r2->num, cbuf + len * 2); - regcache_cooked_write (cache, tdep->r3->num, cbuf + len * 3); + regcache_cooked_write (cache, tdep->r0->num, buf); + regcache_cooked_write (cache, tdep->r1->num, buf + len * 1); + regcache_cooked_write (cache, tdep->r2->num, buf + len * 2); + regcache_cooked_write (cache, tdep->r3->num, buf + len * 3); } return REG_VALID; @@ -601,7 +598,7 @@ m32c_pseudo_register_read (struct gdbarch *arch, struct m32c_reg *reg; gdb_assert (0 <= cookednum && cookednum < tdep->num_regs); - gdb_assert (arch == get_regcache_arch (cache)); + gdb_assert (arch == cache->arch ()); gdb_assert (arch == tdep->regs[cookednum].arch); reg = &tdep->regs[cookednum]; @@ -619,11 +616,11 @@ m32c_pseudo_register_write (struct gdbarch *arch, struct m32c_reg *reg; gdb_assert (0 <= cookednum && cookednum < tdep->num_regs); - gdb_assert (arch == get_regcache_arch (cache)); + gdb_assert (arch == cache->arch ()); gdb_assert (arch == tdep->regs[cookednum].arch); reg = &tdep->regs[cookednum]; - reg->write (reg, cache, (void *) buf); + reg->write (reg, cache, buf); } @@ -634,8 +631,8 @@ add_reg (struct gdbarch *arch, const char *name, struct type *type, int sim_num, - m32c_move_reg_t *read, - m32c_move_reg_t *write, + m32c_read_reg_t *read, + m32c_write_reg_t *write, struct m32c_reg *rx, struct m32c_reg *ry, int n) @@ -817,9 +814,6 @@ make_regs (struct gdbarch *arch) struct m32c_reg *sp; struct m32c_reg *r0hl; struct m32c_reg *r1hl; - struct m32c_reg *r2hl; - struct m32c_reg *r3hl; - struct m32c_reg *intbhl; struct m32c_reg *r2r0; struct m32c_reg *r3r1; struct m32c_reg *r3r1r2r0; @@ -883,9 +877,9 @@ make_regs (struct gdbarch *arch) r0hl = CHL (r0, tdep->int8); r1hl = CHL (r1, tdep->int8); - r2hl = CHL (r2, tdep->int8); - r3hl = CHL (r3, tdep->int8); - intbhl = CHL (intb, tdep->int16); + CHL (r2, tdep->int8); + CHL (r3, tdep->int8); + CHL (intb, tdep->int16); r2r0 = CCAT (r2, r0, tdep->int32); r3r1 = CCAT (r3, r1, tdep->int32); @@ -996,20 +990,26 @@ make_regs (struct gdbarch *arch) /* Breakpoints. */ +constexpr gdb_byte m32c_break_insn[] = { 0x00 }; /* brk */ -static const unsigned char * -m32c_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len) -{ - static unsigned char break_insn[] = { 0x00 }; /* brk */ - - *len = sizeof (break_insn); - return break_insn; -} - +typedef BP_MANIPULATION (m32c_break_insn) m32c_breakpoint; /* Prologue analysis. */ +enum m32c_prologue_kind +{ + /* This function uses a frame pointer. */ + prologue_with_frame_ptr, + + /* This function has no frame pointer. */ + prologue_sans_frame_ptr, + + /* This function sets up the stack, so its frame is the first + frame on the stack. */ + prologue_first_frame +}; + struct m32c_prologue { /* For consistency with the DWARF 2 .debug_frame info generated by @@ -1019,18 +1019,7 @@ struct m32c_prologue /* The architecture for which we generated this prologue info. */ struct gdbarch *arch; - enum { - /* This function uses a frame pointer. */ - prologue_with_frame_ptr, - - /* This function has no frame pointer. */ - prologue_sans_frame_ptr, - - /* This function sets up the stack, so its frame is the first - frame on the stack. */ - prologue_first_frame - - } kind; + enum m32c_prologue_kind kind; /* If KIND is prologue_with_frame_ptr, this is the offset from the CFA to where the frame pointer points. This is always zero or @@ -1090,16 +1079,23 @@ struct m32c_pv_state static int m32c_pv_push (struct m32c_pv_state *state, pv_t value, int size) { - if (pv_area_store_would_trash (state->stack, state->sp)) + if (state->stack->store_would_trash (state->sp)) return 1; state->sp = pv_add_constant (state->sp, -size); - pv_area_store (state->stack, state->sp, size, value); + state->stack->store (state->sp, size, value); return 0; } +enum srcdest_kind +{ + srcdest_reg, + srcdest_partial_reg, + srcdest_mem +}; + /* A source or destination location for an m16c or m32c instruction. */ struct srcdest @@ -1108,7 +1104,7 @@ struct srcdest If srcdest_partial_reg, the location is part of a register pointed to by REG. We don't try to handle this too well. If srcdest_mem, the location is memory whose address is ADDR. */ - enum { srcdest_reg, srcdest_partial_reg, srcdest_mem } kind; + enum srcdest_kind kind; pv_t *reg, addr; }; @@ -1118,7 +1114,7 @@ static pv_t m32c_srcdest_fetch (struct m32c_pv_state *state, struct srcdest loc, int size) { if (loc.kind == srcdest_mem) - return pv_area_fetch (state->stack, loc.addr, size); + return state->stack->fetch (loc.addr, size); else if (loc.kind == srcdest_partial_reg) return pv_unknown (); else @@ -1135,9 +1131,9 @@ m32c_srcdest_store (struct m32c_pv_state *state, struct srcdest loc, { if (loc.kind == srcdest_mem) { - if (pv_area_store_would_trash (state->stack, loc.addr)) + if (state->stack->store_would_trash (loc.addr)) return 1; - pv_area_store (state->stack, loc.addr, size, value); + state->stack->store (loc.addr, size, value); } else if (loc.kind == srcdest_partial_reg) *loc.reg = pv_unknown (); @@ -1354,7 +1350,7 @@ m32c_pv_enter (struct m32c_pv_state *state, int size) /* If simulating this store would require us to forget everything we know about the stack frame in the name of accuracy, it would be better to just quit now. */ - if (pv_area_store_would_trash (state->stack, state->sp)) + if (state->stack->store_would_trash (state->sp)) return 1; if (m32c_pv_push (state, state->fb, tdep->push_addr_bytes)) @@ -1445,7 +1441,7 @@ m32c_is_arg_spill (struct m32c_pv_state *st, return (m32c_is_arg_reg (st, value) && loc.kind == srcdest_mem && pv_is_register (loc.addr, tdep->sp->num) - && ! pv_area_find_reg (st->stack, st->arch, value.reg, 0)); + && ! st->stack->find_reg (st->arch, value.reg, 0)); } /* Return non-zero if a store of VALUE to LOC is probably @@ -1466,7 +1462,7 @@ m32c_is_struct_return (struct m32c_pv_state *st, struct gdbarch_tdep *tdep = gdbarch_tdep (st->arch); return (m32c_is_1st_arg_reg (st, value) - && !pv_area_find_reg (st->stack, st->arch, value.reg, 0) + && !st->stack->find_reg (st->arch, value.reg, 0) && loc.kind == srcdest_reg && (pv_is_register (*loc.reg, tdep->a0->num) || pv_is_register (*loc.reg, tdep->a1->num))); @@ -1497,7 +1493,7 @@ m32c_pushm_is_reg_save (struct m32c_pv_state *st, int src) /* Function for finding saved registers in a 'struct pv_area'; we pass - this to pv_area_scan. + this to pv_area::scan. If VALUE is a saved register, ADDR says it was saved at a constant offset from the frame base, and SIZE indicates that the whole @@ -1550,7 +1546,6 @@ m32c_analyze_prologue (struct gdbarch *arch, struct gdbarch_tdep *tdep = gdbarch_tdep (arch); unsigned long mach = gdbarch_bfd_arch_info (arch)->mach; CORE_ADDR after_last_frame_related_insn; - struct cleanup *back_to; struct m32c_pv_state st; st.arch = arch; @@ -1564,8 +1559,8 @@ m32c_analyze_prologue (struct gdbarch *arch, st.fb = pv_register (tdep->fb->num, 0); st.sp = pv_register (tdep->sp->num, 0); st.pc = pv_register (tdep->pc->num, 0); - st.stack = make_pv_area (tdep->sp->num, gdbarch_addr_bit (arch)); - back_to = make_cleanup_free_pv_area (st.stack); + pv_area stack (tdep->sp->num, gdbarch_addr_bit (arch)); + st.stack = &stack; /* Record that the call instruction has saved the return address on the stack. */ @@ -1816,11 +1811,9 @@ m32c_analyze_prologue (struct gdbarch *arch, prologue->kind = prologue_first_frame; /* Record where all the registers were saved. */ - pv_area_scan (st.stack, check_for_saved, (void *) prologue); + st.stack->scan (check_for_saved, (void *) prologue); prologue->prologue_end = after_last_frame_related_insn; - - do_cleanups (back_to); } @@ -1866,10 +1859,11 @@ m32c_analyze_frame_prologue (struct frame_info *this_frame, *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue); m32c_analyze_prologue (get_frame_arch (this_frame), - func_start, stop_addr, *this_prologue_cache); + func_start, stop_addr, + (struct m32c_prologue *) *this_prologue_cache); } - return *this_prologue_cache; + return (struct m32c_prologue *) *this_prologue_cache; } @@ -1933,7 +1927,6 @@ m32c_prev_register (struct frame_info *this_frame, struct m32c_prologue *p = m32c_analyze_frame_prologue (this_frame, this_prologue_cache); CORE_ADDR frame_base = m32c_frame_base (this_frame, this_prologue_cache); - int reg_size = register_size (get_frame_arch (this_frame), regnum); if (regnum == tdep->sp->num) return frame_unwind_got_constant (this_frame, regnum, frame_base); @@ -2015,7 +2008,7 @@ m32c_reg_arg_type (struct type *type) return (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM || code == TYPE_CODE_PTR - || code == TYPE_CODE_REF + || TYPE_IS_REFERENCE (type) || code == TYPE_CODE_BOOL || code == TYPE_CODE_CHAR); } @@ -2437,8 +2430,7 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch, { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum type_code target_code; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || - TYPE_CODE (type) == TYPE_CODE_REF); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)); target_code = TYPE_CODE (TYPE_TARGET_TYPE (type)); @@ -2458,7 +2450,7 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch, paddress (gdbarch, addr)); func_name = MSYMBOL_LINKAGE_NAME (func_msym.minsym); - tramp_name = xmalloc (strlen (func_name) + 5); + tramp_name = (char *) xmalloc (strlen (func_name) + 5); strcpy (tramp_name, func_name); strcat (tramp_name, ".plt"); @@ -2517,8 +2509,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch, CORE_ADDR ptr; enum type_code target_code; - gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || - TYPE_CODE (type) == TYPE_CODE_REF); + gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type)); ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); @@ -2545,7 +2536,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch, Since the trampoline contains a jump instruction, we could also just extract the jump's target address. I don't see much advantage one way or the other. */ - char *func_name = xmalloc (len - 4 + 1); + char *func_name = (char *) xmalloc (len - 4 + 1); memcpy (func_name, ptr_msym_name, len - 4); func_name[len - 4] = '\0'; func_msym @@ -2618,7 +2609,7 @@ m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc, static struct gdbarch * m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { - struct gdbarch *arch; + struct gdbarch *gdbarch; struct gdbarch_tdep *tdep; unsigned long mach = info.bfd_arch_info->mach; @@ -2629,52 +2620,50 @@ m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) arches = gdbarch_list_lookup_by_info (arches->next, &info)) return arches->gdbarch; - tdep = xcalloc (1, sizeof (*tdep)); - arch = gdbarch_alloc (&info, tdep); + tdep = XCNEW (struct gdbarch_tdep); + gdbarch = gdbarch_alloc (&info, tdep); /* Essential types. */ - make_types (arch); + make_types (gdbarch); /* Address/pointer conversions. */ if (mach == bfd_mach_m16c) { - set_gdbarch_address_to_pointer (arch, m32c_m16c_address_to_pointer); - set_gdbarch_pointer_to_address (arch, m32c_m16c_pointer_to_address); + set_gdbarch_address_to_pointer (gdbarch, m32c_m16c_address_to_pointer); + set_gdbarch_pointer_to_address (gdbarch, m32c_m16c_pointer_to_address); } /* Register set. */ - make_regs (arch); - - /* Disassembly. */ - set_gdbarch_print_insn (arch, print_insn_m32c); + make_regs (gdbarch); /* Breakpoints. */ - set_gdbarch_breakpoint_from_pc (arch, m32c_breakpoint_from_pc); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, m32c_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, m32c_breakpoint::bp_from_kind); /* Prologue analysis and unwinding. */ - set_gdbarch_inner_than (arch, core_addr_lessthan); - set_gdbarch_skip_prologue (arch, m32c_skip_prologue); - set_gdbarch_unwind_pc (arch, m32c_unwind_pc); - set_gdbarch_unwind_sp (arch, m32c_unwind_sp); + set_gdbarch_inner_than (gdbarch, core_addr_lessthan); + set_gdbarch_skip_prologue (gdbarch, m32c_skip_prologue); + set_gdbarch_unwind_pc (gdbarch, m32c_unwind_pc); + set_gdbarch_unwind_sp (gdbarch, m32c_unwind_sp); #if 0 /* I'm dropping the dwarf2 sniffer because it has a few problems. They may be in the dwarf2 cfi code in GDB, or they may be in the debug info emitted by the upstream toolchain. I don't know which, but I do know that the prologue analyzer works better. MVS 04/13/06 */ - dwarf2_append_sniffers (arch); + dwarf2_append_sniffers (gdbarch); #endif - frame_unwind_append_unwinder (arch, &m32c_unwind); + frame_unwind_append_unwinder (gdbarch, &m32c_unwind); /* Inferior calls. */ - set_gdbarch_push_dummy_call (arch, m32c_push_dummy_call); - set_gdbarch_return_value (arch, m32c_return_value); - set_gdbarch_dummy_id (arch, m32c_dummy_id); + set_gdbarch_push_dummy_call (gdbarch, m32c_push_dummy_call); + set_gdbarch_return_value (gdbarch, m32c_return_value); + set_gdbarch_dummy_id (gdbarch, m32c_dummy_id); /* Trampolines. */ - set_gdbarch_skip_trampoline_code (arch, m32c_skip_trampoline_code); + set_gdbarch_skip_trampoline_code (gdbarch, m32c_skip_trampoline_code); - set_gdbarch_virtual_frame_pointer (arch, m32c_virtual_frame_pointer); + set_gdbarch_virtual_frame_pointer (gdbarch, m32c_virtual_frame_pointer); /* m32c function boundary addresses are not necessarily even. Therefore, the `vbit', which indicates a pointer to a virtual @@ -2684,14 +2673,11 @@ m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) In order to verify this, see the definition of TARGET_PTRMEMFUNC_VBIT_LOCATION in gcc/defaults.h along with the definition of FUNCTION_BOUNDARY in gcc/config/m32c/m32c.h. */ - set_gdbarch_vbit_in_delta (arch, 1); + set_gdbarch_vbit_in_delta (gdbarch, 1); - return arch; + return gdbarch; } -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_m32c_tdep; - void _initialize_m32c_tdep (void) {