Better printing of robject.

Author: samuel-williams-shopify

data/toolbox/heap.py

@@ -531,8 +531,18 @@ def _parse_type(self, type_arg):
 		"""
 		import constants
 
-		# Try as a constant name first
-		type_value = constants.get(type_arg)
+		# Try as a Ruby type constant (RUBY_T_*) first, using defaults table
+		if type_arg.startswith('RUBY_T_'):
+			try:
+				return constants.type(type_arg)
+			except Exception:
+				pass
+		
+		# Try as a general constant name
+		try:
+			type_value = constants.get(type_arg)
+		except Exception:
+			type_value = None
 
 		if type_value is None:
 			# Try parsing as a number (hex or decimal)

data/toolbox/print.py

@@ -15,6 +15,7 @@
 import rfloat
 import rbignum
 import rbasic
+import robject
 import format
 
 

data/toolbox/robject.py

@@ -0,0 +1,210 @@
+import debugger
+import constants
+import format
+import rclass
+
+
+class RObjectBase:
+	"""Base class for Ruby T_OBJECT instances (regular class instances like User.new)."""
+	
+	def __init__(self, value):
+		"""value is a VALUE pointing to a T_OBJECT."""
+		self.value = value
+		self.basic = value.cast(constants.type_struct('struct RBasic').pointer())
+		self.flags = int(self.basic.dereference()['flags'])
+		self._class_name = None
+	
+	@property
+	def class_name(self):
+		if self._class_name is None:
+			try:
+				klass = self.basic['klass']
+				self._class_name = rclass.get_class_name(klass)
+			except Exception:
+				self._class_name = f"#<Class:0x{int(self.value):x}>"
+		return self._class_name
+	
+	def numiv(self):
+		"""Get the number of instance variables. Subclasses must implement."""
+		raise NotImplementedError
+	
+	def ivptr(self):
+		"""Get pointer to instance variable values. Subclasses must implement."""
+		raise NotImplementedError
+	
+	def __str__(self):
+		addr = int(self.value)
+		n = self.numiv()
+		if n > 0:
+			return f"<{self.class_name}@0x{addr:x} ivars={n}>"
+		return f"<{self.class_name}@0x{addr:x}>"
+	
+	def print_to(self, terminal):
+		addr = int(self.value)
+		n = self.numiv()
+		details = f"ivars={n}" if n > 0 else None
+		terminal.print_type_tag(self.class_name, addr, details)
+	
+	def print_recursive(self, printer, depth):
+		printer.print(self)
+		
+		n = self.numiv()
+		if depth <= 0 or n <= 0:
+			return
+		
+		ptr = self.ivptr()
+		if ptr is None:
+			return
+		
+		for i in range(n):
+			try:
+				printer.print_item_label(printer.max_depth - depth, i)
+				printer.print_value(ptr[i], depth - 1)
+			except Exception:
+				break
+
+
+class RObjectEmbedded(RObjectBase):
+	"""T_OBJECT with instance variables stored inline (small objects)."""
+	
+	def __init__(self, value, robject):
+		super().__init__(value)
+		self.robject = robject
+		self._numiv = None
+	
+	def numiv(self):
+		if self._numiv is not None:
+			return self._numiv
+		
+		try:
+			# Try shape-based numiv (Ruby 3.4+)
+			self._numiv = self._numiv_from_shape()
+			if self._numiv is not None:
+				return self._numiv
+		except Exception:
+			pass
+		
+		# Fallback: count non-zero slots in the embedded array
+		self._numiv = self._count_embedded_slots()
+		return self._numiv
+	
+	def _numiv_from_shape(self):
+		"""Try to get ivar count from the object's shape (Ruby 3.4+)."""
+		try:
+			shape_id_mask = 0xFFFF  # shape_id is in bits 16..31 of flags typically
+			# In Ruby 3.4+, shape_id_t is stored in flags
+			# SHAPE_FLAG_SHIFT is typically 16
+			shape_id = (self.flags >> 16) & 0xFFFF
+			if shape_id == 0:
+				return 0
+			
+			# Try to read from shape table
+			shape_list = debugger.parse_and_eval('rb_shape_tree.shape_list')
+			shape = shape_list[shape_id]
+			next_iv = int(shape['next_iv'])
+			return next_iv
+		except Exception:
+			return None
+	
+	def _count_embedded_slots(self):
+		"""Count non-Qundef/non-zero slots in the embedded array."""
+		try:
+			ary = self.robject.dereference()['as']['ary']
+			count = 0
+			# ROBJECT_EMBED_LEN_MAX is typically 3 (Ruby 3.2) or varies by slot size
+			for i in range(12):
+				try:
+					val = int(ary[i])
+					if val == 0 or val == 0x34:  # Qundef
+						break
+					count += 1
+				except Exception:
+					break
+			return count
+		except Exception:
+			return 0
+	
+	def ivptr(self):
+		try:
+			return self.robject.dereference()['as']['ary']
+		except Exception:
+			return None
+
+
+class RObjectHeap(RObjectBase):
+	"""T_OBJECT with instance variables stored on the heap (many ivars)."""
+	
+	def __init__(self, value, robject):
+		super().__init__(value)
+		self.robject = robject
+		self._numiv = None
+	
+	def numiv(self):
+		if self._numiv is not None:
+			return self._numiv
+		
+		try:
+			self._numiv = int(self.robject.dereference()['as']['heap']['numiv'])
+		except Exception:
+			self._numiv = 0
+		return self._numiv
+	
+	def ivptr(self):
+		try:
+			return self.robject.dereference()['as']['heap']['ivptr']
+		except Exception:
+			return None
+
+
+class RObjectGeneric(RObjectBase):
+	"""Fallback T_OBJECT when struct RObject is unavailable or has unknown layout."""
+	
+	def numiv(self):
+		return 0
+	
+	def ivptr(self):
+		return None
+
+
+def RObject(value):
+	"""Factory function that detects the RObject variant and returns the appropriate instance.
+	
+	Caller should ensure value is a RUBY_T_OBJECT before calling.
+	"""
+	try:
+		robject = value.cast(constants.type_struct('struct RObject').pointer())
+	except Exception:
+		return RObjectGeneric(value)
+	
+	# Detect embedded vs heap storage
+	try:
+		FL_USER1 = constants.flag('RUBY_FL_USER1')
+		basic = value.cast(constants.type_struct('struct RBasic').pointer())
+		flags = int(basic.dereference()['flags'])
+		
+		if flags & FL_USER1:
+			# ROBJECT_EMBED flag set — ivars are inline
+			return RObjectEmbedded(value, robject)
+		else:
+			# Heap-allocated ivars
+			return RObjectHeap(value, robject)
+	except Exception:
+		pass
+	
+	# Feature detection: check what fields exist
+	try:
+		as_union = robject.dereference()['as']
+		if as_union is not None:
+			heap = as_union['heap']
+			if heap is not None:
+				numiv_field = heap['numiv']
+				if numiv_field is not None:
+					return RObjectHeap(value, robject)
+			
+			ary = as_union['ary']
+			if ary is not None:
+				return RObjectEmbedded(value, robject)
+	except Exception:
+		pass
+	
+	return RObjectGeneric(value)

