ruby-llvm 18.1.7 → 18.2.0

data/lib/llvm/core/value.rb

@@ -20,13 +20,13 @@ module LLVM
       when :instruction
         Instruction.from_ptr(ptr)
       when :const_int
-        Int.from_ptr(ptr)
+        ConstantInt.from_ptr(ptr)
       when :const_fp
-        Float.from_ptr(ptr)
+        ConstantReal.from_ptr(ptr)
       when :poison
         Poison.from_ptr(ptr)
       when :global_variable
-        GlobalValue.from_ptr(ptr)
+        GlobalVariable.from_ptr(ptr)
       else
         raise "from_ptr_kind cannot handle: #{kind}"
       end
@@ -51,8 +51,35 @@ module LLVM
       C.get_value_kind(self)
     end
 
+    def allocated_type?
+      case self
+      when Instruction
+        true
+      else
+        false
+      end
+    end
+
+    # allocated type of alloca
+    # also works on geps of allocas
     def allocated_type
-      Type.from_ptr(C.get_allocated_type(self), nil)
+      return if !allocated_type?
+
+      alloc_type = C.get_allocated_type(self)
+      return nil if alloc_type.nil?
+
+      Type.from_ptr(alloc_type, nil)
+    end
+
+    def gep_source_element_type?
+      is_a?(Instruction)
+    end
+
+    # element type of gep
+    def gep_source_element_type
+      return if !gep_source_element_type?
+
+      Type.from_ptr(C.get_gep_source_element_type(self))
     end
 
     # Returns the value's name.
@@ -63,12 +90,13 @@ module LLVM
     # Sets the value's name to str.
     def name=(str)
       C.set_value_name(self, str)
-      str
     end
 
     # Print the value's IR to stdout.
     def dump
+      # :nocov:
       C.dump_value(self)
+      # :nocov:
     end
 
     def to_s
@@ -77,26 +105,22 @@ module LLVM
 
     # Returns whether the value is constant.
     def constant?
-      case C.is_constant(self)
-      when 0 then false
-      when 1 then true
-      end
+      C.is_constant(self)
     end
 
     # Returns whether the value is null.
     def null?
-      case C.is_null(self)
-      when 0 then false
-      when 1 then true
-      end
+      C.is_null(self)
     end
 
     # Returns whether the value is undefined.
-    def undefined?
-      case C.is_undef(self)
-      when 0 then false
-      when 1 then true
-      end
+    def undef?
+      C.is_undef(self)
+    end
+    alias_method :undefined?, :undef?
+
+    def poison?
+      C.is_poison(self)
     end
 
     # Adds attr to this value's attributes.
@@ -144,7 +168,6 @@ module LLVM
       return if index.nil?
       index + 1
     end
-
   end
 
   class Argument < Value
@@ -213,11 +236,12 @@ module LLVM
       # Iterates through each Instruction in the collection.
       def each
         return to_enum :each unless block_given?
-        inst, last = first, last
+        inst = first
+        final = last
 
         while inst
           yield inst
-          break if inst == last
+          break if inst == final
           inst = inst.next
         end
 
@@ -288,6 +312,10 @@ module LLVM
       from_ptr(C.get_undef(type))
     end
 
+    def self.poison(type)
+      from_ptr(C.get_poison(type))
+    end
+
     # Creates a null pointer constant of Type.
     def self.null_ptr(type)
       from_ptr(C.const_pointer_null(type))
@@ -299,7 +327,7 @@ module LLVM
     end
 
     # @deprecated
-    alias bit_cast bitcast_to
+    alias_method :bit_cast, :bitcast_to
 
     # Returns the element pointer at the given indices of the constant.
     # For more information on gep go to: http://llvm.org/docs/GetElementPtr.html
@@ -339,6 +367,10 @@ module LLVM
       from_ptr(C.const_string(str, str.length, null_terminate ? 0 : 1))
     end
 
