ruby-internal 0.8.3 → 0.8.4

data/ext/internal/yarv-headers/vm_exec.h

@@ -0,0 +1,184 @@
+/**********************************************************************
+
+  vm.h -
+
+  $Author: akr $
+  created at: 04/01/01 16:56:59 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_VM_EXEC_H
+#define RUBY_VM_EXEC_H
+
+typedef long OFFSET;
+typedef unsigned long lindex_t;
+typedef unsigned long dindex_t;
+typedef rb_num_t 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)
+#else
+#define PREFETCH(pc)
+#endif
+
+#if VMDEBUG > 0
+#define debugs printf
+#define DEBUG_ENTER_INSN(insn) \
+  debug_print_pre(th, GET_CFP());
+
+#if OPT_STACK_CACHING
+#define SC_REGS() , reg_a, reg_b
+#else
+#define SC_REGS()
+#endif
+
+#define DEBUG_END_INSN() \
+  debug_print_post(th, GET_CFP() SC_REGS());
+
+#else
+
+#define debugs
+#define DEBUG_ENTER_INSN(insn)
+#define DEBUG_END_INSN()
+#endif
+
+#define throwdebug if(0)printf
+/* #define throwdebug printf */
+
+/************************************************/
+#if   DISPATCH_XXX
+error !
+/************************************************/
+#elif OPT_CALL_THREADED_CODE
+
+#define LABEL(x)  insn_func_##x
+#define ELABEL(x)
+#define LABEL_PTR(x) &LABEL(x)
+
+#define INSN_ENTRY(insn) \
+  static rb_control_frame_t * \
+    FUNC_FASTCALL(LABEL(insn))(rb_thread_t *th, rb_control_frame_t *reg_cfp) {
+
+#define END_INSN(insn) return reg_cfp;}
+
+#define NEXT_INSN() return reg_cfp;
+
+/************************************************/
+#elif OPT_TOKEN_THREADED_CODE || OPT_DIRECT_THREADED_CODE
+/* threaded code with gcc */
+
+#define LABEL(x)  INSN_LABEL_##x
+#define ELABEL(x) INSN_ELABEL_##x
+#define LABEL_PTR(x) &&LABEL(x)
+
+#define INSN_ENTRY_SIG(insn)
+
+
+#define INSN_DISPATCH_SIG(insn)
+
+#define INSN_ENTRY(insn) \
+  LABEL(insn): \
+  INSN_ENTRY_SIG(insn); \
+
+/* dispather */
+#if __GNUC__ && (__i386__ || __x86_64__) && __GNUC__ == 3
+#define DISPATCH_ARCH_DEPEND_WAY(addr) \
+  asm volatile("jmp *%0;\t# -- inseted by vm.h\t[length = 2]" : : "r" (addr))
+
+#else
+#define DISPATCH_ARCH_DEPEND_WAY(addr) \
+				/* do nothing */
+
+#endif
+
+
+/**********************************/
+#if OPT_DIRECT_THREADED_CODE
+
+/* for GCC 3.4.x */
+#define TC_DISPATCH(insn) \
+  INSN_DISPATCH_SIG(insn); \
+  goto *(void const *)GET_CURRENT_INSN(); \
+  ;
+
+#else
+/* token threade code */
+
+#define TC_DISPATCH(insn)  \
+  DISPATCH_ARCH_DEPEND_WAY(insns_address_table[GET_CURRENT_INSN()]); \
+  INSN_DISPATCH_SIG(insn); \
+  goto *insns_address_table[GET_CURRENT_INSN()]; \
+  rb_bug("tc error");
+
+
+#endif /* DISPATCH_DIRECT_THREADED_CODE */
+
+#define END_INSN(insn)      \
+  DEBUG_END_INSN();         \
+  TC_DISPATCH(insn);        \
+
+#define INSN_DISPATCH()     \
+  TC_DISPATCH(__START__)    \
+  {
+
+#define END_INSNS_DISPATCH()    \
+      rb_bug("unknown insn: %"PRIdVALUE, GET_CURRENT_INSN());   \
+  }   /* end of while loop */   \
+
+#define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
+
+/************************************************/
+#else /* no threaded code */
+/* most common method */
+
+#define INSN_ENTRY(insn) \
+case BIN(insn):
+
+#define END_INSN(insn)                        \
+  DEBUG_END_INSN();                           \
+  break;
+
+
+#define INSN_DISPATCH()         \
+  while(1){                     \
+    switch(GET_CURRENT_INSN()){
+
+#define END_INSNS_DISPATCH()    \
+default:                        \
+  SDR(); \
+      rb_bug("unknown insn: %ld", GET_CURRENT_INSN());   \
+    } /* end of switch */       \
+  }   /* end of while loop */   \
+
+#define NEXT_INSN() goto first
+
+#endif
+
+#define VM_SP_CNT(th, sp) ((sp) - (th)->stack)
+
+#if OPT_CALL_THREADED_CODE
+#define THROW_EXCEPTION(exc) do { \
+    th->errinfo = (VALUE)(exc); \
+    return 0; \
+} while (0)
+#else
+#define THROW_EXCEPTION(exc) return (VALUE)(exc)
+#endif
+
+#define SCREG(r) (reg_##r)
+
+#endif /* RUBY_VM_EXEC_H */

