webruby 0.2.7 → 0.9.1

data/modules/mruby/src/dump.c

@@ -6,18 +6,39 @@
 
 #include <ctype.h>
 #include <string.h>
+#include <limits.h>
 #include "mruby/dump.h"
 #include "mruby/string.h"
 #include "mruby/irep.h"
 #include "mruby/numeric.h"
 #include "mruby/debug.h"
 
+#define FLAG_BYTEORDER_NATIVE 2
+#define FLAG_BYTEORDER_NONATIVE 0
+
+#ifdef ENABLE_STDIO
+
 static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep);
 
-static uint32_t
+#if UINT32_MAX > SIZE_MAX
+# error This code cannot be built on your environment.
+#endif
+
+static size_t
+write_padding(uint8_t *buf)
+{
+  const size_t align = MRB_DUMP_ALIGNMENT;
+  size_t pad_len = -(intptr_t)buf & (align-1);
+  if (pad_len > 0) {
+    memset(buf, 0, pad_len);
+  }
+  return pad_len;
+}
+
+static size_t
 get_irep_header_size(mrb_state *mrb)
 {
-  uint32_t size = 0;
+  size_t size = 0;
 
   size += sizeof(uint32_t) * 1;
   size += sizeof(uint16_t) * 3;
@@ -25,7 +46,7 @@ get_irep_header_size(mrb_state *mrb)
   return size;
 }
 
-static size_t
+static ptrdiff_t
 write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 {
   uint8_t *cur = buf;
@@ -35,31 +56,41 @@ write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
   cur += uint16_to_bin((uint16_t)irep->nregs, cur);  /* number of register variable */
   cur += uint16_to_bin((uint16_t)irep->rlen, cur);  /* number of child irep */
 
-  return (cur - buf);
+  return cur - buf;
 }
 
 
-static uint32_t
+static size_t
 get_iseq_block_size(mrb_state *mrb, mrb_irep *irep)
 {
-  uint32_t size = 0;
+  size_t size = 0;
+
   size += sizeof(uint32_t); /* ilen */
+  size += sizeof(uint32_t); /* max padding */
   size += sizeof(uint32_t) * irep->ilen; /* iseq(n) */
+
   return size;
 }
 
-static int
-write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+static ptrdiff_t
+write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
 {
   uint8_t *cur = buf;
-  size_t iseq_no;
+  uint32_t iseq_no;
 
   cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
-  for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
-    cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */
+  cur += write_padding(cur);
+  if (flags & FLAG_BYTEORDER_NATIVE) {
+    memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code));
+    cur += irep->ilen * sizeof(mrb_code);
+  }
+  else {
+    for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
+      cur += uint32_to_bin(irep->iseq[iseq_no], cur); /* opcode */
+    }
   }
 
-  return (cur - buf);
+  return cur - buf;
 }
 
 
@@ -68,7 +99,6 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t size = 0;
   size_t pool_no;
-  int len;
   mrb_value str;
   char buf[32];
 
@@ -81,16 +111,28 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
     switch (mrb_type(irep->pool[pool_no])) {
     case MRB_TT_FIXNUM:
       str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
-      size += RSTRING_LEN(str);
+      {
+        mrb_int len = RSTRING_LEN(str);
+        mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
+        size += (size_t)len;
+      }
       break;
 
     case MRB_TT_FLOAT:
-      len = mrb_float_to_str(buf, mrb_float(irep->pool[pool_no]));
-      size += len;
+      {
+        int len;
+        len = mrb_float_to_str(buf, mrb_float(irep->pool[pool_no]));
+        mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
+        size += (size_t)len;
+      }
       break;
 
     case MRB_TT_STRING:
-      size += RSTRING_LEN(irep->pool[pool_no]);
+      {
+        mrb_int len = RSTRING_LEN(irep->pool[pool_no]);
+        mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
+        size += (size_t)len;
+      }
       break;
 
     default:
@@ -102,12 +144,12 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
   return size;
 }
 