+    def self.string_in_context(context, str, null_terminate = true)
+      from_ptr(C.const_string_in_context(context, str, str.length, null_terminate ? 0 : 1))
+    end
+
     # ConstantArray.const(type, 3) {|i| ... } or
     # ConstantArray.const(type, [...])
     def self.const(type, size_or_values, &block)
@@ -359,38 +391,44 @@ module LLVM
   end
 
   class ConstantInt < Constant
-    def self.all_ones
-      from_ptr(C.const_all_ones(type))
-    end
-
-    # Creates a ConstantInt from an integer.
-    def self.from_i(int, signed = true)
-      width = type.width
-      return type.poison if !fits_width?(int, width, signed)
-
-      from_ptr(C.const_int(type, int, signed ? 1 : 0))
-    end
-
-    # does int fit in width
-    # allow 1 for signed i1 (though really it's -1 to 0)
-    def self.fits_width?(int, width, signed)
-      if signed
-        int.bit_length < width || int == 1
-      else
-        int >= 0 && int.bit_length <= width
-      end
-    end
-
-    def self.parse(str, radix = 10)
-      from_ptr(C.const_int_of_string(type, str, radix))
-    end
+    extend Gem::Deprecate
+
+    # def type
+    #   super
+    # end
+    #
+    # def self.all_ones
+    #   from_ptr(C.const_all_ones(type))
+    # end
+    #
+    # # Creates a ConstantInt from an integer.
+    # def self.from_i(int, signed = true)
+    #   width = type.width
+    #   return type.poison if !fits_width?(int, width, signed)
+    #
+    #   from_ptr(C.const_int(type, int, signed ? 1 : 0))
+    # end
+    #
+    # # does int fit in width
+    # # allow 1 for signed i1 (though really it's -1 to 0)
+    # def self.fits_width?(int, width, signed)
+    #   if signed
+    #     int.bit_length < width || int == 1
+    #   else
+    #     int >= 0 && int.bit_length <= width
+    #   end
+    # end
+    #
+    # def self.parse(str, radix = 10)
+    #   from_ptr(C.const_int_of_string(type, str, radix))
+    # end
 
     # Negation.
     def -@
       self.class.from_ptr(C.const_neg(self))
     end
 
-    alias neg -@
+    alias_method :neg, :-@
 
     # "No signed wrap" negation.
     def nsw_neg
@@ -398,16 +436,20 @@ module LLVM
     end
 
     # "No unsigned wrap" negation.
+    # @deprecated
     def nuw_neg
+      # :nocov:
       self.class.from_ptr(C.const_nuw_neg(self))
+      # :nocov:
     end
+    deprecate :nuw_neg, "neg", 2025, 3
 
     # Addition.
     def +(rhs)
       self.class.from_ptr(C.const_add(self, rhs))
     end
 
-    alias add +
+    alias_method :add, :+
 
     # "No signed wrap" addition.
     def nsw_add(rhs)
@@ -424,7 +466,7 @@ module LLVM
       self.class.from_ptr(C.const_sub(self, rhs))
     end
 
-    alias sub -
+    alias_method :sub, :-
 
     # "No signed wrap" subtraction.
     def nsw_sub(rhs)
@@ -441,7 +483,7 @@ module LLVM
       self.class.from_ptr(C.const_mul(self, rhs))
     end
 
-    alias mul *
+    alias_method :mul, :*
 
     # "No signed wrap" multiplication.
     def nsw_mul(rhs)
@@ -455,22 +497,26 @@ module LLVM
 
     # Unsigned division.
     def udiv(rhs)
-      self.class.from_i(to_ui / rhs.to_ui, false)
+      width = [type.width, rhs.type.width].max
+      LLVM::Type.integer(width).from_i(to_ui / rhs.to_ui, false)
     end
 
     # Signed division.
     def /(rhs)
-      self.class.from_i(to_si / rhs.to_si, true)
+      width = [type.width, rhs.type.width].max
+      LLVM::Type.integer(width).from_i(to_si / rhs.to_si, true)
     end
 
     # Unsigned remainder.
     def urem(rhs)
