Use JRuby implementation for TruffleRuby

.github/workflows/ci.yml

@@ -26,13 +26,15 @@ jobs:
  - '3.2'
  - debug
  - jruby
+ - truffleruby
  include:
  - { os: windows-latest , ruby: mingw }
  - { os: windows-latest , ruby: mswin }
  exclude:
  - { os: macos-14 , ruby: '2.5' }
  - { os: windows-latest , ruby: '3.0' }
  - { os: windows-latest , ruby: debug }
+ - { os: windows-latest , ruby: truffleruby }
 
  steps:
  - uses: actions/checkout@v4

ext/fiddle/extconf.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'mkmf'
 
-if RUBY_ENGINE == "jruby"
+unless RUBY_ENGINE == "ruby"
  File.write('Makefile', dummy_makefile("").join)
  return
 end

fiddle.gemspec

@@ -38,11 +38,10 @@ Gem::Specification.new do |spec|
  "lib/fiddle.rb",
  "lib/fiddle/closure.rb",
  "lib/fiddle/cparser.rb",
+ "lib/fiddle/ffi_backend.rb",
  "lib/fiddle/function.rb",
  "lib/fiddle/import.rb",
- "lib/fiddle/jruby.rb",
  "lib/fiddle/pack.rb",
- "lib/fiddle/ruby.rb",
  "lib/fiddle/struct.rb",
  "lib/fiddle/types.rb",
  "lib/fiddle/value.rb",

lib/fiddle.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require "fiddle/#{RUBY_ENGINE}"
+if RUBY_ENGINE == 'ruby'
+ require 'fiddle.so'
+else
+ require 'fiddle/ffi_backend'
+end
 require 'fiddle/closure'
 require 'fiddle/function'
 require 'fiddle/version'

lib/fiddle/jruby.rb → lib/fiddle/ffi_backend.rb

@@ -1,4 +1,4 @@
-# This is part of JRuby's FFI-based fiddle implementation.
+# This is based on JRuby's FFI-based fiddle implementation.
 
 require 'ffi'
 
@@ -74,7 +74,7 @@ module Types
 
  WINDOWS = FFI::Platform.windows?
 
- module JRuby
+ module FFIBackend
  FFITypes = {
  'c' => FFI::Type::INT8,
  'h' => FFI::Type::INT16,
@@ -104,16 +104,16 @@ module JRuby
  Types::VARIADIC => FFI::Type::Builtin::VARARGS,
  }
 
- def self.__ffi_type__(dl_type)
- if dl_type.is_a?(Symbol)
-dl_type = Types.const_get(dl_type.to_s.upcase)
+ def self.to_ffi_type(fiddle_type)
+ if fiddle_type.is_a?(Symbol)
+fiddle_type = Types.const_get(fiddle_type.to_s.upcase)
  end
- if !dl_type.is_a?(Integer) && dl_type.respond_to?(:to_int)
-dl_type = dl_type.to_int
+ if !fiddle_type.is_a?(Integer) && fiddle_type.respond_to?(:to_int)
+fiddle_type = fiddle_type.to_int
  end
- ffi_type = FFITypes[dl_type]
- ffi_type = FFITypes[-dl_type] if ffi_type.nil? && dl_type.is_a?(Integer) && dl_type < 0
- raise TypeError.new("cannot convert #{dl_type} to ffi") unless ffi_type
+ ffi_type = FFITypes[fiddle_type]
+ ffi_type = FFITypes[-fiddle_type] if ffi_type.nil? && fiddle_type.is_a?(Integer) && fiddle_type < 0
+ raise TypeError.new("cannot convert #{fiddle_type} to ffi") unless ffi_type
  ffi_type
  end
  end
@@ -133,8 +133,8 @@ def initialize(ptr, args, return_type, abi = DEFAULT, kwargs = nil)
  @ptr, @args, @return_type, @abi = ptr, args, return_type, abi
  raise TypeError.new "invalid argument types" unless args.is_a?(Array)
 
- ffi_return_type = Fiddle::JRuby::__ffi_type__(@return_type)
- ffi_args = @args.map { |t| Fiddle::JRuby.__ffi_type__(t) }
+ ffi_return_type = Fiddle::FFIBackend.to_ffi_type(@return_type)
+ ffi_args = @args.map { |t| Fiddle::FFIBackend.to_ffi_type(t) }
  pointer = FFI::Pointer.new(ptr.to_i)
  options = {convention: @abi}
  if ffi_args.last == FFI::Type::Builtin::VARARGS
