debase-ruby_core_source 0.10.2 → 0.10.11

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.5.1-p57}/internal.h

@@ -914,8 +914,8 @@ struct vm_throw_data {
 
 struct vm_ifunc_argc {
 #if SIZEOF_INT * 2 > SIZEOF_VALUE
-    int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
-    int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
+    signed int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
+    signed int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
 #else
     int min, max;
 #endif
@@ -1110,7 +1110,7 @@ VALUE rb_invcmp(VALUE, VALUE);
 struct rb_block;
 int rb_dvar_defined(ID, const struct rb_block *);
 int rb_local_defined(ID, const struct rb_block *);
-CONSTFUNC(const char * rb_insns_name(int i));
+const char * rb_insns_name(int i);
 VALUE rb_insns_name_array(void);
 
 /* complex.c */
@@ -1136,7 +1136,7 @@ void Init_ext(void);
 
 /* encoding.c */
 ID rb_id_encoding(void);
-CONSTFUNC(void rb_gc_mark_encodings(void));
+void rb_gc_mark_encodings(void);
 rb_encoding *rb_enc_get_from_index(int index);
 rb_encoding *rb_enc_check_str(VALUE str1, VALUE str2);
 int rb_encdb_replicate(const char *alias, const char *orig);
@@ -1754,6 +1754,7 @@ VALUE rb_to_symbol_type(VALUE obj);
 /* struct.c */
 VALUE rb_struct_init_copy(VALUE copy, VALUE s);
 VALUE rb_struct_lookup(VALUE s, VALUE idx);
+VALUE rb_struct_s_keyword_init(VALUE klass);
 
 /* time.c */
 struct timeval rb_time_timeval(VALUE);

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.5.1-p57}/iseq.h

@@ -2,7 +2,7 @@
 
   iseq.h -
 
-  $Author: mame $
+  $Author: ko1 $
   created at: 04/01/01 23:36:57 JST
 
   Copyright (C) 2004-2008 Koichi Sasada
@@ -189,6 +189,7 @@ VALUE rb_iseq_label(const rb_iseq_t *iseq);
 VALUE rb_iseq_base_label(const rb_iseq_t *iseq);
 VALUE rb_iseq_first_lineno(const rb_iseq_t *iseq);
 VALUE rb_iseq_method_name(const rb_iseq_t *iseq);
+void rb_iseq_code_range(const rb_iseq_t *iseq, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
 
 /* proc.c */
 const rb_iseq_t *rb_method_iseq(VALUE body);
@@ -202,7 +203,6 @@ struct rb_compile_option_struct {
     unsigned int operands_unification: 1;
     unsigned int instructions_unification: 1;
     unsigned int stack_caching: 1;
-    unsigned int trace_instruction: 1;
     unsigned int frozen_string_literal: 1;
     unsigned int debug_frozen_string_literal: 1;
     unsigned int coverage_enabled: 1;

data/lib/debase/ruby_core_source/ruby-2.5.1-p57/revision.h

@@ -0,0 +1 @@
+#define RUBY_REVISION 63029

data/lib/debase/ruby_core_source/ruby-2.5.1-p57/version.h

@@ -0,0 +1,73 @@
+#define RUBY_VERSION "2.5.1"
+#define RUBY_RELEASE_DATE "2018-03-29"
+#define RUBY_PATCHLEVEL 57
+
+#define RUBY_RELEASE_YEAR 2018
+#define RUBY_RELEASE_MONTH 3
+#define RUBY_RELEASE_DAY 29
+
+#include "ruby/version.h"
+
+#ifndef TOKEN_PASTE
+#define TOKEN_PASTE(x,y) x##y
+#endif
+#define ONLY_ONE_DIGIT(x) TOKEN_PASTE(10,x) < 1000
+#define WITH_ZERO_PADDING(x) TOKEN_PASTE(0,x)
+#define RUBY_BIRTH_YEAR_STR STRINGIZE(RUBY_BIRTH_YEAR)
+#define RUBY_RELEASE_YEAR_STR STRINGIZE(RUBY_RELEASE_YEAR)
+#if ONLY_ONE_DIGIT(RUBY_RELEASE_MONTH)
+#define RUBY_RELEASE_MONTH_STR STRINGIZE(WITH_ZERO_PADDING(RUBY_RELEASE_MONTH))
+#else
+#define RUBY_RELEASE_MONTH_STR STRINGIZE(RUBY_RELEASE_MONTH)
+#endif
+#if ONLY_ONE_DIGIT(RUBY_RELEASE_DAY)
+#define RUBY_RELEASE_DAY_STR STRINGIZE(WITH_ZERO_PADDING(RUBY_RELEASE_DAY))
+#else
+#define RUBY_RELEASE_DAY_STR STRINGIZE(RUBY_RELEASE_DAY)
+#endif
+
+#if !defined RUBY_LIB_VERSION && defined RUBY_LIB_VERSION_STYLE
+# if RUBY_LIB_VERSION_STYLE == 3
+#   define RUBY_LIB_VERSION STRINGIZE(RUBY_API_VERSION_MAJOR)"."STRINGIZE(RUBY_API_VERSION_MINOR)"."STRINGIZE(RUBY_API_VERSION_TEENY)
+# elif RUBY_LIB_VERSION_STYLE == 2
+#   define RUBY_LIB_VERSION STRINGIZE(RUBY_API_VERSION_MAJOR)"."STRINGIZE(RUBY_API_VERSION_MINOR)
+# endif
+#endif
+
+#if RUBY_PATCHLEVEL == -1
+#define RUBY_PATCHLEVEL_STR "dev"
+#else
+#define RUBY_PATCHLEVEL_STR "p"STRINGIZE(RUBY_PATCHLEVEL)
+#endif
+
+#ifndef RUBY_REVISION
+# include "revision.h"
+#endif
+#ifndef RUBY_REVISION
+# define RUBY_REVISION 0
+#endif
+
+#if RUBY_REVISION
+# if RUBY_PATCHLEVEL == -1
+#  ifndef RUBY_BRANCH_NAME
+#   define RUBY_BRANCH_NAME "trunk"
+#  endif
+#  define RUBY_REVISION_STR " "RUBY_BRANCH_NAME" "STRINGIZE(RUBY_REVISION)
+# else
+#  define RUBY_REVISION_STR " revision "STRINGIZE(RUBY_REVISION)
+# endif
+#else
+# define RUBY_REVISION_STR ""
+#endif
+
+# define RUBY_DESCRIPTION	    \
+    "ruby "RUBY_VERSION		    \
+    RUBY_PATCHLEVEL_STR		    \
+    " ("RUBY_RELEASE_DATE	    \
+    RUBY_REVISION_STR") "	    \
+    "["RUBY_PLATFORM"]"
+# define RUBY_COPYRIGHT		    \
+    "ruby - Copyright (C) "	    \
+    RUBY_BIRTH_YEAR_STR"-"   \
+    RUBY_RELEASE_YEAR_STR" " \
+    RUBY_AUTHOR

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.5.1-p57}/vm.inc

@@ -1214,7 +1214,7 @@ INSN_ENTRY(checkmatch){START_OF_ORIGINAL_INSN(checkmatch);
 INSN_ENTRY(checkkeyword){START_OF_ORIGINAL_INSN(checkkeyword);
 {
   VALUE ret;
-  rb_num_t keyword_index = (rb_num_t)GET_OPERAND(2);
+  lindex_t keyword_index = (lindex_t)GET_OPERAND(2);
   lindex_t kw_bits_index = (lindex_t)GET_OPERAND(1);
 
   DEBUG_ENTER_INSN("checkkeyword");
@@ -1239,21 +1239,21 @@ INSN_ENTRY(checkkeyword){START_OF_ORIGINAL_INSN(checkkeyword);
 #undef INSN_LABEL
 #undef LABEL_IS_SC
   END_INSN(checkkeyword);}}}
-INSN_ENTRY(tracebranch){START_OF_ORIGINAL_INSN(tracebranch);
+INSN_ENTRY(tracecoverage){START_OF_ORIGINAL_INSN(tracecoverage);
 {
   VALUE data = (VALUE)GET_OPERAND(2);
   rb_num_t nf = (rb_num_t)GET_OPERAND(1);
 
-  DEBUG_ENTER_INSN("tracebranch");
+  DEBUG_ENTER_INSN("tracecoverage");
   ADD_PC(1+2);
   PREFETCH(GET_PC());
-  #define CURRENT_INSN_tracebranch 1
+  #define CURRENT_INSN_tracecoverage 1
   #define INSN_IS_SC()     0
-  #define INSN_LABEL(lab)  LABEL_tracebranch_##lab
+  #define INSN_LABEL(lab)  LABEL_tracecoverage_##lab
   #define LABEL_IS_SC(lab) LABEL_##lab##_##t
-  COLLECT_USAGE_INSN(BIN(tracebranch));
-  COLLECT_USAGE_OPERAND(BIN(tracebranch), 0, nf);
-  COLLECT_USAGE_OPERAND(BIN(tracebranch), 1, data);
+  COLLECT_USAGE_INSN(BIN(tracecoverage));
+  COLLECT_USAGE_OPERAND(BIN(tracecoverage), 0, nf);
+  COLLECT_USAGE_OPERAND(BIN(tracecoverage), 1, data);
 {
 #line 790 "insns.def"
     rb_event_flag_t flag = (rb_event_flag_t)nf;
@@ -1262,11 +1262,11 @@ INSN_ENTRY(tracebranch){START_OF_ORIGINAL_INSN(tracebranch);
     EXEC_EVENT_HOOK(ec, flag, GET_SELF(), 0, 0, 0 /* id and klass are resolved at callee */, data);
 
 #line 1265 "vm.inc"
-#undef CURRENT_INSN_tracebranch
+#undef CURRENT_INSN_tracecoverage
 #undef INSN_IS_SC
 #undef INSN_LABEL
 #undef LABEL_IS_SC
-  END_INSN(tracebranch);}}}
+  END_INSN(tracecoverage);}}}
 INSN_ENTRY(defineclass){START_OF_ORIGINAL_INSN(defineclass);
 {
   VALUE val;
@@ -3294,13 +3294,13 @@ INSN_ENTRY(trace_checkkeyword){
         DISPATCH_ORIGINAL_INSN(checkkeyword);
 
   END_INSN(trace_checkkeyword);}}}
-INSN_ENTRY(trace_tracebranch){
+INSN_ENTRY(trace_tracecoverage){
 {
 {
         vm_trace(ec, GET_CFP(), GET_PC());
-        DISPATCH_ORIGINAL_INSN(tracebranch);
+        DISPATCH_ORIGINAL_INSN(tracecoverage);
 
-  END_INSN(trace_tracebranch);}}}
+  END_INSN(trace_tracecoverage);}}}
 INSN_ENTRY(trace_defineclass){
 {
 {

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.5.1-p57}/vm_core.h

@@ -2,7 +2,7 @@
 
   vm_core.h -
 
-  $Author: ko1 $
+  $Author: naruse $
   created at: 04/01/01 19:41:38 JST
 
   Copyright (C) 2004-2007 Koichi Sasada
@@ -1561,8 +1561,6 @@ void rb_vm_register_special_exception_str(enum ruby_special_exceptions sp, VALUE
 
 void rb_gc_mark_machine_stack(const rb_execution_context_t *ec);
 
-int rb_autoloading_value(VALUE mod, ID id, VALUE* value);
-
 void rb_vm_rewrite_cref(rb_cref_t *node, VALUE old_klass, VALUE new_klass, rb_cref_t **new_cref_ptr);
 
 const rb_callable_method_entry_t *rb_vm_frame_method_entry(const rb_control_frame_t *cfp);
@@ -1755,7 +1753,8 @@ RUBY_SYMBOL_EXPORT_BEGIN
 int rb_thread_check_trap_pending(void);
 
 /* #define RUBY_EVENT_RESERVED_FOR_INTERNAL_USE 0x030000 */ /* from vm_core.h */
-#define RUBY_EVENT_COVERAGE_BRANCH              0x010000
+#define RUBY_EVENT_COVERAGE_LINE                0x010000
+#define RUBY_EVENT_COVERAGE_BRANCH              0x020000
 
 extern VALUE rb_get_coverages(void);
 extern void rb_set_coverages(VALUE, int, VALUE);

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.5.1-p57}/vm_opts.h

@@ -3,7 +3,7 @@
 
   vm_opts.h - VM optimize option
 
-  $Author: nobu $
+  $Author: ko1 $
 
   Copyright (C) 2004-2007 Koichi Sasada
 
@@ -18,7 +18,6 @@
  * 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

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.5.1-p57}/vmtc.inc

@@ -58,7 +58,7 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(defined),
     LABEL_PTR(checkmatch),
     LABEL_PTR(checkkeyword),
-    LABEL_PTR(tracebranch),
+    LABEL_PTR(tracecoverage),
     LABEL_PTR(defineclass),
     LABEL_PTR(send),
     LABEL_PTR(opt_str_freeze),
@@ -156,7 +156,7 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_defined),
     LABEL_PTR(trace_checkmatch),
     LABEL_PTR(trace_checkkeyword),
-    LABEL_PTR(trace_tracebranch),
+    LABEL_PTR(trace_tracecoverage),
     LABEL_PTR(trace_defineclass),
     LABEL_PTR(trace_send),
     LABEL_PTR(trace_opt_str_freeze),

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.6.0-p0}/addr2line.h

@@ -11,7 +11,7 @@
 #ifndef RUBY_ADDR2LINE_H
 #define RUBY_ADDR2LINE_H
 
-#ifdef USE_ELF
+#if (defined(USE_ELF) || defined(HAVE_MACH_O_LOADER_H))
 
 void
 rb_dump_backtrace_with_lines(int num_traces, void **traces);

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.6.0-p0}/ccan/list/list.h

@@ -57,7 +57,7 @@ struct list_head
  * Example:
  *	static struct list_head my_list = LIST_HEAD_INIT(my_list);
  */
-#define LIST_HEAD_INIT(name) { { &name.n, &name.n } }
+#define LIST_HEAD_INIT(name) { { &(name).n, &(name).n } }
 
 /**
  * LIST_HEAD - define and initialize an empty list_head
@@ -237,6 +237,21 @@ static inline int list_empty_nodebug(const struct list_head *h)
 }
 #endif
 
+/**
+ * list_empty_nocheck - is a list empty?
+ * @h: the list_head
+ *
+ * If the list is empty, returns true. This doesn't perform any
+ * debug check for list consistency, so it can be called without
+ * locks, racing with the list being modified. This is ok for
+ * checks where an incorrect result is not an issue (optimized
+ * bail out path for example).
+ */
+static inline bool list_empty_nocheck(const struct list_head *h)
+{
+	return h->n.next == &h->n;
+}
+
 /**
  * list_del - delete an entry from an (unknown) linked list.
  * @n: the list_node to delete from the list.
@@ -647,12 +662,12 @@ static inline void list_prepend_list_(struct list_head *to,
  * so you can break and continue as normal.
  *
  * WARNING! Being the low-level macro that it is, this wrapper doesn't know
- * nor care about the type of @i. The only assumtion made is that @i points
+ * nor care about the type of @i. The only assumption made is that @i points
  * to a chunk of memory that at some @offset, relative to @i, contains a
- * properly filled `struct node_list' which in turn contains pointers to
- * memory chunks and it's turtles all the way down. Whith all that in mind
+ * properly filled `struct list_node' which in turn contains pointers to
+ * memory chunks and it's turtles all the way down. With all that in mind
  * remember that given the wrong pointer/offset couple this macro will
- * happilly churn all you memory untill SEGFAULT stops it, in other words
+ * happily churn all you memory until SEGFAULT stops it, in other words
  * caveat emptor.
  *
  * It is worth mentioning that one of legitimate use-cases for that wrapper

data/lib/debase/ruby_core_source/{ruby-2.5.0-rc1 → ruby-2.6.0-p0}/constant.h

@@ -46,5 +46,6 @@ int rb_public_const_defined(VALUE klass, ID id);
 int rb_public_const_defined_at(VALUE klass, ID id);
 int rb_public_const_defined_from(VALUE klass, ID id);
 rb_const_entry_t *rb_const_lookup(VALUE klass, ID id);
+int rb_autoloading_value(VALUE mod, ID id, VALUE *value, rb_const_flag_t *flag);
 
 #endif /* CONSTANT_H */

