update-coverage: update-simplecov update-simplecov-html update-doclie

INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \

$(INSNS): $(srcdir)/insns.def vm_opts.h \

$(srcdir)/defs/opt_operand.def $(srcdir)/defs/opt_insn_unif.def \

return ary;

}

rb_ary_tmp_new_from_values(VALUE klass, long n, const VALUE *elts)

{

VALUE ary;

return rb_check_convert_type_with_id(ary, T_ARRAY, "Array", idTo_ary);

}

rb_check_to_array(VALUE ary)

{

return rb_check_convert_type_with_id(ary, T_ARRAY, "Array", idTo_a);

return rb_ary_subseq(ary, beg, len);

}

rb_ary_aref1(VALUE ary, VALUE arg)

{

long beg, len;

return big;

}

rb_int128t2big(int128_t n)

{

int neg = 0;

* \return the value \c Class#inherited's returns

* \pre Each of \a super and \a klass must be a \c Class object.

*/

rb_class_inherited(VALUE super, VALUE klass)

{

ID inherited;

rb_attr(klass, rb_intern(name), read, write, FALSE);

}

rb_keyword_error_new(const char *error, VALUE keys)

{

const VALUE *ptr = RARRAY_CONST_PTR(keys);

$(srcs_vpath)insns_info.inc: $(srcdir)/tool/ruby_vm/views/insns_info.inc.erb

$(srcs_vpath)vmtc.inc: $(srcdir)/tool/ruby_vm/views/vmtc.inc.erb

$(srcs_vpath)vm.inc: $(srcdir)/tool/ruby_vm/views/vm.inc.erb

common-srcs: $(srcs_vpath)parse.c $(srcs_vpath)lex.c $(srcs_vpath)enc/trans/newline.c $(srcs_vpath)id.c \

srcs-lib srcs-ext incs

mjit.$(OBJEXT): {$(VPATH)}ruby_assert.h

mjit.$(OBJEXT): {$(VPATH)}version.h

mjit.$(OBJEXT): {$(VPATH)}vm_core.h

mjit_compile.$(OBJEXT): {$(VPATH)}internal.h

mjit_compile.$(OBJEXT): {$(VPATH)}mjit_compile.c

mjit_compile.$(OBJEXT): {$(VPATH)}vm_core.h

load.$(OBJEXT): $(CCAN_DIR)/check_type/check_type.h

load.$(OBJEXT): $(CCAN_DIR)/container_of/container_of.h

}

#if OPT_DIRECT_THREADED_CODE || OPT_CALL_THREADED_CODE

rb_vm_insn_addr2insn(const void *addr) /* cold path */

{

int insn;

return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt));

}

rb_exc_set_backtrace(VALUE exc, VALUE bt)

{

return exc_set_backtrace(exc, bt);

break;

case T_MODULE:

case T_CLASS:

rb_id_table_free(RCLASS_M_TBL(obj));

if (RCLASS_IV_TBL(obj)) {

st_free_table(RCLASS_IV_TBL(obj));

#define STACKFRAME_FOR_CALL_CFUNC 838

rb_ec_stack_check(rb_execution_context_t *ec)

{

return stack_check(ec, STACKFRAME_FOR_CALL_CFUNC);

/*

* remember `obj' if needed.

*/

rb_gc_writebarrier_remember(VALUE obj)

{

rb_objspace_t *objspace = &rb_objspace;

return hash;

}

rb_hash_new_with_size(st_index_t size)

{

VALUE ret = rb_hash_new();

return hash_tbl(hash);

}

rb_hash_tbl_raw(VALUE hash)

{

return hash_tbl(hash);

*

*/

rb_hash_keys(VALUE hash)

{

VALUE keys;

* See also Enumerable#include?

*/

rb_hash_has_key(VALUE hash, VALUE key)

{

if (!RHASH(hash)->ntbl)

*

*/

rb_hash_compare_by_id_p(VALUE hash)

{

if (!RHASH(hash)->ntbl)

#define RUBY_FUNC_EXPORTED

#endif

#ifndef RUBY_EXTERN

#define RUBY_EXTERN extern

#endif

class_iseq->body->iseq_encoded, GET_SP(),

class_iseq->body->local_table_size,

class_iseq->body->stack_max);

}

/**********************************************************/

val = vm_invoke_block(ec, GET_CFP(), &calling, ci, block_handler);

if (val == Qundef) {

}

}

val = vm_opt_neq(ci, cc, ci_eq, cc_eq, recv, obj);

if (val == Qundef) {

ADD_PC(2); /* !!! */

DIS_ORIGINAL_INSN(opt_send_without_block);

}

}

val = tmp;

}

else {

TOPN(0) = rb_str_resurrect(key);

PUSH(val);

ADD_PC(1); /* !!! */

DIS_ORIGINAL_INSN(opt_send_without_block);

}

}

val = vm_opt_aref_with(recv, key);

if (val == Qundef) {

PUSH(rb_str_resurrect(key));

ADD_PC(1); /* !!! */

DIS_ORIGINAL_INSN(opt_send_without_block);

}

}

