Ruby 2.1.5p273(2014-11-13revision48405)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

vm_core.h
Go to the documentation of this file.
1 /**********************************************************************
2
3 vm_core.h -
4
5 $Author: nagachika $
6 created at: 04/01/01 19:41:38 JST
7
8 Copyright (C) 2004-2007 Koichi Sasada
9
10 **********************************************************************/
11
12 #ifndef RUBY_VM_CORE_H
13 #define RUBY_VM_CORE_H
14
15 #define RUBY_VM_THREAD_MODEL 2
16
17 #include "ruby/ruby.h"
18 #include "ruby/st.h"
19
20 #include "node.h"
21 #include "vm_debug.h"
22 #include "vm_opts.h"
23 #include "id.h"
24 #include "method.h"
25 #include "ruby_atomic.h"
26
27 #include "thread_native.h"
28
29 #ifndef ENABLE_VM_OBJSPACE
30 #ifdef _WIN32
31 /*
32 * TODO: object space independent st_table.
33 * socklist needs st_table in rb_w32_sysinit(), before object space
34 * initialization.
35 * It is too early now to change st_hash_type, since it breaks binary
36 * compatibility.
37 */
38 #define ENABLE_VM_OBJSPACE 0
39 #else
40 #define ENABLE_VM_OBJSPACE 1
41 #endif
42 #endif
43
44 #include <setjmp.h>
45 #include <signal.h>
46
47 #ifndef NSIG
48 # define NSIG (_SIGMAX + 1) /* For QNX */
49 #endif
50
51 #define RUBY_NSIG NSIG
52
53 #ifdef HAVE_STDARG_PROTOTYPES
54 #include <stdarg.h>
55 #define va_init_list(a,b) va_start((a),(b))
56 #else
57 #include <varargs.h>
58 #define va_init_list(a,b) va_start((a))
59 #endif
60
61 #if defined(SIGSEGV) && defined(HAVE_SIGALTSTACK) && defined(SA_SIGINFO) && !defined(__NetBSD__)
62 #define USE_SIGALTSTACK
63 #endif
64
65 /*****************/
66 /* configuration */
67 /*****************/
68
69 /* gcc ver. check */
70 #if defined(__GNUC__) && __GNUC__ >= 2
71
72 #if OPT_TOKEN_THREADED_CODE
73 #if OPT_DIRECT_THREADED_CODE
74 #undef OPT_DIRECT_THREADED_CODE
75 #endif
76 #endif
77
78 #else /* defined(__GNUC__) && __GNUC__ >= 2 */
79
80 /* disable threaded code options */
81 #if OPT_DIRECT_THREADED_CODE
82 #undef OPT_DIRECT_THREADED_CODE
83 #endif
84 #if OPT_TOKEN_THREADED_CODE
85 #undef OPT_TOKEN_THREADED_CODE
86 #endif
87 #endif
88
89 #ifdef __native_client__
90 #undef OPT_DIRECT_THREADED_CODE
91 #endif
92
93 /* call threaded code */
94 #if OPT_CALL_THREADED_CODE
95 #if OPT_DIRECT_THREADED_CODE
96 #undef OPT_DIRECT_THREADED_CODE
97 #endif /* OPT_DIRECT_THREADED_CODE */
98 #if OPT_STACK_CACHING
99 #undef OPT_STACK_CACHING
100 #endif /* OPT_STACK_CACHING */
101 #endif /* OPT_CALL_THREADED_CODE */
102
103 /* likely */
104 #if __GNUC__ >= 3
105 #define LIKELY(x) (__builtin_expect((x), 1))
106 #define UNLIKELY(x) (__builtin_expect((x), 0))
107 #else /* __GNUC__ >= 3 */
108 #define LIKELY(x) (x)
109 #define UNLIKELY(x) (x)
110 #endif /* __GNUC__ >= 3 */
111
112 #ifndef __has_attribute
113 # define __has_attribute(x) 0
114 #endif
115
116 #if __has_attribute(unused)
117 #define UNINITIALIZED_VAR(x) x __attribute__((unused))
118 #elif defined(__GNUC__) && __GNUC__ >= 3
119 #define UNINITIALIZED_VAR(x) x = x
120 #else
121 #define UNINITIALIZED_VAR(x) x
122 #endif
123
124 typedef unsigned long rb_num_t;
125
126 /* iseq data type */
127
128 struct iseq_compile_data_ensure_node_stack;
129
130 typedef struct rb_compile_option_struct rb_compile_option_t;
131
132
133 struct iseq_inline_cache_entry {
134 rb_serial_t ic_serial;
135 union {
136 size_t index;
137 VALUE value;
138 } ic_value;
139 };
140
141 union iseq_inline_storage_entry {
142 struct {
143 struct rb_thread_struct *running_thread;
144 VALUE value;
145 VALUE done;
146 } once;
147 struct iseq_inline_cache_entry cache;
148 };
149
150 /* to avoid warning */
151 struct rb_thread_struct;
152 struct rb_control_frame_struct;
153
154 /* rb_call_info_t contains calling information including inline cache */
155 typedef struct rb_call_info_struct {
156 /* fixed at compile time */
157 ID mid;
158 VALUE flag;
159 int orig_argc;
160 rb_iseq_t *blockiseq;
161
162 /* inline cache: keys */
163 rb_serial_t method_state;
164 rb_serial_t class_serial;
165 VALUE klass;
166
167 /* inline cache: values */
168 const rb_method_entry_t *me;
169 VALUE defined_class;
170
171 /* temporary values for method calling */
172 int argc;
173 struct rb_block_struct *blockptr;
174 VALUE recv;
175 union {
176 int opt_pc; /* used by iseq */
177 long index; /* used by ivar */
178 int missing_reason; /* used by method_missing */
179 int inc_sp; /* used by cfunc */
180 } aux;
181
182 VALUE (*call)(struct rb_thread_struct *th, struct rb_control_frame_struct *cfp, struct rb_call_info_struct *ci);
183 } rb_call_info_t;
184
185 #if 1
186 #define GetCoreDataFromValue(obj, type, ptr) do { \
187 (ptr) = (type*)DATA_PTR(obj); \
188 } while (0)
189 #else
190 #define GetCoreDataFromValue(obj, type, ptr) Data_Get_Struct((obj), type, (ptr))
191 #endif
192
193 #define GetISeqPtr(obj, ptr) \
194 GetCoreDataFromValue((obj), rb_iseq_t, (ptr))
195
196 typedef struct rb_iseq_location_struct {
197 const VALUE path;
198 const VALUE absolute_path;
199 const VALUE base_label;
200 const VALUE label;
201 size_t first_lineno;
202 } rb_iseq_location_t;
203
204 struct rb_iseq_struct;
205
206 struct rb_iseq_struct {
207 /***************/
208 /* static data */
209 /***************/
210
211 enum iseq_type {
212 ISEQ_TYPE_TOP,
213 ISEQ_TYPE_METHOD,
214 ISEQ_TYPE_BLOCK,
215 ISEQ_TYPE_CLASS,
216 ISEQ_TYPE_RESCUE,
217 ISEQ_TYPE_ENSURE,
218 ISEQ_TYPE_EVAL,
219 ISEQ_TYPE_MAIN,
220 ISEQ_TYPE_DEFINED_GUARD
221 } type; /* instruction sequence type */
222
223 rb_iseq_location_t location;
224
225 VALUE *iseq; /* iseq (insn number and operands) */
226 VALUE *iseq_encoded; /* encoded iseq */
227 unsigned long iseq_size;
228 const VALUE mark_ary; /* Array: includes operands which should be GC marked */
229 const VALUE coverage; /* coverage array */
230
231 /* insn info, must be freed */
232 struct iseq_line_info_entry *line_info_table;
233 size_t line_info_size;
234
235 ID *local_table; /* must free */
236 int local_table_size;
237
238 /* sizeof(vars) + 1 */
239 int local_size;
240
241 union iseq_inline_storage_entry *is_entries;
242 int is_size;
243
244 rb_call_info_t *callinfo_entries;
245 int callinfo_size;
246
274 int argc;
275 int arg_simple;
276 int arg_rest;
277 int arg_block;
278 int arg_opts;
279 int arg_post_len;
280 int arg_post_start;
281 int arg_size;
282 VALUE *arg_opt_table;
283 int arg_keyword;
284 int arg_keyword_check; /* if this is true, raise an ArgumentError when unknown keyword argument is passed */
285 int arg_keywords;
286 int arg_keyword_required;
287 ID *arg_keyword_table;
288
289 size_t stack_max; /* for stack overflow check */
290
291 /* catch table */
292 struct iseq_catch_table_entry *catch_table;
293 int catch_table_size;
294
295 /* for child iseq */
296 struct rb_iseq_struct *parent_iseq;
297 struct rb_iseq_struct *local_iseq;
298
299 /****************/
300 /* dynamic data */
301 /****************/
302
303 VALUE self;
304 const VALUE orig; /* non-NULL if its data have origin */
305
306 /* block inlining */
307 /*
308 * NODE *node;
309 * void *special_block_builder;
310 * void *cached_special_block_builder;
311 * VALUE cached_special_block;
312 */
313
314 /* klass/module nest information stack (cref) */
315 NODE * const cref_stack;
316 const VALUE klass;
317
318 /* misc */
319 ID defined_method_id; /* for define_method */
320 rb_num_t flip_cnt;
321
322 /* used at compile time */
323 struct iseq_compile_data *compile_data;
324 };
325
326 enum ruby_special_exceptions {
327 ruby_error_reenter,
328 ruby_error_nomemory,
329 ruby_error_sysstack,
330 ruby_error_closed_stream,
331 ruby_special_error_count
332 };
333
334 #define GetVMPtr(obj, ptr) \
335 GetCoreDataFromValue((obj), rb_vm_t, (ptr))
336
337 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
338 struct rb_objspace;
339 void rb_objspace_free(struct rb_objspace *);
340 #endif
341
342 typedef struct rb_hook_list_struct {
343 struct rb_event_hook_struct *hooks;
344 rb_event_flag_t events;
345 int need_clean;
346 } rb_hook_list_t;
347
348 typedef struct rb_vm_struct {
349 VALUE self;
350
351 rb_global_vm_lock_t gvl;
352 rb_nativethread_lock_t thread_destruct_lock;
353
354 struct rb_thread_struct *main_thread;
355 struct rb_thread_struct *running_thread;
356
357 st_table *living_threads;
358 VALUE thgroup_default;
359
360 int running;
361 int thread_abort_on_exception;
362 int trace_running;
363 volatile int sleeper;
364
365 /* object management */
366 VALUE mark_object_ary;
367
368 VALUE special_exceptions[ruby_special_error_count];
369
370 /* load */
371 VALUE top_self;
372 VALUE load_path;
373 VALUE load_path_snapshot;
374 VALUE load_path_check_cache;
375 VALUE expanded_load_path;
376 VALUE loaded_features;
377 VALUE loaded_features_snapshot;
378 struct st_table *loaded_features_index;
379 struct st_table *loading_table;
380
381 /* signal */
382 struct {
383 VALUE cmd;
384 int safe;
385 } trap_list[RUBY_NSIG];
386
387 /* hook */
388 rb_hook_list_t event_hooks;
389
390 /* relation table of ensure - rollback for callcc */
391 struct st_table *ensure_rollback_table;
392
393 /* postponed_job */
394 struct rb_postponed_job_struct *postponed_job_buffer;
395 int postponed_job_index;
396
397 int src_encoding_index;
398
399 VALUE verbose, debug, orig_progname, progname;
400 VALUE coverages;
401
402 struct unlinked_method_entry_list_entry *unlinked_method_entry_list;
403
404 VALUE defined_module_hash;
405
406 #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
407 struct rb_objspace *objspace;
408 #endif
409
410 /*
411 * @shyouhei notes that this is not for storing normal Ruby
412 * objects so do *NOT* mark this when you GC.
413 */
414 struct RArray at_exit;
415
416 VALUE *defined_strings;
417
418 /* params */
419 struct { /* size in byte */
420 size_t thread_vm_stack_size;
421 size_t thread_machine_stack_size;
422 size_t fiber_vm_stack_size;
423 size_t fiber_machine_stack_size;
424 } default_params;
425 } rb_vm_t;
426
427 /* default values */
428
429 #define RUBY_VM_SIZE_ALIGN 4096
430
431 #define RUBY_VM_THREAD_VM_STACK_SIZE ( 128 * 1024 * sizeof(VALUE)) /* 512 KB or 1024 KB */
432 #define RUBY_VM_THREAD_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE)) /* 8 KB or 16 KB */
433 #define RUBY_VM_THREAD_MACHINE_STACK_SIZE ( 128 * 1024 * sizeof(VALUE)) /* 512 KB or 1024 KB */
434 #define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */
435
436 #define RUBY_VM_FIBER_VM_STACK_SIZE ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */
437 #define RUBY_VM_FIBER_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE)) /* 8 KB or 16 KB */
438 #define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 64 * 1024 * sizeof(VALUE)) /* 256 KB or 512 KB */
439 #define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE)) /* 64 KB or 128 KB */
440
441 #ifndef VM_DEBUG_BP_CHECK
442 #define VM_DEBUG_BP_CHECK 0
443 #endif
444
445 typedef struct rb_control_frame_struct {
446 VALUE *pc; /* cfp[0] */
447 VALUE *sp; /* cfp[1] */
448 rb_iseq_t *iseq; /* cfp[2] */
449 VALUE flag; /* cfp[3] */
450 VALUE self; /* cfp[4] / block[0] */
451 VALUE klass; /* cfp[5] / block[1] */
452 VALUE *ep; /* cfp[6] / block[2] */
453 rb_iseq_t *block_iseq; /* cfp[7] / block[3] */
454 VALUE proc; /* cfp[8] / block[4] */
455 const rb_method_entry_t *me;/* cfp[9] */
456
457 #if VM_DEBUG_BP_CHECK
458 VALUE *bp_check; /* cfp[10] */
459 #endif
460 } rb_control_frame_t;
461
462 typedef struct rb_block_struct {
463 VALUE self; /* share with method frame if it's only block */
464 VALUE klass; /* share with method frame if it's only block */
465 VALUE *ep; /* share with method frame if it's only block */
466 rb_iseq_t *iseq;
467 VALUE proc;
468 } rb_block_t;
469
470 extern const rb_data_type_t ruby_threadptr_data_type;
471
472 #define GetThreadPtr(obj, ptr) \
473 TypedData_Get_Struct((obj), rb_thread_t, &ruby_threadptr_data_type, (ptr))
474
475 enum rb_thread_status {
476 THREAD_RUNNABLE,
477 THREAD_STOPPED,
478 THREAD_STOPPED_FOREVER,
479 THREAD_KILLED
480 };
481
482 typedef RUBY_JMP_BUF rb_jmpbuf_t;
483
484 /*
485 the members which are written in TH_PUSH_TAG() should be placed at
486 the beginning and the end, so that entire region is accessible.
487 */
488 struct rb_vm_tag {
489 VALUE tag;
490 VALUE retval;
491 rb_jmpbuf_t buf;
492 struct rb_vm_tag *prev;
493 };
494
495 struct rb_vm_protect_tag {
496 struct rb_vm_protect_tag *prev;
497 };
498
499 struct rb_unblock_callback {
500 rb_unblock_function_t *func;
501 void *arg;
502 };
503
504 struct rb_mutex_struct;
505
506 struct rb_thread_struct;
507 typedef struct rb_thread_list_struct{
508 struct rb_thread_list_struct *next;
509 struct rb_thread_struct *th;
510 } rb_thread_list_t;
511
512
513 typedef struct rb_ensure_entry {
514 VALUE marker;
515 VALUE (*e_proc)(ANYARGS);
516 VALUE data2;
517 } rb_ensure_entry_t;
518
519 typedef struct rb_ensure_list {
520 struct rb_ensure_list *next;
521 struct rb_ensure_entry entry;
522 } rb_ensure_list_t;
523
524 typedef struct rb_thread_struct {
525 VALUE self;
526 rb_vm_t *vm;
527
528 /* execution information */
529 VALUE *stack; /* must free, must mark */
530 size_t stack_size; /* size in word (byte size / sizeof(VALUE)) */
531 rb_control_frame_t *cfp;
532 int safe_level;
533 int raised_flag;
534 VALUE last_status; /* $? */
535
536 /* passing state */
537 int state;
538
539 int waiting_fd;
540
541 /* for rb_iterate */
542 const rb_block_t *passed_block;
543
544 /* for bmethod */
545 const rb_method_entry_t *passed_bmethod_me;
546
547 /* for cfunc */
548 rb_call_info_t *passed_ci;
549
550 /* for load(true) */
551 VALUE top_self;
552 VALUE top_wrapper;
553
554 /* eval env */
555 rb_block_t *base_block;
556
557 VALUE *root_lep;
558 VALUE root_svar;
559
560 /* thread control */
561 rb_nativethread_id_t thread_id;
562 enum rb_thread_status status;
563 int to_kill;
564 int priority;
565
566 native_thread_data_t native_thread_data;
567 void *blocking_region_buffer;
568
569 VALUE thgroup;
570 VALUE value;
571
572 /* temporary place of errinfo */
573 VALUE errinfo;
574
575 /* temporary place of retval on OPT_CALL_THREADED_CODE */
576 #if OPT_CALL_THREADED_CODE
577 VALUE retval;
578 #endif
579
580 /* async errinfo queue */
581 VALUE pending_interrupt_queue;
582 int pending_interrupt_queue_checked;
583 VALUE pending_interrupt_mask_stack;
584
585 rb_atomic_t interrupt_flag;
586 unsigned long interrupt_mask;
587 rb_nativethread_lock_t interrupt_lock;
588 rb_nativethread_cond_t interrupt_cond;
589 struct rb_unblock_callback unblock;
590 VALUE locking_mutex;
591 struct rb_mutex_struct *keeping_mutexes;
592
593 struct rb_vm_tag *tag;
594 struct rb_vm_protect_tag *protect_tag;
595
602 int parse_in_eval;
603
608 int mild_compile_error;
609
610 /* storage */
611 st_table *local_storage;
612
613 rb_thread_list_t *join_list;
614
615 VALUE first_proc;
616 VALUE first_args;
617 VALUE (*first_func)(ANYARGS);
618
619 /* for GC */
620 struct {
621 VALUE *stack_start;
622 VALUE *stack_end;
623 size_t stack_maxsize;
624 #ifdef __ia64
625 VALUE *register_stack_start;
626 VALUE *register_stack_end;
627 size_t register_stack_maxsize;
628 #endif
629 jmp_buf regs;
630 } machine;
631 int mark_stack_len;
632
633 /* statistics data for profiler */
634 VALUE stat_insn_usage;
635
636 /* tracer */
637 rb_hook_list_t event_hooks;
638 struct rb_trace_arg_struct *trace_arg; /* trace information */
639
640 /* fiber */
641 VALUE fiber;
642 VALUE root_fiber;
643 rb_jmpbuf_t root_jmpbuf;
644
645 /* ensure & callcc */
646 rb_ensure_list_t *ensure_list;
647
648 /* misc */
649 int method_missing_reason;
650 int abort_on_exception;
651 #ifdef USE_SIGALTSTACK
652 void *altstack;
653 #endif
654 unsigned long running_time_us;
655 } rb_thread_t;
656
657 typedef enum {
658 VM_DEFINECLASS_TYPE_CLASS = 0x00,
659 VM_DEFINECLASS_TYPE_SINGLETON_CLASS = 0x01,
660 VM_DEFINECLASS_TYPE_MODULE = 0x02,
661 /* 0x03..0x06 is reserved */
662 VM_DEFINECLASS_TYPE_MASK = 0x07
663 } rb_vm_defineclass_type_t;
664
665 #define VM_DEFINECLASS_TYPE(x) ((rb_vm_defineclass_type_t)(x) & VM_DEFINECLASS_TYPE_MASK)
666 #define VM_DEFINECLASS_FLAG_SCOPED 0x08
667 #define VM_DEFINECLASS_FLAG_HAS_SUPERCLASS 0x10
668 #define VM_DEFINECLASS_SCOPED_P(x) ((x) & VM_DEFINECLASS_FLAG_SCOPED)
669 #define VM_DEFINECLASS_HAS_SUPERCLASS_P(x) \
670 ((x) & VM_DEFINECLASS_FLAG_HAS_SUPERCLASS)
671
672 /* iseq.c */
673 RUBY_SYMBOL_EXPORT_BEGIN
674
675 /* node -> iseq */
676 VALUE rb_iseq_new(NODE*, VALUE, VALUE, VALUE, VALUE, enum iseq_type);
677 VALUE rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE parent);
678 VALUE rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path);
679 VALUE rb_iseq_new_with_bopt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, VALUE);
680 VALUE rb_iseq_new_with_opt(NODE*, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, const rb_compile_option_t*);
681
682 /* src -> iseq */
683 VALUE rb_iseq_compile(VALUE src, VALUE file, VALUE line);
684 VALUE rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, rb_block_t *base_block);
685 VALUE rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, rb_block_t *base_block, VALUE opt);
686
687 VALUE rb_iseq_disasm(VALUE self);
688 int rb_iseq_disasm_insn(VALUE str, VALUE *iseqval, size_t pos, rb_iseq_t *iseq, VALUE child);
689 const char *ruby_node_name(int node);
690
691 RUBY_EXTERN VALUE rb_cISeq;
692 RUBY_EXTERN VALUE rb_cRubyVM;
693 RUBY_EXTERN VALUE rb_cEnv;
694 RUBY_EXTERN VALUE rb_mRubyVMFrozenCore;
695 RUBY_SYMBOL_EXPORT_END
696
697 #define GetProcPtr(obj, ptr) \
698 GetCoreDataFromValue((obj), rb_proc_t, (ptr))
699
700 typedef struct {
701 rb_block_t block;
702
703 VALUE envval; /* for GC mark */
704 VALUE blockprocval;
705 int safe_level;
706 int is_from_method;
707 int is_lambda;
708 } rb_proc_t;
709
710 #define GetEnvPtr(obj, ptr) \
711 GetCoreDataFromValue((obj), rb_env_t, (ptr))
712
713 typedef struct {
714 VALUE *env;
715 int env_size;
716 int local_size;
717 VALUE prev_envval; /* for GC mark */
718 rb_block_t block;
719 } rb_env_t;
720
721 extern const rb_data_type_t ruby_binding_data_type;
722
723 #define GetBindingPtr(obj, ptr) \
724 GetCoreDataFromValue((obj), rb_binding_t, (ptr))
725
726 typedef struct {
727 VALUE env;
728 VALUE path;
729 VALUE blockprocval; /* for GC mark */
730 unsigned short first_lineno;
731 } rb_binding_t;
732
733 /* used by compile time and send insn */
734
735 enum vm_check_match_type {
736 VM_CHECKMATCH_TYPE_WHEN = 1,
737 VM_CHECKMATCH_TYPE_CASE = 2,
738 VM_CHECKMATCH_TYPE_RESCUE = 3
739 };
740
741 #define VM_CHECKMATCH_TYPE_MASK 0x03
742 #define VM_CHECKMATCH_ARRAY 0x04
743
744 #define VM_CALL_ARGS_SPLAT (0x01 << 1) /* m(*args) */
745 #define VM_CALL_ARGS_BLOCKARG (0x01 << 2) /* m(&block) */
746 #define VM_CALL_FCALL (0x01 << 3) /* m(...) */
747 #define VM_CALL_VCALL (0x01 << 4) /* m */
748 #define VM_CALL_TAILCALL (0x01 << 5) /* located at tail position */
749 #define VM_CALL_SUPER (0x01 << 6) /* super */
750 #define VM_CALL_OPT_SEND (0x01 << 7) /* internal flag */
751 #define VM_CALL_ARGS_SKIP_SETUP (0x01 << 8) /* (flag & (SPLAT|BLOCKARG)) && blockiseq == 0 */
752
753 enum vm_special_object_type {
754 VM_SPECIAL_OBJECT_VMCORE = 1,
755 VM_SPECIAL_OBJECT_CBASE,
756 VM_SPECIAL_OBJECT_CONST_BASE
757 };
758
759 #define VM_FRAME_MAGIC_METHOD 0x11
760 #define VM_FRAME_MAGIC_BLOCK 0x21
761 #define VM_FRAME_MAGIC_CLASS 0x31
762 #define VM_FRAME_MAGIC_TOP 0x41
763 #define VM_FRAME_MAGIC_CFUNC 0x61
764 #define VM_FRAME_MAGIC_PROC 0x71
765 #define VM_FRAME_MAGIC_IFUNC 0x81
766 #define VM_FRAME_MAGIC_EVAL 0x91
767 #define VM_FRAME_MAGIC_LAMBDA 0xa1
768 #define VM_FRAME_MAGIC_RESCUE 0xb1
769 #define VM_FRAME_MAGIC_MASK_BITS 8
770 #define VM_FRAME_MAGIC_MASK (~(~0<<VM_FRAME_MAGIC_MASK_BITS))
771
772 #define VM_FRAME_TYPE(cfp) ((cfp)->flag & VM_FRAME_MAGIC_MASK)
773
774 /* other frame flag */
775 #define VM_FRAME_FLAG_PASSED 0x0100
776 #define VM_FRAME_FLAG_FINISH 0x0200
777 #define VM_FRAME_FLAG_BMETHOD 0x0400
778 #define VM_FRAME_TYPE_FINISH_P(cfp) (((cfp)->flag & VM_FRAME_FLAG_FINISH) != 0)
779 #define VM_FRAME_TYPE_BMETHOD_P(cfp) (((cfp)->flag & VM_FRAME_FLAG_BMETHOD) != 0)
780
781 #define RUBYVM_CFUNC_FRAME_P(cfp) \
782 (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
783
784 /* inline cache */
785 typedef struct iseq_inline_cache_entry *IC;
786 typedef rb_call_info_t *CALL_INFO;
787
788 void rb_vm_change_state(void);
789
790 typedef VALUE CDHASH;
791
792 #ifndef FUNC_FASTCALL
793 #define FUNC_FASTCALL(x) x
794 #endif
795
796 typedef rb_control_frame_t *
797 (FUNC_FASTCALL(*rb_insn_func_t))(rb_thread_t *, rb_control_frame_t *);
798
799 #define GC_GUARDED_PTR(p) ((VALUE)((VALUE)(p) | 0x01))
800 #define GC_GUARDED_PTR_REF(p) ((void *)(((VALUE)(p)) & ~0x03))
801 #define GC_GUARDED_PTR_P(p) (((VALUE)(p)) & 0x01)
802
803 /*
804 * block frame:
805 * ep[ 0]: prev frame
806 * ep[-1]: CREF (for *_eval)
807 *
808 * method frame:
809 * ep[ 0]: block pointer (ptr | VM_ENVVAL_BLOCK_PTR_FLAG)
810 */
811
812 #define VM_ENVVAL_BLOCK_PTR_FLAG 0x02
813 #define VM_ENVVAL_BLOCK_PTR(v) (GC_GUARDED_PTR(v) | VM_ENVVAL_BLOCK_PTR_FLAG)
814 #define VM_ENVVAL_BLOCK_PTR_P(v) ((v) & VM_ENVVAL_BLOCK_PTR_FLAG)
815 #define VM_ENVVAL_PREV_EP_PTR(v) ((VALUE)GC_GUARDED_PTR(v))
816 #define VM_ENVVAL_PREV_EP_PTR_P(v) (!(VM_ENVVAL_BLOCK_PTR_P(v)))
817
818 #define VM_EP_PREV_EP(ep) ((VALUE *)GC_GUARDED_PTR_REF((ep)[0]))
819 #define VM_EP_BLOCK_PTR(ep) ((rb_block_t *)GC_GUARDED_PTR_REF((ep)[0]))
820 #define VM_EP_LEP_P(ep) VM_ENVVAL_BLOCK_PTR_P((ep)[0])
821
822 VALUE *rb_vm_ep_local_ep(VALUE *ep);
823 rb_block_t *rb_vm_control_frame_block_ptr(rb_control_frame_t *cfp);
824
825 #define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1)
826 #define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1)
827 #define RUBY_VM_END_CONTROL_FRAME(th) \
828 ((rb_control_frame_t *)((th)->stack + (th)->stack_size))
829 #define RUBY_VM_VALID_CONTROL_FRAME_P(cfp, ecfp) \
830 ((void *)(ecfp) > (void *)(cfp))
831 #define RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp) \
832 (!RUBY_VM_VALID_CONTROL_FRAME_P((cfp), RUBY_VM_END_CONTROL_FRAME(th)))
833
834 #define RUBY_VM_IFUNC_P(ptr) (BUILTIN_TYPE(ptr) == T_NODE)
835 #define RUBY_VM_NORMAL_ISEQ_P(ptr) \
836 ((ptr) && !RUBY_VM_IFUNC_P(ptr))
837
838 #define RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp) ((rb_block_t *)(&(cfp)->self))
839 #define RUBY_VM_GET_CFP_FROM_BLOCK_PTR(b) \
840 ((rb_control_frame_t *)((VALUE *)(b) - 4))
841 /* magic number `4' is depend on rb_control_frame_t layout. */
842
843 /* VM related object allocate functions */
844 VALUE rb_thread_alloc(VALUE klass);
845 VALUE rb_proc_alloc(VALUE klass);
846 VALUE rb_binding_alloc(VALUE klass);
847
848 /* for debug */
849 extern void rb_vmdebug_stack_dump_raw(rb_thread_t *, rb_control_frame_t *);
850 extern void rb_vmdebug_debug_print_pre(rb_thread_t *th, rb_control_frame_t *cfp, VALUE *_pc);
851 extern void rb_vmdebug_debug_print_post(rb_thread_t *th, rb_control_frame_t *cfp);
852
853 #define SDR() rb_vmdebug_stack_dump_raw(GET_THREAD(), GET_THREAD()->cfp)
854 #define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_THREAD(), (cfp))
855 void rb_vm_bugreport(void);
856
857 /* functions about thread/vm execution */
858 RUBY_SYMBOL_EXPORT_BEGIN
859 VALUE rb_iseq_eval(VALUE iseqval);
860 VALUE rb_iseq_eval_main(VALUE iseqval);
861 RUBY_SYMBOL_EXPORT_END
862 int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp);
863
864 VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc,
865 int argc, const VALUE *argv, const rb_block_t *blockptr);
866 VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass);
867 VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp);
868 VALUE rb_vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
869 VALUE rb_binding_new_with_cfp(rb_thread_t *th, const rb_control_frame_t *src_cfp);
870 VALUE *rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars);
871 void rb_vm_inc_const_missing_count(void);
872 void rb_vm_gvl_destroy(rb_vm_t *vm);
873 VALUE rb_vm_call(rb_thread_t *th, VALUE recv, VALUE id, int argc,
874 const VALUE *argv, const rb_method_entry_t *me,
875 VALUE defined_class);
876 void rb_unlink_method_entry(rb_method_entry_t *me);
877 void rb_gc_mark_unlinked_live_method_entries(void *pvm);
878
879 void rb_thread_start_timer_thread(void);
880 void rb_thread_stop_timer_thread(int);
881 void rb_thread_reset_timer_thread(void);
882 void rb_thread_wakeup_timer_thread(void);
883
884 int ruby_thread_has_gvl_p(void);
885 typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);
886 rb_control_frame_t *rb_vm_get_ruby_level_next_cfp(rb_thread_t *th, const rb_control_frame_t *cfp);
887 rb_control_frame_t *rb_vm_get_binding_creatable_next_cfp(rb_thread_t *th, const rb_control_frame_t *cfp);
888 int rb_vm_get_sourceline(const rb_control_frame_t *);
889 VALUE rb_name_err_mesg_new(VALUE obj, VALUE mesg, VALUE recv, VALUE method);
890 void rb_vm_stack_to_heap(rb_thread_t *th);
891 void ruby_thread_init_stack(rb_thread_t *th);
892 int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE *klassp);
893 void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp);
894
895 void rb_gc_mark_machine_stack(rb_thread_t *th);
896
897 int rb_autoloading_value(VALUE mod, ID id, VALUE* value);
898
899 #define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack]
900
901 #define RUBY_CONST_ASSERT(expr) (1/!!(expr)) /* expr must be a compile-time constant */
902 #define VM_STACK_OVERFLOWED_P(cfp, sp, margin) \
903 (!RUBY_CONST_ASSERT(sizeof(*(sp)) == sizeof(VALUE)) || \
904 !RUBY_CONST_ASSERT(sizeof(*(cfp)) == sizeof(rb_control_frame_t)) || \
905 ((rb_control_frame_t *)((sp) + (margin)) + 1) >= (cfp))
906 #define WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) \
907 if (LIKELY(!VM_STACK_OVERFLOWED_P(cfp, sp, margin))) {(void)0;} else /* overflowed */
908 #define CHECK_VM_STACK_OVERFLOW0(cfp, sp, margin) \
909 WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) vm_stackoverflow()
910 #define CHECK_VM_STACK_OVERFLOW(cfp, margin) \
911 WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stackoverflow()
912
913 /* for thread */
914
915 #if RUBY_VM_THREAD_MODEL == 2
916 extern rb_thread_t *ruby_current_thread;
917 extern rb_vm_t *ruby_current_vm;
918 extern rb_event_flag_t ruby_vm_event_flags;
919
920 #define GET_VM() ruby_current_vm
921
922 #ifndef OPT_CALL_CFUNC_WITHOUT_FRAME
923 #define OPT_CALL_CFUNC_WITHOUT_FRAME 0
924 #endif
925
926 static inline rb_thread_t *
927 GET_THREAD(void)
928 {
929 rb_thread_t *th = ruby_current_thread;
930 #if OPT_CALL_CFUNC_WITHOUT_FRAME
931 if (UNLIKELY(th->passed_ci != 0)) {
932 void vm_call_cfunc_push_frame(rb_thread_t *th);
933 vm_call_cfunc_push_frame(th);
934 }
935 #endif
936 return th;
937 }
938
939 #define rb_thread_set_current_raw(th) (void)(ruby_current_thread = (th))
940 #define rb_thread_set_current(th) do { \
941 if ((th)->vm->running_thread != (th)) { \
942 (th)->running_time_us = 0; \
943 } \
944 rb_thread_set_current_raw(th); \
945 (th)->vm->running_thread = (th); \
946 } while (0)
947
948 #else
949 #error "unsupported thread model"
950 #endif
951
952 enum {
953 TIMER_INTERRUPT_MASK = 0x01,
954 PENDING_INTERRUPT_MASK = 0x02,
955 POSTPONED_JOB_INTERRUPT_MASK = 0x04,
956 TRAP_INTERRUPT_MASK = 0x08
957 };
958
959 #define RUBY_VM_SET_TIMER_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, TIMER_INTERRUPT_MASK)
960 #define RUBY_VM_SET_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, PENDING_INTERRUPT_MASK)
961 #define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK)
962 #define RUBY_VM_SET_TRAP_INTERRUPT(th) ATOMIC_OR((th)->interrupt_flag, TRAP_INTERRUPT_MASK)
963 #define RUBY_VM_INTERRUPTED(th) ((th)->interrupt_flag & ~(th)->interrupt_mask & (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK))
964 #define RUBY_VM_INTERRUPTED_ANY(th) ((th)->interrupt_flag & ~(th)->interrupt_mask)
965
966 int rb_signal_buff_size(void);
967 void rb_signal_exec(rb_thread_t *th, int sig);
968 void rb_threadptr_check_signal(rb_thread_t *mth);
969 void rb_threadptr_signal_raise(rb_thread_t *th, int sig);
970 void rb_threadptr_signal_exit(rb_thread_t *th);
971 void rb_threadptr_execute_interrupts(rb_thread_t *, int);
972 void rb_threadptr_interrupt(rb_thread_t *th);
973 void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th);
974 void rb_threadptr_pending_interrupt_clear(rb_thread_t *th);
975 void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v);
976 int rb_threadptr_pending_interrupt_active_p(rb_thread_t *th);
977
978 #define RUBY_VM_CHECK_INTS_BLOCKING(th) do { \
979 if (UNLIKELY(!rb_threadptr_pending_interrupt_empty_p(th))) { \
980 th->pending_interrupt_queue_checked = 0; \
981 RUBY_VM_SET_INTERRUPT(th); \
982 rb_threadptr_execute_interrupts(th, 1); \
983 } \
984 else if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(th))) { \
985 rb_threadptr_execute_interrupts(th, 1); \
986 } \
987 } while (0)
988
989 #define RUBY_VM_CHECK_INTS(th) do { \
990 if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(th))) { \
991 rb_threadptr_execute_interrupts(th, 0); \
992 } \
993 } while (0)
994
995 /* tracer */
996 struct rb_trace_arg_struct {
997 rb_event_flag_t event;
998 rb_thread_t *th;
999 rb_control_frame_t *cfp;
1000 VALUE self;
1001 ID id;
1002 VALUE klass;
1003 VALUE data;
1004
1005 int klass_solved;
1006
1007 /* calc from cfp */
1008 int lineno;
1009 VALUE path;
1010 };
1011
1012 void rb_threadptr_exec_event_hooks(struct rb_trace_arg_struct *trace_arg);
1013 void rb_threadptr_exec_event_hooks_and_pop_frame(struct rb_trace_arg_struct *trace_arg);
1014
1015 #define EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, pop_p_) do { \
1016 if (UNLIKELY(ruby_vm_event_flags & (flag_))) { \
1017 if (((th)->event_hooks.events | (th)->vm->event_hooks.events) & (flag_)) { \
1018 struct rb_trace_arg_struct trace_arg; \
1019 trace_arg.event = (flag_); \
1020 trace_arg.th = (th_); \
1021 trace_arg.cfp = (trace_arg.th)->cfp; \
1022 trace_arg.self = (self_); \
1023 trace_arg.id = (id_); \
1024 trace_arg.klass = (klass_); \
1025 trace_arg.data = (data_); \
1026 trace_arg.path = Qundef; \
1027 trace_arg.klass_solved = 0; \
1028 if (pop_p_) rb_threadptr_exec_event_hooks_and_pop_frame(&trace_arg); \
1029 else rb_threadptr_exec_event_hooks(&trace_arg); \
1030 } \
1031 } \
1032 } while (0)
1033
1034 #define EXEC_EVENT_HOOK(th_, flag_, self_, id_, klass_, data_) \
1035 EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, 0)
1036
1037 #define EXEC_EVENT_HOOK_AND_POP_FRAME(th_, flag_, self_, id_, klass_, data_) \
1038 EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, 1)
1039
1040 VALUE rb_threadptr_reset_recursive_data(rb_thread_t *th);
1041 void rb_threadptr_restore_recursive_data(rb_thread_t *th, VALUE old);
1042
1043 RUBY_SYMBOL_EXPORT_BEGIN
1044
1045 int rb_thread_check_trap_pending(void);
1046
1047 extern VALUE rb_get_coverages(void);
1048 extern void rb_set_coverages(VALUE);
1049 extern void rb_reset_coverages(void);
1050
1051 void rb_postponed_job_flush(rb_vm_t *vm);
1052
1053 RUBY_SYMBOL_EXPORT_END
1054
1055 #endif /* RUBY_VM_CORE_H */
rb_thread_struct::passed_block
const rb_block_t * passed_block
Definition: vm_core.h:542
rb_call_info_struct::class_serial
rb_serial_t class_serial
Definition: vm_core.h:164
rb_proc_t::is_from_method
int is_from_method
Definition: vm_core.h:706
iseq_inline_storage_entry::done
VALUE done
Definition: vm_core.h:145
rb_iseq_struct::ISEQ_TYPE_MAIN
Definition: vm_core.h:219
rb_thread_struct::cfp
rb_control_frame_t * cfp
Definition: vm_core.h:531
rb_objspace_free
void rb_objspace_free(struct rb_objspace *)
Definition: gc.c:890
rb_thread_struct::join_list
rb_thread_list_t * join_list
Definition: vm_core.h:613
rb_trace_arg_struct::klass
VALUE klass
Definition: vm_core.h:1002
rb_call_info_struct::blockptr
struct rb_block_struct * blockptr
Definition: vm_core.h:173
rb_vm_bugreport
void rb_vm_bugreport(void)
Definition: vm_dump.c:713
rb_ensure_entry_t
struct rb_ensure_entry rb_ensure_entry_t
rb_thread_struct::stack_end
VALUE * stack_end
Definition: vm_core.h:622
rb_env_t::env
VALUE * env
Definition: vm_core.h:714
rb_iseq_struct::arg_simple
int arg_simple
Definition: vm_core.h:275
rb_thread_struct::running_time_us
unsigned long running_time_us
Definition: vm_core.h:654
rb_thread_struct::vm
rb_vm_t * vm
Definition: vm_core.h:526
rb_get_coverages
VALUE rb_get_coverages(void)
Definition: thread.c:5287
rb_hook_list_struct::need_clean
int need_clean
Definition: vm_core.h:345
rb_vm_struct::expanded_load_path
VALUE expanded_load_path
Definition: vm_core.h:375
rb_env_t::prev_envval
VALUE prev_envval
Definition: vm_core.h:717
rb_ensure_list::entry
struct rb_ensure_entry entry
Definition: vm_core.h:521
rb_call_info_struct::mid
ID mid
Definition: vm_core.h:157
rb_threadptr_pending_interrupt_clear
void rb_threadptr_pending_interrupt_clear(rb_thread_t *th)
Definition: thread.c:1538
rb_iseq_struct::cref_stack
NODE *const cref_stack
Definition: vm_core.h:315
rb_threadptr_signal_raise
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
Definition: thread.c:2060
rb_thread_struct::root_lep
VALUE * root_lep
Definition: vm_core.h:557
rb_vm_control_frame_block_ptr
rb_block_t * rb_vm_control_frame_block_ptr(rb_control_frame_t *cfp)
Definition: vm.c:59
rb_iseq_new_with_bopt
VALUE rb_iseq_new_with_bopt(NODE *, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, VALUE)
Definition: iseq.c:464
rb_postponed_job_flush
void rb_postponed_job_flush(rb_vm_t *vm)
Definition: vm_trace.c:1512
rb_vm_struct::at_exit
struct RArray at_exit
Definition: vm_core.h:414
rb_iseq_struct::arg_rest
int arg_rest
Definition: vm_core.h:276
rb_thread_struct::protect_tag
struct rb_vm_protect_tag * protect_tag
Definition: vm_core.h:594
rb_vm_struct::running_thread
struct rb_thread_struct * running_thread
Definition: vm_core.h:355
st_table
Definition: st.h:69
rb_vm_struct::cmd
VALUE cmd
Definition: vm_core.h:383
rb_thread_struct::local_storage
st_table * local_storage
Definition: vm_core.h:611
rb_threadptr_unlock_all_locking_mutexes
void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th)
Definition: thread.c:404
rb_thread_struct::pending_interrupt_queue_checked
int pending_interrupt_queue_checked
Definition: vm_core.h:582
rb_call_info_struct::method_state
rb_serial_t method_state
Definition: vm_core.h:163
rb_iseq_struct::arg_keyword_table
ID * arg_keyword_table
Definition: vm_core.h:287
rb_proc_alloc
VALUE rb_proc_alloc(VALUE klass)
Definition: proc.c:87
rb_control_frame_struct::klass
VALUE klass
Definition: vm_core.h:451
iseq_inline_storage_entry::value
VALUE value
Definition: vm_core.h:144
node.h
rb_iseq_struct::coverage
const VALUE coverage
Definition: vm_core.h:229
ruby.h
rb_mutex_struct
Definition: thread.c:388
rb_vm_struct::top_self
VALUE top_self
Definition: vm_core.h:371
method.h
rb_env_t::block
rb_block_t block
Definition: vm_core.h:718
rb_vm_struct::progname
VALUE progname
Definition: vm_core.h:399
rb_thread_list_struct::th
struct rb_thread_struct * th
Definition: vm_core.h:509
rb_unblock_function_t
void rb_unblock_function_t(void *)
Definition: intern.h:864
rb_call_info_struct::klass
VALUE klass
Definition: vm_core.h:165
rb_thread_start_timer_thread
void rb_thread_start_timer_thread(void)
Definition: thread.c:3870
rb_unblock_callback::func
rb_unblock_function_t * func
Definition: vm_core.h:500
rb_iseq_struct::ISEQ_TYPE_ENSURE
Definition: vm_core.h:217
ruby_error_reenter
Definition: vm_core.h:327
rb_iseq_struct::compile_data
struct iseq_compile_data * compile_data
Definition: vm_core.h:323
rb_event_hook_struct
Definition: vm_trace.c:34
rb_vm_struct::loaded_features_index
struct st_table * loaded_features_index
Definition: vm_core.h:378
vm_check_match_type
vm_check_match_type
Definition: vm_core.h:735
rb_block_struct::iseq
rb_iseq_t * iseq
Definition: vm_core.h:466
ruby_error_sysstack
Definition: vm_core.h:329
rb_thread_struct::pending_interrupt_mask_stack
VALUE pending_interrupt_mask_stack
Definition: vm_core.h:583
rb_thread_struct::regs
jmp_buf regs
Definition: vm_core.h:629
rb_iseq_new_top
VALUE rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE parent)
Definition: iseq.c:421
rb_iseq_struct::is_size
int is_size
Definition: vm_core.h:242
rb_cRubyVM
RUBY_EXTERN VALUE rb_cRubyVM
Definition: vm_core.h:692
rb_call_info_struct::flag
VALUE flag
Definition: vm_core.h:158
rb_vm_struct::defined_strings
VALUE * defined_strings
Definition: vm_core.h:416
rb_binding_new_with_cfp
VALUE rb_binding_new_with_cfp(rb_thread_t *th, const rb_control_frame_t *src_cfp)
Definition: proc.c:320
rb_thread_alloc
VALUE rb_thread_alloc(VALUE klass)
Definition: vm.c:2229
rb_iseq_struct::callinfo_entries
rb_call_info_t * callinfo_entries
Definition: vm_core.h:244
rb_env_t::env_size
int env_size
Definition: vm_core.h:715
rb_ensure_entry::data2
VALUE data2
Definition: vm_core.h:516
VM_SPECIAL_OBJECT_CBASE
Definition: vm_core.h:755
rb_block_struct
Definition: vm_core.h:462
rb_trace_arg_struct::th
rb_thread_t * th
Definition: vm_core.h:998
rb_vm_struct::mark_object_ary
VALUE mark_object_ary
Definition: vm_core.h:366
RUBY_NSIG
#define RUBY_NSIG
Definition: vm_core.h:51
ruby_binding_data_type
const rb_data_type_t ruby_binding_data_type
Definition: proc.c:276
VM_SPECIAL_OBJECT_CONST_BASE
Definition: vm_core.h:756
rb_unlink_method_entry
void rb_unlink_method_entry(rb_method_entry_t *me)
Definition: vm_method.c:114
rb_vm_make_env_object
VALUE rb_vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp)
Definition: vm.c:577
rb_control_frame_struct::sp
VALUE * sp
Definition: vm_core.h:447
rb_thread_struct::waiting_fd
int waiting_fd
Definition: vm_core.h:539
rb_autoloading_value
int rb_autoloading_value(VALUE mod, ID id, VALUE *value)
Definition: variable.c:1715
rb_iseq_struct::ISEQ_TYPE_DEFINED_GUARD
Definition: vm_core.h:220
rb_vmdebug_debug_print_pre
void rb_vmdebug_debug_print_pre(rb_thread_t *th, rb_control_frame_t *cfp, VALUE *_pc)
Definition: vm_dump.c:357
rb_iseq_disasm_insn
int rb_iseq_disasm_insn(VALUE str, VALUE *iseqval, size_t pos, rb_iseq_t *iseq, VALUE child)
Disassemble a instruction Iseq -> Iseq inspect object.
Definition: iseq.c:1286
rb_iseq_struct::ISEQ_TYPE_CLASS
Definition: vm_core.h:215
rb_vm_struct::living_threads
st_table * living_threads
Definition: vm_core.h:357
rb_vm_struct::fiber_machine_stack_size
size_t fiber_machine_stack_size
Definition: vm_core.h:423
rb_call_info_struct::call
VALUE(* call)(struct rb_thread_struct *th, struct rb_control_frame_struct *cfp, struct rb_call_info_struct *ci)
Definition: vm_core.h:182
ruby_current_vm
rb_vm_t * ruby_current_vm
Definition: vm.c:105
rb_vm_struct::verbose
VALUE verbose
Definition: vm_core.h:399
ruby_thread_init_stack
void ruby_thread_init_stack(rb_thread_t *th)
Definition: thread.c:497
rb_iseq_struct::local_table_size
int local_table_size
Definition: vm_core.h:236
ruby_special_error_count
Definition: vm_core.h:331
vm_debug.h
rb_hook_list_t
struct rb_hook_list_struct rb_hook_list_t
rb_iseq_struct::local_iseq
struct rb_iseq_struct * local_iseq
Definition: vm_core.h:297
rb_threadptr_reset_recursive_data
VALUE rb_threadptr_reset_recursive_data(rb_thread_t *th)
Definition: thread.c:4794
rb_vm_protect_tag::prev
struct rb_vm_protect_tag * prev
Definition: vm_core.h:496
rb_nativethread_lock_t
pthread_mutex_t rb_nativethread_lock_t
Definition: thread_pthread.h:19
rb_iseq_struct::klass
const VALUE klass
Definition: vm_core.h:316
rb_thread_struct::thgroup
VALUE thgroup
Definition: vm_core.h:569
rb_iseq_struct::stack_max
size_t stack_max
Definition: vm_core.h:289
rb_iseq_struct::arg_keyword
int arg_keyword
Definition: vm_core.h:283
rb_control_frame_t
struct rb_control_frame_struct rb_control_frame_t
rb_hook_list_struct
Definition: vm_core.h:342
VM_DEFINECLASS_TYPE_CLASS
Definition: vm_core.h:658
rb_thread_struct::last_status
VALUE last_status
Definition: vm_core.h:534
rb_iseq_struct::defined_method_id
ID defined_method_id
Definition: vm_core.h:319
rb_thread_method_id_and_class
RUBY_SYMBOL_EXPORT_END int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp)
Definition: vm.c:1696
rb_cEnv
RUBY_EXTERN VALUE rb_cEnv
Definition: vm_core.h:693
native_thread_data_struct
Definition: thread_pthread.h:28
rb_ensure_entry
Definition: vm_core.h:513
rb_binding_t::env
VALUE env
Definition: vm_core.h:727
rb_thread_list_t
struct rb_thread_list_struct rb_thread_list_t
rb_vm_defineclass_type_t
rb_vm_defineclass_type_t
Definition: vm_core.h:657
rb_hook_list_struct::events
rb_event_flag_t events
Definition: vm_core.h:344
rb_thread_struct
Definition: vm_core.h:524
rb_iseq_struct::ISEQ_TYPE_METHOD
Definition: vm_core.h:213
VM_SPECIAL_OBJECT_VMCORE
Definition: vm_core.h:754
rb_iseq_struct::arg_post_len
int arg_post_len
Definition: vm_core.h:279
rb_vmdebug_stack_dump_raw
void rb_vmdebug_stack_dump_raw(rb_thread_t *, rb_control_frame_t *)
Definition: vm_dump.c:141
rb_iseq_struct::iseq_type
iseq_type
Definition: vm_core.h:211
iseq_inline_cache_entry::ic_value
union iseq_inline_cache_entry::@164 ic_value
rb_thread_struct::value
VALUE value
Definition: vm_core.h:570
iseq_inline_cache_entry::value
VALUE value
Definition: vm_core.h:137
rb_threadptr_pending_interrupt_active_p
int rb_threadptr_pending_interrupt_active_p(rb_thread_t *th)
Definition: thread.c:1653
rb_vm_stack_to_heap
void rb_vm_stack_to_heap(rb_thread_t *th)
Definition: vm.c:635
rb_thread_struct::machine
struct rb_thread_struct::@169 machine
rb_thread_stop_timer_thread
void rb_thread_stop_timer_thread(int)
Definition: thread.c:3856
rb_iseq_struct::mark_ary
const VALUE mark_ary
Definition: vm_core.h:228
iseq_inline_storage_entry::once
struct iseq_inline_storage_entry::@165 once
rb_vm_call
VALUE rb_vm_call(rb_thread_t *th, VALUE recv, VALUE id, int argc, const VALUE *argv, const rb_method_entry_t *me, VALUE defined_class)
Definition: vm_eval.c:244
rb_proc_t::envval
VALUE envval
Definition: vm_core.h:703
rb_vm_struct::thgroup_default
VALUE thgroup_default
Definition: vm_core.h:358
id.h
RNode
Definition: node.h:239
rb_call_info_struct::argc
int argc
Definition: vm_core.h:172
rb_thread_struct::first_func
VALUE(* first_func)(ANYARGS)
Definition: vm_core.h:617
rb_iseq_struct::iseq
VALUE * iseq
Definition: vm_core.h:225
rb_thread_struct::stack
VALUE * stack
Definition: vm_core.h:529
rb_iseq_struct::type
enum rb_iseq_struct::iseq_type type
rb_vm_struct::defined_module_hash
VALUE defined_module_hash
Definition: vm_core.h:404
rb_control_frame_struct::proc
VALUE proc
Definition: vm_core.h:454
rb_thread_reset_timer_thread
void rb_thread_reset_timer_thread(void)
Definition: thread.c:3864
rb_iseq_struct::arg_keyword_required
int arg_keyword_required
Definition: vm_core.h:286
rb_call_info_struct::defined_class
VALUE defined_class
Definition: vm_core.h:169
rb_binding_t::first_lineno
unsigned short first_lineno
Definition: vm_core.h:730
rb_call_info_struct::missing_reason
int missing_reason
Definition: vm_core.h:178
rb_thread_wakeup_timer_thread
void rb_thread_wakeup_timer_thread(void)
rb_trace_arg_struct::klass_solved
int klass_solved
Definition: vm_core.h:1005
rb_vm_struct::src_encoding_index
int src_encoding_index
Definition: vm_core.h:397
rb_vm_struct::trace_running
int trace_running
Definition: vm_core.h:362
ruby_atomic.h
rb_thread_struct::locking_mutex
VALUE locking_mutex
Definition: vm_core.h:590
rb_vm_struct::ensure_rollback_table
struct st_table * ensure_rollback_table
Definition: vm_core.h:391
rb_gc_mark_machine_stack
void rb_gc_mark_machine_stack(rb_thread_t *th)
Definition: gc.c:3506
rb_control_frame_struct::block_iseq
rb_iseq_t * block_iseq
Definition: vm_core.h:453
rb_vm_control_frame_id_and_class
int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE *klassp)
Definition: vm.c:1668
vm_opts.h
rb_call_info_struct::recv
VALUE recv
Definition: vm_core.h:174
THREAD_KILLED
Definition: vm_core.h:479
rb_signal_exec
void rb_signal_exec(rb_thread_t *th, int sig)
Definition: signal.c:861
rb_vm_struct::fiber_vm_stack_size
size_t fiber_vm_stack_size
Definition: vm_core.h:422
rb_vm_t
struct rb_vm_struct rb_vm_t
rb_iseq_struct::ISEQ_TYPE_BLOCK
Definition: vm_core.h:214
rb_thread_struct::blocking_region_buffer
void * blocking_region_buffer
Definition: vm_core.h:567
rb_vm_rewind_cfp
void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp)
Definition: vm.c:291
rb_iseq_struct::argc
int argc
argument information
Definition: vm_core.h:274
rb_vm_struct::load_path_check_cache
VALUE load_path_check_cache
Definition: vm_core.h:374
rb_ensure_list_t
struct rb_ensure_list rb_ensure_list_t
RArray
Definition: ruby.h:860
THREAD_STOPPED_FOREVER
Definition: vm_core.h:478
rb_control_frame_struct::iseq
rb_iseq_t * iseq
Definition: vm_core.h:448
rb_vm_struct::trap_list
struct rb_vm_struct::@167 trap_list[RUBY_NSIG]
rb_iseq_struct::arg_post_start
int arg_post_start
Definition: vm_core.h:280
rb_threadptr_exec_event_hooks_and_pop_frame
void rb_threadptr_exec_event_hooks_and_pop_frame(struct rb_trace_arg_struct *trace_arg)
Definition: vm_trace.c:376
rb_vm_struct::running
int running
Definition: vm_core.h:360
UNLIKELY
#define UNLIKELY(x)
Definition: vm_core.h:109
rb_trace_arg_struct::cfp
rb_control_frame_t * cfp
Definition: vm_core.h:999
rb_call_info_struct::orig_argc
int orig_argc
Definition: vm_core.h:159
rb_iseq_struct::arg_opt_table
VALUE * arg_opt_table
Definition: vm_core.h:282
rb_vm_tag::tag
VALUE tag
Definition: vm_core.h:489
signal.h
rb_iseq_struct::arg_keywords
int arg_keywords
Definition: vm_core.h:285
rb_iseq_new_main
VALUE rb_iseq_new_main(NODE *node, VALUE path, VALUE absolute_path)
Definition: iseq.c:428
iseq_inline_storage_entry
Definition: vm_core.h:141
rb_thread_struct::top_self
VALUE top_self
Definition: vm_core.h:551
rb_vm_ep_local_ep
VALUE * rb_vm_ep_local_ep(VALUE *ep)
Definition: vm.c:34
rb_vm_struct::postponed_job_index
int postponed_job_index
Definition: vm_core.h:395
rb_iseq_struct::flip_cnt
rb_num_t flip_cnt
Definition: vm_core.h:320
rb_vm_struct::thread_abort_on_exception
int thread_abort_on_exception
Definition: vm_core.h:361
argc
int argc
Definition: ruby.c:131
rb_vm_struct::unlinked_method_entry_list
struct unlinked_method_entry_list_entry * unlinked_method_entry_list
Definition: vm_core.h:402
vm_special_object_type
vm_special_object_type
Definition: vm_core.h:753
rb_vm_struct::loading_table
struct st_table * loading_table
Definition: vm_core.h:379
rb_thread_status
rb_thread_status
Definition: vm_core.h:475
rb_iseq_location_t
struct rb_iseq_location_struct rb_iseq_location_t
rb_method_entry_struct
Definition: method.h:97
rb_vm_protect_tag
Definition: vm_core.h:495
rb_call_info_struct::blockiseq
rb_iseq_t * blockiseq
Definition: vm_core.h:160
rb_objspace
Definition: gc.c:417
rb_thread_struct::base_block
rb_block_t * base_block
Definition: vm_core.h:555
rb_threadptr_signal_exit
void rb_threadptr_signal_exit(rb_thread_t *th)
Definition: thread.c:2070
rb_vm_struct::sleeper
volatile int sleeper
Definition: vm_core.h:363
ruby_error_nomemory
Definition: vm_core.h:328
VM_DEFINECLASS_TYPE_SINGLETON_CLASS
Definition: vm_core.h:659
rb_iseq_struct::local_table
ID * local_table
Definition: vm_core.h:235
rb_hook_list_struct::hooks
struct rb_event_hook_struct * hooks
Definition: vm_core.h:343
rb_control_frame_struct
Definition: vm_core.h:445
rb_call_info_struct::aux
union rb_call_info_struct::@166 aux
rb_num_t
unsigned long rb_num_t
Definition: vm_core.h:124
rb_iseq_struct::arg_block
int arg_block
Definition: vm_core.h:277
rb_signal_buff_size
int rb_signal_buff_size(void)
Definition: signal.c:655
rb_iseq_struct::arg_opts
int arg_opts
Definition: vm_core.h:278
ruby_node_name
const char * ruby_node_name(int node)
Definition: iseq.c:1603
rb_vm_struct::safe
int safe
Definition: vm_core.h:384
iseq_inline_cache_entry
Definition: vm_core.h:133
rb_thread_struct::event_hooks
rb_hook_list_t event_hooks
Definition: vm_core.h:637
RUBY_EXTERN
#define RUBY_EXTERN
Definition: missing.h:67
VM_CHECKMATCH_TYPE_CASE
Definition: vm_core.h:737
POSTPONED_JOB_INTERRUPT_MASK
Definition: vm_core.h:955
rb_vm_struct::special_exceptions
VALUE special_exceptions[ruby_special_error_count]
Definition: vm_core.h:368
rb_vm_make_proc
VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
Definition: vm.c:656
rb_thread_struct::keeping_mutexes
struct rb_mutex_struct * keeping_mutexes
Definition: vm_core.h:591
rb_iseq_struct::ISEQ_TYPE_EVAL
Definition: vm_core.h:218
rb_serial_t
unsigned long rb_serial_t
Definition: internal.h:260
rb_proc_t
Definition: vm_core.h:700
ruby_error_closed_stream
Definition: vm_core.h:330
rb_vm_struct::loaded_features
VALUE loaded_features
Definition: vm_core.h:376
rb_call_info_struct::opt_pc
int opt_pc
Definition: vm_core.h:176
rb_binding_t::blockprocval
VALUE blockprocval
Definition: vm_core.h:729
rb_postponed_job_struct
Definition: vm_trace.c:1419
rb_iseq_location_struct
Definition: vm_core.h:196
rb_nativethread_id_t
pthread_t rb_nativethread_id_t
Definition: thread_pthread.h:18
RUBY_SYMBOL_EXPORT_END
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:39
rb_thread_list_struct
Definition: vm_core.h:507
ruby_vm_event_flags
rb_event_flag_t ruby_vm_event_flags
Definition: vm.c:106
rb_threadptr_pending_interrupt_enque
void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v)
Definition: thread.c:1544
rb_trace_arg_struct::id
ID id
Definition: vm_core.h:1001
rb_iseq_struct::parent_iseq
struct rb_iseq_struct * parent_iseq
Definition: vm_core.h:296
rb_iseq_location_struct::path
const VALUE path
Definition: vm_core.h:197
ID
unsigned long ID
Definition: ruby.h:89
rb_iseq_struct::orig
const VALUE orig
Definition: vm_core.h:304
rb_vm_struct::thread_vm_stack_size
size_t thread_vm_stack_size
Definition: vm_core.h:420
ruby_current_thread
rb_thread_t * ruby_current_thread
Definition: vm.c:104
rb_vm_make_binding
VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
Definition: vm.c:694
rb_iseq_new
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_iseq_new(NODE *, VALUE, VALUE, VALUE, VALUE, enum iseq_type)
Definition: iseq.c:413
rb_env_t::local_size
int local_size
Definition: vm_core.h:716
CALL_INFO
rb_call_info_t * CALL_INFO
Definition: vm_core.h:786
rb_iseq_compile
VALUE rb_iseq_compile(VALUE src, VALUE file, VALUE line)
Definition: iseq.c:642
rb_iseq_struct::iseq_encoded
VALUE * iseq_encoded
Definition: vm_core.h:226
VALUE
unsigned long VALUE
Definition: ruby.h:88
iseq_compile_data
Definition: iseq.h:80
ruby_threadptr_data_type
const rb_data_type_t ruby_threadptr_data_type
Definition: vm.c:2144
rb_thread_struct::to_kill
int to_kill
Definition: vm_core.h:563
rb_jmpbuf_t
RUBY_JMP_BUF rb_jmpbuf_t
Definition: vm_core.h:482
rb_iseq_struct::catch_table_size
int catch_table_size
Definition: vm_core.h:293
iseq_catch_table_entry
Definition: iseq.h:55
rb_vm_struct::main_thread
struct rb_thread_struct * main_thread
Definition: vm_core.h:354
rb_thread_struct::first_proc
VALUE first_proc
Definition: vm_core.h:615
RUBY_SYMBOL_EXPORT_BEGIN
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:38
rb_thread_check_trap_pending
RUBY_SYMBOL_EXPORT_BEGIN int rb_thread_check_trap_pending(void)
Definition: thread.c:1149
rb_iseq_struct::location
rb_iseq_location_t location
Definition: vm_core.h:223
VM_CHECKMATCH_TYPE_WHEN
Definition: vm_core.h:736
rb_thread_cond_struct
Definition: thread_pthread.h:21
rb_thread_struct::interrupt_flag
rb_atomic_t interrupt_flag
Definition: vm_core.h:585
rb_thread_struct::interrupt_cond
rb_nativethread_cond_t interrupt_cond
Definition: vm_core.h:588
rb_backtrace_iter_func
int rb_backtrace_iter_func(void *, VALUE, int, VALUE)
Definition: vm_core.h:885
rb_binding_alloc
VALUE rb_binding_alloc(VALUE klass)
Definition: proc.c:287
rb_ensure_list::next
struct rb_ensure_list * next
Definition: vm_core.h:520
rb_thread_struct::priority
int priority
Definition: vm_core.h:564
rb_thread_struct::raised_flag
int raised_flag
Definition: vm_core.h:533
iseq_inline_cache_entry::ic_serial
rb_serial_t ic_serial
Definition: vm_core.h:134
rb_control_frame_struct::flag
VALUE flag
Definition: vm_core.h:449
TIMER_INTERRUPT_MASK
Definition: vm_core.h:953
rb_thread_struct::abort_on_exception
int abort_on_exception
Definition: vm_core.h:650
rb_proc_t::blockprocval
VALUE blockprocval
Definition: vm_core.h:704
rb_thread_struct::status
enum rb_thread_status status
Definition: vm_core.h:562
rb_vm_invoke_proc
VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, const rb_block_t *blockptr)
Definition: vm.c:897
ruby_special_exceptions
ruby_special_exceptions
Definition: vm_core.h:326
rb_block_t
struct rb_block_struct rb_block_t
rb_vm_change_state
void rb_vm_change_state(void)
rb_iseq_struct::callinfo_size
int callinfo_size
Definition: vm_core.h:245
rb_iseq_compile_on_base
VALUE rb_iseq_compile_on_base(VALUE src, VALUE file, VALUE line, rb_block_t *base_block)
Definition: iseq.c:648
rb_thread_struct::first_args
VALUE first_args
Definition: vm_core.h:616
rb_vm_tag
Definition: vm_core.h:488
rb_vm_gvl_destroy
void rb_vm_gvl_destroy(rb_vm_t *vm)
Definition: thread.c:272
rb_block_struct::proc
VALUE proc
Definition: vm_core.h:467
rb_vm_struct::objspace
struct rb_objspace * objspace
Definition: vm_core.h:407
rb_proc_t::is_lambda
int is_lambda
Definition: vm_core.h:707
rb_thread_struct::top_wrapper
VALUE top_wrapper
Definition: vm_core.h:552
rb_thread_struct::mark_stack_len
int mark_stack_len
Definition: vm_core.h:631
rb_iseq_struct::arg_size
int arg_size
Definition: vm_core.h:281
rb_proc_t::safe_level
int safe_level
Definition: vm_core.h:705
rb_iseq_struct::arg_keyword_check
int arg_keyword_check
Definition: vm_core.h:284
rb_vm_struct::default_params
struct rb_vm_struct::@168 default_params
rb_thread_struct::root_svar
VALUE root_svar
Definition: vm_core.h:558
rb_proc_t::block
rb_block_t block
Definition: vm_core.h:701
rb_thread_struct::mild_compile_error
int mild_compile_error
Thread-local state of compiling context.
Definition: vm_core.h:608
rb_thread_struct::stack_start
VALUE * stack_start
Definition: vm_core.h:621
rb_control_frame_struct::pc
VALUE * pc
Definition: vm_core.h:446
rb_ensure_list
Definition: vm_core.h:519
iseq_inline_cache_entry::index
size_t index
Definition: vm_core.h:136
rb_thread_struct::interrupt_mask
unsigned long interrupt_mask
Definition: vm_core.h:586
rb_iseq_struct::ISEQ_TYPE_RESCUE
Definition: vm_core.h:216
rb_threadptr_interrupt
void rb_threadptr_interrupt(rb_thread_t *th)
Definition: thread.c:359
rb_iseq_struct::line_info_size
size_t line_info_size
Definition: vm_core.h:233
TRAP_INTERRUPT_MASK
Definition: vm_core.h:956
ANYARGS
#define ANYARGS
Definition: defines.h:98
rb_control_frame_struct::me
const rb_method_entry_t * me
Definition: vm_core.h:455
rb_thread_struct::unblock
struct rb_unblock_callback unblock
Definition: vm_core.h:589
rb_ensure_entry::marker
VALUE marker
Definition: vm_core.h:514
rb_data_type_struct
Definition: ruby.h:966
rb_event_flag_t
unsigned long rb_event_flag_t
Definition: ruby.h:1740
rb_vm_struct::event_hooks
rb_hook_list_t event_hooks
Definition: vm_core.h:388
rb_unblock_callback::arg
void * arg
Definition: vm_core.h:501
rb_binding_add_dynavars
VALUE * rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
Definition: vm.c:725
FUNC_FASTCALL
#define FUNC_FASTCALL(x)
Definition: vm_core.h:793
rb_trace_arg_struct::path
VALUE path
Definition: vm_core.h:1009
rb_call_info_struct
Definition: vm_core.h:155
rb_iseq_eval
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_iseq_eval(VALUE iseqval)
Definition: vm.c:1642
rb_thread_struct::thread_id
rb_nativethread_id_t thread_id
Definition: vm_core.h:561
rb_iseq_struct::catch_table
struct iseq_catch_table_entry * catch_table
Definition: vm_core.h:292
rb_vm_struct::thread_destruct_lock
rb_nativethread_lock_t thread_destruct_lock
Definition: vm_core.h:352
rb_insn_func_t
rb_control_frame_t *FUNC_FASTCALL rb_insn_func_t(rb_thread_t *, rb_control_frame_t *)
Definition: vm_core.h:797
rb_iseq_location_struct::first_lineno
size_t first_lineno
Definition: vm_core.h:201
rb_set_coverages
void rb_set_coverages(VALUE)
Definition: thread.c:5293
rb_control_frame_struct::ep
VALUE * ep
Definition: vm_core.h:452
rb_vm_struct::orig_progname
VALUE orig_progname
Definition: vm_core.h:399
rb_trace_arg_struct
Definition: vm_core.h:996
rb_thread_struct::root_fiber
VALUE root_fiber
Definition: vm_core.h:642
rb_iseq_struct::local_size
int local_size
Definition: vm_core.h:239
rb_thread_struct::fiber
VALUE fiber
Definition: vm_core.h:641
CDHASH
VALUE CDHASH
Definition: vm_core.h:790
IC
struct iseq_inline_cache_entry * IC
Definition: vm_core.h:785
rb_gc_mark_unlinked_live_method_entries
void rb_gc_mark_unlinked_live_method_entries(void *pvm)
Definition: vm_method.c:123
rb_thread_struct::native_thread_data
native_thread_data_t native_thread_data
Definition: vm_core.h:566
rb_vm_struct::thread_machine_stack_size
size_t thread_machine_stack_size
Definition: vm_core.h:421
rb_iseq_compile_with_option
VALUE rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE absolute_path, VALUE line, rb_block_t *base_block, VALUE opt)
Definition: iseq.c:589
iseq_inline_storage_entry::running_thread
struct rb_thread_struct * running_thread
Definition: vm_core.h:143
rb_vm_struct::load_path_snapshot
VALUE load_path_snapshot
Definition: vm_core.h:373
rb_iseq_struct::line_info_table
struct iseq_line_info_entry * line_info_table
Definition: vm_core.h:232
rb_binding_t
Definition: vm_core.h:726
rb_threadptr_restore_recursive_data
void rb_threadptr_restore_recursive_data(rb_thread_t *th, VALUE old)
Definition: thread.c:4802
rb_call_info_struct::inc_sp
int inc_sp
Definition: vm_core.h:179
rb_iseq_disasm
VALUE rb_iseq_disasm(VALUE self)
Definition: iseq.c:1378
iseq_inline_storage_entry::cache
struct iseq_inline_cache_entry cache
Definition: vm_core.h:147
rb_iseq_struct::iseq_size
unsigned long iseq_size
Definition: vm_core.h:227
rb_reset_coverages
void rb_reset_coverages(void)
Definition: thread.c:5300
PENDING_INTERRUPT_MASK
Definition: vm_core.h:954
rb_vm_get_sourceline
int rb_vm_get_sourceline(const rb_control_frame_t *)
Definition: vm_backtrace.c:33
st.h
rb_vm_inc_const_missing_count
void rb_vm_inc_const_missing_count(void)
Definition: vm.c:111
rb_thread_struct::state
int state
Definition: vm_core.h:537
rb_unblock_callback
Definition: vm_core.h:499
rb_thread_struct::ensure_list
rb_ensure_list_t * ensure_list
Definition: vm_core.h:646
rb_vm_struct::loaded_features_snapshot
VALUE loaded_features_snapshot
Definition: vm_core.h:377
rb_iseq_new_with_opt
VALUE rb_iseq_new_with_opt(NODE *, VALUE, VALUE, VALUE, VALUE, VALUE, enum iseq_type, const rb_compile_option_t *)
Definition: iseq.c:454
rb_thread_struct::root_jmpbuf
rb_jmpbuf_t root_jmpbuf
Definition: vm_core.h:643
rb_vm_struct::debug
VALUE debug
Definition: vm_core.h:399
rb_atomic_t
int rb_atomic_t
Definition: ruby_atomic.h:120
VM_DEFINECLASS_TYPE_MASK
Definition: vm_core.h:662
rb_trace_arg_struct::lineno
int lineno
Definition: vm_core.h:1008
rb_thread_struct::passed_bmethod_me
const rb_method_entry_t * passed_bmethod_me
Definition: vm_core.h:545
rb_thread_struct::passed_ci
rb_call_info_t * passed_ci
Definition: vm_core.h:548
rb_compile_option_struct
Definition: iseq.h:38
rb_vm_struct::gvl
rb_global_vm_lock_t gvl
Definition: vm_core.h:351
name
const char * name
Definition: nkf.c:208
rb_vm_struct
Definition: vm_core.h:348
rb_iseq_struct
Definition: vm_core.h:206
THREAD_RUNNABLE
Definition: vm_core.h:476
rb_block_struct::klass
VALUE klass
Definition: vm_core.h:464
rb_trace_arg_struct::event
rb_event_flag_t event
Definition: vm_core.h:997
rb_vmdebug_debug_print_post
void rb_vmdebug_debug_print_post(rb_thread_t *th, rb_control_frame_t *cfp)
Definition: vm_dump.c:385
rb_thread_struct::safe_level
int safe_level
Definition: vm_core.h:532
rb_vm_tag::buf
rb_jmpbuf_t buf
Definition: vm_core.h:491
rb_ensure_entry::e_proc
VALUE(* e_proc)(ANYARGS)
Definition: vm_core.h:515
rb_thread_struct::stack_size
size_t stack_size
Definition: vm_core.h:530
rb_iseq_location_struct::absolute_path
const VALUE absolute_path
Definition: vm_core.h:198
rb_thread_list_struct::next
struct rb_thread_list_struct * next
Definition: vm_core.h:508
rb_thread_t
struct rb_thread_struct rb_thread_t
rb_thread_struct::tag
struct rb_vm_tag * tag
Definition: vm_core.h:593
rb_vm_tag::prev
struct rb_vm_tag * prev
Definition: vm_core.h:492
VM_DEFINECLASS_TYPE_MODULE
Definition: vm_core.h:660
rb_vm_tag::retval
VALUE retval
Definition: vm_core.h:490
rb_call_info_struct::index
long index
Definition: vm_core.h:177
rb_trace_arg_struct::data
VALUE data
Definition: vm_core.h:1003
rb_call_info_t
struct rb_call_info_struct rb_call_info_t
rb_vm_struct::postponed_job_buffer
struct rb_postponed_job_struct * postponed_job_buffer
Definition: vm_core.h:394
rb_thread_struct::interrupt_lock
rb_nativethread_lock_t interrupt_lock
Definition: vm_core.h:587
rb_vm_struct::load_path
VALUE load_path
Definition: vm_core.h:372
rb_threadptr_check_signal
void rb_threadptr_check_signal(rb_thread_t *mth)
Definition: thread.c:3815
rb_threadptr_exec_event_hooks
void rb_threadptr_exec_event_hooks(struct rb_trace_arg_struct *trace_arg)
Definition: vm_trace.c:382
rb_thread_struct::pending_interrupt_queue
VALUE pending_interrupt_queue
Definition: vm_core.h:581
rb_mRubyVMFrozenCore
RUBY_EXTERN VALUE rb_mRubyVMFrozenCore
Definition: vm_core.h:694
iseq_line_info_entry
Definition: iseq.h:50
rb_threadptr_execute_interrupts
void rb_threadptr_execute_interrupts(rb_thread_t *, int)
Definition: thread.c:1953
rb_thread_struct::stack_maxsize
size_t stack_maxsize
Definition: vm_core.h:623
thread_native.h
mod
#define mod(x, y)
Definition: date_strftime.c:28
rb_vm_get_binding_creatable_next_cfp
rb_control_frame_t * rb_vm_get_binding_creatable_next_cfp(rb_thread_t *th, const rb_control_frame_t *cfp)
Definition: vm.c:235
rb_vm_get_ruby_level_next_cfp
rb_control_frame_t * rb_vm_get_ruby_level_next_cfp(rb_thread_t *th, const rb_control_frame_t *cfp)
Definition: vm.c:247
rb_binding_t::path
VALUE path
Definition: vm_core.h:728
rb_thread_struct::method_missing_reason
int method_missing_reason
Definition: vm_core.h:649
rb_thread_struct::stat_insn_usage
VALUE stat_insn_usage
Definition: vm_core.h:634
rb_thread_struct::errinfo
VALUE errinfo
Definition: vm_core.h:573
rb_iseq_location_struct::label
const VALUE label
Definition: vm_core.h:200
rb_iseq_location_struct::base_label
const VALUE base_label
Definition: vm_core.h:199
GET_THREAD
static rb_thread_t * GET_THREAD(void)
Definition: vm_core.h:927
rb_global_vm_lock_struct
Definition: thread_pthread.h:40
rb_iseq_eval_main
VALUE rb_iseq_eval_main(VALUE iseqval)
Definition: vm.c:1655
rb_name_err_mesg_new
VALUE rb_name_err_mesg_new(VALUE obj, VALUE mesg, VALUE recv, VALUE method)
Definition: error.c:1078
rb_cISeq
RUBY_EXTERN VALUE rb_cISeq
Definition: vm_core.h:691
rb_thread_struct::trace_arg
struct rb_trace_arg_struct * trace_arg
Definition: vm_core.h:638
ruby_thread_has_gvl_p
int ruby_thread_has_gvl_p(void)
Definition: thread.c:1492
rb_vm_struct::coverages
VALUE coverages
Definition: vm_core.h:400
unlinked_method_entry_list_entry
Definition: method.h:105
VM_CHECKMATCH_TYPE_RESCUE
Definition: vm_core.h:738
rb_iseq_struct::ISEQ_TYPE_TOP
Definition: vm_core.h:212
iseq_compile_data_ensure_node_stack
Definition: compile.c:71
rb_call_info_struct::me
const rb_method_entry_t * me
Definition: vm_core.h:168
argv
char ** argv
Definition: ruby.c:132
THREAD_STOPPED
Definition: vm_core.h:477
rb_block_struct::ep
VALUE * ep
Definition: vm_core.h:465
rb_thread_struct::parse_in_eval
int parse_in_eval
Thread-local state of evaluation context.
Definition: vm_core.h:602
rb_iseq_struct::is_entries
union iseq_inline_storage_entry * is_entries
Definition: vm_core.h:241
rb_env_t
Definition: vm_core.h:713