diff mbox series

[v17,22/24] target/rx: Collect all bytes during disassembly

Message ID 20190607091116.49044-23-ysato@users.sourceforge.jp
State Superseded
Headers show
Series None | expand

Commit Message

Yoshinori Sato June 7, 2019, 9:11 a.m. UTC 
From: Richard Henderson <richard.henderson@linaro.org>


Collected, to be used in the next patch.

Reviewed-by: Yoshinori Sato <ysato@users.sourceforge.jp>

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>

Signed-off-by: Yoshinori Sato <ysato@users.sourceforge.jp>

---
 target/rx/disas.c | 62 +++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 42 insertions(+), 20 deletions(-)

-- 
2.11.0

Comments

Philippe Mathieu-Daudé June 7, 2019, 1:43 p.m. UTC | #1 
On 6/7/19 11:11 AM, Yoshinori Sato wrote:
> From: Richard Henderson <richard.henderson@linaro.org>

> 

> Collected, to be used in the next patch.

> 

> Reviewed-by: Yoshinori Sato <ysato@users.sourceforge.jp>

> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>


Again:
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>


> Signed-off-by: Yoshinori Sato <ysato@users.sourceforge.jp>

> ---

>  target/rx/disas.c | 62 +++++++++++++++++++++++++++++++++++++------------------

>  1 file changed, 42 insertions(+), 20 deletions(-)

> 

> diff --git a/target/rx/disas.c b/target/rx/disas.c

> index ebc1a44249..5a32a87534 100644

> --- a/target/rx/disas.c

> +++ b/target/rx/disas.c

> @@ -25,43 +25,59 @@ typedef struct DisasContext {

>      disassemble_info *dis;

>      uint32_t addr;

>      uint32_t pc;

> +    uint8_t len;

> +    uint8_t bytes[8];

>  } DisasContext;

>  

>  

>  static uint32_t decode_load_bytes(DisasContext *ctx, uint32_t insn,

> -                           int i, int n)

> +                                  int i, int n)

>  {

> -    bfd_byte buf;

> +    uint32_t addr = ctx->addr;

> +

> +    g_assert(ctx->len == i);

> +    g_assert(n <= ARRAY_SIZE(ctx->bytes));

> +

>      while (++i <= n) {

> -        ctx->dis->read_memory_func(ctx->addr++, &buf, 1, ctx->dis);

> -        insn |= buf << (32 - i * 8);

> +        ctx->dis->read_memory_func(addr++, &ctx->bytes[i - 1], 1, ctx->dis);

> +        insn |= ctx->bytes[i - 1] << (32 - i * 8);

>      }

> +    ctx->addr = addr;

> +    ctx->len = n;

> +

>      return insn;

>  }

>  

>  static int32_t li(DisasContext *ctx, int sz)

>  {

> -    int32_t addr;

> -    bfd_byte buf[4];

> -    addr = ctx->addr;

> +    uint32_t addr = ctx->addr;

> +    uintptr_t len = ctx->len;

>  

>      switch (sz) {

>      case 1:

> +        g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes));

>          ctx->addr += 1;

> -        ctx->dis->read_memory_func(addr, buf, 1, ctx->dis);

> -        return (int8_t)buf[0];

> +        ctx->len += 1;

> +        ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis);

> +        return (int8_t)ctx->bytes[len];

>      case 2:

> +        g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes));

>          ctx->addr += 2;

> -        ctx->dis->read_memory_func(addr, buf, 2, ctx->dis);

> -        return ldsw_le_p(buf);

> +        ctx->len += 2;

> +        ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis);

> +        return ldsw_le_p(ctx->bytes + len);

>      case 3:

> +        g_assert(len + 3 <= ARRAY_SIZE(ctx->bytes));

>          ctx->addr += 3;

> -        ctx->dis->read_memory_func(addr, buf, 3, ctx->dis);

> -        return (int8_t)buf[2] << 16 | lduw_le_p(buf);

> +        ctx->len += 3;

> +        ctx->dis->read_memory_func(addr, ctx->bytes + len, 3, ctx->dis);

> +        return (int8_t)ctx->bytes[len + 2] << 16 | lduw_le_p(ctx->bytes + len);

>      case 0:

> +        g_assert(len + 4 <= ARRAY_SIZE(ctx->bytes));

>          ctx->addr += 4;

> -        ctx->dis->read_memory_func(addr, buf, 4, ctx->dis);

> -        return ldl_le_p(buf);

> +        ctx->len += 4;

> +        ctx->dis->read_memory_func(addr, ctx->bytes + len, 4, ctx->dis);

> +        return ldl_le_p(ctx->bytes + len);

>      default:

>          g_assert_not_reached();

>      }

> @@ -110,7 +126,7 @@ static const char psw[] = {

>  static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi)

>  {

>      uint32_t addr = ctx->addr;

> -    uint8_t buf[2];

> +    uintptr_t len = ctx->len;

>      uint16_t dsp;

>  

>      switch (ld) {

> @@ -119,14 +135,18 @@ static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi)

>          out[0] = '\0';

>          return;

>      case 1:

> +        g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes));

>          ctx->addr += 1;

> -        ctx->dis->read_memory_func(addr, buf, 1, ctx->dis);

> -        dsp = buf[0];

> +        ctx->len += 1;

> +        ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis);

> +        dsp = ctx->bytes[len];

>          break;

>      case 2:

> +        g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes));

>          ctx->addr += 2;

> -        ctx->dis->read_memory_func(addr, buf, 2, ctx->dis);

