From 4c7f9897c2fc1b180a7758130c8e6694d2361c96 Mon Sep 17 00:00:00 2001
From: take_cheeze <takechi101010@gmail.com>
Date: Tue, 29 Apr 2014 20:45:12 +0900
Subject: Support local variables information dumping.

---
 include/mruby/dump.h |   5 ++
 include/mruby/irep.h |   2 +-
 src/codegen.c        |   7 ++-
 src/dump.c           | 157 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 src/load.c           | 104 ++++++++++++++++++++++++++++++++++
 5 files changed, 270 insertions(+), 5 deletions(-)

diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index 35546f9de..b0e96db77 100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -52,6 +52,7 @@ mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 #define RITE_SECTION_IREP_IDENTIFIER   "IREP"
 #define RITE_SECTION_LINENO_IDENTIFIER "LINE"
 #define RITE_SECTION_DEBUG_IDENTIFIER  "DBG\0"
+#define RITE_SECTION_LV_IDENTIFIER     "LOCV"
 
 #define MRB_DUMP_DEFAULT_STR_LEN      128
 
@@ -88,6 +89,10 @@ struct rite_section_debug_header {
   RITE_SECTION_HEADER;
 };
 
+struct rite_section_lv_header {
+  RITE_SECTION_HEADER;
+};
+
 struct rite_binary_footer {
   RITE_SECTION_HEADER;
 };
diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 13298f17f..a06483090 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -41,7 +41,7 @@ typedef struct mrb_irep {
   uint16_t *lines;
   struct mrb_irep_debug_info* debug_info;
 
-  size_t ilen, plen, slen, rlen, refcnt;
+  size_t ilen, plen, slen, rlen, lv_len, refcnt;
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
diff --git a/src/codegen.c b/src/codegen.c
index 0347f8e7a..822dfef88 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -2496,11 +2496,16 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
   p->lv = lv;
   p->sp += node_len(lv)+1;        /* add self */
   p->nlocals = p->sp;
+  p->irep->lv_len = 0;
   if (lv) {
     node *n = lv;
     size_t i = 0;
 
-    p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals)*p->nlocals);
+    for (n=lv; n; n=n->cdr) {
+      p->irep->lv_len++;
+    }
+
+    p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals)*p->irep->lv_len);
     for (i=0, n=lv; n; i++,n=n->cdr) {
       p->irep->lv[i].name = lv_name(n);
       p->irep->lv[i].r = lv_idx(p, lv_name(n));
diff --git a/src/dump.c b/src/dump.c
index a2bcab99b..c06c5a49e 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -500,7 +500,7 @@ get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static int
-find_filename_index(const mrb_sym *ary, uint16_t ary_len, mrb_sym s)
+find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s)
 {
   int i;
 
@@ -692,6 +692,143 @@ write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur)
   return MRB_DUMP_OK;
 }
 
