From 61f49690e43cea3df6ebbdf424cf6777826056b0 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 15 Nov 2018 20:15:10 +0900
Subject: Remove `filename`&`lines` from `mrb_irep` struct.

This patch slightly reduce memory consumption (2% for my test).
---
 src/debug.c | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

(limited to 'src/debug.c')

diff --git a/src/debug.c b/src/debug.c
index e55f11d4f..207065d9e 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -55,7 +55,7 @@ mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc)
 {
   if (irep && pc >= 0 && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;
-    if (!irep->debug_info) { return irep->filename; }
+    if (!irep->debug_info) return NULL;
     else if ((f = get_file(irep->debug_info, (uint32_t)pc))) {
       return f->filename;
     }
@@ -69,7 +69,7 @@ mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc)
   if (irep && pc >= 0 && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;
     if (!irep->debug_info) {
-      return irep->lines? irep->lines[pc] : -1;
+      return -1;
     }
     else if ((f = get_file(irep->debug_info, (uint32_t)pc))) {
       switch (f->line_type) {
@@ -122,24 +122,22 @@ mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep)
 }
 
 MRB_API mrb_irep_debug_info_file*
-mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
+mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *info,
+                           const char *filename, uint16_t *lines,
                            uint32_t start_pos, uint32_t end_pos)
 {
-  mrb_irep_debug_info *info;
   mrb_irep_debug_info_file *ret;
   uint32_t file_pc_count;
   size_t fn_len;
   mrb_int len;
   uint32_t i;
 
-  if (!irep->debug_info) { return NULL; }
+  if (!info) { return NULL; }
 
-  mrb_assert(irep->filename);
-  mrb_assert(irep->lines);
+  mrb_assert(filename);
+  mrb_assert(lines);
 
-  info = irep->debug_info;
-
-  if (info->flen > 0 && strcmp(irep->filename, info->files[info->flen - 1]->filename) == 0) {
+  if (info->flen > 0 && strcmp(filename, info->files[info->flen - 1]->filename) == 0) {
     return NULL;
   }
 
@@ -156,12 +154,12 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
   ret->start_pos = start_pos;
   info->pc_count = end_pos;
 
-  fn_len = strlen(irep->filename);
-  ret->filename_sym = mrb_intern(mrb, irep->filename, fn_len);
+  fn_len = strlen(filename);
+  ret->filename_sym = mrb_intern(mrb, filename, fn_len);
   len = 0;
   ret->filename = mrb_sym2name_len(mrb, ret->filename_sym, &len);
 
-  ret->line_type = select_line_type(irep->lines + start_pos, end_pos - start_pos);
+  ret->line_type = select_line_type(lines + start_pos, end_pos - start_pos);
   ret->lines.ptr = NULL;
 
   switch (ret->line_type) {
@@ -169,7 +167,7 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
       ret->line_entry_count = file_pc_count;
       ret->lines.ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
       for (i = 0; i < file_pc_count; ++i) {
-        ret->lines.ary[i] = irep->lines[start_pos + i];
+        ret->lines.ary[i] = lines[start_pos + i];
       }
       break;
 
@@ -179,18 +177,18 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
       ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
       ret->line_entry_count = 0;
       for (i = 0; i < file_pc_count; ++i) {
-        if (irep->lines[start_pos + i] == prev_line) { continue; }
+        if (lines[start_pos + i] == prev_line) { continue; }
 
         ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
             mrb, ret->lines.flat_map,
             sizeof(mrb_irep_debug_info_line) * (ret->line_entry_count + 1));
         m.start_pos = start_pos + i;
-        m.line = irep->lines[start_pos + i];
+        m.line = lines[start_pos + i];
         ret->lines.flat_map[ret->line_entry_count] = m;
 
         /* update */
         ++ret->line_entry_count;
-        prev_line = irep->lines[start_pos + i];
+        prev_line = lines[start_pos + i];
       }
     } break;
 
-- 
cgit v1.2.3


From faf51f82c7265f2cbdda8291429d7f2016d2bc3f Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 15 Nov 2018 23:28:34 +0900
Subject: Rename local variables in `mrb_debug_info_append_file`

---
 src/debug.c | 56 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

(limited to 'src/debug.c')

diff --git a/src/debug.c b/src/debug.c
index 207065d9e..2949131e4 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -122,72 +122,72 @@ mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep)
 }
 
 MRB_API mrb_irep_debug_info_file*
-mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *info,
+mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d,
                            const char *filename, uint16_t *lines,
                            uint32_t start_pos, uint32_t end_pos)
 {
-  mrb_irep_debug_info_file *ret;
+  mrb_irep_debug_info_file *f;
   uint32_t file_pc_count;
   size_t fn_len;
   mrb_int len;
   uint32_t i;
 
-  if (!info) { return NULL; }
+  if (!d) return NULL;
+  if (start_pos == end_pos) return NULL;
 
   mrb_assert(filename);
   mrb_assert(lines);
 
-  if (info->flen > 0 && strcmp(filename, info->files[info->flen - 1]->filename) == 0) {
+  if (d->flen > 0 && strcmp(filename, d->files[d->flen - 1]->filename) == 0) {
     return NULL;
   }
 
-  ret = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*ret));
-  info->files =
-      (mrb_irep_debug_info_file**)(
-          info->files
-          ? mrb_realloc(mrb, info->files, sizeof(mrb_irep_debug_info_file*) * (info->flen + 1))
+  f = (mrb_irep_debug_info_file*)mrb_malloc(mrb, sizeof(*f));
+  d->files = (mrb_irep_debug_info_file**)(
+          d->files
+          ? mrb_realloc(mrb, d->files, sizeof(mrb_irep_debug_info_file*) * (d->flen + 1))
           : mrb_malloc(mrb, sizeof(mrb_irep_debug_info_file*)));
-  info->files[info->flen++] = ret;
+  d->files[d->flen++] = f;
 
   file_pc_count = end_pos - start_pos;
 
-  ret->start_pos = start_pos;
-  info->pc_count = end_pos;
+  f->start_pos = start_pos;
+  d->pc_count = end_pos;
 
   fn_len = strlen(filename);
-  ret->filename_sym = mrb_intern(mrb, filename, fn_len);
+  f->filename_sym = mrb_intern(mrb, filename, fn_len);
   len = 0;
-  ret->filename = mrb_sym2name_len(mrb, ret->filename_sym, &len);
+  f->filename = mrb_sym2name_len(mrb, f->filename_sym, &len);
 
-  ret->line_type = select_line_type(lines + start_pos, end_pos - start_pos);
-  ret->lines.ptr = NULL;
+  f->line_type = select_line_type(lines + start_pos, end_pos - start_pos);
+  f->lines.ptr = NULL;
 
-  switch (ret->line_type) {
+  switch (f->line_type) {
     case mrb_debug_line_ary:
-      ret->line_entry_count = file_pc_count;
-      ret->lines.ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
+      f->line_entry_count = file_pc_count;
+      f->lines.ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
       for (i = 0; i < file_pc_count; ++i) {
-        ret->lines.ary[i] = lines[start_pos + i];
+        f->lines.ary[i] = lines[start_pos + i];
       }
       break;
 
     case mrb_debug_line_flat_map: {
       uint16_t prev_line = 0;
       mrb_irep_debug_info_line m;
-      ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
-      ret->line_entry_count = 0;
+      f->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
+      f->line_entry_count = 0;
       for (i = 0; i < file_pc_count; ++i) {
         if (lines[start_pos + i] == prev_line) { continue; }
 
-        ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
-            mrb, ret->lines.flat_map,
-            sizeof(mrb_irep_debug_info_line) * (ret->line_entry_count + 1));
+        f->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
+            mrb, f->lines.flat_map,
+            sizeof(mrb_irep_debug_info_line) * (f->line_entry_count + 1));
         m.start_pos = start_pos + i;
         m.line = lines[start_pos + i];
-        ret->lines.flat_map[ret->line_entry_count] = m;
+        f->lines.flat_map[f->line_entry_count] = m;
 
         /* update */
-        ++ret->line_entry_count;
+        ++f->line_entry_count;
         prev_line = lines[start_pos + i];
       }
     } break;
@@ -195,7 +195,7 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *info,
     default: mrb_assert(0); break;
   }
 