@@ -149,14 +149,25 @@ def initialize(ptr, args, return_type, abi = DEFAULT, kwargs = nil)
  end
  end
 
- def call(*args, &block);
+ def call(*args, &block)
  if @function.is_a?(FFI::VariadicInvoker)
  n_fixed_args = @args.size - 1
  n_fixed_args.step(args.size - 1, 2) do |i|
  if args[i] == :const_string || args[i] == Types::CONST_STRING
  args[i + 1] = String.try_convert(args[i + 1]) || args[i + 1]
  end
- args[i] = Fiddle::JRuby.__ffi_type__(args[i])
+ args[i] = Fiddle::FFIBackend.to_ffi_type(args[i])
+ end
+ else
+ args.map! do |arg|
+ if arg.respond_to?(:to_ptr)
+ begin
+ arg = arg.to_ptr
+ end until arg.is_a?(FFI::Pointer) || !arg.respond_to?(:to_ptr)
+ arg
+ else
+ arg
+ end
  end
  end
  result = @function.call(*args, &block)
@@ -170,19 +181,21 @@ def initialize(ret, args, abi = Function::DEFAULT)
  raise TypeError.new "invalid argument types" unless args.is_a?(Array)
 
  @ctype, @args = ret, args
- ffi_args = @args.map { |t| Fiddle::JRuby.__ffi_type__(t) }
+ ffi_args = @args.map { |t| Fiddle::FFIBackend.to_ffi_type(t) }
  if ffi_args.size == 1 && ffi_args[0] == FFI::Type::Builtin::VOID
  ffi_args = []
  end
- @function = FFI::Function.new(
- Fiddle::JRuby.__ffi_type__(@ctype),
- ffi_args,
- self,
- :convention => abi
- )
+ return_type = Fiddle::FFIBackend.to_ffi_type(@ctype)
+ raise "#{self.class} must implement #call" unless respond_to?(:call)
+ callable = method(:call)
+ @function = FFI::Function.new(return_type, ffi_args, callable, convention: abi)
  @freed = false
  end
 
+ def to_ptr
+ @function
+ end
+
  def to_i
  @function.to_i
  end
@@ -550,51 +563,51 @@ def cleared?
  RUBY_FREE = Fiddle::Pointer::LibC::FREE.address
  NULL = Fiddle::Pointer.new(0)
 
- ALIGN_VOIDP = Fiddle::JRuby::FFITypes[Types::VOIDP].alignment
- ALIGN_CHAR = Fiddle::JRuby::FFITypes[Types::CHAR].alignment
- ALIGN_SHORT = Fiddle::JRuby::FFITypes[Types::SHORT].alignment
- ALIGN_INT = Fiddle::JRuby::FFITypes[Types::INT].alignment
- ALIGN_LONG = Fiddle::JRuby::FFITypes[Types::LONG].alignment
- ALIGN_LONG_LONG = Fiddle::JRuby::FFITypes[Types::LONG_LONG].alignment
- ALIGN_INT8_T = Fiddle::JRuby::FFITypes[Types::INT8_T].alignment
- ALIGN_INT16_T = Fiddle::JRuby::FFITypes[Types::INT16_T].alignment
- ALIGN_INT32_T = Fiddle::JRuby::FFITypes[Types::INT32_T].alignment
- ALIGN_INT64_T = Fiddle::JRuby::FFITypes[Types::INT64_T].alignment
- ALIGN_FLOAT = Fiddle::JRuby::FFITypes[Types::FLOAT].alignment
- ALIGN_DOUBLE = Fiddle::JRuby::FFITypes[Types::DOUBLE].alignment
- ALIGN_BOOL = Fiddle::JRuby::FFITypes[Types::BOOL].alignment
- ALIGN_SIZE_T = Fiddle::JRuby::FFITypes[Types::SIZE_T].alignment
+ ALIGN_VOIDP = Fiddle::FFIBackend::FFITypes[Types::VOIDP].alignment
+ ALIGN_CHAR = Fiddle::FFIBackend::FFITypes[Types::CHAR].alignment
+ ALIGN_SHORT = Fiddle::FFIBackend::FFITypes[Types::SHORT].alignment
+ ALIGN_INT = Fiddle::FFIBackend::FFITypes[Types::INT].alignment
+ ALIGN_LONG = Fiddle::FFIBackend::FFITypes[Types::LONG].alignment
+ ALIGN_LONG_LONG = Fiddle::FFIBackend::FFITypes[Types::LONG_LONG].alignment
+ ALIGN_INT8_T = Fiddle::FFIBackend::FFITypes[Types::INT8_T].alignment
+ ALIGN_INT16_T = Fiddle::FFIBackend::FFITypes[Types::INT16_T].alignment
+ ALIGN_INT32_T = Fiddle::FFIBackend::FFITypes[Types::INT32_T].alignment
+ ALIGN_INT64_T = Fiddle::FFIBackend::FFITypes[Types::INT64_T].alignment
+ ALIGN_FLOAT = Fiddle::FFIBackend::FFITypes[Types::FLOAT].alignment
+ ALIGN_DOUBLE = Fiddle::FFIBackend::FFITypes[Types::DOUBLE].alignment
+ ALIGN_BOOL = Fiddle::FFIBackend::FFITypes[Types::BOOL].alignment
+ ALIGN_SIZE_T = Fiddle::FFIBackend::FFITypes[Types::SIZE_T].alignment
  ALIGN_SSIZE_T = ALIGN_SIZE_T
