ruby-gdb 0.1.0

data/data/ruby/gdb/rhash.py

@@ -0,0 +1,157 @@
+import gdb
+import rbasic
+import constants
+import format
+
+class RHashBase:
+	"""Base class for RHash variants."""
+	
+	def __init__(self, value):
+		"""value is a VALUE pointing to a T_HASH object."""
+		self.value = value
+		self.rhash = value.cast(constants.get_type('struct RHash').pointer())
+		self.basic = value.cast(constants.get_type('struct RBasic').pointer())
+		self.flags = int(self.basic.dereference()['flags'])
+	
+	def size(self):
+		"""Get hash size. Must be implemented by subclasses."""
+		raise NotImplementedError
+	
+	def pairs(self):
+		"""Iterate over (key, value) pairs. Must be implemented by subclasses."""
+		raise NotImplementedError
+
+class RHashSTTable(RHashBase):
+	"""Hash using ST table structure (older or larger hashes)."""
+	
+	def __init__(self, value):
+		super().__init__(value)
+		# Calculate st_table pointer
+		rhash_size = gdb.parse_and_eval("sizeof(struct RHash)")
+		st_table_ptr = gdb.Value(int(value) + int(rhash_size))
+		self.st_table = st_table_ptr.cast(constants.get_type("st_table").pointer())
+	
+	def size(self):
+		return int(self.st_table.dereference()['num_entries'])
+	
+	def pairs(self):
+		"""Yield (key, value) pairs."""
+		num_entries = self.size()
+		for i in range(num_entries):
+			key = self.st_table.dereference()['entries'][i]['key']
+			value = self.st_table.dereference()['entries'][i]['record']
+			yield (key, value)
+	
+	def __str__(self):
+		"""Return string representation of hash."""
+		addr = int(self.value)
+		return f"<T_HASH@0x{addr:x} ST-Table entries={self.size()}>"
+	
+	def print_to(self, terminal):
+		"""Print this hash with formatting."""
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<', 
+			format.type, 'T_HASH',
+			format.metadata, f'@0x{addr:x} ST-Table entries={self.size()}>',
+			format.reset
+		)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this hash recursively."""
+		printer.print(self)
+		
+		if depth <= 0:
+			if self.size() > 0:
+				printer.print_with_indent(printer.max_depth - depth, "  ...")
+			return
+		
+		# Print each key-value pair
+		for i, (key, value) in enumerate(self.pairs()):
+			printer.print_key_label(printer.max_depth - depth, i)
+			printer.print_value(key, depth - 1)
+			printer.print_value_label(printer.max_depth - depth)
+			printer.print_value(value, depth - 1)
+
+class RHashARTable(RHashBase):
+	"""Hash using AR table structure (newer, smaller hashes)."""
+	
+	def __init__(self, value):
+		super().__init__(value)
+		# Feature detection: check if as.ar field exists (Ruby 3.2)
+		# vs embedded after RHash (Ruby 3.3+)
+		try:
+			# Try Ruby 3.2 layout: ar_table is accessed via as.ar pointer
+			self.ar_table = self.rhash.dereference()['as']['ar']
+		except (gdb.error, KeyError):
+			# Ruby 3.3+: ar_table is embedded directly after RHash structure
+			rhash_size = gdb.parse_and_eval("sizeof(struct RHash)")
+			ar_table_addr = int(self.rhash) + int(rhash_size)
+			ar_table_type = constants.get_type("struct ar_table_struct").pointer()
+			self.ar_table = gdb.Value(ar_table_addr).cast(ar_table_type)
+		
+		# Get array table size and bound from flags
+		self.ar_size = ((self.flags & constants.get("RHASH_AR_TABLE_SIZE_MASK")) >> constants.get("RHASH_AR_TABLE_SIZE_SHIFT"))
+		self.ar_bound = ((self.flags & constants.get("RHASH_AR_TABLE_BOUND_MASK")) >> constants.get("RHASH_AR_TABLE_BOUND_SHIFT"))
+	
+	def size(self):
+		return self.ar_size
+	
+	def bound(self):
+		"""Get the bound (capacity) of the AR table."""
+		return self.ar_bound
+	
+	def pairs(self):
+		"""Yield (key, value) pairs, skipping undefined/deleted entries."""
+		RUBY_Qundef = constants.get("RUBY_Qundef")
+		for i in range(int(self.ar_bound)):
+			key = self.ar_table.dereference()['pairs'][i]['key']
+			# Skip undefined/deleted entries
+			if int(key) != RUBY_Qundef:
+				value = self.ar_table.dereference()['pairs'][i]['val']
+				yield (key, value)
+	
+	def __str__(self):
+		"""Return string representation of hash."""
+		addr = int(self.value)
+		return f"<T_HASH@0x{addr:x} AR-Table size={self.size()} bound={self.bound()}>"
+	
+	def print_to(self, terminal):
+		"""Print this hash with formatting."""
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<',
+			format.type, 'T_HASH',
+			format.metadata, f'@0x{addr:x} AR-Table size={self.size()} bound={self.bound()}>',
+			format.reset
+		)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this hash recursively."""
+		printer.print(self)
+		
+		if depth <= 0:
+			if self.size() > 0:
+				printer.print_with_indent(printer.max_depth - depth, "  ...")
+			return
+		
+		# Print each key-value pair
+		for i, (key, value) in enumerate(self.pairs()):
+			printer.print_key_label(printer.max_depth - depth, i)
+			printer.print_value(key, depth - 1)
+			printer.print_value_label(printer.max_depth - depth)
+			printer.print_value(value, depth - 1)
+
+def RHash(value):
+	"""Factory function that returns the appropriate RHash variant.
+	
+	Caller should ensure value is a RUBY_T_HASH before calling this function.
+	"""
+	# Get flags to determine ST table vs AR table
+	basic = value.cast(constants.get_type('struct RBasic').pointer())
+	flags = int(basic.dereference()['flags'])
+	
+	if (flags & constants.get("RHASH_ST_TABLE_FLAG")) != 0:
+		return RHashSTTable(value)
+	else:
+		return RHashARTable(value)