+static void
+create_lv_sym_table(mrb_state *mrb, mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len)
+{
+  size_t i;
+
+  if (*syms == NULL) {
+    *syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * 1);
+  }
+
+  for (i = 0; i < irep->lv_len; ++i) {
+    mrb_sym const name = irep->lv[i].name;
+    if (find_filename_index(*syms, *syms_len, name) != -1) continue;
+
+    ++(*syms_len);
+    *syms = (mrb_sym*)mrb_realloc(mrb, *syms, sizeof(mrb_sym) * (*syms_len));
+    (*syms)[*syms_len - 1] = name;
+  }
+
+  for (i = 0; i < irep->rlen; ++i) {
+    create_lv_sym_table(mrb, irep->reps[i], syms, syms_len);
+  }
+}
+
+static int
+write_lv_sym_table(mrb_state *mrb, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
+{
+  uint8_t *cur = *start;
+  uint32_t i;
+  const char *str;
+  mrb_int str_len;
+
+  cur += uint32_to_bin(syms_len, cur);
+
+  for (i = 0; i < syms_len; ++i) {
+    str = mrb_sym2name_len(mrb, syms[i], &str_len);
+    cur += uint16_to_bin(str_len, cur);
+    memcpy(cur, str, str_len);
+    cur += str_len;
+  }
+
+  *start = cur;
+
+  return MRB_DUMP_OK;
+}
+
+static int
+write_lv_record(mrb_state *mrb, mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
+{
+  uint8_t *cur = *start;
+  size_t i;
+
+  cur += uint16_to_bin(irep->lv_len, cur);
+  for (i = 0; i < irep->lv_len; ++i) {
+    int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);
+    mrb_assert(sym_idx != -1); /* local variable name must be in syms */
+
+    cur += uint16_to_bin(sym_idx, cur);
+    cur += uint32_to_bin(irep->lv[i].r, cur);
+  }
+
+  for (i = 0; i < irep->rlen; ++i) {
+    write_lv_record(mrb, irep->reps[i], &cur, syms, syms_len);
+  }
+
+  *start = cur;
+
+  return MRB_DUMP_OK;
+}
+
+static size_t
+get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
+{
+  size_t ret = 0, i;
+
+  ret += sizeof(uint16_t); /* lv_len */
+  ret += (sizeof(uint16_t) + sizeof(uint32_t)) * irep->lv_len;
+
+  for (i = 0; i < irep->rlen; ++i) {
+    ret += get_lv_record_size(mrb, irep->reps[i]);
+  }
+
+  return ret;
+}
+
+static size_t
+get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len)
+{
+  size_t ret = 0, i;
+
+  ret += sizeof(uint32_t); /* syms_len */
+  ret += sizeof(uint16_t) * syms_len; /* symbol name lengths */
+  for (i = 0; i < syms_len; ++i) {
+    mrb_int str_len;
+    mrb_sym2name_len(mrb, syms[i], &str_len);
+    ret += str_len;
+  }
+
+  ret += get_lv_record_size(mrb, irep);
+
+  return ret;
+}
+
+static int
+write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
+{
+  uint8_t *cur = start;
+  struct rite_section_lv_header *header;
+  ptrdiff_t diff;
+  int result = MRB_DUMP_OK;
+
+  if (mrb == NULL || cur == NULL) {
+    return MRB_DUMP_INVALID_ARGUMENT;
+  }
+
+  header = (struct rite_section_lv_header*)cur;
+  cur += sizeof(struct rite_section_lv_header);
+
+  result = write_lv_sym_table(mrb, &cur, syms, syms_len);
+  if (result != MRB_DUMP_OK) {
+    goto lv_section_exit;
+  }
+
+  result = write_lv_record(mrb, irep, &cur, syms, syms_len);
+  if (result != MRB_DUMP_OK) {
+    goto lv_section_exit;
+  }
+
+  memcpy(header->section_identify, RITE_SECTION_LV_IDENTIFIER, sizeof(header->section_identify));
+
+  diff = cur - start;
+  mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
+  uint32_to_bin(diff, header->section_size);
+
+lv_section_exit:
+  return result;
+}
+
 static int
 write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin)
 {
@@ -730,9 +867,10 @@ dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t
 {
   int result = MRB_DUMP_GENERAL_FAILURE;
   size_t section_irep_size;
-  size_t section_lineno_size = 0;
+  size_t section_lineno_size = 0, section_lv_size = 0;
   uint8_t *cur = NULL;
   mrb_bool const debug_info_defined = is_debug_info_defined(irep);
+  mrb_sym *lv_syms = NULL; uint32_t lv_syms_len = 0;
 
   if (mrb == NULL) {
     *bin = NULL;
@@ -764,8 +902,12 @@ dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t
     }
   }
 
+  section_lv_size += sizeof(struct rite_section_lv_header);
+  create_lv_sym_table(mrb, irep, &lv_syms, &lv_syms_len);
+  section_lv_size += get_lv_section_size(mrb, irep, lv_syms, lv_syms_len);
+
   *bin_size = sizeof(struct rite_binary_header) +
-              section_irep_size + section_lineno_size +
+              section_irep_size + section_lineno_size + section_lv_size +
               sizeof(struct rite_binary_footer);
   cur = *bin = (uint8_t*)mrb_malloc(mrb, *bin_size);
   if (cur == NULL) {
@@ -793,6 +935,12 @@ dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t
     cur += section_lineno_size;
   }
 
+  result = write_section_lv(mrb, irep, cur, lv_syms, lv_syms_len);
+  if (result != MRB_DUMP_OK) {
+    goto error_exit;
+  }
+  cur += section_lv_size;
+
   write_footer(mrb, cur);
   write_rite_binary_header(mrb, *bin_size, *bin);
 
@@ -801,6 +949,9 @@ error_exit:
     mrb_free(mrb, *bin);
     *bin = NULL;
   }
