debase-ruby_core_source 0.10.15 → 0.10.16

data/lib/debase/ruby_core_source/{ruby-1.9.3-p550/debug.h → ruby-2.5.4-p155/vm_debug.h}

@@ -1,8 +1,8 @@
 /**********************************************************************
 
-  debug.h - YARV Debug function interface
+  vm_debug.h - YARV Debug function interface
 
-  $Author: akr $
+  $Author: nobu $
   created at: 04/08/25 02:33:49 JST
 
   Copyright (C) 2004-2007 Koichi Sasada
@@ -15,9 +15,7 @@
 #include "ruby/ruby.h"
 #include "node.h"
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility push(default)
-#endif
+RUBY_SYMBOL_EXPORT_BEGIN
 
 #define dpv(h,v) ruby_debug_print_value(-1, 0, (h), (v))
 #define dp(v)    ruby_debug_print_value(-1, 0, "", (v))
@@ -34,8 +32,6 @@ void  ruby_debug_breakpoint(void);
 void  ruby_debug_gc_check_func(void);
 void ruby_set_debug_option(const char *str);
 
-#if defined __GNUC__ && __GNUC__ >= 4
-#pragma GCC visibility pop
-#endif
+RUBY_SYMBOL_EXPORT_END
 
 #endif /* RUBY_DEBUG_H */

data/lib/debase/ruby_core_source/{ruby-1.9.3-p550 → ruby-2.5.4-p155}/vm_exec.h

@@ -2,7 +2,7 @@
 
   vm.h -
 
-  $Author: usa $
+  $Author: nagachika $
   created at: 04/01/01 16:56:59 JST
 
   Copyright (C) 2004-2007 Koichi Sasada
@@ -14,20 +14,9 @@
 
 typedef long OFFSET;
 typedef unsigned long lindex_t;
-typedef unsigned long dindex_t;
 typedef VALUE GENTRY;
 typedef rb_iseq_t *ISEQ;
 
-#ifdef  COLLECT_USAGE_ANALYSIS
-#define USAGE_ANALYSIS_INSN(insn)           vm_analysis_insn(insn)
-#define USAGE_ANALYSIS_OPERAND(insn, n, op) vm_analysis_operand((insn), (n), (VALUE)(op))
-#define USAGE_ANALYSIS_REGISTER(reg, s)     vm_analysis_register((reg), (s))
-#else
-#define USAGE_ANALYSIS_INSN(insn)		/* none */
-#define USAGE_ANALYSIS_OPERAND(insn, n, op)	/* none */
-#define USAGE_ANALYSIS_REGISTER(reg, s)		/* none */
-#endif
-
 #ifdef __GCC__
 /* TODO: machine dependent prefetch instruction */
 #define PREFETCH(pc)
@@ -38,7 +27,7 @@ typedef rb_iseq_t *ISEQ;
 #if VMDEBUG > 0
 #define debugs printf
 #define DEBUG_ENTER_INSN(insn) \
-  debug_print_pre(th, GET_CFP());
+    rb_vmdebug_debug_print_pre(ec, GET_CFP(), GET_PC());
 
 #if OPT_STACK_CACHING
 #define SC_REGS() , reg_a, reg_b
@@ -47,7 +36,7 @@ typedef rb_iseq_t *ISEQ;
 #endif
 
 #define DEBUG_END_INSN() \
-  debug_print_post(th, GET_CFP() SC_REGS());
+  rb_vmdebug_debug_print_post(ec, GET_CFP() SC_REGS());
 
 #else
 
@@ -60,7 +49,7 @@ typedef rb_iseq_t *ISEQ;
 /* #define throwdebug printf */
 
 /************************************************/
-#if   DISPATCH_XXX
+#if defined(DISPATCH_XXX)
 error !
 /************************************************/
 #elif OPT_CALL_THREADED_CODE
@@ -71,12 +60,15 @@ error !
 
 #define INSN_ENTRY(insn) \
   static rb_control_frame_t * \