- ALIGN_PTRDIFF_T = Fiddle::JRuby::FFITypes[Types::PTRDIFF_T].alignment
- ALIGN_INTPTR_T = Fiddle::JRuby::FFITypes[Types::INTPTR_T].alignment
- ALIGN_UINTPTR_T = Fiddle::JRuby::FFITypes[Types::UINTPTR_T].alignment
-
- SIZEOF_VOIDP = Fiddle::JRuby::FFITypes[Types::VOIDP].size
- SIZEOF_CHAR = Fiddle::JRuby::FFITypes[Types::CHAR].size
- SIZEOF_UCHAR = Fiddle::JRuby::FFITypes[Types::UCHAR].size
- SIZEOF_SHORT = Fiddle::JRuby::FFITypes[Types::SHORT].size
- SIZEOF_USHORT = Fiddle::JRuby::FFITypes[Types::USHORT].size
- SIZEOF_INT = Fiddle::JRuby::FFITypes[Types::INT].size
- SIZEOF_UINT = Fiddle::JRuby::FFITypes[Types::UINT].size
- SIZEOF_LONG = Fiddle::JRuby::FFITypes[Types::LONG].size
- SIZEOF_ULONG = Fiddle::JRuby::FFITypes[Types::ULONG].size
- SIZEOF_LONG_LONG = Fiddle::JRuby::FFITypes[Types::LONG_LONG].size
- SIZEOF_ULONG_LONG = Fiddle::JRuby::FFITypes[Types::ULONG_LONG].size
- SIZEOF_INT8_T = Fiddle::JRuby::FFITypes[Types::INT8_T].size
- SIZEOF_UINT8_T = Fiddle::JRuby::FFITypes[Types::UINT8_T].size
- SIZEOF_INT16_T = Fiddle::JRuby::FFITypes[Types::INT16_T].size
- SIZEOF_UINT16_T = Fiddle::JRuby::FFITypes[Types::UINT16_T].size
- SIZEOF_INT32_T = Fiddle::JRuby::FFITypes[Types::INT32_T].size
- SIZEOF_UINT32_T = Fiddle::JRuby::FFITypes[Types::UINT32_T].size
- SIZEOF_INT64_T = Fiddle::JRuby::FFITypes[Types::INT64_T].size
- SIZEOF_UINT64_T = Fiddle::JRuby::FFITypes[Types::UINT64_T].size
- SIZEOF_FLOAT = Fiddle::JRuby::FFITypes[Types::FLOAT].size
- SIZEOF_DOUBLE = Fiddle::JRuby::FFITypes[Types::DOUBLE].size
- SIZEOF_BOOL = Fiddle::JRuby::FFITypes[Types::BOOL].size
- SIZEOF_SIZE_T = Fiddle::JRuby::FFITypes[Types::SIZE_T].size
+ ALIGN_PTRDIFF_T = Fiddle::FFIBackend::FFITypes[Types::PTRDIFF_T].alignment
+ ALIGN_INTPTR_T = Fiddle::FFIBackend::FFITypes[Types::INTPTR_T].alignment
+ ALIGN_UINTPTR_T = Fiddle::FFIBackend::FFITypes[Types::UINTPTR_T].alignment
+
+ SIZEOF_VOIDP = Fiddle::FFIBackend::FFITypes[Types::VOIDP].size
+ SIZEOF_CHAR = Fiddle::FFIBackend::FFITypes[Types::CHAR].size
+ SIZEOF_UCHAR = Fiddle::FFIBackend::FFITypes[Types::UCHAR].size
+ SIZEOF_SHORT = Fiddle::FFIBackend::FFITypes[Types::SHORT].size
+ SIZEOF_USHORT = Fiddle::FFIBackend::FFITypes[Types::USHORT].size
+ SIZEOF_INT = Fiddle::FFIBackend::FFITypes[Types::INT].size
+ SIZEOF_UINT = Fiddle::FFIBackend::FFITypes[Types::UINT].size
+ SIZEOF_LONG = Fiddle::FFIBackend::FFITypes[Types::LONG].size
+ SIZEOF_ULONG = Fiddle::FFIBackend::FFITypes[Types::ULONG].size
+ SIZEOF_LONG_LONG = Fiddle::FFIBackend::FFITypes[Types::LONG_LONG].size
+ SIZEOF_ULONG_LONG = Fiddle::FFIBackend::FFITypes[Types::ULONG_LONG].size
+ SIZEOF_INT8_T = Fiddle::FFIBackend::FFITypes[Types::INT8_T].size
+ SIZEOF_UINT8_T = Fiddle::FFIBackend::FFITypes[Types::UINT8_T].size
+ SIZEOF_INT16_T = Fiddle::FFIBackend::FFITypes[Types::INT16_T].size
+ SIZEOF_UINT16_T = Fiddle::FFIBackend::FFITypes[Types::UINT16_T].size
+ SIZEOF_INT32_T = Fiddle::FFIBackend::FFITypes[Types::INT32_T].size
+ SIZEOF_UINT32_T = Fiddle::FFIBackend::FFITypes[Types::UINT32_T].size
+ SIZEOF_INT64_T = Fiddle::FFIBackend::FFITypes[Types::INT64_T].size
+ SIZEOF_UINT64_T = Fiddle::FFIBackend::FFITypes[Types::UINT64_T].size
+ SIZEOF_FLOAT = Fiddle::FFIBackend::FFITypes[Types::FLOAT].size
+ SIZEOF_DOUBLE = Fiddle::FFIBackend::FFITypes[Types::DOUBLE].size
+ SIZEOF_BOOL = Fiddle::FFIBackend::FFITypes[Types::BOOL].size
+ SIZEOF_SIZE_T = Fiddle::FFIBackend::FFITypes[Types::SIZE_T].size
  SIZEOF_SSIZE_T = SIZEOF_SIZE_T
