Class: RubyVM

Inherits:
Object show all
Defined in:
vm.c,
vm.c

Overview

The RubyVM module only exists on MRI. RubyVM is not defined in other Ruby implementations such as JRuby and TruffleRuby.

The RubyVM module provides some access to MRI internals. This module is for very limited purposes, such as debugging, prototyping, and research. Normal users must not use it. This module is not portable between Ruby implementations.

Defined Under Namespace

Modules: AbstractSyntaxTree Classes: InstructionSequence

Constant Summary collapse

OPTS =

RubyVM::OPTS An Array of VM build options. This constant is MRI specific.

:
INSTRUCTION_NAMES =

RubyVM::INSTRUCTION_NAMES A list of bytecode instruction names in MRI. This constant is MRI specific.

:
DEFAULT_PARAMS =

RubyVM::DEFAULT_PARAMS This constant exposes the VM’s default parameters. Note that changing these values does not affect VM execution. Specification is not stable and you should not depend on this value. Of course, this constant is MRI specific.

:

Class Method Summary collapse

Class Method Details

.each_builtin ⇒ Object

:nodoc:



82
83
84
85
86
87
 
# File 'mini_builtin.c', line 82

static VALUE
each_builtin(VALUE self)
{
    st_foreach(loaded_builtin_table, each_builtin_i, 0);
    return Qnil;
}

.keep_script_lines ⇒ Boolean

Return current keep_script_lines status. Now it only returns true of false, but it can return other objects in future.

Note that this is an API for ruby internal use, debugging, and research. Do not use this for any other purpose. The compatibility is not guaranteed.

Returns:

  • (Boolean) 


3805
3806
3807
3808
3809
 
# File 'vm.c', line 3805

static VALUE
vm_keep_script_lines(VALUE self)
{
    return RBOOL(ruby_vm_keep_script_lines);
}

.keep_script_lines=(true) ⇒ Object

It set keep_script_lines flag. If the flag is set, all loaded scripts are recorded in a interpreter process.

Note that this is an API for ruby internal use, debugging, and research. Do not use this for any other purpose. The compatibility is not guaranteed.



3822
3823
3824
3825
3826
3827
 
# File 'vm.c', line 3822

static VALUE
vm_keep_script_lines_set(VALUE self, VALUE flags)
{
    ruby_vm_keep_script_lines = RTEST(flags);
    return flags;
}

.mtbl(obj, sym) ⇒ Object

:nodoc:



3779
3780
3781
3782
3783
3784
 
# File 'vm.c', line 3779

static VALUE
vm_mtbl(VALUE self, VALUE obj, VALUE sym)
{
    vm_mtbl_dump(CLASS_OF(obj), RTEST(sym) ? SYM2ID(sym) : 0);
    return Qnil;
}

.mtbl2(obj, sym) ⇒ Object

:nodoc:



3787
3788
3789
3790
3791
3792
 
# File 'vm.c', line 3787

static VALUE
vm_mtbl2(VALUE self, VALUE obj, VALUE sym)
{
    vm_mtbl_dump(obj, RTEST(sym) ? SYM2ID(sym) : 0);
    return Qnil;
}

.NSDR ⇒ Object

:nodoc:



3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
 
# File 'vm.c', line 3715

static VALUE
nsdr(VALUE self)
{
    VALUE ary = rb_ary_new();
#ifdef HAVE_BACKTRACE
#include <execinfo.h>
#define MAX_NATIVE_TRACE 1024
    static void *trace[MAX_NATIVE_TRACE];
    int n = (int)backtrace(trace, MAX_NATIVE_TRACE);
    char **syms = backtrace_symbols(trace, n);
    int i;

    if (syms == 0) {
        rb_memerror();
    }

    for (i=0; i<n; i++) {
        rb_ary_push(ary, rb_str_new2(syms[i]));
    }
    free(syms); /* OK */
#endif
    return ary;
}

.reset_debug_counters ⇒ Object

.SDR ⇒ Object

:nodoc:



3707
3708
3709
3710
3711
3712
 
# File 'vm.c', line 3707

static VALUE
sdr(VALUE self)
{
    rb_vm_bugreport(NULL, stderr);
    return Qnil;
}

.show_debug_counters ⇒ Object

.stat ⇒ Hash .stat(hsh) ⇒ Hash .stat(Symbol) ⇒ Numeric

Returns a Hash containing implementation-dependent counters inside the VM.

This hash includes information about method/constant caches:

{
  :constant_cache_invalidations=>2,
  :constant_cache_misses=>14,
  :global_cvar_state=>27
}

If USE_DEBUG_COUNTER is enabled, debug counters will be included.

