lldb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 116313cb462b86b83a7be8159cda38760bd0d1f840862749599ffacd2513def8
-  data.tar.gz: ff1e7c2fce29bf78a5414f9485075e3abeeca0f9759df0bc42f4ea1bdc94c454
+  metadata.gz: 2a9c4b0d0816a16700d8fc4e5b7bcb5e122875ead9fcfc8a2dde3c722e68d827
+  data.tar.gz: 6268f8c9bea45f4947cdb5a95ca5d95603e1d322e16f2f4aa1267c84f258b84c
 SHA512:
-  metadata.gz: 7b8fa444acc7a89419d17d4b991d1d69c1ede22bb811802830fb262bcb8c11141ec31e4bad291aca71a7ed1723780848dd60463d87653b87ad3047c29ab608ee
-  data.tar.gz: fc2e3e34f56ebd2de5b0f0e9e0f479fc975107bfed7c8131eb430aec09432971c2b700605b7864f1a5ad9867b47a2203a21d85a47bed0dbfbca8e49a9cab8d2c
+  metadata.gz: f305a6a355a1f599bd2706e8e9531c6a465ff17bf45aa3525bfac8f1c0a9f6cc3ecaf32bfc78f0ff7006b383094ad653e0656a5f994ab2a86335c632f57812d1
+  data.tar.gz: cdbe16e161820379724b65595ce44d4d04f307f3edb1c9cae6f854b6088f90e7d7ea654799fef0f5126243e41c020e4b84a412a4b4dd7e03510db039c7f8eecf

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 0.2.0 - 2026-01-04
+
+- Add MemoryRegionInfo bindings.
+- Add APISupport module for feature detection.
+
 ## 0.1.0 - 2025-12-30
 
 - Initial release.

data/ext/lldb/lldb_wrapper.cpp

@@ -759,6 +759,70 @@ uint32_t lldb_process_get_unique_id(lldb_process_t process) {
     return static_cast<lldb::SBProcess*>(process)->GetUniqueID();
 }
 
+lldb_memory_region_info_t lldb_process_get_memory_region_info(lldb_process_t process, uint64_t addr, lldb_error_t error) {
+    if (!process) return nullptr;
+
+    lldb::SBProcess* p = static_cast<lldb::SBProcess*>(process);
+    lldb::SBError* err = error ? static_cast<lldb::SBError*>(error) : nullptr;
+    lldb::SBError local_error;
+
+    lldb::SBMemoryRegionInfo* info = new lldb::SBMemoryRegionInfo();
+    lldb::SBError result = p->GetMemoryRegionInfo(addr, *info);
+
+    if (result.Fail()) {
+        if (err) *err = result;
+        delete info;
+        return nullptr;
+    }
+
+    return static_cast<lldb_memory_region_info_t>(info);
+}
+
+// ============================================================================
+// SBMemoryRegionInfo
+// ============================================================================
+
+void lldb_memory_region_info_destroy(lldb_memory_region_info_t info) {
+    if (info) {
+        delete static_cast<lldb::SBMemoryRegionInfo*>(info);
+    }
+}
+
+uint64_t lldb_memory_region_info_get_region_base(lldb_memory_region_info_t info) {
+    if (!info) return 0;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->GetRegionBase();
+}
+
+uint64_t lldb_memory_region_info_get_region_end(lldb_memory_region_info_t info) {
+    if (!info) return 0;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->GetRegionEnd();
+}
+
+int lldb_memory_region_info_is_readable(lldb_memory_region_info_t info) {
+    if (!info) return 0;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->IsReadable() ? 1 : 0;
+}
+
+int lldb_memory_region_info_is_writable(lldb_memory_region_info_t info) {
+    if (!info) return 0;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->IsWritable() ? 1 : 0;
+}
+
+int lldb_memory_region_info_is_executable(lldb_memory_region_info_t info) {
+    if (!info) return 0;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->IsExecutable() ? 1 : 0;
+}
+
+int lldb_memory_region_info_is_mapped(lldb_memory_region_info_t info) {
+    if (!info) return 0;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->IsMapped() ? 1 : 0;
+}
+
+const char* lldb_memory_region_info_get_name(lldb_memory_region_info_t info) {
+    if (!info) return nullptr;
+    return static_cast<lldb::SBMemoryRegionInfo*>(info)->GetName();
+}
+
 // ============================================================================
 // SBThread
 // ============================================================================