THROW_EXCEPTION(err);

}

}

/* BLT */

int rb_local_defined(ID, const struct rb_block *);

const char * rb_insns_name(int i);

VALUE rb_insns_name_array(void);

/* complex.c */

VALUE rb_complex_plus(VALUE, VALUE);

}

}

rb_iseq_event_flags(const rb_iseq_t *iseq, size_t pos)

{

const struct iseq_insn_info_entry *entry = get_insn_info(iseq, pos);

#include "mjit.h"

#include "version.h"

#include "gc.h"

#include "ruby_assert.h"

extern void rb_native_mutex_lock(rb_nativethread_lock_t *lock);

static char *pch_file;

/* Path of "/tmp", which can be changed to $TMP in MinGW. */

static char *tmp_dir;

/* Ruby level interface module. */

VALUE rb_mMJIT;

/* TODO: Should we initiate MJIT in the forked Ruby. */

}

/* Default permitted number of units with a JIT code kept in

memory. */

#define DEFAULT_CACHE_SIZE 1000

rb_native_cond_initialize(&mjit_worker_wakeup, RB_CONDATTR_CLOCK_MONOTONIC);

rb_native_cond_initialize(&mjit_gc_wakeup, RB_CONDATTR_CLOCK_MONOTONIC);

/* Initialize worker thread */

finish_worker_p = FALSE;

worker_finished = FALSE;

CRITICAL_SECTION_FINISH(4, "mjit_mark");

RUBY_MARK_LEAVE("mjit");

}

extern void mjit_mark(void);

extern struct mjit_cont *mjit_cont_new(rb_execution_context_t *ec);

extern void mjit_cont_free(struct mjit_cont *cont);

/* A threshold used to reject long iseqs from JITting as such iseqs

takes too much time to be compiled. */

#include "internal.h"

#include "vm_core.h"

int

mjit_compile(FILE *f, const struct rb_iseq_constant_body *body, const char *funcname)

{

}

* An error will be raised if y == 0.

*/

ruby_float_mod(double x, double y)