-static int
+static ptrdiff_t
 write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 {
   size_t pool_no;
   uint8_t *cur = buf;
-  size_t len;
+  uint16_t len;
   mrb_value str;
   const char *char_ptr;
   char char_buf[30];
@@ -122,19 +164,36 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
       cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */
       str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
       char_ptr = RSTRING_PTR(str);
-      len = RSTRING_LEN(str);
+      {
+        mrb_int tlen;
+
+        tlen = RSTRING_LEN(str);
+        mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
+        len = (uint16_t)tlen;
+      }
       break;
 
     case MRB_TT_FLOAT:
       cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */
-      len = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
+      {
+        int tlen;
+        tlen = mrb_float_to_str(char_buf, mrb_float(irep->pool[pool_no]));
+        mrb_assert_int_fit(int, tlen, uint16_t, UINT16_MAX);
+        len = (uint16_t)tlen;
+      }
       char_ptr = &char_buf[0];
       break;
 
     case MRB_TT_STRING:
       cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */
       char_ptr = RSTRING_PTR(irep->pool[pool_no]);
-      len = RSTRING_LEN(irep->pool[pool_no]);
+      {
+        mrb_int tlen;
+
+        tlen = RSTRING_LEN(irep->pool[pool_no]);
+        mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
+        len = (uint16_t)tlen;
+      }
       break;
 
     default:
@@ -142,13 +201,13 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
     }
 
     cur += uint16_to_bin(len, cur); /* data length */
-    memcpy(cur, char_ptr, len);
+    memcpy(cur, char_ptr, (size_t)len);
     cur += len;
 
     mrb_gc_arena_restore(mrb, ai);
   }
 
-  return (int)(cur - buf);
+  return cur - buf;
 }
 
 
@@ -156,8 +215,8 @@ static size_t
 get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t size = 0;
-  size_t sym_no;
-  size_t len;
+  uint32_t sym_no;
+  mrb_int len;
 
   size += sizeof(uint32_t); /* slen */
   for (sym_no = 0; sym_no < irep->slen; sym_no++) {
@@ -171,10 +230,10 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
   return size;
 }
 
-static int
+static ptrdiff_t
 write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 {
-  size_t sym_no;
+  uint32_t sym_no;
   uint8_t *cur = buf;
   const char *name;
 
@@ -182,13 +241,11 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 
   for (sym_no = 0; sym_no < irep->slen; sym_no++) {
     if (irep->syms[sym_no] != 0) {
-      size_t len;
+      mrb_int len;
 
       name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
-      if (len > UINT16_MAX) {
-        return MRB_DUMP_GENERAL_FAILURE;
-      }
 
+      mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
       cur += uint16_to_bin((uint16_t)len, cur); /* length of symbol name */
       memcpy(cur, name, len); /* symbol name */
       cur += (uint16_t)len;
@@ -199,13 +256,13 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
     }
   }
 
-  return (int)(cur - buf);
+  return cur - buf;
 }
 
 static size_t
 get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep)
 {
-  uint32_t size = 0;
+  size_t size = 0;
 
   size += get_irep_header_size(mrb);
   size += get_iseq_block_size(mrb, irep);
@@ -217,9 +274,9 @@ get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep)
 static size_t
 get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
 {
-  uint32_t size = 0;
+  size_t size = 0;
   size_t irep_no;
-  
+
   size = get_irep_record_size_1(mrb, irep);
   for (irep_no = 0; irep_no < irep->rlen; irep_no++) {
     size += get_irep_record_size(mrb, irep->reps[irep_no]);
@@ -228,9 +285,10 @@ get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static int
-write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin, uint32_t *irep_record_size)
+write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
 {
-  size_t i;
+  uint32_t i;
+  uint8_t *src = bin;
 
   if (irep == NULL) {
     return MRB_DUMP_INVALID_IREP;
@@ -241,28 +299,26 @@ write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin, uint32_t *irep_r
     return MRB_DUMP_GENERAL_FAILURE;
   }
 
-  memset(bin, 0, *irep_record_size);
-
   bin += write_irep_header(mrb, irep, bin);
-  bin += write_iseq_block(mrb, irep, bin);
+  bin += write_iseq_block(mrb, irep, bin, flags);
   bin += write_pool_block(mrb, irep, bin);
   bin += write_syms_block(mrb, irep, bin);
 
   for (i = 0; i < irep->rlen; i++) {
     int result;
-    uint32_t rlen;
+    size_t rsize;
 
-    result = write_irep_record(mrb, irep->reps[i], bin, &rlen);
+    result = write_irep_record(mrb, irep->reps[i], bin, &rsize, flags);
     if (result != MRB_DUMP_OK) {
       return result;
     }
-    *irep_record_size += rlen;
-    bin += rlen;
+    bin += rsize;
   }
+  *irep_record_size = bin - src;
   return MRB_DUMP_OK;
 }
 
-static size_t
+static uint32_t
 write_footer(mrb_state *mrb, uint8_t *bin)
 {
   struct rite_binary_footer footer;
@@ -276,22 +332,24 @@ write_footer(mrb_state *mrb, uint8_t *bin)
 
 
 static int
-write_section_irep_header(mrb_state *mrb, uint32_t section_size, uint8_t *bin)
+write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
 {
   struct rite_section_irep_header *header = (struct rite_section_irep_header*)bin;
 
   memcpy(header->section_identify, RITE_SECTION_IREP_IDENTIFIER, sizeof(header->section_identify));
-  uint32_to_bin(section_size, header->section_size);
+
+  mrb_assert_int_fit(size_t, section_size, uint32_t, UINT32_MAX);
+  uint32_to_bin((uint32_t)section_size, header->section_size);
   memcpy(header->rite_version, RITE_VM_VER, sizeof(header->rite_version));
 
   return MRB_DUMP_OK;
 }
 
 static int
-write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin)
+write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags)
 {
   int result;
-  uint32_t section_size = 0, rlen = 0; /* size of irep record */
+  size_t rsize = 0;
   uint8_t *cur = bin;
 
   if (mrb == NULL || bin == NULL) {
@@ -299,27 +357,24 @@ write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin)
   }
 
   cur += sizeof(struct rite_section_irep_header);