data/data/ruby/gdb/rstring.py

@@ -0,0 +1,217 @@
+import gdb
+import rbasic
+import constants
+import format
+
+def _char_ptr_type():
+	"""Return char* type for GDB."""
+	return constants.get_type('char').pointer()
+
+class RStringBase:
+	"""Base class for RString variants with common functionality."""
+	
+	def __init__(self, value):
+		"""value is a VALUE pointing to a T_STRING object."""
+		self.value = value
+		self.rstring = value.cast(constants.get_type('struct RString').pointer())
+		self.basic = value.cast(constants.get_type('struct RBasic').pointer())
+		self.flags = int(self.basic.dereference()['flags'])
+	
+	def _is_embedded(self):
+		"""Check if string is embedded. Must be implemented by subclasses."""
+		raise NotImplementedError
+	
+	def length(self):
+		"""Get string length. Must be implemented by subclasses."""
+		raise NotImplementedError
+	
+	def data_ptr(self):
+		"""Get pointer to string data. Must be implemented by subclasses."""
+		raise NotImplementedError
+	
+	def read_bytes(self, max_fallback_scan=256):
+		"""Return (bytes, length). If declared length is 0, will fallback to scanning for NUL up to max_fallback_scan."""
+		pointer = self.data_ptr()
+		length = self.length()
+		
+		inferior = gdb.selected_inferior()
+		if length and length > 0:
+			return (inferior.read_memory(pointer, length).tobytes(), length)
+		
+		# Fallback: scan for NUL terminator when length is unavailable (e.g., symbol table strings)
+		buffer = inferior.read_memory(pointer, max_fallback_scan).tobytes()
+		n = buffer.find(b'\x00')
+		if n == -1:
+			n = max_fallback_scan
+		return (buffer[:n], n)
+	
+	def to_str(self, encoding='utf-8'):
+		"""Convert to Python string."""
+		data, length = self.read_bytes()
+		return data.decode(encoding, errors='replace')
+	
+	def __str__(self):
+		"""Return the string with type tag and metadata."""
+		addr = int(self.value)
+		storage = "embedded" if self._is_embedded() else "heap"
+		content = self.to_str()
+		return f"<T_STRING@0x{addr:x} {storage} length={self.length()}> {repr(content)}"
+	
+	def print_to(self, terminal):
+		"""Print this string with formatting."""
+		addr = int(self.value)
+		storage = "embedded" if self._is_embedded() else "heap"
+		content = self.to_str()
+		tag = terminal.print(
+			format.metadata, '<',
+			format.type, 'T_STRING',
+			format.metadata, f'@0x{addr:x} {storage} length={self.length()}>',
+			format.reset
+		)
+		# Use repr() to properly escape quotes, newlines, etc.
+		string_val = terminal.print(format.string, repr(content), format.reset)
+		return f"{tag} {string_val}"
+	
+	def print_recursive(self, printer, depth):
+		"""Print this string (no recursion needed for strings)."""
+		printer.print(self)
+
+class RString34(RStringBase):
+	"""Ruby 3.4+ strings: top-level len, as.embed.ary, FL_USER1 set = heap."""
+	
+	def _is_embedded(self):
+		FL_USER1 = constants.get('RUBY_FL_USER1', 1 << 13)
+		# FL_USER1 set => heap (not embedded)
+		return (self.flags & FL_USER1) == 0
+	
+	def length(self):
+		return int(self.rstring.dereference()['len'])
+	
+	def data_ptr(self):
+		if not self._is_embedded():
+			return self.rstring.dereference()['as']['heap']['ptr']
+		# Embedded: use as.embed.ary
+		ary = self.rstring.dereference()['as']['embed']['ary']
+		try:
+			if ary.type.code == gdb.TYPE_CODE_ARRAY:
+				return ary.address.cast(_char_ptr_type())
+			return ary
+		except Exception:
+			return ary.address.cast(_char_ptr_type())
+
+class RString33(RStringBase):
+	"""Ruby 3.3 strings: top-level len, as.embed.len exists, FL_USER1 set = embedded."""
+	
+	def _is_embedded(self):
+		FL_USER1 = constants.get('RUBY_FL_USER1', 1 << 13)
+		# FL_USER1 set => embedded
+		return (self.flags & FL_USER1) != 0
+	
+	def length(self):
+		return int(self.rstring.dereference()['len'])
+	
+	def data_ptr(self):
+		if not self._is_embedded():
+			return self.rstring.dereference()['as']['heap']['ptr']
+		# Embedded: use as.embed.ary
+		ary = self.rstring.dereference()['as']['embed']['ary']
+		try:
+			if ary.type.code == gdb.TYPE_CODE_ARRAY:
+				return ary.address.cast(_char_ptr_type())
+			return ary
+		except Exception:
+			return ary.address.cast(_char_ptr_type())
+
+class RString32RVARGC(RStringBase):
+	"""Ruby 3.2 with RVARGC: as.embed.len for embedded, as.embed.ary for data."""
+	
+	def _is_embedded(self):
+		FL_USER1 = constants.get('RUBY_FL_USER1', 1 << 13)
+		# FL_USER1 set => heap (not embedded)
+		return (self.flags & FL_USER1) == 0
+	
+	def length(self):
+		if self._is_embedded():
+			return int(self.rstring.dereference()['as']['embed']['len'])
+		else:
+			return int(self.rstring.dereference()['as']['heap']['len'])
+	
+	def data_ptr(self):
+		if not self._is_embedded():
+			return self.rstring.dereference()['as']['heap']['ptr']
+		# Embedded: use as.embed.ary
+		ary = self.rstring.dereference()['as']['embed']['ary']
+		try:
+			if ary.type.code == gdb.TYPE_CODE_ARRAY:
+				return ary.address.cast(_char_ptr_type())
+			return ary
+		except Exception:
+			return ary.address.cast(_char_ptr_type())
+
+class RString32Legacy(RStringBase):
+	"""Legacy Ruby 3.2: embedded length in FL_USER2..6, data in as.ary."""
+	
+	def _is_embedded(self):
+		FL_USER1 = constants.get('RUBY_FL_USER1', 1 << 13)
+		# FL_USER1 set => heap (not embedded)
+		return (self.flags & FL_USER1) == 0
+	
+	def length(self):
+		if self._is_embedded():
+			FL2 = constants.get('RUBY_FL_USER2')
+			FL3 = constants.get('RUBY_FL_USER3')
+			FL4 = constants.get('RUBY_FL_USER4')
+			FL5 = constants.get('RUBY_FL_USER5')
+			FL6 = constants.get('RUBY_FL_USER6')
+			USHIFT = constants.get('RUBY_FL_USHIFT')
+			mask = FL2 | FL3 | FL4 | FL5 | FL6
+			return (self.flags & mask) >> (USHIFT + 2)
+		else:
+			return int(self.rstring.dereference()['as']['heap']['len'])
+	
+	def data_ptr(self):
+		if not self._is_embedded():
+			return self.rstring.dereference()['as']['heap']['ptr']
+		# Embedded: use as.ary (not as.embed.ary)
+		ary = self.rstring.dereference()['as']['ary']
+		try:
+			if ary.type.code == gdb.TYPE_CODE_ARRAY:
+				return ary.address.cast(_char_ptr_type())
+			return ary
+		except Exception:
+			return ary.address.cast(_char_ptr_type())
+
+def RString(value):
+	"""Factory function that detects the RString variant and returns the appropriate instance.
+	
+	Caller should ensure value is a RUBY_T_STRING before calling this function.
+	
+	Detects at runtime whether the process uses:
+	- Ruby 3.4+: top-level len field, as.embed.ary (no embed.len), FL_USER1 set = heap
+	- Ruby 3.3: top-level len field, as.embed.len exists, FL_USER1 set = embedded
+	- Ruby 3.2 with RVARGC: as.embed.len for embedded, as.embed.ary for data
+	- Legacy 3.2: embedded length in FL_USER2..6, data in as.ary
+	"""
+	rstring = value.cast(constants.get_type('struct RString').pointer())
+	
+	# Try top-level len field (Ruby 3.3+/3.4+)
+	try:
+		_ = rstring.dereference()['len']
+		# Now check if embed structure has len field (3.3) or just ary (3.4+)
+		try:
+			_ = rstring.dereference()['as']['embed']['len']
+			return RString33(value)
+		except Exception:
+			return RString34(value)
+	except Exception:
+		pass
+	
+	# Try RVARGC embedded len field (3.2 RVARGC)
+	try:
+		_ = rstring.dereference()['as']['embed']['len']
+		return RString32RVARGC(value)
+	except Exception:
+		pass
+	
+	# Fallback to legacy 3.2
+	return RString32Legacy(value)