data/toolbox/rvalue.py

@@ -11,6 +11,7 @@
 import rhash
 import rstruct
 import rbignum
+import robject
 
 class RImmediate:
 	"""Wrapper for Ruby immediate values (fixnum, nil, true, false)."""
@@ -174,6 +175,8 @@ def interpret(value):
 			return rfloat.RFloat(value)
 		elif type_flag == constants.type("RUBY_T_BIGNUM"):
 			return rbignum.RBignum(value)
+		elif type_flag == constants.type("RUBY_T_OBJECT"):
+			return robject.RObject(value)
 		else:
 			# Unknown type - return generic RBasic
 			return rbasic.RBasic(value)

fixtures/toolbox/gdb/object/can_print_t_object.gdb

@@ -0,0 +1,23 @@
+# Test printing T_OBJECT (regular class instance)
+
+# Reduce GDB verbosity
+set verbose off
+set confirm off
+set pagination off
+set print thread-events off
+
+source data/toolbox/init.py
+
+# Enable pending breakpoints (for when symbols load from shared libraries)
+set breakpoint pending on
+
+# Break at the point where puts is called
+break rb_f_puts
+run
+
+echo ===TOOLBOX-OUTPUT-START===\n
+rb-heap-scan --type RUBY_T_OBJECT --limit 1
+rb-print $heap0
+echo ===TOOLBOX-OUTPUT-END===\n
+
+quit

fixtures/toolbox/gdb/object/can_print_t_object.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+object = Object.new
+puts object

fixtures/toolbox/gdb/object/can_print_t_object.txt

@@ -0,0 +1,10 @@
+Scanning heap for type 0x..., limit=1...
+
+Found 1 object(s):
+
+  [0] $heap0 = <Object@...>
+
+Objects saved in $heap0 through $heap0
+Next scan address saved to $heap: 0x...
+Run "..." for next page
+<Object@...>

fixtures/toolbox/lldb/object/can_print_t_object.lldb

@@ -0,0 +1,13 @@
+# Test printing T_OBJECT (regular class instance)
+
+command script import data/toolbox/init.py
+
+b rb_f_puts
+run
+
+script print("===TOOLBOX-OUTPUT-START===")
+rb-heap-scan --type RUBY_T_OBJECT --limit 1
+rb-print $heap0
+script print("===TOOLBOX-OUTPUT-END===")
+
+quit

fixtures/toolbox/lldb/object/can_print_t_object.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+object = Object.new
+puts object

fixtures/toolbox/lldb/object/can_print_t_object.txt

@@ -0,0 +1,10 @@
+Scanning heap for type 0x..., limit=1...
+
+Found 1 object(s):
+
+  [0] $heap0 = <Object@...>
+
+Objects saved in $heap0 through $heap0
+Next scan address saved to $heap: 0x...
+Run "..." for next page
+<Object@...>