-  section_size += sizeof(struct rite_section_irep_header);
 
-  result = write_irep_record(mrb, irep, cur, &rlen);
+  result = write_irep_record(mrb, irep, cur, &rsize, flags);
   if (result != MRB_DUMP_OK) {
     return result;
   }
-  cur += rlen;
-  section_size += rlen;
-  write_section_irep_header(mrb, section_size, bin);
+  *len_p = cur - bin + rsize;
+  write_section_irep_header(mrb, *len_p, bin);
 
   return MRB_DUMP_OK;
 }
 
 static int
-write_section_lineno_header(mrb_state *mrb, uint32_t section_size, uint8_t *bin)
+write_section_lineno_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
 {
   struct rite_section_lineno_header *header = (struct rite_section_lineno_header*)bin;
 
-  // TODO
   memcpy(header->section_identify, RITE_SECTION_LINENO_IDENTIFIER, sizeof(header->section_identify));
-  uint32_to_bin(section_size, header->section_size);
+  uint32_to_bin((uint32_t)section_size, header->section_size);
 
   return MRB_DUMP_OK;
 }
@@ -329,30 +384,36 @@ get_lineno_record_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t size = 0;
 
-  size += sizeof(uint32_t); // record size
-  size += sizeof(uint16_t); // filename size
+  size += sizeof(uint32_t); /* record size */
+  size += sizeof(uint16_t); /* filename size */
   if (irep->filename) {
-    size += strlen(irep->filename); // filename
+    size += strlen(irep->filename); /* filename */
   }
-  size += sizeof(uint32_t); // niseq
+  size += sizeof(uint32_t); /* niseq */
   if (irep->lines) {
-    size += sizeof(uint16_t) * irep->ilen; // lineno
+    size += sizeof(uint16_t) * irep->ilen; /* lineno */
   }
+
   return size;
 }
 
-static int
+static size_t
 write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 {
   uint8_t *cur = bin;
-  size_t filename_len = 0, iseq_no;
+  size_t iseq_no;
+  size_t filename_len;
+  ptrdiff_t diff;
 
   cur += sizeof(uint32_t); /* record size */
 
   if (irep->filename) {
     filename_len = strlen(irep->filename);
+  } else {
+    filename_len = 0;
   }
-  cur += uint16_to_bin(filename_len, cur); /* filename size */
+  mrb_assert_int_fit(size_t, filename_len, uint16_t, UINT16_MAX);
+  cur += uint16_to_bin((uint16_t)filename_len, cur); /* filename size */
 
   if (filename_len) {
     memcpy(cur, irep->filename, filename_len);
@@ -360,7 +421,8 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
   }
 
   if (irep->lines) {
-    cur += uint32_to_bin(irep->ilen, cur); /* niseq */
+    mrb_assert_int_fit(size_t, irep->ilen, uint32_t, UINT32_MAX);
+    cur += uint32_to_bin((uint32_t)(irep->ilen), cur); /* niseq */
     for (iseq_no = 0; iseq_no < irep->ilen; iseq_no++) {
       cur += uint16_to_bin(irep->lines[iseq_no], cur); /* opcode */
     }
@@ -369,16 +431,20 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
     cur += uint32_to_bin(0, cur); /* niseq */
   }
 
-  uint32_to_bin(cur - bin, bin); /* record size */
+  diff = cur - bin;
+  mrb_assert_int_fit(ptrdiff_t, diff, uint32_t, UINT32_MAX);
+
+  uint32_to_bin((uint32_t)diff, bin); /* record size */
 
-  return (cur - bin);
+  mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
+  return (size_t)diff;
 }
 