{

double mod;

* so an implementation-dependent value is returned.

*/

rb_float_equal(VALUE x, VALUE y)

{

volatile double a, b;

return rb_dbl_cmp(a, b);

}

rb_float_cmp(VALUE x, VALUE y)

{

return NUM2INT(flo_cmp(x, y));

* \private

*++

*/

rb_obj_equal(VALUE obj1, VALUE obj2)

{

if (obj1 == obj2) return Qtrue;

*++

*/

rb_obj_not(VALUE obj)

{

return RTEST(obj) ? Qfalse : Qtrue;

*++

*/

rb_obj_not_equal(VALUE obj1, VALUE obj2)

{

VALUE result = rb_funcall(obj1, id_eq, 1, obj2);

}

/*! \private */

rb_obj_copy_ivar(VALUE dest, VALUE obj)

{

if (!(RBASIC(dest)->flags & ROBJECT_EMBED) && ROBJECT_IVPTR(dest)) {

}

/*! \private */

rb_check_convert_type_with_id(VALUE val, int type, const char *tname, ID method)

{

VALUE v;

return IFUNC_NEW(func, data, arity.packed);

}

rb_func_proc_new(rb_block_call_func_t func, VALUE val)

{

struct vm_ifunc *ifunc = rb_vm_ifunc_proc_new(func, (void *)val);

return rb_hash_uint(hash, (st_index_t)proc->block.as.captured.ep >> 16);

}

rb_sym_to_proc(VALUE sym)

{

static VALUE sym_proc_cache = Qfalse;

return re;

}

rb_reg_new_ary(VALUE ary, int opt)

{

return rb_reg_new_str(rb_reg_preprocess_dregexp(ary, opt), opt);

/* Mimics ruby's { foo => bar } syntax. This function is placed here

because it touches table internals and write barriers at once. */

rb_hash_bulk_insert(long argc, const VALUE *argv, VALUE hash)

{

st_index_t n;

return setup_fake_str(fake_str, name, len, rb_enc_to_index(enc));

}

rb_fstring_new(const char *ptr, long len)

{

struct RString fake_str;

return rb_obj_as_string_result(str, obj);

}

rb_obj_as_string_result(VALUE str, VALUE obj)

{

if (!RB_TYPE_P(str, T_STRING))

#define MIN_PRE_ALLOC_SIZE 48

rb_str_concat_literals(size_t num, const VALUE *strary)

{

VALUE str;

return str;

}

rb_id_quote_unprintable(ID id)

{

return rb_str_quote_unprintable(rb_id2str(id));

return sym;

}

rb_sym_proc_call(ID mid, int argc, const VALUE *argv, VALUE passed_proc)

{

VALUE obj;

class TestThreadFdClose < Test::Unit::TestCase

def test_thread_fd_close

IO.pipe do |r, w|

th = Thread.new do

begin

puts if @verbose

$stdout.flush

inst._assertions

}

end

def test_autoclose_true_closed_by_finalizer

feature2250 = '[ruby-core:26222]'

pre = 'ft2250'

t = Tempfile.new(pre)

assert_raise(Errno::EBADF, feature2250) {t.close}

end

ensure

end

def test_autoclose_false_closed_by_finalizer

}

# it is dirty hack. usually we shouldn't use such technique

Thread.pass until t.status == 'sleep'

t.add_trace_func proc{|ev, file, line, *args|

if file == __FILE__

s += 1

end

Thread.pass until t.stop?

assert_equal(1, s)

t.wakeup

Thread.pass while t.alive?

class TestGemUtil < Gem::TestCase

def test_class_popen

assert_equal "0\n", Gem::Util.popen(Gem.ruby, '-e', 'p 0')

assert_raises Errno::ECHILD do

end

def test_condvar_wait_exception_handling

# Calling wait in the only thread running should raise a ThreadError of

# 'stopping only thread'

mutex = Mutex.new

}

sleep 0.1 until t.stop?

t.raise

t.join

server.virtual_host(WEBrick::HTTPServer.new(vhost_config))

Thread.pass while server.status != :Running

assert_equal(1, started, log.call)

assert_equal(0, stopped, log.call)

assert_equal(0, accepted, log.call)

}

TestWEBrick.start_server(Echo, config){|server, addr, port, log|

true while server.status != :Running

assert_equal(1, started, log.call)

assert_equal(0, stopped, log.call)

assert_equal(0, accepted, log.call)

return interrupt & (rb_atomic_t)~ec->interrupt_mask;

}

rb_threadptr_execute_interrupts(rb_thread_t *th, int blocking_timing)

{

rb_atomic_t interrupt;

]

IGNORED_FUNCTIONS = [

'rb_equal_opt', # Not used from VM and not compilable

]

known_errors.inc

lex.c

miniprelude.c

newline.c

node_name.inc

opt_sc.inc

struct trace_var *trace;

};

rb_global_entry(ID id)

{

struct rb_global_entry *entry;

return Qnil;

}

rb_gvar_get(struct rb_global_entry *entry)

{

struct rb_global_variable *var = entry->var;

return Qnil; /* not reached */

}

rb_gvar_set(struct rb_global_entry *entry, VALUE val)

{

struct trace_data trace;

return rb_gvar_get(entry);

}

rb_gvar_defined(struct rb_global_entry *entry)

{

if (entry->var->getter == rb_gvar_undef_getter) return Qfalse;

return 0;

}

rb_autoloading_value(VALUE mod, ID id, VALUE* value)

{

VALUE load;

return (ele = check_autoload_data(load)) ? ele->feature : Qnil;

}

rb_const_warn_if_deprecated(const rb_const_entry_t *ce, VALUE klass, ID id)

{

if (RB_CONST_DEPRECATED_P(ce)) {

return rb_const_get_0(klass, id, TRUE, FALSE, FALSE);

}

rb_public_const_get_from(VALUE klass, ID id)

{

return rb_const_get_0(klass, id, TRUE, TRUE, TRUE);

return rb_const_get_0(klass, id, FALSE, TRUE, TRUE);

}

rb_public_const_get_at(VALUE klass, ID id)

{

return rb_const_get_0(klass, id, TRUE, FALSE, TRUE);

return rb_const_defined_0(klass, id, TRUE, FALSE, FALSE);

}

rb_public_const_defined_from(VALUE klass, ID id)

{

return rb_const_defined_0(klass, id, TRUE, TRUE, TRUE);

return new_tbl;

}

rb_const_lookup(VALUE klass, ID id)

{

struct rb_id_table *tbl = RCLASS_CONST_TBL(klass);

#endif

static VALUE vm_make_env_object(const rb_execution_context_t *ec, rb_control_frame_t *cfp);

static VALUE vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc, VALUE self, int argc, const VALUE *argv, VALUE block_handler);

static VALUE rb_block_param_proxy;

#include "vm_insnhelper.h"

#include "vm_exec.h"

#include "vm_insnhelper.c"

#include "vm_exec.c"

#include "vm_method.c"

#include "vm_eval.c"

#define PROCDEBUG 0

rb_serial_t

rb_next_class_serial(void)

{

}

VALUE rb_cRubyVM;

VALUE rb_class_path_no_cache(VALUE _klass);

rb_dtrace_setup(rb_execution_context_t *ec, VALUE klass, ID id,

struct ruby_dtrace_method_hook_args *args)

{

return 0;

}

rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)

{

if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) bp();

return 0;

}

static rb_control_frame_t *

vm_get_ruby_level_caller_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp)

{

vm_pop_frame(ec, cfp, cfp->ep);

}

void

rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp)

{

}

rb_vm_make_proc_lambda(const rb_execution_context_t *ec, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda)

{

VALUE procval;

return invoke_block_from_c_proc(ec, proc, self, argc, argv, passed_block_handler, proc->is_lambda);

}

vm_invoke_bmethod(rb_execution_context_t *ec, rb_proc_t *proc, VALUE self,

int argc, const VALUE *argv, VALUE block_handler)

{

return invoke_block_from_c_proc(ec, proc, self, argc, argv, block_handler, TRUE);

}

rb_vm_invoke_proc(rb_execution_context_t *ec, rb_proc_t *proc,

int argc, const VALUE *argv, VALUE passed_block_handler)

{

return exc;

}

rb_vm_localjump_error(const char *mesg, VALUE value, int reason)

{

VALUE exc = make_localjump_error(mesg, value, reason);

};

*/

vm_exec(rb_execution_context_t *ec)

{

enum ruby_tag_type state;

if ((state = EC_EXEC_TAG()) == TAG_NONE) {

result = mjit_exec(ec);

vm_loop_start:

VM_ASSERT(ec->tag == &_tag);

if ((state = _tag.state) != TAG_NONE) {

err = (struct vm_throw_data *)result;

state = 0;

ec->tag->state = TAG_NONE;

ec->errinfo = Qnil;

result = Qundef;

goto vm_loop_start;

}

}

#endif

#include "vm_call_iseq_optimized.inc" /* required from vm_insnhelper.c */

loc->body.cfunc.prev_loc = arg->prev_loc;

}

rb_ec_backtrace_object(const rb_execution_context_t *ec)

{

struct bt_iter_arg arg;

return bt->strary;

}

rb_backtrace_use_iseq_first_lineno_for_last_location(VALUE self)

{

const rb_backtrace_t *bt;

VALUE self; /* cfp[3] / block[0] */

const VALUE *ep; /* cfp[4] / block[1] */

const void *block_code; /* cfp[5] / block[2] */ /* iseq or ifunc */

#if VM_DEBUG_BP_CHECK

#endif

} rb_control_frame_t;

static inline VALUE vm_yield(rb_execution_context_t *ec, int argc, const VALUE *argv);

static inline VALUE vm_yield_with_block(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE block_handler);

static inline VALUE vm_yield_force_blockarg(rb_execution_context_t *ec, VALUE args);

static void vm_set_eval_stack(rb_execution_context_t * th, const rb_iseq_t *iseq, const rb_cref_t *cref, const struct rb_block *base_block);

static int vm_collect_local_variables_in_heap(const VALUE *dfp, const struct local_var_list *vars);

static VALUE send_internal(int argc, const VALUE *argv, VALUE recv, call_type scope);

static VALUE vm_call0_body(rb_execution_context_t* ec, struct rb_calling_info *calling, const struct rb_call_info *ci, struct rb_call_cache *cc, const VALUE *argv);

vm_call0(rb_execution_context_t *ec, VALUE recv, ID id, int argc, const VALUE *argv, const rb_callable_method_entry_t *me)

{

struct rb_calling_info calling_entry, *calling;

return cfp->self;

}

static inline void

stack_check(rb_execution_context_t *ec)

{

}

}

