ruby-gdb 0.1.0

data/data/ruby/gdb/rarray.py

@@ -0,0 +1,124 @@
+import gdb
+import rbasic
+import constants
+import format
+
+class RArrayBase:
+	"""Base class for RArray variants."""
+	
+	def __init__(self, value):
+		"""value is a VALUE pointing to a T_ARRAY object."""
+		self.value = value
+		self.rarray = value.cast(constants.get_type('struct RArray').pointer())
+		self.basic = value.cast(constants.get_type('struct RBasic').pointer())
+		self.flags = int(self.basic.dereference()['flags'])
+	
+	def length(self):
+		"""Get array length. Must be implemented by subclasses."""
+		raise NotImplementedError
+	
+	def items_ptr(self):
+		"""Get pointer to array items. Must be implemented by subclasses."""
+		raise NotImplementedError
+	
+	def get_item(self, index):
+		"""Get item at index."""
+		if index < 0 or index >= self.length():
+			raise IndexError(f"Index {index} out of range")
+		items = self.items_ptr()
+		return items[index]
+	
+	def __len__(self):
+		"""Support len() function."""
+		return self.length()
+	
+	def __getitem__(self, index):
+		"""Support indexing."""
+		return self.get_item(index)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this array recursively."""
+		# Print the array header
+		printer.print(self)
+		
+		# If depth is 0, don't recurse into elements
+		if depth <= 0:
+			if len(self) > 0:
+				printer.print_with_indent(printer.max_depth - depth, "  ...")
+			return
+		
+		# Print each element
+		for i in range(len(self)):
+			printer.print_item_label(printer.max_depth - depth, i)
+			try:
+				element = self[i]
+				printer.print_value(element, depth - 1)
+			except Exception as e:
+				print(f"Error accessing element {i}: {e}")
+
+class RArrayEmbedded(RArrayBase):
+	"""Embedded array (small arrays stored directly in struct)."""
+	
+	def length(self):
+		# Extract length from flags using Ruby's encoding
+		# Length is stored in RUBY_FL_USER3|RUBY_FL_USER4 bits, shifted by RUBY_FL_USHIFT+3
+		mask = constants.get("RUBY_FL_USER3") | constants.get("RUBY_FL_USER4")
+		shift = constants.get("RUBY_FL_USHIFT") + 3
+		return (self.flags & mask) >> shift
+	
+	def items_ptr(self):
+		return self.rarray.dereference()['as']['ary']
+	
+	def __str__(self):
+		"""Return string representation of array."""
+		addr = int(self.value)
+		return f"<T_ARRAY@0x{addr:x} embedded length={len(self)}>"
+	
+	def print_to(self, terminal):
+		"""Print this array with formatting."""
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<',
+			format.type, 'T_ARRAY',
+			format.metadata, f'@0x{addr:x} embedded length={len(self)}>',
+			format.reset
+		)
+
+class RArrayHeap(RArrayBase):
+	"""Heap array (larger arrays with separate memory allocation)."""
+	
+	def length(self):
+		return int(self.rarray.dereference()['as']['heap']['len'])
+	
+	def items_ptr(self):
+		return self.rarray.dereference()['as']['heap']['ptr']
+	
+	def __str__(self):
+		"""Return string representation of array."""
+		addr = int(self.value)
+		return f"<T_ARRAY@0x{addr:x} heap length={len(self)}>"
+	
+	def print_to(self, terminal):
+		"""Print this array with formatting."""
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<',
+			format.type, 'T_ARRAY',
+			format.metadata, f'@0x{addr:x} heap length={len(self)}>',
+			format.reset
+		)
+
+def RArray(value):
+	"""Factory function that returns the appropriate RArray variant.
+	
+	Caller should ensure value is a RUBY_T_ARRAY before calling this function.
+	"""
+	# Get flags to determine embedded vs heap
+	basic = value.cast(constants.get_type('struct RBasic').pointer())
+	flags = int(basic.dereference()['flags'])
+	
+	# Check if array is embedded or heap-allocated using flags
+	if (flags & constants.get("RARRAY_EMBED_FLAG")) != 0:
+		return RArrayEmbedded(value)
+	else:
+		return RArrayHeap(value)

data/data/ruby/gdb/rbasic.py

@@ -0,0 +1,103 @@
+import gdb
+import constants
+import format
+
+def type_of(value):
+	"""Get the Ruby type of a VALUE.
+	
+	Returns the RUBY_T_* constant value (e.g., RUBY_T_STRING, RUBY_T_ARRAY),
+	or None if the type cannot be determined.
+	"""
+	basic = value.cast(constants.get_type('struct RBasic').pointer())
+	flags = int(basic.dereference()['flags'])
+	RUBY_T_MASK = constants.get('RUBY_T_MASK')
+	return flags & RUBY_T_MASK
+
+def is_type(value, ruby_type_constant):
+	"""Check if a VALUE is of a specific Ruby type.
+	
+	Arguments:
+		value: The GDB value to check
+		ruby_type_constant: String name of the constant (e.g., 'RUBY_T_STRING')
+	
+	Returns:
+		True if the value is of the specified type, False otherwise
+	"""
+	type_flag = type_of(value)
+	expected_type = constants.get(ruby_type_constant)
+	return type_flag == expected_type
+
+# Map of type constants to their names for display
+TYPE_NAMES = {
+	'RUBY_T_NONE': 'None',
+	'RUBY_T_OBJECT': 'Object',
+	'RUBY_T_CLASS': 'Class',
+	'RUBY_T_MODULE': 'Module',
+	'RUBY_T_FLOAT': 'Float',
+	'RUBY_T_STRING': 'String',
+	'RUBY_T_REGEXP': 'Regexp',
+	'RUBY_T_ARRAY': 'Array',
+	'RUBY_T_HASH': 'Hash',
+	'RUBY_T_STRUCT': 'Struct',
+	'RUBY_T_BIGNUM': 'Bignum',
+	'RUBY_T_FILE': 'File',
+	'RUBY_T_DATA': 'Data',
+	'RUBY_T_MATCH': 'Match',
+	'RUBY_T_COMPLEX': 'Complex',
+	'RUBY_T_RATIONAL': 'Rational',
+	'RUBY_T_NIL': 'Nil',
+	'RUBY_T_TRUE': 'True',
+	'RUBY_T_FALSE': 'False',
+	'RUBY_T_SYMBOL': 'Symbol',
+	'RUBY_T_FIXNUM': 'Fixnum',
+	'RUBY_T_UNDEF': 'Undef',
+	'RUBY_T_IMEMO': 'IMemo',
+	'RUBY_T_NODE': 'Node',
+	'RUBY_T_ICLASS': 'IClass',
+	'RUBY_T_ZOMBIE': 'Zombie',
+}
+
+def type_name(value):
+	"""Get the human-readable type name for a VALUE.
+	
+	Returns:
+		String like 'String', 'Array', 'Hash', etc., or 'Unknown'
+	"""
+	type_flag = type_of(value)
+	
+	# Try to find matching type name
+	for const_name, display_name in TYPE_NAMES.items():
+		if constants.get(const_name) == type_flag:
+			return display_name
+	
+	return f'Unknown(0x{type_flag:x})'
+
+class RBasic:
+	"""Generic Ruby object wrapper for unhandled types.
+	
+	This provides a fallback for types that don't have specialized handlers.
+	"""
+	def __init__(self, value):
+		self.value = value
+		self.basic = value.cast(constants.get_type('struct RBasic').pointer())
+		self.flags = int(self.basic.dereference()['flags'])
+		self.type_flag = self.flags & constants.get('RUBY_T_MASK')
+	
+	def __str__(self):
+		type_str = type_name(self.value)
+		return f"<{type_str}:0x{int(self.value):x}>"
+	
+	def print_to(self, terminal):
+		"""Return formatted basic object representation."""
+		type_str = type_name(self.value)
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<',
+			format.type, type_str,
+			format.metadata, f':0x{addr:x}>',
+			format.reset
+		)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this basic object (no recursion)."""
+		printer.print(self)