+  if (lv_syms) {
+    mrb_free(mrb, lv_syms);
+  }
   return result;
 }
 
diff --git a/src/load.c b/src/load.c
index c6aff4f9c..27832af3c 100644
--- a/src/load.c
+++ b/src/load.c
@@ -401,6 +401,88 @@ debug_exit:
   return result;
 }
 
+static int
+read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len)
+{
+  const uint8_t *bin = start;
+  size_t i;
+  ptrdiff_t diff;
+
+  irep->lv_len = bin_to_uint16(bin);
+  bin += sizeof(uint16_t);
+  irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * irep->lv_len);
+
+  for (i = 0; i < irep->lv_len; ++i) {
+    uint16_t const sym_idx = bin_to_uint16(bin);
+    bin += sizeof(uint16_t);
+    if (sym_idx >= syms_len) {
+      return MRB_DUMP_GENERAL_FAILURE;
+    }
+    irep->lv[i].name = syms[sym_idx];
+
+    irep->lv[i].r = bin_to_uint32(bin);
+    bin += sizeof(uint32_t);
+  }
+
+  for (i = 0; i < irep->rlen; ++i) {
+    size_t len;
+    int ret;
+
+    ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len);
+    if (ret != MRB_DUMP_OK) return ret;
+    bin += len;
+  }
+
+  diff = bin - start;
+  mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
+  *record_len = (size_t)diff;
+
+  return MRB_DUMP_OK;
+}
+
+static int
+read_section_lv(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_bool alloc)
+{
+  const uint8_t *bin;
+  ptrdiff_t diff;
+  struct rite_section_lv_header const *header;
+  uint32_t i;
+  size_t len = 0;
+  int result;
+  uint32_t syms_len;
+  mrb_sym *syms;
+  mrb_sym (*intern_func)(mrb_state*, const char*, size_t) = alloc? mrb_intern : mrb_intern_static;
+
+  bin = start;
+  header = (struct rite_section_lv_header const*)bin;
+  bin += sizeof(struct rite_section_lv_header);
+
+  syms_len = bin_to_uint32(bin);
+  bin += sizeof(uint32_t);
+  syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)syms_len);
+  for (i = 0; i < syms_len; ++i) {
+    uint16_t const str_len = bin_to_uint16(bin);
+    bin += sizeof(uint16_t);
+
+    syms[i] = intern_func(mrb, (const char*)bin, str_len);
+    bin += str_len;
+  }
+
+  result = read_lv_record(mrb, bin, irep, &len, syms, syms_len);
+  if (result != MRB_DUMP_OK) goto lv_exit;
+
+  bin += len;
+  diff = bin - start;
+  mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
+  if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
+    result = MRB_DUMP_GENERAL_FAILURE;
+  }
+
+lv_exit:
+  mrb_free(mrb, syms);
+  return result;
+}
+
 static int
 read_binary_header(const uint8_t *bin, size_t *bin_size, uint16_t *crc)
 {
@@ -467,6 +549,13 @@ mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
         return NULL;
       }
     }
+    else if (memcmp(section_header->section_identify, RITE_SECTION_LV_IDENTIFIER, sizeof(section_header->section_identify)) == 0) {
+      if (!irep) return NULL;
+      result = read_section_lv(mrb, bin, irep, FALSE);
+      if (result < MRB_DUMP_OK) {
+        return NULL;
+      }
+    }
     bin += bin_to_uint32(section_header->section_size);
   } while (memcmp(section_header->section_identify, RITE_BINARY_EOF, sizeof(section_header->section_identify)) != 0);
 
@@ -686,6 +775,21 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
       }
       if (result < MRB_DUMP_OK) return NULL;
     }
