ruby-llvm 15.0.1 → 15.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1595f619407ef3dcb3bf455c4b14dc5843accc2f42854cf9b3bf46f378fcea40
-  data.tar.gz: 1cf2978bf457a6f45b19483570bef9ef1a0b6730bb90786895a6dd86950ab24b
+  metadata.gz: 79169ec6b39406ef0c395bee5bbc02578340808b2728ba61b5b89c1532e05c94
+  data.tar.gz: 8fe97708a36b561acbd24433f1ddf5d940e6535a776d918eca463fd179a29aea
 SHA512:
-  metadata.gz: 7a49ba3ff1bf07d0f529b54e82b696c1bb6c1dae57f126204f9fec56781e4a625a7d6f0b80d638598f63f009658f02e9a9dc4d7542bee10bae58501ab53220ec
-  data.tar.gz: f0b87e6e18742252858ace4e0e2366f98270feebfc4d948291abe8ba0306a957c17b1b59cc7ae081a6c4c30e294892d899148ce3ed8ad4d6f7abdaadf0c64424
+  metadata.gz: 75303049be604101b44001f68264b0ba0e5902816cf8d001ed5302aa7b71067b1e8d4ac7f24cf3470e53f59aac5547391b31c5f1145dceb28661966e95c56928
+  data.tar.gz: 9bad15b50111baf7dd2804d9bd6e61d8a2d05b892eacbbbc52df0194662f961eba8c7f9b81f5ebf1b5e9ce796e4aaeb4b4b47e858874d474ea39e54d3a6dd042

data/ext/ruby-llvm-support/Rakefile

@@ -77,7 +77,7 @@ desc "Build the shared library and config module"
 task :default => [SUPPORT_LIB, CONFIG_MOD]
 
 file SUPPORT_LIB => %w(support.cpp) do |task|
-  clang_stdlib = CXX =~ /^clang++/ ? "-stdlib=libc++" : ""
+  clang_stdlib = CXX.match?(/^clang++/) ? "-stdlib=libc++" : ""
   sh "#{CXX} -O3 -shared #{task.prerequisites.join(' ')} -l#{llvm_lib_name} " \
      "#{invoke_llvm_config('--cxxflags --ldflags')} -fPIC #{clang_stdlib} -o #{SUPPORT_LIB}"
 end

data/lib/llvm/core/builder.rb

@@ -1070,20 +1070,20 @@ module LLVM
 
     private
 
-    private def must_be_value!(value)
+    def must_be_value!(value)
       raise "must be a Value, got #{value.class.name}" unless Value === value
     end
 
-    private def must_be_type!(type)
+    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)
+    def must_infer_type!(value)
       infer_type(value)
     end
 
-    private def infer_type(ptr)
+    def infer_type(ptr)
       case ptr
       when GlobalVariable
         Type.from_ptr(C.global_get_value_type(ptr))
@@ -1094,7 +1094,7 @@ module LLVM
       end
     end
 
-    private def must_infer_instruction_type!(ptr)
+    def must_infer_instruction_type!(ptr)
       case ptr.opcode
       when :get_element_ptr
         must_infer_gep!(ptr)
@@ -1107,7 +1107,7 @@ module LLVM
       end
     end
 
-    private def must_infer_gep!(ptr)
+    def must_infer_gep!(ptr)
       source_type = Type.from_ptr(C.get_gep_source_element_type(ptr))
       case source_type.kind
       when :integer
@@ -1121,7 +1121,7 @@ module LLVM
       end
     end
 
-    private def element_error(vector, idx) # rubocop:disable Style/AccessModifierDeclarations
+    def element_error(vector, idx)
       if !vector.is_a?(LLVM::Value)
         "non-value: #{vector.inspect}"
       elsif vector.type.kind != :vector
@@ -1131,7 +1131,7 @@ module LLVM
       end
     end
 
-    private def value_error(aggregate, idx) # rubocop:disable Style/AccessModifierDeclarations
+    def value_error(aggregate, idx)
       if !aggregate.is_a?(LLVM::Value)
         "non-value: #{aggregate.inspect}"
         # TODO: fix this

data/lib/llvm/core/opaque_pointer_builder.rb

@@ -1,4 +1,5 @@
-# unmodule LLVM
+# frozen_string_literal: true
+# module LLVM
 #   module OpaquePointerBuilder
 #     # Builds a struct getelementptr Instruction.
 #     #

data/lib/llvm/core/type.rb

@@ -79,18 +79,47 @@ module LLVM
       [:struct, :array].include?(kind)
     end
 
+    def opaque_struct?
+      C.is_opaque_struct(self)
+    end
+
+    def packed_struct?
+      C.is_packed_struct(self)
+    end
+
+    def literal_struct?
+      C.is_literal_struct(self)
+    end
+
     # Creates an array type of Type with the given size.
+    # arrays can be size >= 0, https://llvm.org/docs/LangRef.html#array-type
     def self.array(ty, sz = 0)
+      sz = sz.to_i
+      raise ArgumentError, "LLVM Array size must be >= 0" if sz.negative?
+
       from_ptr(C.array_type(LLVM::Type(ty), sz), :array)
     end
 
     # Creates the pointer type of Type with the given address space.