-  return ret;
+  return f;
 }
 
 MRB_API void
-- 
cgit v1.2.3


From 2871d0cdc5e5ef952d27187b5488888bbd18c5b0 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Mon, 1 Apr 2019 14:13:06 +0900
Subject: Avoid keeping pointers from `mrb_sym2name_len()`; fix #4342

The addresses for packed inline symbols reference `mrb->symbuf` that
could be overridden by the later call of `mrb_sym2name_len`. Since
file names in call stack information are kept as symbols, keeping the
address in the C structures could cause problems like #4342.

This changes small incompatible changes in function prototypes:
* `mrb_parser_get_filename`: return value changed to `mrb_sym`.
* `mrb_debug_get_filename`: add `mrb_state*` as a first argument.
* `mrb_debug_get_line`: ditto.

I believe above functions are almost internal, and no third-party
mrbgem use them.
---
 include/mruby/compile.h                          |  4 ++--
 include/mruby/debug.h                            |  5 ++---
 mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c | 16 ++++++++-------
 mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c  |  2 +-
 mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c |  6 +++---
 mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c     |  4 ++--
 mrbgems/mruby-compiler/core/codegen.c            | 25 +++++++++++++-----------
 mrbgems/mruby-compiler/core/parse.y              | 20 ++++++++++---------
 mrbgems/mruby-proc-ext/src/proc.c                |  8 ++++----
 src/backtrace.c                                  |  4 ++--
 src/class.c                                      | 14 +++----------
 src/codedump.c                                   | 14 ++++++-------
 src/debug.c                                      | 15 +++++++-------
 src/error.c                                      |  4 ++--
 src/load.c                                       |  3 ---
 src/symbol.c                                     |  9 ++++++++-
 16 files changed, 77 insertions(+), 76 deletions(-)

(limited to 'src/debug.c')

diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index fd735be88..f19d9b0b3 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -118,7 +118,7 @@ struct mrb_parser_state {
   FILE *f;
 #endif
   mrbc_context *cxt;
-  char const *filename;
+  mrb_sym filename_sym;
   int lineno;
   int column;
 
@@ -168,7 +168,7 @@ MRB_API void mrb_parser_free(struct mrb_parser_state*);
 MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
 MRB_API void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
-MRB_API char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
+MRB_API mrb_sym mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
 
 /* utility functions */
 #ifndef MRB_DISABLE_STDIO
diff --git a/include/mruby/debug.h b/include/mruby/debug.h
index f0a40dfcf..e08c47cfc 100644
--- a/include/mruby/debug.h
+++ b/include/mruby/debug.h
@@ -26,7 +26,6 @@ typedef struct mrb_irep_debug_info_line {
 
 typedef struct mrb_irep_debug_info_file {
   uint32_t start_pos;
-  const char *filename;
   mrb_sym filename_sym;
   uint32_t line_entry_count;
   mrb_debug_line_type line_type;
@@ -47,13 +46,13 @@ typedef struct mrb_irep_debug_info {
  * get line from irep's debug info and program counter
  * @return returns NULL if not found
  */
-MRB_API const char *mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc);
+MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc);
 
 /*
  * get line from irep's debug info and program counter
  * @return returns -1 if not found
  */
-MRB_API int32_t mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc);
+MRB_API int32_t mrb_debug_get_line(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc);
 
 MRB_API mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
 MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
index d3ccf08ae..513db4ded 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
@@ -84,7 +84,7 @@ free_breakpoint(mrb_state *mrb, mrb_debug_breakpoint *bp)
 }
 
 static uint16_t