+    else if (memcmp(section_header.section_identify, RITE_SECTION_LV_IDENTIFIER, sizeof(section_header.section_identify)) == 0) {
+      if (!irep) return NULL;
+      else {
+        uint8_t* const bin = (uint8_t*)mrb_malloc(mrb, section_size);
+
+        fseek(fp, fpos, SEEK_SET);
+        if (fread((char*)bin, section_size, 1, fp) != 1) {
+          mrb_free(mrb, bin);
+          return NULL;
+        }
+        result = read_section_lv(mrb, bin, irep, TRUE);
+        mrb_free(mrb, bin);
+      }
+      if (result < MRB_DUMP_OK) return NULL;
+    }
 
     fseek(fp, fpos + section_size, SEEK_SET);
   } while (memcmp(section_header.section_identify, RITE_BINARY_EOF, sizeof(section_header.section_identify)) != 0);
-- 
cgit v1.2.3


From 7ea82fedd5585bc753464aae7fc406cd2f1ce08e Mon Sep 17 00:00:00 2001
From: take_cheeze <takechi101010@gmail.com>
Date: Tue, 29 Apr 2014 20:46:24 +0900
Subject: Implement Kernel.local_variables for testing dumped local variables
 information.

---
 mrbgems/mruby-proc-ext/src/proc.c   | 24 ++++++++++++++++++++++++
 mrbgems/mruby-proc-ext/test/proc.rb |  8 ++++++++
 2 files changed, 32 insertions(+)

diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index b105c95d7..964a7c9bb 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -122,6 +122,29 @@ mrb_kernel_proc(mrb_state *mrb, mrb_value self)
   return blk;
 }
 
+static mrb_value
+mrb_local_variables(mrb_state *mrb, mrb_value self)
+{
+  mrb_value ret;
+  struct RProc *proc;
+  struct mrb_irep *irep;
+  size_t i;
+
+  proc = mrb->c->ci[-1].proc;
+
+  if (MRB_PROC_CFUNC_P(proc)) {
+    return mrb_ary_new(mrb);
+  }
+
+  irep = proc->body.irep;
+  ret = mrb_ary_new_capa(mrb, irep->lv_len);
+  for (i = 0; i < irep->lv_len; ++i) {
+    mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name));
+  }
+
+  return ret;
+}
+
 void
 mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
 {
@@ -133,6 +156,7 @@ mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
 
   mrb_define_class_method(mrb, mrb->kernel_module, "proc", mrb_kernel_proc, MRB_ARGS_NONE());
   mrb_define_method(mrb, mrb->kernel_module,       "proc", mrb_kernel_proc, MRB_ARGS_NONE());
+  mrb_define_module_function(mrb, mrb->kernel_module, "local_variables", mrb_local_variables, MRB_ARGS_NONE());
 }
 
 void
diff --git a/mrbgems/mruby-proc-ext/test/proc.rb b/mrbgems/mruby-proc-ext/test/proc.rb
index 0f5ecfb94..a5611e586 100644
--- a/mrbgems/mruby-proc-ext/test/proc.rb
+++ b/mrbgems/mruby-proc-ext/test/proc.rb
@@ -74,3 +74,11 @@ assert('mrb_cfunc_env_get') do
 
   assert_equal 1, t.get_int(1)
 end
+
+assert('Kernel.local_variables') do
+  a, b = 0, 1
+  a += b
+
+  vars = Kernel.local_variables.sort
+  assert_equal [:a, :b, :vars], vars
+end
-- 
cgit v1.2.3


From 5073d14e280a82e4cb4e41692154de825b07b5e9 Mon Sep 17 00:00:00 2001
From: take_cheeze <takechi101010@gmail.com>
Date: Tue, 29 Apr 2014 22:06:59 +0900
Subject: Remove `lv_len` and use `nlocals - 1` instead. Check that `lv`'s
 length is always `nlocals - 1`.

---
 include/mruby/irep.h              |  2 +-
 mrbgems/mruby-proc-ext/src/proc.c |  4 ++--
 src/codegen.c                     |  8 ++------
 src/dump.c                        | 12 +++++-------
 src/load.c                        |  6 ++----
 5 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index a06483090..13298f17f 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -41,7 +41,7 @@ typedef struct mrb_irep {
   uint16_t *lines;
   struct mrb_irep_debug_info* debug_info;
 
-  size_t ilen, plen, slen, rlen, lv_len, refcnt;
+  size_t ilen, plen, slen, rlen, refcnt;
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index 964a7c9bb..341001f05 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -137,8 +137,8 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
   }
 
   irep = proc->body.irep;
