ffi-llvm-jit 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7330fb0bd311b6b6655240b9801e1af1951964f57210540c6d00db78aeddf001
-  data.tar.gz: a98d9784adebf9e4c4ecdbeb778a48ffd2a19161713f5f8a48c5dc3b00abac58
+  metadata.gz: bfb626cce651accf4c6a89183521b2466b28896d51da8618e9bd5ba6d4cab0ea
+  data.tar.gz: f981dac4d5b6b28ca8deda9f8d83fac86fdba9f652341cf0aebd5b86afd05823
 SHA512:
-  metadata.gz: 2c311b57edf7649f606f5d983718de9659808d13d28dba0f5d34c20e56b796296fbd702c7e58e30271c525041973c1f4fa587d5963433131b0c7d785f9374e7d
-  data.tar.gz: ec31286dee9223c8b9ca64827b40783e97dcecc5a4ee06192b75afe125fc341a724f036851c520da4861e9dc2a03b4e7690ee672a85f27712619de210c5c1141
+  metadata.gz: def04235fac925e1d93a69ea6c4e1bc934aed21aea42fa2001753c1a99176801b27dbb85968958762a97ec75b764c6182ca8ac35a2d07f31ef82225750bf0a51
+  data.tar.gz: d547365f887e0bbceb29032b2b98cc325e226b075a900996fa9aec64248c71f165d9d5e9190af388f1f821b1a569d7fce06f261890b22cffb2f160d6c2122acd

data/README.md

@@ -1,6 +1,6 @@
 # FFI::LLVMJIT
 
-Extends Ruby FFI and uses LLVM to generate JIT wrappers for attached native functions. Works only on MRI.
+Extends Ruby FFI and uses LLVM to generate JIT wrappers for attached native functions. Works only on MRI, doesn't support Windows yet.
 
 ## Requirements
 
@@ -25,9 +25,9 @@ gem install ffi-llvm-jit
 
 ## Usage
 
