lldb 0.2.0 → 0.3.0

data/ext/lldb/discovery.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+module LLDB
+  module BuildDiscovery
+    Candidate = Struct.new(:include_dir, :lib_dir, :llvm_config, keyword_init: true)
+
+    DEFAULT_PREFIXES = [
+      '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr',
+      '/Library/Developer/CommandLineTools/usr',
+      '/opt/homebrew/opt/llvm',
+      '/usr/local/opt/llvm',
+      '/usr',
+      '/usr/local'
+    ].freeze
+
+    module_function
+
+    def candidates(options = {}, env: ENV, path: ENV.fetch('PATH', ''))
+      explicit_include = options[:include] || options[:include_dir]
+      explicit_lib = options[:lib] || options[:lib_dir]
+      explicit_dir = options[:dir] || options[:lldb_dir] || env['LLDB_DIR']
+
+      candidates = []
+      candidates << Candidate.new(include_dir: explicit_include, lib_dir: explicit_lib) if explicit_include || explicit_lib
+
+      if explicit_dir
+        candidates << candidate_for_prefix(explicit_dir)
+      end
+
+      llvm_config_paths(path).each do |llvm_config|
+        candidates << candidate_for_llvm_config(llvm_config)
+      end
+
+      prefix_paths(explicit_dir, env: env).each do |prefix|
+        candidates << candidate_for_prefix(prefix)
+      end
+
+      candidates.compact.uniq { |candidate| [candidate.include_dir, candidate.lib_dir] }
+    end
+
+    def candidate_for_llvm_config(llvm_config)
+      include_dir = command_output(llvm_config, '--includedir')
+      lib_dir = command_output(llvm_config, '--libdir')
+      return unless include_dir && lib_dir
+
+      Candidate.new(include_dir: include_dir, lib_dir: lib_dir, llvm_config: llvm_config)
+    end
+
+    def candidate_for_prefix(prefix)
+      return unless prefix
+
+      include_dir = File.join(prefix, 'include')
+      lib_dir = %w[lib lib64].map { |name| File.join(prefix, name) }.find do |path|
+        File.directory?(path)
+      end
+
+      Candidate.new(include_dir: include_dir, lib_dir: lib_dir)
+    end
+
+    def prefix_paths(explicit_dir, env: ENV)
+      paths = []
+      paths << explicit_dir if explicit_dir
+      paths << env['LLVM_PREFIX'] if env['LLVM_PREFIX']
+      paths.concat(DEFAULT_PREFIXES)
+      paths.concat(Dir.glob('/usr/lib/llvm-*').sort_by { |path| version_key(path) }.reverse)
+      paths.compact.uniq
+    end
+
+    def llvm_config_paths(path)
+      executables = path.split(File::PATH_SEPARATOR).flat_map do |directory|
+        next [] unless File.directory?(directory)
+
+        Dir.children(directory).filter_map do |name|
+          next unless name.match?(/\Allvm-config(?:-\d+(?:\.\d+)*)?\z/)
+
+          executable = File.join(directory, name)
+          executable if File.executable?(executable)
+        end
+      end
+
+      unique_executables = executables.uniq
+      unversioned = unique_executables.select { |path| File.basename(path) == 'llvm-config' }
+      versioned = unique_executables.reject { |path| File.basename(path) == 'llvm-config' }
+
+      unversioned + versioned.sort_by { |path| version_key(path) }.reverse
+    end
+
+    def command_output(*command)
+      output = IO.popen(command, &:read).strip
+      output.empty? ? nil : output
+    rescue SystemCallError
+      nil
+    end
+
+    def version_key(value)
+      value.to_s.scan(/\d+/).map(&:to_i)
+    end
+  end
+end

data/ext/lldb/extconf.rb

@@ -2,124 +2,241 @@
 # frozen_string_literal: true
 
 require 'mkmf'
+require 'open3'
+require 'rbconfig'
+require 'shellwords'
+require 'tmpdir'
 
-# Enable C++17
-$CXXFLAGS ||= ''
-$CXXFLAGS << ' -std=c++17'
+require_relative 'discovery'
 
-# Common LLDB search paths
-lldb_search_paths = [
-  # macOS Xcode
-  '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr',
-  '/Library/Developer/CommandLineTools/usr',
-  # Homebrew LLVM on macOS (Apple Silicon)
-  '/opt/homebrew/opt/llvm',
-  # Homebrew LLVM on macOS (Intel)
-  '/usr/local/opt/llvm',
-  # Linux system paths
-  '/usr',
-  '/usr/local'
-]
-
-# Find LLDB version-specific paths on Linux
-Dir.glob('/usr/lib/llvm-*').each do |path|
-  lldb_search_paths << path
+unless RbConfig::CONFIG['host_os'] =~ /darwin|linux/
+  abort "Unsupported platform: #{RbConfig::CONFIG['host_os']} (supported: Linux, macOS)"
 end
 