-    FUNC_FASTCALL(LABEL(insn))(rb_thread_t *th, rb_control_frame_t *reg_cfp) {
+    FUNC_FASTCALL(LABEL(insn))(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp) {
 
 #define END_INSN(insn) return reg_cfp;}
 
 #define NEXT_INSN() return reg_cfp;
 
+#define START_OF_ORIGINAL_INSN(x) /* ignore */
+#define DISPATCH_ORIGINAL_INSN(x) return LABEL(x)(ec, reg_cfp);
+
 /************************************************/
 #elif OPT_TOKEN_THREADED_CODE || OPT_DIRECT_THREADED_CODE
 /* threaded code with gcc */
@@ -85,8 +77,12 @@ error !
 #define ELABEL(x) INSN_ELABEL_##x
 #define LABEL_PTR(x) &&LABEL(x)
 
-#define INSN_ENTRY_SIG(insn)
-
+#define INSN_ENTRY_SIG(insn) \
+  if (0) fprintf(stderr, "exec: %s@(%d, %d)@%s:%d\n", #insn, \
+		 (int)(reg_pc - reg_cfp->iseq->body->iseq_encoded), \
+		 (int)(reg_cfp->pc - reg_cfp->iseq->body->iseq_encoded), \
+		 RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), \
+		 (int)(rb_iseq_line_no(reg_cfp->iseq, reg_pc - reg_cfp->iseq->body->iseq_encoded)));
 
 #define INSN_DISPATCH_SIG(insn)
 
@@ -94,18 +90,16 @@ error !
   LABEL(insn): \
   INSN_ENTRY_SIG(insn); \
 
-/* dispather */
-#if __GNUC__ && (__i386__ || __x86_64__) && __GNUC__ == 3
+/* dispatcher */
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && __GNUC__ == 3
 #define DISPATCH_ARCH_DEPEND_WAY(addr) \
-  asm volatile("jmp *%0;\t# -- inseted by vm.h\t[length = 2]" : : "r" (addr))
+  __asm__ __volatile__("jmp *%0;\t# -- inserted by vm.h\t[length = 2]" : : "r" (addr))
 
 #else
 #define DISPATCH_ARCH_DEPEND_WAY(addr) \
 				/* do nothing */
-
 #endif
 
-
 /**********************************/
 #if OPT_DIRECT_THREADED_CODE
 
@@ -116,7 +110,7 @@ error !
   ;
 
 #else
-/* token threade code */
+/* token threaded code */
 
 #define TC_DISPATCH(insn)  \
   DISPATCH_ARCH_DEPEND_WAY(insns_address_table[GET_CURRENT_INSN()]); \
@@ -129,7 +123,7 @@ error !
 
 #define END_INSN(insn)      \
   DEBUG_END_INSN();         \
-  TC_DISPATCH(insn);        \
+  TC_DISPATCH(insn);
 
 #define INSN_DISPATCH()     \
   TC_DISPATCH(__START__)    \
@@ -141,6 +135,9 @@ error !
 
 #define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
 
+#define START_OF_ORIGINAL_INSN(x) start_of_##x:
+#define DISPATCH_ORIGINAL_INSN(x) goto  start_of_##x;
+
 /************************************************/
 #else /* no threaded code */
 /* most common method */
@@ -152,10 +149,9 @@ case BIN(insn):
   DEBUG_END_INSN();                           \
   break;
 
-
 #define INSN_DISPATCH()         \
-  while(1){                     \
-    switch(GET_CURRENT_INSN()){
+  while (1) {			\
+    switch (GET_CURRENT_INSN()) {
 
 #define END_INSNS_DISPATCH()    \
 default:                        \
@@ -166,13 +162,16 @@ default:                        \
 
 #define NEXT_INSN() goto first
 
+#define START_OF_ORIGINAL_INSN(x) start_of_##x:
+#define DISPATCH_ORIGINAL_INSN(x) goto  start_of_##x;
+
 #endif
 
-#define VM_SP_CNT(th, sp) ((sp) - (th)->stack)
+#define VM_SP_CNT(ec, sp) ((sp) - (ec)->vm_stack)
 
 #if OPT_CALL_THREADED_CODE
 #define THROW_EXCEPTION(exc) do { \
-    th->errinfo = (VALUE)(exc); \
+    ec->errinfo = (VALUE)(exc); \
     return 0; \
 } while (0)
 #else
@@ -181,4 +180,13 @@ default:                        \
 
 #define SCREG(r) (reg_##r)
 
+#define VM_DEBUG_STACKOVERFLOW 0
+
+#if VM_DEBUG_STACKOVERFLOW
+#define CHECK_VM_STACK_OVERFLOW_FOR_INSN(cfp, margin) \
+    WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stack_overflow_for_insn()
+#else
+#define CHECK_VM_STACK_OVERFLOW_FOR_INSN(cfp, margin)
+#endif
+
 #endif /* RUBY_VM_EXEC_H */

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/vm_insnhelper.h

@@ -0,0 +1,255 @@
+/**********************************************************************
+
+  insnhelper.h - helper macros to implement each instructions
+
+  $Author: ko1 $
+  created at: 04/01/01 15:50:34 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_INSNHELPER_H
+#define RUBY_INSNHELPER_H
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+extern VALUE ruby_vm_const_missing_count;
+extern rb_serial_t ruby_vm_global_method_state;
+extern rb_serial_t ruby_vm_global_constant_state;
+extern rb_serial_t ruby_vm_class_serial;
+
+RUBY_SYMBOL_EXPORT_END
+
+#if VM_COLLECT_USAGE_DETAILS
+#define COLLECT_USAGE_INSN(insn)           vm_collect_usage_insn(insn)
+#define COLLECT_USAGE_OPERAND(insn, n, op) vm_collect_usage_operand((insn), (n), ((VALUE)(op)))
+
+#define COLLECT_USAGE_REGISTER(reg, s)     vm_collect_usage_register((reg), (s))
+#else
+#define COLLECT_USAGE_INSN(insn)		/* none */
+#define COLLECT_USAGE_OPERAND(insn, n, op)	/* none */
+#define COLLECT_USAGE_REGISTER(reg, s)		/* none */
+#endif
+
+/**********************************************************/
+/* deal with stack                                        */
+/**********************************************************/
+
+#define PUSH(x) (SET_SV(x), INC_SP(1))
+#define TOPN(n) (*(GET_SP()-(n)-1))
+#define POPN(n) (DEC_SP(n))
+#define POP()   (DEC_SP(1))
+#define STACK_ADDR_FROM_TOP(n) (GET_SP()-(n))
+
+#define GET_TOS()  (tos)	/* dummy */
+
+/**********************************************************/
+/* deal with registers                                    */
+/**********************************************************/
+
+#define VM_REG_CFP (reg_cfp)
+#define VM_REG_PC  (VM_REG_CFP->pc)
+#define VM_REG_SP  (VM_REG_CFP->sp)
+#define VM_REG_EP  (VM_REG_CFP->ep)
+
+#define RESTORE_REGS() do { \
+    VM_REG_CFP = ec->cfp; \
+} while (0)
+
+#define REG_A   reg_a
+#define REG_B   reg_b
+
+enum vm_regan_regtype {
+    VM_REGAN_PC = 0,
+    VM_REGAN_SP = 1,
+    VM_REGAN_EP = 2,
+    VM_REGAN_CFP = 3,
+    VM_REGAN_SELF = 4,
+    VM_REGAN_ISEQ = 5,
+};
+enum vm_regan_acttype {
+    VM_REGAN_ACT_GET = 0,
+    VM_REGAN_ACT_SET = 1,
+};
+
+#if VM_COLLECT_USAGE_DETAILS
+#define COLLECT_USAGE_REGISTER_HELPER(a, b, v) \
+  (COLLECT_USAGE_REGISTER((VM_REGAN_##a), (VM_REGAN_ACT_##b)), (v))
+#else
+#define COLLECT_USAGE_REGISTER_HELPER(a, b, v) (v)
+#endif
+
+/* PC */
+#define GET_PC()           (COLLECT_USAGE_REGISTER_HELPER(PC, GET, VM_REG_PC))
+#define SET_PC(x)          (VM_REG_PC = (COLLECT_USAGE_REGISTER_HELPER(PC, SET, (x))))
+#define GET_CURRENT_INSN() (*GET_PC())
+#define GET_OPERAND(n)     (GET_PC()[(n)])
+#define ADD_PC(n)          (SET_PC(VM_REG_PC + (n)))
+#define JUMP(dst)          (SET_PC(VM_REG_PC + (dst)))
+
+/* frame pointer, environment pointer */
+#define GET_CFP()  (COLLECT_USAGE_REGISTER_HELPER(CFP, GET, VM_REG_CFP))
+#define GET_EP()   (COLLECT_USAGE_REGISTER_HELPER(EP, GET, VM_REG_EP))
+#define SET_EP(x)  (VM_REG_EP = (COLLECT_USAGE_REGISTER_HELPER(EP, SET, (x))))
+#define GET_LEP()  (VM_EP_LEP(GET_EP()))
+
+/* SP */
+#define GET_SP()   (COLLECT_USAGE_REGISTER_HELPER(SP, GET, VM_REG_SP))
+#define SET_SP(x)  (VM_REG_SP  = (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
+#define INC_SP(x)  (VM_REG_SP += (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
+#define DEC_SP(x)  (VM_REG_SP -= (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
+#define SET_SV(x)  (*GET_SP() = (x))
+  /* set current stack value as x */
+
+/* instruction sequence C struct */
+#define GET_ISEQ() (GET_CFP()->iseq)
+
+/**********************************************************/
+/* deal with variables                                    */
+/**********************************************************/
+
+#define GET_PREV_EP(ep)                ((VALUE *)((ep)[VM_ENV_DATA_INDEX_SPECVAL] & ~0x03))
+
+#define GET_GLOBAL(entry)       rb_gvar_get((struct rb_global_entry*)(entry))
+#define SET_GLOBAL(entry, val)  rb_gvar_set((struct rb_global_entry*)(entry), (val))
+
+#define GET_CONST_INLINE_CACHE(dst) ((IC) * (GET_PC() + (dst) + 2))
+
+/**********************************************************/
+/* deal with values                                       */
+/**********************************************************/
+
+#define GET_SELF() (COLLECT_USAGE_REGISTER_HELPER(SELF, GET, GET_CFP()->self))
+
+/**********************************************************/
+/* deal with control flow 2: method/iterator              */
+/**********************************************************/
+
+#define CALL_METHOD(calling, ci, cc) do { \
+    VALUE v = (*(cc)->call)(ec, GET_CFP(), (calling), (ci), (cc)); \
+    if (v == Qundef) { \
+	RESTORE_REGS(); \
+	NEXT_INSN(); \
+    } \
+    else { \
+	val = v; \
+    } \
+} while (0)
+
+/* set fastpath when cached method is *NOT* protected
+ * because inline method cache does not care about receiver.
+ */
+
+#ifndef OPT_CALL_FASTPATH
+#define OPT_CALL_FASTPATH 1
+#endif
+
+#if OPT_CALL_FASTPATH
+#define CI_SET_FASTPATH(cc, func, enabled) do { \
+    if (LIKELY(enabled)) ((cc)->call = (func)); \
+} while (0)
+#else
+#define CI_SET_FASTPATH(ci, func, enabled) /* do nothing */
+#endif
+
+#define GET_BLOCK_HANDLER() (GET_LEP()[VM_ENV_DATA_INDEX_SPECVAL])
+
+/**********************************************************/
+/* deal with control flow 3: exception                    */
+/**********************************************************/
+
+
+/**********************************************************/
+/* others                                                 */
+/**********************************************************/
+
+/* optimize insn */
+#define FIXNUM_2_P(a, b) ((a) & (b) & 1)
+#if USE_FLONUM
+#define FLONUM_2_P(a, b) (((((a)^2) | ((b)^2)) & 3) == 0) /* (FLONUM_P(a) && FLONUM_P(b)) */
+#else
+#define FLONUM_2_P(a, b) 0
+#endif
+#define FLOAT_HEAP_P(x) (!SPECIAL_CONST_P(x) && RBASIC_CLASS(x) == rb_cFloat)
+#define FLOAT_INSTANCE_P(x) (FLONUM_P(x) || FLOAT_HEAP_P(x))
+
+#ifndef USE_IC_FOR_SPECIALIZED_METHOD
+#define USE_IC_FOR_SPECIALIZED_METHOD 1
+#endif
+
+#define CALL_SIMPLE_METHOD(recv_) do { \
+    struct rb_calling_info calling; \
+    calling.block_handler = VM_BLOCK_HANDLER_NONE; \
+    calling.argc = ci->orig_argc; \
+    vm_search_method(ci, cc, calling.recv = (recv_)); \
+    CALL_METHOD(&calling, ci, cc); \
+} while (0)
+
+#define NEXT_CLASS_SERIAL() (++ruby_vm_class_serial)
+#define GET_GLOBAL_METHOD_STATE() (ruby_vm_global_method_state)
+#define INC_GLOBAL_METHOD_STATE() (++ruby_vm_global_method_state)
+#define GET_GLOBAL_CONSTANT_STATE() (ruby_vm_global_constant_state)
+#define INC_GLOBAL_CONSTANT_STATE() (++ruby_vm_global_constant_state)
+
+static VALUE make_no_method_exception(VALUE exc, VALUE format, VALUE obj,
+				      int argc, const VALUE *argv, int priv);
+
+static inline struct vm_throw_data *
+THROW_DATA_NEW(VALUE val, const rb_control_frame_t *cf, VALUE st)
+{
+    return (struct vm_throw_data *)rb_imemo_new(imemo_throw_data, val, (VALUE)cf, st, 0);
+}
+
+static inline VALUE
+THROW_DATA_VAL(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->throw_obj;
+}
+
+static inline const rb_control_frame_t *
+THROW_DATA_CATCH_FRAME(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->catch_frame;
+}
+
+static inline int
+THROW_DATA_STATE(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return (int)obj->throw_state;
+}
+
+static inline int
+THROW_DATA_CONSUMED_P(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->flags & THROW_DATA_CONSUMED;
+}
+
+static inline void
+THROW_DATA_CATCH_FRAME_SET(struct vm_throw_data *obj, const rb_control_frame_t *cfp)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    obj->catch_frame = cfp;
+}
+
+static inline void
+THROW_DATA_STATE_SET(struct vm_throw_data *obj, int st)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    obj->throw_state = (VALUE)st;
+}
+
+static inline void
+THROW_DATA_CONSUMED_SET(struct vm_throw_data *obj)
+{
+    if (THROW_DATA_P(obj) &&
+	THROW_DATA_STATE(obj) == TAG_BREAK) {
+	obj->flags |= THROW_DATA_CONSUMED;
+    }
+}
+
+#endif /* RUBY_INSNHELPER_H */

data/lib/debase/ruby_core_source/{ruby-1.9.3-p550 → ruby-2.5.4-p155}/vm_opts.h

@@ -3,7 +3,7 @@
 
   vm_opts.h - VM optimize option
 
-  $Author: akr $
+  $Author: ko1 $
 
   Copyright (C) 2004-2007 Koichi Sasada
 
@@ -18,18 +18,18 @@
  * Following definitions are default values.
  */
 
-#define OPT_TRACE_INSTRUCTION        1
-#define OPT_TAILCALL_OPTIMIZATION    0
-#define OPT_PEEPHOLE_OPTIMIZATION    1
-#define OPT_SPECIALISED_INSTRUCTION  1
-#define OPT_INLINE_CONST_CACHE       1
-
+#define OPT_TAILCALL_OPTIMIZATION       0
+#define OPT_PEEPHOLE_OPTIMIZATION       1
+#define OPT_SPECIALISED_INSTRUCTION     1
+#define OPT_INLINE_CONST_CACHE          1
+#define OPT_FROZEN_STRING_LITERAL       0
+#define OPT_DEBUG_FROZEN_STRING_LITERAL 0
 
 /* Build Options.
  * You can't change these options at runtime.
  */
 
-/* C compiler depend */
+/* C compiler dependent */
 #define OPT_DIRECT_THREADED_CODE     1
 #define OPT_TOKEN_THREADED_CODE      0
 #define OPT_CALL_THREADED_CODE       0
@@ -37,10 +37,11 @@
 /* VM running option */
 #define OPT_CHECKED_RUN              1
 #define OPT_INLINE_METHOD_CACHE      1
+#define OPT_GLOBAL_METHOD_CACHE      1
 #define OPT_BLOCKINLINING            0
 
 /* architecture independent, affects generated code */
-#define OPT_OPERANDS_UNIFICATION     0
+#define OPT_OPERANDS_UNIFICATION     1
 #define OPT_INSTRUCTIONS_UNIFICATION 0
 #define OPT_UNIFY_ALL_COMBINATION    0
 #define OPT_STACK_CACHING            0
@@ -48,4 +49,8 @@
 /* misc */
 #define SUPPORT_JOKE                 0
 
+#ifndef VM_COLLECT_USAGE_DETAILS
+#define VM_COLLECT_USAGE_DETAILS     0
+#endif
+
 #endif /* RUBY_VM_OPTS_H */