data/ext/lldb/lldb_wrapper.h

@@ -26,6 +26,7 @@ typedef void* lldb_type_t;
 typedef void* lldb_watchpoint_t;
 typedef void* lldb_command_interpreter_t;
 typedef void* lldb_command_return_object_t;
+typedef void* lldb_memory_region_info_t;
 
 // Initialization
 void lldb_initialize(void);
@@ -149,6 +150,17 @@ size_t lldb_process_put_stdin(lldb_process_t process, const char* buf, size_t si
 int lldb_process_send_async_interrupt(lldb_process_t process);
 uint32_t lldb_process_get_num_supported_hardware_watchpoints(lldb_process_t process, lldb_error_t error);
 uint32_t lldb_process_get_unique_id(lldb_process_t process);
+lldb_memory_region_info_t lldb_process_get_memory_region_info(lldb_process_t process, uint64_t addr, lldb_error_t error);
+
+// SBMemoryRegionInfo
+void lldb_memory_region_info_destroy(lldb_memory_region_info_t info);
+uint64_t lldb_memory_region_info_get_region_base(lldb_memory_region_info_t info);
+uint64_t lldb_memory_region_info_get_region_end(lldb_memory_region_info_t info);
+int lldb_memory_region_info_is_readable(lldb_memory_region_info_t info);
+int lldb_memory_region_info_is_writable(lldb_memory_region_info_t info);
+int lldb_memory_region_info_is_executable(lldb_memory_region_info_t info);
+int lldb_memory_region_info_is_mapped(lldb_memory_region_info_t info);
+const char* lldb_memory_region_info_get_name(lldb_memory_region_info_t info);
 
 // SBThread
 void lldb_thread_destroy(lldb_thread_t thread);

data/lib/lldb/api_support.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module LLDB
+  # Module for checking API availability across different LLDB versions
+  # and lldb-ruby binding implementations.
+  module APISupport
+    # Feature to FFI method mapping
+    FEATURES = {
+      breakpoint_by_address: :lldb_target_breakpoint_create_by_address,
+      breakpoint_by_regex: :lldb_target_breakpoint_create_by_regex,
+      memory_read: :lldb_process_read_memory,
+      memory_write: :lldb_process_write_memory,
+      thread_by_id: :lldb_process_get_thread_by_id,
+      memory_region_info: :lldb_process_get_memory_region_info,
+      step_into: :lldb_thread_step_into,
+      step_over: :lldb_thread_step_over,
+      step_out: :lldb_thread_step_out,
+      step_instruction: :lldb_thread_step_instruction,
+      registers: :lldb_frame_get_registers,
+      find_variable: :lldb_frame_find_variable,
+      evaluate_expression: :lldb_frame_evaluate_expression
+    }.freeze
+
+    class << self
+      # Check if a specific FFI method is available
+      #
+      # @rbs method_name: Symbol
+      # @rbs return: bool
+      def method_available?(method_name)
+        FFIBindings.respond_to?(method_name)
+      end
+
+      # Raise UnsupportedAPIError if the required method is not available
+      #
+      # @rbs method_name: Symbol
+      # @rbs feature_name: String?
+      # @rbs return: void
+      def require_method!(method_name, feature_name = nil)
+        return if method_available?(method_name)
+
+        feature = feature_name || method_name.to_s
+        raise UnsupportedAPIError,
+              "API '#{feature}' is not supported in this LLDB version or binding"
+      end
+
+      # Check if a feature is supported
+      #
+      # @rbs feature: Symbol
+      # @rbs return: bool
+      def feature_supported?(feature)
+        method_name = FEATURES[feature]
+        return false unless method_name
+
+        method_available?(method_name)
+      end
+
+      # Get list of all supported features
+      #
+      # @rbs return: Array[Symbol]
+      def supported_features
+        FEATURES.keys.select { |f| feature_supported?(f) }
+      end
+
+      # Get list of all unsupported features
+      #
+      # @rbs return: Array[Symbol]
+      def unsupported_features
+        FEATURES.keys.reject { |f| feature_supported?(f) }
+      end
+    end
+  end
+end

data/lib/lldb/error.rb

@@ -9,6 +9,7 @@ module LLDB
   class AttachError < LLDBError; end
   class BreakpointError < LLDBError; end
   class EvaluationError < LLDBError; end
+  class UnsupportedAPIError < LLDBError; end
 
   class Error
     # @rbs ptr: FFI::Pointer?

data/lib/lldb/ffi_bindings.rb

@@ -156,6 +156,19 @@ module LLDB
     attach_function :lldb_process_send_async_interrupt, [:pointer], :int
     attach_function :lldb_process_get_num_supported_hardware_watchpoints, %i[pointer pointer], :uint32
     attach_function :lldb_process_get_unique_id, [:pointer], :uint32
+    attach_function :lldb_process_get_memory_region_info, %i[pointer uint64 pointer], :pointer
+
+    # =========================================================================
+    # SBMemoryRegionInfo
+    # =========================================================================
+    attach_function :lldb_memory_region_info_destroy, [:pointer], :void
+    attach_function :lldb_memory_region_info_get_region_base, [:pointer], :uint64
+    attach_function :lldb_memory_region_info_get_region_end, [:pointer], :uint64
+    attach_function :lldb_memory_region_info_is_readable, [:pointer], :int
+    attach_function :lldb_memory_region_info_is_writable, [:pointer], :int
+    attach_function :lldb_memory_region_info_is_executable, [:pointer], :int
+    attach_function :lldb_memory_region_info_is_mapped, [:pointer], :int
+    attach_function :lldb_memory_region_info_get_name, [:pointer], :string
 
     # =========================================================================
     # SBThread

data/lib/lldb/frame.rb

@@ -96,6 +96,7 @@ module LLDB
     # @rbs return: Value?
     def find_variable(name)
       raise InvalidObjectError, 'Frame is not valid' unless valid?
+      APISupport.require_method!(:lldb_frame_find_variable, 'find_variable')
 
       value_ptr = FFIBindings.lldb_frame_find_variable(@ptr, name)
       return nil if value_ptr.nil? || value_ptr.null?
@@ -107,6 +108,7 @@ module LLDB
     # @rbs return: Value?
     def evaluate_expression(expression)
       raise InvalidObjectError, 'Frame is not valid' unless valid?
+      APISupport.require_method!(:lldb_frame_evaluate_expression, 'evaluate_expression')
 
       value_ptr = FFIBindings.lldb_frame_evaluate_expression(@ptr, expression)
       return nil if value_ptr.nil? || value_ptr.null?
@@ -177,6 +179,7 @@ module LLDB
     # @rbs return: ValueList
     def get_registers
       raise InvalidObjectError, 'Frame is not valid' unless valid?
+      APISupport.require_method!(:lldb_frame_get_registers, 'get_registers')
 
       list_ptr = FFIBindings.lldb_frame_get_registers(@ptr)
       raise LLDBError, 'Failed to get registers' if list_ptr.nil? || list_ptr.null?

data/lib/lldb/memory_region_info.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module LLDB
+  # Represents information about a memory region in the target process.
+  class MemoryRegionInfo
+    # @rbs ptr: FFI::Pointer
+    # @rbs return: void
+    def initialize(ptr)
+      @ptr = ptr # : FFI::Pointer
+      ObjectSpace.define_finalizer(self, self.class.release(@ptr))
+    end
+
+    # @rbs ptr: FFI::Pointer
+    # @rbs return: ^(Integer) -> void
+    def self.release(ptr)
+      ->(_id) { FFIBindings.lldb_memory_region_info_destroy(ptr) unless ptr.null? }
+    end
+
+    # Get the base address of the memory region
+    #
+    # @rbs return: Integer
+    def base_address
+      FFIBindings.lldb_memory_region_info_get_region_base(@ptr)
+    end
+
+    # Get the end address of the memory region
+    #
+    # @rbs return: Integer
+    def end_address
+      FFIBindings.lldb_memory_region_info_get_region_end(@ptr)
+    end
+
+    # Get the size of the memory region
+    #
+    # @rbs return: Integer
+    def size
+      end_address - base_address
+    end
+
+    # Check if the memory region is readable
+    #
+    # @rbs return: bool
+    def readable?
+      FFIBindings.lldb_memory_region_info_is_readable(@ptr) != 0
+    end
+
+    # Check if the memory region is writable
+    #
+    # @rbs return: bool
+    def writable?
+      FFIBindings.lldb_memory_region_info_is_writable(@ptr) != 0
+    end
+
+    # Check if the memory region is executable
+    #
+    # @rbs return: bool
+    def executable?
+      FFIBindings.lldb_memory_region_info_is_executable(@ptr) != 0
+    end
+
+    # Check if the memory region is mapped
+    #
+    # @rbs return: bool
+    def mapped?
+      FFIBindings.lldb_memory_region_info_is_mapped(@ptr) != 0
+    end
+
+    # Get the name of the memory region (if available)
+    #
+    # @rbs return: String?
+    def name
+      FFIBindings.lldb_memory_region_info_get_name(@ptr)
+    end
+
+    # Get the permissions string (e.g., "rwx", "r-x", etc.)
+    #
+    # @rbs return: String
+    def permissions
+      perms = +''
+      perms << (readable? ? 'r' : '-')
+      perms << (writable? ? 'w' : '-')
+      perms << (executable? ? 'x' : '-')
+      perms.freeze
+    end
+
+    # @rbs return: String
+    def to_s
+      format(
+        '0x%016x-0x%016x %s %s',
+        base_address,
+        end_address,
+        permissions,
+        name || ''
+      ).strip
+    end
+
+    # @rbs return: FFI::Pointer
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/lldb/process.rb

@@ -170,6 +170,7 @@ module LLDB
     # @rbs return: Thread?
     def thread_by_id(thread_id)
       raise InvalidObjectError, 'Process is not valid' unless valid?
+      APISupport.require_method!(:lldb_process_get_thread_by_id, 'thread_by_id')
 
       thread_ptr = FFIBindings.lldb_process_get_thread_by_id(@ptr, thread_id)
       return nil if thread_ptr.nil? || thread_ptr.null?
@@ -201,6 +202,7 @@ module LLDB
     # @rbs return: String
     def read_memory(address, size)
       raise InvalidObjectError, 'Process is not valid' unless valid?
+      APISupport.require_method!(:lldb_process_read_memory, 'read_memory')
 
       buffer = FFI::MemoryPointer.new(:uint8, size)
       error = Error.new
@@ -215,6 +217,7 @@ module LLDB
     # @rbs return: Integer
     def write_memory(address, data)
       raise InvalidObjectError, 'Process is not valid' unless valid?
+      APISupport.require_method!(:lldb_process_write_memory, 'write_memory')
 
       buffer = FFI::MemoryPointer.from_string(data)
       error = Error.new
@@ -309,6 +312,24 @@ module LLDB
       FFIBindings.lldb_process_get_unique_id(@ptr)
     end
 
+    # Get information about the memory region at the specified address
+    #
+    # @rbs address: Integer
+    # @rbs return: MemoryRegionInfo?
+    def get_memory_region_info(address)
+      raise InvalidObjectError, 'Process is not valid' unless valid?
+      APISupport.require_method!(:lldb_process_get_memory_region_info,
+                                 'get_memory_region_info')
+
+      error = Error.new
+      info_ptr = FFIBindings.lldb_process_get_memory_region_info(@ptr, address, error.to_ptr)
+
+      error.raise_if_error!
+      return nil if info_ptr.nil? || info_ptr.null?
+
+      MemoryRegionInfo.new(info_ptr)
+    end
+
     # @rbs return: FFI::Pointer
     def to_ptr
       @ptr

data/lib/lldb/target.rb

@@ -128,6 +128,8 @@ module LLDB
     # @rbs return: Breakpoint
     def breakpoint_create_by_address(address)
       raise InvalidObjectError, 'Target is not valid' unless valid?
+      APISupport.require_method!(:lldb_target_breakpoint_create_by_address,
+                                 'breakpoint_create_by_address')
 
       bp_ptr = FFIBindings.lldb_target_breakpoint_create_by_address(@ptr, address)
       if bp_ptr.nil? || bp_ptr.null?
@@ -244,6 +246,8 @@ module LLDB
     # @rbs return: Breakpoint
     def breakpoint_create_by_regex(regex, module_name: nil)
       raise InvalidObjectError, 'Target is not valid' unless valid?
+      APISupport.require_method!(:lldb_target_breakpoint_create_by_regex,
+                                 'breakpoint_create_by_regex')
 
       bp_ptr = FFIBindings.lldb_target_breakpoint_create_by_regex(@ptr, regex, module_name)
       raise BreakpointError, "Failed to create breakpoint for regex '#{regex}'" if bp_ptr.nil? || bp_ptr.null?

data/lib/lldb/thread.rb

@@ -30,6 +30,7 @@ module LLDB
     # @rbs return: bool
     def step_over
       raise InvalidObjectError, 'Thread is not valid' unless valid?
+      APISupport.require_method!(:lldb_thread_step_over, 'step_over')
 
       FFIBindings.lldb_thread_step_over(@ptr) != 0
     end
@@ -37,6 +38,7 @@ module LLDB
     # @rbs return: bool
     def step_into
       raise InvalidObjectError, 'Thread is not valid' unless valid?
+      APISupport.require_method!(:lldb_thread_step_into, 'step_into')
 
       FFIBindings.lldb_thread_step_into(@ptr) != 0
     end
@@ -44,6 +46,7 @@ module LLDB
     # @rbs return: bool
     def step_out
       raise InvalidObjectError, 'Thread is not valid' unless valid?
+      APISupport.require_method!(:lldb_thread_step_out, 'step_out')
 
       FFIBindings.lldb_thread_step_out(@ptr) != 0
     end
@@ -52,6 +55,7 @@ module LLDB
     # @rbs return: bool
     def step_instruction(step_over: false)
       raise InvalidObjectError, 'Thread is not valid' unless valid?
+      APISupport.require_method!(:lldb_thread_step_instruction, 'step_instruction')
 
       FFIBindings.lldb_thread_step_instruction(@ptr, step_over ? 1 : 0) != 0
     end

data/lib/lldb/version.rb

@@ -3,5 +3,5 @@
 # rbs_inline: enabled
 
 module LLDB
-  VERSION = '0.1.0' # : String
+  VERSION = '0.2.0' # : String
 end

data/lib/lldb.rb

@@ -6,10 +6,12 @@ require_relative 'lldb/version'
 require_relative 'lldb/ffi_bindings'
 require_relative 'lldb/types'
 require_relative 'lldb/error'
+require_relative 'lldb/api_support'
 require_relative 'lldb/debugger'
 require_relative 'lldb/target'
 require_relative 'lldb/launch_info'
 require_relative 'lldb/process'
+require_relative 'lldb/memory_region_info'
 require_relative 'lldb/thread'
 require_relative 'lldb/frame'
 require_relative 'lldb/breakpoint'

data/sig/lldb/ffi_bindings.rbs

@@ -100,6 +100,17 @@ module LLDB
     def self.lldb_process_send_async_interrupt: (FFI::Pointer) -> Integer
     def self.lldb_process_get_num_supported_hardware_watchpoints: (FFI::Pointer, FFI::Pointer) -> Integer
     def self.lldb_process_get_unique_id: (FFI::Pointer) -> Integer
+    def self.lldb_process_get_memory_region_info: (FFI::Pointer, Integer, FFI::Pointer) -> FFI::Pointer
+
+    # SBMemoryRegionInfo
+    def self.lldb_memory_region_info_destroy: (FFI::Pointer) -> void
+    def self.lldb_memory_region_info_get_region_base: (FFI::Pointer) -> Integer
+    def self.lldb_memory_region_info_get_region_end: (FFI::Pointer) -> Integer
+    def self.lldb_memory_region_info_is_readable: (FFI::Pointer) -> Integer
+    def self.lldb_memory_region_info_is_writable: (FFI::Pointer) -> Integer
+    def self.lldb_memory_region_info_is_executable: (FFI::Pointer) -> Integer
+    def self.lldb_memory_region_info_is_mapped: (FFI::Pointer) -> Integer
+    def self.lldb_memory_region_info_get_name: (FFI::Pointer) -> String?
 
     # SBThread
     def self.lldb_thread_destroy: (FFI::Pointer) -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lldb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -50,6 +50,7 @@ files:
 - ext/lldb/lldb_wrapper.o
 - ext/lldb/mkmf.log
 - lib/lldb.rb
+- lib/lldb/api_support.rb
 - lib/lldb/breakpoint.rb
 - lib/lldb/breakpoint_location.rb
 - lib/lldb/command_interpreter.rb
@@ -59,6 +60,7 @@ files:
 - lib/lldb/ffi_bindings.rb
 - lib/lldb/frame.rb
 - lib/lldb/launch_info.rb
+- lib/lldb/memory_region_info.rb
 - lib/lldb/module.rb
 - lib/lldb/process.rb
 - lib/lldb/symbol_context.rb