static inline const rb_callable_method_entry_t *rb_search_method_entry(VALUE recv, ID mid);

static inline enum method_missing_reason rb_method_call_status(rb_execution_context_t *ec, const rb_callable_method_entry_t *me, call_type scope, VALUE self);

UNREACHABLE;

}

make_no_method_exception(VALUE exc, VALUE format, VALUE obj,

int argc, const VALUE *argv, int priv)

{

return rb_class_new_instance(n, args, exc);

}

static void

raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE obj,

enum method_missing_reason last_call_status)

return result;

}

/*!

* Calls a method

* \param recv receiver of the method

id_tag = rb_intern_const("tag");

id_value = rb_intern_const("value");

}

#endif

#define VM_SP_CNT(ec, sp) ((sp) - (ec)->vm_stack)

#if OPT_CALL_THREADED_CODE

#define THROW_EXCEPTION(exc) do { \

ec->errinfo = (VALUE)(exc); \

#else

#define THROW_EXCEPTION(exc) return (VALUE)(exc)

#endif

#define SCREG(r) (reg_##r)

*sp++ = specval /* ep[-1] / block handler or prev env ptr */;

*sp = type; /* ep[-0] / ENV_FLAGS */

cfp->sp = sp + 1;

#if VM_DEBUG_BP_CHECK