data/data/ruby/gdb/rbignum.py

@@ -0,0 +1,52 @@
+import gdb
+import constants
+import rbasic
+import format
+
+class RBignumObject:
+	def __init__(self, value):
+		self.value = value
+		self.rbignum = value.cast(constants.get_type('struct RBignum').pointer())
+		self.basic = value.cast(constants.get_type('struct RBasic').pointer())
+		self.flags = int(self.basic.dereference()['flags'])
+	
+	def is_embedded(self):
+		# Check if FL_USER1 flag is set (RBIGNUM_EMBED_FLAG)
+		FL_USER1 = 1 << (constants.get('RUBY_FL_USHIFT', 12) + 1)
+		return bool(self.flags & FL_USER1)
+	
+	def __len__(self):
+		if self.is_embedded():
+			# Embedded length is stored in flags
+			# Extract length from FL_USER2 onwards
+			return (self.flags >> (constants.get('RUBY_FL_USHIFT', 12) + 2)) & 0x1F
+		else:
+			return int(self.rbignum.dereference()['as']['heap']['len'])
+	
+	def __str__(self):
+		addr = int(self.value)
+		if self.is_embedded():
+			return f"<T_BIGNUM@0x{addr:x} embedded length={len(self)}>"
+		else:
+			return f"<T_BIGNUM@0x{addr:x} heap length={len(self)}>"
+	
+	def print_to(self, terminal):
+		"""Return formatted bignum representation."""
+		addr = int(self.value)
+		storage = "embedded" if self.is_embedded() else "heap"
+		return terminal.print(
+			format.metadata, '<',
+			format.type, 'T_BIGNUM',
+			format.metadata, f'@0x{addr:x} {storage} length={len(self)}>',
+			format.reset
+		)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this bignum (no recursion needed)."""
+		printer.print(self)
+
+def RBignum(value):
+	if rbasic.is_type(value, 'RUBY_T_BIGNUM'):
+		return RBignumObject(value)
+	
+	return None

data/data/ruby/gdb/rclass.py

@@ -0,0 +1,133 @@
+import gdb
+import constants
+import value
+import rstring
+
+class RClass:
+	"""Wrapper for Ruby class objects (klass pointers)."""
+	
+	def __init__(self, klass_value):
+		"""Initialize with a klass VALUE.
+		
+		Args:
+			klass_value: A GDB value representing a Ruby class (klass pointer)
+		"""
+		self.klass = klass_value
+		self._name = None
+	
+	def name(self):
+		"""Get the class name as a string.
+		
+		Returns:
+			Class name string, or formatted anonymous class representation
+		"""
+		if self._name is None:
+			self._name = self._get_class_name()
+		return self._name
+	
+	def _get_class_name(self):
+		"""Extract class name from klass pointer.
+		
+		Tries multiple strategies across Ruby versions:
+		1. Check against well-known global class pointers (rb_eStandardError, etc.)
+		2. Try rb_classext_struct.classpath (Ruby 3.4+)
+		3. Fall back to anonymous class format
+		
+		Returns:
+			Class name string
+		"""
+		try:
+			# Strategy 1: Check well-known exception classes
+			# This works in core dumps since we're just comparing pointers
+			well_known = [
+				('rb_eException', 'Exception'),
+				('rb_eStandardError', 'StandardError'),
+				('rb_eSystemExit', 'SystemExit'),
+				('rb_eInterrupt', 'Interrupt'),
+				('rb_eSignal', 'SignalException'),
+				('rb_eFatal', 'fatal'),
+				('rb_eScriptError', 'ScriptError'),
+				('rb_eLoadError', 'LoadError'),
+				('rb_eNotImpError', 'NotImplementedError'),
+				('rb_eSyntaxError', 'SyntaxError'),
+				('rb_eSecurityError', 'SecurityError'),
+				('rb_eNoMemError', 'NoMemoryError'),
+				('rb_eTypeError', 'TypeError'),
+				('rb_eArgError', 'ArgumentError'),
+				('rb_eIndexError', 'IndexError'),
+				('rb_eKeyError', 'KeyError'),
+				('rb_eRangeError', 'RangeError'),
+				('rb_eNameError', 'NameError'),
+				('rb_eNoMethodError', 'NoMethodError'),
+				('rb_eRuntimeError', 'RuntimeError'),
+				('rb_eFrozenError', 'FrozenError'),
+				('rb_eIOError', 'IOError'),
+				('rb_eEOFError', 'EOFError'),
+				('rb_eLocalJumpError', 'LocalJumpError'),
+				('rb_eSysStackError', 'SystemStackError'),
+				('rb_eRegexpError', 'RegexpError'),
+				('rb_eThreadError', 'ThreadError'),
+				('rb_eZeroDivError', 'ZeroDivisionError'),
+				('rb_eFloatDomainError', 'FloatDomainError'),
+				('rb_eStopIteration', 'StopIteration'),
+				('rb_eMathDomainError', 'Math::DomainError'),
+				('rb_eEncCompatError', 'Encoding::CompatibilityError'),
+			]
+			
+			klass_addr = int(self.klass)
+			for var_name, class_name in well_known:
+				try:
+					known_klass = gdb.parse_and_eval(var_name)
+					if int(known_klass) == klass_addr:
+						return class_name
+				except:
+					# Variable might not exist in this Ruby version
+					continue
+			
+			# Strategy 2: Try modern rb_classext_struct.classpath (Ruby 3.4+)
+			try:
+				rclass = self.klass.cast(gdb.lookup_type('struct RClass').pointer())
+				# Try to access classext.classpath
+				try:
+					# Try embedded classext (RCLASS_EXT_EMBEDDED)
+					classext_ptr = gdb.parse_and_eval(f"(rb_classext_t *)((char *){int(self.klass)} + sizeof(struct RClass))")
+					classpath_val = classext_ptr['classpath']
+				except:
+					# Try pointer-based classext
+					try:
+						classext_ptr = rclass['ptr']
+						classpath_val = classext_ptr['classpath']
+					except:
+						classpath_val = None
+				
+				if classpath_val and int(classpath_val) != 0 and not value.is_nil(classpath_val):
+					# Decode the classpath string
+					class_name_obj = value.interpret(classpath_val)
+					if hasattr(class_name_obj, 'to_str'):
+						class_name = class_name_obj.to_str()
+						if class_name and not class_name.startswith('<'):
+							return class_name
+			except:
+				pass
+			
+			# Strategy 3: Fall back to anonymous class format
+			return f"#<Class:0x{int(self.klass):x}>"
+		except Exception as e:
+			# Ultimate fallback
+			return f"#<Class:0x{int(self.klass):x}>"
+	
+	def __str__(self):
+		"""Return the class name."""
+		return self.name()
+
+def get_class_name(klass_value):
+	"""Get the name of a class from its klass pointer.
+	
+	Args:
+		klass_value: A GDB value representing a Ruby class (klass pointer)
+	
+	Returns:
+		Class name string
+	"""
+	rc = RClass(klass_value)
+	return rc.name()

data/data/ruby/gdb/rexception.py

@@ -0,0 +1,150 @@
+import gdb
+import constants
+import format
+import value
+import rstring
+import rclass
+
+class RException:
+	"""Wrapper for Ruby exception objects."""
+	
+	def __init__(self, exception_value):
+		"""Initialize with a Ruby exception VALUE.
+		
+		Args:
+			exception_value: A GDB value representing a Ruby exception object
+		"""
+		self.value = exception_value
+		self._basic = None
+		self._klass = None
+		self._class_name = None
+		self._message = None
+		
+		# Validate it's an object
+		if value.is_immediate(exception_value):
+			raise ValueError("Exception VALUE cannot be an immediate value")
+	
+	@property
+	def klass(self):
+		"""Get the exception's class (klass pointer)."""
+		if self._klass is None:
+			if self._basic is None:
+				self._basic = self.value.cast(constants.get_type('struct RBasic').pointer())
+			self._klass = self._basic['klass']
+		return self._klass
+	
+	@property
+	def class_name(self):
+		"""Get the exception class name as a string."""
+		if self._class_name is None:
+			self._class_name = self._get_class_name()
+		return self._class_name
+	
+	@property
+	def message(self):
+		"""Get the exception message as a string (None if unavailable)."""
+		if self._message is None:
+			self._message = self._get_message()
+		return self._message
+	
+	def _get_class_name(self):
+		"""Extract class name from klass pointer.
+		
+		Uses the rclass module to get the class name.
+		"""
+		try:
+			return rclass.get_class_name(self.klass)
+		except Exception:
+			# Fallback if we can't read the class
+			return f"Exception(klass=0x{int(self.klass):x})"
+	
+	def _get_message(self):
+		"""Extract message from exception object.
+		
+		Walks instance variables to find 'mesg' ivar.
+		Returns None if message is unavailable (common in core dumps).
+		"""
+		try:
+			# Exception objects store message in 'mesg' instance variable
+			# For now, return None as full ivar walking is complex
+			# TODO: Implement full instance variable walking for core dumps
+			return None
+		except Exception:
+			return None
+	
+	def __str__(self):
+		"""Return formatted string 'ClassName: message' or just 'ClassName'."""
+		class_name = self.class_name
+		msg = self.message
+		
+		if msg:
+			return f"{class_name}: {msg}"
+		else:
+			return class_name
+	
+	def print_to(self, terminal):
+		"""Print this exception with formatting to the given terminal."""
+		class_name = self.class_name
+		msg = self.message
+		
+		# Print class name with type formatting
+		class_output = terminal.print(
+			format.type, class_name,
+			format.reset
+		)
+		
+		if msg:
+			# Print message with string formatting
+			msg_output = terminal.print(
+				format.string, f': {msg}',
+				format.reset
+			)
+			return f"{class_output}{msg_output}"
+		else:
+			return class_output
+	
+	def print_recursive(self, printer, depth):
+		"""Print this exception (no recursion needed for exceptions)."""
+		printer.print(self)
+
+def is_exception(val):
+	"""Check if a VALUE is an exception object.
+	
+	Args:
+		val: A GDB value representing a Ruby VALUE
+	
+	Returns:
+		True if the value appears to be an exception object, False otherwise
+	"""
+	if not value.is_object(val):
+		return False
+	
+	try:
+		# Check if it's a T_OBJECT or T_DATA (exceptions can be either)
+		basic = val.cast(constants.get_type("struct RBasic").pointer())
+		flags = int(basic['flags'])
+		type_flag = flags & constants.get("RUBY_T_MASK")
+		
+		# Exceptions are typically T_OBJECT, but could also be T_DATA
+		t_object = constants.get("RUBY_T_OBJECT")
+		t_data = constants.get("RUBY_T_DATA")
+		
+		return type_flag == t_object or type_flag == t_data
+	except Exception:
+		return False
+
+def RExceptionFactory(val):
+	"""Factory function to create RException or return None.
+	
+	Args:
+		val: A GDB value representing a Ruby VALUE
+	
+	Returns:
+		RException instance if val is an exception, None otherwise
+	"""
+	if is_exception(val):
+		try:
+			return RException(val)
+		except Exception:
+			return None
+	return None