-static int
+static size_t
 write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 {
   size_t i;
-  uint32_t rlen, size = 0;
+  size_t rlen, size = 0;
 
   rlen = write_lineno_record_1(mrb, irep, bin);
   bin += rlen;
@@ -394,7 +460,8 @@ write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 static int
 write_section_lineno(mrb_state *mrb, mrb_irep *irep, uint8_t *bin)
 {
-  uint32_t section_size = 0, rlen = 0; /* size of irep record */
+  size_t section_size = 0;
+  size_t rlen = 0; /* size of irep record */
   uint8_t *cur = bin;
 
   if (mrb == NULL || bin == NULL) {
@@ -416,28 +483,28 @@ static size_t
 get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t ret = 0;
-  uint32_t f_idx;
+  uint16_t f_idx;
   size_t i;
 
-  ret += sizeof(uint32_t); // record size
-  ret += sizeof(uint16_t); // file count
+  ret += sizeof(uint32_t); /* record size */
+  ret += sizeof(uint16_t); /* file count */
 
   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
     mrb_irep_debug_info_file const* file = irep->debug_info->files[f_idx];
 
-    ret += sizeof(uint32_t); // position
-    ret += sizeof(uint16_t); // filename index
+    ret += sizeof(uint32_t); /* position */
+    ret += sizeof(uint16_t); /* filename index */
 
-    // lines
-    ret += sizeof(uint32_t); // entry count
-    ret += sizeof(uint8_t); // line type
-    switch(file->line_type) {
+    /* lines */
+    ret += sizeof(uint32_t); /* entry count */
+    ret += sizeof(uint8_t); /* line type */
+    switch (file->line_type) {
       case mrb_debug_line_ary:
-        ret += sizeof(uint16_t) * file->line_entry_count;
+        ret += sizeof(uint16_t) * (size_t)(file->line_entry_count);
         break;
 
       case mrb_debug_line_flat_map:
-        ret += (sizeof(uint32_t) + sizeof(uint16_t)) * file->line_entry_count;
+        ret += (sizeof(uint32_t) + sizeof(uint16_t)) * (size_t)(file->line_entry_count);
         break;
 
       default: mrb_assert(0); break;
@@ -451,9 +518,9 @@ get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static int
-find_filename_index(const mrb_sym *ary, size_t ary_len, mrb_sym s)
+find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s)
 {
-  size_t i;
+  int i;
 
   for (i = 0; i < ary_len; ++i) {
     if (ary[i] == s) { return i; }
@@ -462,80 +529,74 @@ find_filename_index(const mrb_sym *ary, size_t ary_len, mrb_sym s)
 }
 
 static size_t
-get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, size_t *lp)
+get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
 {
   mrb_sym *filenames = *fp;
-  size_t tsize = 0;
-  size_t file_i;
-  size_t size = 0;
+  size_t i, size = 0;
   mrb_irep_debug_info *di = irep->debug_info;
 
-  if (lp == NULL) {
-    lp = &tsize;
-  }
-  for (file_i = 0; file_i < di->flen; ++file_i) {
+  mrb_assert(lp);
+  for (i = 0; i < di->flen; ++i) {
     mrb_irep_debug_info_file *file;
-    size_t filename_len;
-    size_t i;
+    mrb_int filename_len;
 
-    file = di->files[file_i];
+    file = di->files[i];
     if (find_filename_index(filenames, *lp, file->filename_sym) == -1) {
-      // register filename
+      /* register filename */
       *lp += 1;
       *fp = filenames = (mrb_sym *)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));
       filenames[*lp - 1] = file->filename_sym;
 
-      // filename
+      /* filename */
       mrb_sym2name_len(mrb, file->filename_sym, &filename_len);
-      size += sizeof(uint16_t) + filename_len;
-    }
-    for (i=0; i<irep->rlen; i++) {
-      size += get_filename_table_size(mrb, irep->reps[i], fp, lp);
-      filenames = *fp;
+      size += sizeof(uint16_t) + (size_t)filename_len;
     }
   }
+  for (i=0; i<irep->rlen; i++) {
+    size += get_filename_table_size(mrb, irep->reps[i], fp, lp);
+  }
   return size;
 }
 
-static int
-write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, size_t filenames_len)
+static size_t
+write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
 {
   uint8_t *cur;
-  uint32_t f_idx;
-  size_t ret;
+  uint16_t f_idx;
+  ptrdiff_t ret;
 
-  cur = bin + sizeof(uint32_t); // skip record size
-  cur += uint16_to_bin(irep->debug_info->flen, cur); // file count
+  cur = bin + sizeof(uint32_t); /* skip record size */
+  cur += uint16_to_bin(irep->debug_info->flen, cur); /* file count */
 
   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
     int filename_idx;
     const mrb_irep_debug_info_file *file = irep->debug_info->files[f_idx];
 
-    // position
+    /* position */
     cur += uint32_to_bin(file->start_pos, cur);
 
-    // filename index
+    /* filename index */
     filename_idx = find_filename_index(filenames, filenames_len,
                                                   file->filename_sym);
-    mrb_assert(filename_idx != -1);
-    cur += uint16_to_bin(filename_idx, cur);
+    mrb_assert_int_fit(int, filename_idx, uint16_t, UINT16_MAX);
+    cur += uint16_to_bin((uint16_t)filename_idx, cur);
 
-    // lines
+    /* lines */
     cur += uint32_to_bin(file->line_entry_count, cur);
     cur += uint8_to_bin(file->line_type, cur);
-    switch(file->line_type) {
+    switch (file->line_type) {
       case mrb_debug_line_ary: {
-        size_t l;
+        uint32_t l;
         for (l = 0; l < file->line_entry_count; ++l) {
-          cur += uint16_to_bin(file->line_ary[l], cur);
+          cur += uint16_to_bin(file->lines.ary[l], cur);
         }
       } break;
 
       case mrb_debug_line_flat_map: {
         uint32_t line;
         for (line = 0; line < file->line_entry_count; ++line) {
-          cur += uint32_to_bin(file->line_flat_map[line].start_pos, cur);
-          cur += uint16_to_bin(file->line_flat_map[line].line, cur);
+          cur += uint32_to_bin(file->lines.flat_map[line].start_pos, cur);
+          cur += uint16_to_bin(file->lines.flat_map[line].line, cur);
         }
       } break;
 
@@ -544,17 +605,19 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
   }
 
   ret = cur - bin;
+  mrb_assert_int_fit(ptrdiff_t, ret, uint32_t, UINT32_MAX);
   uint32_to_bin(ret, bin);
 
-  return ret;
+  mrb_assert_int_fit(ptrdiff_t, ret, size_t, SIZE_MAX);
+  return (size_t)ret;
 }
 
-static int
-write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, size_t filenames_len)
+static size_t
+write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
 {
-  uint32_t size, len;
+  size_t size, len;
   size_t irep_no;
-  
+
   size = len = write_debug_record_1(mrb, irep, bin, filenames, filenames_len);
   bin += len;
   for (irep_no = 0; irep_no < irep->rlen; irep_no++) {
@@ -563,54 +626,19 @@ write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const*
     size += len;
   }
 
-  mrb_assert(size == (int)get_debug_record_size(mrb, irep));
-  return size;
-}
-
-static int
-write_filename_table(mrb_state *mrb, mrb_irep *irep, uint8_t **cp, mrb_sym **fp, size_t *lp)
-{
-  uint8_t *cur = *cp;
-  mrb_sym *filenames = *fp;
-  size_t file_i;
-  uint16_t fn_len;
-  size_t size = 0;
-  mrb_irep_debug_info *debug_info = irep->debug_info;
-
-  for (file_i = 0; file_i < debug_info->flen; ++file_i) {
-    mrb_irep_debug_info_file *file = debug_info->files[file_i];
-    if (find_filename_index(filenames, *lp, file->filename_sym) != -1) continue;
-
-    // register filename
-    *lp += 1;
-    *fp = filenames = (mrb_sym*)mrb_realloc(mrb, filenames, sizeof(mrb_sym) * (*lp));
-    filenames[*lp - 1] = file->filename_sym;
-
-    // filename
-    fn_len = (uint16_t)strlen(file->filename);
-    cur += uint16_to_bin(fn_len, cur);
-    memcpy(cur, file->filename, fn_len);
-    cur += fn_len;
-
-    size += sizeof(uint16_t) + fn_len;
-  }
-  for (file_i=0; file_i<irep->rlen; file_i++) {
-    size += write_filename_table(mrb, irep->reps[file_i], &cur, fp, lp);
-  }
-  *cp = cur;
+  mrb_assert(size == get_debug_record_size(mrb, irep));
   return size;
 }
 
 static int
-write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur)
+write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
 {
-  uint32_t section_size = 0;
+  size_t section_size = 0;
   const uint8_t *bin = cur;
   struct rite_section_debug_header *header;
-  mrb_sym *filenames;
-  size_t filenames_len = 0;
-  uint8_t *filenames_len_out;
-  uint32_t dlen;
+  size_t dlen;
+  uint16_t i;
+  char const *sym; mrb_int sym_len;
 
   if (mrb == NULL || cur == NULL) {
     return MRB_DUMP_INVALID_ARGUMENT;
@@ -620,38 +648,196 @@ write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur)
   cur += sizeof(struct rite_section_debug_header);
   section_size += sizeof(struct rite_section_debug_header);
 
-  // filename table
-  filenames = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * 1);
-  filenames_len_out = cur;
-  cur += sizeof(uint16_t);
+  /* filename table */
+  cur += uint16_to_bin(filenames_len, cur);
   section_size += sizeof(uint16_t);
-  section_size += write_filename_table(mrb, irep, &cur, &filenames, &filenames_len);
-  uint16_to_bin(filenames_len, filenames_len_out);
+  for (i = 0; i < filenames_len; ++i) {
+    sym = mrb_sym2name_len(mrb, filenames[i], &sym_len);
+    mrb_assert(sym);
+    cur += uint16_to_bin(sym_len, cur);
+    memcpy(cur, sym, sym_len);
+    cur += sym_len;
+    section_size += sizeof(uint16_t) + sym_len;
+  }
 
-  // debug records
+  /* debug records */
   dlen = write_debug_record(mrb, irep, cur, filenames, filenames_len);
   section_size += dlen;
 
   memcpy(header->section_identify, RITE_SECTION_DEBUG_IDENTIFIER, sizeof(header->section_identify));
+  mrb_assert(section_size <= INT32_MAX);
   uint32_to_bin(section_size, header->section_size);
 
-  mrb_free(mrb, filenames);
+  return MRB_DUMP_OK;
+}
+
+static void
+create_lv_sym_table(mrb_state *mrb, const 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 + 1 < irep->nlocals; ++i) {
+    mrb_sym const name = irep->lv[i].name;
+    if (name == 0) continue;
+    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_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin)
+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;
+
+  for (i = 0; i + 1 < irep->nlocals; ++i) {
+    if (irep->lv[i].name == 0) {
+      cur += uint16_to_bin(RITE_LV_NULL_MARK, cur);
+      cur += uint16_to_bin(0, cur);
+    }
+    else {
+      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 += uint16_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) + sizeof(uint16_t)) * (irep->nlocals - 1);
+
+  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, uint8_t flags)
 {
   struct rite_binary_header *header = (struct rite_binary_header *)bin;
   uint16_t crc;
-  size_t offset;
+  uint32_t offset;
+
+  if (flags & FLAG_BYTEORDER_NATIVE) {
+    uint32_t ident = 0;
+    size_t i;
 
-  memcpy(header->binary_identify, RITE_BINARY_IDENTIFIER, sizeof(header->binary_identify));
+    for(i=0; i<sizeof(ident); i++) {
+      ident<<=8;
+      ident|=RITE_BINARY_IDENTIFIER[i];
+    }
+    memcpy(header->binary_identify, (char*)&ident, sizeof(uint32_t));
+  }
+  else {
+    memcpy(header->binary_identify, RITE_BINARY_IDENTIFIER, sizeof(header->binary_identify));
+  }
   memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version));
   memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name));
   memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version));