- SIZEOF_PTRDIFF_T = Fiddle::JRuby::FFITypes[Types::PTRDIFF_T].size
- SIZEOF_INTPTR_T = Fiddle::JRuby::FFITypes[Types::INTPTR_T].size
- SIZEOF_UINTPTR_T = Fiddle::JRuby::FFITypes[Types::UINTPTR_T].size
- SIZEOF_CONST_STRING = Fiddle::JRuby::FFITypes[Types::VOIDP].size
+ SIZEOF_PTRDIFF_T = Fiddle::FFIBackend::FFITypes[Types::PTRDIFF_T].size
+ SIZEOF_INTPTR_T = Fiddle::FFIBackend::FFITypes[Types::INTPTR_T].size
+ SIZEOF_UINTPTR_T = Fiddle::FFIBackend::FFITypes[Types::UINTPTR_T].size
+ SIZEOF_CONST_STRING = Fiddle::FFIBackend::FFITypes[Types::VOIDP].size
 end

test/fiddle/helper.rb

@@ -183,6 +183,10 @@ def teardown
  end
  end
 
+ def ffi_backend?
+ RUBY_ENGINE != 'ruby'
+ end
+
  def under_gc_stress
  stress, GC.stress = GC.stress, true
  yield

test/fiddle/test_closure.rb

