ffi 1.15.5 → 1.16.0

data/ext/ffi_c/libffi/testsuite/libffi.closures/stret_medium2.c

@@ -22,7 +22,7 @@ typedef struct struct_72byte {
 	long long i;
 } struct_72byte;
 
-struct_72byte cls_struct_72byte_fn(
+static struct_72byte cls_struct_72byte_fn(
 	struct_72byte b0,
 	struct_72byte b1,
 	struct_72byte b2,

data/ext/ffi_c/libffi/testsuite/libffi.closures/testclosure.c

@@ -14,12 +14,17 @@ typedef struct cls_struct_combined {
   float d;
 } cls_struct_combined;
 
-void cls_struct_combined_fn(struct cls_struct_combined arg)
+static void cls_struct_combined_fn(struct cls_struct_combined arg)
 {
   printf("%g %g %g %g\n",
 	 arg.a, arg.b,
 	 arg.c, arg.d);
   fflush(stdout);
+
+  CHECK_FLOAT_EQ(arg.a, 4);
+  CHECK_FLOAT_EQ(arg.b, 5);
+  CHECK_FLOAT_EQ(arg.c, 1);
+  CHECK_FLOAT_EQ(arg.d, 8);
 }
 
 static void

data/ext/ffi_c/libffi/testsuite/libffi.closures/unwindtest.cc

@@ -4,7 +4,7 @@
    PR:		none.
    Originator:	Jeff Sturm <jsturm@one-point.com>  */
 
-/* { dg-do run { xfail x86_64-apple-darwin* moxie*-*-* } } */
+/* { dg-do run { xfail moxie*-*-* } } */
 
 #include "ffitest.h"
 
@@ -48,6 +48,7 @@ typedef int (*closure_test_type1)(float, float, float, float, signed short,
 				  float, float, int, double, int, int, float,
 				  int, int, int, int);
 
+extern "C"
 int main (void)
 {
   ffi_cif cif;

data/ext/ffi_c/libffi/testsuite/libffi.closures/unwindtest_ffi_call.cc

@@ -14,6 +14,7 @@ static int checking(int a __UNUSED__, short b __UNUSED__,
   throw 9;
 }
 
+extern "C"
 int main (void)
 {
   ffi_cif cif;

data/ext/ffi_c/libffi.bsd.mk

@@ -18,8 +18,8 @@ INCFLAGS := -I${LIBFFI_BUILD_DIR}/include -I${INCFLAGS}
 
 LIBFFI = ${LIBFFI_BUILD_DIR}/.libs/libffi_convenience.a
 LIBFFI_AUTOGEN = ${LIBFFI_SRC_DIR}/autogen.sh
-LIBFFI_CONFIGURE = ${LIBFFI_SRC_DIR}/configure --disable-static \
-	--with-pic=yes --disable-dependency-tracking --disable-docs
+LIBFFI_CONFIGURE = ${LIBFFI_SRC_DIR}/configure --disable-shared --enable-static \
+	--with-pic=yes --disable-dependency-tracking --disable-docs $(LIBFFI_DEBUG)
 
 $(OBJS):	${LIBFFI}
 

data/ext/ffi_c/libffi.gnu.mk

@@ -21,8 +21,8 @@ endif
 
 LIBFFI = "$(LIBFFI_BUILD_DIR)"/.libs/libffi_convenience.a
 LIBFFI_AUTOGEN = ${LIBFFI_SRC_DIR}/autogen.sh
-LIBFFI_CONFIGURE = "$(LIBFFI_SRC_DIR)"/configure --disable-static \
-	--with-pic=yes --disable-dependency-tracking --disable-docs
+LIBFFI_CONFIGURE = "$(LIBFFI_SRC_DIR)"/configure --disable-shared --enable-static \
+	--with-pic=yes --disable-dependency-tracking --disable-docs $(LIBFFI_DEBUG)
 
 $(OBJS):	$(LIBFFI)
 

data/ext/ffi_c/rbffi.h

@@ -39,7 +39,7 @@ extern "C" {
 #define MAX_PARAMETERS (32)
 
 extern VALUE rbffi_FFIModule;
-    
+
 extern void rbffi_Type_Init(VALUE ffiModule);
 extern void rbffi_Buffer_Init(VALUE ffiModule);
 extern void rbffi_Invoker_Init(VALUE ffiModule);

data/ffi.gemspec

@@ -34,9 +34,9 @@ Gem::Specification.new do |s|
   s.rdoc_options = %w[--exclude=ext/ffi_c/.*\.o$ --exclude=ffi_c\.(bundle|so)$]
   s.license = 'BSD-3-Clause'
   s.require_paths << 'ext/ffi_c'
-  s.required_ruby_version = '>= 2.3'
+  s.required_ruby_version = '>= 2.5'
   s.add_development_dependency 'rake', '~> 13.0'
-  s.add_development_dependency 'rake-compiler', '~> 1.0'
+  s.add_development_dependency 'rake-compiler', '~> 1.1'
   s.add_development_dependency 'rake-compiler-dock', '~> 1.0'
   s.add_development_dependency 'rspec', '~> 2.14.1'
 end

data/lib/ffi/autopointer.rb

@@ -76,21 +76,21 @@ module FFI
     #  going to be useful if you subclass {AutoPointer}, and override
     #  #release, which by default does nothing.
     def initialize(ptr, proc=nil, &block)
+      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) ||
+          ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
       super(ptr.type_size, ptr)
-      raise TypeError, "Invalid pointer" if ptr.nil? || !ptr.kind_of?(Pointer) \
-        || ptr.kind_of?(MemoryPointer) || ptr.kind_of?(AutoPointer)
 
       @releaser = if proc
                     if not proc.respond_to?(:call)
                       raise RuntimeError.new("proc must be callable")
                     end
-                    CallableReleaser.new(ptr, proc)
+                    Releaser.new(ptr, proc)
 
                   else
-                    if not self.class.respond_to?(:release)
+                    if not self.class.respond_to?(:release, true)
                       raise RuntimeError.new("no release method defined")
                     end
-                    DefaultReleaser.new(ptr, self.class)
+                    Releaser.new(ptr, self.class.method(:release))
                   end
 
       ObjectSpace.define_finalizer(self, @releaser)
@@ -107,6 +107,7 @@ module FFI
     # @return [Boolean] +autorelease+
     # Set +autorelease+ property. See {Pointer Autorelease section at Pointer}.
     def autorelease=(autorelease)
+      raise FrozenError.new("can't modify frozen #{self.class}") if frozen?
       @releaser.autorelease=(autorelease)
     end
 
@@ -149,23 +150,7 @@ module FFI
       def call(*args)
         release(@ptr) if @autorelease && @ptr
       end
-    end
-
-    # DefaultReleaser is a {Releaser} used when an {AutoPointer} is defined
-    # without Proc or Method. In this case, the pointer to release must be of
-    # a class derived from AutoPointer with a {release} class method.
-    class DefaultReleaser < Releaser
-      # @param [Pointer] ptr
-      # @return [nil]
-      # Release +ptr+ using the {release} class method of its class.
-      def release(ptr)
-        @proc.release(ptr)
-      end
-    end
 
-    # CallableReleaser is a {Releaser} used when an {AutoPointer} is defined with a
-    # Proc or a Method.
-    class CallableReleaser < Releaser
       # Release +ptr+ by using Proc or Method defined at +ptr+
       # {AutoPointer#initialize initialization}.
       #
@@ -182,7 +167,7 @@ module FFI
     # @return [Type::POINTER]
     # @raise {RuntimeError} if class does not implement a +#release+ method
     def self.native_type
-      if not self.respond_to?(:release)
+      if not self.respond_to?(:release, true)
         raise RuntimeError.new("no release method defined for #{self.inspect}")
       end
       Type::POINTER

data/lib/ffi/compat.rb

@@ -0,0 +1,43 @@
+#
+# Copyright (C) 2023-2023 Lars Kanis
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+module FFI
+  if defined?(Ractor.make_shareable)
+    # This is for FFI internal use only.
+    def self.make_shareable(obj)
+      Ractor.make_shareable(obj)
+    end
+  else
+    def self.make_shareable(obj)
+      obj.freeze
+    end
+  end
+end

data/lib/ffi/data_converter.rb

@@ -31,7 +31,7 @@
 module FFI
   # This module is used to extend somes classes and give then a common API.
   #
-  # Most of methods defined here must be overriden.
+  # Most of methods defined here must be overridden.
   module DataConverter
     # Get native type.
     #
@@ -41,7 +41,7 @@ module FFI
     #  Get native type from +type+.
     #
     # @overload native_type
-    #  @raise {NotImplementedError} This method must be overriden.
+    #  @raise {NotImplementedError} This method must be overridden.
     def native_type(type = nil)
       if type
         @native_type = FFI.find_type(type)

data/lib/ffi/dynamic_library.rb

@@ -0,0 +1,89 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
+
+module FFI
+  class DynamicLibrary
+    SEARCH_PATH = %w[/usr/lib /usr/local/lib /opt/local/lib]
+    if FFI::Platform::ARCH == 'aarch64' && FFI::Platform.mac?
+      SEARCH_PATH << '/opt/homebrew/lib'
+    end
+
+    SEARCH_PATH_MESSAGE = "Searched in <system library path>, #{SEARCH_PATH.join(', ')}".freeze
+
+    def self.load_library(name, flags)
+      if name == FFI::CURRENT_PROCESS
+        FFI::DynamicLibrary.open(nil, RTLD_LAZY | RTLD_LOCAL)
+      else
+        flags ||= RTLD_LAZY | RTLD_LOCAL
+
+        libnames = (name.is_a?(::Array) ? name : [name])
+        libnames = libnames.map(&:to_s).map { |n| [n, FFI.map_library_name(n)].uniq }.flatten.compact
+        errors = []
+
+        libnames.each do |libname|
+          lib = try_load(libname, flags, errors)
+          return lib if lib
+
+          unless libname.start_with?("/") || FFI::Platform.windows?
+            SEARCH_PATH.each do |prefix|
+              path = "#{prefix}/#{libname}"
+              if File.exist?(path)
+                lib = try_load(path, flags, errors)
+                return lib if lib
+              end
+            end
+          end
+        end
+
+        raise LoadError, [*errors, SEARCH_PATH_MESSAGE].join(".\n")
+      end
+    end
+    private_class_method :load_library
+
+    def self.try_load(libname, flags, errors)
+      begin
+        lib = FFI::DynamicLibrary.open(libname, flags)
+        return lib if lib
+
+      # LoadError for C ext & JRuby, RuntimeError for TruffleRuby
+      rescue LoadError, RuntimeError => ex
+        if ex.message =~ /(([^ \t()])+\.so([^ \t:()])*):([ \t])*(invalid ELF header|file too short|invalid file format)/
+          if File.binread($1) =~ /(?:GROUP|INPUT) *\( *([^ \)]+)/
+            return try_load($1, flags, errors)
+          end
+        end
+
+        errors << ex
+        nil
+      end
+    end
+    private_class_method :try_load
+  end
+end

data/lib/ffi/enum.rb

@@ -192,6 +192,7 @@ module FFI
     #   @param [nil, Symbol] tag name of new Bitmask
     def initialize(*args)
       @native_type = args.first.kind_of?(FFI::Type) ? args.shift : Type::INT
+      @signed = [Type::INT8, Type::INT16, Type::INT32, Type::INT64].include?(@native_type)
       info, @tag = *args
       @kv_map = Hash.new
       unless info.nil?
@@ -220,7 +221,7 @@ module FFI
     #  @param [Symbol] query
     #  @return [Integer]
     # @overload [](query)
-    #  Get bitmaks value from symbol array
+    #  Get bitmask value from symbol array
     #  @param [Array<Symbol>] query
     #  @return [Integer]
     # @overload [](*query)
@@ -240,7 +241,7 @@ module FFI
       when Symbol
         flat_query.inject(0) do |val, o|
           v = @kv_map[o]
-          if v then val |= v else val end
+          if v then val | v else val end
         end
       when Integer, ->(o) { o.respond_to?(:to_int) }
         val = flat_query.inject(0) { |mask, o| mask |= o.to_int }
@@ -260,35 +261,41 @@ module FFI
     def to_native(query, ctx)
       return 0 if query.nil?
       flat_query = [query].flatten
-      flat_query.inject(0) do |val, o|
+      res = flat_query.inject(0) do |val, o|
         case o
         when Symbol
           v = @kv_map[o]
           raise ArgumentError, "invalid bitmask value, #{o.inspect}" unless v
-          val |= v
+          val | v
         when Integer
-          val |= o
+          val | o
         when ->(obj) { obj.respond_to?(:to_int) }
-          val |= o.to_int
+          val | o.to_int
         else
           raise ArgumentError, "invalid bitmask value, #{o.inspect}"
         end
       end
+      # Take two's complement of positive values bigger than the max value
+      # for the type when native type is signed.
+      if @signed && res >= (1 << (@native_type.size * 8 - 1))
+        res = -(-res & ((1 << (@native_type.size * 8)) - 1))
+      end
+      res
     end
 
     # @param [Integer] val
     # @param ctx unused
     # @return [Array<Symbol, Integer>] list of symbol names corresponding to val, plus an optional remainder if some bits don't match any constant
     def from_native(val, ctx)
-      list = @kv_map.select { |_, v| v & val != 0 }.keys
+      flags = @kv_map.select { |_, v| v & val != 0 }
+      list = flags.keys
+      # force an unsigned value of the correct size
+      val &= (1 << (@native_type.size * 8)) - 1 if @signed
       # If there are unmatch flags,
       # return them in an integer,
       # else information can be lost.
       # Similar to Enum behavior.
-      remainder = val ^ list.inject(0) do |tmp, o|
-        v = @kv_map[o]
-        if v then tmp |= v else tmp end
-      end
+      remainder = val ^ flags.values.reduce(0, :|)
       list.push remainder unless remainder == 0
       return list
     end

data/lib/ffi/ffi.rb

@@ -28,9 +28,11 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+require 'ffi/compat'
 require 'ffi/platform'
 require 'ffi/data_converter'
 require 'ffi/types'
+require 'ffi/library_path'
 require 'ffi/library'
 require 'ffi/errno'
 require 'ffi/abstract_memory'
@@ -45,3 +47,4 @@ require 'ffi/autopointer'
 require 'ffi/variadic'
 require 'ffi/enum'
 require 'ffi/version'
+require 'ffi/function'

data/lib/ffi/function.rb

@@ -0,0 +1,71 @@
+#
+# Copyright (C) 2008-2010 JRuby project
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module FFI
+  class Function
+    # Only MRI allows function type queries
+    if private_method_defined?(:type)
+      # Retrieve the return type of the function
+      #
+      # This method returns FFI type returned by the function.
+      #
+      # @return [FFI::Type]
+      def return_type
+        type.return_type
+      end
+
+      # Retrieve Array of parameter types
+      #
+      # This method returns an Array of FFI types accepted as function parameters.
+      #
+      # @return [Array<FFI::Type>]
+      def param_types
+        type.param_types
+      end
+    end
+
+    # Stash the Function in a module variable so it can be inspected by attached_functions.
+    # On CRuby it also ensures that it does not get garbage collected.
+    module RegisterAttach
+      def attach(mod, name)
+        funcs = mod.instance_variable_get("@ffi_functions")
+        unless funcs
+          funcs = {}
+          mod.instance_variable_set("@ffi_functions", funcs)
+        end
+        funcs[name.to_sym] = self
+        # Jump to the native attach method of CRuby, JRuby or Tuffleruby
+        super
+      end
+    end
+    private_constant :RegisterAttach
+    prepend RegisterAttach
+  end
+end

data/lib/ffi/library.rb

@@ -28,10 +28,12 @@
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
 
+require 'ffi/dynamic_library'
+
 module FFI
-  CURRENT_PROCESS = USE_THIS_PROCESS_AS_LIBRARY = Object.new
+  CURRENT_PROCESS = USE_THIS_PROCESS_AS_LIBRARY = FFI.make_shareable(Object.new)
 
-  # @param [#to_s] lib library name
+  # @param [String, FFI::LibraryPath] lib library name or LibraryPath object
   # @return [String] library name formatted for current platform
   # Transform a generic library name to a platform library name
   # @example
@@ -43,15 +45,7 @@ module FFI
   #  FFI.map_library_name 'jpeg'  # -> "jpeg.dll"
   def self.map_library_name(lib)
     # Mangle the library name to reflect the native library naming conventions
-    lib = Library::LIBC if lib == 'c'
-
-    if lib && File.basename(lib) == lib
-      lib = Platform::LIBPREFIX + lib unless lib =~ /^#{Platform::LIBPREFIX}/
-      r = Platform::IS_WINDOWS || Platform::IS_MAC ? "\\.#{Platform::LIBSUFFIX}$" : "\\.so($|\\.[1234567890]+)"
-      lib += ".#{Platform::LIBSUFFIX}" unless lib =~ /#{r}/
-    end
-
-    lib
+    LibraryPath.wrap(lib).to_s
   end
 
   # Exception raised when a function is not found in libraries
@@ -95,62 +89,11 @@ module FFI
     def ffi_lib(*names)
       raise LoadError.new("library names list must not be empty") if names.empty?
 
-      lib_flags = defined?(@ffi_lib_flags) ? @ffi_lib_flags : FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_LOCAL
-      ffi_libs = names.map do |name|
+      lib_flags = defined?(@ffi_lib_flags) && @ffi_lib_flags
 
-        if name == FFI::CURRENT_PROCESS
-          FFI::DynamicLibrary.open(nil, FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_LOCAL)
-
-        else
-          libnames = (name.is_a?(::Array) ? name : [ name ]).map(&:to_s).map { |n| [ n, FFI.map_library_name(n) ].uniq }.flatten.compact
-          lib = nil
-          errors = {}
-
-          libnames.each do |libname|
-            begin
-              orig = libname
-              lib = FFI::DynamicLibrary.open(libname, lib_flags)
-              break if lib
-
-            rescue Exception => ex
-              ldscript = false
-              if ex.message =~ /(([^ \t()])+\.so([^ \t:()])*):([ \t])*(invalid ELF header|file too short|invalid file format)/
-                if File.binread($1) =~ /(?:GROUP|INPUT) *\( *([^ \)]+)/
-                  libname = $1
-                  ldscript = true
-                end
-              end
-
-              if ldscript
-                retry
-              else
-                # TODO better library lookup logic
-                unless libname.start_with?("/") || FFI::Platform.windows?
-                  path = ['/usr/lib/','/usr/local/lib/','/opt/local/lib/', '/opt/homebrew/lib/'].find do |pth|
-                    File.exist?(pth + libname)
-                  end
-                  if path
-                    libname = path + libname
-                    retry
-                  end
-                end
-
-                libr = (orig == libname ? orig : "#{orig} #{libname}")
-                errors[libr] = ex
-              end
-            end
-          end
-
-          if lib.nil?
-            raise LoadError.new(errors.values.join(".\n"))
-          end
-
-          # return the found lib
-          lib
-        end
+      @ffi_libs = names.map do |name|
+        FFI::DynamicLibrary.send(:load_library, name, lib_flags)
       end
-
-      @ffi_libs = ffi_libs
     end
 
     # Set the calling convention for {#attach_function} and {#callback}
@@ -258,7 +201,7 @@ module FFI
             end
             raise LoadError unless function
 
-            invokers << if arg_types.length > 0 && arg_types[arg_types.length - 1] == FFI::NativeType::VARARGS
+            invokers << if arg_types[-1] == FFI::NativeType::VARARGS
               VariadicInvoker.new(function, arg_types, find_type(ret_type), options)
 
             else
@@ -330,6 +273,7 @@ module FFI
     # Attach C variable +cname+ to this module.
     def attach_variable(mname, a1, a2 = nil)
       cname, type = a2 ? [ a1, a2 ] : [ mname.to_s, a1 ]
+      mname = mname.to_sym
       address = nil
       ffi_libraries.each do |lib|
         begin
@@ -344,9 +288,10 @@ module FFI
         # If it is a global struct, just attach directly to the pointer
         s = s = type.new(address) # Assigning twice to suppress unused variable warning
         self.module_eval <<-code, __FILE__, __LINE__
-          @@ffi_gvar_#{mname} = s
+          @ffi_gsvars = {} unless defined?(@ffi_gsvars)
+          @ffi_gsvars[#{mname.inspect}] = s
           def self.#{mname}
-            @@ffi_gvar_#{mname}
+            @ffi_gsvars[#{mname.inspect}]
           end
         code
 
@@ -358,12 +303,13 @@ module FFI
         # Attach to this module as mname/mname=
         #
         self.module_eval <<-code, __FILE__, __LINE__
-          @@ffi_gvar_#{mname} = s
+          @ffi_gvars = {} unless defined?(@ffi_gvars)
+          @ffi_gvars[#{mname.inspect}] = s
           def self.#{mname}
-            @@ffi_gvar_#{mname}[:gvar]
+            @ffi_gvars[#{mname.inspect}][:gvar]
           end
           def self.#{mname}=(value)
-            @@ffi_gvar_#{mname}[:gvar] = value
+            @ffi_gvars[#{mname.inspect}][:gvar] = value
           end
         code
 
@@ -588,5 +534,43 @@ module FFI
 
       end || FFI.find_type(t)
     end
+
+    # Retrieve all attached functions and their function signature
+    #
+    # This method returns a Hash of method names of attached functions connected by #attach_function and the corresponding function type.
+    # The function type responds to #return_type and #param_types which return the FFI types of the function signature.
+    #
+    # @return [Hash< Symbol => [FFI::Function, FFI::VariadicInvoker] >]
+    def attached_functions
+      @ffi_functions || {}
+    end
+
+    # Retrieve all attached variables and their type
+    #
+    # This method returns a Hash of variable names and the corresponding type or variables connected by #attach_variable .
+    #
+    # @return [Hash< Symbol => ffi_type >]
+    def attached_variables
+      (
+        (@ffi_gsvars || {}).map do |name, gvar|
+          [name, gvar.class]
+        end +
+        (@ffi_gvars || {}).map do |name, gvar|
+          [name, gvar.layout[:gvar].type]
+        end
+      ).to_h
+    end
+
+    # Freeze all definitions of the module
+    #
+    # This freezes the module's definitions, so that it can be used in a Ractor.
+    # No further methods or variables can be attached and no further enums or typedefs can be created in this module afterwards.
+    def freeze
+      instance_variables.each do |name|
+        var = instance_variable_get(name)
+        FFI.make_shareable(var)
+      end
+      nil
+    end
   end
 end