/* Renesas M32C target-dependent code for GDB, the GNU debugger.
- Copyright (C) 2004-2014 Free Software Foundation, Inc.
+ Copyright (C) 2004-2016 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-
-#include <stdarg.h>
-
-#include <string.h>
-#include "gdb_assert.h"
#include "elf-bfd.h"
#include "elf/m32c.h"
#include "gdb/sim-m32c.h"
/* 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
{
/* 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
/* 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);
}
/* 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;
}
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);
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;
}
/* 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);
/* 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);
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;
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;
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 = regcache_cooked_read (cache, reg->rx->num, buf);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, reg->ry->num, cbuf + high_bytes);
+ status = regcache_cooked_read (cache, reg->ry->num, buf + high_bytes);
}
else
{
- status = regcache_cooked_read (cache, reg->rx->num, cbuf + low_bytes);
+ status = regcache_cooked_read (cache, reg->rx->num, buf + low_bytes);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, reg->ry->num, cbuf);
+ status = regcache_cooked_read (cache, reg->ry->num, buf);
}
return status;
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;
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 = regcache_cooked_read (cache, tdep->r0->num, buf + len * 3);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 2);
+ status = regcache_cooked_read (cache, tdep->r1->num, buf + len * 2);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 1);
+ status = regcache_cooked_read (cache, tdep->r2->num, buf + len * 1);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r3->num, cbuf);
+ status = regcache_cooked_read (cache, tdep->r3->num, buf);
}
else
{
- status = regcache_cooked_read (cache, tdep->r0->num, cbuf);
+ status = regcache_cooked_read (cache, tdep->r0->num, buf);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r1->num, cbuf + len * 1);
+ status = regcache_cooked_read (cache, tdep->r1->num, buf + len * 1);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r2->num, cbuf + len * 2);
+ status = regcache_cooked_read (cache, tdep->r2->num, buf + len * 2);
if (status == REG_VALID)
- status = regcache_cooked_read (cache, tdep->r3->num, cbuf + len * 3);
+ status = regcache_cooked_read (cache, tdep->r3->num, buf + len * 3);
}
return status;
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;
gdb_assert (arch == tdep->regs[cookednum].arch);
reg = &tdep->regs[cookednum];
- reg->write (reg, cache, (void *) buf);
+ reg->write (reg, cache, buf);
}
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)
\f
/* 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
/* 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
}
+enum srcdest_kind
+{
+ srcdest_reg,
+ srcdest_partial_reg,
+ srcdest_mem
+};
+
/* A source or destination location for an m16c or m32c
instruction. */
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;
};
*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;
}
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");
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
arches = gdbarch_list_lookup_by_info (arches->next, &info))
return arches->gdbarch;
- tdep = xcalloc (1, sizeof (*tdep));
+ tdep = XCNEW (struct gdbarch_tdep);
arch = gdbarch_alloc (&info, tdep);
/* Essential types. */
projects / deliverable / binutils-gdb.git / blobdiff