-check_file_lineno(struct mrb_irep *irep, const char *file, uint16_t lineno)
+check_file_lineno(mrb_state *mrb, struct mrb_irep *irep, const char *file, uint16_t lineno)
 {
   mrb_irep_debug_info_file *info_file;
   uint16_t result = 0;
@@ -93,8 +93,10 @@ check_file_lineno(struct mrb_irep *irep, const char *file, uint16_t lineno)
   uint16_t i;
 
   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
+    const char *filename;
     info_file = irep->debug_info->files[f_idx];
-    if (!strcmp(info_file->filename, file)) {
+    filename = mrb_sym2name_len(mrb, info_file->filename_sym, NULL);
+    if (!strcmp(filename, file)) {
       result = MRB_DEBUG_BP_FILE_OK;
 
       fix_lineno = check_lineno(info_file, lineno);
@@ -103,7 +105,7 @@ check_file_lineno(struct mrb_irep *irep, const char *file, uint16_t lineno)
       }
     }
     for (i=0; i < irep->rlen; ++i) {
-      result  |= check_file_lineno(irep->reps[i], file, lineno);
+      result  |= check_file_lineno(mrb, irep->reps[i], file, lineno);
       if (result == (MRB_DEBUG_BP_FILE_OK | MRB_DEBUG_BP_LINENO_OK)) {
         return result;
       }
@@ -185,7 +187,7 @@ mrb_debug_set_break_line(mrb_state *mrb, mrb_debug_context *dbg, const char *fil
   }
 
   /* file and lineno check (line type mrb_debug_line_ary only.) */
-  result = check_file_lineno(dbg->root_irep, file, lineno);
+  result = check_file_lineno(mrb, dbg->root_irep, file, lineno);
   if (result == 0) {
     return MRB_DEBUG_BREAK_INVALID_FILE;
   }
@@ -426,10 +428,10 @@ mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg)
 }
 
 static mrb_bool
