ruby-llvm 3.5.0 → 13.0.1

data/lib/llvm/core/value.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LLVM
   class Value
     include PointerIdentity
@@ -12,7 +14,7 @@ module LLVM
 
     # Returns the Value type. This is abstract and is overidden by its subclasses.
     def self.type
-      raise NotImplementedError, "#{self.name}.type() is abstract."
+      raise NotImplementedError, "#{name}.type() is abstract."
     end
 
     def self.to_ptr
@@ -40,6 +42,10 @@ module LLVM
       C.dump_value(self)
     end
 
+    def to_s
+      C.print_value_to_string(self)
+    end
+
     # Returns whether the value is constant.
     def constant?
       case C.is_constant(self)
@@ -66,8 +72,45 @@ module LLVM
 
     # Adds attr to this value's attributes.
     def add_attribute(attr)
-      C.add_attribute(self, attr)
+      fun = param_parent
+      return unless fun
+
+      index = param_index(fun)
+      return unless index
+
+      fun.add_attribute(attr, index)
     end
+
+    # Removes the given attribute from the function.
+    def remove_attribute(attr)
+      fun = param_parent
+      return unless fun
+
+      index = param_index(fun)
+      return unless index
+
+      fun.remove_attribute(attr, index)
+    end
+
+    private
+
+    # get function this param belongs to
+    # return if it is not a param
+    def param_parent
+      valueref = C.get_param_parent(self)
+      return if valueref.null?
+      fun = LLVM::Function.from_ptr(valueref)
+      return if fun.null?
+      fun
+    end
+
+    # get index of this param by llvm count (+1 from parametercollection)
+    def param_index(fun)
+      index = fun.params.find_index(self)
+      return if index.nil?
+      index + 1
+    end
+
   end
 
   class Argument < Value
@@ -76,7 +119,7 @@ module LLVM
   class BasicBlock < Value
     # Creates a basic block for the given function with the given name.
     def self.create(fun = nil, name = "")
-      self.from_ptr(C.append_basic_block(fun, name))
+      from_ptr(C.append_basic_block(fun, name))
     end
 
     # Build the basic block with the given builder. Creates a new one if nil. Yields the builder.
@@ -110,11 +153,13 @@ module LLVM
       BasicBlock.from_ptr(ptr) unless ptr.null?
     end
 
-    def first_instruction  # deprecated
+    # deprecated
+    def first_instruction
       instructions.first
     end
 
-    def last_instruction  # deprecated
+    # deprecated
+    def last_instruction
       instructions.last
     end
 
@@ -192,7 +237,7 @@ module LLVM
       # Iterates through each operand in the collection.
       def each
         return to_enum :each unless block_given?
-        0.upto(size-1) { |i| yield self[i] }
+        0.upto(size - 1) { |i| yield self[i] }
         self
       end
     end
@@ -444,12 +489,22 @@ module LLVM
     def int_to_ptr(type)
       ConstantExpr.from_ptr(C.const_int_to_ptr(self, type))
     end
+
+    # constant zext
+    def zext(type)
+      self.class.from_ptr(C.const_z_ext(self, type))
+    end
+
+    # constant sext
+    def sext(type)
+      self.class.from_ptr(C.const_s_ext(self, type))
+    end
   end
 
-  def LLVM.const_missing(const)
+  def self.const_missing(const)
     case const.to_s
     when /Int(\d+)/
-      width = $1.to_i
+      width = Regexp.last_match(1).to_i
       name  = "Int#{width}"
       eval <<-KLASS
         class #{name} < ConstantInt
@@ -469,7 +524,7 @@ module LLVM
   ::LLVM::Int = const_get("Int#{bits}")
 
   # Creates a LLVM Int (subclass of ConstantInt) at the NATIVE_INT_SIZE from a integer (val).
-  def LLVM.Int(val)
+  def self.Int(val)
     case val
     when LLVM::ConstantInt then val
     when Integer then Int.from_i(val)