-  uint32_to_bin(binary_size, header->binary_size);
+  mrb_assert(binary_size <= UINT32_MAX);
+  uint32_to_bin((uint32_t)binary_size, header->binary_size);
 
   offset = (&(header->binary_crc[0]) - bin) + sizeof(uint16_t);
   crc = calc_crc_16_ccitt(bin + offset, binary_size - offset, 0);
@@ -665,21 +851,38 @@ is_debug_info_defined(mrb_irep *irep)
 {
   size_t i;
 
-  if (!irep->debug_info) return 0;
+  if (!irep->debug_info) return FALSE;
   for (i=0; i<irep->rlen; i++) {
-    if (!is_debug_info_defined(irep->reps[i])) return 0;
+    if (!is_debug_info_defined(irep->reps[i])) return FALSE;
+  }
+  return TRUE;
+}
+
+static mrb_bool
+is_lv_defined(mrb_irep *irep)
+{
+  size_t i;
+
+  if (irep->lv) { return TRUE; }
+
+  for (i = 0; i < irep->rlen; ++i) {
+    if (is_lv_defined(irep->reps[i])) { return TRUE; }
   }
-  return 1;
+
+  return FALSE;
 }
 
 static int
-dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size)
+dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size, uint8_t flags)
 {
   int result = MRB_DUMP_GENERAL_FAILURE;
+  size_t malloc_size;
   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_bool const debug_info_defined = is_debug_info_defined(irep), lv_defined = is_lv_defined(irep);
+  mrb_sym *lv_syms = NULL; uint32_t lv_syms_len = 0;
+  mrb_sym *filenames = NULL; uint16_t filenames_len = 0;
 
   if (mrb == NULL) {
     *bin = NULL;
@@ -692,16 +895,13 @@ dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t
   /* DEBUG section size */
   if (debug_info) {
     if (debug_info_defined) {
-      mrb_sym *filenames;
-
       section_lineno_size += sizeof(struct rite_section_debug_header);
-      // filename table
+      /* filename table */
       filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) + 1);
 
-      // filename table size
+      /* filename table size */
       section_lineno_size += sizeof(uint16_t);
-      section_lineno_size += get_filename_table_size(mrb, irep, &filenames, NULL);
-      mrb_free(mrb, filenames);
+      section_lineno_size += get_filename_table_size(mrb, irep, &filenames, &filenames_len);
 
       section_lineno_size += get_debug_record_size(mrb, irep);
     }
@@ -711,25 +911,31 @@ dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t
     }
   }
 
-  *bin_size = sizeof(struct rite_binary_header) +
-              section_irep_size + section_lineno_size +
-              sizeof(struct rite_binary_footer);
-  cur = *bin = (uint8_t*)mrb_malloc(mrb, *bin_size);
-  if (cur == NULL) {
-    goto error_exit;
+  if (lv_defined) {
+    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);
   }
+
+  malloc_size = sizeof(struct rite_binary_header) +
+                section_irep_size + section_lineno_size + section_lv_size +
+                sizeof(struct rite_binary_footer);
+  cur = *bin = (uint8_t*)mrb_malloc(mrb, malloc_size);
   cur += sizeof(struct rite_binary_header);
 
-  result = write_section_irep(mrb, irep, cur);
+  result = write_section_irep(mrb, irep, cur, &section_irep_size, flags);
   if (result != MRB_DUMP_OK) {
     goto error_exit;
   }
   cur += section_irep_size;
+  *bin_size = sizeof(struct rite_binary_header) +
+              section_irep_size + section_lineno_size + section_lv_size +
+              sizeof(struct rite_binary_footer);
 
   /* write DEBUG section */
   if (debug_info) {
     if (debug_info_defined) {
-      result = write_section_debug(mrb, irep, cur);
+      result = write_section_debug(mrb, irep, cur, filenames, filenames_len);
     }
     else {
       result = write_section_lineno(mrb, irep, cur);
@@ -740,19 +946,36 @@ dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t
     cur += section_lineno_size;
   }
 
+  if (lv_defined) {
+    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);
+  write_rite_binary_header(mrb, *bin_size, *bin, flags);
 
 error_exit:
   if (result != MRB_DUMP_OK) {
     mrb_free(mrb, *bin);
     *bin = NULL;
   }
+  if (lv_syms) {
+    mrb_free(mrb, lv_syms);
+  }
+  if (filenames) {
+    mrb_free(mrb, filenames);
+  }
   return result;
 }
 