-      self.class.from_i(to_ui % rhs.to_ui, false)
+      width = [type.width, rhs.type.width].max
+      LLVM::Type.integer(width).from_i(to_ui % rhs.to_ui, false)
     end
 
     # Signed remainder.
     def rem(rhs)
-      self.class.from_i(to_si % rhs.to_si, true)
+      width = [type.width, rhs.type.width].max
+      LLVM::Type.integer(width).from_i(to_si % rhs.to_si, true)
     end
 
     # Boolean negation.
@@ -478,47 +524,53 @@ module LLVM
       self.class.from_ptr(C.const_not(self))
     end
 
-    alias not ~
+    alias_method :not, :~
 
     # Integer AND.
     # was: self.class.from_ptr(C.const_and(self, rhs))
     def &(rhs)
-      self.class.from_i(to_i & rhs.to_i)
+      width = [type.width, rhs.type.width].max
+      LLVM::Type.integer(width).from_i(to_i & rhs.to_i)
     end
 
-    alias and &
+    alias_method :and, :&
 
     # Integer OR.
     def |(rhs)
-      self.class.from_i(to_i | rhs.to_i)
+      width = [type.width, rhs.type.width].max
+      LLVM::Type.integer(width).from_i(to_i | rhs.to_i)
     end
 
-    alias or |
+    alias_method :or, :|
 
     # Integer XOR.
     def ^(rhs)
       self.class.from_ptr(C.const_xor(self, rhs))
     end
 
-    alias xor ^
+    alias_method :xor, :^
 
     # Shift left.
     def <<(bits)
-      self.class.from_ptr(C.const_shl(self, bits))
+      width = [type.width, bits.type.width].max
+      LLVM::Type.integer(width).from_i(to_i << bits.to_i)
     end
 
-    alias shl <<
+    alias_method :shl, :<<
 
     # Shift right.
-    def >>(bits)
-      self.class.from_ptr(C.const_l_shr(self, bits))
+    def lshr(bits)
+      width = [type.width, bits.type.width].max
+      LLVM::Type.integer(width).from_i(to_ui >> bits.to_i)
     end
 
-    alias shr >>
+    alias_method :shr, :lshr
+    alias_method :>>, :lshr
 
     # Arithmatic shift right.
     def ashr(bits)
-      self.class.from_ptr(C.const_a_shr(self, bits))
+      width = [type.width, bits.type.width].max
+      LLVM::Type.integer(width).from_i(to_i >> bits.to_i)
     end
 
     # Integer comparison using the predicate specified via the first parameter.
@@ -533,12 +585,12 @@ module LLVM
     #   :sge - signed greater than or equal to
     #   :slt - signed less than
     #   :sle - signed less than or equal to
-    def icmp(pred, rhs)
-      self.class.from_ptr(C.const_i_cmp(pred, self, rhs))
+    def icmp(_pred, _rhs)
+      raise DeprecationError
     end
 
     # Conversion to pointer.
-    def int_to_ptr(type)
+    def int_to_ptr(type = LLVM.Pointer)
       ConstantExpr.from_ptr(C.const_int_to_ptr(self, type))
     end
 
@@ -584,19 +636,14 @@ module LLVM
     end
   end
 
+  # creates LLVM::Int1, LLVM::Int64, etc
   def self.const_missing(const)
     case const.to_s
     when /Int(\d+)/
       width = Regexp.last_match(1).to_i
