debase-ruby_core_source 0.10.13 → 0.10.16

data/lib/debase/ruby_core_source/ruby-2.5.4-p155/vmtc.inc

@@ -0,0 +1,214 @@
+/* -*-c-*- *********************************************************/
+/*******************************************************************/
+/*******************************************************************/
+/**
+  This file is for threaded code.
+
+  ----
+  This file is auto generated by insns2vm.rb
+  DO NOT TOUCH!
+
+  If you want to fix something, you must edit 'template/vmtc.inc.tmpl'
+  or insns2vm.rb
+ */
+
+static const void *const insns_address_table[] = {
+    LABEL_PTR(nop),
+    LABEL_PTR(getlocal),
+    LABEL_PTR(setlocal),
+    LABEL_PTR(getblockparam),
+    LABEL_PTR(setblockparam),
+    LABEL_PTR(getspecial),
+    LABEL_PTR(setspecial),
+    LABEL_PTR(getinstancevariable),
+    LABEL_PTR(setinstancevariable),
+    LABEL_PTR(getclassvariable),
+    LABEL_PTR(setclassvariable),
+    LABEL_PTR(getconstant),
+    LABEL_PTR(setconstant),
+    LABEL_PTR(getglobal),
+    LABEL_PTR(setglobal),
+    LABEL_PTR(putnil),
+    LABEL_PTR(putself),
+    LABEL_PTR(putobject),
+    LABEL_PTR(putspecialobject),
+    LABEL_PTR(putiseq),
+    LABEL_PTR(putstring),
+    LABEL_PTR(concatstrings),
+    LABEL_PTR(tostring),
+    LABEL_PTR(freezestring),
+    LABEL_PTR(toregexp),
+    LABEL_PTR(intern),
+    LABEL_PTR(newarray),
+    LABEL_PTR(duparray),
+    LABEL_PTR(expandarray),
+    LABEL_PTR(concatarray),
+    LABEL_PTR(splatarray),
+    LABEL_PTR(newhash),
+    LABEL_PTR(newrange),
+    LABEL_PTR(pop),
+    LABEL_PTR(dup),
+    LABEL_PTR(dupn),
+    LABEL_PTR(swap),
+    LABEL_PTR(reverse),
+    LABEL_PTR(reput),
+    LABEL_PTR(topn),
+    LABEL_PTR(setn),
+    LABEL_PTR(adjuststack),
+    LABEL_PTR(defined),
+    LABEL_PTR(checkmatch),
+    LABEL_PTR(checkkeyword),
+    LABEL_PTR(tracecoverage),
+    LABEL_PTR(defineclass),
+    LABEL_PTR(send),
+    LABEL_PTR(opt_str_freeze),
+    LABEL_PTR(opt_str_uminus),
+    LABEL_PTR(opt_newarray_max),
+    LABEL_PTR(opt_newarray_min),
+    LABEL_PTR(opt_send_without_block),
+    LABEL_PTR(invokesuper),
+    LABEL_PTR(invokeblock),
+    LABEL_PTR(leave),
+    LABEL_PTR(throw),
+    LABEL_PTR(jump),
+    LABEL_PTR(branchif),
+    LABEL_PTR(branchunless),
+    LABEL_PTR(branchnil),
+    LABEL_PTR(branchiftype),
+    LABEL_PTR(getinlinecache),
+    LABEL_PTR(setinlinecache),
+    LABEL_PTR(once),
+    LABEL_PTR(opt_case_dispatch),
+    LABEL_PTR(opt_plus),
+    LABEL_PTR(opt_minus),
+    LABEL_PTR(opt_mult),
+    LABEL_PTR(opt_div),
+    LABEL_PTR(opt_mod),
+    LABEL_PTR(opt_eq),
+    LABEL_PTR(opt_neq),
+    LABEL_PTR(opt_lt),
+    LABEL_PTR(opt_le),
+    LABEL_PTR(opt_gt),
+    LABEL_PTR(opt_ge),
+    LABEL_PTR(opt_ltlt),
+    LABEL_PTR(opt_aref),
+    LABEL_PTR(opt_aset),
+    LABEL_PTR(opt_aset_with),
+    LABEL_PTR(opt_aref_with),
+    LABEL_PTR(opt_length),
+    LABEL_PTR(opt_size),
+    LABEL_PTR(opt_empty_p),
+    LABEL_PTR(opt_succ),
+    LABEL_PTR(opt_not),
+    LABEL_PTR(opt_regexpmatch1),
+    LABEL_PTR(opt_regexpmatch2),
+    LABEL_PTR(opt_call_c_function),
+    LABEL_PTR(bitblt),
+    LABEL_PTR(answer),
+    LABEL_PTR(getlocal_OP__WC__0),
+    LABEL_PTR(getlocal_OP__WC__1),
+    LABEL_PTR(setlocal_OP__WC__0),
+    LABEL_PTR(setlocal_OP__WC__1),
+    LABEL_PTR(putobject_OP_INT2FIX_O_0_C_),
+    LABEL_PTR(putobject_OP_INT2FIX_O_1_C_),
+    LABEL_PTR(trace_nop),
+    LABEL_PTR(trace_getlocal),
+    LABEL_PTR(trace_setlocal),
+    LABEL_PTR(trace_getblockparam),
+    LABEL_PTR(trace_setblockparam),
+    LABEL_PTR(trace_getspecial),
+    LABEL_PTR(trace_setspecial),
+    LABEL_PTR(trace_getinstancevariable),
+    LABEL_PTR(trace_setinstancevariable),
+    LABEL_PTR(trace_getclassvariable),
+    LABEL_PTR(trace_setclassvariable),
+    LABEL_PTR(trace_getconstant),
+    LABEL_PTR(trace_setconstant),
+    LABEL_PTR(trace_getglobal),
+    LABEL_PTR(trace_setglobal),
+    LABEL_PTR(trace_putnil),
+    LABEL_PTR(trace_putself),
+    LABEL_PTR(trace_putobject),
+    LABEL_PTR(trace_putspecialobject),
+    LABEL_PTR(trace_putiseq),
+    LABEL_PTR(trace_putstring),
+    LABEL_PTR(trace_concatstrings),
+    LABEL_PTR(trace_tostring),
+    LABEL_PTR(trace_freezestring),
+    LABEL_PTR(trace_toregexp),
+    LABEL_PTR(trace_intern),
+    LABEL_PTR(trace_newarray),
+    LABEL_PTR(trace_duparray),
+    LABEL_PTR(trace_expandarray),
+    LABEL_PTR(trace_concatarray),
+    LABEL_PTR(trace_splatarray),
+    LABEL_PTR(trace_newhash),
+    LABEL_PTR(trace_newrange),
+    LABEL_PTR(trace_pop),
+    LABEL_PTR(trace_dup),
+    LABEL_PTR(trace_dupn),
+    LABEL_PTR(trace_swap),
+    LABEL_PTR(trace_reverse),
+    LABEL_PTR(trace_reput),
+    LABEL_PTR(trace_topn),
+    LABEL_PTR(trace_setn),
+    LABEL_PTR(trace_adjuststack),
+    LABEL_PTR(trace_defined),
+    LABEL_PTR(trace_checkmatch),
+    LABEL_PTR(trace_checkkeyword),
+    LABEL_PTR(trace_tracecoverage),
+    LABEL_PTR(trace_defineclass),
+    LABEL_PTR(trace_send),
+    LABEL_PTR(trace_opt_str_freeze),
+    LABEL_PTR(trace_opt_str_uminus),
+    LABEL_PTR(trace_opt_newarray_max),
+    LABEL_PTR(trace_opt_newarray_min),
+    LABEL_PTR(trace_opt_send_without_block),
+    LABEL_PTR(trace_invokesuper),
+    LABEL_PTR(trace_invokeblock),
+    LABEL_PTR(trace_leave),
+    LABEL_PTR(trace_throw),
+    LABEL_PTR(trace_jump),
+    LABEL_PTR(trace_branchif),
+    LABEL_PTR(trace_branchunless),
+    LABEL_PTR(trace_branchnil),
+    LABEL_PTR(trace_branchiftype),
+    LABEL_PTR(trace_getinlinecache),
+    LABEL_PTR(trace_setinlinecache),
+    LABEL_PTR(trace_once),
+    LABEL_PTR(trace_opt_case_dispatch),
+    LABEL_PTR(trace_opt_plus),
+    LABEL_PTR(trace_opt_minus),
+    LABEL_PTR(trace_opt_mult),
+    LABEL_PTR(trace_opt_div),
+    LABEL_PTR(trace_opt_mod),
+    LABEL_PTR(trace_opt_eq),
+    LABEL_PTR(trace_opt_neq),
+    LABEL_PTR(trace_opt_lt),
+    LABEL_PTR(trace_opt_le),
+    LABEL_PTR(trace_opt_gt),
+    LABEL_PTR(trace_opt_ge),
+    LABEL_PTR(trace_opt_ltlt),
+    LABEL_PTR(trace_opt_aref),
+    LABEL_PTR(trace_opt_aset),
+    LABEL_PTR(trace_opt_aset_with),
+    LABEL_PTR(trace_opt_aref_with),
+    LABEL_PTR(trace_opt_length),
+    LABEL_PTR(trace_opt_size),
+    LABEL_PTR(trace_opt_empty_p),
+    LABEL_PTR(trace_opt_succ),
+    LABEL_PTR(trace_opt_not),
+    LABEL_PTR(trace_opt_regexpmatch1),
+    LABEL_PTR(trace_opt_regexpmatch2),
+    LABEL_PTR(trace_opt_call_c_function),
+    LABEL_PTR(trace_bitblt),
+    LABEL_PTR(trace_answer),
+    LABEL_PTR(trace_getlocal_OP__WC__0),
+    LABEL_PTR(trace_getlocal_OP__WC__1),
+    LABEL_PTR(trace_setlocal_OP__WC__0),
+    LABEL_PTR(trace_setlocal_OP__WC__1),
+    LABEL_PTR(trace_putobject_OP_INT2FIX_O_0_C_),
+    LABEL_PTR(trace_putobject_OP_INT2FIX_O_1_C_),
+};
+
+ASSERT_VM_INSTRUCTION_SIZE(insns_address_table);

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/builtin.h

@@ -56,6 +56,7 @@ static inline void rb_builtin_function_check_arity13(VALUE (*f)(rb_execution_con
 static inline void rb_builtin_function_check_arity14(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
 static inline void rb_builtin_function_check_arity15(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
 
+PUREFUNC(VALUE rb_vm_lvar_exposed(rb_execution_context_t *ec, int index));
 VALUE rb_vm_lvar_exposed(rb_execution_context_t *ec, int index);
 
 // __builtin_inline!

data/lib/debase/ruby_core_source/ruby-3.1.0-p0/ccan/build_assert/build_assert.h

@@ -0,0 +1,40 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_BUILD_ASSERT_H
+#define CCAN_BUILD_ASSERT_H
+
+/**
+ * BUILD_ASSERT - assert a build-time dependency.
+ * @cond: the compile-time condition which must be true.
+ *
+ * Your compile will fail if the condition isn't true, or can't be evaluated
+ * by the compiler.  This can only be used within a function.
+ *
+ * Example:
+ *	#include <stddef.h>
+ *	...
+ *	static char *foo_to_char(struct foo *foo)
+ *	{
+ *		// This code needs string to be at start of foo.
+ *		BUILD_ASSERT(offsetof(struct foo, string) == 0);
+ *		return (char *)foo;
+ *	}
+ */
+#define BUILD_ASSERT(cond) \
+	do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
+
+/**
+ * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
+ * @cond: the compile-time condition which must be true.
+ *
+ * Your compile will fail if the condition isn't true, or can't be evaluated
+ * by the compiler.  This can be used in an expression: its value is "0".
+ *
+ * Example:
+ *	#define foo_to_char(foo)					\
+ *		 ((char *)(foo)						\
+ *		  + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
+ */
+#define BUILD_ASSERT_OR_ZERO(cond) \
+	(sizeof(char [1 - 2*!(cond)]) - 1)
+
+#endif /* CCAN_BUILD_ASSERT_H */

data/lib/debase/ruby_core_source/ruby-3.1.0-p0/ccan/check_type/check_type.h

@@ -0,0 +1,63 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_CHECK_TYPE_H
+#define CCAN_CHECK_TYPE_H
+
+/**
+ * check_type - issue a warning or build failure if type is not correct.
+ * @expr: the expression whose type we should check (not evaluated).
+ * @type: the exact type we expect the expression to be.
+ *
+ * This macro is usually used within other macros to try to ensure that a macro
+ * argument is of the expected type.  No type promotion of the expression is
+ * done: an unsigned int is not the same as an int!
+ *
+ * check_type() always evaluates to 0.
+ *
+ * If your compiler does not support typeof, then the best we can do is fail
+ * to compile if the sizes of the types are unequal (a less complete check).
+ *
+ * Example:
+ *	// They should always pass a 64-bit value to _set_some_value!
+ *	#define set_some_value(expr)			\
+ *		_set_some_value((check_type((expr), uint64_t), (expr)))
+ */
+
+/**
+ * check_types_match - issue a warning or build failure if types are not same.
+ * @expr1: the first expression (not evaluated).
+ * @expr2: the second expression (not evaluated).
+ *
+ * This macro is usually used within other macros to try to ensure that
+ * arguments are of identical types.  No type promotion of the expressions is
+ * done: an unsigned int is not the same as an int!
+ *
+ * check_types_match() always evaluates to 0.
+ *
+ * If your compiler does not support typeof, then the best we can do is fail
+ * to compile if the sizes of the types are unequal (a less complete check).
+ *
+ * Example:
+ *	// Do subtraction to get to enclosing type, but make sure that
+ *	// pointer is of correct type for that member.
+ *	#define container_of(mbr_ptr, encl_type, mbr)			\
+ *		(check_types_match((mbr_ptr), &((encl_type *)0)->mbr),	\
+ *		 ((encl_type *)						\
+ *		  ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
+ */
+#if HAVE_TYPEOF
+#define check_type(expr, type)			\
+	((typeof(expr) *)0 != (type *)0)
+
+#define check_types_match(expr1, expr2)		\
+	((typeof(expr1) *)0 != (typeof(expr2) *)0)
+#else
+#include "ccan/build_assert/build_assert.h"
+/* Without typeof, we can only test the sizes. */
+#define check_type(expr, type)					\
+	BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
+
+#define check_types_match(expr1, expr2)				\
+	BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
+#endif /* HAVE_TYPEOF */
+
+#endif /* CCAN_CHECK_TYPE_H */

data/lib/debase/ruby_core_source/ruby-3.1.0-p0/ccan/container_of/container_of.h

@@ -0,0 +1,142 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_CONTAINER_OF_H
+#define CCAN_CONTAINER_OF_H
+#include "ccan/check_type/check_type.h"
+
+/**
+ * container_of - get pointer to enclosing structure
+ * @member_ptr: pointer to the structure member
+ * @containing_type: the type this member is within
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does pointer
+ * subtraction to return the pointer to the enclosing type.
+ *
+ * Example:
+ *	struct foo {
+ *		int fielda, fieldb;
+ *		// ...
+ *	};
+ *	struct info {
+ *		int some_other_field;
+ *		struct foo my_foo;
+ *	};
+ *
+ *	static struct info *foo_to_info(struct foo *foo)
+ *	{
+ *		return container_of(foo, struct info, my_foo);
+ *	}
+ */
+#define container_of(member_ptr, containing_type, member)		\
+	 ((containing_type *)						\
+	  ((char *)(member_ptr)						\
+	   - container_off(containing_type, member))			\
+	  + check_types_match(*(member_ptr), ((containing_type *)0)->member))
+
+
+/**
+ * container_of_or_null - get pointer to enclosing structure, or NULL
+ * @member_ptr: pointer to the structure member
+ * @containing_type: the type this member is within
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does pointer
+ * subtraction to return the pointer to the enclosing type, unless it
+ * is given NULL, in which case it also returns NULL.
+ *
+ * Example:
+ *	struct foo {
+ *		int fielda, fieldb;
+ *		// ...
+ *	};
+ *	struct info {
+ *		int some_other_field;
+ *		struct foo my_foo;
+ *	};
+ *
+ *	static struct info *foo_to_info_allowing_null(struct foo *foo)
+ *	{
+ *		return container_of_or_null(foo, struct info, my_foo);
+ *	}
+ */
+static inline char *container_of_or_null_(void *member_ptr, size_t offset)
+{
+	return member_ptr ? (char *)member_ptr - offset : NULL;
+}
+#define container_of_or_null(member_ptr, containing_type, member)	\
+	((containing_type *)						\
+	 container_of_or_null_(member_ptr,				\
+			       container_off(containing_type, member))	\
+	 + check_types_match(*(member_ptr), ((containing_type *)0)->member))
+
+/**
+ * container_off - get offset to enclosing structure
+ * @containing_type: the type this member is within
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does
+ * typechecking and figures out the offset to the enclosing type.
+ *
+ * Example:
+ *	struct foo {
+ *		int fielda, fieldb;
+ *		// ...
+ *	};
+ *	struct info {
+ *		int some_other_field;
+ *		struct foo my_foo;
+ *	};
+ *
+ *	static struct info *foo_to_info(struct foo *foo)
+ *	{
+ *		size_t off = container_off(struct info, my_foo);
+ *		return (void *)((char *)foo - off);
+ *	}
+ */
+#define container_off(containing_type, member)	\
+	offsetof(containing_type, member)
+
+/**
+ * container_of_var - get pointer to enclosing structure using a variable
+ * @member_ptr: pointer to the structure member
+ * @container_var: a pointer of same type as this member's container
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does pointer
+ * subtraction to return the pointer to the enclosing type.
+ *
+ * Example:
+ *	static struct info *foo_to_i(struct foo *foo)
+ *	{
+ *		struct info *i = container_of_var(foo, i, my_foo);
+ *		return i;
+ *	}
+ */
+#if HAVE_TYPEOF
+#define container_of_var(member_ptr, container_var, member) \
+	container_of(member_ptr, typeof(*container_var), member)
+#else
+#define container_of_var(member_ptr, container_var, member)	\
+	((void *)((char *)(member_ptr)	-			\
+		  container_off_var(container_var, member)))
+#endif
+
+/**
+ * container_off_var - get offset of a field in enclosing structure
+ * @container_var: a pointer to a container structure
+ * @member: the name of a member within the structure.
+ *
+ * Given (any) pointer to a structure and a its member name, this
+ * macro does pointer subtraction to return offset of member in a
+ * structure memory layout.
+ *
+ */
+#if HAVE_TYPEOF
+#define container_off_var(var, member)		\
+	container_off(typeof(*var), member)
+#else
+#define container_off_var(var, member)			\
+	((const char *)&(var)->member - (const char *)(var))
+#endif
+
+#endif /* CCAN_CONTAINER_OF_H */

data/lib/debase/ruby_core_source/ruby-3.1.0-p0/ccan/str/str.h

@@ -0,0 +1,16 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_STR_H
+#define CCAN_STR_H
+/**
+ * stringify - Turn expression into a string literal
+ * @expr: any C expression
+ *
+ * Example:
+ *	#define PRINT_COND_IF_FALSE(cond) \
+ *		((cond) || printf("%s is false!", stringify(cond)))
+ */
+#define stringify(expr)		stringify_1(expr)
+/* Double-indirection required to stringify expansions */
+#define stringify_1(expr)	#expr
+
+#endif /* CCAN_STR_H */

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/debug_counter.h

@@ -97,6 +97,8 @@ RB_DEBUG_COUNTER(ccf_bmethod)
 RB_DEBUG_COUNTER(ccf_opt_send)
 RB_DEBUG_COUNTER(ccf_opt_call)
 RB_DEBUG_COUNTER(ccf_opt_block_call)
+RB_DEBUG_COUNTER(ccf_opt_struct_aref)
+RB_DEBUG_COUNTER(ccf_opt_struct_aset)
 RB_DEBUG_COUNTER(ccf_super_method)
 
 /*

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/eval_intern.h

@@ -173,11 +173,30 @@ rb_ec_tag_jump(const rb_execution_context_t *ec, enum ruby_tag_type st)
 
 #define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
 #define CREF_FL_OMOD_SHARED    IMEMO_FL_USER2
+#define CREF_FL_SINGLETON      IMEMO_FL_USER3
+
+static inline int CREF_SINGLETON(const rb_cref_t *cref);
 
 static inline VALUE
 CREF_CLASS(const rb_cref_t *cref)
 {
-    return cref->klass;
+    if (CREF_SINGLETON(cref)) {
+        return CLASS_OF(cref->klass_or_self);
+    }
+    else {
+        return cref->klass_or_self;
+    }
+}
+
+static inline VALUE
+CREF_CLASS_FOR_DEFINITION(const rb_cref_t *cref)
+{
+    if (CREF_SINGLETON(cref)) {
+        return rb_singleton_class(cref->klass_or_self);
+    }
+    else {
+        return cref->klass_or_self;
+    }
 }
 
 static inline rb_cref_t *
@@ -216,6 +235,18 @@ CREF_PUSHED_BY_EVAL_SET(rb_cref_t *cref)
     cref->flags |= CREF_FL_PUSHED_BY_EVAL;
 }
 
+static inline int
+CREF_SINGLETON(const rb_cref_t *cref)
+{
+    return cref->flags & CREF_FL_SINGLETON;
+}
+
+static inline void
+CREF_SINGLETON_SET(rb_cref_t *cref)
+{
+    cref->flags |= CREF_FL_SINGLETON;
+}
+
 static inline int
 CREF_OMOD_SHARED(const rb_cref_t *cref)
 {

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/gc.h

@@ -127,7 +127,6 @@ void rb_objspace_reachable_objects_from_root(void (func)(const char *category, V
 int rb_objspace_markable_object_p(VALUE obj);
 int rb_objspace_internal_object_p(VALUE obj);
 int rb_objspace_marked_object_p(VALUE obj);
-int rb_objspace_garbage_object_p(VALUE obj);
 
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/insns.inc

@@ -62,7 +62,7 @@ enum ruby_vminsn_type {
     BIN(putspecialobject),
     BIN(putstring),
     BIN(concatstrings),
-    BIN(tostring),
+    BIN(anytostring),
     BIN(toregexp),
     BIN(intern),
     BIN(newarray),
@@ -90,6 +90,7 @@ enum ruby_vminsn_type {
     BIN(definesmethod),
     BIN(send),
     BIN(opt_send_without_block),
+    BIN(objtostring),
     BIN(opt_str_freeze),
     BIN(opt_nil_p),
     BIN(opt_str_uminus),
@@ -162,7 +163,7 @@ enum ruby_vminsn_type {
     BIN(trace_putspecialobject),
     BIN(trace_putstring),
     BIN(trace_concatstrings),
-    BIN(trace_tostring),
+    BIN(trace_anytostring),
     BIN(trace_toregexp),
     BIN(trace_intern),
     BIN(trace_newarray),
@@ -190,6 +191,7 @@ enum ruby_vminsn_type {
     BIN(trace_definesmethod),
     BIN(trace_send),
     BIN(trace_opt_send_without_block),
+    BIN(trace_objtostring),
     BIN(trace_opt_str_freeze),
     BIN(trace_opt_nil_p),
     BIN(trace_opt_str_uminus),