-
-#ifdef ENABLE_STDIO
+int
+mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size)
+{
+  return dump_irep(mrb, irep, debug_info, bin, bin_size, FLAG_BYTEORDER_NONATIVE);
+}
 
 int
 mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE* fp)
@@ -765,29 +988,31 @@ mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE* fp)
     return MRB_DUMP_INVALID_ARGUMENT;
   }
 
-  result = dump_irep(mrb, irep, debug_info, &bin, &bin_size);
+  result = dump_irep(mrb, irep, debug_info, &bin, &bin_size, FLAG_BYTEORDER_NONATIVE);
   if (result == MRB_DUMP_OK) {
-    fwrite(bin, bin_size, 1, fp);
+    if (fwrite(bin, sizeof(bin[0]), bin_size, fp) != bin_size) {
+      result = MRB_DUMP_WRITE_FAULT;
+    }
   }
 
   mrb_free(mrb, bin);
   return result;
 }
 
-static int
+static mrb_bool
 is_valid_c_symbol_name(const char *name)
 {
    const char *c = NULL;
 
-   if (name == NULL || name[0] == '\0') return 0;
-   if (!ISALPHA(name[0]) && name[0] != '_') return 0;
+   if (name == NULL || name[0] == '\0') return FALSE;
+   if (!ISALPHA(name[0]) && name[0] != '_') return FALSE;
 
    c = &name[1];
    for (; *c != '\0'; ++c) {
-     if (!ISALNUM(*c) && *c != '_') return 0;
+     if (!ISALNUM(*c) && *c != '_') return FALSE;
    }
 
-   return 1;
+   return TRUE;
 }
 
 int
