ruby-llvm 13.0.2 → 15.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84318238934c7be3357466dfcda5fdf52b587164a4756f1663a749edd3754964
-  data.tar.gz: 2fee5d96b91ebe3edf7d835c4cbe5111e1d9ce8fa63042a32123b506cb65085d
+  metadata.gz: c32840c0ecd67347ba80b8521cb5bdac2820b38280c887ee8625b75a20b5345f
+  data.tar.gz: effe7776c25a308c5a6ff6fb5c87ddaefed4e6beb03ab946810b4b1f960bd464
 SHA512:
-  metadata.gz: 5e03ffebe80a650098d8974ea5b218a727b3f165400cd797bc1d3e652d10cb06f4a621310917e6ee9011b31f4b3ab2dfe215165373c666e78b5d68c8e15703e6
-  data.tar.gz: bd40aa282aeac16fe3e189c05ab26db1230af73f7b536803e218f1d78a86087fe6f4389e3dfe4ae66eab4fdc7a4417dd712bd2449c6c12b77efd1d99bfffc7a3
+  metadata.gz: fcec365b19b7620bf72395c92fb25f1dcf35830496fd1cf9d9778bebecaed85e842136721dd2c8b383191989afb5be0ed110d333e99c6e7a7a967aafe7516128
+  data.tar.gz: cc4646ff588df7005443524b14287f97deecc187046f77d87e84d784ee532f0b282d9a5d847d9e0c94e7b981b9484142cdc44e4cdd19bc7daca2a5e3d14bfef5

data/ext/ruby-llvm-support/Rakefile

@@ -46,7 +46,7 @@ def find_llvm_config
 end
 
 def find_cxx