-      name  = "Int#{width}"
-      eval <<-KLASS
-        class #{name} < ConstantInt
-          def self.type
-            Type.from_ptr(C.int_type(#{width}), :integer)
-          end
-        end
-      KLASS
-      const_get(name)
+      name = "Int#{width}"
+      value = LLVM::Type.integer(width).freeze
+      const_set(name, value)
     else
       super
     end
@@ -623,42 +670,39 @@ module LLVM
   ::LLVM::FALSE = ::LLVM::Int1.from_i(0)
 
   class ConstantReal < Constant
-    # Creates a ConstantReal from a float of Type.
-    def self.from_f(n)
-      from_ptr(C.const_real(type, n))
-    end
-
-    def self.parse(type, str)
-      from_ptr(C.const_real_of_string(type, str))
-    end
-
     # Negation.
+    # fneg
     def -@
-      self.class.from_f(-to_f)
+      type.from_f(-to_f)
     end
 
     # Returns the result of adding this ConstantReal to rhs.
     def +(rhs)
-      self.class.from_f(to_f + rhs.to_f)
+      type = LLVM::RealType.fits([self.type, rhs.type])
+      type.from_f(to_f + rhs.to_f)
     end
 
     def -(rhs)
-      self.class.from_f(to_f - rhs.to_f)
+      type = LLVM::RealType.fits([self.type, rhs.type])
+      type.from_f(to_f - rhs.to_f)
     end
 
     # Returns the result of multiplying this ConstantReal by rhs.
     def *(rhs)
-      self.class.from_f(to_f * rhs.to_f)
+      type = LLVM::RealType.fits([self.type, rhs.type])
+      type.from_f(to_f * rhs.to_f)
     end
 
     # Returns the result of dividing this ConstantReal by rhs.
     def /(rhs)
-      self.class.from_f(to_f / rhs.to_f) # rubocop:disable Style/FloatDivision
+      type = LLVM::RealType.fits([self.type, rhs.type])
+      type.from_f(to_f / rhs.to_f) # rubocop:disable Style/FloatDivision
     end
 
     # Remainder.
     def rem(rhs)
-      self.class.from_f(to_f.divmod(rhs.to_f).last)
+      type = LLVM::RealType.fits([self.type, rhs.type])
+      type.from_f(to_f.divmod(rhs.to_f).last)
     end
 
     # Floating point comparison using the predicate specified via the first
@@ -679,8 +723,8 @@ module LLVM
     #   :sle  - unordered and less than or equal to
     #   :true - always true
     #   :false- always false
-    def fcmp(pred, rhs)
-      self.class.from_ptr(C.llmv_const_f_cmp(pred, self, rhs))
+    def fcmp(_pred, _rhs)
+      raise DeprecationError
     end
 
     # constant FPToSI
@@ -711,29 +755,6 @@ module LLVM
       end
       double
     end
-
-  end
-
-  class Float < ConstantReal
-    # Return a Type representation of the float.
-    def self.type
-      Type.from_ptr(C.float_type, :float)
-    end
-  end
-
-  # Create a LLVM::Float from a Ruby Float (val).
-  def self.Float(val)
-    Float.from_f(val)
-  end
-
-  class Double < ConstantReal
-    def self.type
-      Type.from_ptr(C.double_type, :double)
-    end
-  end
-
-  def self.Double(val)
-    Double.from_f(val)
   end
 
   class ConstantStruct < Constant
@@ -761,6 +782,11 @@ module LLVM
 
     def self.const(size_or_values, &block)
       vals = LLVM::Support.allocate_pointers(size_or_values, &block)
+
+      # size 0, or empty values
+      # this will segfault in const_vector
+      raise ArgumentError if vals.size.zero? # rubocop:disable Style/ZeroLengthPredicate
+
       from_ptr(C.const_vector(vals, vals.size / vals.type_size))
     end
 
@@ -810,27 +836,6 @@ module LLVM
       C.set_alignment(self, bytes)
     end
 
-    def initializer
-      Value.from_ptr(C.get_initializer(self))
-    end
-
-    def initializer=(val)
-      C.set_initializer(self, val)
-    end
-
-    def global_constant?
-      C.is_global_constant(self) != 0
-    end
-
-    def global_constant=(flag)
-      if flag.kind_of?(Integer)
-        warn 'Warning: Passing Integer value to LLVM::GlobalValue#global_constant=(Boolean) is deprecated.'
-        flag = !flag.zero?
-      end
-
-      C.set_global_constant(self, flag ? 1 : 0)
-    end
-
     def unnamed_addr?
       C.has_unnamed_addr(self) != 0
     end
@@ -852,7 +857,6 @@ module LLVM
     # Sets the function's calling convention and returns it.
     def call_conv=(conv)
       C.set_function_call_conv(self, conv)
-      conv
     end
 
     # gets the calling convention of the function
@@ -860,6 +864,21 @@ module LLVM
       C.get_function_call_conv(self)
     end
 
+    # Get personality function of function
+    # @note Experimental and unsupported
+    # @return LLVM::Function
+    def personality_function
+      ptr = C.get_personality_fn(self)
+      LLVM::Function.from_ptr(ptr)
+    end
+
+    # Set personality function of function
+    # @note Experimental and unsupported
+    # @return self
+    def personality_function=(personality_function)
+      C.set_personality_fn(self, personality_function)
+    end
+
     # Returns an Enumerable of the BasicBlocks in this function.
     def basic_blocks
       @basic_block_collection ||= BasicBlockCollection.new(self)
@@ -921,7 +940,6 @@ module LLVM
     end
 
     class AttributeCollection
-
       def initialize(fun, index)
         @fun = fun
         @index = index
@@ -1001,7 +1019,6 @@ module LLVM
           LLVM::Attribute.memory(inaccessiblemem: :readwrite)
         end
       end
-
     end
 
     # @private
@@ -1117,23 +1134,42 @@ module LLVM
     end
 
     def initializer=(val)
+      raise ArgumentError unless val.is_a? Constant
+
       C.set_initializer(self, val)
     end
 
     def thread_local?
-      case C.is_thread_local(self)
-      when 0 then false
-      else true
-      end
+      C.is_thread_local(self)
     end
 
     def thread_local=(local)
       C.set_thread_local(self, local ? 1 : 0)
     end
+
+    def global_constant?
+      C.is_global_constant(self)
+    end
+
+    def global_constant=(flag)
+      if flag.kind_of?(Integer)
+        warn 'Warning: Passing Integer value to LLVM::GlobalValue#global_constant=(Boolean) is deprecated.'
+        flag = !flag.zero?
+      end
+
+      C.set_global_constant(self, flag ? 1 : 0)
+    end
+
+    def externally_initialized?
+      C.is_externally_initialized(self)
+    end
+
+    def externally_initialized=(boolean)
+      C.set_externally_initialized(self, boolean)
+    end
   end
 
   class Instruction < User
-
     def self.from_ptr(ptr)
       kind = C.get_value_kind(ptr)
       kind == :instruction ? super : LLVM::Value.from_ptr_kind(ptr)
@@ -1164,17 +1200,45 @@ module LLVM
     def inspect
       { self.class.name => { opcode: opcode, ptr: @ptr } }.to_s
     end
+
+    def nsw!
+      C.set_nsw(self, true)
+      self
+    end
+
+    def clear_nsw!
+      C.set_nsw(self, false)
+      self
+    end
+
+    def nuw!
+      C.set_nuw(self, true)
+      self
+    end
+
+    def clear_nuw!
+      C.set_nuw(self, false)
+      self
+    end
+
+    def exact!
+      C.set_exact(self, true)
+      self
+    end
+
+    def clear_exact!
+      C.set_exact(self, false)
+      self
+    end
   end
 
   class Poison < Value
-
   end
 
   class CallInst < Instruction
     # Sets the call convention to conv.
     def call_conv=(conv)
       C.set_instruction_call_conv(self, conv)
-      conv
     end
 
     # Returns the call insatnce's call convention.
@@ -1183,6 +1247,9 @@ module LLVM
     end
   end
 
+  class InvokeInst < CallInst
+  end
+
   # @private
   class Phi < Instruction
     # Add incoming branches to a phi node by passing an alternating list of
@@ -1214,7 +1281,6 @@ module LLVM
     end
   end
 
-
   # @private
   class IndirectBr < Instruction
     # Adds a basic block reference as a destination for this indirect branch.
@@ -1222,6 +1288,6 @@ module LLVM
       C.add_destination(self, dest)
     end
 
-    alias :<< :add_dest
+    alias_method :<<, :add_dest
   end
 end