@@ -801,15 +1026,40 @@ mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, int debug_info, FILE *fp, co
     return MRB_DUMP_INVALID_ARGUMENT;
   }
 
-  result = dump_irep(mrb, irep, debug_info, &bin, &bin_size);
+  result = dump_irep(mrb, irep, debug_info, &bin, &bin_size, FLAG_BYTEORDER_NATIVE);
   if (result == MRB_DUMP_OK) {
-    fprintf(fp, "#include <stdint.h>\n"); // for uint8_t under at least Darwin
-    fprintf(fp, "const uint8_t %s[] = {", initname);
+    if (fprintf(fp, "#include <stdint.h>\n") < 0) { /* for uint8_t under at least Darwin */
+      mrb_free(mrb, bin);
+      return MRB_DUMP_WRITE_FAULT;
+    }
+    if (fprintf(fp,
+          "const uint8_t\n"
+          "#if defined __GNUC__\n"
+          "__attribute__((aligned(%u)))\n"
+          "#elif defined _MSC_VER\n"
+          "__declspec(align(%u))\n"
+          "#endif\n"
+          "%s[] = {",
+          (uint16_t)MRB_DUMP_ALIGNMENT, (uint16_t)MRB_DUMP_ALIGNMENT, initname) < 0) {
+      mrb_free(mrb, bin);
+      return MRB_DUMP_WRITE_FAULT;
+    }
     while (bin_idx < bin_size) {
-      if (bin_idx % 16 == 0) fputs("\n", fp);
-      fprintf(fp, "0x%02x,", bin[bin_idx++]);
+      if (bin_idx % 16 == 0) {
+        if (fputs("\n", fp) == EOF) {
+          mrb_free(mrb, bin);
+          return MRB_DUMP_WRITE_FAULT;
+        }
+      }
+      if (fprintf(fp, "0x%02x,", bin[bin_idx++]) < 0) {
+        mrb_free(mrb, bin);
+        return MRB_DUMP_WRITE_FAULT;
+      }
+    }
+    if (fputs("\n};\n", fp) == EOF) {
+      mrb_free(mrb, bin);
+      return MRB_DUMP_WRITE_FAULT;
     }
-    fputs("\n};\n", fp);
   }
 
   mrb_free(mrb, bin);