lldb 0.1.0 → 0.3.0

data/lib/lldb/native_lifecycle.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module LLDB
+  module NativeLifecycle
+    # @rbs return: bool
+    def closed?
+      @native_handle ? @native_handle.closed? : false
+    end
+
+    # @rbs return: bool
+    def close
+      return false unless @native_handle
+      return false if @native_handle.closed?
+
+      send(:close_context) if respond_to?(:close_context, true)
+      @native_handle.close
+      @ptr = NativeHandle::NULL_POINTER
+      true
+    end
+
+    # @rbs return: FFI::Pointer
+    def to_ptr
+      return NativeHandle::NULL_POINTER if closed?
+
+      super
+    end
+
+    # @rbs return: void
+    def ensure_open!
+      raise ClosedObjectError, "#{self.class} is closed" if closed?
+      @context&.ensure_open!
+    end
+
+    # @rbs ptr: FFI::Pointer
+    # @rbs release: ^(FFI::Pointer) -> void
+    # @rbs context: Context?
+    # @rbs return: void
+    def initialize_native_object(ptr, release:, context: nil)
+      @ptr = ptr
+      @context = context
+      @native_handle = NativeHandle.new(ptr, release: release)
+      context&.register(@native_handle)
+    end
+
+    # @rbs return: Context?
+    def context
+      @context
+    end
+
+    # @rbs return: Context
+    def context!
+      context || raise(LifecycleError, 'LLDB object has no context')
+    end
+
+    # @rbs return: bool
+    def valid?
+      return false if closed? || @context&.closed?
+
+      super
+    end
+  end
+end

data/lib/lldb/native_string_array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module LLDB
+  class NativeStringArray
+    # @rbs strings: Array[String]
+    # @rbs return: void
+    def initialize(strings)
+      @strings = strings.map { |string| NativeStringArray.validate!(string) }
+      @string_pointers = @strings.map { |string| FFI::MemoryPointer.from_string(string) }
+      @pointer_array = FFI::MemoryPointer.new(:pointer, @string_pointers.length + 1)
+
+      @string_pointers.each_with_index do |pointer, index|
+        @pointer_array[index].put_pointer(0, pointer)
+      end
+      @pointer_array[@string_pointers.length].put_pointer(0, nil)
+    end
+
+    # @rbs value: String
+    # @rbs return: String
+    def self.validate!(value)
+      raise ArgumentError, 'native string values must be String' unless value.is_a?(String)
+      raise ArgumentError, 'native strings must not contain NUL bytes' if value.include?("\0")
+
+      value
+    end
+
+    # @rbs return: FFI::Pointer
+    def to_ptr
+      @pointer_array
+    end
+  end
+end

data/lib/lldb/process.rb

@@ -4,16 +4,30 @@
 
 module LLDB
   class Process
-    # @rbs return: Target
+    prepend NativeLifecycle
+
+    module BroadcastBit
+      STATE_CHANGED = 1 << 0
+      INTERRUPT = 1 << 1
+      STDOUT = 1 << 2
+      STDERR = 1 << 3
+      PROFILE_DATA = 1 << 4
+      STRUCTURED_DATA = 1 << 5
+    end
+
+    # @rbs return: Target?
     attr_reader :target
 
     # @rbs ptr: FFI::Pointer
-    # @rbs target: Target
+    # @rbs target: Target?
     # @rbs return: void
-    def initialize(ptr, target:)
-      @ptr = ptr # : FFI::Pointer
+    def initialize(ptr, target: nil, context: target&.context)
       @target = target
-      ObjectSpace.define_finalizer(self, self.class.release(@ptr))
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_process_destroy(released) },
+        context: context
+      )
     end
 
     # @rbs ptr: FFI::Pointer
@@ -27,32 +41,34 @@ module LLDB
       !@ptr.null? && FFIBindings.lldb_process_is_valid(@ptr) != 0
     end
 
-    # @rbs return: bool
+    # @rbs return: true
     def continue
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_continue(@ptr) != 0
+      native_operation('process.continue') do |error|
+        FFIBindings.lldb_process_continue(@ptr, error.to_ptr)
+      end
     end
 
