From a54a3df32c379a6953664f1d9241c731066915ec Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.osdn.me>
Date: Sun, 24 May 2020 00:19:04 +0900
Subject: Extended mruby binary format

The catch handler table is combined with iseq block.
This is to prevent the structure from growing by adding a field for the
catch handler table to the `mrb_irep` structure.

"iseq block" and "catch handler table":
  [number of catch handler table (2 bytes)]
  [number of byte code (4 bytes)]
  [iseq (any bytes)]
  [catch handlers (multiple of 7 bytes)]

catch handler:
  [catch type (1 byte)]
  [begin offset (2 bytes)]
  [end offset (2 bytes)]
  [target offset (2 bytes)]

catch type: enum mrb_catch_type (0 = rescue, 1 = ensure)
begin offset: Includes the specified instruction address
end offset: Does not include the specified instruction address
target offset: replaces pc with the specified instruction address

This table is not expanded by `read_irep_record_1()`.
The necessary elements are expanded one by one when used.
---
 src/codedump.c | 29 +++++++++++++++++++++++++++++
 src/dump.c     | 32 ++++++++++++++++++++++++++++++++
 src/load.c     | 11 +++++++----
 3 files changed, 68 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/codedump.c b/src/codedump.c
index 106312f67..a19d60708 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -4,6 +4,7 @@
 #include <mruby/opcode.h>
 #include <mruby/string.h>
 #include <mruby/proc.h>
+#include <mruby/dump.h>
 
 #ifndef MRB_DISABLE_STDIO
 static void
@@ -80,6 +81,34 @@ codedump(mrb_state *mrb, const mrb_irep *irep)
     }
   }
 
+  if (irep->clen > 0) {
+    int i = irep->clen;
+    const struct mrb_irep_catch_hander *e = mrb_irep_catch_handler_table(irep);
+
+    for (; i > 0; i --, e ++) {
+      int begin = bin_to_uint16(e->begin);
+      int end = bin_to_uint16(e->end);
+      int target = bin_to_uint16(e->target);
+      char buf[20];
+      const char *type;
+
+      switch (e->type) {
+        case MRB_CATCH_RESCUE:
+          type = "rescue";
+          break;
+        case MRB_CATCH_ENSURE:
+          type = "ensure";
+          break;
+        default:
+          buf[0] = '\0';
+          snprintf(buf, sizeof(buf), "0x%02x <unknown>", (int)e->type);
+          type = buf;
+          break;
+      }
+      printf("catch type: %-8s begin: %04d end: %04d target: %04d\n", type, begin, end, target);
+    }
+  }
+
   pc = irep->iseq;
   pcend = pc + irep->ilen;
   while (pc < pcend) {
diff --git a/src/dump.c b/src/dump.c
index 6acba12c2..884c44dc6 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -273,6 +273,31 @@ write_syms_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
   return cur - buf;
 }
 
+static size_t
+get_catch_table_block_size(mrb_state *mrb, const mrb_irep *irep)
+{
+  size_t size = 0;
+
+  size += sizeof(uint16_t); /* number of catch handler */
+  size += (sizeof(struct mrb_irep_catch_hander)) * irep->clen;
+
+  return size;
+}
+
+static ptrdiff_t
+write_catch_table_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
+{
+  uint8_t *cur = buf;
+  const struct mrb_irep_catch_hander *e = mrb_irep_catch_handler_table(irep);
+  mrb_static_assert1(sizeof(*e) == 7);
+
+  /* irep->clen has already been written before iseq block */
+  memcpy(cur, (const void *)e, sizeof(*e) * irep->clen);
+  cur += sizeof(*e) * irep->clen;
+
+  return cur - buf;
+}
+
 static size_t
 get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep)
 {
@@ -280,6 +305,7 @@ get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep)
 
   size += get_irep_header_size(mrb);
   size += get_iseq_block_size(mrb, irep);
+  size += get_catch_table_block_size(mrb, irep);
   size += get_pool_block_size(mrb, irep);
   size += get_syms_block_size(mrb, irep);
   return size;
@@ -314,7 +340,13 @@ write_irep_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *ir
   }
 
   bin += write_irep_header(mrb, irep, bin);
+  /*
+   * The catch handler table is after iseq block, but the number of
+   * elements is placed before iseq block.
+   */
+  bin += uint16_to_bin(irep->clen, bin);
   bin += write_iseq_block(mrb, irep, bin, flags);
+  bin += write_catch_table_block(mrb, irep, bin);
   bin += write_pool_block(mrb, irep, bin);
   bin += write_syms_block(mrb, irep, bin);
 
diff --git a/src/load.c b/src/load.c
index 1118fc2ad..59790bc17 100644
--- a/src/load.c
+++ b/src/load.c
@@ -96,27 +96,30 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
   src += sizeof(uint16_t);
 
   /* Binary Data Section */
-  /* ISEQ BLOCK */
+  /* ISEQ BLOCK (and CATCH HANDLER TABLE BLOCK) */
+  irep->clen = bin_to_uint16(src);  /* number of catch handler */
+  src += sizeof(uint16_t);
   irep->ilen = (uint16_t)bin_to_uint32(src);
   src += sizeof(uint32_t);
   src += skip_padding(src);
 
   if (irep->ilen > 0) {
+    size_t data_len = sizeof(mrb_code) * irep->ilen +
+                      sizeof(struct mrb_irep_catch_hander) * irep->clen;
+    mrb_static_assert1(sizeof(struct mrb_irep_catch_hander) == 7);
     if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) {
       return NULL;
     }
     if ((flags & FLAG_SRC_MALLOC) == 0) {
       irep->iseq = (mrb_code*)src;
-      src += sizeof(mrb_code) * irep->ilen;
       irep->flags |= MRB_ISEQ_NO_FREE;
     }
     else {
-      size_t data_len = sizeof(mrb_code) * irep->ilen;
       void *buf = mrb_malloc(mrb, data_len);
       irep->iseq = (mrb_code *)buf;
       memcpy(buf, src, data_len);
-      src += data_len;
     }
+    src += data_len;
   }
 
   /* POOL BLOCK */
-- 
cgit v1.2.3