-  ret = mrb_ary_new_capa(mrb, irep->lv_len);
-  for (i = 0; i < irep->lv_len; ++i) {
+  ret = mrb_ary_new_capa(mrb, irep->nlocals - 1);
+  for (i = 0; i < (irep->nlocals - 1); ++i) {
     mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name));
   }
 
diff --git a/src/codegen.c b/src/codegen.c
index 822dfef88..5e22e199f 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -2496,20 +2496,16 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
   p->lv = lv;
   p->sp += node_len(lv)+1;        /* add self */
   p->nlocals = p->sp;
-  p->irep->lv_len = 0;
   if (lv) {
     node *n = lv;
     size_t i = 0;
 
-    for (n=lv; n; n=n->cdr) {
-      p->irep->lv_len++;
-    }
-
-    p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals)*p->irep->lv_len);
+    p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (p->nlocals - 1));
     for (i=0, n=lv; n; i++,n=n->cdr) {
       p->irep->lv[i].name = lv_name(n);
       p->irep->lv[i].r = lv_idx(p, lv_name(n));
     }
+    mrb_assert(i == (p->nlocals - 1));
   }
   p->ai = mrb_gc_arena_save(mrb);
 
diff --git a/src/dump.c b/src/dump.c
index c06c5a49e..854ddfe33 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -693,7 +693,7 @@ write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur)
 }
 
 static void
-create_lv_sym_table(mrb_state *mrb, mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len)
+create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len)
 {
   size_t i;
 
@@ -701,7 +701,7 @@ create_lv_sym_table(mrb_state *mrb, mrb_irep *irep, mrb_sym **syms, uint32_t *sy
     *syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * 1);
   }
 