@@ -550,7 +605,7 @@ module LLVM
   end
 
   # Create a LLVM::Float from a Ruby Float (val).
-  def LLVM.Float(val)
+  def self.Float(val)
     Float.from_f(val)
   end
 
@@ -560,7 +615,7 @@ module LLVM
     end
   end
 
-  def LLVM.Double(val)
+  def self.Double(val)
     Double.from_f(val)
   end
 
@@ -675,16 +730,6 @@ module LLVM
       conv
     end
 
-    # Adds the given attribute to the function.
-    def add_attribute(attr)
-      C.add_function_attr(self, attr)
-    end
-
-    # Removes the given attribute from the function.
-    def remove_attribute(attr)
-      C.remove_function_attr(self, attr)
-    end
-
     # Returns an Enumerable of the BasicBlocks in this function.
     def basic_blocks
       @basic_block_collection ||= BasicBlockCollection.new(self)
@@ -698,6 +743,90 @@ module LLVM
       type.element_type
     end
 
+    # Adds attr to this value's attributes.
+    def add_attribute(attr, index = -1)
+      AttributeCollection.new(self, index).add(attr)
+    end
+
+    # Removes the given attribute from the function.
+    def remove_attribute(attr, index = -1)
+      AttributeCollection.new(self, index).remove(attr)
+    end
+
+    def attribute_count
+      function_attributes.count
+    end
+
+    def attributes
+      function_attributes.to_a
+    end
+
+    def function_attributes
+      AttributeCollection.new(self, -1)
+    end
+
+    def return_attributes
+      AttributeCollection.new(self, 0)
+    end
+
+    def param_attributes(index)
+      AttributeCollection.new(self, index)
+    end
+
+    class AttributeCollection
+
+      def initialize(fun, index)
+        @fun = fun
+        @index = index
+      end
+
+      def add(attr)
+        attr_kind_id = attribute_id(attr)
+        ctx = Context.global
+        attr_ref = C.create_enum_attribute(ctx, attr_kind_id, 0)
+        C.add_attribute_at_index(@fun, @index, attr_ref)
+      end
+
+      def remove(attr)
+        attr_kind_id = attribute_id(attr)
+        C.remove_enum_attribute_at_index(@fun, @index, attr_kind_id)
+      end
+
+      def count
+        C.get_attribute_count_at_index(@fun, @index)
+      end
+
+      def to_a
+        attr_refs = nil
+        n = count
+        FFI::MemoryPointer.new(:pointer, n) do |p|
+          C.get_attributes_at_index(@fun, @index, p)
+          attr_refs = p.read_array_of_type(:pointer, :read_pointer, n)
+        end
+
+        attr_refs.map { |e| C.get_enum_attribute_kind(e) }
+      end
+
+      private
+
+      def attribute_name(attr_name)
+        attr_name = attr_name.to_s
+        if attr_name =~ /_attribute$/
+          attr_name.chomp('_attribute').tr('_', '')
+        else
+          attr_name
+        end
+      end
+
+      def attribute_id(attr_name)
+        attr_mem = FFI::MemoryPointer.from_string(attribute_name(attr_name))
+        attr_kind_id = C.get_enum_attribute_kind_for_name(attr_mem, attr_mem.size - 1)
+
+        raise "No attribute named: #{attr_name}" if attr_kind_id.zero?
+        attr_kind_id
+      end
+    end
+
     # @private
     class BasicBlockCollection
       include Enumerable
@@ -716,7 +845,7 @@ module LLVM
         return to_enum :each unless block_given?
 
         ptr = C.get_first_basic_block(@fun)
-        0.upto(size-1) do |i|
+        0.upto(size - 1) do |i|
           yield BasicBlock.from_ptr(ptr)
           ptr = C.get_next_basic_block(ptr)
         end
@@ -761,7 +890,7 @@ module LLVM
 
       # Returns a Value representation of the parameter at the given index.
       def [](i)
-        sz = self.size
+        sz = size
         i = sz + i if i < 0
         return unless 0 <= i && i < sz
         Value.from_ptr(C.get_param(@fun, i))
