debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/ruby-2.7.0-preview3/mjit.h

@@ -1,175 +0,0 @@
-/**********************************************************************
-
-  mjit.h - Interface to MRI method JIT compiler for Ruby's main thread
-
-  Copyright (C) 2017 Vladimir Makarov <vmakarov@redhat.com>.
-
-**********************************************************************/
-
-#ifndef RUBY_MJIT_H
-#define RUBY_MJIT_H 1
-
-#include "ruby.h"
-#include "debug_counter.h"
-
-#if USE_MJIT
-
-// Special address values of a function generated from the
-// corresponding iseq by MJIT:
-enum rb_mjit_iseq_func {
-    // ISEQ was not queued yet for the machine code generation
-    NOT_ADDED_JIT_ISEQ_FUNC = 0,
-    // ISEQ is already queued for the machine code generation but the
-    // code is not ready yet for the execution
-    NOT_READY_JIT_ISEQ_FUNC = 1,
-    // ISEQ included not compilable insn, some internal assertion failed
-    // or the unit is unloaded
-    NOT_COMPILED_JIT_ISEQ_FUNC = 2,
-    // End mark
-    LAST_JIT_ISEQ_FUNC = 3
-};
-
-// MJIT options which can be defined on the MRI command line.
-struct mjit_options {
-    // Converted from "jit" feature flag to tell the enablement
-    // information to ruby_show_version().
-    char on;
-    // Save temporary files after MRI finish.  The temporary files
-    // include the pre-compiled header, C code file generated for ISEQ,
-    // and the corresponding object file.
-    char save_temps;
-    // Print MJIT warnings to stderr.
-    char warnings;
-    // Disable compiler optimization and add debug symbols. It can be
-    // very slow.
-    char debug;
-    // If not 0, all ISeqs are synchronously compiled. For testing.
-    unsigned int wait;
-    // Number of calls to trigger JIT compilation. For testing.
-    unsigned int min_calls;
-    // Force printing info about MJIT work of level VERBOSE or
-    // less. 0=silence, 1=medium, 2=verbose.
-    int verbose;
-    // Maximal permitted number of iseq JIT codes in a MJIT memory
-    // cache.
-    int max_cache_size;
-};
-
-// State of optimization switches
-struct rb_mjit_compile_info {
-    // Disable getinstancevariable/setinstancevariable optimizations based on inline cache
-    bool disable_ivar_cache;
-    // Disable send/opt_send_without_block optimizations based on inline cache
-    bool disable_send_cache;
-    // Disable method inlining
-    bool disable_inlining;
-};
-
-typedef VALUE (*mjit_func_t)(rb_execution_context_t *, rb_control_frame_t *);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-RUBY_EXTERN struct mjit_options mjit_opts;
-RUBY_EXTERN bool mjit_call_p;
-
-extern void rb_mjit_add_iseq_to_process(const rb_iseq_t *iseq);
-extern VALUE rb_mjit_wait_call(rb_execution_context_t *ec, struct rb_iseq_constant_body *body);
-extern struct rb_mjit_compile_info* rb_mjit_iseq_compile_info(const struct rb_iseq_constant_body *body);
-extern void rb_mjit_recompile_iseq(const rb_iseq_t *iseq);
-RUBY_SYMBOL_EXPORT_END
-
-extern bool mjit_compile(FILE *f, const rb_iseq_t *iseq, const char *funcname);
-extern void mjit_init(struct mjit_options *opts);
-extern void mjit_gc_start_hook(void);
-extern void mjit_gc_exit_hook(void);
-extern void mjit_free_iseq(const rb_iseq_t *iseq);
-extern void mjit_update_references(const rb_iseq_t *iseq);
-extern void mjit_mark(void);
-extern struct mjit_cont *mjit_cont_new(rb_execution_context_t *ec);
-extern void mjit_cont_free(struct mjit_cont *cont);
-extern void mjit_add_class_serial(rb_serial_t class_serial);
-extern void mjit_remove_class_serial(rb_serial_t class_serial);
-
-// A threshold used to reject long iseqs from JITting as such iseqs
-// takes too much time to be compiled.
-#define JIT_ISEQ_SIZE_THRESHOLD 1000
-
-// Return TRUE if given ISeq body should be compiled by MJIT
-static inline int
-mjit_target_iseq_p(struct rb_iseq_constant_body *body)
-{
-    return (body->type == ISEQ_TYPE_METHOD || body->type == ISEQ_TYPE_BLOCK)
-        && body->iseq_size < JIT_ISEQ_SIZE_THRESHOLD;
-}
-
-// Try to execute the current iseq in ec.  Use JIT code if it is ready.
-// If it is not, add ISEQ to the compilation queue and return Qundef.
-static inline VALUE
-mjit_exec(rb_execution_context_t *ec)
-{
-    const rb_iseq_t *iseq;
-    struct rb_iseq_constant_body *body;
-    long unsigned total_calls;
-    mjit_func_t func;
-
-    if (!mjit_call_p)
-        return Qundef;
-    RB_DEBUG_COUNTER_INC(mjit_exec);
-
-    iseq = ec->cfp->iseq;
-    body = iseq->body;
-    total_calls = ++body->total_calls;
-
-    func = body->jit_func;
-    if (UNLIKELY((uintptr_t)func <= (uintptr_t)LAST_JIT_ISEQ_FUNC)) {
-#     ifdef MJIT_HEADER
-        RB_DEBUG_COUNTER_INC(mjit_frame_JT2VM);
-#     else
-        RB_DEBUG_COUNTER_INC(mjit_frame_VM2VM);
-#     endif
-        switch ((enum rb_mjit_iseq_func)func) {
-          case NOT_ADDED_JIT_ISEQ_FUNC:
-            RB_DEBUG_COUNTER_INC(mjit_exec_not_added);
-            if (total_calls == mjit_opts.min_calls && mjit_target_iseq_p(body)) {
-                RB_DEBUG_COUNTER_INC(mjit_exec_not_added_add_iseq);
-                rb_mjit_add_iseq_to_process(iseq);
-                if (UNLIKELY(mjit_opts.wait)) {
-                    return rb_mjit_wait_call(ec, body);
-                }
-            }
-            return Qundef;
-          case NOT_READY_JIT_ISEQ_FUNC:
-            RB_DEBUG_COUNTER_INC(mjit_exec_not_ready);
-            return Qundef;
-          case NOT_COMPILED_JIT_ISEQ_FUNC:
-            RB_DEBUG_COUNTER_INC(mjit_exec_not_compiled);
-            return Qundef;
-          default: // to avoid warning with LAST_JIT_ISEQ_FUNC
-            break;
-        }
-    }
-
-#   ifdef MJIT_HEADER
-      RB_DEBUG_COUNTER_INC(mjit_frame_JT2JT);
-#   else
-      RB_DEBUG_COUNTER_INC(mjit_frame_VM2JT);
-#   endif
-    RB_DEBUG_COUNTER_INC(mjit_exec_call_func);
-    return func(ec, ec->cfp);
-}
-
-void mjit_child_after_fork(void);
-
-#else // USE_MJIT
-static inline struct mjit_cont *mjit_cont_new(rb_execution_context_t *ec){return NULL;}
-static inline void mjit_cont_free(struct mjit_cont *cont){}
-static inline void mjit_gc_start_hook(void){}
-static inline void mjit_gc_exit_hook(void){}
-static inline void mjit_free_iseq(const rb_iseq_t *iseq){}
-static inline void mjit_mark(void){}
-static inline void mjit_add_class_serial(rb_serial_t class_serial){}
-static inline void mjit_remove_class_serial(rb_serial_t class_serial){}
-static inline VALUE mjit_exec(rb_execution_context_t *ec) { return Qundef; /* unreachable */ }
-static inline void mjit_child_after_fork(void){}
-
-#endif // USE_MJIT
-#endif // RUBY_MJIT_H