-  check_for('C++ compiler', %W(g++ clang++), 'CXX') do |cxx|
+  check_for('C++ compiler', %W(clang++-#{LLVM_VERSION} clang++ g++), 'CXX') do |cxx|
     system(cxx, "--version", out: File::NULL, err: File::NULL)
     $?.success?
   end

data/lib/llvm/analysis_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/config.rb

@@ -5,6 +5,6 @@ module LLVM
     TARGETS_BUILT = ["AArch64", "AMDGPU", "ARM", "BPF", "Hexagon", "Lanai", "Mips", "MSP430", "NVPTX", "PowerPC", "RISCV", "Sparc", "SystemZ", "WebAssembly", "X86", "XCore", "AVR"]
     HOST_TARGET = "x86_64-pc-linux-gnu "
     BUILD_MODE = "RelWithDebInfo "
-    CFLAGS = "-I/usr/lib/llvm-11/include -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS "
+    CFLAGS = "-I/usr/lib/llvm-15/include -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS "
   end
 end

data/lib/llvm/core/bitcode.rb

@@ -9,8 +9,8 @@ module LLVM
     # @return [LLVM::Module]
     def self.parse_bitcode(path_or_memory_buffer)
       memory_buffer = case path_or_memory_buffer
-                      when MemoryBuffer then path_or_memory_buffer
-                      else MemoryBuffer.from_file(path_or_memory_buffer)
+      when MemoryBuffer then path_or_memory_buffer
+      else MemoryBuffer.from_file(path_or_memory_buffer)
       end
       FFI::MemoryPointer.new(:pointer) do |mod_ref|
         FFI::MemoryPointer.new(:pointer) do |msg_ref|

data/lib/llvm/core/bitcode_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/core/builder.rb

@@ -169,12 +169,20 @@ module LLVM
     #   unwind instruction occurs
     # @LLVMinst invoke
     def invoke(fun, args, normal, exception, name = "")
+      invoke2(nil, fun, args, normal, exception, name)
+    end
+
+    def invoke2(type, fun, args, normal, exception, name = "")
+      raise ArgumentError, "Trying to build LLVM call with non-function: #{fun.inspect}" if !fun.is_a?(LLVM::Function)
+
+      type ||= fun.return_type
+      must_be_type!(type)
+
       s = args.size
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * s) do |args_ptr|
         args_ptr.write_array_of_pointer(args)
-        return Instruction.from_ptr(
-          C.build_invoke(self,
-            fun, args_ptr, s, normal, exception, name))
+        ins = C.build_invoke2(self, type, fun, args_ptr, s, normal, exception, name)
+        return Instruction.from_ptr(ins)
       end
     end
 
@@ -524,7 +532,17 @@ module LLVM
     #   a value of the pointer's type.
     # @LLVMinst load
     def load(ptr, name = "")
-      Instruction.from_ptr(C.build_load(self, ptr, name))
+      load2(nil, ptr, name)
+    end
+
+    def load2(type, ptr, name = "")
+      must_be_value!(ptr)
+
+      type ||= infer_type(ptr)
+      must_be_type!(type)
+
+      load = C.build_load2(self, type, ptr, name)
+      Instruction.from_ptr(load)
     end
 
     # Store a value at a given pointer
@@ -546,11 +564,29 @@ module LLVM
     # @LLVMinst gep
     # @see http://llvm.org/docs/GetElementPtr.html
     def gep(ptr, indices, name = "")
+      gep2(nil, ptr, indices, name)
+    end
+
+    # Obtain a pointer to the element at the given indices
+    # @param [LLVM::Type] type An LLVM::Type
+    # @param [LLVM::Value] ptr A pointer to an aggregate value
+    # @param [Array<LLVM::Value>] indices Ruby array of LLVM::Value representing
+    #   indices into the aggregate
+    # @param [String] name The name of the result in LLVM IR
+    # @return [LLVM::Instruction] The resulting pointer
+    # @LLVMinst gep2
+    # @see http://llvm.org/docs/GetElementPtr.html
+    def gep2(type, ptr, indices, name)
+      must_be_value!(ptr)
+
+      type ||= must_infer_type!(ptr)
+      must_be_type!(type)
+
       indices = Array(indices)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
         indices_ptr.write_array_of_pointer(indices)
-        return Instruction.from_ptr(
-          C.build_gep(self, ptr, indices_ptr, indices.size, name))
+        ins = C.build_gep2(self, type, ptr, indices_ptr, indices.size, name)
+        return Instruction.from_ptr(ins)
       end
     end
 
@@ -564,25 +600,44 @@ module LLVM
     # @LLVMinst gep
     # @see http://llvm.org/docs/GetElementPtr.html
     def inbounds_gep(ptr, indices, name = "")
+      inbounds_gep2(nil, ptr, indices, name)
+    end
+
+    def inbounds_gep2(type, ptr, indices, name = "")
+      must_be_value!(ptr)
+
+      type = must_infer_type!(ptr)
+      must_be_type!(type)
+
       indices = Array(indices)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
         indices_ptr.write_array_of_pointer(indices)
-        return Instruction.from_ptr(
-          C.build_in_bounds_gep(self, ptr, indices_ptr, indices.size, name))
+        ins = C.build_inbounds_gep2(self, type, ptr, indices_ptr, indices.size, name)
+        return Instruction.from_ptr(ins)
       end
     end
 
     # Builds a struct getelementptr Instruction.
     #
-    # @param  [LLVM::Value] pointer A pointer to a structure
+    # @param  [LLVM::Value] ptr A pointer to a structure
     # @param  [LLVM::Value] idx     Unsigned integer representing the index of a
     #   structure member
     # @param  [String]      name    The name of the result in LLVM IR
     # @return [LLVM::Instruction]   The resulting pointer
     # @LLVMinst gep
     # @see http://llvm.org/docs/GetElementPtr.html
-    def struct_gep(pointer, idx, name = "")
-      Instruction.from_ptr(C.build_struct_gep(self, pointer, idx, name))
+    def struct_gep(ptr, idx, name = "")
+      struct_gep2(nil, ptr, idx, name)
+    end
+
+    def struct_gep2(type, ptr, idx, name)
+      must_be_value!(ptr)
+
+      type ||= must_infer_type!(ptr)
+      must_be_type!(type)
+
+      ins = C.build_struct_gep2(self, type, ptr, idx, name)
+      Instruction.from_ptr(ins)
     end
 
     # Creates a global string initialized to a given value.
@@ -868,8 +923,15 @@ module LLVM
     # @param [LLVM::Instruction]
     # @LLVMinst call
     def call(fun, *args)
+      call2(nil, fun, *args)
+    end
+
+    def call2(type, fun, *args)
       raise ArgumentError, "Trying to build LLVM call with non-function: #{fun.inspect}" if !fun.is_a?(LLVM::Function)
 
+      type ||= fun.function_type
+      must_be_type!(type)
+
       if args.last.kind_of? String
         name = args.pop
       else
@@ -878,7 +940,8 @@ module LLVM
 
       args_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * args.size)
       args_ptr.write_array_of_pointer(args)