-lldb_lib_dir = nil
-lldb_include_dir = nil
+$CXXFLAGS ||= ''
+$CXXFLAGS << ' -std=c++17'
 
-# Try to find LLDB using lldb-config or llvm-config
-llvm_config = find_executable('llvm-config') ||
-              find_executable('llvm-config-18') ||
-              find_executable('llvm-config-17') ||
-              find_executable('llvm-config-16') ||
-              find_executable('llvm-config-15') ||
-              find_executable('llvm-config-14')
+def run_command(*command)
+  stdout, stderr, status = Open3.capture3(*command)
+  [stdout, stderr, status]
+end
 
-if llvm_config
-  lldb_lib_dir = `#{llvm_config} --libdir`.strip
-  lldb_include_dir = `#{llvm_config} --includedir`.strip
-else
-  # Search manually
-  lldb_search_paths.each do |base_path|
-    next unless File.directory?(base_path)
+def native_probe(compiler, include_dir, lib_dir, source, link:)
+  Dir.mktmpdir('lldb-ruby-probe') do |directory|
+    source_path = File.join(directory, 'probe.cpp')
+    output_path = File.join(directory, 'probe')
+    File.write(source_path, source)
+
+    command = [*compiler, '-std=c++17', '-I', include_dir]
+    if link
+      command.concat([source_path, '-L', lib_dir, '-llldb', '-o', output_path])
+      command << "-Wl,-rpath,#{lib_dir}"
+      command << (RbConfig::CONFIG['host_os'] =~ /darwin/ ? '-lc++' : '-lstdc++')
+    else
+      command.concat(['-fsyntax-only', source_path])
+    end
 
-    lib_candidates = [
-      File.join(base_path, 'lib'),
-      File.join(base_path, 'lib64')
-    ]
+    run_command(*command)
+  end
+end
 
-    lib_candidates.each do |lib_path|
-      next unless File.directory?(lib_path)
+def lldb_library_present?(lib_dir)
+  return false unless lib_dir && File.directory?(lib_dir)
 
-      # Check for liblldb
-      has_lldb = File.exist?(File.join(lib_path, 'liblldb.so')) ||
-                 File.exist?(File.join(lib_path, 'liblldb.dylib')) ||
-                 Dir.glob(File.join(lib_path, 'liblldb.so.*')).any?
+  Dir.glob(File.join(lib_dir, 'liblldb.{so,dylib}*')).any?
+end
 
-      next unless has_lldb
+def lldb_probe(compiler, candidate)
+  return [false, 'include directory does not exist'] unless File.directory?(candidate.include_dir)
+  return [false, 'library directory does not contain liblldb'] unless lldb_library_present?(candidate.lib_dir)
+
+  source = <<~CPP
+    #include <lldb/API/LLDB.h>
+
+    int main() {
+      lldb::SBDebugger debugger;
+      return debugger.IsValid() ? 0 : 0;
+    }
+  CPP
+
+  stdout, stderr, status = native_probe(
+    compiler,
+    candidate.include_dir,
+    candidate.lib_dir,
+    source,
+    link: true
+  )
+  return [true, nil] if status.success?
+
+  [false, [stdout, stderr].reject(&:empty?).join("\n")]
+end
 
-      lldb_lib_dir = lib_path
-      lldb_include_dir = File.join(base_path, 'include')
-      break
-    end
+def watchpoint_capability_probe(compiler, candidate)
+  source = <<~CPP
+    #include <lldb/API/SBWatchpoint.h>
+
+    int main() {
+      auto reads = static_cast<bool (lldb::SBWatchpoint::*)()>(
+        &lldb::SBWatchpoint::IsWatchingReads);
+      auto writes = static_cast<bool (lldb::SBWatchpoint::*)()>(
+        &lldb::SBWatchpoint::IsWatchingWrites);
+      (void)reads;
+      (void)writes;
+      return 0;
+    }
+  CPP
+
+  _stdout, _stderr, status = native_probe(
+    compiler,
+    candidate.include_dir,
+    candidate.lib_dir,
+    source,
+    link: false
+  )
+  status.success?
+end
 
-    break if lldb_lib_dir
-  end
+def api_capability_probe(compiler, candidate, header, expression)
+  source = <<~CPP
+    #include <lldb/API/#{header}>
+
+    int main() {
+      auto method = #{expression};
+      (void)method;
+      return 0;
+    }
+  CPP
+
+  _stdout, _stderr, status = native_probe(
+    compiler,
+    candidate.include_dir,
+    candidate.lib_dir,
+    source,
+    link: false
+  )
+  status.success?
 end
 
