kotovalexarian-likes-github
/
ruby--ruby
mirror of https://github.com/ruby/ruby.git
1
0
Fork 0
Code Releases Activity

rename absolute_path to realpath internally and introduce pathobj. 

* vm_core.h: rename absolute_path to realpath because it is expected name.
  external APIs (#absolute_path methods) are remained.

* vm_core.h: remove rb_iseq_location_struct::path and
  rb_iseq_location_struct::absolute_path and introduce pathobj.
  if given path equals to given absolute_path (and most of case
  it is true), pathobj is simply given path String. If it is not same,
  pathobj is Array and pathobj[0] is path and pathobj[1] is realpath.

  This size optimization reduce 8 bytes and
  sizeof(struct rb_iseq_constant_body) is 200 bytes -> 192 bytes
  on 64bit CPU.

  To support this change, the following functions are introduced:
    * pathobj_path() (defined in vm_core.h)
    * pathobj_realpath() (ditto)
    * rb_iseq_path() (decl. in vm_core.h)
    * rb_iseq_realpath() (ditto)
    * rb_iseq_pathobj_new() (ditto)
    * rb_iseq_pathobj_set() (ditto)

* vm_core.h (rb_binding_t): use pathobj instead of path. If binding
  is given at eval methods, realpath (absolute_path) was caller's
  realpath. However, they should use binding's realpath.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@58979 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1 2017-06-01 00:05:33 +00:00
parent d0015e4ac6
commit 478003f6df
13 changed files with 165 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
compile.c
View File

@ -175,9 +175,6 @@ struct iseq_compile_data_ensure_node_stack {
#define NEW_LABEL(l) new_label_body(iseq, (l))
#define LABEL_FORMAT "<L%03d>"
#define iseq_path(iseq) ((iseq)->body->location.path)
#define iseq_absolute_path(iseq) ((iseq)->body->location.absolute_path)
#define NEW_ISEQ(node, name, type, line_no) \
new_child_iseq(iseq, (node), rb_fstring(name), 0, (type), (line_no))
@ -328,7 +325,7 @@ static void
append_compile_error(rb_iseq_t *iseq, int line, const char *fmt, ...)
{
VALUE err_info = ISEQ_COMPILE_DATA(iseq)->err_info;
VALUE file = iseq->body->location.path;
VALUE file = rb_iseq_path(iseq);
VALUE err = err_info == Qtrue ? Qfalse : err_info;
va_list args;
@ -349,7 +346,7 @@ compile_bug(rb_iseq_t *iseq, int line, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
rb_report_bug_valist(iseq->body->location.path, line, fmt, args);
rb_report_bug_valist(rb_iseq_path(iseq), line, fmt, args);
va_end(args);
abort();
}
@ -532,7 +529,7 @@ iseq_add_mark_object(const rb_iseq_t *iseq, VALUE v)
return COMPILE_OK;
}
#define ruby_sourcefile RSTRING_PTR(iseq->body->location.path)
#define ruby_sourcefile RSTRING_PTR(rb_iseq_path(iseq))
static int
iseq_add_mark_object_compile_time(const rb_iseq_t *iseq, VALUE v)
@ -1116,7 +1113,7 @@ new_child_iseq(rb_iseq_t *iseq, NODE *node,
debugs("[new_child_iseq]> ---------------------------------------\n");
ret_iseq = rb_iseq_new_with_opt(node, name,
iseq_path(iseq), iseq_absolute_path(iseq),
rb_iseq_path(iseq), rb_iseq_realpath(iseq),
INT2FIX(line_no), parent, type, ISEQ_COMPILE_DATA(iseq)->option);
debugs("[new_child_iseq]< ---------------------------------------\n");
iseq_add_mark_object(iseq, (VALUE)ret_iseq);
@ -5809,7 +5806,7 @@ iseq_compile_each0(rb_iseq_t *iseq, LINK_ANCHOR *const ret, NODE *node, int popp
}
else {
if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
VALUE debug_info = rb_ary_new_from_args(2, iseq->body->location.path, INT2FIX(line));
VALUE debug_info = rb_ary_new_from_args(2, rb_iseq_path(iseq), INT2FIX(line));
VALUE str = rb_str_dup(node->nd_lit);
rb_ivar_set(str, id_debug_created_info, rb_obj_freeze(debug_info));
ADD_INSN1(ret, line, putobject, rb_obj_freeze(str));
@ -5832,7 +5829,7 @@ iseq_compile_each0(rb_iseq_t *iseq, LINK_ANCHOR *const ret, NODE *node, int popp
if (ISEQ_COMPILE_DATA(iseq)->option->frozen_string_literal) {
VALUE debug_info = Qnil;
if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal || RTEST(ruby_debug)) {
debug_info = rb_ary_new_from_args(2, iseq->body->location.path, INT2FIX(line));
debug_info = rb_ary_new_from_args(2, rb_iseq_path(iseq), INT2FIX(line));
iseq_add_mark_object_compile_time(iseq, rb_obj_freeze(debug_info));
}
ADD_INSN1(ret, line, freezestring, debug_info);
@ -7148,7 +7145,7 @@ rb_local_defined(ID id, const struct rb_block *base_block)
}
static int
caller_location(VALUE *path, VALUE *absolute_path)
caller_location(VALUE *path, VALUE *realpath)
{
const rb_thread_t *const th = GET_THREAD();
const rb_control_frame_t *const cfp =
@ -7156,13 +7153,13 @@ caller_location(VALUE *path, VALUE *absolute_path)
if (cfp) {
int line = rb_vm_get_sourceline(cfp);
*path = cfp->iseq->body->location.path;
*absolute_path = cfp->iseq->body->location.absolute_path;
*path = rb_iseq_path(cfp->iseq);
*realpath = rb_iseq_realpath(cfp->iseq);
return line;
}
else {
*path = rb_fstring_cstr("<compiled>");
*absolute_path = *path;
*realpath = *path;
return 1;
}
}
@ -7177,14 +7174,14 @@ static const rb_iseq_t *
method_for_self(VALUE name, VALUE arg, rb_insn_func_t func,
VALUE (*build)(rb_iseq_t *, LINK_ANCHOR *const, VALUE))
{
VALUE path, absolute_path;
VALUE path, realpath;
accessor_args acc;
acc.arg = arg;
acc.func = func;
acc.line = caller_location(&path, &absolute_path);
acc.line = caller_location(&path, &realpath);
return rb_iseq_new_with_opt((NODE *)IFUNC_NEW(build, (VALUE)&acc, 0),
rb_sym2str(name), path, absolute_path,
rb_sym2str(name), path, realpath,
INT2FIX(acc.line), 0, ISEQ_TYPE_METHOD, 0);
}
@ -7797,8 +7794,7 @@ ibf_dump_iseq_each(struct ibf_dump *dump, const rb_iseq_t *iseq)
struct rb_iseq_constant_body dump_body;
dump_body = *iseq->body;
dump_body.location.path = ibf_dump_object(dump, dump_body.location.path);
dump_body.location.absolute_path = ibf_dump_object(dump, dump_body.location.absolute_path);
dump_body.location.pathobj = ibf_dump_object(dump, dump_body.location.pathobj); /* TODO: freeze */
dump_body.location.base_label = ibf_dump_object(dump, dump_body.location.base_label);
dump_body.location.label = ibf_dump_object(dump, dump_body.location.label);
@ -7847,8 +7843,7 @@ ibf_load_iseq_each(const struct ibf_load *load, rb_iseq_t *iseq, ibf_offset_t of
RB_OBJ_WRITE(iseq, &load_body->mark_ary, iseq_mark_ary_create((int)body->mark_ary));
RB_OBJ_WRITE(iseq, &load_body->location.path, ibf_load_location_str(load, body->location.path));
RB_OBJ_WRITE(iseq, &load_body->location.absolute_path, ibf_load_location_str(load, body->location.absolute_path));
RB_OBJ_WRITE(iseq, &load_body->location.pathobj, ibf_load_location_str(load, body->location.pathobj));
RB_OBJ_WRITE(iseq, &load_body->location.base_label, ibf_load_location_str(load, body->location.base_label));
RB_OBJ_WRITE(iseq, &load_body->location.label, ibf_load_location_str(load, body->location.label));
load_body->location.first_lineno = body->location.first_lineno;

5
debug_counter.h
View File

@ -61,6 +61,11 @@ RB_DEBUG_COUNTER(obj_ary_embed)
RB_DEBUG_COUNTER(obj_obj_ptr)
RB_DEBUG_COUNTER(obj_obj_embed)
/* load */
RB_DEBUG_COUNTER(load_files)
RB_DEBUG_COUNTER(load_path_is_not_realpath)
#endif
#ifndef RUBY_DEBUG_COUNTER_H

2
gc.c
View File

@ -9210,7 +9210,7 @@ rb_raw_iseq_info(char *buff, const int buff_size, const rb_iseq_t *iseq)
if (iseq->body->location.label) {
snprintf(buff, buff_size, "%s %s@%s:%d", buff,
RSTRING_PTR(iseq->body->location.label),
RSTRING_PTR(iseq->body->location.path),
RSTRING_PTR(rb_iseq_path(iseq)),
FIX2INT(iseq->body->location.first_lineno));
}
}

99
iseq.c
View File

@ -107,16 +107,13 @@ rb_iseq_mark(const rb_iseq_t *iseq)
{
RUBY_MARK_ENTER("iseq");
RUBY_GC_INFO("%s @ %s\n", RSTRING_PTR(iseq->body->location.label), RSTRING_PTR(iseq->body->location.path));
if (iseq->body) {
const struct rb_iseq_constant_body *body = iseq->body;
RUBY_MARK_UNLESS_NULL(body->mark_ary);
rb_gc_mark(body->location.label);
rb_gc_mark(body->location.base_label);
rb_gc_mark(body->location.path);
RUBY_MARK_UNLESS_NULL(body->location.absolute_path);
rb_gc_mark(body->location.pathobj);
RUBY_MARK_UNLESS_NULL((VALUE)body->parent_iseq);
}
@ -216,17 +213,38 @@ iseq_alloc(void)
return iseq;
}
static rb_iseq_location_t *
iseq_location_setup(rb_iseq_t *iseq, VALUE path, VALUE absolute_path, VALUE name, VALUE first_lineno)
VALUE
rb_iseq_pathobj_new(VALUE path, VALUE realpath)
{
rb_iseq_location_t *loc = &iseq->body->location;
RB_OBJ_WRITE(iseq, &loc->path, path);
if (RTEST(absolute_path) && rb_str_cmp(path, absolute_path) == 0) {
RB_OBJ_WRITE(iseq, &loc->absolute_path, path);
VALUE pathobj;
VM_ASSERT(RB_TYPE_P(path, T_STRING));
VM_ASSERT(realpath == Qnil || RB_TYPE_P(realpath, T_STRING));
if (path == realpath ||
(!NIL_P(realpath) && rb_str_cmp(path, realpath) == 0)) {
pathobj = rb_fstring(path);
}
else {
RB_OBJ_WRITE(iseq, &loc->absolute_path, absolute_path);
if (!NIL_P(realpath)) realpath = rb_fstring(realpath);
pathobj = rb_ary_new_from_args(2, rb_fstring(path), realpath);
rb_obj_freeze(pathobj);
}
return pathobj;
}
void
rb_iseq_pathobj_set(const rb_iseq_t *iseq, VALUE path, VALUE realpath)
{
RB_OBJ_WRITE(iseq, &iseq->body->location.pathobj,
rb_iseq_pathobj_new(path, realpath));
}
static rb_iseq_location_t *
iseq_location_setup(rb_iseq_t *iseq, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno)
{
rb_iseq_location_t *loc = &iseq->body->location;
rb_iseq_pathobj_set(iseq, path, realpath);
RB_OBJ_WRITE(iseq, &loc->label, name);
RB_OBJ_WRITE(iseq, &loc->base_label, name);
loc->first_lineno = first_lineno;
@ -267,7 +285,7 @@ rb_iseq_add_mark_object(const rb_iseq_t *iseq, VALUE obj)
static VALUE
prepare_iseq_build(rb_iseq_t *iseq,
VALUE name, VALUE path, VALUE absolute_path, VALUE first_lineno,
VALUE name, VALUE path, VALUE realpath, VALUE first_lineno,
const rb_iseq_t *parent, enum iseq_type type,
const rb_compile_option_t *option)
{
@ -281,9 +299,7 @@ prepare_iseq_build(rb_iseq_t *iseq,
set_relation(iseq, parent);
name = rb_fstring(name);
path = rb_fstring(path);
if (RTEST(absolute_path)) absolute_path = rb_fstring(absolute_path);
iseq_location_setup(iseq, path, absolute_path, name, first_lineno);
iseq_location_setup(iseq, name, path, realpath, first_lineno);
if (iseq != iseq->body->local_iseq) {
RB_OBJ_WRITE(iseq, &iseq->body->location.base_label, iseq->body->local_iseq->body->location.label);
}
@ -311,7 +327,7 @@ prepare_iseq_build(rb_iseq_t *iseq,
if (option->coverage_enabled) {
VALUE coverages = rb_get_coverages();
if (RTEST(coverages)) {
coverage = rb_hash_lookup(coverages, path);
coverage = rb_hash_lookup(coverages, rb_iseq_path(iseq));
if (NIL_P(coverage)) coverage = Qfalse;
}
}
@ -329,8 +345,9 @@ cleanup_iseq_build(rb_iseq_t *iseq)
compile_data_free(data);
if (RTEST(err)) {
VALUE path = pathobj_path(iseq->body->location.pathobj);
if (err == Qtrue) err = rb_exc_new_cstr(rb_eSyntaxError, "compile error");
rb_funcallv(err, rb_intern("set_backtrace"), 1, &iseq->body->location.path);
rb_funcallv(err, rb_intern("set_backtrace"), 1, &path);
rb_exc_raise(err);
}
return Qtrue;
@ -438,25 +455,25 @@ make_compile_option_value(rb_compile_option_t *option)
}
rb_iseq_t *
rb_iseq_new(NODE *node, VALUE name, VALUE path, VALUE absolute_path,
rb_iseq_new(NODE *node, VALUE name, VALUE path, VALUE realpath,
const rb_iseq_t *parent, enum iseq_type type)
{
return rb_iseq_new_with_opt(node, name, path, absolute_path, INT2FIX(0), parent, type,
return rb_iseq_new_with_opt(node, name, path, realpath, INT2FIX(0), parent, type,
&COMPILE_OPTION_DEFAULT);
}
rb_iseq_t *
rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent)
{
return rb_iseq_new_with_opt(node, name, path, absolute_path, INT2FIX(0), parent, ISEQ_TYPE_TOP,
return rb_iseq_new_with_opt(node, name, path, realpath, INT2FIX(0), parent, ISEQ_TYPE_TOP,
&COMPILE_OPTION_DEFAULT);
}
rb_iseq_t *
rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path, const rb_iseq_t *parent)
rb_iseq_new_main(NODE *node, VALUE path, VALUE realpath, const rb_iseq_t *parent)
{
return rb_iseq_new_with_opt(node, rb_fstring_cstr("<main>"),
path, absolute_path, INT2FIX(0),
path, realpath, INT2FIX(0),
parent, ISEQ_TYPE_MAIN, &COMPILE_OPTION_DEFAULT);
}
@ -475,7 +492,7 @@ iseq_translate(rb_iseq_t *iseq)
}
rb_iseq_t *
rb_iseq_new_with_opt(NODE *node, VALUE name, VALUE path, VALUE absolute_path,
rb_iseq_new_with_opt(NODE *node, VALUE name, VALUE path, VALUE realpath,
VALUE first_lineno, const rb_iseq_t *parent,
enum iseq_type type, const rb_compile_option_t *option)
{
@ -483,7 +500,7 @@ rb_iseq_new_with_opt(NODE *node, VALUE name, VALUE path, VALUE absolute_path,
rb_iseq_t *iseq = iseq_alloc();
if (!option) option = &COMPILE_OPTION_DEFAULT;
prepare_iseq_build(iseq, name, path, absolute_path, first_lineno, parent, type, option);
prepare_iseq_build(iseq, name, path, realpath, first_lineno, parent, type, option);
rb_iseq_compile_node(iseq, node);
cleanup_iseq_build(iseq);
@ -542,7 +559,7 @@ iseq_load(VALUE data, const rb_iseq_t *parent, VALUE opt)
rb_iseq_t *iseq = iseq_alloc();
VALUE magic, version1, version2, format_type, misc;
VALUE name, path, absolute_path, first_lineno;
VALUE name, path, realpath, first_lineno;
VALUE type, body, locals, params, exception;
st_data_t iseq_type;
@ -565,8 +582,8 @@ iseq_load(VALUE data, const rb_iseq_t *parent, VALUE opt)
name = CHECK_STRING(rb_ary_entry(data, i++));
path = CHECK_STRING(rb_ary_entry(data, i++));
absolute_path = rb_ary_entry(data, i++);
absolute_path = NIL_P(absolute_path) ? Qnil : CHECK_STRING(absolute_path);
realpath = rb_ary_entry(data, i++);
realpath = NIL_P(realpath) ? Qnil : CHECK_STRING(realpath);
first_lineno = CHECK_INTEGER(rb_ary_entry(data, i++));
type = CHECK_SYMBOL(rb_ary_entry(data, i++));
@ -584,7 +601,7 @@ iseq_load(VALUE data, const rb_iseq_t *parent, VALUE opt)
make_compile_option(&option, opt);
option.peephole_optimization = FALSE; /* because peephole optimization can modify original iseq */
prepare_iseq_build(iseq, name, path, absolute_path, first_lineno,
prepare_iseq_build(iseq, name, path, realpath, first_lineno,
parent, (enum iseq_type)iseq_type, &option);
rb_iseq_build_from_ary(iseq, misc, locals, params, exception, body);
@ -612,7 +629,7 @@ rb_iseq_load(VALUE data, VALUE parent, VALUE opt)
}
rb_iseq_t *
rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, const struct rb_block *base_block, VALUE opt)
rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, const struct rb_block *base_block, VALUE opt)
{
rb_thread_t *th = GET_THREAD();
rb_iseq_t *iseq = NULL;
@ -652,7 +669,7 @@ rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE li
INITIALIZED VALUE label = parent ?
parent->body->location.label :
rb_fstring_cstr("<compiled>");
iseq = rb_iseq_new_with_opt(node, label, file, absolute_path, line,
iseq = rb_iseq_new_with_opt(node, label, file, realpath, line,
parent, type, &option);
}
@ -674,13 +691,19 @@ rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, const struct rb_block
VALUE
rb_iseq_path(const rb_iseq_t *iseq)
{
return iseq->body->location.path;
return pathobj_path(iseq->body->location.pathobj);
}
VALUE
rb_iseq_realpath(const rb_iseq_t *iseq)
{
return pathobj_realpath(iseq->body->location.pathobj);
}
VALUE
rb_iseq_absolute_path(const rb_iseq_t *iseq)
{
return iseq->body->location.absolute_path;
return rb_iseq_realpath(iseq);
}
VALUE
@ -967,7 +990,7 @@ iseqw_inspect(VALUE self)
else {
return rb_sprintf("<%s:%s@%s>",
rb_obj_classname(self),
RSTRING_PTR(iseq->body->location.label), RSTRING_PTR(iseq->body->location.path));
RSTRING_PTR(iseq->body->location.label), RSTRING_PTR(rb_iseq_path(iseq)));
}
}
@ -1019,7 +1042,7 @@ iseqw_path(VALUE self)
static VALUE
iseqw_absolute_path(VALUE self)
{
return rb_iseq_absolute_path(iseqw_check(self));
return rb_iseq_realpath(iseqw_check(self));
}
/* Returns the label of this instruction sequence.
@ -1484,7 +1507,7 @@ iseq_inspect(const rb_iseq_t *iseq)
return rb_sprintf("#<ISeq: uninitialized>");
}
else {
return rb_sprintf("#<ISeq:%s@%s>", RSTRING_PTR(iseq->body->location.label), RSTRING_PTR(iseq->body->location.path));
return rb_sprintf("#<ISeq:%s@%s>", RSTRING_PTR(iseq->body->location.label), RSTRING_PTR(rb_iseq_path(iseq)));
}
}
@ -2087,8 +2110,8 @@ iseq_data_to_ary(const rb_iseq_t *iseq)
rb_ary_push(val, INT2FIX(1));
rb_ary_push(val, misc);
rb_ary_push(val, iseq->body->location.label);
rb_ary_push(val, iseq->body->location.path);
rb_ary_push(val, iseq->body->location.absolute_path);
rb_ary_push(val, rb_iseq_path(iseq));
rb_ary_push(val, rb_iseq_realpath(iseq));
rb_ary_push(val, iseq->body->location.first_lineno);
rb_ary_push(val, type);
rb_ary_push(val, locals);

3
iseq.h
View File

@ -112,8 +112,7 @@ VALUE rb_iseqw_line_trace_specify(VALUE iseqval, VALUE pos, VALUE set);
VALUE rb_iseqw_new(const rb_iseq_t *iseq);
const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
VALUE rb_iseq_path(const rb_iseq_t *iseq);
VALUE rb_iseq_absolute_path(const rb_iseq_t *iseq);
VALUE rb_iseq_absolute_path(const rb_iseq_t *iseq); /* obsolete */
VALUE rb_iseq_label(const rb_iseq_t *iseq);
VALUE rb_iseq_base_label(const rb_iseq_t *iseq);
VALUE rb_iseq_first_lineno(const rb_iseq_t *iseq);

18
proc.c
View File

@ -276,13 +276,9 @@ static void
binding_mark(void *ptr)
{
rb_binding_t *bind = ptr;
RUBY_MARK_ENTER("binding");
block_mark(&bind->block);
RUBY_MARK_UNLESS_NULL(bind->path);
rb_gc_mark(bind->pathobj);
RUBY_MARK_LEAVE("binding");
}
@ -320,7 +316,7 @@ binding_dup(VALUE self)
GetBindingPtr(self, src);
GetBindingPtr(bindval, dst);
dst->block = src->block;
dst->path = src->path;
dst->pathobj = src->pathobj;
dst->first_lineno = src->first_lineno;
return bindval;
}
@ -1073,7 +1069,7 @@ iseq_location(const rb_iseq_t *iseq)
if (!iseq) return Qnil;
rb_iseq_check(iseq);
loc[0] = iseq->body->location.path;
loc[0] = rb_iseq_path(iseq);
loc[1] = iseq->body->location.first_lineno;
return rb_ary_new4(2, loc);
@ -1225,7 +1221,7 @@ proc_to_s_(VALUE self, const rb_proc_t *proc)
{
const rb_iseq_t *iseq = rb_iseq_check(block->as.captured.code.iseq);
rb_str_catf(str, "%p@%"PRIsVALUE":%d", (void *)self,
iseq->body->location.path,
rb_iseq_path(iseq),
FIX2INT(iseq->body->location.first_lineno));
}
break;
@ -2777,12 +2773,12 @@ proc_binding(VALUE self)
if (iseq) {
rb_iseq_check(iseq);
bind->path = iseq->body->location.path;
bind->pathobj = iseq->body->location.pathobj;
bind->first_lineno = FIX2INT(rb_iseq_first_lineno(iseq));
}
else {
bind->path = Qnil;
bind->first_lineno = 0;
bind->pathobj = rb_iseq_pathobj_new(rb_fstring_cstr("(binding)"), Qnil);
bind->first_lineno = 1;
}
return bindval;

19
vm.c
View File

@ -902,7 +902,7 @@ rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
vm_bind_update_env(bind, envval);
bind->block.as.captured.self = cfp->self;
bind->block.as.captured.code.iseq = cfp->iseq;
bind->path = ruby_level_cfp->iseq->body->location.path;
bind->pathobj = ruby_level_cfp->iseq->body->location.pathobj;
bind->first_lineno = rb_vm_get_sourceline(ruby_level_cfp);
return bindval;
@ -911,7 +911,9 @@ rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
const VALUE *
rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
{
VALUE envval, path = bind->path;
VALUE envval, pathobj = bind->pathobj;
VALUE path = pathobj_path(pathobj);
VALUE realpath = pathobj_realpath(pathobj);
const struct rb_block *base_block;
const rb_env_t *env;
rb_thread_t *th = GET_THREAD();
@ -932,7 +934,7 @@ rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
node = NEW_NODE(NODE_SCOPE, dyns, 0, 0);
if (base_iseq) {
iseq = rb_iseq_new(node, base_iseq->body->location.label, path, path, base_iseq, ISEQ_TYPE_EVAL);
iseq = rb_iseq_new(node, base_iseq->body->location.label, path, realpath, base_iseq, ISEQ_TYPE_EVAL);
}
else {
VALUE tempstr = rb_fstring_cstr("<temp>");
@ -1234,7 +1236,7 @@ rb_sourcefilename(void)
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->ec.cfp);
if (cfp) {
return cfp->iseq->body->location.path;
return rb_iseq_path(cfp->iseq);
}
else {
return Qnil;
@ -1248,7 +1250,7 @@ rb_sourcefile(void)
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->ec.cfp);
if (cfp) {
return RSTRING_PTR(cfp->iseq->body->location.path);
return RSTRING_PTR(rb_iseq_path(cfp->iseq));
}
else {
return 0;
@ -1277,7 +1279,7 @@ rb_source_location(int *pline)
if (cfp) {
if (pline) *pline = rb_vm_get_sourceline(cfp);
return cfp->iseq->body->location.path;
return rb_iseq_path(cfp->iseq);
}
else {
if (pline) *pline = 0;
@ -2060,7 +2062,7 @@ rb_thread_current_status(const rb_thread_t *th)
const rb_iseq_t *iseq = cfp->iseq;
int line_no = rb_vm_get_sourceline(cfp);
str = rb_sprintf("%"PRIsVALUE":%d:in `%"PRIsVALUE"'",
iseq->body->location.path, line_no, iseq->body->location.label);
rb_iseq_path(iseq), line_no, iseq->body->location.label);
}
}
else if ((me = rb_vm_frame_method_entry(cfp)) && me->def->original_id) {
@ -3085,7 +3087,8 @@ rb_vm_set_progname(VALUE filename)
rb_thread_t *th = GET_VM()->main_thread;
rb_control_frame_t *cfp = (void *)(th->ec.stack + th->ec.stack_size);
--cfp;
RB_OBJ_WRITE(cfp->iseq, &cfp->iseq->body->location.path, filename);
rb_iseq_pathobj_set(cfp->iseq, rb_str_dup(filename), rb_iseq_realpath(cfp->iseq));
}
extern const struct st_hash_type rb_fstring_hash_type;

22
vm_backtrace.c
View File

@ -232,7 +232,7 @@ location_path(rb_backtrace_location_t *loc)
switch (loc->type) {
case LOCATION_TYPE_ISEQ:
case LOCATION_TYPE_ISEQ_CALCED:
return loc->body.iseq.iseq->body->location.path;
return rb_iseq_path(loc->body.iseq.iseq);
case LOCATION_TYPE_CFUNC:
if (loc->body.cfunc.prev_loc) {
return location_path(loc->body.cfunc.prev_loc);
@ -260,20 +260,20 @@ location_path_m(VALUE self)
}
static VALUE
location_absolute_path(rb_backtrace_location_t *loc)
location_realpath(rb_backtrace_location_t *loc)
{
switch (loc->type) {
case LOCATION_TYPE_ISEQ:
case LOCATION_TYPE_ISEQ_CALCED:
return loc->body.iseq.iseq->body->location.absolute_path;
return rb_iseq_realpath(loc->body.iseq.iseq);
case LOCATION_TYPE_CFUNC:
if (loc->body.cfunc.prev_loc) {
return location_absolute_path(loc->body.cfunc.prev_loc);
return location_realpath(loc->body.cfunc.prev_loc);
}
return Qnil;
case LOCATION_TYPE_IFUNC:
default:
rb_bug("location_absolute_path: unreachable");
rb_bug("location_realpath: unreachable");
UNREACHABLE;
}
}
@ -286,7 +286,7 @@ location_absolute_path(rb_backtrace_location_t *loc)
static VALUE
location_absolute_path_m(VALUE self)
{
return location_absolute_path(location_ptr(self));
return location_realpath(location_ptr(self));
}
static VALUE
@ -314,20 +314,20 @@ location_to_str(rb_backtrace_location_t *loc)
switch (loc->type) {
case LOCATION_TYPE_ISEQ:
file = loc->body.iseq.iseq->body->location.path;
file = rb_iseq_path(loc->body.iseq.iseq);
name = loc->body.iseq.iseq->body->location.label;
lineno = loc->body.iseq.lineno.lineno = calc_lineno(loc->body.iseq.iseq, loc->body.iseq.lineno.pc);
loc->type = LOCATION_TYPE_ISEQ_CALCED;
break;
case LOCATION_TYPE_ISEQ_CALCED:
file = loc->body.iseq.iseq->body->location.path;
file = rb_iseq_path(loc->body.iseq.iseq);
lineno = loc->body.iseq.lineno.lineno;
name = loc->body.iseq.iseq->body->location.label;
break;
case LOCATION_TYPE_CFUNC:
if (loc->body.cfunc.prev_loc) {
file = loc->body.cfunc.prev_loc->body.iseq.iseq->body->location.path;
file = rb_iseq_path(loc->body.cfunc.prev_loc->body.iseq.iseq);
lineno = location_lineno(loc->body.cfunc.prev_loc);
}
else {
@ -686,7 +686,7 @@ oldbt_iter_iseq(void *ptr, const rb_control_frame_t *cfp)
const rb_iseq_t *iseq = cfp->iseq;
const VALUE *pc = cfp->pc;
struct oldbt_arg *arg = (struct oldbt_arg *)ptr;
VALUE file = arg->filename = iseq->body->location.path;
VALUE file = arg->filename = rb_iseq_path(iseq);
VALUE name = iseq->body->location.label;
int lineno = arg->lineno = calc_lineno(iseq, pc);
@ -1314,7 +1314,7 @@ VALUE
rb_profile_frame_absolute_path(VALUE frame)
{
const rb_iseq_t *iseq = frame2iseq(frame);
return iseq ? rb_iseq_absolute_path(iseq) : Qnil;
return iseq ? rb_iseq_realpath(iseq) : Qnil;
}
VALUE

52
vm_core.h
View File

@ -261,13 +261,39 @@ struct rb_call_cache {
#define GetCoreDataFromValue(obj, type, ptr) ((ptr) = CoreDataFromValue((obj), type))
typedef struct rb_iseq_location_struct {
VALUE path;
VALUE absolute_path;
VALUE base_label;
VALUE label;
VALUE pathobj; /* String (path) or Array [path, realpath]. Frozen. */
VALUE base_label; /* String */
VALUE label; /* String */
VALUE first_lineno; /* TODO: may be unsigned short */
} rb_iseq_location_t;
#define PATHOBJ_PATH 0
#define PATHOBJ_REALPATH 1
static inline VALUE
pathobj_path(VALUE pathobj)
{
if (RB_TYPE_P(pathobj, T_STRING)) {
return pathobj;
}
else {
VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
return RARRAY_AREF(pathobj, PATHOBJ_PATH);
}
}
static inline VALUE
pathobj_realpath(VALUE pathobj)
{
if (RB_TYPE_P(pathobj, T_STRING)) {
return pathobj;
}
else {
VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
return RARRAY_AREF(pathobj, PATHOBJ_REALPATH);
}
}
struct rb_iseq_constant_body {
enum iseq_type {
ISEQ_TYPE_TOP,
@ -842,16 +868,16 @@ typedef enum {
RUBY_SYMBOL_EXPORT_BEGIN
/* node -> iseq */
rb_iseq_t *rb_iseq_new (NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent, enum iseq_type);
rb_iseq_t *rb_iseq_new_top (NODE *node, VALUE name, VALUE path, VALUE absolute_path, const rb_iseq_t *parent);
rb_iseq_t *rb_iseq_new_main (NODE *node, VALUE path, VALUE absolute_path, const rb_iseq_t *parent);
rb_iseq_t *rb_iseq_new_with_opt(NODE* node, VALUE name, VALUE path, VALUE absolute_path, VALUE first_lineno,
rb_iseq_t *rb_iseq_new (NODE *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum iseq_type);
rb_iseq_t *rb_iseq_new_top (NODE *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent);
rb_iseq_t *rb_iseq_new_main (NODE *node, VALUE path, VALUE realpath, const rb_iseq_t *parent);
rb_iseq_t *rb_iseq_new_with_opt(NODE* node, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno,
const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t*);
/* src -> iseq */
rb_iseq_t *rb_iseq_compile(VALUE src, VALUE file, VALUE line);
rb_iseq_t *rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, const struct rb_block *base_block);
rb_iseq_t *rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, const struct rb_block *base_block, VALUE opt);
rb_iseq_t *rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, const struct rb_block *base_block, VALUE opt);
VALUE rb_iseq_disasm(const rb_iseq_t *iseq);
int rb_iseq_disasm_insn(VALUE str, const VALUE *iseqval, size_t pos, const rb_iseq_t *iseq, VALUE child);
@ -889,7 +915,7 @@ extern const rb_data_type_t ruby_binding_data_type;
typedef struct {
struct rb_block block;
VALUE path;
VALUE pathobj;
unsigned short first_lineno;
} rb_binding_t;
@ -1417,7 +1443,13 @@ NORETURN(void rb_bug_context(const void *, const char *fmt, ...));
RUBY_SYMBOL_EXPORT_BEGIN
VALUE rb_iseq_eval(const rb_iseq_t *iseq);
VALUE rb_iseq_eval_main(const rb_iseq_t *iseq);
VALUE rb_iseq_path(const rb_iseq_t *iseq);
VALUE rb_iseq_realpath(const rb_iseq_t *iseq);
RUBY_SYMBOL_EXPORT_END
VALUE rb_iseq_pathobj_new(VALUE path, VALUE realpath);
void rb_iseq_pathobj_set(const rb_iseq_t *iseq, VALUE path, VALUE realpath);
int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, ID *called_idp, VALUE *klassp);
VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, VALUE block_handler);

2
vm_dump.c
View File

@ -107,7 +107,7 @@ control_frame_dump(rb_thread_t *th, rb_control_frame_t *cfp)
iseq_name = RSTRING_PTR(cfp->iseq->body->location.label);
line = rb_vm_get_sourceline(cfp);
if (line) {
snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(cfp->iseq->body->location.path), line);
snprintf(posbuf, MAX_POSBUF, "%s:%d", RSTRING_PTR(rb_iseq_path(cfp->iseq)), line);
}
}
}

19
vm_eval.c
View File

@ -1296,20 +1296,20 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, rb_cref_t *const cref_
rb_cref_t *cref = cref_arg;
rb_binding_t *bind = 0;
const rb_iseq_t *iseq;
VALUE absolute_path = Qnil;
VALUE realpath = Qnil;
VALUE fname;
if (file != Qundef) {
absolute_path = file;
realpath = file;
}
if (!NIL_P(scope)) {
bind = Check_TypedStruct(scope, &ruby_binding_data_type);
if (NIL_P(absolute_path) && !NIL_P(bind->path)) {
file = bind->path;
if (NIL_P(realpath)) {
file = pathobj_path(bind->pathobj);
realpath = pathobj_realpath(bind->pathobj);
line = bind->first_lineno;
absolute_path = rb_current_realfilepath();
}
base_block = &bind->block;
}
@ -1332,13 +1332,8 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, rb_cref_t *const cref_
fname = rb_usascii_str_new_cstr("(eval)");
}
if (RTEST(fname))
fname = rb_fstring(fname);
if (RTEST(absolute_path))
absolute_path = rb_fstring(absolute_path);
/* make eval iseq */
iseq = rb_iseq_compile_with_option(src, fname, absolute_path, INT2FIX(line), base_block, Qnil);
iseq = rb_iseq_compile_with_option(src, fname, realpath, INT2FIX(line), base_block, Qnil);
if (!iseq) {
rb_exc_raise(adjust_backtrace_in_eval(th, th->errinfo));
@ -2180,7 +2175,7 @@ rb_current_realfilepath(void)
rb_thread_t *th = GET_THREAD();
rb_control_frame_t *cfp = th->ec.cfp;
cfp = vm_get_ruby_level_caller_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
if (cfp != 0) return cfp->iseq->body->location.absolute_path;
if (cfp != 0) return rb_iseq_realpath(cfp->iseq);
return Qnil;
}

4
vm_method.c
View File

@ -267,7 +267,7 @@ method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def,
cfp = rb_vm_get_ruby_level_next_cfp(th, th->ec.cfp);
if (cfp && (line = rb_vm_get_sourceline(cfp))) {
VALUE location = rb_ary_new3(2, cfp->iseq->body->location.path, INT2FIX(line));
VALUE location = rb_ary_new3(2, rb_iseq_path(cfp->iseq), INT2FIX(line));
RB_OBJ_WRITE(me, &def->body.attr.location, rb_ary_freeze(location));
}
else {
@ -558,7 +558,7 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
break;
}
if (iseq) {
rb_compile_warning(RSTRING_PTR(iseq->body->location.path),
rb_compile_warning(RSTRING_PTR(rb_iseq_path(iseq)),
FIX2INT(iseq->body->location.first_lineno),
"previous definition of %"PRIsVALUE" was here",
rb_id2str(old_def->original_id));

2
vm_trace.c
View File

@ -753,7 +753,7 @@ fill_path_and_lineno(rb_trace_arg_t *trace_arg)
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(trace_arg->th, trace_arg->cfp);
if (cfp) {
trace_arg->path = cfp->iseq->body->location.path;
trace_arg->path = rb_iseq_path(cfp->iseq);
trace_arg->lineno = rb_vm_get_sourceline(cfp);
}
else {