data/data/ruby/gdb/rstruct.py

@@ -0,0 +1,157 @@
+import gdb
+import rbasic
+import constants
+import format
+
+
+class RStructBase:
+	"""Base class for Ruby struct variants."""
+	
+	def __init__(self, value):
+		"""value is a VALUE pointing to a T_STRUCT object."""
+		self.value = value
+		self.rstruct = value.cast(constants.get_type('struct RStruct').pointer())
+	
+	def length(self):
+		"""Get the number of fields in the struct."""
+		raise NotImplementedError("Subclass must implement length()")
+	
+	def items_ptr(self):
+		"""Get pointer to the struct's data array."""
+		raise NotImplementedError("Subclass must implement items_ptr()")
+	
+	def __len__(self):
+		"""Support len(struct) syntax."""
+		return self.length()
+	
+	def __getitem__(self, index):
+		"""Support struct[i] syntax to access fields."""
+		length = self.length()
+		if index < 0 or index >= length:
+			raise IndexError(f"struct index out of range: {index} (length: {length})")
+		
+		ptr = self.items_ptr()
+		return ptr[index]
+
+
+class RStructEmbedded(RStructBase):
+	"""Ruby struct with embedded storage (small structs)."""
+	
+	def length(self):
+		"""Get length from flags for embedded struct."""
+		flags = int(self.rstruct.dereference()['basic']['flags'])
+		
+		# Extract length from FL_USER1 and FL_USER2 flags
+		RUBY_FL_USER1 = constants.get("RUBY_FL_USER1")
+		RUBY_FL_USER2 = constants.get("RUBY_FL_USER2")
+		RUBY_FL_USHIFT = constants.get("RUBY_FL_USHIFT")
+		
+		mask = RUBY_FL_USER1 | RUBY_FL_USER2
+		shift = RUBY_FL_USHIFT + 1
+		return (flags & mask) >> shift
+	
+	def items_ptr(self):
+		"""Get pointer to embedded data array."""
+		return self.rstruct.dereference()['as']['ary']
+	
+	def __str__(self):
+		"""Return string representation of struct."""
+		addr = int(self.value)
+		return f"<T_STRUCT@0x{addr:x} embedded length={len(self)}>"
+	
+	def print_to(self, terminal):
+		"""Return formatted struct representation."""
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<',
+			format.type, 'T_STRUCT',
+			format.metadata, f'@0x{addr:x} embedded length={len(self)}>',
+			format.reset
+		)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this struct recursively."""
+		printer.print(self)
+		
+		if depth <= 0:
+			if len(self) > 0:
+				printer.print_with_indent(printer.max_depth - depth, "  ...")
+			return
+		
+		# Print each field
+		for i in range(len(self)):
+			printer.print_item_label(printer.max_depth - depth, i)
+			printer.print_value(self[i], depth - 1)
+
+
+class RStructHeap(RStructBase):
+	"""Ruby struct with heap-allocated storage (large structs)."""
+	
+	def length(self):
+		"""Get length from heap structure."""
+		return int(self.rstruct.dereference()['as']['heap']['len'])
+	
+	def items_ptr(self):
+		"""Get pointer to heap-allocated data array."""
+		return self.rstruct.dereference()['as']['heap']['ptr']
+	
+	def __str__(self):
+		"""Return string representation of struct."""
+		addr = int(self.value)
+		return f"<T_STRUCT@0x{addr:x} heap length={len(self)}>"
+	
+	def print_to(self, terminal):
+		"""Return formatted struct representation."""
+		addr = int(self.value)
+		return terminal.print(
+			format.metadata, '<',
+			format.type, 'T_STRUCT',
+			format.metadata, f'@0x{addr:x} heap length={len(self)}>',
+			format.reset
+		)
+	
+	def print_recursive(self, printer, depth):
+		"""Print this struct recursively."""
+		printer.print(self)
+		
+		if depth <= 0:
+			if len(self) > 0:
+				printer.print_with_indent(printer.max_depth - depth, "  ...")
+			return
+		
+		# Print each field
+		for i in range(len(self)):
+			printer.print_item_label(printer.max_depth - depth, i)
+			printer.print_value(self[i], depth - 1)
+
+
+def RStruct(value):
+	"""
+	Factory function to create the appropriate RStruct variant.
+	
+	Caller should ensure value is a RUBY_T_STRUCT before calling this function.
+	
+	Returns:
+		RStructEmbedded or RStructHeap instance
+	"""
+	# Cast to RStruct pointer to read flags
+	rstruct_type = constants.get_type("struct RStruct").pointer()
+	rstruct = value.cast(rstruct_type)
+	flags = int(rstruct.dereference()['basic']['flags'])
+	
+	# Feature detection: check for RSTRUCT_EMBED_LEN_MASK flag
+	# If struct uses embedded storage, the length is encoded in flags
+	RSTRUCT_EMBED_LEN_MASK = constants.get("RSTRUCT_EMBED_LEN_MASK")
+	if RSTRUCT_EMBED_LEN_MASK is None:
+		# Fallback: try to detect by checking if as.heap exists
+		try:
+			_ = rstruct.dereference()['as']['heap']
+			return RStructHeap(value)
+		except Exception:
+			return RStructEmbedded(value)
+	
+	# Check if embedded flag is set
+	if flags & RSTRUCT_EMBED_LEN_MASK:
+		return RStructEmbedded(value)
+	else:
+		return RStructHeap(value)