+def llvm_config_version(candidate)
+  llvm_config = candidate.llvm_config
+  if !llvm_config
+    possible = File.join(candidate.lib_dir.to_s, '..', 'bin', 'llvm-config')
+    llvm_config = possible if File.executable?(possible)
+  end
+  return 'unknown' unless llvm_config
 
-unless lldb_lib_dir
-  abort <<~MSG
+  stdout, _stderr, status = run_command(llvm_config, '--version')
+  status.success? && !stdout.strip.empty? ? stdout.strip : 'unknown'
+end
 
-    *** ERROR: Could not find LLDB library ***
+explicit_options = {
+  dir: with_config('lldb-dir'),
+  include: with_config('lldb-include'),
+  lib: with_config('lldb-lib')
+}.compact
+
+compiler = Shellwords.split(ENV.fetch('CXX', RbConfig::CONFIG['CXX'] || 'c++'))
+abort 'C++ compiler command is empty' if compiler.empty?
+attempts = []
+selected = nil
+
+LLDB::BuildDiscovery.candidates(explicit_options).each do |candidate|
+  success, reason = lldb_probe(compiler, candidate)
+  unless success
+    attempts << "#{candidate.inspect}: #{reason}"
+    next
+  end
 
-    Please install LLDB development files:
+  selected = candidate
+  break
+end
 
-    On Ubuntu/Debian:
-      sudo apt-get install lldb-14 liblldb-14-dev
+unless selected
+  abort <<~MSG
 
-    On Fedora/RHEL:
-      sudo dnf install lldb-devel
+    *** ERROR: Could not find a usable LLDB installation ***
 
-    On macOS:
-      xcode-select --install
-      # or
-      brew install llvm
+    A C++17 program including lldb/API/LLDB.h and linking against liblldb
+    must compile successfully. Tried:
+    #{attempts.join("\n")}
 
-    You can also set LLDB_DIR environment variable to point to your LLDB installation:
-      LLDB_DIR=/path/to/llvm gem install lldb
+    Supported inputs, in priority order:
+      --with-lldb-include=/path/to/include --with-lldb-lib=/path/to/lib
+      --with-lldb-dir=/path/to/llvm
+      LLDB_DIR=/path/to/llvm
+      llvm-config or llvm-config-N on PATH
 
+    The compiler used was: #{compiler}
   MSG
 end
 