-check_start_pc_for_line(mrb_irep *irep, mrb_code *pc, uint16_t line)
+check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, uint16_t line)
 {
   if (pc > irep->iseq) {
-    if (line == mrb_debug_get_line(irep, pc - irep->iseq - 1)) {
+    if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) {
       return FALSE;
     }
   }
@@ -447,7 +449,7 @@ mrb_debug_check_breakpoint_line(mrb_state *mrb, mrb_debug_context *dbg, const ch
     return MRB_DEBUG_INVALID_ARGUMENT;
   }
 
-  if (!check_start_pc_for_line(dbg->irep, dbg->pc, line)) {
+  if (!check_start_pc_for_line(mrb, dbg->irep, dbg->pc, line)) {
     return MRB_DEBUG_OK;
   }
 
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c
index 21fe64127..66ddfa783 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apilist.c
@@ -181,7 +181,7 @@ mrb_debug_get_source(mrb_state *mrb, mrdb_state *mrdb, const char *srcpath, cons
   else srcname = filename;
 
   search_path[0] = srcpath;
-  search_path[1] = dirname(mrb, mrb_debug_get_filename(mrdb->dbg->irep, 0));
+  search_path[1] = dirname(mrb, mrb_debug_get_filename(mrb, mrdb->dbg->irep, 0));
   search_path[2] = ".";
 
   for (i = 0; i < 3; i++) {
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
index 8e5901754..bc9937e94 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c
@@ -242,7 +242,7 @@ info_break_select(mrb_state *mrb, mrdb_state *mrdb)
 }
 
 mrb_debug_bptype
-parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method)
+parse_breakcommand(mrb_state *mrb, mrdb_state *mrdb, const char **file, uint32_t *line, char **cname, char **method)
 {
   mrb_debug_context *dbg = mrdb->dbg;
   char *args;
@@ -274,7 +274,7 @@ parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **c
       STRTOUL(l, body);
       if (l <= 65535) {
         *line = l;
-        *file = (body == args)? mrb_debug_get_filename(dbg->irep, dbg->pc - dbg->irep->iseq): args;
+        *file = (body == args)? mrb_debug_get_filename(mrb, dbg->irep, dbg->pc - dbg->irep->iseq): args;
       }
       else {
         puts(BREAK_ERR_MSG_RANGEOVER);
@@ -332,7 +332,7 @@ dbgcmd_break(mrb_state *mrb, mrdb_state *mrdb)
   char *method = NULL;
   int32_t ret;
 
-  type = parse_breakcommand(mrdb, &file, &line, &cname, &method);
+  type = parse_breakcommand(mrb, mrdb, &file, &line, &cname, &method);
   switch (type) {
     case MRB_DEBUG_BPTYPE_LINE:
       ret = mrb_debug_set_break_line(mrb, dbg, file, line);
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
index 5256ac5e3..003406172 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
@@ -569,8 +569,8 @@ mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *reg
     dbg->xphase = DBG_PHASE_RUNNING;
   }
 
-  file = mrb_debug_get_filename(irep, pc - irep->iseq);
-  line = mrb_debug_get_line(irep, pc - irep->iseq);
+  file = mrb_debug_get_filename(mrb, irep, pc - irep->iseq);
+  line = mrb_debug_get_line(mrb, irep, pc - irep->iseq);
 
   switch (dbg->xm) {
   case DBG_STEP:
diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index a2d790e32..927cc3a0f 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -62,7 +62,7 @@ typedef struct scope {
 
   struct loopinfo *loop;
   int ensure_level;
-  char const *filename;
+  mrb_sym filename_sym;
   uint16_t lineno;
 
   mrb_code *iseq;
@@ -106,8 +106,9 @@ codegen_error(codegen_scope *s, const char *message)
     s = tmp;
   }
 #ifndef MRB_DISABLE_STDIO
-  if (s->filename && s->lineno) {
-    fprintf(stderr, "codegen error:%s:%d: %s\n", s->filename, s->lineno, message);
+  if (s->filename_sym && s->lineno) {
+    const char *filename = mrb_sym2name_len(s->mrb, s->filename_sym, NULL);
+    fprintf(stderr, "codegen error:%s:%d: %s\n", filename, s->lineno, message);
   }
   else {
     fprintf(stderr, "codegen error: %s\n", message);
@@ -1399,13 +1400,14 @@ codegen(codegen_scope *s, node *tree, int val)
     codegen_error(s, "too complex expression");
   }
   if (s->irep && s->filename_index != tree->filename_index) {
-    const char *filename = mrb_parser_get_filename(s->parser, s->filename_index);
+    mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
+    const char *filename = mrb_sym2name_len(s->mrb, fname, NULL);
 
     mrb_debug_info_append_file(s->mrb, s->irep->debug_info,
                                filename, s->lines, s->debug_start_pos, s->pc);
     s->debug_start_pos = s->pc;
     s->filename_index = tree->filename_index;
-    s->filename = mrb_parser_get_filename(s->parser, tree->filename_index);
+    s->filename_sym = mrb_parser_get_filename(s->parser, tree->filename_index);
   }
 
   nt = nint(tree->car);
@@ -2990,15 +2992,15 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
   }
   p->ai = mrb_gc_arena_save(mrb);
 
-  p->filename = prev->filename;
-  if (p->filename) {
+  p->filename_sym = prev->filename_sym;
+  if (p->filename_sym) {
     p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa);
   }
   p->lineno = prev->lineno;
 
   /* debug setting */
   p->debug_start_pos = 0;
-  if (p->filename) {
+  if (p->filename_sym) {
     mrb_debug_info_alloc(mrb, p->irep);
   }
   else {
@@ -3026,8 +3028,9 @@ scope_finish(codegen_scope *s)
   irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen);
   irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen);
   irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen);
-  if (s->filename) {
-    const char *filename = mrb_parser_get_filename(s->parser, s->filename_index);
+  if (s->filename_sym) {
+    mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
+    const char *filename = mrb_sym2name_len(s->mrb, fname, NULL);
 
     mrb_debug_info_append_file(s->mrb, s->irep->debug_info,
                                filename, s->lines, s->debug_start_pos, s->pc);
@@ -3136,7 +3139,7 @@ generate_code(mrb_state *mrb, parser_state *p, int val)
   }
   scope->mrb = mrb;
   scope->parser = p;
-  scope->filename = p->filename;
+  scope->filename_sym = p->filename_sym;
   scope->filename_index = p->current_filename_index;
 
   MRB_TRY(&scope->jmp) {
diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y
index 90f01e3a8..88d9ea4ee 100644
--- a/mrbgems/mruby-compiler/core/parse.y
+++ b/mrbgems/mruby-compiler/core/parse.y
@@ -3162,7 +3162,7 @@ var_ref         : variable
                     }
                 | keyword__FILE__
                     {
-                      const char *fn = p->filename;
+                      const char *fn = mrb_sym2name_len(p->mrb, p->filename_sym, NULL);
                       if (!fn) {
                         fn = "(null)";
                       }
@@ -3671,8 +3671,9 @@ yyerror(parser_state *p, const char *s)
 
   if (! p->capture_errors) {
 #ifndef MRB_DISABLE_STDIO
-    if (p->filename) {
-      fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
+    if (p->filename_sym) {
+      const char *filename = mrb_sym2name_len(p->mrb, p->filename_sym, NULL);
+      fprintf(stderr, "%s:%d:%d: %s\n", filename, p->lineno, p->column, s);
     }
     else {
       fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
@@ -3707,8 +3708,9 @@ yywarn(parser_state *p, const char *s)
 
   if (! p->capture_errors) {
 #ifndef MRB_DISABLE_STDIO
-    if (p->filename) {
-      fprintf(stderr, "%s:%d:%d: warning: %s\n", p->filename, p->lineno, p->column, s);
+    if (p->filename_sym) {
+      const char *filename = mrb_sym2name_len(p->mrb, p->filename_sym, NULL);
+      fprintf(stderr, "%s:%d:%d: warning: %s\n", filename, p->lineno, p->column, s);
     }
     else {
       fprintf(stderr, "line %d:%d: warning: %s\n", p->lineno, p->column, s);
@@ -6012,7 +6014,7 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
   mrb_sym* new_table;
 
   sym = mrb_intern_cstr(p->mrb, f);
-  p->filename = mrb_sym2name_len(p->mrb, sym, NULL);
+  p->filename_sym = sym;
   p->lineno = (p->filename_table_length > 0)? 0 : 1;
 
   for (i = 0; i < p->filename_table_length; ++i) {
@@ -6036,11 +6038,11 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
   p->filename_table[p->filename_table_length - 1] = sym;
 }
 
-MRB_API char const*
+MRB_API mrb_sym
 mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) {
-  if (idx >= p->filename_table_length) return NULL;
+  if (idx >= p->filename_table_length) return 0;
   else {
-    return mrb_sym2name_len(p->mrb, p->filename_table[idx], NULL);
+    return p->filename_table[idx];
   }
 }
 
diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index 4b85c245d..17884e3c6 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -25,8 +25,8 @@ mrb_proc_source_location(mrb_state *mrb, mrb_value self)
     int32_t line;
     const char *filename;
 
-    filename = mrb_debug_get_filename(irep, 0);
-    line = mrb_debug_get_line(irep, 0);
+    filename = mrb_debug_get_filename(mrb, irep, 0);
+    line = mrb_debug_get_line(mrb, irep, 0);
 
     return (!filename && line == -1)? mrb_nil_value()
         : mrb_assoc_new(mrb, mrb_str_new_cstr(mrb, filename), mrb_fixnum_value(line));
@@ -46,11 +46,11 @@ mrb_proc_inspect(mrb_state *mrb, mrb_value self)
     int32_t line;
     mrb_str_cat_lit(mrb, str, "@");
 
-    filename = mrb_debug_get_filename(irep, 0);
+    filename = mrb_debug_get_filename(mrb, irep, 0);
     mrb_str_cat_cstr(mrb, str, filename ? filename : "-");
     mrb_str_cat_lit(mrb, str, ":");
 
-    line = mrb_debug_get_line(irep, 0);
+    line = mrb_debug_get_line(mrb, irep, 0);
     if (line != -1) {
       str = mrb_format(mrb, "%S:%S", str, mrb_fixnum_value(line));
     }
diff --git a/src/backtrace.c b/src/backtrace.c
index efca2562f..e4f5a3064 100644
--- a/src/backtrace.c
+++ b/src/backtrace.c
@@ -58,10 +58,10 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, mrb_code *pc0, each_backtrace_fu
       pc = pc0;
     }
 
-    loc.lineno = mrb_debug_get_line(irep, pc - irep->iseq);
+    loc.lineno = mrb_debug_get_line(mrb, irep, pc - irep->iseq);
     if (loc.lineno == -1) continue;
 
-    loc.filename = mrb_debug_get_filename(irep, pc - irep->iseq);
+    loc.filename = mrb_debug_get_filename(mrb, irep, pc - irep->iseq);
     if (!loc.filename) {
       loc.filename = "(unknown)";
     }
diff --git a/src/class.c b/src/class.c
index 3354617bb..5c5ee9d17 100644
--- a/src/class.c
+++ b/src/class.c
@@ -484,15 +484,11 @@ mrb_define_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t
 MRB_API void
 mrb_notimplement(mrb_state *mrb)
 {
-  const char *str;
-  mrb_int len;
   mrb_callinfo *ci = mrb->c->ci;
 
   if (ci->mid) {
-    str = mrb_sym2name_len(mrb, ci->mid, &len);
-    mrb_raisef(mrb, E_NOTIMP_ERROR,
-      "%S() function is unimplemented on this machine",
-      mrb_str_new_static(mrb, str, (size_t)len));
+    mrb_value str = mrb_sym2str(mrb, ci->mid);
+    mrb_raisef(mrb, E_NOTIMP_ERROR, "%S() function is unimplemented on this machine", str);
   }
 }
 
@@ -1686,11 +1682,7 @@ mrb_class_path(mrb_state *mrb, struct RClass *c)
   }
   else if (mrb_symbol_p(path)) {
     /* toplevel class/module */
-    const char *str;
-    mrb_int len;
-
-    str = mrb_sym2name_len(mrb, mrb_symbol(path), &len);
-    return mrb_str_new(mrb, str, len);
+    return mrb_sym2str(mrb, mrb_symbol(path));
   }
   return mrb_str_dup(mrb, path);
 }
diff --git a/src/codedump.c b/src/codedump.c
index c9c3b25ef..5bffefddb 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -48,11 +48,11 @@ print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
 }
 
 static void
-print_header(mrb_irep *irep, ptrdiff_t i)
+print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
 {
   int32_t line;
 
-  line = mrb_debug_get_line(irep, i);
+  line = mrb_debug_get_line(mrb, irep, i);
   if (line < 0) {
     printf("      ");
   }
@@ -99,12 +99,12 @@ codedump(mrb_state *mrb, mrb_irep *irep)
     ai = mrb_gc_arena_save(mrb);
 
     i = pc - irep->iseq;
-    next_file = mrb_debug_get_filename(irep, i);
+    next_file = mrb_debug_get_filename(mrb, irep, i);
     if (next_file && file != next_file) {
       printf("file: %s\n", next_file);
       file = next_file;
     }
-    print_header(irep, i);
+    print_header(mrb, irep, i);
     ins = READ_B();
     switch (ins) {
     CASE(OP_NOP, Z):
@@ -491,7 +491,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
     CASE(OP_EXT1, Z):
       ins = READ_B();
       printf("OP_EXT1\n");
-      print_header(irep, pc-irep->iseq-2);
+      print_header(mrb, irep, pc-irep->iseq-2);
       switch (ins) {
 #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i;
 #include "mruby/ops.h"
@@ -501,7 +501,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
     CASE(OP_EXT2, Z):
       ins = READ_B();
       printf("OP_EXT2\n");
-      print_header(irep, pc-irep->iseq-2);
+      print_header(mrb, irep, pc-irep->iseq-2);
       switch (ins) {
 #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i;
 #include "mruby/ops.h"
@@ -511,7 +511,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
     CASE(OP_EXT3, Z):
       ins = READ_B();
       printf("OP_EXT3\n");
-      print_header(irep, pc-irep->iseq-2);
+      print_header(mrb, irep, pc-irep->iseq-2);
       switch (ins) {
 #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i;
 #include "mruby/ops.h"
diff --git a/src/debug.c b/src/debug.c
index 2949131e4..0dc02a1e3 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -51,20 +51,20 @@ select_line_type(const uint16_t *lines, size_t lines_len)
 }
 
 MRB_API char const*
-mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc)
+mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc)
 {
   if (irep && pc >= 0 && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;
     if (!irep->debug_info) return NULL;
     else if ((f = get_file(irep->debug_info, (uint32_t)pc))) {
-      return f->filename;
+      return mrb_sym2name_len(mrb, f->filename_sym, NULL);
     }
   }
   return NULL;
 }
 
 MRB_API int32_t
-mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc)
+mrb_debug_get_line(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc)
 {
   if (irep && pc >= 0 && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;
@@ -129,7 +129,6 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d,
   mrb_irep_debug_info_file *f;
   uint32_t file_pc_count;
   size_t fn_len;
-  mrb_int len;
   uint32_t i;
 
   if (!d) return NULL;
@@ -138,8 +137,10 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d,
   mrb_assert(filename);
   mrb_assert(lines);
 
-  if (d->flen > 0 && strcmp(filename, d->files[d->flen - 1]->filename) == 0) {
-    return NULL;
+  if (d->flen > 0) {
+    const char *fn = mrb_sym2name_len(mrb, d->files[d->flen - 1]->filename_sym, NULL);
+    if (strcmp(filename, fn) == 0)
+      return NULL;
   }
 
   f = (mrb_irep_debug_info_file*)mrb_malloc(mrb, sizeof(*f));
@@ -156,8 +157,6 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep_debug_info *d,
 
   fn_len = strlen(filename);
   f->filename_sym = mrb_intern(mrb, filename, fn_len);
-  len = 0;
-  f->filename = mrb_sym2name_len(mrb, f->filename_sym, &len);
 
   f->line_type = select_line_type(lines + start_pos, end_pos - start_pos);
   f->lines.ptr = NULL;
diff --git a/src/error.c b/src/error.c
index 50d1ab6f9..e69812dda 100644
--- a/src/error.c
+++ b/src/error.c
@@ -208,8 +208,8 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc)
     if (err && ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) {
       mrb_irep *irep = ci->proc->body.irep;
 
-      int32_t const line = mrb_debug_get_line(irep, err - irep->iseq);
-      char const* file = mrb_debug_get_filename(irep, err - irep->iseq);
+      int32_t const line = mrb_debug_get_line(mrb, irep, err - irep->iseq);
+      char const* file = mrb_debug_get_filename(mrb, irep, err - irep->iseq);
       if (line != -1 && file) {
         mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "file"), mrb_str_new_cstr(mrb, file));
         mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "line"), mrb_fixnum_value(line));
diff --git a/src/load.c b/src/load.c
index 55e0845f3..ab0346750 100644
--- a/src/load.c
+++ b/src/load.c
@@ -317,7 +317,6 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
   for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
     mrb_irep_debug_info_file *file;
     uint16_t filename_idx;
-    mrb_int len;
 
     file = (mrb_irep_debug_info_file *)mrb_malloc(mrb, sizeof(*file));
     irep->debug_info->files[f_idx] = file;
@@ -330,8 +329,6 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
     bin += sizeof(uint16_t);
     mrb_assert(filename_idx < filenames_len);
     file->filename_sym = filenames[filename_idx];
-    len = 0;
-    file->filename = mrb_sym2name_len(mrb, file->filename_sym, &len);
 
     file->line_entry_count = bin_to_uint32(bin);
     bin += sizeof(uint32_t);
diff --git a/src/symbol.c b/src/symbol.c
index 8ca03344c..96ca9dd17 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -520,7 +520,14 @@ mrb_sym2name(mrb_state *mrb, mrb_sym sym)
     return name;
   }
   else {
-    mrb_value str = mrb_str_dump(mrb, mrb_str_new_static(mrb, name, len));
+    mrb_value str;
+    if (sym&1) {                /* inline symbol */
+      str = mrb_str_new(mrb, name, len);
+    }
+    else {
+      str = mrb_str_new_static(mrb, name, len);
+    }
+    str = mrb_str_dump(mrb, str);
     return RSTRING_PTR(str);
   }
 }
-- 
cgit v1.2.3