-    # @rbs return: bool
+    # @rbs return: true
     def stop
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_stop(@ptr) != 0
+      native_operation('process.stop') { |error| FFIBindings.lldb_process_stop(@ptr, error.to_ptr) }
     end
 
-    # @rbs return: bool
+    # @rbs return: true
     def kill
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_kill(@ptr) != 0
+      native_operation('process.kill') { |error| FFIBindings.lldb_process_kill(@ptr, error.to_ptr) }
     end
 
-    # @rbs return: bool
+    # @rbs return: true
     def detach
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_detach(@ptr) != 0
+      native_operation('process.detach') { |error| FFIBindings.lldb_process_detach(@ptr, error.to_ptr) }
     end
 
     # @rbs return: Integer
@@ -102,7 +118,7 @@ module LLDB
       thread_ptr = FFIBindings.lldb_process_get_thread_at_index(@ptr, index)
       return nil if thread_ptr.nil? || thread_ptr.null?
 
-      Thread.new(thread_ptr, process: self)
+      Thread.new(thread_ptr, process: self, context: context)
     end
 
     # @rbs return: Thread?
@@ -112,7 +128,7 @@ module LLDB
       thread_ptr = FFIBindings.lldb_process_get_selected_thread(@ptr)
       return nil if thread_ptr.nil? || thread_ptr.null?
 
-      Thread.new(thread_ptr, process: self)
+      Thread.new(thread_ptr, process: self, context: context)
     end
 
     # @rbs thread_id: Integer
@@ -151,30 +167,35 @@ module LLDB
       FFIBindings.lldb_process_get_exit_description(@ptr)
     end
 
-    # @rbs return: bool
+    # @rbs return: true
     def destroy
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_destroy_process(@ptr) != 0
+      native_operation('process.destroy') do |error|
+        FFIBindings.lldb_process_destroy_process(@ptr, error.to_ptr)
+      end
     end
 
     # @rbs signal: Integer
-    # @rbs return: bool
+    # @rbs return: true
     def signal(signal)
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_signal(@ptr, signal) != 0
+      native_operation('process.signal') do |error|
+        FFIBindings.lldb_process_signal(@ptr, signal, error.to_ptr)
+      end
     end
 
     # @rbs thread_id: Integer
     # @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?
 
-      Thread.new(thread_ptr, process: self)
+      Thread.new(thread_ptr, process: self, context: context)
     end
 
     # @rbs index_id: Integer
@@ -185,7 +206,7 @@ module LLDB
       thread_ptr = FFIBindings.lldb_process_get_thread_by_index_id(@ptr, index_id)
       return nil if thread_ptr.nil? || thread_ptr.null?
 
-      Thread.new(thread_ptr, process: self)
+      Thread.new(thread_ptr, process: self, context: context)
     end
 
     # @rbs index_id: Integer
@@ -201,13 +222,14 @@ 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
       bytes_read = FFIBindings.lldb_process_read_memory(@ptr, address, buffer, size, error.to_ptr)
 
-      error.raise_if_error!
-      buffer.read_string(bytes_read)
+      error.raise_if_error!('process.read_memory')
+      buffer.get_bytes(0, bytes_read)
     end
 
     # @rbs address: Integer
@@ -215,12 +237,14 @@ 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)
+      buffer = FFI::MemoryPointer.new(:uint8, [data.bytesize, 1].max)
+      buffer.put_bytes(0, data)
       error = Error.new
       bytes_written = FFIBindings.lldb_process_write_memory(@ptr, address, buffer, data.bytesize, error.to_ptr)
 
-      error.raise_if_error!
+      error.raise_if_error!('process.write_memory')
       bytes_written
     end
 
@@ -233,16 +257,18 @@ module LLDB
       error = Error.new
       address = FFIBindings.lldb_process_allocate_memory(@ptr, size, permissions, error.to_ptr)
 
-      error.raise_if_error!
+      error.raise_if_error!('process.allocate_memory')
       address
     end
 
     # @rbs address: Integer
-    # @rbs return: bool
+    # @rbs return: true
     def deallocate_memory(address)
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_deallocate_memory(@ptr, address) != 0
+      native_operation('process.deallocate_memory') do |error|
+        FFIBindings.lldb_process_deallocate_memory(@ptr, address, error.to_ptr)
+      end
     end
 
     # @rbs address: Integer
