ffi-llvm-jit 0.1.0

checksums.yaml

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 uvlad7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# FFI::LLVMJIT
+
+Extends Ruby FFI and uses LLVM to generate JIT wrappers for attached native functions. Works only on MRI.
+
+## Requirements
+
+The gem depends on `ruby-llvm` gem, which requires `llvm` development package to be installed.
+
+On Debian/Ubuntu you can install it with `apt install llvmXX-dev`, where `XX` is a major version of `ruby-llvm` gem.
+For other systems, refer to `ruby-llvm` [README](https://github.com/ruby-llvm/ruby-llvm/blob/master/README.md).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add ffi-llvm-jit
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+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.
+
+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.
+
+Example:
+
+```ruby
+require 'ffi/llvm_jit'
+
+module LibCFFI
+  extend FFI::LLVMJIT::Library
+  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>
+
+LibCFFI.attach_function :printf, [:string, :varargs], :int
+# => #<FFI::VariadicInvoker:0x0000766a3ac4a200 @fixed=[#<FFI::Type::Builtin::STRING size=8 alignment=8>], @type_map=nil>
+
+begin
+  LibCFFI.attach_llvm_jit_function :strcasecmp, [:string, :string], :int, blocking: true
+rescue NotImplementedError => e
+  e
+end
+# => #<NotImplementedError: Cannot create JIT function strcasecmp>
+
+LibCFFI.attach_llvm_jit_function :strcasecmp, [:string, :string], :int
+# => nil
+
+LibCFFI.strcasecmp('aBBa', 'AbbA')
+# => 0
+```
+
+## 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
+
+```
+Comparison:
+         ruby-direct: 15089241.4 i/s
+         strlen-ruby: 11353201.8 i/s - 1.33x  slower
+ strlen-ffi-llvm-jit: 10839778.2 i/s - 1.39x  slower
+         strlen-cext: 10822451.7 i/s - 1.39x  slower
+          strlen-ffi:  5058105.5 i/s - 2.98x  slower
+```
+
+## Development
+
+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.
+
+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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome [on GitHub](https://github.com/uvlad7/ffi-llvm-jit).
+
+## 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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+# Makes all symbols private by default to avoid unintended conflict
+# with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
+# selectively, or entirely remove this flag.
+append_cflags('-fvisibility=hidden')
+
+create_makefile('llvm_jit/ffi_llvm_jit')

data/ext/ffi_llvm_jit/ffi_llvm_jit.c

@@ -0,0 +1,41 @@
+#include "ffi_llvm_jit.h"
+
+VALUE rb_mFFI;
+VALUE rb_mFFILLVMJIT;
+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)
+{
+  const char * name = StringValueCStr(name_val);
+  VALUE (*func)(ANYARGS);
+  int argc;
+  // if (!rb_obj_is_kind_of(module, rb_cModule))
+  // {
+  //   rb_raise(rb_eRuntimeError, "trying to attach function to non-module");
+  //   return Qnil;
+  // }
+  func = (VALUE (*)(VALUE))NUM2PTR(func_val);
+  if (func == NULL)
+  {
+    rb_raise(rb_eRuntimeError, "trying to attach NULL function");
+    return Qnil;
+  }
+  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);
+
+  // return self;
+  return module;
+}
+
+RUBY_FUNC_EXPORTED void
+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);
+}

data/ext/ffi_llvm_jit/ffi_llvm_jit.h

@@ -0,0 +1,16 @@
+#ifndef FFI_LLVM_JIT_H
+#define FFI_LLVM_JIT_H 1
+
+#include "ruby.h"
+
+
+#if SIZEOF_VOIDP == SIZEOF_LONG
+# define PTR2NUM(x)   (LONG2NUM((long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#else
+/* # error --->> Ruby/DL2 requires sizeof(void*) == sizeof(long) to be compiled. <<--- */
+# define PTR2NUM(x)   (LL2NUM((LONG_LONG)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#endif
+
+#endif /* FFI_LLVM_JIT_H */

