archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-09-15 16:44:01 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Use JRuby implementation for TruffleRuby (#149)

Browse source 
Fix GH-145

Rename `lib/fiddle/jruby.rb` to `lib/fiddle/ffi_backend.rb` as a generic
ffi gem API based implementation.
JRuby and TruffleRuby use `lib/fiddle/ffi_backend.rb`.

---------

Co-authored-by: Benoit Daloze <eregontp@gmail.com>
This commit is contained in:
Sutou Kouhei 2024-10-10 14:37:12 +09:00 • committed by Hiroshi SHIBATA
parent bbd5b8ddae
commit 8d127c9b59
No known key found for this signature in database
GPG key ID: F9CF13417264FAC2
13 changed files with 155 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

2
ext/fiddle/extconf.rb
View file

@ -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

3
ext/fiddle/fiddle.gemspec
View file

@ -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",

6
ext/fiddle/lib/fiddle.rb
View file

@ -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'

143
ext/fiddle/lib/fiddle/jruby.rb → ext/fiddle/lib/fiddle/ffi_backend.rb
View file

@ -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 Fiddle
WINDOWS = FFI::Platform.windows?
module JRuby
module FFIBackend
FFITypes = {
'c' => FFI::Type::INT8,
'h' => FFI::Type::INT16,
@ -104,16 +104,16 @@ module Fiddle
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 @@ module Fiddle
@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 @@ module Fiddle
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 @@ module Fiddle
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 @@ module Fiddle
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
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::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
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

1
ext/fiddle/lib/fiddle/ruby.rb
View file

@ -1 +0,0 @@
require "fiddle.so"

4
test/fiddle/helper.rb
View file

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

11
test/fiddle/test_closure.rb
View file

@ -58,9 +58,9 @@ module Fiddle
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 @@ module Fiddle
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

12
test/fiddle/test_fiddle.rb
View file

@ -6,8 +6,8 @@ end
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 @@ class TestFiddle < Fiddle::TestCase
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 @@ class TestFiddle < Fiddle::TestCase
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

15
test/fiddle/test_func.rb
View file

@ -64,6 +64,10 @@ module Fiddle
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,20 +78,24 @@ module Fiddle
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"
unless RUBY_ENGINE == "jruby"
# Ensure freeing all closures.
# See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
not_freed_closures = []
@ -96,6 +104,7 @@ module Fiddle
end
assert_equal([], not_freed_closures)
end
end
def test_snprintf
unless Fiddle.const_defined?("TYPE_VARIADIC")

10
test/fiddle/test_function.rb
View file

@ -41,6 +41,9 @@ module Fiddle
if RUBY_ENGINE == "jruby"
omit("rb_str_dup() doesn't exist in JRuby")
end
if RUBY_ENGINE == "truffleruby"
omit("rb_str_dup() doesn't work with TruffleRuby")
end
libruby = Fiddle.dlopen(nil)
rb_str_dup = Function.new(libruby['rb_str_dup'],
@ -109,8 +112,8 @@ module Fiddle
end
def test_last_error
if RUBY_ENGINE == "jruby"
omit("Fiddle.last_error doesn't work with JRuby")
if ffi_backend?
omit("Fiddle.last_error doesn't work with FFI backend")
end
func = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
@ -219,6 +222,9 @@ module Fiddle
if RUBY_ENGINE == "jruby"
omit("rb_obj_frozen_p() doesn't exist in JRuby")
end
if RUBY_ENGINE == "truffleruby"
omit("memory leak detection is fragile with TruffleRuby")
end
if respond_to?(:assert_nothing_leaked_memory)
rb_obj_frozen_p_symbol = Fiddle.dlopen(nil)["rb_obj_frozen_p"]

20
test/fiddle/test_handle.rb
View file

@ -9,8 +9,8 @@ module Fiddle
include Fiddle
def test_to_i
if RUBY_ENGINE == "jruby"
omit("Fiddle::Handle#to_i is unavailable with JRuby")
if ffi_backend?
omit("Fiddle::Handle#to_i is unavailable with FFI backend")
end
handle = Fiddle::Handle.new(LIBC_SO)
@ -18,8 +18,8 @@ module Fiddle
end
def test_to_ptr
if RUBY_ENGINE == "jruby"
omit("Fiddle::Handle#to_i is unavailable with JRuby")
if ffi_backend?
omit("Fiddle::Handle#to_i is unavailable with FFI backend")
end
handle = Fiddle::Handle.new(LIBC_SO)
@ -34,8 +34,8 @@ module Fiddle
end
def test_static_sym
if RUBY_ENGINE == "jruby"
omit("We can't assume static symbols with JRuby")
if ffi_backend?
omit("We can't assume static symbols with FFI backend")
end
begin
@ -133,8 +133,8 @@ module Fiddle
end
def test_file_name
if RUBY_ENGINE == "jruby"
omit("Fiddle::Handle#file_name doesn't exist in JRuby")
if ffi_backend?
omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
end
file_name = Handle.new(LIBC_SO).file_name
@ -155,8 +155,8 @@ module Fiddle
end
def test_NEXT
if RUBY_ENGINE == "jruby"
omit("Fiddle::Handle::NEXT doesn't exist in JRuby")
if ffi_backend?
omit("Fiddle::Handle::NEXT doesn't exist in FFI backend")
end
begin

4
test/fiddle/test_import.rb
View file

@ -154,8 +154,8 @@ module Fiddle
end
def test_io()
if RUBY_ENGINE == "jruby"
omit("BUILD_RUBY_PLATFORM doesn't exist in JRuby")
if ffi_backend?
omit("BUILD_RUBY_PLATFORM doesn't exist in FFI backend")
end
if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM ) || !defined?(LIBC.fprintf)

20
test/fiddle/test_pointer.rb
View file

@ -11,8 +11,8 @@ module Fiddle
end
def test_can_read_write_memory
if RUBY_ENGINE == "jruby"
omit("Fiddle::Pointer.{read,write} don't exist in JRuby")
if ffi_backend?
omit("Fiddle::Pointer.{read,write} don't exist in FFI backend")
end
# Allocate some memory
@ -113,8 +113,8 @@ module Fiddle
end
def test_inspect
if RUBY_ENGINE == "jruby"
omit("Fiddle::Pointer#inspect is incompatible on JRuby")
if ffi_backend?
omit("Fiddle::Pointer#inspect is incompatible with FFI backend")
end
ptr = Pointer.new(0)
@ -132,8 +132,8 @@ module Fiddle
end
def test_to_ptr_io
if RUBY_ENGINE == "jruby"
omit("Fiddle::Pointer.to_ptr(IO) isn't supported with JRuby")
if ffi_backend?
omit("Fiddle::Pointer.to_ptr(IO) isn't supported with FFI backend")
end
Pointer.malloc(10, Fiddle::RUBY_FREE) do |buf|
@ -183,8 +183,8 @@ module Fiddle
end
def test_ref_ptr
if RUBY_ENGINE == "jruby"
omit("Fiddle.dlwrap([]) isn't supported with JRuby")
if ffi_backend?
omit("Fiddle.dlwrap([]) isn't supported with FFI backend")
end
ary = [0,1,2,4,5]
@ -195,8 +195,8 @@ module Fiddle
end
def test_to_value
if RUBY_ENGINE == "jruby"
omit("Fiddle.dlwrap([]) isn't supported with JRuby")
if ffi_backend?
omit("Fiddle.dlwrap([]) isn't supported with FFI backend")
end
ary = [0,1,2,4,5]