@@ -58,9 +58,9 @@ def call thing
  end
 
  def test_const_string
- if RUBY_ENGINE == "jruby"
+ if ffi_backend?
  omit("Closure with :const_string works but " +
- "Function with :const_string doesn't work with JRuby")
+ "Function with :const_string doesn't work with FFI backend")
  end
 
  closure_class = Class.new(Closure) do
@@ -119,9 +119,14 @@ def test_memsize_ruby_dev_42480
  end
 
  require 'objspace'
+ closure_class = Class.new(Closure) do
+ def call
+ 10
+ end
+ end
  n = 10000
  n.times do
-Closure.create(:int, [:void]) do |closure|
+closure_class.create(:int, [:void]) do |closure|
  ObjectSpace.memsize_of(closure)
  end
  end

test/fiddle/test_fiddle.rb

@@ -6,8 +6,8 @@
 
 class TestFiddle < Fiddle::TestCase
  def test_nil_true_etc
- if RUBY_ENGINE == "jruby"
- omit("Fiddle::Q* aren't supported with JRuby")
+ if ffi_backend?
+ omit("Fiddle::Q* aren't supported with FFI backend")
  end
 
  assert_equal Fiddle::Qtrue, Fiddle.dlwrap(true)
@@ -30,6 +30,10 @@ def test_dlopen_linker_script_input_linux
  if Dir.glob("/usr/lib/*/libncurses.so").empty?
  omit("libncurses.so is needed")
  end
+ if ffi_backend?
+ omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
+ end
+
  # libncurses.so uses INPUT() on Debian GNU/Linux
  # $ cat /usr/lib/x86_64-linux-gnu/libncurses.so
  # INPUT(libncurses.so.6 -ltinfo)
@@ -44,6 +48,10 @@ def test_dlopen_linker_script_input_linux
 
  def test_dlopen_linker_script_group_linux
  omit("This is only for Linux") unless RUBY_PLATFORM.match?("linux")
+ if ffi_backend?
+ omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
+ end
+
  # libc.so uses GROUP() on Debian GNU/Linux
  # $ cat /usr/lib/x86_64-linux-gnu/libc.so
  # /* GNU ld script

test/fiddle/test_func.rb

@@ -64,6 +64,10 @@ def test_strtod
  end
 
  def test_qsort1
+ if RUBY_ENGINE == "jruby"
+ omit("The untouched sanity check is broken on JRuby: https://github.com/jruby/jruby/issues/8365")
+ end
+
  closure_class = Class.new(Closure) do
  def call(x, y)
  Pointer.new(x)[0] <=> Pointer.new(y)[0]
@@ -74,27 +78,32 @@ def call(x, y)
  qsort = Function.new(@libc['qsort'],
  [TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T, TYPE_VOIDP],
  TYPE_VOID)
- buff = "9341"
+ untouched = "9341"
+ buff = +"9341"
  qsort.call(buff, buff.size, 1, callback)
  assert_equal("1349", buff)
 
  bug4929 = '[ruby-core:37395]'
- buff = "9341"
+ buff = +"9341"
  under_gc_stress do
  qsort.call(buff, buff.size, 1, callback)
  end
  assert_equal("1349", buff, bug4929)
+
+ # Ensure the test didn't mutate String literals
+ assert_equal("93" + "41", untouched)
  end
  ensure
  # We can't use ObjectSpace with JRuby.
- return if RUBY_ENGINE == "jruby"
- # Ensure freeing all closures.
- # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
- not_freed_closures = []
- ObjectSpace.each_object(Fiddle::Closure) do |closure|
- not_freed_closures << closure unless closure.freed?
+ unless RUBY_ENGINE == "jruby"
+ # Ensure freeing all closures.
+ # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
+ not_freed_closures = []
+ ObjectSpace.each_object(Fiddle::Closure) do |closure|
+ not_freed_closures << closure unless closure.freed?
+ end
+ assert_equal([], not_freed_closures)
  end
- assert_equal([], not_freed_closures)
  end
 
  def test_snprintf