@@ -250,13 +276,21 @@ module LLDB
     # @rbs return: String
     def read_cstring_from_memory(address, max_size = 1024)
       raise InvalidObjectError, 'Process is not valid' unless valid?
+      raise ArgumentError, 'max_size must be non-negative' if max_size.negative?
 
-      buffer = FFI::MemoryPointer.new(:uint8, max_size)
+      buffer = FFI::MemoryPointer.new(:uint8, [max_size, 1].max)
       error = Error.new
-      FFIBindings.lldb_process_read_cstring_from_memory(@ptr, address, buffer, max_size, error.to_ptr)
+      bytes_read = FFIBindings.lldb_process_read_cstring_from_memory(
+        @ptr,
+        address,
+        buffer,
+        max_size,
+        error.to_ptr
+      )
 
-      error.raise_if_error!
-      buffer.read_string
+      error.raise_if_error!('process.read_cstring_from_memory')
+      bytes = buffer.get_bytes(0, [bytes_read, max_size].min)
+      bytes.delete_suffix("\0")
     end
 
     # @rbs max_size: Integer
@@ -266,7 +300,7 @@ module LLDB
 
       buffer = FFI::MemoryPointer.new(:uint8, max_size)
       bytes_read = FFIBindings.lldb_process_get_stdout(@ptr, buffer, max_size)
-      buffer.read_string(bytes_read)
+      buffer.get_bytes(0, bytes_read)
     end
 
     # @rbs max_size: Integer
@@ -276,7 +310,7 @@ module LLDB
 
       buffer = FFI::MemoryPointer.new(:uint8, max_size)
       bytes_read = FFIBindings.lldb_process_get_stderr(@ptr, buffer, max_size)
-      buffer.read_string(bytes_read)
+      buffer.get_bytes(0, bytes_read)
     end
 
     # @rbs data: String
@@ -284,22 +318,42 @@ module LLDB
     def put_stdin(data)
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_put_stdin(@ptr, data, data.bytesize)
+      buffer = FFI::MemoryPointer.new(:uint8, [data.bytesize, 1].max)
+      buffer.put_bytes(0, data)
+      FFIBindings.lldb_process_put_stdin(@ptr, buffer, data.bytesize)
     end
 
-    # @rbs return: bool
+    # @rbs return: nil
     def send_async_interrupt
       raise InvalidObjectError, 'Process is not valid' unless valid?
 
-      FFIBindings.lldb_process_send_async_interrupt(@ptr) != 0
+      FFIBindings.lldb_process_send_async_interrupt(@ptr)
+      nil
+    end
+
+    # @rbs return: Broadcaster
+    def broadcaster
+      raise InvalidObjectError, 'Process is not valid' unless valid?
+
+      broadcaster_ptr = FFIBindings.lldb_process_get_broadcaster(@ptr)
+      raise LLDBError, 'Failed to get process broadcaster' if broadcaster_ptr.nil? || broadcaster_ptr.null?
+
+      Broadcaster.from_ptr(broadcaster_ptr, context: context)
     end
 
     # @rbs return: Integer
     def num_supported_hardware_watchpoints
       return 0 unless valid?
 
+      result = FFI::MemoryPointer.new(:uint32)
       error = Error.new
-      FFIBindings.lldb_process_get_num_supported_hardware_watchpoints(@ptr, error.to_ptr)
+      status = FFIBindings.lldb_process_get_num_supported_hardware_watchpoints(
+        @ptr,
+        result,
+        error.to_ptr
+      )
+      Native.check_status!(status, 'process.num_supported_hardware_watchpoints', error)
+      result.read_uint32
     end
 
     # @rbs return: Integer
@@ -309,9 +363,38 @@ 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!('process.get_memory_region_info')
+      return nil if info_ptr.nil? || info_ptr.null?
+
+      MemoryRegionInfo.new(info_ptr, context: context)
+    end
+
     # @rbs return: FFI::Pointer
     def to_ptr
       @ptr
     end