-      CallInst.from_ptr(C.build_call(self, fun, args_ptr, args.size, name))
+      ins = C.build_call2(self, type, fun, args_ptr, args.size, name)
+      CallInst.from_ptr(ins)
     end
 
     # Return a value based on a condition. This differs from 'cond' in that
@@ -908,7 +971,8 @@ module LLVM
 
       raise ArgumentError, "Error building extract_element with #{error}" if error
 
-      Instruction.from_ptr(C.build_extract_element(self, vector, idx, name))
+      ins = C.build_extract_element(self, vector, idx, name)
+      Instruction.from_ptr(ins)
     end
 
     # Insert an element into a vector
@@ -927,17 +991,8 @@ module LLVM
 
       raise ArgumentError, "Error building insert_element with #{error}" if error
 
-      Instruction.from_ptr(C.build_insert_element(self, vector, elem, idx, name))
-    end
-
-    private def element_error(vector, idx) # rubocop:disable Style/AccessModifierDeclarations
-      if !vector.is_a?(LLVM::Value)
-        "non-value: #{vector.inspect}"
-      elsif vector.type.kind != :vector
-        "non-vector: #{vector.type.kind}"
-      elsif !idx.is_a?(LLVM::Value)
-        "index: #{idx}"
-      end
+      ins = C.build_insert_element(self, vector, elem, idx, name)
+      Instruction.from_ptr(ins)
     end
 
     # Shuffle two vectors according to a given mask
@@ -963,7 +1018,8 @@ module LLVM
 
       raise ArgumentError, "Error building extract_value with #{error}" if error
 
-      Instruction.from_ptr(C.build_extract_value(self, aggregate, idx, name))
+      ins = C.build_extract_value(self, aggregate, idx, name)
+      Instruction.from_ptr(ins)
     end
 
     # Insert a value into an aggregate value's member field
@@ -982,17 +1038,8 @@ module LLVM
 
       raise ArgumentError, "Error building insert_value with #{error}" if error
 
-      Instruction.from_ptr(C.build_insert_value(self, aggregate, elem, idx, name))
-    end
-
-    private def value_error(aggregate, idx) # rubocop:disable Style/AccessModifierDeclarations
-      if !aggregate.is_a?(LLVM::Value)
-        "non-value: #{aggregate.inspect}"
-      elsif !aggregate.type.aggregate?
-        "non-aggregate: #{aggregate.type.kind}"
-      elsif !idx.is_a?(Integer) || idx.negative?
-        "index: #{idx}"
-      end
+      ins = C.build_insert_value(self, aggregate, elem, idx, name)
+      Instruction.from_ptr(ins)
     end
 
     # Check if a value is null
@@ -1020,5 +1067,79 @@ module LLVM
     def ptr_diff(lhs, rhs, name = "")
       Instruction.from_ptr(C.build_ptr_diff(lhs, rhs, name))
     end
+
+    private
+
+    private def must_be_value!(value)
+      raise "must be a Value, got #{value.class.name}" unless Value === value
+    end
+
+    private def must_be_type!(type)
+      type2 = LLVM.Type(type)
+      raise "must be a Type (LLVMTypeRef), got #{type2.class.name}" unless Type === type2
+    end
+
+    private def must_infer_type!(value)
+      infer_type(value)
+    end
+
+    private def infer_type(ptr)
+      case ptr
+      when GlobalVariable
+        Type.from_ptr(C.global_get_value_type(ptr))
+      when Instruction
+        must_infer_instruction_type!(ptr)
+      else
+        raise "#{ptr.class.name} #{ptr}"
+      end
+    end
+
+    private def must_infer_instruction_type!(ptr)
+      case ptr.opcode
+      when :get_element_ptr
+        must_infer_gep!(ptr)
+      when :alloca
+        Type.from_ptr(C.get_allocated_type(ptr))
+      when :load
+        ptr.type
+      else
+        raise "Inferring type for instruction not currently supported: #{ptr.opcode} #{ptr}"
+      end
+    end
+
+    private def must_infer_gep!(ptr)
+      source_type = Type.from_ptr(C.get_gep_source_element_type(ptr))
+      case source_type.kind
+      when :integer
+        source_type
+      when :struct
+        raise "Cannot currently infer type from gep of struct"
+      when :array, :vector
+        source_type.element_type
+      else
+        debugger
+      end
+    end
+
+    private def element_error(vector, idx) # rubocop:disable Style/AccessModifierDeclarations
+      if !vector.is_a?(LLVM::Value)
+        "non-value: #{vector.inspect}"
+      elsif vector.type.kind != :vector
+        "non-vector: #{vector.type.kind}"
+      elsif !idx.is_a?(LLVM::Value)
+        "index: #{idx}"
+      end
+    end
+
+    private def value_error(aggregate, idx) # rubocop:disable Style/AccessModifierDeclarations
+      if !aggregate.is_a?(LLVM::Value)
+        "non-value: #{aggregate.inspect}"
+        # TODO: fix this
+      elsif !aggregate.type.aggregate?
+        "non-aggregate: #{aggregate.type.kind}"
+      elsif !idx.is_a?(Integer) || idx.negative?
+        "index: #{idx}"
+      end
+    end
   end
 end