-puts "Found LLDB library directory: #{lldb_lib_dir}"
-puts "Found LLDB include directory: #{lldb_include_dir}" if lldb_include_dir
-
-# Add include paths
-$CXXFLAGS << " -I#{lldb_include_dir}" if lldb_include_dir && File.directory?(lldb_include_dir)
-
-# Link against LLDB library
-$LDFLAGS << " -L#{lldb_lib_dir} -llldb"
-$LDFLAGS << " -Wl,-rpath,#{lldb_lib_dir}"
-
-# Check for C++ standard library
-$LDFLAGS << if RUBY_PLATFORM =~ /darwin/
+puts "Found LLDB library directory: #{selected.lib_dir}"
+puts "Found LLDB include directory: #{selected.include_dir}"
+puts "Found LLDB via: #{selected.llvm_config || 'prefix discovery'}"
+puts "Using C++ compiler: #{compiler.join(' ')}"
+
+watchpoint_access_kind = watchpoint_capability_probe(compiler, selected)
+symbol_get_base_name = api_capability_probe(
+  compiler, selected, 'SBSymbol.h', '&lldb::SBSymbol::GetBaseName'
+)
+symbol_get_id = api_capability_probe(
+  compiler, selected, 'SBSymbol.h', '&lldb::SBSymbol::GetID'
+)
+symbol_get_value = api_capability_probe(
+  compiler, selected, 'SBSymbol.h', '&lldb::SBSymbol::GetValue'
+)
+symbol_get_size = api_capability_probe(
+  compiler, selected, 'SBSymbol.h', '&lldb::SBSymbol::GetSize'
+)
+function_get_base_name = api_capability_probe(
+  compiler, selected, 'SBFunction.h', '&lldb::SBFunction::GetBaseName'
+)
+basic_type_char8 = api_capability_probe(
+  compiler, selected, 'SBType.h', 'static_cast<int>(lldb::eBasicTypeChar8)'
+)
+build_version = llvm_config_version(selected)
+config_path = File.expand_path('lldb_wrapper_config.h', __dir__)
+File.write(config_path, <<~HEADER)
+  #ifndef LLDB_WRAPPER_CONFIG_H
+  #define LLDB_WRAPPER_CONFIG_H
+
+  #define LLDB_RUBY_WRAPPER_ABI_VERSION 1
+  #define LLDB_RUBY_BUILD_LLDB_VERSION #{build_version.dump}
+  #define LLDB_RUBY_HAVE_WATCHPOINT_ACCESS_KIND #{watchpoint_access_kind ? 1 : 0}
+  #define LLDB_RUBY_HAVE_SYMBOL_GET_BASE_NAME #{symbol_get_base_name ? 1 : 0}
+  #define LLDB_RUBY_HAVE_SYMBOL_GET_ID #{symbol_get_id ? 1 : 0}
+  #define LLDB_RUBY_HAVE_SYMBOL_GET_VALUE #{symbol_get_value ? 1 : 0}
+  #define LLDB_RUBY_HAVE_SYMBOL_GET_SIZE #{symbol_get_size ? 1 : 0}
+  #define LLDB_RUBY_HAVE_FUNCTION_GET_BASE_NAME #{function_get_base_name ? 1 : 0}
+  #define LLDB_RUBY_HAVE_BASIC_TYPE_CHAR8 #{basic_type_char8 ? 1 : 0}
+
+  #endif
+HEADER
+puts "Watchpoint access capability: #{watchpoint_access_kind ? 'supported' : 'unsupported'}"
+puts "SBSymbol::GetBaseName capability: #{symbol_get_base_name ? 'supported' : 'unsupported'}"
+puts "SBSymbol::GetID capability: #{symbol_get_id ? 'supported' : 'unsupported'}"
+puts "SBSymbol::GetValue capability: #{symbol_get_value ? 'supported' : 'unsupported'}"
+puts "SBSymbol::GetSize capability: #{symbol_get_size ? 'supported' : 'unsupported'}"
+puts "SBFunction::GetBaseName capability: #{function_get_base_name ? 'supported' : 'unsupported'}"
+puts "BasicType::Char8 capability: #{basic_type_char8 ? 'supported' : 'unsupported'}"
+puts "Build LLDB version: #{build_version}"
+
+$CXXFLAGS << " -I#{selected.include_dir}"
+$LDFLAGS << " -L#{selected.lib_dir} -llldb"
+$LDFLAGS << " -Wl,-rpath,#{selected.lib_dir}"
+$LDFLAGS << if RbConfig::CONFIG['host_os'] =~ /darwin/
               ' -lc++'
             else
               ' -lstdc++'
             end
 
-# Create the extension as a shared library, not a Ruby native extension
-# because we're using FFI to load it
+# Create the extension as a shared library, not a Ruby native extension,
+# because the Ruby layer loads it through FFI.
 $srcs = ['lldb_wrapper.cpp']
 $objs = ['lldb_wrapper.o']
-
-# Set the target library name
 $DLDFLAGS ||= ''
 
-if RUBY_PLATFORM =~ /darwin/
+if RbConfig::CONFIG['host_os'] =~ /darwin/
   target = 'liblldb_wrapper.dylib'
   $DLDFLAGS << ' -dynamiclib'
 else
@@ -127,7 +244,6 @@ else
   $DLDFLAGS << ' -shared'
 end
 
-# Create a custom Makefile that builds a shared library
 File.open('Makefile', 'w') do |f|
   f.puts <<~MAKEFILE
     CXX = #{RbConfig::CONFIG['CXX'] || 'c++'}
@@ -137,6 +253,8 @@ File.open('Makefile', 'w') do |f|
     TARGET = #{target}
     SRCS = lldb_wrapper.cpp
     OBJS = lldb_wrapper.o
+    sitelibdir ?= #{RbConfig::CONFIG['sitelibdir']}
+    sitearchdir ?= #{RbConfig::CONFIG['sitearchdir']}
 
     all: $(TARGET)
 
@@ -147,13 +265,13 @@ File.open('Makefile', 'w') do |f|
     \t$(CXX) $(CXXFLAGS) -c -o $@ $<
 
     install: $(TARGET)
-    \tmkdir -p $(DESTDIR)#{RbConfig::CONFIG['sitelibdir']}/lldb
-    \tcp $(TARGET) $(DESTDIR)#{RbConfig::CONFIG['sitelibdir']}/lldb/
+    \tmkdir -p $(DESTDIR)$(sitearchdir)/lldb
+    \tcp $(TARGET) $(DESTDIR)$(sitearchdir)/lldb/
 
     clean:
     \trm -f $(OBJS) $(TARGET)
 
-    .PHONY: all install clean
+    .PHONY: all clean install
   MAKEFILE
 end