X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fm32c-tdep.c;h=d579616b06aa4a14b99362e78e50aa962fa09167;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=5c8f4fbc381f9cc3c810b9390d931dbc2fd23a11;hpb=7b9ee6a80648a8e8bb30090d76035605299f805d;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index 5c8f4fbc38..d579616b06 100644
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -1,12 +1,12 @@
/* Renesas M32C target-dependent code for GDB, the GNU debugger.
- Copyright 2004, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2004-2020 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -15,19 +15,9 @@
GNU General Public License for more details.
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. */
+ along with this program. If not, see . */
#include "defs.h"
-
-#include
-
-#if defined (HAVE_STRING_H)
-#include
-#endif
-
-#include "gdb_assert.h"
#include "elf-bfd.h"
#include "elf/m32c.h"
#include "gdb/sim-m32c.h"
@@ -37,14 +27,15 @@
#include "arch-utils.h"
#include "frame.h"
#include "frame-unwind.h"
-#include "dwarf2-frame.h"
-#include "dwarf2expr.h"
+#include "dwarf2/frame.h"
+#include "dwarf2/expr.h"
#include "symtab.h"
#include "gdbcore.h"
#include "value.h"
#include "reggroups.h"
#include "prologue-value.h"
#include "target.h"
+#include "objfiles.h"
/* The m32c tdep structure. */
@@ -55,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 void (m32c_move_reg_t) (struct m32c_reg *reg,
- struct regcache *cache,
- void *buf);
+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,
+ readable_regcache *cache,
+ gdb_byte *buf);
struct m32c_reg
{
@@ -87,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
@@ -189,39 +185,32 @@ make_types (struct gdbarch *arch)
break;
default:
- gdb_assert (0);
+ gdb_assert_not_reached ("unexpected mach");
}
/* The builtin_type_mumble variables are sometimes uninitialized when
this is called, so we avoid using them. */
- tdep->voyd = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
- tdep->ptr_voyd = init_type (TYPE_CODE_PTR, gdbarch_ptr_bit (arch) / 8,
- TYPE_FLAG_UNSIGNED, NULL, NULL);
- TYPE_TARGET_TYPE (tdep->ptr_voyd) = tdep->voyd;
+ tdep->voyd = arch_type (arch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
+ tdep->ptr_voyd
+ = arch_pointer_type (arch, gdbarch_ptr_bit (arch), NULL, tdep->voyd);
tdep->func_voyd = lookup_function_type (tdep->voyd);
- sprintf (type_name, "%s_data_addr_t",
- gdbarch_bfd_arch_info (arch)->printable_name);
+ xsnprintf (type_name, sizeof (type_name), "%s_data_addr_t",
+ gdbarch_bfd_arch_info (arch)->printable_name);
tdep->data_addr_reg_type
- = init_type (TYPE_CODE_PTR, data_addr_reg_bits / 8,
- TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL);
- TYPE_TARGET_TYPE (tdep->data_addr_reg_type) = tdep->voyd;
+ = arch_pointer_type (arch, data_addr_reg_bits, type_name, tdep->voyd);
- sprintf (type_name, "%s_code_addr_t",
- gdbarch_bfd_arch_info (arch)->printable_name);
+ xsnprintf (type_name, sizeof (type_name), "%s_code_addr_t",
+ gdbarch_bfd_arch_info (arch)->printable_name);
tdep->code_addr_reg_type
- = init_type (TYPE_CODE_PTR, code_addr_reg_bits / 8,
- TYPE_FLAG_UNSIGNED, xstrdup (type_name), NULL);
- TYPE_TARGET_TYPE (tdep->code_addr_reg_type) = tdep->func_voyd;
+ = arch_pointer_type (arch, code_addr_reg_bits, type_name, tdep->func_voyd);
- tdep->uint8 = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
- "uint8_t", NULL);
- tdep->uint16 = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
- "uint16_t", NULL);
- tdep->int8 = init_type (TYPE_CODE_INT, 1, 0, "int8_t", NULL);
- tdep->int16 = init_type (TYPE_CODE_INT, 2, 0, "int16_t", NULL);
- tdep->int32 = init_type (TYPE_CODE_INT, 4, 0, "int32_t", NULL);
- tdep->int64 = init_type (TYPE_CODE_INT, 8, 0, "int64_t", NULL);
+ tdep->uint8 = arch_integer_type (arch, 8, 1, "uint8_t");
+ tdep->uint16 = arch_integer_type (arch, 16, 1, "uint16_t");
+ tdep->int8 = arch_integer_type (arch, 8, 0, "int8_t");
+ tdep->int16 = arch_integer_type (arch, 16, 0, "int16_t");
+ tdep->int32 = arch_integer_type (arch, 32, 0, "int32_t");
+ tdep->int64 = arch_integer_type (arch, 64, 0, "int64_t");
}
@@ -229,9 +218,9 @@ make_types (struct gdbarch *arch)
/* Register set. */
static const char *
-m32c_register_name (int num)
+m32c_register_name (struct gdbarch *gdbarch, int num)
{
- return gdbarch_tdep (current_gdbarch)->regs[num].name;
+ return gdbarch_tdep (gdbarch)->regs[num].name;
}
@@ -243,16 +232,16 @@ m32c_register_type (struct gdbarch *arch, int reg_nr)
static int
-m32c_register_sim_regno (int reg_nr)
+m32c_register_sim_regno (struct gdbarch *gdbarch, int reg_nr)
{
- return gdbarch_tdep (current_gdbarch)->regs[reg_nr].sim_num;
+ return gdbarch_tdep (gdbarch)->regs[reg_nr].sim_num;
}
static int
-m32c_debug_info_reg_to_regnum (int reg_nr)
+m32c_debug_info_reg_to_regnum (struct gdbarch *gdbarch, int reg_nr)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (0 <= reg_nr && reg_nr <= M32C_MAX_DWARF_REGNUM
&& tdep->dwarf_regs[reg_nr])
return tdep->dwarf_regs[reg_nr]->num;
@@ -263,11 +252,11 @@ m32c_debug_info_reg_to_regnum (int reg_nr)
}
-int
+static int
m32c_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
struct reggroup *group)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
struct m32c_reg *reg = &tdep->regs[regnum];
/* The anonymous raw registers aren't in any groups. */
@@ -304,45 +293,55 @@ 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 void
-m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_raw_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
- 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 void
-m32c_raw_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_raw_write (struct m32c_reg *reg, struct regcache *cache,
+ const gdb_byte *buf)
{
- regcache_raw_write (cache, reg->num, (const void *) buf);
+ cache->raw_write (reg->num, buf);
+
+ return REG_VALID;
}
/* Return the value of the 'flg' register in CACHE. */
static int
-m32c_read_flg (struct regcache *cache)
+m32c_read_flg (readable_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;
}
/* Evaluate the real register number of a banked register. */
static struct m32c_reg *
-m32c_banked_register (struct m32c_reg *reg, struct regcache *cache)
+m32c_banked_register (struct m32c_reg *reg, readable_regcache *cache)
{
return ((m32c_read_flg (cache) & reg->n) ? reg->ry : reg->rx);
}
@@ -352,11 +351,11 @@ m32c_banked_register (struct m32c_reg *reg, struct regcache *cache)
If the value of the 'flg' register in CACHE has any of the bits
masked in REG->n set, then read REG->ry. Otherwise, read
REG->rx. */
-static void
-m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_banked_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
struct m32c_reg *bank_reg = m32c_banked_register (reg, cache);
- regcache_raw_read (cache, bank_reg->num, buf);
+ return cache->raw_read (bank_reg->num, buf);
}
@@ -364,35 +363,40 @@ m32c_banked_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
If the value of the 'flg' register in CACHE has any of the bits
masked in REG->n set, then write REG->ry. Otherwise, write
REG->rx. */
-static void
-m32c_banked_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+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);
+ cache->raw_write (bank_reg->num, buf);
+
+ return REG_VALID;
}
/* 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 void
-m32c_sb_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_sb_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
if (gdbarch_bfd_arch_info (reg->arch)->mach == bfd_mach_m16c)
- m32c_raw_read (reg->rx, cache, buf);
+ return m32c_raw_read (reg->rx, cache, buf);
else
- m32c_banked_read (reg, cache, buf);
+ return m32c_banked_read (reg, cache, 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 void
-m32c_sb_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+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);
else
m32c_banked_write (reg, cache, buf);
+
+ return REG_VALID;
}
@@ -437,13 +441,14 @@ m32c_find_part (struct m32c_reg *reg, int *offset_p, int *len_p)
to BUF. Treating the value of the register REG->rx as an array of
REG->type values, where higher indices refer to more significant
bits, read the value of the REG->n'th element. */
-static void
-m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_part_read (struct m32c_reg *reg, readable_regcache *cache, gdb_byte *buf)
{
int offset, len;
+
memset (buf, 0, TYPE_LENGTH (reg->type));
m32c_find_part (reg, &offset, &len);
- regcache_cooked_read_part (cache, reg->rx->num, offset, len, buf);
+ return cache->cooked_read_part (reg->rx->num, offset, len, buf);
}
@@ -451,128 +456,141 @@ m32c_part_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
Treating the value of the register REG->rx as an array of REG->type
values, where higher indices refer to more significant bits, write
the value of the REG->n'th element. */
-static void
-m32c_part_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_part_write (struct m32c_reg *reg, struct regcache *cache,
+ const gdb_byte *buf)
{
int offset, len;
+
m32c_find_part (reg, &offset, &len);
- regcache_cooked_write_part (cache, reg->rx->num, offset, len, buf);
+ cache->cooked_write_part (reg->rx->num, offset, len, buf);
+
+ return REG_VALID;
}
/* Move the value of REG from CACHE to BUF. REG's value is the
concatenation of the values of the registers REG->rx and REG->ry,
with REG->rx contributing the more significant bits. */
-static void
-m32c_cat_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_cat_read (struct m32c_reg *reg, readable_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)
{
- regcache_cooked_read (cache, reg->rx->num, cbuf);
- regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes);
+ status = cache->cooked_read (reg->rx->num, buf);
+ if (status == REG_VALID)
+ status = cache->cooked_read (reg->ry->num, buf + high_bytes);
}
else
{
- regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes);
- regcache_cooked_read (cache, reg->ry->num, cbuf);
+ status = cache->cooked_read (reg->rx->num, buf + low_bytes);
+ if (status == REG_VALID)
+ status = cache->cooked_read (reg->ry->num, buf);
}
+ return status;
}
/* Move the value of REG from CACHE to BUF. REG's value is the
concatenation of the values of the registers REG->rx and REG->ry,
with REG->rx contributing the more significant bits. */
-static void
-m32c_cat_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+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);
+ cache->cooked_write (reg->rx->num, buf);
+ cache->cooked_write (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);
+ cache->cooked_write (reg->rx->num, buf + low_bytes);
+ cache->cooked_write (reg->ry->num, buf);
}
+
+ return REG_VALID;
}
/* Copy the value of the raw register REG from CACHE to BUF. REG is
the concatenation (from most significant to least) of r3, r2, r1,
and r0. */
-static void
-m32c_r3r2r1r0_read (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+m32c_r3r2r1r0_read (struct m32c_reg *reg, readable_regcache *cache, 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;
+ enum register_status status;
if (gdbarch_byte_order (reg->arch) == BFD_ENDIAN_BIG)
{
- regcache_cooked_read (cache, tdep->r0->num, cbuf + len * 3);
- regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2);
- regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1);
- regcache_cooked_read (cache, tdep->r3->num, cbuf);
+ status = cache->cooked_read (tdep->r0->num, buf + len * 3);
+ if (status == REG_VALID)
+ status = cache->cooked_read (tdep->r1->num, buf + len * 2);
+ if (status == REG_VALID)
+ status = cache->cooked_read (tdep->r2->num, buf + len * 1);
+ if (status == REG_VALID)
+ status = cache->cooked_read (tdep->r3->num, buf);
}
else
{
- regcache_cooked_read (cache, tdep->r0->num, cbuf);
- regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1);
- regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2);
- regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3);
+ status = cache->cooked_read (tdep->r0->num, buf);
+ if (status == REG_VALID)
+ status = cache->cooked_read (tdep->r1->num, buf + len * 1);
+ if (status == REG_VALID)
+ status = cache->cooked_read (tdep->r2->num, buf + len * 2);
+ if (status == REG_VALID)
+ status = cache->cooked_read (tdep->r3->num, buf + len * 3);
}
+
+ return status;
}
/* Copy the value of the raw register REG from BUF to CACHE. REG is
the concatenation (from most significant to least) of r3, r2, r1,
and r0. */
-static void
-m32c_r3r2r1r0_write (struct m32c_reg *reg, struct regcache *cache, void *buf)
+static enum register_status
+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);
+ cache->cooked_write (tdep->r0->num, buf + len * 3);
+ cache->cooked_write (tdep->r1->num, buf + len * 2);
+ cache->cooked_write (tdep->r2->num, buf + len * 1);
+ cache->cooked_write (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);
+ cache->cooked_write (tdep->r0->num, buf);
+ cache->cooked_write (tdep->r1->num, buf + len * 1);
+ cache->cooked_write (tdep->r2->num, buf + len * 2);
+ cache->cooked_write (tdep->r3->num, buf + len * 3);
}
+
+ return REG_VALID;
}
-static void
+static enum register_status
m32c_pseudo_register_read (struct gdbarch *arch,
- struct regcache *cache,
+ readable_regcache *cache,
int cookednum,
gdb_byte *buf)
{
@@ -580,11 +598,11 @@ 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];
- reg->read (reg, cache, buf);
+ return reg->read (reg, cache, buf);
}
@@ -598,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);
}
@@ -613,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)
@@ -671,12 +689,11 @@ mark_general (struct m32c_reg *reg)
}
-/* Mark REG as a DMA register, and return it. */
-static struct m32c_reg *
+/* Mark REG as a DMA register. */
+static void
mark_dma (struct m32c_reg *reg)
{
reg->dma_p = 1;
- return reg;
}
@@ -782,6 +799,25 @@ make_regs (struct gdbarch *arch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
int mach = gdbarch_bfd_arch_info (arch)->mach;
+ int num_raw_regs;
+ int num_cooked_regs;
+
+ struct m32c_reg *r0;
+ struct m32c_reg *r1;
+ struct m32c_reg *r2;
+ struct m32c_reg *r3;
+ struct m32c_reg *a0;
+ struct m32c_reg *a1;
+ struct m32c_reg *fb;
+ struct m32c_reg *sb;
+ struct m32c_reg *sp;
+ struct m32c_reg *r0hl;
+ struct m32c_reg *r1hl;
+ struct m32c_reg *r2r0;
+ struct m32c_reg *r3r1;
+ struct m32c_reg *r3r1r2r0;
+ struct m32c_reg *r3r2r1r0;
+ struct m32c_reg *a1a0;
struct m32c_reg *raw_r0_pair = RBD (r0);
struct m32c_reg *raw_r1_pair = RBD (r1);
@@ -804,62 +840,60 @@ make_regs (struct gdbarch *arch)
if (mach == bfd_mach_m32c)
{
- struct m32c_reg *svf = S (R16U (svf));
- struct m32c_reg *svp = S (RC (svp));
- struct m32c_reg *vct = S (RC (vct));
-
- struct m32c_reg *dmd01 = DMA (RP (dmd, tdep->uint8));
- struct m32c_reg *dct01 = DMA (RP (dct, tdep->uint16));
- struct m32c_reg *drc01 = DMA (RP (drc, tdep->uint16));
- struct m32c_reg *dma01 = DMA (RP (dma, tdep->data_addr_reg_type));
- struct m32c_reg *dsa01 = DMA (RP (dsa, tdep->data_addr_reg_type));
- struct m32c_reg *dra01 = DMA (RP (dra, tdep->data_addr_reg_type));
+ S (R16U (svf));
+ S (RC (svp));
+ S (RC (vct));
+
+ DMA (RP (dmd, tdep->uint8));
+ DMA (RP (dct, tdep->uint16));
+ DMA (RP (drc, tdep->uint16));
+ DMA (RP (dma, tdep->data_addr_reg_type));
+ DMA (RP (dsa, tdep->data_addr_reg_type));
+ DMA (RP (dra, tdep->data_addr_reg_type));
}
- int num_raw_regs = tdep->num_regs;
+ num_raw_regs = tdep->num_regs;
- struct m32c_reg *r0 = G (CB (r0, raw_r0_pair));
- struct m32c_reg *r1 = G (CB (r1, raw_r1_pair));
- struct m32c_reg *r2 = G (CB (r2, raw_r2_pair));
- struct m32c_reg *r3 = G (CB (r3, raw_r3_pair));
- struct m32c_reg *a0 = G (CB (a0, raw_a0_pair));
- struct m32c_reg *a1 = G (CB (a1, raw_a1_pair));
- struct m32c_reg *fb = G (CB (fb, raw_fb_pair));
+ r0 = G (CB (r0, raw_r0_pair));
+ r1 = G (CB (r1, raw_r1_pair));
+ r2 = G (CB (r2, raw_r2_pair));
+ r3 = G (CB (r3, raw_r3_pair));
+ a0 = G (CB (a0, raw_a0_pair));
+ a1 = G (CB (a1, raw_a1_pair));
+ fb = G (CB (fb, raw_fb_pair));
/* sb is banked on the bfd_mach_m32c, but not on bfd_mach_m16c.
Specify custom read/write functions that do the right thing. */
- struct m32c_reg *sb
- = G (add_reg (arch, "sb", raw_sb_pair->type, 0,
- m32c_sb_read, m32c_sb_write,
- raw_sb_pair, raw_sb_pair + 1, 0));
+ sb = G (add_reg (arch, "sb", raw_sb_pair->type, 0,
+ m32c_sb_read, m32c_sb_write,
+ raw_sb_pair, raw_sb_pair + 1, 0));
/* The current sp is either usp or isp, depending on the value of
the FLG register's U bit. */
- struct m32c_reg *sp
- = G (add_reg (arch, "sp", usp->type, 0,
- m32c_banked_read, m32c_banked_write, isp, usp, FLAGBIT_U));
+ sp = G (add_reg (arch, "sp", usp->type, 0,
+ m32c_banked_read, m32c_banked_write,
+ isp, usp, FLAGBIT_U));
- struct m32c_reg *r0hl = CHL (r0, tdep->int8);
- struct m32c_reg *r1hl = CHL (r1, tdep->int8);
- struct m32c_reg *r2hl = CHL (r2, tdep->int8);
- struct m32c_reg *r3hl = CHL (r3, tdep->int8);
- struct m32c_reg *intbhl = CHL (intb, tdep->int16);
+ r0hl = CHL (r0, tdep->int8);
+ r1hl = CHL (r1, tdep->int8);
+ CHL (r2, tdep->int8);
+ CHL (r3, tdep->int8);
+ CHL (intb, tdep->int16);
- struct m32c_reg *r2r0 = CCAT (r2, r0, tdep->int32);
- struct m32c_reg *r3r1 = CCAT (r3, r1, tdep->int32);
- struct m32c_reg *r3r1r2r0 = CCAT (r3r1, r2r0, tdep->int64);
+ r2r0 = CCAT (r2, r0, tdep->int32);
+ r3r1 = CCAT (r3, r1, tdep->int32);
+ r3r1r2r0 = CCAT (r3r1, r2r0, tdep->int64);
- struct m32c_reg *r3r2r1r0
+ r3r2r1r0
= add_reg (arch, "r3r2r1r0", tdep->int64, 0,
m32c_r3r2r1r0_read, m32c_r3r2r1r0_write, NULL, NULL, 0);
- struct m32c_reg *a1a0;
if (mach == bfd_mach_m16c)
a1a0 = CCAT (a1, a0, tdep->int32);
else
a1a0 = NULL;
- int num_cooked_regs = tdep->num_regs - num_raw_regs;
+ num_cooked_regs = tdep->num_regs - num_raw_regs;
tdep->pc = pc;
tdep->flg = flg;
@@ -941,7 +975,6 @@ make_regs (struct gdbarch *arch)
set_gdbarch_pseudo_register_write (arch, m32c_pseudo_register_write);
set_gdbarch_register_sim_regno (arch, m32c_register_sim_regno);
set_gdbarch_stab_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
- set_gdbarch_dwarf_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
set_gdbarch_dwarf2_reg_to_regnum (arch, m32c_debug_info_reg_to_regnum);
set_gdbarch_register_reggroup_p (arch, m32c_register_reggroup_p);
@@ -956,20 +989,26 @@ make_regs (struct gdbarch *arch)
/* Breakpoints. */
+constexpr gdb_byte m32c_break_insn[] = { 0x00 }; /* brk */
-static const unsigned char *
-m32c_breakpoint_from_pc (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
@@ -979,18 +1018,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
@@ -1050,16 +1078,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
@@ -1068,7 +1103,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;
};
@@ -1078,7 +1113,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
@@ -1095,9 +1130,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 ();
@@ -1201,7 +1236,7 @@ m32c_decode_srcdest4 (struct m32c_pv_state *st,
switch (code)
{
- case 0x0: sd.reg = (size == 1 ? &st->r0 : &st->r0); break;
+ case 0x0: sd.reg = &st->r0; break;
case 0x1: sd.reg = (size == 1 ? &st->r0 : &st->r1); break;
case 0x2: sd.reg = (size == 1 ? &st->r1 : &st->r2); break;
case 0x3: sd.reg = (size == 1 ? &st->r1 : &st->r3); break;
@@ -1223,7 +1258,7 @@ m32c_decode_srcdest4 (struct m32c_pv_state *st,
case 0xf: sd.addr = pv_constant (m32c_udisp16 (st)); break;
default:
- gdb_assert (0);
+ gdb_assert_not_reached ("unexpected srcdest4");
}
return sd;
@@ -1282,7 +1317,7 @@ m32c_decode_sd23 (struct m32c_pv_state *st, int code, int size, int ind)
case 0x0f: sd.addr = pv_constant (m32c_udisp16 (st)); break;
case 0x0e: sd.addr = pv_constant (m32c_udisp24 (st)); break;
default:
- gdb_assert (0);
+ gdb_assert_not_reached ("unexpected sd23");
}
if (ind)
@@ -1314,7 +1349,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))
@@ -1405,7 +1440,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
@@ -1426,7 +1461,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)));
@@ -1457,7 +1492,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
@@ -1502,7 +1537,7 @@ check_for_saved (void *prologue_untyped, pv_t addr, CORE_ADDR size, pv_t value)
/* Analyze the function prologue for ARCH at START, going no further
than LIMIT, and place a description of what we found in
PROLOGUE. */
-void
+static void
m32c_analyze_prologue (struct gdbarch *arch,
CORE_ADDR start, CORE_ADDR limit,
struct m32c_prologue *prologue)
@@ -1510,7 +1545,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;
@@ -1524,8 +1558,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);
- 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. */
@@ -1592,14 +1626,16 @@ m32c_analyze_prologue (struct gdbarch *arch,
else if ((st.insn[0] & 0xfe) == 0x72)
{
int size = (st.insn[0] & 0x01) ? 2 : 1;
-
+ struct srcdest src;
+ struct srcdest dest;
+ pv_t src_value;
st.next_addr += 2;
- struct srcdest src
+ src
= m32c_decode_srcdest4 (&st, (st.insn[1] >> 4) & 0xf, size);
- struct srcdest dest
+ dest
= m32c_decode_srcdest4 (&st, st.insn[1] & 0xf, size);
- pv_t src_value = m32c_srcdest_fetch (&st, src, size);
+ src_value = m32c_srcdest_fetch (&st, src, size);
if (m32c_is_arg_spill (&st, dest, src_value))
after_last_frame_related_insn = st.next_addr;
@@ -1677,18 +1713,20 @@ m32c_analyze_prologue (struct gdbarch *arch,
&& m32c_get_src23 (&st.insn[i]) < 20
&& m32c_get_dest23 (&st.insn[i]) < 20)
{
+ struct srcdest src;
+ struct srcdest dest;
+ pv_t src_value;
int bw = st.insn[i] & 0x01;
int size = bw ? 2 : 1;
-
st.next_addr += 2;
- struct srcdest src
+ src
= m32c_decode_sd23 (&st, m32c_get_src23 (&st.insn[i]),
size, src_indirect);
- struct srcdest dest
+ dest
= m32c_decode_sd23 (&st, m32c_get_dest23 (&st.insn[i]),
size, dest_indirect);
- pv_t src_value = m32c_srcdest_fetch (&st, src, size);
+ src_value = m32c_srcdest_fetch (&st, src, size);
if (m32c_is_arg_spill (&st, dest, src_value))
after_last_frame_related_insn = st.next_addr;
@@ -1772,18 +1810,16 @@ 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);
}
static CORE_ADDR
-m32c_skip_prologue (CORE_ADDR ip)
+m32c_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
{
- char *name;
+ const char *name;
CORE_ADDR func_addr, func_end, sal_end;
struct m32c_prologue p;
@@ -1792,9 +1828,9 @@ m32c_skip_prologue (CORE_ADDR ip)
return ip;
/* Find end by prologue analysis. */
- m32c_analyze_prologue (current_gdbarch, ip, func_end, &p);
+ m32c_analyze_prologue (gdbarch, ip, func_end, &p);
/* Find end by line info. */
- sal_end = skip_prologue_using_sal (ip);
+ sal_end = skip_prologue_using_sal (gdbarch, ip);
/* Return whichever is lower. */
if (sal_end != 0 && sal_end != ip && sal_end < p.prologue_end)
return sal_end;
@@ -1807,13 +1843,13 @@ m32c_skip_prologue (CORE_ADDR ip)
/* Stack unwinding. */
static struct m32c_prologue *
-m32c_analyze_frame_prologue (struct frame_info *next_frame,
+m32c_analyze_frame_prologue (struct frame_info *this_frame,
void **this_prologue_cache)
{
if (! *this_prologue_cache)
{
- CORE_ADDR func_start = frame_func_unwind (next_frame);
- CORE_ADDR stop_addr = frame_pc_unwind (next_frame);
+ CORE_ADDR func_start = get_frame_func (this_frame);
+ CORE_ADDR stop_addr = get_frame_pc (this_frame);
/* If we couldn't find any function containing the PC, then
just initialize the prologue cache, but don't do anything. */
@@ -1821,21 +1857,22 @@ m32c_analyze_frame_prologue (struct frame_info *next_frame,
stop_addr = func_start;
*this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue);
- m32c_analyze_prologue (get_frame_arch (next_frame),
- func_start, stop_addr, *this_prologue_cache);
+ m32c_analyze_prologue (get_frame_arch (this_frame),
+ func_start, stop_addr,
+ (struct m32c_prologue *) *this_prologue_cache);
}
- return *this_prologue_cache;
+ return (struct m32c_prologue *) *this_prologue_cache;
}
static CORE_ADDR
-m32c_frame_base (struct frame_info *next_frame,
+m32c_frame_base (struct frame_info *this_frame,
void **this_prologue_cache)
{
struct m32c_prologue *p
- = m32c_analyze_frame_prologue (next_frame, this_prologue_cache);
- struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame));
+ = m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
/* In functions that use alloca, the distance between the stack
pointer and the frame base varies dynamically, so we can't use
@@ -1848,14 +1885,14 @@ m32c_frame_base (struct frame_info *next_frame,
case prologue_with_frame_ptr:
{
CORE_ADDR fb
- = frame_unwind_register_unsigned (next_frame, tdep->fb->num);
+ = get_frame_register_unsigned (this_frame, tdep->fb->num);
return fb - p->frame_ptr_offset;
}
case prologue_sans_frame_ptr:
{
CORE_ADDR sp
- = frame_unwind_register_unsigned (next_frame, tdep->sp->num);
+ = get_frame_register_unsigned (this_frame, tdep->sp->num);
return sp - p->frame_size;
}
@@ -1863,102 +1900,57 @@ m32c_frame_base (struct frame_info *next_frame,
return 0;
default:
- gdb_assert (0);
+ gdb_assert_not_reached ("unexpected prologue kind");
}
}
static void
-m32c_this_id (struct frame_info *next_frame,
+m32c_this_id (struct frame_info *this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
- CORE_ADDR base = m32c_frame_base (next_frame, this_prologue_cache);
+ CORE_ADDR base = m32c_frame_base (this_frame, this_prologue_cache);
if (base)
- *this_id = frame_id_build (base, frame_func_unwind (next_frame));
+ *this_id = frame_id_build (base, get_frame_func (this_frame));
/* Otherwise, leave it unset, and that will terminate the backtrace. */
}
-static void
-m32c_prev_register (struct frame_info *next_frame,
- void **this_prologue_cache,
- int regnum, int *optimizedp,
- enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, gdb_byte *bufferp)
+static struct value *
+m32c_prev_register (struct frame_info *this_frame,
+ void **this_prologue_cache, int regnum)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (next_frame));
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
struct m32c_prologue *p
- = m32c_analyze_frame_prologue (next_frame, this_prologue_cache);
- CORE_ADDR frame_base = m32c_frame_base (next_frame, this_prologue_cache);
- int reg_size = register_size (get_frame_arch (next_frame), regnum);
+ = m32c_analyze_frame_prologue (this_frame, this_prologue_cache);
+ CORE_ADDR frame_base = m32c_frame_base (this_frame, this_prologue_cache);
if (regnum == tdep->sp->num)
- {
- *optimizedp = 0;
- *lvalp = not_lval;
- *addrp = 0;
- *realnump = -1;
- if (bufferp)
- store_unsigned_integer (bufferp, reg_size, frame_base);
- }
+ return frame_unwind_got_constant (this_frame, regnum, frame_base);
/* If prologue analysis says we saved this register somewhere,
return a description of the stack slot holding it. */
- else if (p->reg_offset[regnum] != 1)
- {
- *optimizedp = 0;
- *lvalp = lval_memory;
- *addrp = frame_base + p->reg_offset[regnum];
- *realnump = -1;
- if (bufferp)
- get_frame_memory (next_frame, *addrp, bufferp, reg_size);
- }
+ if (p->reg_offset[regnum] != 1)
+ return frame_unwind_got_memory (this_frame, regnum,
+ frame_base + p->reg_offset[regnum]);
/* Otherwise, presume we haven't changed the value of this
register, and get it from the next frame. */
- else
- {
- *optimizedp = 0;
- *lvalp = lval_register;
- *addrp = 0;
- *realnump = regnum;
- if (bufferp)
- frame_unwind_register (next_frame, *realnump, bufferp);
- }
+ return frame_unwind_got_register (this_frame, regnum, regnum);
}
static const struct frame_unwind m32c_unwind = {
NORMAL_FRAME,
+ default_frame_unwind_stop_reason,
m32c_this_id,
- m32c_prev_register
+ m32c_prev_register,
+ NULL,
+ default_frame_sniffer
};
-
-static const struct frame_unwind *
-m32c_frame_sniffer (struct frame_info *next_frame)
-{
- return &m32c_unwind;
-}
-
-
-static CORE_ADDR
-m32c_unwind_pc (struct gdbarch *arch, struct frame_info *next_frame)
-{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
- return frame_unwind_register_unsigned (next_frame, tdep->pc->num);
-}
-
-
-static CORE_ADDR
-m32c_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
-{
- struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
- return frame_unwind_register_unsigned (next_frame, tdep->sp->num);
-}
-
/* Inferior calls. */
@@ -1994,12 +1986,12 @@ m32c_unwind_sp (struct gdbarch *arch, struct frame_info *next_frame)
static int
m32c_reg_arg_type (struct type *type)
{
- enum type_code code = TYPE_CODE (type);
+ enum type_code code = type->code ();
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);
}
@@ -2008,10 +2000,12 @@ m32c_reg_arg_type (struct type *type)
static CORE_ADDR
m32c_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,
+ struct value **args, CORE_ADDR sp,
+ function_call_return_method return_method,
CORE_ADDR struct_addr)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
unsigned long mach = gdbarch_bfd_arch_info (gdbarch)->mach;
CORE_ADDR cfa;
int i;
@@ -2026,8 +2020,12 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{
struct type *func_type = value_type (function);
- gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC ||
- TYPE_CODE (func_type) == TYPE_CODE_METHOD);
+ /* Dereference function pointer types. */
+ if (func_type->code () == TYPE_CODE_PTR)
+ func_type = TYPE_TARGET_TYPE (func_type);
+
+ gdb_assert (func_type->code () == TYPE_CODE_FUNC ||
+ func_type->code () == TYPE_CODE_METHOD);
#if 0
/* The ABI description in gcc/config/m32c/m32c.abi says that
@@ -2035,17 +2033,17 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
separately, but the code in GCC doesn't actually do so. */
if (TYPE_PROTOTYPED (func_type))
#endif
- num_prototyped_args = TYPE_NFIELDS (func_type);
+ num_prototyped_args = func_type->num_fields ();
}
/* First, if the function returns an aggregate by value, push a
pointer to a buffer for it. This doesn't affect the way
subsequent arguments are allocated to registers. */
- if (struct_return)
+ if (return_method == return_method_struct)
{
int ptr_len = TYPE_LENGTH (tdep->ptr_voyd);
sp -= ptr_len;
- write_memory_unsigned_integer (sp, ptr_len, struct_addr);
+ write_memory_unsigned_integer (sp, ptr_len, byte_order, struct_addr);
}
/* Push the arguments. */
@@ -2066,7 +2064,8 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
sure it ends up in the least significant end of r1. (GDB
should avoid assuming endianness, even on uni-endian
processors.) */
- ULONGEST u = extract_unsigned_integer (arg_bits, arg_size);
+ ULONGEST u = extract_unsigned_integer (arg_bits, arg_size,
+ byte_order);
struct m32c_reg *reg = (mach == bfd_mach_m16c) ? tdep->r1 : tdep->r0;
regcache_cooked_write_unsigned (regcache, reg->num, u);
}
@@ -2077,7 +2076,7 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
&& arg_size == 2
&& i < num_prototyped_args
&& m32c_reg_arg_type (arg_type))
- regcache_cooked_write (regcache, tdep->r2->num, arg_bits);
+ regcache->cooked_write (tdep->r2->num, arg_bits);
/* Everything else goes on the stack. */
else
@@ -2097,7 +2096,8 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
/* Push the return address. */
sp -= tdep->ret_addr_bytes;
- write_memory_unsigned_integer (sp, tdep->ret_addr_bytes, bp_addr);
+ write_memory_unsigned_integer (sp, tdep->ret_addr_bytes, byte_order,
+ bp_addr);
/* Update the stack pointer. */
regcache_cooked_write_unsigned (regcache, tdep->sp->num, sp);
@@ -2123,20 +2123,6 @@ m32c_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
}
-static struct frame_id
-m32c_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- /* This needs to return a frame ID whose PC is the return address
- passed to m32c_push_dummy_call, and whose stack_addr is the SP
- m32c_push_dummy_call returned.
-
- m32c_unwind_sp gives us the CFA, which is the value the SP had
- before the return address was pushed. */
- return frame_id_build (m32c_unwind_sp (gdbarch, next_frame),
- frame_pc_unwind (next_frame));
-}
-
-
/* Return values. */
@@ -2167,7 +2153,7 @@ m32c_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
static int
m32c_return_by_passed_buf (struct type *type)
{
- enum type_code code = TYPE_CODE (type);
+ enum type_code code = type->code ();
return (code == TYPE_CODE_STRUCT
|| code == TYPE_CODE_UNION);
@@ -2175,12 +2161,14 @@ m32c_return_by_passed_buf (struct type *type)
static enum return_value_convention
m32c_return_value (struct gdbarch *gdbarch,
+ struct value *function,
struct type *valtype,
struct regcache *regcache,
gdb_byte *readbuf,
const gdb_byte *writebuf)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum return_value_convention conv;
ULONGEST valtype_len = TYPE_LENGTH (valtype);
@@ -2203,21 +2191,21 @@ m32c_return_value (struct gdbarch *gdbarch,
{
ULONGEST u;
regcache_cooked_read_unsigned (regcache, tdep->r0->num, &u);
- store_unsigned_integer (readbuf, valtype_len, u);
+ store_unsigned_integer (readbuf, valtype_len, byte_order, u);
}
else
{
/* Everything else is passed in mem0, using as many bytes as
needed. This is not what the Renesas tools do, but it's
what GCC does at the moment. */
- struct minimal_symbol *mem0
+ struct bound_minimal_symbol mem0
= lookup_minimal_symbol ("mem0", NULL, NULL);
- if (! mem0)
- error ("The return value is stored in memory at 'mem0', "
- "but GDB cannot find\n"
- "its address.");
- read_memory (SYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len);
+ if (! mem0.minsym)
+ error (_("The return value is stored in memory at 'mem0', "
+ "but GDB cannot find\n"
+ "its address."));
+ read_memory (BMSYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len);
}
}
@@ -2233,7 +2221,8 @@ m32c_return_value (struct gdbarch *gdbarch,
/* Anything that fits in r0 is returned there. */
if (valtype_len <= TYPE_LENGTH (tdep->r0->type))
{
- ULONGEST u = extract_unsigned_integer (writebuf, valtype_len);
+ ULONGEST u = extract_unsigned_integer (writebuf, valtype_len,
+ byte_order);
regcache_cooked_write_unsigned (regcache, tdep->r0->num, u);
}
else
@@ -2241,15 +2230,14 @@ m32c_return_value (struct gdbarch *gdbarch,
/* Everything else is passed in mem0, using as many bytes as
needed. This is not what the Renesas tools do, but it's
what GCC does at the moment. */
- struct minimal_symbol *mem0
+ struct bound_minimal_symbol mem0
= lookup_minimal_symbol ("mem0", NULL, NULL);
- if (! mem0)
- error ("The return value is stored in memory at 'mem0', "
- "but GDB cannot find\n"
- " its address.");
- write_memory (SYMBOL_VALUE_ADDRESS (mem0),
- (char *) writebuf, valtype_len);
+ if (! mem0.minsym)
+ error (_("The return value is stored in memory at 'mem0', "
+ "but GDB cannot find\n"
+ " its address."));
+ write_memory (BMSYMBOL_VALUE_ADDRESS (mem0), writebuf, valtype_len);
}
}
@@ -2294,10 +2282,10 @@ m32c_return_value (struct gdbarch *gdbarch,
their program is calling, not in some trampoline code they've never
seen before.)
- The SKIP_TRAMPOLINE_CODE gdbarch method tells GDB how to step
+ The gdbarch_skip_trampoline_code method tells GDB how to step
through such trampoline functions transparently to the user. When
given the address of a trampoline function's first instruction,
- SKIP_TRAMPOLINE_CODE should return the address of the first
+ gdbarch_skip_trampoline_code should return the address of the first
instruction of the function really being called. If GDB decides it
wants to step into that function, it will set a breakpoint there
and silently continue to it.
@@ -2307,9 +2295,11 @@ m32c_return_value (struct gdbarch *gdbarch,
code sequence seems more fragile. */
static CORE_ADDR
-m32c_skip_trampoline_code (CORE_ADDR stop_pc)
+m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* It would be nicer to simply look up the addresses of known
trampolines once, and then compare stop_pc with them. However,
@@ -2317,7 +2307,7 @@ m32c_skip_trampoline_code (CORE_ADDR stop_pc)
someone loaded a new executable, and I'm not quite sure of the
best way to do that. find_pc_partial_function does do some
caching, so we'll see how this goes. */
- char *name;
+ const char *name;
CORE_ADDR start, end;
if (find_pc_partial_function (stop_pc, &name, &start, &end))
@@ -2332,13 +2322,14 @@ m32c_skip_trampoline_code (CORE_ADDR stop_pc)
m32c_jsri*16*. */
CORE_ADDR sp = get_frame_sp (get_current_frame ());
CORE_ADDR target
- = read_memory_unsigned_integer (sp + tdep->ret_addr_bytes, 2);
+ = read_memory_unsigned_integer (sp + tdep->ret_addr_bytes,
+ 2, byte_order);
/* What we have now is the address of a jump instruction.
What we need is the destination of that jump.
- The opcode is 1 byte, and the destination is the next 3 bytes.
- */
- target = read_memory_unsigned_integer (target + 1, 3);
+ The opcode is 1 byte, and the destination is the next 3 bytes. */
+
+ target = read_memory_unsigned_integer (target + 1, 3, byte_order);
return target;
}
}
@@ -2403,129 +2394,182 @@ m32c_skip_trampoline_code (CORE_ADDR stop_pc)
programmer! :) */
static void
-m32c_m16c_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
+m32c_m16c_address_to_pointer (struct gdbarch *gdbarch,
+ struct type *type, gdb_byte *buf, CORE_ADDR addr)
{
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
- TYPE_CODE (type) == TYPE_CODE_REF);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum type_code target_code;
+ gdb_assert (type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type));
- enum type_code target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ target_code = TYPE_TARGET_TYPE (type)->code ();
if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
{
+ const char *func_name;
+ char *tramp_name;
+ struct bound_minimal_symbol tramp_msym;
+
/* Try to find a linker symbol at this address. */
- struct minimal_symbol *func_msym = lookup_minimal_symbol_by_pc (addr);
+ struct bound_minimal_symbol func_msym
+ = lookup_minimal_symbol_by_pc (addr);
- if (! func_msym)
- error ("Cannot convert code address %s to function pointer:\n"
- "couldn't find a symbol at that address, to find trampoline.",
- paddr_nz (addr));
+ if (! func_msym.minsym)
+ error (_("Cannot convert code address %s to function pointer:\n"
+ "couldn't find a symbol at that address, to find trampoline."),
+ paddress (gdbarch, addr));
- char *func_name = SYMBOL_LINKAGE_NAME (func_msym);
- char *tramp_name = xmalloc (strlen (func_name) + 5);
+ func_name = func_msym.minsym->linkage_name ();
+ tramp_name = (char *) xmalloc (strlen (func_name) + 5);
strcpy (tramp_name, func_name);
strcat (tramp_name, ".plt");
/* Try to find a linker symbol for the trampoline. */
- struct minimal_symbol *tramp_msym
- = lookup_minimal_symbol (tramp_name, NULL, NULL);
+ tramp_msym = lookup_minimal_symbol (tramp_name, NULL, NULL);
/* We've either got another copy of the name now, or don't need
the name any more. */
xfree (tramp_name);
- if (! tramp_msym)
- error ("Cannot convert code address %s to function pointer:\n"
- "couldn't find trampoline named '%s.plt'.",
- paddr_nz (addr), func_name);
+ if (! tramp_msym.minsym)
+ {
+ CORE_ADDR ptrval;
+
+ /* No PLT entry found. Mask off the upper bits of the address
+ to make a pointer. As noted in the warning to the user
+ below, this value might be useful if converted back into
+ an address by GDB, but will otherwise, almost certainly,
+ be garbage.
+
+ Using this masked result does seem to be useful
+ in gdb.cp/cplusfuncs.exp in which ~40 FAILs turn into
+ PASSes. These results appear to be correct as well.
+
+ We print a warning here so that the user can make a
+ determination about whether the result is useful or not. */
+ ptrval = addr & 0xffff;
+
+ warning (_("Cannot convert code address %s to function pointer:\n"
+ "couldn't find trampoline named '%s.plt'.\n"
+ "Returning pointer value %s instead; this may produce\n"
+ "a useful result if converted back into an address by GDB,\n"
+ "but will most likely not be useful otherwise."),
+ paddress (gdbarch, addr), func_name,
+ paddress (gdbarch, ptrval));
+
+ addr = ptrval;
- /* The trampoline's address is our pointer. */
- addr = SYMBOL_VALUE_ADDRESS (tramp_msym);
+ }
+ else
+ {
+ /* The trampoline's address is our pointer. */
+ addr = BMSYMBOL_VALUE_ADDRESS (tramp_msym);
+ }
}
- store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
+ store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
static CORE_ADDR
-m32c_m16c_pointer_to_address (struct type *type, const gdb_byte *buf)
+m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
+ struct type *type, const gdb_byte *buf)
{
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_PTR ||
- TYPE_CODE (type) == TYPE_CODE_REF);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ CORE_ADDR ptr;
+ enum type_code target_code;
- CORE_ADDR ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
+ gdb_assert (type->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type));
- enum type_code target_code = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ ptr = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
+
+ target_code = TYPE_TARGET_TYPE (type)->code ();
if (target_code == TYPE_CODE_FUNC || target_code == TYPE_CODE_METHOD)
{
/* See if there is a minimal symbol at that address whose name is
"NAME.plt". */
- struct minimal_symbol *ptr_msym = lookup_minimal_symbol_by_pc (ptr);
+ struct bound_minimal_symbol ptr_msym = lookup_minimal_symbol_by_pc (ptr);
- if (ptr_msym)
+ if (ptr_msym.minsym)
{
- char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym);
+ const char *ptr_msym_name = ptr_msym.minsym->linkage_name ();
int len = strlen (ptr_msym_name);
if (len > 4
&& strcmp (ptr_msym_name + len - 4, ".plt") == 0)
{
+ struct bound_minimal_symbol func_msym;
/* We have a .plt symbol; try to find the symbol for the
corresponding function.
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';
- struct minimal_symbol *func_msym
+ func_msym
= lookup_minimal_symbol (func_name, NULL, NULL);
/* If we do have such a symbol, return its value as the
function's true address. */
- if (func_msym)
- ptr = SYMBOL_VALUE_ADDRESS (func_msym);
+ if (func_msym.minsym)
+ ptr = BMSYMBOL_VALUE_ADDRESS (func_msym);
}
}
+ else
+ {
+ int aspace;
+
+ for (aspace = 1; aspace <= 15; aspace++)
+ {
+ ptr_msym = lookup_minimal_symbol_by_pc ((aspace << 16) | ptr);
+
+ if (ptr_msym.minsym)
+ ptr |= aspace << 16;
+ }
+ }
}
return ptr;
}
-void
-m32c_virtual_frame_pointer (CORE_ADDR pc,
+static void
+m32c_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc,
int *frame_regnum,
LONGEST *frame_offset)
{
- char *name;
- CORE_ADDR func_addr, func_end, sal_end;
+ const char *name;
+ CORE_ADDR func_addr, func_end;
struct m32c_prologue p;
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ struct regcache *regcache = get_current_regcache ();
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
- internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
+ internal_error (__FILE__, __LINE__,
+ _("No virtual frame pointer available"));
- m32c_analyze_prologue (current_gdbarch, func_addr, pc, &p);
+ m32c_analyze_prologue (gdbarch, func_addr, pc, &p);
switch (p.kind)
{
case prologue_with_frame_ptr:
- *frame_regnum = m32c_banked_register (tdep->fb, current_regcache)->num;
+ *frame_regnum = m32c_banked_register (tdep->fb, regcache)->num;
*frame_offset = p.frame_ptr_offset;
break;
case prologue_sans_frame_ptr:
- *frame_regnum = m32c_banked_register (tdep->sp, current_regcache)->num;
+ *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
*frame_offset = p.frame_size;
break;
default:
- *frame_regnum = m32c_banked_register (tdep->sp, current_regcache)->num;
+ *frame_regnum = m32c_banked_register (tdep->sp, regcache)->num;
*frame_offset = 0;
break;
}
/* Sanity check */
- if (*frame_regnum > NUM_REGS)
- internal_error (__FILE__, __LINE__, _("No virtual frame pointer available"));
+ if (*frame_regnum > gdbarch_num_regs (gdbarch))
+ internal_error (__FILE__, __LINE__,
+ _("No virtual frame pointer available"));
}
@@ -2534,7 +2578,7 @@ m32c_virtual_frame_pointer (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;
@@ -2545,60 +2589,64 @@ 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);
#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
- */
- frame_unwind_append_sniffer (arch, dwarf2_frame_sniffer);
+ MVS 04/13/06 */
+ dwarf2_append_sniffers (gdbarch);
#endif
- frame_unwind_append_sniffer (arch, m32c_frame_sniffer);
+ 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_unwind_dummy_id (arch, m32c_unwind_dummy_id);
+ set_gdbarch_push_dummy_call (gdbarch, m32c_push_dummy_call);
+ set_gdbarch_return_value (gdbarch, m32c_return_value);
/* 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);
- return arch;
-}
+ /* m32c function boundary addresses are not necessarily even.
+ Therefore, the `vbit', which indicates a pointer to a virtual
+ member function, is stored in the delta field, rather than as
+ the low bit of a function pointer address.
+
+ 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 (gdbarch, 1);
+ return gdbarch;
+}
+void _initialize_m32c_tdep ();
void
-_initialize_m32c_tdep (void)
+_initialize_m32c_tdep ()
{
register_gdbarch_init (bfd_arch_m32c, m32c_gdbarch_init);