data/ext/internal/yarv-headers/vm_insnhelper.h

@@ -0,0 +1,220 @@
+/**********************************************************************
+
+  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
+
+/**
+ * VM Debug Level
+ *
+ * debug level:
+ *  0: no debug output
+ *  1: show instruction name
+ *  2: show stack frame when control stack frame is changed
+ *  3: show stack status
+ *  4: show register
+ *  5:
+ * 10: gc check
+ */
+
+#ifndef VMDEBUG
+#define VMDEBUG 0
+#endif
+
+#if 0
+#undef  VMDEBUG
+#define VMDEBUG 3
+#endif
+
+enum {
+  BOP_PLUS,
+  BOP_MINUS,
+  BOP_MULT,
+  BOP_DIV,
+  BOP_MOD,
+  BOP_EQ,
+  BOP_EQQ,
+  BOP_LT,
+  BOP_LE,
+  BOP_LTLT,
+  BOP_AREF,
+  BOP_ASET,
+  BOP_LENGTH,
+  BOP_SIZE,
+  BOP_SUCC,
+  BOP_GT,
+  BOP_GE,
+  BOP_NOT,
+  BOP_NEQ,
+
+  BOP_LAST_
+};
+
+extern char ruby_vm_redefined_flag[BOP_LAST_];
+extern VALUE ruby_vm_const_missing_count;
+
+
+/**********************************************************/
+/* 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 REG_CFP (reg_cfp)
+#define REG_PC  (REG_CFP->pc)
+#define REG_SP  (REG_CFP->sp)
+#define REG_LFP (REG_CFP->lfp)
+#define REG_DFP (REG_CFP->dfp)
+
+#define RESTORE_REGS() do { \
+  REG_CFP = th->cfp; \
+} while (0)
+
+#define REG_A   reg_a
+#define REG_B   reg_b
+
+#ifdef COLLECT_USAGE_ANALYSIS
+#define USAGE_ANALYSIS_REGISTER_HELPER(a, b, v) \
+  (USAGE_ANALYSIS_REGISTER((a), (b)), (v))
+#else
+#define USAGE_ANALYSIS_REGISTER_HELPER(a, b, v) (v)
+#endif
+
+/* PC */
+#define GET_PC()           (USAGE_ANALYSIS_REGISTER_HELPER(0, 0, REG_PC))
+#define SET_PC(x)          (REG_PC = (USAGE_ANALYSIS_REGISTER_HELPER(0, 1, (x))))
+#define GET_CURRENT_INSN() (*GET_PC())
+#define GET_OPERAND(n)     (GET_PC()[(n)])
+#define ADD_PC(n)          (SET_PC(REG_PC + (n)))
+
+#define GET_PC_COUNT()     (REG_PC - GET_ISEQ()->iseq_encoded)
+#define JUMP(dst)          (REG_PC += (dst))
+
+/* FP */
+#define GET_CFP()  (USAGE_ANALYSIS_REGISTER_HELPER(2, 0, REG_CFP))
+#define GET_LFP()  (USAGE_ANALYSIS_REGISTER_HELPER(3, 0, REG_LFP))
+#define SET_LFP(x) (REG_LFP = (USAGE_ANALYSIS_REGISTER_HELPER(3, 1, (x))))
+#define GET_DFP()  (USAGE_ANALYSIS_REGISTER_HELPER(4, 0, REG_DFP))
+#define SET_DFP(x) (REG_DFP = (USAGE_ANALYSIS_REGISTER_HELPER(4, 1, (x))))
+
+/* SP */
+#define GET_SP()   (USAGE_ANALYSIS_REGISTER_HELPER(1, 0, REG_SP))
+#define SET_SP(x)  (REG_SP  = (USAGE_ANALYSIS_REGISTER_HELPER(1, 1, (x))))
+#define INC_SP(x)  (REG_SP += (USAGE_ANALYSIS_REGISTER_HELPER(1, 1, (x))))
+#define DEC_SP(x)  (REG_SP -= (USAGE_ANALYSIS_REGISTER_HELPER(1, 1, (x))))
+#define SET_SV(x)  (*GET_SP() = (x))
+  /* set current stack value as x */
+
+#define GET_SP_COUNT() (REG_SP - th->stack)
+
+/* instruction sequence C struct */
+#define GET_ISEQ() (GET_CFP()->iseq)
+
+/**********************************************************/
+/* deal with variables                                    */
+/**********************************************************/
+
+#define GET_PREV_DFP(dfp)                ((VALUE *)((dfp)[0] & ~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() (USAGE_ANALYSIS_REGISTER_HELPER(5, 0, GET_CFP()->self))
+
+/**********************************************************/
+/* deal with control flow 2: method/iterator              */
+/**********************************************************/
+
+#define COPY_CREF(c1, c2) do {  \
+  NODE *__tmp_c2 = (c2); \
+  (c1)->nd_clss = __tmp_c2->nd_clss; \
+  (c1)->nd_visi = __tmp_c2->nd_visi;\
+  (c1)->nd_next = __tmp_c2->nd_next; \
+  if (__tmp_c2->flags & NODE_FL_CREF_PUSHED_BY_EVAL) { \
+      (c1)->flags |= NODE_FL_CREF_PUSHED_BY_EVAL; \
+  } \
+} while (0)
+
+#define CALL_METHOD(num, blockptr, flag, id, me, recv) do { \
+    VALUE v = vm_call_method(th, GET_CFP(), (num), (blockptr), (flag), (id), (me), (recv)); \
+    if (v == Qundef) { \
+	RESTORE_REGS(); \
+	NEXT_INSN(); \
+    } \
+    else { \
+	val = v; \
+    } \
+} while (0)
+
+#define GET_BLOCK_PTR() \
+  ((rb_block_t *)(GC_GUARDED_PTR_REF(GET_LFP()[0] & \
+				     ((GET_LFP()[0] & 0x02) - 0x02))))
+
+/**********************************************************/
+/* deal with control flow 3: exception                    */
+/**********************************************************/
+
+
+/**********************************************************/
+/* others                                                 */
+/**********************************************************/
+
+/* optimize insn */
+#define FIXNUM_2_P(a, b) ((a) & (b) & 1)
+#define BASIC_OP_UNREDEFINED_P(op) (LIKELY(ruby_vm_redefined_flag[(op)] == 0))
+#define HEAP_CLASS_OF(obj) RBASIC(obj)->klass
+
+#ifndef USE_IC_FOR_SPECIALIZED_METHOD
+#define USE_IC_FOR_SPECIALIZED_METHOD 1
+#endif
+
+#if USE_IC_FOR_SPECIALIZED_METHOD
+
+#define CALL_SIMPLE_METHOD(num, id, recv) do { \
+    VALUE klass = CLASS_OF(recv); \
+    CALL_METHOD((num), 0, 0, (id), vm_method_search((id), klass, ic), (recv)); \
+} while (0)
+
+#else
+
+#define CALL_SIMPLE_METHOD(num, id, recv) do { \
+    VALUE klass = CLASS_OF(recv); \
+    CALL_METHOD((num), 0, 0, (id), rb_method_entry(klass, (id)), (recv)); \
+} while (0)
+
+#endif
+
+static VALUE ruby_vm_global_state_version = 1;
+
+#define GET_VM_STATE_VERSION() (ruby_vm_global_state_version)
+#define INC_VM_STATE_VERSION() do { \
+    ruby_vm_global_state_version = (ruby_vm_global_state_version + 1); \
+    if (ruby_vm_global_state_version == 0) vm_clear_all_cache(); \
+} while (0)
+static void vm_clear_all_cache(void);
+
+#endif /* RUBY_INSNHELPER_H */