data/ext/llvm_bitcode/extconf.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+RbConfig::MAKEFILE_CONFIG['CC'] = RbConfig::CONFIG['CC'] = 'clang'
+RbConfig::MAKEFILE_CONFIG['CXX'] = RbConfig::CONFIG['CXX'] = 'clang++'
+RbConfig::MAKEFILE_CONFIG['LDSHARED'] =
+  RbConfig::CONFIG['LDSHARED'] = "ruby -rfileutils -e 'FileUtils.cp(ARGV[2], ARGV[1])' -- "
+# RbConfig::MAKEFILE_CONFIG['MKMF_VERBOSE'] = RbConfig::CONFIG['MKMF_VERBOSE'] = '1'
+# cp into lib dir won't work; just use MAKEFILE_CONFIG later to find the extname
+# RbConfig::MAKEFILE_CONFIG['DLEXT'] = RbConfig::CONFIG['DLEXT'] = 'bc'
+
+# required to push flags without checking
+$CFLAGS << ' -emit-llvm -c ' # rubocop:disable Style/GlobalVars
+
+# MakeMakefile::COMPILE_C = config_string('COMPILE_C') ||
+#   '$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG) -c $(CSRCFLAG)$<'
+
+create_makefile('llvm_jit/llvm_bitcode')

data/ext/llvm_bitcode/llvm_bitcode.c