static VALUE vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, const struct rb_call_info *ci, struct rb_call_cache *cc);

static void

vm_search_method(const struct rb_call_info *ci, struct rb_call_cache *cc, VALUE recv)

{

}

RB_DEBUG_COUNTER_INC(mc_inline_miss);

#endif

}

static inline int

return opt_eql_func(obj1, obj2, &ci, &cc);

}

static VALUE

check_match(rb_execution_context_t *ec, VALUE pattern, VALUE target, enum vm_check_match_type type)

static vm_call_handler vm_call_iseq_setup_func(const struct rb_call_info *ci, const int param_size, const int local_size);

static const rb_iseq_t *

def_iseq_ptr(rb_method_definition_t *def)

return vm_call_iseq_setup_normal(ec, cfp, calling, ci, cc, 0, param, local);

}

simple_iseq_p(const rb_iseq_t *iseq)

{

return iseq->body->param.flags.has_opt == FALSE &&

#define CALL_METHOD(calling, ci, cc) do { \

VALUE v = (*(cc)->call)(ec, GET_CFP(), (calling), (ci), (cc)); \

if (v == Qundef && (v = mjit_exec(ec)) == Qundef) { \

} \

else { \

val = v; \

#define GET_GLOBAL_CONSTANT_STATE() (ruby_vm_global_constant_state)

#define INC_GLOBAL_CONSTANT_STATE() (++ruby_vm_global_constant_state)

int argc, const VALUE *argv, int priv);

static inline struct vm_throw_data *

static void

rb_class_clear_method_cache(VALUE klass, VALUE arg)

{

RCLASS_SERIAL(klass) = rb_next_class_serial();

if (RB_TYPE_P(klass, T_ICLASS)) {

}

static inline rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr);

static inline rb_method_entry_t *

lookup_method_table(VALUE klass, ID id)

cfunc->invoker = call_cfunc_invoker_func(argc);

}

method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def, void *opts)

{

*(rb_method_definition_t **)&me->def = def;

}

}

method_definition_create(rb_method_type_t type, ID mid)

{

rb_method_definition_t *def;

return me;

}

rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class)

{

rb_method_definition_t *def = src_me->def;

return method_entry_get_without_cache(klass, id, defined_class_ptr);

}

rb_method_entry(VALUE klass, ID id)

{

return method_entry_get(klass, id, NULL);

return cme;

}

rb_callable_method_entry(VALUE klass, ID id)

{

VALUE defined_class;

return me;

}

rb_callable_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)

{

VALUE defined_class, *dcp = defined_class_ptr ? defined_class_ptr : &defined_class;

return method_entry_resolve_refinement(klass, id, FALSE, defined_class_ptr);

}

rb_callable_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)

{

VALUE defined_class, *dcp = defined_class_ptr ? defined_class_ptr : &defined_class;

return def;

}

rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2)

{

d1 = original_method_definition(d1);

return state;

}

rb_exec_event_hooks(rb_trace_arg_t *trace_arg, int pop_p)

{

rb_execution_context_t *ec = trace_arg->ec;

$(Q) $(IFCHANGE) $@ vm.i

INSNS = opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \

!if [exit > insns_rules.mk]

!else if [for %I in ($(INSNS)) do \

end

class Exports

@@subclass = []

def self.inherited(klass)