data/lib/llvm/core/opaque_pointer_builder.rb

@@ -0,0 +1,25 @@
+# unmodule LLVM
+#   module OpaquePointerBuilder
+#     # Builds a struct getelementptr Instruction.
+#     #
+#     # @param  [LLVM::Value] pointer A pointer to a structure
+#     # @param  [LLVM::Value] idx     Unsigned integer representing the index of a
+#     #   structure member
+#     # @param  [String]      name    The name of the result in LLVM IR
+#     # @return [LLVM::Instruction]   The resulting pointer
+#     # @LLVMinst gep
+#     # @see http://llvm.org/docs/GetElementPtr.html
+#     def struct_gep1(pointer, idx, name = "")
+#       Instruction.from_ptr(C.build_struct_gep(self, pointer, idx, name))
+#     end
+#
+#     private def struct_gep2(type, pointer, idx, name)
+#       Instruction.from_ptr(C.build_struct_gep2(self, type, pointer, idx, name))
+#     end
+#
+#     def struct_gep(pointer, idx, name = "", type = nil)
+#       type2 = type || must_infer_type(pointer)
+#       struct_gep2(types2, pointer, idx, name)
+#     end
+#   end
+# end

data/lib/llvm/core/type.rb

@@ -5,14 +5,18 @@ module LLVM
     include PointerIdentity
 
     # @private
-    def self.from_ptr(ptr, kind)
+    def self.from_ptr(ptr, kind = nil)
       return if ptr.null?
       kind ||= C.get_type_kind(ptr)
       ty = case kind
-      when :integer  then IntType.allocate
-      when :function then FunctionType.allocate
-      when :struct   then StructType.allocate
-      else allocate
+      when :integer
+        IntType.allocate
+      when :function
+        FunctionType.allocate
+      when :struct
+        StructType.allocate
+      else
+        allocate
       end
       ty.instance_variable_set(:@ptr, ptr)
       ty.instance_variable_set(:@kind, kind)
@@ -36,8 +40,13 @@ module LLVM
     # Returns the type of this types elements (works only for Pointer, Vector, and Array types.)
     def element_type
       case kind
-      when :pointer, :vector, :array
-        Type.from_ptr(C.get_element_type(self), nil)
+      when :vector, :array
+        element_type = C.get_element_type(self)
+        Type.from_ptr(element_type)
+      when :pointer
+        LLVM.Void
+      else
+        raise "element_type not supported for kind: #{kind}"
       end
     end
 
@@ -113,6 +122,21 @@ module LLVM
       from_ptr(C.void_type, :void)
     end
 
+    def self.label
+      from_ptr(C.label_type, :label)
+    end
+
+    def self.x86_mmx
+      from_ptr(C.x86mmx_type, :x86mmx)
+    end
+
+    def self.x86_amx
+      from_ptr(C.x86amx_type, :x86amx)
+    end
+    # def self.opaque_pointer
+    #  from_ptr(C.opaque_type, :pointer)
+    # end
+
     def self.rec
       h = opaque
       ty = yield h
@@ -129,7 +153,11 @@ module LLVM
 
   class FunctionType < Type
     def return_type
-      Type.from_ptr(C.get_return_type(self), nil)
+      Type.from_ptr(C.get_return_type(self))
+    end
+
+    def element_type
+      self
     end
 
     def argument_types

data/lib/llvm/core/value.rb

@@ -26,6 +26,10 @@ module LLVM
       Type.from_ptr(C.type_of(self), nil)
     end
 
+    def allocated_type
+      Type.from_ptr(C.get_allocated_type(self), nil)
+    end
+
     # Returns the value's name.
     def name
       C.get_value_name(self)
@@ -315,6 +319,10 @@ module LLVM
     def size
       C.get_array_length(type)
     end
+
+    def [](idx)
+      self.class.from_ptr(C.get_aggregate_element(self, idx))
+    end
   end
 
   class ConstantExpr < Constant
@@ -631,6 +639,10 @@ module LLVM
       vals = LLVM::Support.allocate_pointers(size_or_values, &block)
       from_ptr C.const_named_struct(type, vals, vals.size / vals.type_size)
     end
+
+    def [](idx)
+      self.class.from_ptr(C.get_aggregate_element(self, idx))
+    end
   end
 
   class ConstantVector < Constant
@@ -646,6 +658,10 @@ module LLVM
     def size
       C.get_vector_size(type)
     end
+
+    def [](idx)
+      self.class.from_ptr(C.get_aggregate_element(self, idx))
+    end
   end
 
   class GlobalValue < Constant
@@ -735,12 +751,17 @@ module LLVM
       @basic_block_collection ||= BasicBlockCollection.new(self)
     end
 
+    def function_type
+      Type.from_ptr(C.get_element_type(self), :function)
+    end
+
+    # In LLVM 15, not overriding this yields a pointer type instead of a function type
     def type
-      Type.from_ptr(C.type_of(self), :pointer)
+      function_type
     end
 
-    def function_type
-      type.element_type
+    def return_type
+      type.return_type
     end
 
     # Adds attr to this value's attributes.
@@ -962,6 +983,10 @@ module LLVM
       ptr = C.get_previous_instruction(self)
       LLVM::Instruction.from_ptr(ptr) unless ptr.null?
     end
+
+    def opcode
+      C.get_instruction_opcode(self)
+    end
   end
 
   class CallInst < Instruction

data/lib/llvm/core.rb

@@ -51,6 +51,57 @@ module LLVM
     # const char *LLVMGetStringAttributeValue
     # (LLVMAttributeRef A, unsigned *Length);
     attach_function :get_string_attribute_value, :LLVMGetStringAttributeValue, [:pointer, :pointer], :pointer
+
+    # LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef PointerVal, const char *Name);
+    attach_function :build_load2, :LLVMBuildLoad2, [:pointer, :pointer, :pointer, :string], :pointer
+
+    # LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
+    #                            LLVMValueRef Pointer, LLVMValueRef *Indices,
+    #                            unsigned NumIndices, const char *Name);
+    attach_function :build_gep2, :LLVMBuildGEP2, [:pointer, :pointer, :pointer, :pointer, :uint, :string], :pointer
+
+    # LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
+    #                                    LLVMValueRef Pointer, LLVMValueRef *Indices,
+    #                                    unsigned NumIndices, const char *Name);
+    attach_function :build_inbounds_gep2, :LLVMBuildInBoundsGEP2, [:pointer, :pointer, :pointer, :pointer, :uint, :string], :pointer
+
+    # LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
+    #                                  LLVMValueRef Pointer, unsigned Idx,
+    #                                  const char *Name);
+    attach_function :build_struct_gep2, :LLVMBuildStructGEP2, [:pointer, :pointer, :pointer, :uint, :string], :pointer
+
+    # LLVMValueRef LLVMBuildCall2(LLVMBuilderRef, LLVMTypeRef, LLVMValueRef Fn,
+    #                             LLVMValueRef *Args, unsigned NumArgs,
+    #                             const char *Name);
+    attach_function :build_call2, :LLVMBuildCall2, [:pointer, :pointer, :pointer, :pointer, :uint, :string], :pointer
+
+    # LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef, LLVMTypeRef Ty, LLVMValueRef Fn,
+    #                               LLVMValueRef *Args, unsigned NumArgs,
+    #                               LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
+    #                               const char *Name);
+    attach_function :build_invoke2, :LLVMBuildInvoke2, [:pointer, :pointer, :pointer, :pointer, :uint, :pointer, :pointer, :string], :pointer
+
+    # LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global);
+    attach_function :global_get_value_type, :LLVMGlobalGetValueType, [:pointer], :pointer
+
+    # LLVMTypeRef LLVMGetGEPSourceElementType(LLVMValueRef GEP);
+    attach_function :get_gep_source_element_type, :LLVMGetGEPSourceElementType, [:pointer], :pointer
+
+    # (Not documented)
+    #
+    # @method x86amx_type()
+    # @return [FFI::Pointer(TypeRef)]
+    # @scope class
+    attach_function :x86amx_type, :LLVMX86AMXType, [], :pointer
+
+    # LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca);
+    attach_function :get_allocated_type, :LLVMGetAllocatedType, [:pointer], :pointer
+
+    # LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global);
+    attach_function :get_value_type, :LLVMGlobalGetValueType, [:pointer], :pointer
+
+    # LLVMValueRef LLVMGetAggregateElement(LLVMValueRef C, unsigned Idx);
+    attach_function :get_aggregate_element, :LLVMGetAggregateElement, [:pointer, :int], :pointer
   end
 
   # Yields a pointer suitable for storing an LLVM output message.

data/lib/llvm/core_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -410,7 +410,10 @@ module LLVM::C
     :vector, 13,
     :metadata, 14,
     :x86_mmx, 15,
-    :token, 16
+    :token, 16,
+    :scalable_vector, 17,
+    :bfloat, 18,
+    :x86_amx, 19,
   ]
 
   # (Not documented)
@@ -3012,15 +3015,6 @@ module LLVM::C
   # @scope class
   attach_function :const_nuw_add, :LLVMConstNUWAdd, [:pointer, :pointer], :pointer
 
-  # (Not documented)
-  #
-  # @method const_f_add(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_f_add, :LLVMConstFAdd, [:pointer, :pointer], :pointer
-
   # (Not documented)
   #
   # @method const_sub(lhs_constant, rhs_constant)
@@ -3048,15 +3042,6 @@ module LLVM::C
   # @scope class
   attach_function :const_nuw_sub, :LLVMConstNUWSub, [:pointer, :pointer], :pointer
 
-  # (Not documented)
-  #
-  # @method const_f_sub(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_f_sub, :LLVMConstFSub, [:pointer, :pointer], :pointer
-
   # (Not documented)
   #
   # @method const_mul(lhs_constant, rhs_constant)
@@ -3084,78 +3069,6 @@ module LLVM::C
   # @scope class
   attach_function :const_nuw_mul, :LLVMConstNUWMul, [:pointer, :pointer], :pointer
 
-  # (Not documented)
-  #
-  # @method const_f_mul(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_f_mul, :LLVMConstFMul, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_u_div(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_u_div, :LLVMConstUDiv, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_s_div(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_s_div, :LLVMConstSDiv, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_exact_s_div(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_exact_s_div, :LLVMConstExactSDiv, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_f_div(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_f_div, :LLVMConstFDiv, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_u_rem(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_u_rem, :LLVMConstURem, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_s_rem(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_s_rem, :LLVMConstSRem, [:pointer, :pointer], :pointer
-
-  # (Not documented)
-  #
-  # @method const_f_rem(lhs_constant, rhs_constant)
-  # @param [FFI::Pointer(ValueRef)] lhs_constant
-  # @param [FFI::Pointer(ValueRef)] rhs_constant
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_f_rem, :LLVMConstFRem, [:pointer, :pointer], :pointer
-
   # (Not documented)
   #
   # @method const_and(lhs_constant, rhs_constant)
@@ -3461,27 +3374,6 @@ module LLVM::C
   # @scope class
   attach_function :const_shuffle_vector, :LLVMConstShuffleVector, [:pointer, :pointer, :pointer], :pointer
 