data/ext/internal/yarv-headers/vm_opts.h

@@ -0,0 +1,51 @@
+/*-*-c-*-*/
+/**********************************************************************
+
+  vm_opts.h - VM optimize option
+
+  $Author: akr $
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+
+#ifndef RUBY_VM_OPTS_H
+#define RUBY_VM_OPTS_H
+
+/* Compile options.
+ * You can change these options at runtime by VM::CompileOption.
+ * 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
+
+
+/* Build Options.
+ * You can't change these options at runtime.
+ */
+
+/* C compiler depend */
+#define OPT_DIRECT_THREADED_CODE     1
+#define OPT_TOKEN_THREADED_CODE      0
+#define OPT_CALL_THREADED_CODE       0
+
+/* VM running option */
+#define OPT_CHECKED_RUN              1
+#define OPT_INLINE_METHOD_CACHE      1
+#define OPT_BLOCKINLINING            0
+
+/* architecture independent, affects generated code */
+#define OPT_OPERANDS_UNIFICATION     0
+#define OPT_INSTRUCTIONS_UNIFICATION 0
+#define OPT_UNIFY_ALL_COMBINATION    0
+#define OPT_STACK_CACHING            0
+
+/* misc */
+#define SUPPORT_JOKE                 0
+
+#endif /* RUBY_VM_OPTS_H */