data/lib/debase/ruby_core_source/ruby-2.6.0-p0/debug_counter.h

@@ -0,0 +1,283 @@
+/**********************************************************************
+
+  debug_counter.h -
+
+  created at: Tue Feb 21 16:51:18 2017
+
+  Copyright (C) 2017 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef USE_DEBUG_COUNTER
+#define USE_DEBUG_COUNTER 0
+#endif
+
+#ifdef RB_DEBUG_COUNTER
+
+/*
+ * method cache (mc) counts.
+ *
+ * * mc_inline_hit/miss: inline mc hit/miss counts (VM send insn)
+ * * mc_global_hit/miss: global method cache hit/miss counts
+ *                       two types: (1) inline cache miss (VM send insn)
+ *                                  (2) called from C (rb_funcall).
+ * * mc_global_state_miss: inline mc miss by global_state miss.
+ * * mc_class_serial_miss:            ... by mc_class_serial_miss
+ * * mc_cme_complement: cme complement counts.
+ * * mc_cme_complement_hit: cme cache hit counts.
+ * * mc_search_super: search_method() call counts.
+ */
+RB_DEBUG_COUNTER(mc_inline_hit)
+RB_DEBUG_COUNTER(mc_inline_miss)
+RB_DEBUG_COUNTER(mc_global_hit)
+RB_DEBUG_COUNTER(mc_global_miss)
+RB_DEBUG_COUNTER(mc_global_state_miss)
+RB_DEBUG_COUNTER(mc_class_serial_miss)
+RB_DEBUG_COUNTER(mc_cme_complement)
+RB_DEBUG_COUNTER(mc_cme_complement_hit)
+RB_DEBUG_COUNTER(mc_search_super)
+
+/*
+ * control frame push counts.
+ *
+ * * frame_push: frame push counts.
+ * * frame_push_*: frame push counts per each type.
+ * * frame_R2R: Ruby frame to Ruby frame
+ * * frame_R2C: Ruby frame to C frame
+ * * frame_C2C: C frame to C frame
+ * * frame_C2R: C frame to Ruby frame
+ */
+RB_DEBUG_COUNTER(frame_push)
+RB_DEBUG_COUNTER(frame_push_method)
+RB_DEBUG_COUNTER(frame_push_block)
+RB_DEBUG_COUNTER(frame_push_class)
+RB_DEBUG_COUNTER(frame_push_top)
+RB_DEBUG_COUNTER(frame_push_cfunc)
+RB_DEBUG_COUNTER(frame_push_ifunc)
+RB_DEBUG_COUNTER(frame_push_eval)
+RB_DEBUG_COUNTER(frame_push_rescue)
+RB_DEBUG_COUNTER(frame_push_dummy)
+
+RB_DEBUG_COUNTER(frame_R2R)
+RB_DEBUG_COUNTER(frame_R2C)
+RB_DEBUG_COUNTER(frame_C2C)
+RB_DEBUG_COUNTER(frame_C2R)
+
+/* instance variable counts
+ *
+ * * ivar_get_ic_hit/miss: ivar_get inline cache (ic) hit/miss counts (VM insn)
+ * * ivar_get_ic_miss_serial: ivar_get ic miss reason by serial (VM insn)
+ * * ivar_get_ic_miss_unset:                      ... by unset (VM insn)
+ * * ivar_get_ic_miss_noobject:                   ... by "not T_OBJECT" (VM insn)
+ * * ivar_set_...: same counts with ivar_set (VM insn)
+ * * ivar_get/set_base: call counts of "rb_ivar_get/set()".
+ *                      because of (1) ic miss.
+ *                                 (2) direct call by C extensions.
+ */
+RB_DEBUG_COUNTER(ivar_get_ic_hit)
+RB_DEBUG_COUNTER(ivar_get_ic_miss)
+RB_DEBUG_COUNTER(ivar_get_ic_miss_serial)
+RB_DEBUG_COUNTER(ivar_get_ic_miss_unset)
+RB_DEBUG_COUNTER(ivar_get_ic_miss_noobject)
+RB_DEBUG_COUNTER(ivar_set_ic_hit)
+RB_DEBUG_COUNTER(ivar_set_ic_miss)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_serial)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_unset)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_oorange)
+RB_DEBUG_COUNTER(ivar_set_ic_miss_noobject)
+RB_DEBUG_COUNTER(ivar_get_base)
+RB_DEBUG_COUNTER(ivar_set_base)
+
+/* local variable counts
+ *
+ * * lvar_get: total lvar get counts (VM insn)
+ * * lvar_get_dynamic: lvar get counts if accessing upper env (VM insn)
+ * * lvar_set*: same as "get"
+ * * lvar_set_slowpath: counts using vm_env_write_slowpath()
+ */
+RB_DEBUG_COUNTER(lvar_get)
+RB_DEBUG_COUNTER(lvar_get_dynamic)
+RB_DEBUG_COUNTER(lvar_set)
+RB_DEBUG_COUNTER(lvar_set_dynamic)
+RB_DEBUG_COUNTER(lvar_set_slowpath)
+
+/* GC counts:
+ *
+ * * count: simple count
+ * * _minor: minor gc
+ * * _major: major gc
+ * * other suffix is corresponding to last_gc_info or
+ *   gc_profile_record_flag in gc.c.
+ */
+RB_DEBUG_COUNTER(gc_count)
+RB_DEBUG_COUNTER(gc_minor_newobj)
+RB_DEBUG_COUNTER(gc_minor_malloc)
+RB_DEBUG_COUNTER(gc_minor_method)
+RB_DEBUG_COUNTER(gc_minor_capi)
+RB_DEBUG_COUNTER(gc_minor_stress)
+RB_DEBUG_COUNTER(gc_major_nofree)
+RB_DEBUG_COUNTER(gc_major_oldgen)
+RB_DEBUG_COUNTER(gc_major_shady)
+RB_DEBUG_COUNTER(gc_major_force)
+RB_DEBUG_COUNTER(gc_major_oldmalloc)
+
+/* object allocation counts:
+ *
+ * * obj_newobj: newobj counts
+ * * obj_newobj_slowpath: newobj with slowpath counts
+ * * obj_newobj_wb_unprotected: newobj for wb_unprotecte.
+ * * obj_free: obj_free() counts
+ * * obj_promote: promoted counts (oldgen)
+ * * obj_wb_unprotect: wb unprotect counts
+ *
+ * * obj_[type]_[attr]: *free'ed counts* for each type.
+ *                      Note that it is not a allocated counts.
+ * * [type]
+ *   * _obj: T_OBJECT
+ *   * _str: T_STRING
+ *   * _ary: T_ARRAY
+ *   * _xxx: T_XXX (hash, struct, ...)
+ *
+ * * [attr]
+ *   * _ptr: R?? is not embed.
+ *   * _embed: R?? is embed.
+ *   * _transient: R?? uses transient heap.
+ * * type specific attr.
+ *   * str_shared: str is shared.
+ *   * str_nofree:        nofree
+ *   * str_fstr:          fstr
+ *   * hash_empty: hash is empty
+ *   * hash_under4:     has under 4 entries
+ *   * hash_ge4:        has n entries (4<=n<8)
+ *   * hash_ge8:        has n entries (8<=n)
+ *   * data_empty: T_DATA but no memory free.
+ *   * data_xfree:        free'ed by xfree().
+ *   * data_imm_free:     free'ed immediately.
+ *   * data_zombie:       free'ed with zombie.
+ *   * imemo_*: T_IMEMO with each type.
+ */
+RB_DEBUG_COUNTER(obj_newobj)
+RB_DEBUG_COUNTER(obj_newobj_slowpath)
+RB_DEBUG_COUNTER(obj_newobj_wb_unprotected)
+RB_DEBUG_COUNTER(obj_free)
+RB_DEBUG_COUNTER(obj_promote)
+RB_DEBUG_COUNTER(obj_wb_unprotect)
+
+RB_DEBUG_COUNTER(obj_obj_embed)
+RB_DEBUG_COUNTER(obj_obj_transient)
+RB_DEBUG_COUNTER(obj_obj_ptr)
+
+RB_DEBUG_COUNTER(obj_str_ptr)
+RB_DEBUG_COUNTER(obj_str_embed)
+RB_DEBUG_COUNTER(obj_str_shared)
+RB_DEBUG_COUNTER(obj_str_nofree)
+RB_DEBUG_COUNTER(obj_str_fstr)
+
+RB_DEBUG_COUNTER(obj_ary_embed)
+RB_DEBUG_COUNTER(obj_ary_transient)
+RB_DEBUG_COUNTER(obj_ary_ptr)
+
+RB_DEBUG_COUNTER(obj_hash_empty)
+RB_DEBUG_COUNTER(obj_hash_under4)
+RB_DEBUG_COUNTER(obj_hash_ge4)
+RB_DEBUG_COUNTER(obj_hash_ge8)
+RB_DEBUG_COUNTER(obj_hash_ar)
+RB_DEBUG_COUNTER(obj_hash_st)
+RB_DEBUG_COUNTER(obj_hash_transient)
+
+RB_DEBUG_COUNTER(obj_hash_force_convert)
+
+RB_DEBUG_COUNTER(obj_struct_embed)
+RB_DEBUG_COUNTER(obj_struct_transient)
+RB_DEBUG_COUNTER(obj_struct_ptr)
+
+RB_DEBUG_COUNTER(obj_regexp_ptr)
+
+RB_DEBUG_COUNTER(obj_data_empty)
+RB_DEBUG_COUNTER(obj_data_xfree)
+RB_DEBUG_COUNTER(obj_data_imm_free)
+RB_DEBUG_COUNTER(obj_data_zombie)
+
+RB_DEBUG_COUNTER(obj_match_ptr)
+RB_DEBUG_COUNTER(obj_file_ptr)
+RB_DEBUG_COUNTER(obj_bignum_ptr)
+
+RB_DEBUG_COUNTER(obj_symbol)
+
+RB_DEBUG_COUNTER(obj_imemo_ment)
+RB_DEBUG_COUNTER(obj_imemo_iseq)
+RB_DEBUG_COUNTER(obj_imemo_env)
+RB_DEBUG_COUNTER(obj_imemo_tmpbuf)
+RB_DEBUG_COUNTER(obj_imemo_ast)
+RB_DEBUG_COUNTER(obj_imemo_cref)
+RB_DEBUG_COUNTER(obj_imemo_svar)
+RB_DEBUG_COUNTER(obj_imemo_throw_data)
+RB_DEBUG_COUNTER(obj_imemo_ifunc)
+RB_DEBUG_COUNTER(obj_imemo_memo)
+RB_DEBUG_COUNTER(obj_imemo_parser_strterm)
+
+RB_DEBUG_COUNTER(obj_iclass_ptr)
+RB_DEBUG_COUNTER(obj_class_ptr)
+RB_DEBUG_COUNTER(obj_module_ptr)
+
+/* heap function counts
+ *
+ * * heap_xmalloc/realloc/xfree: call counts
+ */
+RB_DEBUG_COUNTER(heap_xmalloc)
+RB_DEBUG_COUNTER(heap_xrealloc)
+RB_DEBUG_COUNTER(heap_xfree)
+
+/* transient_heap */
+RB_DEBUG_COUNTER(theap_alloc)
+RB_DEBUG_COUNTER(theap_alloc_fail)
+RB_DEBUG_COUNTER(theap_evacuate)
+
+/* load (not implemented yet) */
+/*
+RB_DEBUG_COUNTER(load_files)
+RB_DEBUG_COUNTER(load_path_is_not_realpath)
+*/
+#endif
+
+#ifndef RUBY_DEBUG_COUNTER_H
+#define RUBY_DEBUG_COUNTER_H 1
+
+#if !defined(__GNUC__) && USE_DEBUG_COUNTER
+#error "USE_DEBUG_COUNTER is not supported by other than __GNUC__"
+#endif
+
+enum rb_debug_counter_type {
+#define RB_DEBUG_COUNTER(name) RB_DEBUG_COUNTER_##name,
+#include __FILE__
+    RB_DEBUG_COUNTER_MAX
+#undef RB_DEBUG_COUNTER
+};
+
+#if USE_DEBUG_COUNTER
+#include "ruby/ruby.h"
+
+extern size_t rb_debug_counter[];
+
+inline static int
+rb_debug_counter_add(enum rb_debug_counter_type type, int add, int cond)
+{
+    if (cond) {
+	rb_debug_counter[(int)type] += add;
+    }
+    return cond;
+}
+
+#define RB_DEBUG_COUNTER_INC(type)                rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, 1)
+#define RB_DEBUG_COUNTER_INC_UNLESS(type, cond) (!rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, !(cond)))
+#define RB_DEBUG_COUNTER_INC_IF(type, cond)       rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, (cond))
+
+#else
+#define RB_DEBUG_COUNTER_INC(type)              ((void)0)
+#define RB_DEBUG_COUNTER_INC_UNLESS(type, cond) (cond)
+#define RB_DEBUG_COUNTER_INC_IF(type, cond)     (cond)
+#endif
+
+void rb_debug_counter_show_results(const char *msg);
+
+#endif /* RUBY_DEBUG_COUNTER_H */