-  for (i = 0; i < irep->lv_len; ++i) {
+  for (i = 0; i < (irep->nlocals - 1); ++i) {
     mrb_sym const name = irep->lv[i].name;
     if (find_filename_index(*syms, *syms_len, name) != -1) continue;
 
@@ -738,13 +738,12 @@ write_lv_sym_table(mrb_state *mrb, uint8_t **start, mrb_sym const *syms, uint32_
 }
 
 static int
-write_lv_record(mrb_state *mrb, mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
+write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
 {
   uint8_t *cur = *start;
   size_t i;
 
-  cur += uint16_to_bin(irep->lv_len, cur);
-  for (i = 0; i < irep->lv_len; ++i) {
+  for (i = 0; i < (irep->nlocals - 1); ++i) {
     int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);
     mrb_assert(sym_idx != -1); /* local variable name must be in syms */
 
@@ -766,8 +765,7 @@ get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t ret = 0, i;
 
-  ret += sizeof(uint16_t); /* lv_len */
-  ret += (sizeof(uint16_t) + sizeof(uint32_t)) * irep->lv_len;
+  ret += (sizeof(uint16_t) + sizeof(uint32_t)) * (irep->nlocals - 1);
 
   for (i = 0; i < irep->rlen; ++i) {
     ret += get_lv_record_size(mrb, irep->reps[i]);
diff --git a/src/load.c b/src/load.c
index 27832af3c..912a28218 100644
--- a/src/load.c
+++ b/src/load.c
@@ -408,11 +408,9 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec
   size_t i;
   ptrdiff_t diff;
 
-  irep->lv_len = bin_to_uint16(bin);
-  bin += sizeof(uint16_t);
-  irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * irep->lv_len);
+  irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
 
-  for (i = 0; i < irep->lv_len; ++i) {
+  for (i = 0; i < (irep->nlocals - 1); ++i) {
     uint16_t const sym_idx = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
     if (sym_idx >= syms_len) {
-- 
cgit v1.2.3


From 7a5d8a40fecb89c4f9fbbce46a12595f26a71260 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Wed, 14 May 2014 17:26:45 +0900
Subject: rename lv section header from LOCV to LVAR

---
 include/mruby/dump.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index d8713343e..1b691ea1a 100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -53,7 +53,7 @@ mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 #define RITE_SECTION_IREP_IDENTIFIER   "IREP"
 #define RITE_SECTION_LINENO_IDENTIFIER "LINE"
 #define RITE_SECTION_DEBUG_IDENTIFIER  "DBG\0"
-#define RITE_SECTION_LV_IDENTIFIER     "LOCV"
+#define RITE_SECTION_LV_IDENTIFIER     "LVAR"
 
 #define MRB_DUMP_DEFAULT_STR_LEN      128
 
-- 
cgit v1.2.3


From 9184d254e23c14a67b5b1aa5dc5dbbbf747a9ff6 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby-lang.org>
Date: Wed, 14 May 2014 17:32:30 +0900
Subject: resize register number in LVAR section from 32bits to 16bits

---
 include/mruby/irep.h | 2 +-
 src/codegen.c        | 6 +++---
 src/dump.c           | 8 ++++----
 src/load.c           | 6 +++---
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 13298f17f..3d6b5efc7 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -21,7 +21,7 @@ enum irep_pool_type {
 
 struct mrb_locals {
   mrb_sym name;
-  size_t r;
+  uint16_t r;
 };
 
 /* Program data array struct */
diff --git a/src/codegen.c b/src/codegen.c
index 226cd9bf8..6406c58b3 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -66,8 +66,8 @@ typedef struct scope {
   size_t scapa;
   size_t rcapa;
 
-  int nlocals;
-  int nregs;
+  uint16_t nlocals;
+  uint16_t nregs;
   int ai;
 
   int debug_start_pos;
@@ -2505,7 +2505,7 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
       p->irep->lv[i].name = lv_name(n);
       p->irep->lv[i].r = lv_idx(p, lv_name(n));
     }
-    mrb_assert(i == (p->nlocals - 1));
+    mrb_assert(i + 1 == p->nlocals);
   }
   p->ai = mrb_gc_arena_save(mrb);
 
diff --git a/src/dump.c b/src/dump.c
index 7ad3d6985..d0e230f1f 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -701,7 +701,7 @@ create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32
     *syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * 1);
   }
 
-  for (i = 0; i < (irep->nlocals - 1); ++i) {
+  for (i = 0; i + 1 < irep->nlocals; ++i) {
     mrb_sym const name = irep->lv[i].name;
     if (find_filename_index(*syms, *syms_len, name) != -1) continue;
 
@@ -743,12 +743,12 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c
   uint8_t *cur = *start;
   size_t i;
 
-  for (i = 0; i < (irep->nlocals - 1); ++i) {
+  for (i = 0; i + 1 < irep->nlocals; ++i) {
     int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);
     mrb_assert(sym_idx != -1); /* local variable name must be in syms */
 
     cur += uint16_to_bin(sym_idx, cur);
-    cur += uint32_to_bin(irep->lv[i].r, cur);
+    cur += uint16_to_bin(irep->lv[i].r, cur);
   }
 
   for (i = 0; i < irep->rlen; ++i) {
@@ -765,7 +765,7 @@ get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t ret = 0, i;
 
-  ret += (sizeof(uint16_t) + sizeof(uint32_t)) * (irep->nlocals - 1);
+  ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1);
 
   for (i = 0; i < irep->rlen; ++i) {
     ret += get_lv_record_size(mrb, irep->reps[i]);
diff --git a/src/load.c b/src/load.c
index dc5a5bf06..89a5f7cd2 100644
--- a/src/load.c
+++ b/src/load.c
@@ -408,7 +408,7 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec
 
   irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
 
-  for (i = 0; i < (irep->nlocals - 1); ++i) {
+  for (i = 0; i + 1< irep->nlocals; ++i) {
     uint16_t const sym_idx = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
     if (sym_idx >= syms_len) {
@@ -416,8 +416,8 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec
     }
     irep->lv[i].name = syms[sym_idx];
 
-    irep->lv[i].r = bin_to_uint32(bin);
-    bin += sizeof(uint32_t);
+    irep->lv[i].r = bin_to_uint16(bin);
+    bin += sizeof(uint16_t);
   }
 
   for (i = 0; i < irep->rlen; ++i) {
-- 
cgit v1.2.3