From patchwork Sun Oct 11 04:37:15 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 9042 Received: (qmail 111464 invoked by alias); 11 Oct 2015 04:37:35 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 111021 invoked by uid 89); 11 Oct 2015 04:37:26 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.0 required=5.0 tests=AWL, BAYES_00, SPF_SOFTFAIL autolearn=no version=3.3.2 X-HELO: smtp.electronicbox.net Received: from smtp.electronicbox.net (HELO smtp.electronicbox.net) (96.127.255.83) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sun, 11 Oct 2015 04:37:21 +0000 Received: from simark.lan. (cable-192.222.137.139.electronicbox.net [192.222.137.139]) by smtp.electronicbox.net (Postfix) with ESMTP id C5EE6440E79; Sun, 11 Oct 2015 00:37:19 -0400 (EDT) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH c++ 2/5] m32c: Split m32c_move_reg_t in read/write variants Date: Sun, 11 Oct 2015 00:37:15 -0400 Message-Id: <1444538238-7468-2-git-send-email-simon.marchi@polymtl.ca> In-Reply-To: <1444538238-7468-1-git-send-email-simon.marchi@polymtl.ca> References: <1444538238-7468-1-git-send-email-simon.marchi@polymtl.ca> This allows to avoid casting away the const qualification in m32c_pseudo_register_write (which is the entry points for all other register read/write functions). Also, use gdb_byte* instead of void* to avoid casts when calling gdb common memory functions. It also allows to remove those "For adderss arithmetic" local variables. gdb/ChangeLog: * m32c-tdep.c (m32c_move_reg_t): Replace with... (m32c_write_reg_t): ...this and... (m32c_read_reg_t): ...this. (struct m32c_reg): Update types of read and write. (m32c_raw_read): Change declaration type to m32c_read_reg_t and adjust definition. (m32c_banked_read): Likewise. (m32c_sb_read): Likewise. (m32c_part_read): Likewise. (m32c_cat_read): Likewise. (m32c_r3r2r1r0_read): Likewise. (m32c_raw_write): Change declaration type to m32c_write_reg_t and adjust definition. (m32c_banked_write): Likewise. (m32c_sb_write): Likewise. (m32c_part_write): Likewise. (m32c_cat_write): Likewise. (m32c_r3r2r1r0_write): Likewise. --- gdb/m32c-tdep.c | 130 +++++++++++++++++++++++++++++--------------------------- 1 file changed, 68 insertions(+), 62 deletions(-) diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c index f2d060a..40abe9d 100644 --- a/gdb/m32c-tdep.c +++ b/gdb/m32c-tdep.c @@ -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 @@ -297,18 +302,24 @@ 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, + m32c_banked_read, + m32c_sb_read, + m32c_part_read, + m32c_cat_read, + m32c_r3r2r1r0_read; + +static m32c_write_reg_t m32c_raw_write, + m32c_banked_write, + m32c_sb_write, + m32c_part_write, + m32c_cat_write, + 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); } @@ -316,9 +327,10 @@ m32c_raw_read (struct m32c_reg *reg, struct regcache *cache, void *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; } @@ -348,7 +360,7 @@ 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); @@ -360,10 +372,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 +385,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 +397,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,7 +450,7 @@ 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; @@ -452,7 +465,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,27 +481,25 @@ 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 = 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; @@ -498,24 +510,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 +537,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 = 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; @@ -564,27 +572,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; @@ -623,7 +629,7 @@ m32c_pseudo_register_write (struct gdbarch *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 +640,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)