data/data/ruby/gdb/rfloat.py

@@ -0,0 +1,95 @@
+import gdb
+import constants
+import rbasic
+import struct
+import format
+
+class RFloatImmediate:
+	"""Flonum - immediate float encoding (Ruby 3.4+)"""
+	def __init__(self, value):
+		self.value = int(value)
+	
+	def float_value(self):
+		# Flonum decoding from Ruby's rb_float_flonum_value
+		# Special case for 0.0
+		if self.value == 0x8000000000000002:
+			return 0.0
+		
+		v = self.value
+		b63 = (v >> 63) & 1
+		# e: xx1... -> 011...
+		#    xx0... -> 100...
+		#      ^b63
+		adjusted = (2 - b63) | (v & ~0x03)
+		# RUBY_BIT_ROTR(x, 3) rotates right by 3 bits
+		# Which is: (x >> 3) | (x << (64 - 3))
+		rotated = ((adjusted >> 3) | (adjusted << 61)) & 0xFFFFFFFFFFFFFFFF
+		
+		# Pack as unsigned long long, then unpack as double
+		return struct.unpack('d', struct.pack('Q', rotated))[0]
+	
+	def __str__(self):
+		return f"<T_FLOAT> {self.float_value()}"
+	
+	def print_to(self, terminal):
+		"""Return formatted float representation."""
+		tag = terminal.print(
+			format.metadata, '<',
+			format.type, 'T_FLOAT',
+			format.metadata, '>',
+			format.reset
+		)
+		num_val = terminal.print(format.number, str(self.float_value()), format.reset)
+		return f"{tag} {num_val}"
+	
+	def print_recursive(self, printer, depth):
+		"""Print this float (no recursion needed)."""
+		printer.print(self)
+
+class RFloatObject:
+	"""Heap-allocated float object"""
+	def __init__(self, value):
+		self.value = value.cast(constants.get_type('struct RFloat'))
+	
+	def float_value(self):
+		return float(self.value['float_value'])
+	
+	def __str__(self):
+		addr = int(self.value.address)
+		return f"<T_FLOAT@0x{addr:x}> {self.float_value()}"
+	
+	def print_to(self, terminal):
+		"""Return formatted float representation."""
+		addr = int(self.value.address)
+		tag = terminal.print(
+			format.metadata, '<',
+			format.type, 'T_FLOAT',
+			format.metadata, f'@0x{addr:x}>',
+			format.reset
+		)
+		num_val = terminal.print(format.number, str(self.float_value()), format.reset)
+		return f"{tag} {num_val}"
+	
+	def print_recursive(self, printer, depth):
+		"""Print this float (no recursion needed)."""
+		printer.print(self)
+
+def is_flonum(value):
+	"""Check if value is an immediate flonum"""
+	val_int = int(value)
+	# FLONUM_MASK = 0x03, FLONUM_FLAG = 0x02
+	FLONUM_MASK = constants.get('RUBY_FLONUM_MASK', 0x03)
+	FLONUM_FLAG = constants.get('RUBY_FLONUM_FLAG', 0x02)
+	return (val_int & FLONUM_MASK) == FLONUM_FLAG
+
+def RFloat(value):
+	"""Factory function for float values - handles both flonums and heap objects"""
+	# Check for immediate flonum first
+	if is_flonum(value):
+		return RFloatImmediate(value)
+	
+	# Check for heap-allocated T_FLOAT
+	if rbasic.is_type(value, 'RUBY_T_FLOAT'):
+		return RFloatObject(value)
+	
+	return None