@@ -0,0 +1,165 @@
+#include "llvm_bitcode.h"
+
+// See https://github.com/ffi/ffi/blob/master/ext/ffi_c/Call.c
+// https://github.com/ffi/ffi/blob/master/ext/ffi_c/Function.c
+// rbffi_SetupCallParams
+// and
+// See https://github.com/ffi/ffi/blob/master/ext/ffi_c/Types.c
+// rbffi_NativeValue_ToRuby
+// typedef union {
+// #ifdef USE_RAW
+//     signed int s8, s16, s32;
+//     unsigned int u8, u16, u32;
+// #else
+//     signed char s8;
+//     unsigned char u8;
+//     signed short s16;
+//     unsigned short u16;
+//     signed int s32;
+//     unsigned int u32;
+// #endif
+//     signed long long i64;
+//     unsigned long long u64;
+//     signed long sl;
+//     unsigned long ul;
+//     void* ptr;
+//     float f32;
+//     double f64;
+//     long double ld;
+// } FFIStorage;
+// typedef enum {
+//     NATIVE_VOID,
+VALUE ffi_llvm_jit_Qnil = Qnil;
+//     NATIVE_INT8,
+__attribute__((always_inline)) signed char ffi_llvm_jit_value_to_int8(VALUE arg) {
+    return NUM2INT(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_int8_to_value(signed char arg) {
+    return INT2NUM(arg);
+}
+//     NATIVE_UINT8,
+__attribute__((always_inline)) unsigned char ffi_llvm_jit_value_to_uint8(VALUE arg) {
+    return NUM2UINT(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_uint8_to_value(unsigned char arg) {
+    return UINT2NUM(arg);
+}
+//     NATIVE_INT16,
+__attribute__((always_inline)) signed short ffi_llvm_jit_value_to_int16(VALUE arg) {
+    return NUM2INT(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_int16_to_value(signed short arg) {
+    return INT2NUM(arg);
+}
+//     NATIVE_UINT16,
+__attribute__((always_inline)) unsigned short ffi_llvm_jit_value_to_uint16(VALUE arg) {
+    return NUM2UINT(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_uint16_to_value(unsigned short arg) {
+    return UINT2NUM(arg);
+}
+//     NATIVE_INT32,
+__attribute__((always_inline)) signed int ffi_llvm_jit_value_to_int32(VALUE arg) {
+    return NUM2INT(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_int32_to_value(signed int arg) {
+    return INT2NUM(arg);
+}
+//     NATIVE_UINT32,
+__attribute__((always_inline)) unsigned int ffi_llvm_jit_value_to_uint32(VALUE arg) {
+    return NUM2UINT(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_uint32_to_value(unsigned int arg) {
+    return UINT2NUM(arg);
+}
+//     NATIVE_INT64,
+__attribute__((always_inline)) signed long long ffi_llvm_jit_value_to_int64(VALUE arg) {
+    return NUM2LL(arg);
+}
+// TODO: Ruby defines long long differently, see include/ruby/backward/2/long_long.h
+// but FFI simply uses `long long`, and so do I
+__attribute__((always_inline)) VALUE ffi_llvm_jit_int64_to_value(signed long long arg) {
+    return LL2NUM(arg);
+}
+//     NATIVE_UINT64,
+__attribute__((always_inline)) unsigned long long ffi_llvm_jit_value_to_uint64(VALUE arg) {
+    return NUM2ULL(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_uint64_to_value(unsigned long long arg) {
+    return ULL2NUM(arg);
+}
+//     NATIVE_LONG,
+__attribute__((always_inline)) signed long ffi_llvm_jit_value_to_long(VALUE arg) {
+    return NUM2LONG(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_long_to_value(signed long arg) {
+    return LONG2NUM(arg);
+}
+//     NATIVE_ULONG,
+__attribute__((always_inline)) unsigned long ffi_llvm_jit_value_to_ulong(VALUE arg) {
+    return NUM2ULONG(arg);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_ulong_to_value(unsigned long arg) {
+    return ULONG2NUM(arg);
+}
+//     NATIVE_FLOAT32,
+__attribute__((always_inline)) VALUE ffi_llvm_jit_float_to_value(float arg) {
+    // FFI uses rb_float_new, I prefer DBL2NUM - which is defined exactly like that - for consistency
+    return DBL2NUM(arg);
+}
+__attribute__((always_inline)) float ffi_llvm_jit_value_to_float(VALUE arg) {
+    return (float) NUM2DBL(arg);
+}
+//     NATIVE_FLOAT64,
+__attribute__((always_inline)) VALUE ffi_llvm_jit_double_to_value(double arg) {
+    return DBL2NUM(arg);
+}
+__attribute__((always_inline)) double ffi_llvm_jit_value_to_double(VALUE arg) {
+    return NUM2DBL(arg);
+}
+//     NATIVE_LONGDOUBLE,
+//     NATIVE_POINTER,
+//     NATIVE_FUNCTION,
+//     NATIVE_BUFFER_IN,
+//     NATIVE_BUFFER_OUT,
+//     NATIVE_BUFFER_INOUT,
+//     NATIVE_BOOL,
+// They use signed char as return value, but unsigned char as param when convert into Ruby, for some reason
+__attribute__((always_inline)) bool ffi_llvm_jit_value_to_bool(VALUE arg) {
+    // return RTEST(arg);
+    // I'd use RTEST, but FFI enforces that the argument is a boolean.
+    switch (TYPE(arg)) {
+        case T_TRUE:
+            return true;
+        case T_FALSE:
+            return false;
+        default:
+            rb_raise(rb_eTypeError, "wrong argument type  (expected a boolean parameter)");
+    }
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_bool_to_value(bool arg) {
+    return arg ? Qtrue : Qfalse;
+}
+//     /** An immutable string.  Nul terminated, but only copies in to the native function */
+//     NATIVE_STRING,
+//
+// 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);
+}
+__attribute__((always_inline)) VALUE ffi_llvm_jit_string_to_value(char * arg) {
+    return arg != NULL ? rb_str_new2(arg) : Qnil;
+}
+//     /** The function takes a variable number of arguments */
+//     NATIVE_VARARGS,
+
+//     /** Struct-by-value param or result */
+//     NATIVE_STRUCT,
+
+//     /** An array type definition */
+//     NATIVE_ARRAY,
+
+//     /** Custom native type */
+//     NATIVE_MAPPED,
+// } NativeType;

data/ext/llvm_bitcode/llvm_bitcode.h

@@ -0,0 +1,8 @@
+#ifndef FFI_LLVM_JIT_LLVM_BITCODE_H
+#define FFI_LLVM_JIT_LLVM_BITCODE_H 1
+
+#include "ruby.h"
+// #include <stdint.h>
+#include <stdbool.h>
+
+#endif /* FFI_LLVM_JIT_LLVM_BITCODE_H */

data/lib/ffi/llvm_jit/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module FFI
+  module LLVMJIT
+    VERSION = '0.1.0'
+  end
+end

data/lib/ffi/llvm_jit.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'llvm/core'
+require 'llvm/execution_engine'
+
+require_relative 'llvm_jit/version'
+require_relative 'llvm_jit/ffi_llvm_jit'
+
+module FFI
+  # https://llvm.org/doxygen/group__LLVMCCoreModule.html
+  # https://llvm.org/doxygen/group__LLVMCBitReader.html
+  # https://llvm.org/doxygen/group__LLVMCCoreMemoryBuffers.html
+  # see llvm/core/bitcode.rb
+
+  # Ruby FFI JIT using LLVM
+  module LLVMJIT
+    # Extension to FFI::Library to support JIT compilation using LLVM
+    module Library # rubocop:disable Metrics/ModuleLength
+      include ::FFI::Library
+
+      LLVM_MOD = LLVM::Module.parse_bitcode(
+        File.expand_path("llvm_jit/llvm_bitcode.#{RbConfig::MAKEFILE_CONFIG['DLEXT']}", __dir__),
+      )
+      LLVM.init_jit
+      LLVM_ENG = LLVM::JITCompiler.new(LLVM_MOD, opt_level: 3)
+
+      private_constant :LLVM_MOD, :LLVM_ENG
+
+      # LLVM_ENG.dispose is never called
+      # https://llvm.org/doxygen/group__LLVMCTarget.html#gaaa9ce583969eb8754512e70ec4b80061
+      # LLVM_MOD.dump
+
+      # # Native integer type
+      # 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
+      LLVM_TYPES = {
+        # Again, not sure. Char resolves into int8, but internally it uses 'signed char'
+        void: LLVM.Void,
+        int8: LLVM.const_get("Int#{FFI.type_size(:int8) * 8}"),
+        uint8: LLVM.const_get("Int#{FFI.type_size(:uint8) * 8}"),
+        int16: LLVM.const_get("Int#{FFI.type_size(:int16) * 8}"),
+        uint16: LLVM.const_get("Int#{FFI.type_size(:uint16) * 8}"),
+        int32: LLVM.const_get("Int#{FFI.type_size(:int32) * 8}"),
+        uint32: LLVM.const_get("Int#{FFI.type_size(:uint32) * 8}"),
+        int64: LLVM.const_get("Int#{FFI.type_size(:int64) * 8}"),
+        uint64: LLVM.const_get("Int#{FFI.type_size(:uint64) * 8}"),
+        long: LLVM.const_get("Int#{FFI.type_size(:long) * 8}"),
+        ulong: LLVM.const_get("Int#{FFI.type_size(:ulong) * 8}"),
+        # These types are actually defined as float and double in FFI
+        # and despite they are called float32 and float64 in the definitions
+        # and having FFI::NativeType::FLOAT32/FFI::NativeType::FLOAT64 constants,
+        # you can't find them through FFI.find_type and therefore use in attach_function
+        # 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),
+      }.freeze
+
+      private_constant :POINTER, :VALUE, :LLVM_TYPES
+
+      # TODO: LLVM args
+      # FFI::Type::Builtin to LLVM types
+      # FFI::NativeType.constants
+      # https://github.com/ffi/ffi/blob/master/ext/ffi_c/Type.c#L410
+
+      # rubocop:disable Style/MutableConstant
+      # Frozen later
+
+      SUPPORTED_TO_NATIVE = {}
+      SUPPORTED_FROM_NATIVE = {}
+
+      # rubocop:enable Style/MutableConstant
+
+      LLVM_MOD.functions.each do |func|
+        name = func.name
+        if name[/\Affi_llvm_jit_value_to_(.*)\z/, 1]
+          type = Regexp.last_match(1).to_sym
+          SUPPORTED_TO_NATIVE[FFI.find_type(type)] = type
+        elsif name[/\Affi_llvm_jit_(.*)_to_value\z/]
+          type = Regexp.last_match(1).to_sym
+          SUPPORTED_FROM_NATIVE[FFI.find_type(type)] = type
+        end
+
+        raise "Conversion function #{name} defined, but LLVM type #{type} is unknown" if type && !LLVM_TYPES.key?(type)
+      end
+
+      SUPPORTED_FROM_NATIVE[FFI.find_type(:void)] = :void
+      SUPPORTED_TO_NATIVE.freeze
+      SUPPORTED_FROM_NATIVE.freeze
+      private_constant :SUPPORTED_TO_NATIVE, :SUPPORTED_FROM_NATIVE
+
+      # rubocop:disable Metrics/MethodLength, 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)
+      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}"
+      end
+
+      private
+
+      def convert_params(name, func, args, returns, options)
+        mname = name
+        a2 = func
+        a3 = args
+        a4 = returns
+        a5 = options
+        cname, arg_types, ret_type, opts = if a4 && (a2.is_a?(String) || a2.is_a?(Symbol))
+                                             [a2, a3, a4, a5]
+                                           else
+                                             [mname.to_s, a2, a3, a4]
+                                           end
+        # Convert :foo to the native type
+        arg_types = arg_types.map { |e| find_type(e) }
+        options = {
+          convention: ffi_convention,
+          type_map: defined?(@ffi_typedefs) ? @ffi_typedefs : nil,
+          blocking: defined?(@blocking) && @blocking,
+          enums: defined?(@ffi_enums) ? @ffi_enums : nil,
+        }
+
+        @blocking = false
+        options.merge!(opts) if opts.is_a?(Hash)
+
+        [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
+          begin
+            function_names(cname, arg_types).find do |fname|
+              fn = lib.find_function(fname)
+            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
+      end
+
+      def attach_llvm_jit_function_addr(rb_name, c_address, arg_type_names, ret_type_name)
+        # 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)
+        # 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|
+          var.linkage = :private
+          var.global_constant = true
+          var.unnamed_addr = true
+          var.initializer = POINTER.from_i(c_address)
+        end
+
+        # Something is wrong in case of name collizion; 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,
+        ) do |llvm_function, _rb_self, *params|
+          llvm_function.basic_blocks.append('entry').build do |b|
+            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)
+            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'])
+              else
+                b.call(LLVM_MOD.functions["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
+      end
+
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
+  end
+end

data/sig/ffi_llvm_jit.rbs

@@ -0,0 +1,6 @@
+module FFI
+  module LLVMJIT
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,241 @@
+--- !ruby/object:Gem::Specification
+name: ffi-llvm-jit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- uvlad7
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: ruby-llvm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '14'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.10.1
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: strlen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-llvm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '17'
+- !ruby/object:Gem::Dependency
+  name: ffi-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.37
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.37
+description: Extends Ruby FFI and uses LLVM to generate JIT wrappers for attached
+  native functions. Works only on MRI
+email:
+- uvlad7@gmail.com
+executables: []
+extensions:
+- ext/ffi_llvm_jit/extconf.rb
+- ext/llvm_bitcode/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- ext/ffi_llvm_jit/extconf.rb
+- ext/ffi_llvm_jit/ffi_llvm_jit.c
+- ext/ffi_llvm_jit/ffi_llvm_jit.h
+- ext/llvm_bitcode/extconf.rb
+- ext/llvm_bitcode/llvm_bitcode.c
+- ext/llvm_bitcode/llvm_bitcode.h
+- lib/ffi/llvm_jit.rb
+- lib/ffi/llvm_jit/version.rb
+- sig/ffi_llvm_jit.rbs
+homepage: https://github.com/uvlad7/ffi-llvm-jit
+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
+  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
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.3
+requirements:
+- llvm-14-dev or newer
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby FFI JIT using LLVM
+test_files: []