data/lib/debase/ruby_core_source/ruby-2.7.0-preview3/node_name.inc

@@ -1,208 +0,0 @@
-      case NODE_SCOPE:
-   return "NODE_SCOPE";
-      case NODE_BLOCK:
-   return "NODE_BLOCK";
-      case NODE_IF:
-   return "NODE_IF";
-      case NODE_UNLESS:
-   return "NODE_UNLESS";
-      case NODE_CASE:
-   return "NODE_CASE";
-      case NODE_CASE2:
-   return "NODE_CASE2";
-      case NODE_CASE3:
-   return "NODE_CASE3";
-      case NODE_WHEN:
-   return "NODE_WHEN";
-      case NODE_IN:
-   return "NODE_IN";
-      case NODE_WHILE:
-   return "NODE_WHILE";
-      case NODE_UNTIL:
-   return "NODE_UNTIL";
-      case NODE_ITER:
-   return "NODE_ITER";
-      case NODE_FOR:
-   return "NODE_FOR";
-      case NODE_FOR_MASGN:
-   return "NODE_FOR_MASGN";
-      case NODE_BREAK:
-   return "NODE_BREAK";
-      case NODE_NEXT:
-   return "NODE_NEXT";
-      case NODE_REDO:
-   return "NODE_REDO";
-      case NODE_RETRY:
-   return "NODE_RETRY";
-      case NODE_BEGIN:
-   return "NODE_BEGIN";
-      case NODE_RESCUE:
-   return "NODE_RESCUE";
-      case NODE_RESBODY:
-   return "NODE_RESBODY";
-      case NODE_ENSURE:
-   return "NODE_ENSURE";
-      case NODE_AND:
-   return "NODE_AND";
-      case NODE_OR:
-   return "NODE_OR";
-      case NODE_MASGN:
-   return "NODE_MASGN";
-      case NODE_LASGN:
-   return "NODE_LASGN";
-      case NODE_DASGN:
-   return "NODE_DASGN";
-      case NODE_DASGN_CURR:
-   return "NODE_DASGN_CURR";
-      case NODE_GASGN:
-   return "NODE_GASGN";
-      case NODE_IASGN:
-   return "NODE_IASGN";
-      case NODE_CDECL:
-   return "NODE_CDECL";
-      case NODE_CVASGN:
-   return "NODE_CVASGN";
-      case NODE_OP_ASGN1:
-   return "NODE_OP_ASGN1";
-      case NODE_OP_ASGN2:
-   return "NODE_OP_ASGN2";
-      case NODE_OP_ASGN_AND:
-   return "NODE_OP_ASGN_AND";
-      case NODE_OP_ASGN_OR:
-   return "NODE_OP_ASGN_OR";
-      case NODE_OP_CDECL:
-   return "NODE_OP_CDECL";
-      case NODE_CALL:
-   return "NODE_CALL";
-      case NODE_OPCALL:
-   return "NODE_OPCALL";
-      case NODE_FCALL:
-   return "NODE_FCALL";
-      case NODE_VCALL:
-   return "NODE_VCALL";
-      case NODE_QCALL:
-   return "NODE_QCALL";
-      case NODE_SUPER:
-   return "NODE_SUPER";
-      case NODE_ZSUPER:
-   return "NODE_ZSUPER";
-      case NODE_LIST:
-   return "NODE_LIST";
-      case NODE_ZLIST:
-   return "NODE_ZLIST";
-      case NODE_VALUES:
-   return "NODE_VALUES";
-      case NODE_HASH:
-   return "NODE_HASH";
-      case NODE_RETURN:
-   return "NODE_RETURN";
-      case NODE_YIELD:
-   return "NODE_YIELD";
-      case NODE_LVAR:
-   return "NODE_LVAR";
-      case NODE_DVAR:
-   return "NODE_DVAR";
-      case NODE_GVAR:
-   return "NODE_GVAR";
-      case NODE_IVAR:
-   return "NODE_IVAR";
-      case NODE_CONST:
-   return "NODE_CONST";
-      case NODE_CVAR:
-   return "NODE_CVAR";
-      case NODE_NTH_REF:
-   return "NODE_NTH_REF";
-      case NODE_BACK_REF:
-   return "NODE_BACK_REF";
-      case NODE_MATCH:
-   return "NODE_MATCH";
-      case NODE_MATCH2:
-   return "NODE_MATCH2";
-      case NODE_MATCH3:
-   return "NODE_MATCH3";
-      case NODE_LIT:
-   return "NODE_LIT";
-      case NODE_STR:
-   return "NODE_STR";
-      case NODE_DSTR:
-   return "NODE_DSTR";
-      case NODE_XSTR:
-   return "NODE_XSTR";
-      case NODE_DXSTR:
-   return "NODE_DXSTR";
-      case NODE_EVSTR:
-   return "NODE_EVSTR";
-      case NODE_DREGX:
-   return "NODE_DREGX";
-      case NODE_ONCE:
-   return "NODE_ONCE";
-      case NODE_ARGS:
-   return "NODE_ARGS";
-      case NODE_ARGS_AUX:
-   return "NODE_ARGS_AUX";
-      case NODE_OPT_ARG:
-   return "NODE_OPT_ARG";
-      case NODE_KW_ARG:
-   return "NODE_KW_ARG";
-      case NODE_POSTARG:
-   return "NODE_POSTARG";
-      case NODE_ARGSCAT:
-   return "NODE_ARGSCAT";
-      case NODE_ARGSPUSH:
-   return "NODE_ARGSPUSH";
-      case NODE_SPLAT:
-   return "NODE_SPLAT";
-      case NODE_BLOCK_PASS:
-   return "NODE_BLOCK_PASS";
-      case NODE_DEFN:
-   return "NODE_DEFN";
-      case NODE_DEFS:
-   return "NODE_DEFS";
-      case NODE_ALIAS:
-   return "NODE_ALIAS";
-      case NODE_VALIAS:
-   return "NODE_VALIAS";
-      case NODE_UNDEF:
-   return "NODE_UNDEF";
-      case NODE_CLASS:
-   return "NODE_CLASS";
-      case NODE_MODULE:
-   return "NODE_MODULE";
-      case NODE_SCLASS:
-   return "NODE_SCLASS";
-      case NODE_COLON2:
-   return "NODE_COLON2";
-      case NODE_COLON3:
-   return "NODE_COLON3";
-      case NODE_DOT2:
-   return "NODE_DOT2";
-      case NODE_DOT3:
-   return "NODE_DOT3";
-      case NODE_FLIP2:
-   return "NODE_FLIP2";
-      case NODE_FLIP3:
-   return "NODE_FLIP3";
-      case NODE_SELF:
-   return "NODE_SELF";
-      case NODE_NIL:
-   return "NODE_NIL";
-      case NODE_TRUE:
-   return "NODE_TRUE";
-      case NODE_FALSE:
-   return "NODE_FALSE";
-      case NODE_ERRINFO:
-   return "NODE_ERRINFO";
-      case NODE_DEFINED:
-   return "NODE_DEFINED";
-      case NODE_POSTEXE:
-   return "NODE_POSTEXE";
-      case NODE_DSYM:
-   return "NODE_DSYM";
-      case NODE_ATTRASGN:
-   return "NODE_ATTRASGN";
-      case NODE_LAMBDA:
-   return "NODE_LAMBDA";
-      case NODE_ARYPTN:
-   return "NODE_ARYPTN";
-      case NODE_HSHPTN:
-   return "NODE_HSHPTN";