> -        dsp = lduw_le_p(buf);

> +        ctx->len += 2;

> +        ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis);

> +        dsp = lduw_le_p(ctx->bytes + len);

>          break;

>      default:

>          g_assert_not_reached();

> @@ -1392,8 +1412,10 @@ int print_insn_rx(bfd_vma addr, disassemble_info *dis)

>      DisasContext ctx;

>      uint32_t insn;

>      int i;

> +

>      ctx.dis = dis;

>      ctx.pc = ctx.addr = addr;

> +    ctx.len = 0;

>  

>      insn = decode_load(&ctx);

>      if (!decode(&ctx, insn)) {

>
diff mbox series

Patch

diff --git a/target/rx/disas.c b/target/rx/disas.c
index ebc1a44249..5a32a87534 100644
--- a/target/rx/disas.c
+++ b/target/rx/disas.c
@@ -25,43 +25,59 @@  typedef struct DisasContext {
     disassemble_info *dis;
     uint32_t addr;
     uint32_t pc;
+    uint8_t len;
+    uint8_t bytes[8];
 } DisasContext;
 
 
 static uint32_t decode_load_bytes(DisasContext *ctx, uint32_t insn,
-                           int i, int n)
+                                  int i, int n)
 {
-    bfd_byte buf;
+    uint32_t addr = ctx->addr;
+
+    g_assert(ctx->len == i);
+    g_assert(n <= ARRAY_SIZE(ctx->bytes));
+
     while (++i <= n) {
-        ctx->dis->read_memory_func(ctx->addr++, &buf, 1, ctx->dis);
-        insn |= buf << (32 - i * 8);
+        ctx->dis->read_memory_func(addr++, &ctx->bytes[i - 1], 1, ctx->dis);
+        insn |= ctx->bytes[i - 1] << (32 - i * 8);
     }
+    ctx->addr = addr;
+    ctx->len = n;
+
     return insn;
 }
 
 static int32_t li(DisasContext *ctx, int sz)
 {
-    int32_t addr;
-    bfd_byte buf[4];
-    addr = ctx->addr;
+    uint32_t addr = ctx->addr;
+    uintptr_t len = ctx->len;
 
     switch (sz) {
     case 1:
+        g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes));
         ctx->addr += 1;
-        ctx->dis->read_memory_func(addr, buf, 1, ctx->dis);
-        return (int8_t)buf[0];
+        ctx->len += 1;
+        ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis);
+        return (int8_t)ctx->bytes[len];
     case 2:
+        g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes));
         ctx->addr += 2;
-        ctx->dis->read_memory_func(addr, buf, 2, ctx->dis);
-        return ldsw_le_p(buf);
+        ctx->len += 2;
+        ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis);
+        return ldsw_le_p(ctx->bytes + len);
     case 3:
+        g_assert(len + 3 <= ARRAY_SIZE(ctx->bytes));
         ctx->addr += 3;
-        ctx->dis->read_memory_func(addr, buf, 3, ctx->dis);
-        return (int8_t)buf[2] << 16 | lduw_le_p(buf);
+        ctx->len += 3;
+        ctx->dis->read_memory_func(addr, ctx->bytes + len, 3, ctx->dis);
+        return (int8_t)ctx->bytes[len + 2] << 16 | lduw_le_p(ctx->bytes + len);
     case 0:
+        g_assert(len + 4 <= ARRAY_SIZE(ctx->bytes));
         ctx->addr += 4;
-        ctx->dis->read_memory_func(addr, buf, 4, ctx->dis);
-        return ldl_le_p(buf);
+        ctx->len += 4;
+        ctx->dis->read_memory_func(addr, ctx->bytes + len, 4, ctx->dis);
+        return ldl_le_p(ctx->bytes + len);
     default:
         g_assert_not_reached();
     }
@@ -110,7 +126,7 @@  static const char psw[] = {
 static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi)
 {
     uint32_t addr = ctx->addr;
-    uint8_t buf[2];
+    uintptr_t len = ctx->len;
     uint16_t dsp;
 
     switch (ld) {
@@ -119,14 +135,18 @@  static void rx_index_addr(DisasContext *ctx, char out[8], int ld, int mi)
         out[0] = '\0';
         return;
     case 1:
+        g_assert(len + 1 <= ARRAY_SIZE(ctx->bytes));
         ctx->addr += 1;
-        ctx->dis->read_memory_func(addr, buf, 1, ctx->dis);
-        dsp = buf[0];
+        ctx->len += 1;
+        ctx->dis->read_memory_func(addr, ctx->bytes + len, 1, ctx->dis);
+        dsp = ctx->bytes[len];
         break;
     case 2:
+        g_assert(len + 2 <= ARRAY_SIZE(ctx->bytes));
         ctx->addr += 2;
-        ctx->dis->read_memory_func(addr, buf, 2, ctx->dis);
-        dsp = lduw_le_p(buf);
+        ctx->len += 2;
+        ctx->dis->read_memory_func(addr, ctx->bytes + len, 2, ctx->dis);
+        dsp = lduw_le_p(ctx->bytes + len);
         break;
     default:
         g_assert_not_reached();
@@ -1392,8 +1412,10 @@  int print_insn_rx(bfd_vma addr, disassemble_info *dis)
     DisasContext ctx;
     uint32_t insn;
     int i;
+
     ctx.dis = dis;
     ctx.pc = ctx.addr = addr;
+    ctx.len = 0;
 
     insn = decode_load(&ctx);
     if (!decode(&ctx, insn)) {