+
+    private
+
+    # @rbs operation: String
+    # @rbs &block: (Error) -> Integer
+    # @rbs return: true
+    def native_operation(operation, &block)
+      error = Error.new
+      Native.check_status!(yield(error), operation, error)
+      true
+    end
   end
 end

data/lib/lldb/symbol.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module LLDB
+  class Symbol
+    prepend NativeLifecycle
+
+    # @rbs target: Target?
+    # @rbs context: Context?
+    # @rbs return: void
+    def initialize(ptr, target: nil, context: nil)
+      @target = target
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_symbol_destroy(released) },
+        context: context || target&.context
+      )
+    end
+
+    # @rbs return: bool
+    def valid?
+      !@ptr.null? && FFIBindings.lldb_symbol_is_valid(@ptr) != 0
+    end
+
+    # @rbs return: String?
+    def name
+      return nil unless valid?
+
+      FFIBindings.lldb_symbol_get_name(@ptr)
+    end
+
+    # @rbs return: String?
+    def display_name
+      return nil unless valid?
+
+      FFIBindings.lldb_symbol_get_display_name(@ptr)
+    end
+
+    # @rbs return: String?
+    def mangled_name
+      return nil unless valid?
+
+      FFIBindings.lldb_symbol_get_mangled_name(@ptr)
+    end
+
+    # @rbs return: String?
+    def base_name
+      return nil unless valid?
+
+      FFIBindings.lldb_symbol_get_base_name(@ptr)
+    end
+
+    # @rbs return: Address?
+    def start_address
+      address_at(:lldb_symbol_get_start_address)
+    end
+
+    # @rbs return: Address?
+    def end_address
+      address_at(:lldb_symbol_get_end_address)
+    end
+
+    # @rbs return: Integer
+    def value
+      return INVALID_ADDRESS unless valid?
+
+      FFIBindings.lldb_symbol_get_value(@ptr)
+    end
+
+    # @rbs return: Integer
+    def size
+      return 0 unless valid?
+
+      FFIBindings.lldb_symbol_get_size(@ptr)
+    end
+
+    # @rbs return: Integer
+    def prologue_byte_size
+      return 0 unless valid?
+
+      FFIBindings.lldb_symbol_get_prologue_byte_size(@ptr)
+    end
+
+    # @rbs return: Integer
+    def type
+      return 0 unless valid?
+
+      FFIBindings.lldb_symbol_get_type(@ptr)
+    end
+
+    # @rbs return: Integer
+    def id
+      return 0 unless valid?
+
+      FFIBindings.lldb_symbol_get_id(@ptr)
+    end
+
+    # @rbs return: FFI::Pointer
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    # @rbs method_name: ::Symbol
+    # @rbs return: Address?
+    def address_at(method_name)
+      return nil unless valid?
+
+      ptr = FFIBindings.public_send(method_name, @ptr)
+      return nil if ptr.nil? || ptr.null?
+
+      Address.from_ptr(ptr, target: @target, context: context)
+    end
+  end
+end

data/lib/lldb/symbol_context.rb

@@ -4,16 +4,21 @@
 
 module LLDB
   class SymbolContext
+    prepend NativeLifecycle
+
     # @rbs return: Frame
     attr_reader :parent
 
     # @rbs ptr: FFI::Pointer
     # @rbs parent: Frame
     # @rbs return: void
-    def initialize(ptr, parent:)
-      @ptr = ptr # : FFI::Pointer
+    def initialize(ptr, parent:, context: parent.context)
       @parent = parent
-      ObjectSpace.define_finalizer(self, self.class.release(@ptr))
+      initialize_native_object(
+        ptr,
+        release: ->(released) { FFIBindings.lldb_symbol_context_destroy(released) },
+        context: context
+      )
     end
 
     # @rbs ptr: FFI::Pointer
@@ -34,7 +39,7 @@ module LLDB
       mod_ptr = FFIBindings.lldb_symbol_context_get_module(@ptr)
       return nil if mod_ptr.nil? || mod_ptr.null?
 
-      Module.new(mod_ptr, target: nil)
+      Module.new(mod_ptr, target: nil, context: context)
     end
 
     # @rbs return: String?