data/lib/debase/ruby_core_source/ruby-2.7.0-preview3/revision.h

@@ -1,2 +0,0 @@
-#define RUBY_REVISION "b563439274"
-#define RUBY_FULL_REVISION "b563439274a402e33541f5695b1bfd4ac1085638"

data/lib/debase/ruby_core_source/ruby-2.7.0-preview3/ruby_assert.h

@@ -1,15 +0,0 @@
-#include "ruby/assert.h"
-
-#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)
-/* C89 compilers are required to support strings of only 509 chars. */
-/* can't use RUBY_ASSERT for such compilers. */
-#include <assert.h>
-#else
-#undef assert
-#define assert RUBY_ASSERT
-#endif
-
-#ifdef NDEBUG
-  #undef  RUBY_NDEBUG
-  #define RUBY_NDEBUG 1
-#endif

data/lib/debase/ruby_core_source/ruby-2.7.0-preview3/ruby_atomic.h

@@ -1,244 +0,0 @@
-#ifndef RUBY_ATOMIC_H
-#define RUBY_ATOMIC_H
-
-#if 0
-#elif defined HAVE_GCC_ATOMIC_BUILTINS
-typedef unsigned int rb_atomic_t;
-# define ATOMIC_SET(var, val)  (void)__atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
-# define ATOMIC_INC(var) __atomic_fetch_add(&(var), 1, __ATOMIC_SEQ_CST)
-# define ATOMIC_DEC(var) __atomic_fetch_sub(&(var), 1, __ATOMIC_SEQ_CST)
-# define ATOMIC_OR(var, val) __atomic_fetch_or(&(var), (val), __ATOMIC_SEQ_CST)
-# define ATOMIC_EXCHANGE(var, val) __atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
-# define ATOMIC_CAS(var, oldval, newval) RB_GNUC_EXTENSION_BLOCK( \
-   __typeof__(var) oldvaldup = (oldval); /* oldval should not be modified */ \
-   __atomic_compare_exchange_n(&(var), &oldvaldup, (newval), 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); \
-   oldvaldup )
-
-# define ATOMIC_SIZE_ADD(var, val) __atomic_fetch_add(&(var), (val), __ATOMIC_SEQ_CST)
-# define ATOMIC_SIZE_SUB(var, val) __atomic_fetch_sub(&(var), (val), __ATOMIC_SEQ_CST)
-
-# define RUBY_ATOMIC_GENERIC_MACRO 1
-
-#elif defined HAVE_GCC_SYNC_BUILTINS
-/* @shyouhei hack to support atomic operations in case of gcc. Gcc
- * has its own pseudo-insns to support them.  See info, or
- * http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html */
-
-typedef unsigned int rb_atomic_t; /* Anything OK */
-# define ATOMIC_SET(var, val)  (void)__sync_lock_test_and_set(&(var), (val))
-# define ATOMIC_INC(var) __sync_fetch_and_add(&(var), 1)
-# define ATOMIC_DEC(var) __sync_fetch_and_sub(&(var), 1)
-# define ATOMIC_OR(var, val) __sync_fetch_and_or(&(var), (val))
-# define ATOMIC_EXCHANGE(var, val) __sync_lock_test_and_set(&(var), (val))
-# define ATOMIC_CAS(var, oldval, newval) __sync_val_compare_and_swap(&(var), (oldval), (newval))
-
-# define ATOMIC_SIZE_ADD(var, val) __sync_fetch_and_add(&(var), (val))
-# define ATOMIC_SIZE_SUB(var, val) __sync_fetch_and_sub(&(var), (val))
-
-# define RUBY_ATOMIC_GENERIC_MACRO 1
-
-#elif defined _WIN32
-#if defined _MSC_VER && _MSC_VER > 1200
-#pragma intrinsic(_InterlockedOr)
-#endif
-typedef LONG rb_atomic_t;
-
-# define ATOMIC_SET(var, val) InterlockedExchange(&(var), (val))
-# define ATOMIC_INC(var) InterlockedIncrement(&(var))
-# define ATOMIC_DEC(var) InterlockedDecrement(&(var))
-#if defined __GNUC__
-# define ATOMIC_OR(var, val) __asm__("lock\n\t" "orl\t%1, %0" : "=m"(var) : "Ir"(val))
-#elif defined _MSC_VER && _MSC_VER <= 1200
-# define ATOMIC_OR(var, val) rb_w32_atomic_or(&(var), (val))
-static inline void
-rb_w32_atomic_or(volatile rb_atomic_t *var, rb_atomic_t val)
-{
-#ifdef _M_IX86
-    __asm mov eax, var;
-    __asm mov ecx, val;
-    __asm lock or [eax], ecx;
-#else
-#error unsupported architecture
-#endif
-}
-#else
-# define ATOMIC_OR(var, val) _InterlockedOr(&(var), (val))
-#endif
-# define ATOMIC_EXCHANGE(var, val) InterlockedExchange(&(var), (val))
-# define ATOMIC_CAS(var, oldval, newval) InterlockedCompareExchange(&(var), (newval), (oldval))
-# if defined _MSC_VER && _MSC_VER <= 1200
-static inline rb_atomic_t
-rb_w32_atomic_cas(volatile rb_atomic_t *var, rb_atomic_t oldval, rb_atomic_t newval)
-{
-    return (rb_atomic_t)InterlockedCompareExchange((PVOID *)var, (PVOID)newval, (PVOID)oldval);
-}
-#   undef ATOMIC_CAS
-#   define ATOMIC_CAS(var, oldval, newval) rb_w32_atomic_cas(&(var), (oldval), (newval))
-# endif
-# ifdef _M_AMD64
-#  define ATOMIC_SIZE_ADD(var, val) InterlockedExchangeAdd64((LONG_LONG *)&(var), (val))
-#  define ATOMIC_SIZE_SUB(var, val) InterlockedExchangeAdd64((LONG_LONG *)&(var), -(LONG)(val))
-#  define ATOMIC_SIZE_INC(var) InterlockedIncrement64(&(var))
-#  define ATOMIC_SIZE_DEC(var) InterlockedDecrement64(&(var))
-#  define ATOMIC_SIZE_EXCHANGE(var, val) InterlockedExchange64(&(var), (val))
-#  define ATOMIC_SIZE_CAS(var, oldval, newval) InterlockedCompareExchange64(&(var), (newval), (oldval))
-# else
-#  define ATOMIC_SIZE_ADD(var, val) InterlockedExchangeAdd((LONG *)&(var), (val))
-#  define ATOMIC_SIZE_SUB(var, val) InterlockedExchangeAdd((LONG *)&(var), -(LONG)(val))
-#  define ATOMIC_SIZE_INC(var) InterlockedIncrement((LONG *)&(var))
-#  define ATOMIC_SIZE_DEC(var) InterlockedDecrement((LONG *)&(var))
-#  define ATOMIC_SIZE_EXCHANGE(var, val) InterlockedExchange((LONG *)&(var), (val))
-# endif
-
-# ifdef InterlockedExchangePointer
-#   define ATOMIC_PTR_EXCHANGE(var, val) InterlockedExchangePointer((PVOID volatile *)&(var), (PVOID)(val))
-# endif /* See below for definitions of other situations */
-
-#elif defined(__sun) && defined(HAVE_ATOMIC_H)
-#include <atomic.h>
-typedef unsigned int rb_atomic_t;
-
-# define ATOMIC_SET(var, val) (void)atomic_swap_uint(&(var), (val))
-# define ATOMIC_INC(var) atomic_inc_uint(&(var))
-# define ATOMIC_DEC(var) atomic_dec_uint(&(var))
-# define ATOMIC_OR(var, val) atomic_or_uint(&(var), (val))
-# define ATOMIC_EXCHANGE(var, val) atomic_swap_uint(&(var), (val))
-# define ATOMIC_CAS(var, oldval, newval) atomic_cas_uint(&(var), (oldval), (newval))
-
-# if SIZEOF_SIZE_T == SIZEOF_LONG
-#  define ATOMIC_SIZE_ADD(var, val) atomic_add_long(&(var), (val))
-#  define ATOMIC_SIZE_SUB(var, val) atomic_add_long(&(var), -(val))
-#  define ATOMIC_SIZE_INC(var) atomic_inc_ulong(&(var))
-#  define ATOMIC_SIZE_DEC(var) atomic_dec_ulong(&(var))
-#  define ATOMIC_SIZE_EXCHANGE(var, val) atomic_swap_ulong(&(var), (val))
-#  define ATOMIC_SIZE_CAS(var, oldval, val) atomic_cas_ulong(&(var), (oldval), (val))
-# else
-#  define ATOMIC_SIZE_ADD(var, val) atomic_add_int(&(var), (val))
-#  define ATOMIC_SIZE_SUB(var, val) atomic_add_int(&(var), -(val))
-#  define ATOMIC_SIZE_INC(var) atomic_inc_uint(&(var))
-#  define ATOMIC_SIZE_DEC(var) atomic_dec_uint(&(var))
-#  define ATOMIC_SIZE_EXCHANGE(var, val) atomic_swap_uint(&(var), (val))
-# endif
-
-#else
-typedef int rb_atomic_t;
-#define NEED_RUBY_ATOMIC_OPS
-extern rb_atomic_t ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val);
-extern rb_atomic_t ruby_atomic_compare_and_swap(rb_atomic_t *ptr,
-                       rb_atomic_t cmp,
-                       rb_atomic_t newval);
-
-# define ATOMIC_SET(var, val) (void)((var) = (val))
-# define ATOMIC_INC(var) ((var)++)
-# define ATOMIC_DEC(var) ((var)--)
-# define ATOMIC_OR(var, val) ((var) |= (val))
-# define ATOMIC_EXCHANGE(var, val) ruby_atomic_exchange(&(var), (val))
-# define ATOMIC_CAS(var, oldval, newval) ruby_atomic_compare_and_swap(&(var), (oldval), (newval))
-
-# define ATOMIC_SIZE_ADD(var, val) (void)((var) += (val))
-# define ATOMIC_SIZE_SUB(var, val) (void)((var) -= (val))
-# define ATOMIC_SIZE_EXCHANGE(var, val) ruby_atomic_size_exchange(&(var), (val))
-static inline size_t
-ruby_atomic_size_exchange(size_t *ptr, size_t val)
-{
-    size_t old = *ptr;
-    *ptr = val;
-    return old;
-}
-#endif
-
-#ifndef ATOMIC_SIZE_INC
-# define ATOMIC_SIZE_INC(var) ATOMIC_INC(var)
-#endif
-
-#ifndef ATOMIC_SIZE_DEC
-# define ATOMIC_SIZE_DEC(var) ATOMIC_DEC(var)
-#endif
-
-#ifndef ATOMIC_SIZE_EXCHANGE
-# define ATOMIC_SIZE_EXCHANGE(var, val) ATOMIC_EXCHANGE(var, val)
-#endif
-
-#ifndef ATOMIC_SIZE_CAS
-# define ATOMIC_SIZE_CAS(var, oldval, val) ATOMIC_CAS(var, oldval, val)
-#endif
-
-#if RUBY_ATOMIC_GENERIC_MACRO
-# ifndef ATOMIC_PTR_EXCHANGE
-#   define ATOMIC_PTR_EXCHANGE(var, val) ATOMIC_EXCHANGE(var, val)
-# endif
-
-# ifndef ATOMIC_PTR_CAS
-#   define ATOMIC_PTR_CAS(var, oldval, newval) ATOMIC_CAS(var, oldval, newval)
-# endif
-
-# ifndef ATOMIC_VALUE_EXCHANGE
-#   define ATOMIC_VALUE_EXCHANGE(var, val) ATOMIC_EXCHANGE(var, val)
-# endif
-
-# ifndef ATOMIC_VALUE_CAS
-#   define ATOMIC_VALUE_CAS(var, oldval, val) ATOMIC_CAS(var, oldval, val)
-# endif
-#endif
-
-#ifndef ATOMIC_PTR_EXCHANGE
-# if SIZEOF_VOIDP == SIZEOF_SIZE_T
-#   define ATOMIC_PTR_EXCHANGE(var, val) (void *)ATOMIC_SIZE_EXCHANGE(*(size_t *)&(var), (size_t)(val))
-# else
-#   define ATOMIC_PTR_EXCHANGE(var, val) ruby_atomic_ptr_exchange((const void **)&(var), (val))
-static inline void *
-ruby_atomic_ptr_exchange(const void **ptr, const void *val)
-{
-    const void *const old = *ptr;
-    *ptr = val;
-    return (void *)old;
-}
-# endif
-#endif
-
-#ifndef ATOMIC_PTR_CAS
-# if SIZEOF_VOIDP == SIZEOF_SIZE_T
-#   define ATOMIC_PTR_CAS(var, oldval, val) (void *)ATOMIC_SIZE_CAS(*(size_t *)&(var), (size_t)(oldval), (size_t)(val))
-# else
-#   define ATOMIC_PTR_CAS(var, oldval, val) ruby_atomic_ptr_cas(&(var), (oldval), (val))
-static inline void *
-ruby_atomic_ptr_cas(const void **ptr, const void *oldval, const void *val)
-{
-    const void *const old = *ptr;
-    if (old == oldval) *ptr = val;
-    return (void *)old;
-}
-# endif
-#endif
-
-#ifndef ATOMIC_VALUE_EXCHANGE
-# if SIZEOF_VALUE == SIZEOF_SIZE_T
-#   define ATOMIC_VALUE_EXCHANGE(var, val) ATOMIC_SIZE_EXCHANGE(*(size_t *)&(var), (size_t)(val))
-# else
-#   define ATOMIC_VALUE_EXCHANGE(var, val) ruby_atomic_value_exchange(&(var), (val))
-static inline VALUE
-ruby_atomic_value_exchange(VALUE *ptr, VALUE val)
-{
-    const VALUE old = *ptr;
-    *ptr = val;
-    return old;
-}
-# endif
-#endif
-
-#ifndef ATOMIC_VALUE_CAS
-# if SIZEOF_VALUE == SIZEOF_SIZE_T
-#   define ATOMIC_VALUE_CAS(var, oldval, val) ATOMIC_SIZE_CAS(*(size_t *)&(var), (size_t)(oldval), (size_t)(val))
-# else
-#   define ATOMIC_VALUE_CAS(var, oldval, val) ruby_atomic_value_cas(&(var), (oldval), (val))
-static inline VALUE
-ruby_atomic_value_cas(VALUE *ptr, VALUE oldval, VALUE val)
-{
-    const VALUE old = *ptr;
-    if (old == oldval) *ptr = val;
-    return old;
-}
-# endif
-#endif
-
-#endif /* RUBY_ATOMIC_H */

data/lib/debase/ruby_core_source/ruby-2.7.0-preview3/vm_debug.h

@@ -1,34 +0,0 @@
-/**********************************************************************
-
-  vm_debug.h - YARV Debug function interface
-
-  $Author$
-  created at: 04/08/25 02:33:49 JST
-
-  Copyright (C) 2004-2007 Koichi Sasada
-
-**********************************************************************/
-
-#ifndef RUBY_DEBUG_H
-#define RUBY_DEBUG_H
-
-#include "ruby/ruby.h"
-#include "node.h"
-
-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))
-#define dpi(i)   ruby_debug_print_id(-1, 0, "", (i))
-#define dpn(n)   ruby_debug_print_node(-1, 0, "", (n))
-
-VALUE ruby_debug_print_value(int level, int debug_level, const char *header, VALUE v);
-ID    ruby_debug_print_id(int level, int debug_level, const char *header, ID id);
-NODE *ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node);
-int   ruby_debug_print_indent(int level, int debug_level, int indent_level);
-void  ruby_debug_gc_check_func(void);
-void ruby_set_debug_option(const char *str);
-
-RUBY_SYMBOL_EXPORT_END
-
-#endif /* RUBY_DEBUG_H */