-This gem provides `FFI::LLVMJIT::Library` module that intends to be fully compatible with (`FFI::Library`)[https://www.rubydoc.info/gems/ffi/1.17.2/FFI/Library#attach_function-instance_method]. It defines its own `attach_function` method to create a faster JIT fuction instead of a FFI wrapper. The only difference for the caller is that `attach_function` returns `nil` instead of `FFI::Function`/`FFI::VariadicInvoker` when JIT function is created.
+This gem provides the `FFI::LLVMJIT::Library` module that intends to be fully compatible with [FFI::Library](https://www.rubydoc.info/gems/ffi/1.17.2/FFI/Library#attach_function-instance_method). It defines its own `attach_function` method to create a faster JIT function instead of a FFI wrapper. When a JIT function is created, `attach_function` still returns an `FFI::Function` for API compatibility (though the method uses the JIT implementation). Use `attach_llvm_jit_function` if you want `nil` on success or an explicit error on failure.
 
-Only basic types and none configuration options are supported; in case of unsupported parameters `ffi-llvm-jit` simply calls `ffi`. It also provides `attach_llvm_jit_function` method that raises an exception instead in that case.
+Supported features include basic scalar types, typedefs, enums, `FFI::DataConverter` mapped types (including stacked converters, note that it differs slightly from how FFI [behaves](https://github.com/ffi/ffi/pull/1185)), blocking calls, and errno saving. Unsupported parameters (varargs, callbacks, `:pointer` arguments) cause `attach_function` to fall back to FFI, or raise `FFI::LLVMJIT::UnsupportedError` when using `attach_llvm_jit_function`.
 
 Example:
 
@@ -39,23 +39,23 @@ module LibCFFI
   ffi_lib FFI::Library::LIBC
 end
 
-begin
-  LibCFFI.attach_llvm_jit_function :printf, [:string, :varargs], :int
-rescue NotImplementedError => e
-  e
-end
-# => #<NotImplementedError: Cannot create JIT function printf>
-
+# Varargs are unsupported — attach_function falls back to FFI and returns a VariadicInvoker
 LibCFFI.attach_function :printf, [:string, :varargs], :int
-# => #<FFI::VariadicInvoker:0x0000766a3ac4a200 @fixed=[#<FFI::Type::Builtin::STRING size=8 alignment=8>], @type_map=nil>
+# => #<FFI::VariadicInvoker:0x0000766a3ac4a200 ...>
 
+# For supported types, attach_function returns FFI::Function (JIT is still used for the actual call)
+LibCFFI.attach_function :strlen, [:string], :size_t
+# => #<FFI::Function address=0x000070e75099d8a0>
+
+# attach_llvm_jit_function raises FFI::LLVMJIT::UnsupportedError for unsupported types
 begin
-  LibCFFI.attach_llvm_jit_function :strcasecmp, [:string, :string], :int, blocking: true
-rescue NotImplementedError => e
-  e
+  LibCFFI.attach_llvm_jit_function :printf, [:string, :varargs], :int
+rescue FFI::LLVMJIT::UnsupportedError => e
+  e.message
 end
-# => #<NotImplementedError: Cannot create JIT function strcasecmp>
+# => "Unsupported argument type: #<FFI::Type::Builtin::VARARGS ...>"
 
+# Basic function — JIT compiled, returns nil
 LibCFFI.attach_llvm_jit_function :strcasecmp, [:string, :string], :int
 # => nil
 
@@ -63,11 +63,100 @@ LibCFFI.strcasecmp('aBBa', 'AbbA')
 # => 0
 ```
 
+### Blocking calls
+
+Pass `blocking: true` to release the GVL while the native function runs, allowing other Ruby threads to execute concurrently. Exceptions raised in other threads during the call are propagated correctly.
+
+```ruby
+LibCFFI.attach_llvm_jit_function :sleep, [:uint], :uint, blocking: true
+
+thread = Thread.new { LibCFFI.sleep(3600) }
+sleep(0.1) until thread.stop?
+thread.kill  # works — GVL is released during the blocking call
+```
+
+### Enums
+
+Enum symbols from `enum` declarations are resolved automatically before JIT calls. You can also pass a custom `FFI::Enums` object via the `enums:` option.
+
+```ruby
+module LibC
+  extend FFI::LLVMJIT::Library
+  ffi_lib FFI::Library::LIBC
+  enum :open_flags, [:rdonly, 0, :wronly, 1, :rdwr, 2]
+  attach_llvm_jit_function :open, [:string, :open_flags], :int
+end
+LibC.open('/dev/null', :rdonly)  # symbol :rdonly resolved to 0
+# => 5
+
+# Custom enums object:
+enums = FFI::Enums.new
+enums << FFI::Enum.new([:rdonly, 0])
+LibC.attach_llvm_jit_function :open2, :open, [:string, :int], :int, enums: enums
+```
+
+### DataConverter
+
+Types implementing `FFI::DataConverter` (mapped types) work for both arguments and return values. Stacked converters (where one converter's `native_type` is another `FFI::DataConverter`) are also supported.
+
+> [!WARNING]
+> Stacked converters currently [don't work](https://github.com/ffi/ffi/pull/1185) on MRI with the regular FFI gem.
+
+```ruby
+Squared = Class.new do
+  extend FFI::DataConverter
+  native_type FFI::Type::INT
+  def self.to_native(value, _ctx) = value**2
+  def self.from_native(value, _ctx) = value * 2
+end
+
+module Lib
+  extend FFI::LLVMJIT::Library
+  # ...
+  attach_llvm_jit_function :abs, [Squared], Squared
+end
+Lib.abs(3)  # to_native(3) => 9; C returns abs(9) = 9; from_native(9) => 18
+```
+
+### Errno
+
+`FFI.errno` is saved after every JIT call, matching standard FFI behavior.
+
+```ruby
+FFI.errno = 0
+LibCFFI.strtol('9' * 30, nil, 10)  # overflows
+FFI.errno  # => Errno::ERANGE::Errno
+```
+
+### Typedefs
+
+Type aliases defined with `typedef` are resolved transparently by the JIT.
+
+```ruby
+module Lib
+  extend FFI::LLVMJIT::Library
+  ffi_lib FFI::Library::LIBC
+  typedef :size_t, :length
+  attach_llvm_jit_function :strlen, [:string], :length  # :length resolves to :size_t
+end
+```
+
+> [!NOTE]
+> The `type_map:` option is ignored by `ffi-llvm-jit` (as it is by FFI for non-variadic functions). Use `typedef` on the module instead.
+
+### Fork safety
+
+Functions attached before a fork work correctly in the child process. Because `ffi-llvm-jit` uses eager (non-lazy) LLVM compilation, the native wrapper code is fully compiled at attach time and requires no further interaction with the JIT engine in the child.
+
+Attaching new functions after a fork is not supported — LLVM's JIT engine is not fork-safe; `attach_llvm_jit_function` raises `FFI::LLVMJIT::UnsupportedError`, and `attach_function` falls back to FFI silently.
+
+Forking servers (Unicorn, Puma in cluster mode, etc.) work fine in practice because `attach_function` is normally called at require time, and the server forks workers only after the application is fully loaded.
+
 ## Benchmarks
 
 `FFI::LLVMJIT` can be up to 2x faster when used with fast native functions, where FFI overhead is especially significant.
 
-Below is a benchmark that compares Ruby's `bytesize` method called directly and indirectly with C `strlen` method called via LLVMJIT, C extension and FFI respectively
+Below is a benchmark that compares Ruby's `bytesize` method called directly and indirectly with the C `strlen` method called via LLVMJIT, a C extension, and FFI respectively.
 
 ```
 Comparison:
@@ -82,7 +171,7 @@ Comparison:
 
 After checking out the repo, run `bin/setup` to install dependencies.
 
-LLVM 17 is used for development, install it via `apt install llvm17-dev` or change `ruby-llvm` version in [ffi-llvm-jit.gemspec](./ffi-llvm-jit.gemspec) if you want to use another version of LLVM.
+LLVM 17 is used for development. Install it via `apt install llvm17-dev`, or change the `ruby-llvm` version in [ffi-llvm-jit.gemspec](./ffi-llvm-jit.gemspec) to use a different version of LLVM.
 
 Then, run `bundle exec rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
@@ -92,6 +181,18 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome [on GitHub](https://github.com/uvlad7/ffi-llvm-jit).
 
+## AI assistance disclosure
+
+The core idea behind this gem — using LLVM's JIT compiler to eliminate FFI call overhead by generating native Ruby-to-C bridge functions at runtime — as well as the entire implementation, architecture, and design decisions are the author's original work.
+
+Claude (Anthropic) was used in an assistive capacity for:
+
+- **Documentation** — drafting and editing README sections, including usage examples and feature descriptions.
+- **Specs** — helping write RSpec test cases for newly added features.
+- **API discovery** — searching LLVM C API and ruby-llvm documentation to find relevant functions and capabilities. For example, `LLVM::C.add_symbol` — which registers native symbols with the JIT engine's global symbol table before compilation — was found this way, as was `LLVM::C.search_for_address_of_symbol` used to validate that all external declarations are resolved.
+
+All code, including the LLVM IR generation, the blocking call mechanism, the DataConverter pipeline, and the FFI compatibility layer, was written by the author without AI code generation.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/ext/ffi_llvm_jit/extconf.rb

@@ -6,5 +6,6 @@ require 'mkmf'
 # with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
 # selectively, or entirely remove this flag.
 append_cflags('-fvisibility=hidden')
+append_cflags('-Werror=implicit-function-declaration')
 
 create_makefile('llvm_jit/ffi_llvm_jit')

data/ext/ffi_llvm_jit/ffi_llvm_jit.c

@@ -6,7 +6,7 @@ VALUE rb_mFFILLVMJITLibrary;
 
 // from https://github.com/ffi/ffi/blob/master/ext/ffi_c/Function.c
 static VALUE
-attach_rb_wrap_function(VALUE module, VALUE name_val, VALUE func_val, VALUE argc_val)
+attach_rb_wrap_function(VALUE module, VALUE name_val, VALUE func_val, VALUE argc_val, VALUE private)
 {
   const char * name = StringValueCStr(name_val);
   VALUE (*func)(ANYARGS);
@@ -16,7 +16,7 @@ attach_rb_wrap_function(VALUE module, VALUE name_val, VALUE func_val, VALUE argc
   //   rb_raise(rb_eRuntimeError, "trying to attach function to non-module");
   //   return Qnil;
   // }
-  func = (VALUE (*)(VALUE))NUM2PTR(func_val);
+  func = (VALUE (*)(ANYARGS))NUM2PTR(func_val);
   if (func == NULL)
   {
     rb_raise(rb_eRuntimeError, "trying to attach NULL function");
@@ -24,8 +24,13 @@ attach_rb_wrap_function(VALUE module, VALUE name_val, VALUE func_val, VALUE argc
   }
   argc = NUM2INT(argc_val);
   // rb_define_module_function uses rb_define_private_method instead of rb_define_method
-  rb_define_singleton_method(module, name, func, argc);
-  rb_define_method(module, name, func, argc);
+  if (RTEST(private)) {
+    rb_define_private_method(rb_singleton_class(module), name, func, argc);
+    rb_define_private_method(module, name, func, argc);
+  } else {
+    rb_define_singleton_method(module, name, func, argc);
+    rb_define_method(module, name, func, argc);
+  }
 
   // return self;
   return module;
@@ -37,5 +42,14 @@ Init_ffi_llvm_jit(void)
   rb_mFFI = rb_define_module("FFI");
   rb_mFFILLVMJIT = rb_define_module_under(rb_mFFI, "LLVMJIT");
   rb_mFFILLVMJITLibrary = rb_define_module_under(rb_mFFILLVMJIT, "Library");
-  rb_define_private_method(rb_mFFILLVMJITLibrary, "attach_rb_wrap_function", attach_rb_wrap_function, 3);
+  rb_define_const(rb_mFFILLVMJITLibrary, "LLVM_STDCALL",
+  // That's how FFI hadles it, see https://github.com/ffi/ffi/blob/5b44581847bf167b83db51ac64aa409ccc9cabee/ext/ffi_c/FunctionInfo.c#L233
+  // the only supported calling convention other than default is stdcall on x86 windows
+#if defined(X86_WIN32)
+  rb_intern("x86_stdcall")
+#else
+  Qnil
+#endif
+  );
+  rb_define_private_method(rb_mFFILLVMJITLibrary, "attach_rb_wrap_function", attach_rb_wrap_function, 4);
 }

data/ext/llvm_bitcode/extconf.rb

@@ -11,7 +11,7 @@ RbConfig::MAKEFILE_CONFIG['LDSHARED'] =
 # RbConfig::MAKEFILE_CONFIG['DLEXT'] = RbConfig::CONFIG['DLEXT'] = 'bc'
 
 # required to push flags without checking
-$CFLAGS << ' -emit-llvm -c ' # rubocop:disable Style/GlobalVars
+$CFLAGS << ' -emit-llvm -c -Werror=implicit-function-declaration ' # rubocop:disable Style/GlobalVars
 
 # MakeMakefile::COMPILE_C = config_string('COMPILE_C') ||
 #   '$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG) -c $(CSRCFLAG)$<'

data/ext/llvm_bitcode/llvm_bitcode.c

@@ -146,10 +146,10 @@ __attribute__((always_inline)) VALUE ffi_llvm_jit_bool_to_value(bool arg) {
 // TODO: Since we generate code for every function, we could easily support safe
 // non-nullable arguments with almost no overhead.
 __attribute__((always_inline)) char * ffi_llvm_jit_value_to_string(VALUE arg) {
-    return NIL_P(arg) ? NULL : StringValueCStr(arg);
+    return unlikely(NIL_P(arg)) ? NULL : StringValueCStr(arg);
 }
 __attribute__((always_inline)) VALUE ffi_llvm_jit_string_to_value(char * arg) {
-    return arg != NULL ? rb_str_new2(arg) : Qnil;
+    return likely(arg != NULL) ? rb_str_new2(arg) : Qnil;
 }
 //     /** The function takes a variable number of arguments */
 //     NATIVE_VARARGS,
@@ -163,3 +163,35 @@ __attribute__((always_inline)) VALUE ffi_llvm_jit_string_to_value(char * arg) {
 //     /** Custom native type */
 //     NATIVE_MAPPED,
 // } NativeType;
+
+__attribute__((always_inline)) void ffi_llvm_jit_rb_gc_guard(VALUE v) {
+    RB_GC_GUARD(v);
+}
+
+VALUE ffi_llvm_jit_save_exception(VALUE data, VALUE exc) {
+    VALUE* store = (VALUE *) data;
+    *store = exc;
+    return Qnil;
+}
+
+__attribute__((always_inline)) void ffi_llvm_jit_raise_exception(VALUE exc) {
+    // For now, RTEST isn't needed here
+    if (exc) {
+        rb_exc_raise(exc);
+    }
+}
+
+typedef struct
+{
+    void* (*call_blocking_function_fn)(void *);
+    void *params_store;
+} ffi_llvm_jit_blocking_call_t;
+
+VALUE
+ffi_llvm_jit_blocking_call(VALUE data)
+{
+    ffi_llvm_jit_blocking_call_t* call_data = (ffi_llvm_jit_blocking_call_t *) data;
+    rb_thread_call_without_gvl(call_data->call_blocking_function_fn, call_data->params_store, (rb_unblock_function_t *)-1, NULL);
+
+    return Qnil;
+}

data/ext/llvm_bitcode/llvm_bitcode.h

@@ -2,7 +2,29 @@
 #define FFI_LLVM_JIT_LLVM_BITCODE_H 1
 
 #include "ruby.h"
+#include "ruby/thread.h"
 // #include <stdint.h>
 #include <stdbool.h>
 
+#ifdef __GNUC__
+#  define likely(x) __builtin_expect((x), 1)
+#  define unlikely(x) __builtin_expect((x), 0)
+#else
+#  define likely(x) (x)
+#  define unlikely(x) (x)
+#endif
+
+/* Resolved at JIT load time via LLVM::C.add_symbol */
+extern void ffi_llvm_jit_save_errno(void);
+
+__attribute__((used)) static void *llvm_keepalive[] = {
+    (void *)ffi_llvm_jit_save_errno,
+    (void *)rb_thread_call_without_gvl,
+    (void *)rb_rescue2,
+};
+
+__attribute__((used)) static VALUE *llvm_keepalive_values[] = {
+    &rb_eException,
+};
+
 #endif /* FFI_LLVM_JIT_LLVM_BITCODE_H */

data/lib/ffi/llvm_jit/version.rb

@@ -2,6 +2,6 @@
 
 module FFI
   module LLVMJIT
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/ffi/llvm_jit.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'set'
+
 require 'ffi'
 require 'llvm/core'
+require 'llvm/linker'
 require 'llvm/execution_engine'
 
 require_relative 'llvm_jit/version'
@@ -15,6 +18,8 @@ module FFI
 
   # Ruby FFI JIT using LLVM
   module LLVMJIT
+    class UnsupportedError < RuntimeError; end
+
     # Extension to FFI::Library to support JIT compilation using LLVM
     module Library # rubocop:disable Metrics/ModuleLength
       include ::FFI::Library
@@ -22,10 +27,30 @@ module FFI
       LLVM_MOD = LLVM::Module.parse_bitcode(
         File.expand_path("llvm_jit/llvm_bitcode.#{RbConfig::MAKEFILE_CONFIG['DLEXT']}", __dir__),
       )
+      LLVM_MOD.verify!
+
+      # Register FFI converter addresses with LLVM's global symbol table
+      # before JIT engine creation so they are resolved on first compilation.
+      LLVM::C.add_symbol(
+        'ffi_llvm_jit_save_errno',
+        FFI::DynamicLibrary.send(
+          :load_library, FFI::CURRENT_PROCESS, nil,
+        ).find_function('rbffi_save_errno'),
+      )
+
       LLVM.init_jit
       LLVM_ENG = LLVM::JITCompiler.new(LLVM_MOD, opt_level: 3)
+      LLVM_MUTEX = Mutex.new
+
+      # Validate all external declarations in the bitcode module are resolved.
+      # LLVM intrinsics (llvm.*) are handled natively by the JIT and not in the symbol table.
+      unresolved = LLVM_MOD.functions.select do |f|
+        f.declaration?.nonzero? && !f.name.start_with?('llvm.') &&
+          LLVM::C.search_for_address_of_symbol(f.name).null?
+      end
+      raise "Unresolved JIT symbols: #{unresolved.map(&:name).join(', ')}" unless unresolved.empty?
 
-      private_constant :LLVM_MOD, :LLVM_ENG
+      private_constant :LLVM_MOD, :LLVM_ENG, :LLVM_MUTEX
 
       # LLVM_ENG.dispose is never called
       # https://llvm.org/doxygen/group__LLVMCTarget.html#gaaa9ce583969eb8754512e70ec4b80061
@@ -35,8 +60,12 @@ module FFI
       # bits = FFI.type_size(:int) * 8
       # ::LLVM::Int = const_get("Int#{bits}")
       # see @LLVMinst inttoptr
-      POINTER = LLVM.const_get("Int#{FFI.type_size(:pointer) * 8}")
-      VALUE = POINTER
+      INTPTR = LLVM.const_get("Int#{FFI.type_size(:pointer) * 8}")
+      VALUE = INTPTR
+      VOID_PTR_T = LLVM.Pointer() # Opaque pointer I guess
+      BLOCKING_CALL_T = LLVM_MOD.types['struct.ffi_llvm_jit_blocking_call_t']
+      raise 'BLOCKING_CALL_T not found' unless BLOCKING_CALL_T
+
       LLVM_TYPES = {
         # Again, not sure. Char resolves into int8, but internally it uses 'signed char'
         void: LLVM.Void,
@@ -57,11 +86,11 @@ module FFI
         # anyway, they are just aliases
         float: LLVM::Float,
         double: LLVM::Double,
-        bool: LLVM.const_get("Int#{FFI.type_size(:bool) * 8}"),
-        string: LLVM.Pointer(LLVM::Int8),
+        bool: LLVM::Int1,
+        string: LLVM.Pointer(LLVM.const_get("Int#{FFI.type_size(:char) * 8}")),
       }.freeze
 
-      private_constant :POINTER, :VALUE, :LLVM_TYPES
+      private_constant :INTPTR, :VALUE, :VOID_PTR_T, :BLOCKING_CALL_T, :LLVM_TYPES, :LLVM_STDCALL
 
       # TODO: LLVM args
       # FFI::Type::Builtin to LLVM types
@@ -94,29 +123,40 @@ module FFI
       SUPPORTED_FROM_NATIVE.freeze
       private_constant :SUPPORTED_TO_NATIVE, :SUPPORTED_FROM_NATIVE
 
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      ENUM_TYPES = Set[
+        :int8, :int16, :int32, :uint8, :uint16, :uint32, :int64, :uint64, :long, :ulong, :float, :double, :long_double,
+      ].freeze
+      private_constant :ENUM_TYPES
+
+      INIT_PID = Process.pid
+      private_constant :INIT_PID
+
+      # rubocop:disable Metrics/MethodLength, Metrics/BlockLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      # @note Return type doesn't match the original method, but it's usually not used
       # @see https://www.rubydoc.info/gems/ffi/FFI/Library#attach_function-instance_method FFI::Library.attach_function
       def attach_function(name, func, args, returns = nil, options = nil)
-        mname, cname, arg_types, ret_type, options = convert_params(name, func, args, returns, options)
-        return if attached_llvm_jit_function?(mname, cname, arg_types, ret_type, options)
-
-        super(mname, cname, arg_types, ret_type, options)
+        mname, cname, arg_types, ret_type, options = convert_attach_function_params(name, func, args, returns, options)
+        function_handle = find_function_handle(cname, arg_types)
+        attach_function_handle(function_handle, mname, arg_types, ret_type, options)
       end
 
       # Same as +attach_function+, but raises an exception if cannot create JIT function
       # instead of falling back to the regular FFI function
       def attach_llvm_jit_function(name, func, args, returns = nil, options = nil)
-        mname, cname, arg_types, ret_type, options = convert_params(name, func, args, returns, options)
-        return if attached_llvm_jit_function?(mname, cname, arg_types, ret_type, options)
-
-        raise NotImplementedError, "Cannot create JIT function #{name}"
+        # TODO: support LLVM call_conv; note that function_names must be patched for that
+        # (they also forgot an underscore on Windows for cdecl)
+        # https://en.wikipedia.org/wiki/Name_mangling#C
+        # (see core_ffi.rb and https://llvm.org/doxygen/namespacellvm_1_1CallingConv.html)
+        mname, cname, arg_types, ret_type, options = convert_attach_function_params(name, func, args, returns, options)
+        function_handle = find_function_handle(cname, arg_types)
+        attach_function_handle(function_handle, mname, arg_types, ret_type, options, jit_only: true)
       end
 
       private
 
-      def convert_params(name, func, args, returns, options)
+      # Part copied from refactored FFI for compatibility
+
+      def convert_attach_function_params(name, func, args, returns, options)
         mname = name
         a2 = func
         a3 = args
@@ -129,6 +169,7 @@ module FFI
                                            end
         # Convert :foo to the native type
         arg_types = arg_types.map { |e| find_type(e) }
+        ret_type = find_type(ret_type)
         options = {
           convention: ffi_convention,
           type_map: defined?(@ffi_typedefs) ? @ffi_typedefs : nil,
@@ -142,92 +183,347 @@ module FFI
         [mname, cname, arg_types, ret_type, options]
       end
 
-      def attached_llvm_jit_function?(mname, cname, arg_types, ret_type, options)
-        # TODO: support stdcall convention (rb_func.call_conv=)
-        # TODO: support call_without_gvl
-        # Variadic functions are not supported; we could support known arguments,
-        # but we'd still need to know use libffi to create varargs
-        ret_type_name = SUPPORTED_FROM_NATIVE[find_type(ret_type)]
-        arg_type_names = arg_types.map { |arg_type| SUPPORTED_TO_NATIVE[arg_type] }
-        if options[:convention] != :default || !options[:type_map].nil? ||
-           options[:blocking] || options[:enums] || ret_type_name.nil? || arg_type_names.any?(&:nil?)
-          return false
-        end
-
-        function_handle = ffi_libraries.find do |lib|
-          fn = nil
+      def find_function_handle(cname, arg_types)
+        ffi_libraries.each do |lib|
           begin
-            function_names(cname, arg_types).find do |fname|
+            function_names(cname, arg_types).each do |fname|
               fn = lib.find_function(fname)
+              return fn if fn
             end
           rescue LoadError
             # Ignored
           end
-          break fn if fn
         end
-        raise FFI::NotFoundError.new(cname.to_s, ffi_libraries.map(&:name)) unless function_handle
 
-        attach_llvm_jit_function_addr(mname, function_handle.address, arg_type_names, ret_type_name)
-        # singleton_class.alias_method rb_name, jit_name
-        # alias_method rb_name, jit_name
-        true
+        raise FFI::NotFoundError.new(cname.to_s, ffi_libraries.map(&:name))
+      end
+
+      ###### End ######
+
+      def attach_function_handle(function_handle, mname, arg_types, ret_type, options, jit_only: false)
+        attach_llvm_jit_function_handle(function_handle, mname, arg_types, ret_type, options)
+      rescue UnsupportedError
+        raise if jit_only
+
+        # Part copied from refactored FFI for compatibility
+        invoker = if arg_types[-1] == FFI::NativeType::VARARGS
+                    VariadicInvoker.new(function_handle, arg_types, ret_type, options)
+                  else
+                    Function.new(ret_type, arg_types, function_handle, options)
+                  end
+        invoker.attach(self, mname.to_s)
+        invoker
+      else
+        return if jit_only
+
+        invoker = Function.new(ret_type, arg_types, function_handle, options)
+        @ffi_functions ||= {}
+        @ffi_functions[mname.to_s.to_sym] = invoker
+        invoker
+      end
+
+      def attach_llvm_jit_function_handle(function_handle, mname, arg_types, ret_type, options)
+        raise UnsupportedError, "Can't use LLVM after fork" unless Process.pid == INIT_PID
+
+        unknown_options = options.keys - %i[convention type_map blocking enums]
+        unless unknown_options.empty?
+          raise UnsupportedError, "Unsupported option#{'s' if unknown_options.size > 1}: #{unknown_options.join(', ')}"
+        end
+
+        type_mappers = []
+        arg_types = arg_types.map.with_index do |arg_type, i|
+          while arg_type.is_a?(Type::Mapped)
+            type_mappers[i] ||= []
+            type_mappers[i].push(arg_type)
+            arg_type = arg_type.native_type
+          end
+          arg_type
+        end
+
+        while ret_type.is_a?(Type::Mapped)
+          type_mappers[arg_types.size] ||= []
+          type_mappers[arg_types.size].unshift(ret_type)
+          ret_type = ret_type.native_type
+        end
+
+        # TODO: support call conventions other than stdcall (rb_func.call_conv=)
+        # TODO: support call_without_gvl
+        # Variadic functions are not supported; we could support known arguments,
+        # but we'd still need to know use libffi to create varargs
+        ret_type_name = SUPPORTED_FROM_NATIVE.fetch(ret_type) do
+          raise UnsupportedError, "Unsupported return type: #{ret_type.inspect}"
+        end
+
+        arg_type_names = arg_types.map do |arg_type|
+          SUPPORTED_TO_NATIVE.fetch(arg_type) do
+            raise UnsupportedError, "Unsupported argument type: #{arg_type.inspect}"
+          end
+        end
+        enum_types = []
+        unless options[:enums].nil?
+          arg_type_names.each_with_index { |arg_type_name, i| enum_types.push(i) if ENUM_TYPES.include?(arg_type_name) }
+        end
+        # Value type_map from opts is ignored by FFI for regular functions and is used only in Variadic
+        # Here we do the same and don't need to guard against type_map
+
+        call_conv = options[:convention]&.to_s == 'stdcall' ? LLVM_STDCALL : nil
+        rb_func_addr, uniq_id = llvm_jit_function_addr(
+          mname, function_handle.address, arg_type_names, ret_type_name, call_conv,
+          blocking: options[:blocking],
+        )
+        attach_jit_and_wrappers(mname, rb_func_addr, uniq_id, arg_types, enum_types, type_mappers, options)
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def attach_jit_and_wrappers(mname, rb_func_addr, uniq_id, arg_types, enum_types, type_mappers, options)
+        if enum_types.empty? && type_mappers.empty?
+          attach_rb_wrap_function(mname.to_s, rb_func_addr, arg_types.size, false)
+        else
+          # mapped.to_native is the same as mapped.converter.to_native
+          # mapped.from_native is the same as mapped.converter.from_native
+          # mapped.native_type is the same as mapped.converter.native_type
+          enums_and_mappers = [options[:enums], type_mappers] # rubocop:disable Lint/UselessAssignment
+          code = <<-CODE
+            @_ffi_jit_enums_and_mappers_#{uniq_id} = enums_and_mappers
+
+            def self.included(base)
+              base.instance_variable_set(:@_ffi_jit_enums_and_mappers_#{uniq_id}, @_ffi_jit_enums_and_mappers_#{uniq_id})
+              super
+            end
+
+            def self.#{mname}(#{arg_types.size.times.map { |i| "arg_#{i}" }.join(', ')})
+              enums, type_mappers = @_ffi_jit_enums_and_mappers_#{uniq_id}
+              #{
+                arg_types.size.times.map do |i|
+                  next unless type_mappers[i]
+
+                  "type_mappers[#{i}].each { |mapper| arg_#{i} = mapper.to_native(arg_#{i}, nil) }"
+                end.join("\n")
+              }
+              #{enum_types.map { |i| "arg_#{i} = enums.__map_symbol(arg_#{i}) if arg_#{i}.is_a?(Symbol)" }.join("\n")}
+              res = #{mname}_#{uniq_id}(#{arg_types.size.times.map { |i| "arg_#{i}" }.join(', ')})
+              #{
+                if type_mappers[arg_types.size]
+                  i = arg_types.size
+                  "type_mappers[#{i}].each { |mapper| res = mapper.from_native(res, nil) }"
+                end
+              }
+              res
+            end
+
+            def #{mname}(#{arg_types.size.times.map { |i| "arg_#{i}" }.join(', ')})
+              enums, type_mappers = self.class.instance_variable_get(:@_ffi_jit_enums_and_mappers_#{uniq_id})
+              #{
+                arg_types.size.times.map do |i|
+                  next unless type_mappers[i]
+
+                  "type_mappers[#{i}].each { |mapper| arg_#{i} = mapper.to_native(arg_#{i}, nil) }"
+                end.join("\n")
+              }
+              #{enum_types.map { |i| "arg_#{i} = enums.__map_symbol(arg_#{i}) if arg_#{i}.is_a?(Symbol)" }.join("\n")}
+              res = #{mname}_#{uniq_id}(#{arg_types.size.times.map { |i| "arg_#{i}" }.join(', ')})
+              #{
+                if type_mappers[arg_types.size]
+                  i = arg_types.size
+                  "type_mappers[#{i}].each { |mapper| res = mapper.from_native(res, nil) }"
+                end
+              }
+              res
+            end
+          CODE
+          attach_rb_wrap_function("#{mname}_#{uniq_id}", rb_func_addr, arg_types.size, true)
+          module_eval code, __FILE__, __LINE__
+        end
       end
+      # rubocop:enable Metrics/ParameterLists
 
-      def attach_llvm_jit_function_addr(rb_name, c_address, arg_type_names, ret_type_name)
+      def llvm_jit_function_addr(rb_name, c_address, arg_type_names, ret_type_name, call_conv, blocking:)
         # AFAIK name doesn't need to be unique
         llvm_mod = LLVM::Module.new('llvm_jit')
         # string -> LLVM.Pointer; size_t -> LLVM::Int64
-        fn_type = LLVM.Function(
-          arg_type_names.map { |arg_type| LLVM_TYPES[arg_type] },
-          LLVM_TYPES[ret_type_name],
-        )
-        fn_ptr_type = LLVM.Pointer(fn_type)
+        arg_types = arg_type_names.map { |arg_type| LLVM_TYPES[arg_type] }
+        ret_type = LLVM_TYPES[ret_type_name]
+        func_t = LLVM.Function(arg_types, ret_type)
+        func_ptr_t = LLVM.Pointer(func_t)
         # Unnamed, can change '' into :"#{cname}_ptr" for debugging, but unnamed is better to prevent name clashes
-        func_ptr = llvm_mod.globals.add(POINTER, '') do |var|
+        func_ptr = llvm_mod.globals.add(func_ptr_t, '') do |var|
           var.linkage = :private
           var.global_constant = true
           var.unnamed_addr = true
-          var.initializer = POINTER.from_i(c_address)
+          var.initializer = INTPTR.from_i(c_address).int_to_ptr(func_ptr_t)
+        end
+        void_ret = ret_type_name == :void
+
+        if blocking
+          params_store_fields = [*arg_types, *(ret_type unless void_ret)]
+          params_store_t = LLVM.Struct(*params_store_fields) unless params_store_fields.empty?
+          call_blocking_func = llvm_mod.functions.add(
+            '', [VOID_PTR_T], VOID_PTR_T,
+          ) do |llvm_function, params_store|
+            llvm_function.basic_blocks.append('entry').build do |builder|
+              converted_params = arg_types.map.with_index do |t, i|
+                builder.load2(t, builder.gep2(params_store_t, params_store, [LLVM::Int(0), LLVM::Int(i)], ''))
+              end
+              ret = emit_cfunc_call(
+                builder, call_conv, converted_params, func_ptr, func_t,
+              )
+              unless void_ret
+                builder.store(
+                  ret, builder.gep2(params_store_t, params_store, [LLVM::Int(0), LLVM::Int(arg_types.size)], ''),
+                )
+              end
+              builder.ret(VOID_PTR_T.null)
+            end
+          end
         end
 
-        # Something is wrong in case of name collizion; and even though you can
+        # Something is wrong in case of name collision; and even though you can
         # update rb_func.name=, function_address is still zero
         # Upd: It happens if functions are the same even though their names are different
-
         rb_func = llvm_mod.functions.add(
-          :"rb_llvm_jit_wrap_#{rb_name}_#{llvm_mod.to_ptr.address}", [VALUE] * (arg_type_names.size + 1), VALUE,
+          :"rb_llvm_jit_wrap_#{rb_name}_#{llvm_mod.to_ptr.address}", [VALUE] * (1 + arg_type_names.size), VALUE,
         ) do |llvm_function, _rb_self, *params|
-          llvm_function.basic_blocks.append('entry').build do |b|
+          llvm_function.basic_blocks.append('entry').build do |builder|
+            # less readable, but easier that to position builder
+            # TODO: figure out builder.position stuff
+            if blocking
+              params_store = builder.alloca(params_store_t) if params_store_t
+              call_data = builder.alloca(BLOCKING_CALL_T)
+              exc_store = builder.alloca(VALUE)
+            end
             converted_params = arg_type_names.zip(params).map do |arg_type, param|
-              b.call(LLVM_MOD.functions["ffi_llvm_jit_value_to_#{arg_type}"], param)
+              builder.call(
+                link_external_function(llvm_mod, "ffi_llvm_jit_value_to_#{arg_type}"),
+                param,
+              )
             end
-
-            func_ptr_val = b.int2ptr(func_ptr, fn_ptr_type)
-            res = b.call2(fn_type, b.load2(fn_ptr_type, func_ptr_val), *converted_params)
-            b.ret(
-              if ret_type_name == :void
-                b.load2(VALUE, LLVM_MOD.globals['ffi_llvm_jit_Qnil'])
+            res = if blocking
+                    emit_blocking_call(
+                      builder, llvm_mod, params_store_t, exc_store, converted_params, call_blocking_func,
+                      void_ret ? nil : ret_type, params_store, call_data,
+                    )
+                  else
+                    emit_cfunc_call(
+                      builder, call_conv, converted_params, func_ptr, func_t,
+                    )
+                  end
+            # TODO: make it optional - in orig FFI there is ignoreErrno flag that's never set
+            builder.call(link_external_function(llvm_mod, 'ffi_llvm_jit_save_errno'))
+            # In FFI it's also used to re-raise from callbacks, but here it's only for blocking calls
+            if blocking
+              builder.call(
+                link_external_function(llvm_mod, 'ffi_llvm_jit_raise_exception'), builder.load(exc_store),
+              )
+            end
+            builder.ret(
+              if void_ret
+                builder.load2(VALUE, link_external_global(llvm_mod, 'ffi_llvm_jit_Qnil'))
               else
-                b.call(LLVM_MOD.functions["ffi_llvm_jit_#{ret_type_name}_to_value"], res)
+                # Note for future: in FFI struct layout redefinition doesn't change ffiParameterTypes of
+                #   already attached functions
+                builder.call(
+                  link_external_function(llvm_mod, "ffi_llvm_jit_#{ret_type_name}_to_value"),
+                  res,
+                )
               end,
             )
           end
         end
 
-        # Ruby llvm_mod object isn't kept arount and might be GCed, but
-        # it doesn't call +dispose+ automatically, so it's ok.
-        # Note that in function name +llvm_mod.hash+ is used and it
-        # mustn't be reused until the module is disposed, unlike
-        # Ruby's object_id, which may be reused and cause name clashes in some rare cases.
-        LLVM_ENG.modules.add(llvm_mod)
-        # rb_func.name isn't always the same as rb_name, in case of name clashes
-        # it contains a postfix like "rb_llvm_jit_wrap_strlen.1"
-        # https://llvm.org/doxygen/group__LLVMCExecutionEngine.html
-        attach_rb_wrap_function(rb_name.to_s, LLVM_ENG.function_address(rb_func.name), arg_type_names.size)
-        nil
+        rb_func_addr = LLVM_MUTEX.synchronize do
+          # TODO: investigate what's more performant: function linking or link module into
+          # LLVM_MOD.link_into(llvm_mod)
+          # rb_func.dump
+
+          # Ruby llvm_mod object isn't kept around and might be GCed, but
+          # it doesn't call +dispose+ automatically, so it's ok.
+          # Note that in function name +llvm_mod.hash+ is used and it
+          # mustn't be reused until the module is disposed, unlike
+          # Ruby's object_id, which may be reused and cause name clashes in some rare cases.
+          LLVM_ENG.modules.add(llvm_mod)
+          call_blocking_func&.verify!
+          rb_func.verify!
+          llvm_mod.verify!
+          # rb_func.name isn't always the same as rb_name, in case of name clashes
+          # it contains a postfix like "rb_llvm_jit_wrap_strlen.1"
+          # https://llvm.org/doxygen/group__LLVMCExecutionEngine.html
+          LLVM_ENG.function_address(rb_func.name)
+        end
+        # I'm not sure whether func addr can be the same in ORC JIT, but I'm pretty sure module address is unique
+        [rb_func_addr, llvm_mod.to_ptr.address]
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def emit_blocking_call(
+        builder, llvm_mod, params_store_t, exc_store, converted_params, call_blocking_func, ret_type,
+        params_store, call_data
+      )
+        builder.store(
+          # Maybe use Qnil here? But const is probably faster
+          VALUE.from_i(0),
+          exc_store,
+        )
+        converted_params.each_with_index do |p, i|
+          builder.store(p, builder.gep2(params_store_t, params_store, [LLVM::Int(0), LLVM::Int(i)], ''))
+        end
+        builder.store(call_blocking_func, builder.gep2(BLOCKING_CALL_T, call_data, [LLVM::Int(0), LLVM::Int(0)], ''))
+        builder.store(
+          params_store || VOID_PTR_T.null,
+          builder.gep2(BLOCKING_CALL_T, call_data, [LLVM::Int(0), LLVM::Int(1)], ''),
+        )
+        builder.call(
+          link_external_function(llvm_mod, 'rb_rescue2'),
+          link_external_function(llvm_mod, 'ffi_llvm_jit_blocking_call'),
+          builder.ptr2int(call_data, VALUE),
+          link_external_function(llvm_mod, 'ffi_llvm_jit_save_exception'),
+          builder.ptr2int(exc_store, VALUE),
+          builder.load2(VALUE, link_external_global(llvm_mod, 'rb_eException')),
+          VALUE.from_i(0),
+        )
+        return unless ret_type
+
+        builder.load2(
+          ret_type,
+          builder.gep2(params_store_t, params_store, [LLVM::Int(0), LLVM::Int(converted_params.size)], ''),
+        )
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def emit_cfunc_call(builder, call_conv, converted_params, func_ptr, func_t)
+        func_ptr_val = builder.load(func_ptr)
+        # See value.rb (Function) and builder.rb (Builder#call2)
+        # func_ptr_val is actually an Instruction, can't set call_conv
+        res = builder.call2(func_t, func_ptr_val, *converted_params)
+        res.call_conv = call_conv if call_conv
+        res
+      end
+
+      def link_external_function(mod, name)
+        unless mod.functions[name]
+          external_function = LLVM_MOD.functions[name]
+          func = mod.functions.add(name, external_function.function_type)
+          func.linkage = :external
+          func.call_conv = external_function.call_conv
+          external_function.function_attributes.to_a.each { |attr| func.add_attribute(attr, -1) }
+          external_function.return_attributes.to_a.each { |attr| func.add_attribute(attr, 0) }
+          external_function.params.size.times do |idx|
+            external_function.param_attributes(idx + 1).to_a.each do |attr|
+              func.add_attribute(attr, idx + 1)
+            end
+          end
+        end
+        mod.functions[name]
+      end
+
+      def link_external_global(mod, name)
+        unless mod.globals[name]
+          glob = mod.globals.add(LLVM::Type.from_ptr(LLVM::C.get_value_type(LLVM_MOD.globals[name]), nil), name)
+          glob.linkage = :external
+        end
+        mod.globals[name]
       end
 
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/MethodLength, Metrics/BlockLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-llvm-jit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - uvlad7
@@ -217,9 +217,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/uvlad7/ffi-llvm-jit
-  source_code_uri: https://github.com/uvlad7/ffi-llvm-jit/tree/v0.1.0
+  source_code_uri: https://github.com/uvlad7/ffi-llvm-jit/tree/v0.2.0
   changelog_uri: https://github.com/uvlad7/ffi-llvm-jit/blob/main/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/ffi-llvm-jit/0.1.0
+  documentation_uri: https://rubydoc.info/gems/ffi-llvm-jit/0.2.0
 rdoc_options: []
 require_paths:
 - lib