The contents of the hash are implementation specific and may be changed in the future.

This method is only expected to work on C Ruby.

Overloads:



663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
 
# File 'vm.c', line 663

static VALUE
vm_stat(int argc, VALUE *argv, VALUE self)
{
    static VALUE sym_constant_cache_invalidations, sym_constant_cache_misses, sym_global_cvar_state, sym_next_shape_id;
    static VALUE sym_shape_cache_size;
    VALUE arg = Qnil;
    VALUE hash = Qnil, key = Qnil;

    if (rb_check_arity(argc, 0, 1) == 1) {
        arg = argv[0];
        if (SYMBOL_P(arg))
            key = arg;
        else if (RB_TYPE_P(arg, T_HASH))
            hash = arg;
        else
            rb_raise(rb_eTypeError, "non-hash or symbol given");
    }
    else {
        hash = rb_hash_new();
    }

#define S(s) sym_##s = ID2SYM(rb_intern_const(#s))
    S(constant_cache_invalidations);
    S(constant_cache_misses);
        S(global_cvar_state);
    S(next_shape_id);
    S(shape_cache_size);
#undef S

#define SET(name, attr) \
    if (key == sym_##name) \
        return SERIALT2NUM(attr); \
    else if (hash != Qnil) \
        rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr));

    SET(constant_cache_invalidations, ruby_vm_constant_cache_invalidations);
    SET(constant_cache_misses, ruby_vm_constant_cache_misses);
    SET(global_cvar_state, ruby_vm_global_cvar_state);
    SET(next_shape_id, (rb_serial_t)GET_SHAPE_TREE()->next_shape_id);
    SET(shape_cache_size, (rb_serial_t)GET_SHAPE_TREE()->cache_size);
#undef SET

#if USE_DEBUG_COUNTER
    ruby_debug_counter_show_at_exit(FALSE);
    for (size_t i = 0; i < RB_DEBUG_COUNTER_MAX; i++) {
        const VALUE name = rb_sym_intern_ascii_cstr(rb_debug_counter_names[i]);
        const VALUE boxed_value = SIZET2NUM(rb_debug_counter[i]);

        if (key == name) {
            return boxed_value;
        }
        else if (hash != Qnil) {
            rb_hash_aset(hash, name, boxed_value);
        }
    }
#endif

    if (!NIL_P(key)) { /* matched key should return above */
        rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(key));
    }

    return hash;
}

.USAGE_ANALYSIS_INSN_CLEAR ⇒ Object 



3749
 
# File 'vm.c', line 3749

static VALUE usage_analysis_insn_clear(VALUE self);

.USAGE_ANALYSIS_INSN_RUNNING ⇒ Object 



3746
 
# File 'vm.c', line 3746

static VALUE usage_analysis_insn_running(VALUE self);

.USAGE_ANALYSIS_INSN_START ⇒ Object 



3740
 
# File 'vm.c', line 3740

static VALUE usage_analysis_insn_start(VALUE self);

.USAGE_ANALYSIS_INSN_STOP ⇒ Object 



3743
 
# File 'vm.c', line 3743

static VALUE usage_analysis_insn_stop(VALUE self);

.USAGE_ANALYSIS_OPERAND_CLEAR ⇒ Object 



3750
 
# File 'vm.c', line 3750

static VALUE usage_analysis_operand_clear(VALUE self);

.USAGE_ANALYSIS_OPERAND_RUNNING ⇒ Object 



3747
 
# File 'vm.c', line 3747

static VALUE usage_analysis_operand_running(VALUE self);

.USAGE_ANALYSIS_OPERAND_START ⇒ Object 



3741
 
# File 'vm.c', line 3741

static VALUE usage_analysis_operand_start(VALUE self);

.USAGE_ANALYSIS_OPERAND_STOP ⇒ Object 



3744
 
# File 'vm.c', line 3744

static VALUE usage_analysis_operand_stop(VALUE self);

.USAGE_ANALYSIS_REGISTER_CLEAR ⇒ Object 



3751
 
# File 'vm.c', line 3751

static VALUE usage_analysis_register_clear(VALUE self);

.USAGE_ANALYSIS_REGISTER_RUNNING ⇒ Object 



3748
 
# File 'vm.c', line 3748

static VALUE usage_analysis_register_running(VALUE self);

.USAGE_ANALYSIS_REGISTER_START ⇒ Object 



3742
 
# File 'vm.c', line 3742

static VALUE usage_analysis_register_start(VALUE self);

.USAGE_ANALYSIS_REGISTER_STOP ⇒ Object 



3745
 
# File 'vm.c', line 3745

static VALUE usage_analysis_register_stop(VALUE self);