@@ -777,7 +906,7 @@ module LLVM
       # Iteraters through each parameter in the collection.
       def each
         return to_enum :each unless block_given?
-        0.upto(size-1) { |i| yield self[i] }
+        0.upto(size - 1) { |i| yield self[i] }
         self
       end
     end
@@ -785,6 +914,7 @@ module LLVM
     def gc=(name)
       C.set_gc(self, name)
     end
+
     def gc
       C.get_gc(self)
     end

data/lib/llvm/core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'llvm'
 require 'llvm/core_ffi'
 require 'llvm/support'
@@ -6,6 +8,49 @@ module LLVM
   # @private
   module C
     attach_function :dispose_message, :LLVMDisposeMessage, [:pointer], :void
+
+    # typedef unsigned LLVMAttributeIndex;
+    typedef(:uint, :llvmattributeindex)
+
+    # void LLVMAddAttributeAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef A);
+    attach_function :add_attribute_at_index, :LLVMAddAttributeAtIndex, [:pointer, :llvmattributeindex, :pointer], :void
+
+    # void LLVMRemoveEnumAttributeAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID);
+    attach_function :remove_enum_attribute_at_index, :LLVMRemoveEnumAttributeAtIndex, [:pointer, :llvmattributeindex, :uint], :void
+
+    # LLVMAttributeRef LLVMCreateEnumAttribute
+    # (LLVMContextRef C, unsigned KindID, uint64_t Val);
+    attach_function :create_enum_attribute, :LLVMCreateEnumAttribute, [:pointer, :uint, :uint64], :pointer
+
+    # unsigned LLVMGetEnumAttributeKindForName
+    # (const char *Name, size_t SLen);
+    attach_function :get_enum_attribute_kind_for_name, :LLVMGetEnumAttributeKindForName, [:pointer, :size_t], :uint
+
+    # unsigned LLVMGetAttributeCountAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx);
+    attach_function :get_attribute_count_at_index, :LLVMGetAttributeCountAtIndex, [:pointer, :llvmattributeindex], :uint
+
+    # void LLVMGetAttributesAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs);
+    attach_function :get_attributes_at_index, :LLVMGetAttributesAtIndex, [:pointer, :llvmattributeindex, :pointer], :void
+
+    # unsigned LLVMGetEnumAttributeKind
+    # (LLVMAttributeRef A);
+    attach_function :get_enum_attribute_kind, :LLVMGetEnumAttributeKind, [:pointer], :uint
+
+    # uint64_t LLVMGetEnumAttributeValue
+    # (LLVMAttributeRef A);
+    attach_function :get_enum_attribute_value, :LLVMGetEnumAttributeKind, [:pointer], :uint64
+
+    # const char *LLVMGetStringAttributeKind
+    # (LLVMAttributeRef A, unsigned *Length);
+    attach_function :get_string_attribute_kind, :LLVMGetStringAttributeKind, [:pointer, :pointer], :pointer
+
+    # const char *LLVMGetStringAttributeValue
+    # (LLVMAttributeRef A, unsigned *Length);
+    attach_function :get_string_attribute_value, :LLVMGetStringAttributeValue, [:pointer, :pointer], :pointer
   end
 
   # Yields a pointer suitable for storing an LLVM output message.
@@ -23,7 +68,7 @@ module LLVM
       msg_ptr = str.read_pointer
 
       if result != 0
-        raise RuntimeError, "Error is signalled, but msg_ptr is null" if msg_ptr.null?
+        raise "Error is signalled, but msg_ptr is null" if msg_ptr.null?
 
         message = msg_ptr.read_string
         C.dispose_message msg_ptr
@@ -41,7 +86,7 @@ module LLVM
   def self.with_error_output(&block)
     error = with_message_output(&block)
 
-    raise RuntimeError, error unless error.nil?
+    raise error unless error.nil?
   end
 
   require 'llvm/core/context'