-  # (Not documented)
-  #
-  # @method const_extract_value(agg_constant, idx_list, num_idx)
-  # @param [FFI::Pointer(ValueRef)] agg_constant
-  # @param [FFI::Pointer(*UInt)] idx_list
-  # @param [Integer] num_idx
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_extract_value, :LLVMConstExtractValue, [:pointer, :pointer, :uint], :pointer
-
-  # (Not documented)
-  #
-  # @method const_insert_value(agg_constant, element_value_constant, idx_list, num_idx)
-  # @param [FFI::Pointer(ValueRef)] agg_constant
-  # @param [FFI::Pointer(ValueRef)] element_value_constant
-  # @param [FFI::Pointer(*UInt)] idx_list
-  # @param [Integer] num_idx
-  # @return [FFI::Pointer(ValueRef)]
-  # @scope class
-  attach_function :const_insert_value, :LLVMConstInsertValue, [:pointer, :pointer, :pointer, :uint], :pointer
-
   # (Not documented)
   #
   # @method const_inline_asm(ty, asm_string, constraints, has_side_effects, is_align_stack)

data/lib/llvm/execution_engine_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/linker_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/target_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/transforms/builder.rb

@@ -86,18 +86,7 @@ module LLVM
     # Populate an LTO pass manager.
     # @param [PassManager] pass_manager
     def build_with_lto(pass_manager, internalize = false, run_inliner = false)
-      if pass_manager.is_a?(FunctionPassManager)
-        raise ArgumentError, "FunctionPassManager does not support LTO"
-      end
-
-      if internalize.kind_of?(Integer) || run_inliner.kind_of?(Integer)
-        warn 'Warning: Passing Integer value to LLVM::PassManagerBuilder#build_with_lto is deprecated.'
-        internalize = !internalize.zero? if internalize.kind_of?(Integer)
-        run_inliner = !run_inliner.zero? if run_inliner.kind_of?(Integer)
-      end
-
-      C.pass_manager_builder_populate_lto_pass_manager(self,
-            pass_manager, flag(internalize), flag(run_inliner))
+      raise "build_with_lto is not currently supported"
     end
 
     private

data/lib/llvm/transforms/builder_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -103,15 +103,4 @@ module LLVM::C
   # @return [nil]
   # @scope class
   attach_function :pass_manager_builder_populate_module_pass_manager, :LLVMPassManagerBuilderPopulateModulePassManager, [OpaquePassManagerBuilder, :pointer], :void
-
-  # See llvm::PassManagerBuilder::populateLTOPassManager.
-  #
-  # @method pass_manager_builder_populate_lto_pass_manager(pmb, pm, internalize, run_inliner)
-  # @param [OpaquePassManagerBuilder] pmb
-  # @param [FFI::Pointer(PassManagerRef)] pm
-  # @param [Integer] internalize
-  # @param [Integer] run_inliner
-  # @return [nil]
-  # @scope class
-  attach_function :pass_manager_builder_populate_lto_pass_manager, :LLVMPassManagerBuilderPopulateLTOPassManager, [OpaquePassManagerBuilder, :pointer, :int, :int], :void
 end

data/lib/llvm/transforms/ipo_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/transforms/scalar_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/transforms/vectorize_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+  ffi_lib ["libLLVM-15.so.1", "libLLVM.so.15", "LLVM-15"]
 
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module LLVM
-  LLVM_VERSION = "13"
-  LLVM_REQUIRED_VERSION = "13.0"
-  RUBY_LLVM_VERSION = "13.0.2"
+  LLVM_VERSION = "15"
+  LLVM_REQUIRED_VERSION = "15.0"
+  RUBY_LLVM_VERSION = "15.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-llvm
 version: !ruby/object:Gem::Version
-  version: 13.0.2
+  version: 15.0.0
 platform: ruby
 authors:
 - Jesse Johnson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-02 00:00:00.000000000 Z
+date: 2022-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -45,62 +45,76 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '14'
+- !ruby/object:Gem::Dependency
+  name: debug
+  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: ffi_gen
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.15.0
+        version: '5.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.15.0
+        version: '5.16'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.30.0
+        version: '1.31'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.30.0
+        version: '1.31'
 - !ruby/object:Gem::Dependency
   name: rubocop-minitest
   requirement: !ruby/object:Gem::Requirement
@@ -149,14 +163,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: '0.9'
 description: Ruby-LLVM is a Ruby language binding to the LLVM compiler infrastructure
   library.
 email:
@@ -183,6 +197,7 @@ files:
 - lib/llvm/core/builder.rb
 - lib/llvm/core/context.rb
 - lib/llvm/core/module.rb
+- lib/llvm/core/opaque_pointer_builder.rb
 - lib/llvm/core/pass_manager.rb
 - lib/llvm/core/type.rb
 - lib/llvm/core/value.rb