-    def self.pointer(ty, address_space = 0)
-      from_ptr(C.pointer_type(LLVM::Type(ty), address_space), :pointer)
+    def self.pointer(ty = nil, address_space = 0)
+      if ty
+        from_ptr(C.pointer_type(LLVM::Type(ty), address_space), :pointer)
+      else
+        ptr(address_space)
+      end
+    end
+
+    # opaque pointer
+    def self.ptr(address_space = 0)
+      from_ptr(C.pointer_type(void, address_space), :pointer)
     end
 
     # Creates a vector type of Type with the given element count.
+    # vectors can be size > 0, https://llvm.org/docs/LangRef.html#vector-type
     def self.vector(ty, element_count)
+      element_count = element_count.to_i
+      raise ArgumentError, "LLVM Vector size must be > 0" unless element_count.positive?
+
       from_ptr(C.vector_type(LLVM::Type(ty), element_count), :vector)
     end
 
@@ -117,6 +146,14 @@ module LLVM
       end
     end
 
+    def self.opaque_struct(name)
+      from_ptr(C.struct_create_named(Context.global, name.to_s), :struct)
+    end
+
+    def self.named(name)
+      from_ptr(C.get_type_by_name2(Context.global, name.to_s), nil)
+    end
+
     # Creates a void type.
     def self.void
       from_ptr(C.void_type, :void)
@@ -217,7 +254,7 @@ module LLVM
   end
 
   # Shortcut to Type.pointer.
-  def Pointer(ty)
+  def Pointer(ty = nil)
     LLVM::Type.pointer(ty)
   end
 

data/lib/llvm/core/value.rb

@@ -291,7 +291,7 @@ module LLVM
   module Support
     def allocate_pointers(size_or_values, &block)
       if size_or_values.is_a?(Integer)
-        raise ArgumentError, 'block not given' unless block_given?
+        raise ArgumentError, 'block not given' unless block
         size = size_or_values
         values = (0...size).map { |i| yield i }
       else
@@ -832,7 +832,7 @@ module LLVM
 
       def attribute_name(attr_name)
         attr_name = attr_name.to_s
-        if attr_name =~ /_attribute$/
+        if /_attribute$/.match?(attr_name)
           attr_name.chomp('_attribute').tr('_', '')
         else
           attr_name

data/lib/llvm/core.rb

@@ -102,6 +102,38 @@ module LLVM
 
     # LLVMValueRef LLVMGetAggregateElement(LLVMValueRef C, unsigned Idx);
     attach_function :get_aggregate_element, :LLVMGetAggregateElement, [:pointer, :int], :pointer
+
+    attach_function :get_type_by_name2, :LLVMGetTypeByName2, [:pointer, :string], :pointer
+
+    # Determine whether a structure is packed.
+    #
+    # @see llvm::StructType::isPacked()
+    #
+    # @method is_packed_struct(struct_ty)
+    # @param [FFI::Pointer(TypeRef)] struct_ty
+    # @return [Bool]
+    # @scope class
+    attach_function :is_packed_struct, :LLVMIsPackedStruct, [:pointer], :bool
+
+    # Determine whether a structure is opaque.
+    #
+    # @see llvm::StructType::isOpaque()
+    #
+    # @method is_opaque_struct(struct_ty)
+    # @param [FFI::Pointer(TypeRef)] struct_ty
+    # @return [Bool]
+    # @scope class
+    attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [:pointer], :bool
+
+    # Determine whether a structure is literal.
+    #
+    # @see llvm::StructType::isLiteral()
+    #
+    # @method is_literal_struct(struct_ty)
+    # @param [FFI::Pointer(TypeRef)] struct_ty
+    # @return [Bool]
+    # @scope class
+    attach_function :is_literal_struct, :LLVMIsLiteralStruct, [:pointer], :bool
   end
 
   # Yields a pointer suitable for storing an LLVM output message.

data/lib/llvm/core_ffi.rb

@@ -1651,26 +1651,6 @@ module LLVM::C
   # @scope class
   attach_function :struct_get_type_at_index, :LLVMStructGetTypeAtIndex, [:pointer, :uint], :pointer
 
-  # Determine whether a structure is packed.
-  #
-  # @see llvm::StructType::isPacked()
-  #
-  # @method is_packed_struct(struct_ty)
-  # @param [FFI::Pointer(TypeRef)] struct_ty
-  # @return [Integer]
-  # @scope class
-  attach_function :is_packed_struct, :LLVMIsPackedStruct, [:pointer], :int
-
-  # Determine whether a structure is opaque.
-  #
-  # @see llvm::StructType::isOpaque()
-  #
-  # @method is_opaque_struct(struct_ty)
-  # @param [FFI::Pointer(TypeRef)] struct_ty
-  # @return [Integer]
-  # @scope class
-  attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [:pointer], :int
-
   # Obtain the type of elements within a sequential type.
   #
   # This works on array, vector, and pointer types.

data/lib/llvm/version.rb

@@ -3,5 +3,5 @@
 module LLVM
   LLVM_VERSION = "15"
   LLVM_REQUIRED_VERSION = "15.0"
-  RUBY_LLVM_VERSION = "15.0.1"
+  RUBY_LLVM_VERSION = "15.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-llvm
 version: !ruby/object:Gem::Version
-  version: 15.0.1
+  version: 15.0.2
 platform: ruby
 authors:
 - Jesse Johnson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-03 00:00:00.000000000 Z
+date: 2023-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi