ruby-llvm 3.2.0.beta.1 → 3.3.0

data/lib/llvm/core/value.rb

@@ -219,6 +219,9 @@ module LLVM
       ConstantExpr.from_ptr(C.const_bit_cast(self, type))
     end
 
+    # @deprecated
+    alias 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
     def gep(*indices)
@@ -230,8 +233,9 @@ module LLVM
       end
     end
 
-    def bit_cast(type)
-      return ConstantExpr.from_ptr(C.const_bit_cast(self, type))
+    # Conversion to integer.
+    def ptr_to_int(type)
+      ConstantInt.from_ptr(C.const_ptr_to_int(self, type))
     end
   end
 
@@ -290,29 +294,69 @@ module LLVM
       self.class.from_ptr(C.const_neg(self))
     end
 
-    # Boolean negation.
-    def ~@
-      self.class.from_ptr(C.const_not(self))
+    alias neg -@
+
+    # "No signed wrap" negation.
+    def nsw_neg
+      self.class.from_ptr(C.const_nsw_neg(self))
     end
 
-    alias not ~
+    # "No unsigned wrap" negation.
+    def nuw_neg
+      self.class.from_ptr(C.const_nuw_neg(self))
+    end
 
     # Addition.
     def +(rhs)
       self.class.from_ptr(C.const_add(self, rhs))
     end
 
-    # "No signed wrap" addition. See
-    # http://llvm.org/docs/LangRef.html#i_add for discusison.
+    alias add +
+
+    # "No signed wrap" addition.
     def nsw_add(rhs)
       self.class.from_ptr(C.const_nsw_add(self, rhs))
     end
 
+    # "No unsigned wrap" addition.
+    def nuw_add(rhs)
+      self.class.from_ptr(C.const_nuw_add(self, rhs))
+    end
+
+    # Subtraction.
+    def -(rhs)
+      self.class.from_ptr(C.const_sub(self, rhs))
+    end
+
+    alias sub -
+
+    # "No signed wrap" subtraction.
+    def nsw_sub(rhs)
+      self.class.from_ptr(C.const_nsw_sub(self, rhs))
+    end
+
+    # "No unsigned wrap" subtraction.
+    def nuw_sub(rhs)
+      self.class.from_ptr(C.const_nuw_sub(self, rhs))
+    end
+
     # Multiplication.
     def *(rhs)
       self.class.from_ptr(C.const_mul(self, rhs))
     end
 
+    alias mul *
+
+    # "No signed wrap" multiplication.
+    def nsw_mul(rhs)
+      self.class.from_ptr(C.const_nsw_mul(self, rhs))
+    end
+
+    # "No unsigned wrap" multiplication.
+    def nuw_mul(rhs)
+      self.class.from_ptr(C.const_nuw_mul(self, rhs))
+    end
+
     # Unsigned division.
     def udiv(rhs)
       self.class.from_ptr(C.const_u_div(self, rhs))
@@ -333,21 +377,53 @@ module LLVM
       self.class.from_ptr(C.const_s_rem(self, rhs))
     end
 
+    # Boolean negation.
+    def ~@
+      self.class.from_ptr(C.const_not(self))
+    end
+
+    alias not ~
+
     # Integer AND.
-    def and(rhs)
+    def &(rhs)
       self.class.from_ptr(C.const_and(self, rhs))
     end
 
+    alias and &
+
     # Integer OR.
-    def or(rhs)
+    def |(rhs)
       self.class.from_ptr(C.const_or(self, rhs))
     end
 
+    alias or |
+
     # Integer XOR.
-    def xor(rhs)
+    def ^(rhs)
       self.class.from_ptr(C.const_xor(self, rhs))
     end
 
+    alias xor ^
+
+    # Shift left.
+    def <<(bits)
+      self.class.from_ptr(C.const_shl(self, bits))
+    end
+
+    alias shl <<
+
+    # Shift right.
+    def >>(bits)
+      self.class.from_ptr(C.const_l_shr(self, bits))
+    end
+
+    alias shr >>
+
+    # Arithmatic shift right.
+    def ashr(bits)
+      self.class.from_ptr(C.const_a_shr(self, bits))
+    end
+
     # Integer comparison using the predicate specified via the first parameter.
     # Predicate can be any of:
     #   :eq  - equal to
@@ -364,19 +440,9 @@ module LLVM
       self.class.from_ptr(C.const_i_cmp(pred, self, rhs))
     end
 
-    # Shift left.
-    def <<(bits)
-      self.class.from_ptr(C.const_shl(self, bits))
-    end
-
-    # Shift right.
-    def >>(bits)
-      self.class.from_ptr(C.const_l_shr(self, bits))
-    end
-
-    # Arithmatic shift right.
-    def ashr(bits)
-      self.class.from_ptr(C.const_a_shr(self, bits))
+    # Conversion to pointer.
+    def int_to_ptr(type)
+      ConstantExpr.from_ptr(C.const_int_to_ptr(self, type))
     end
   end
 
@@ -505,6 +571,11 @@ module LLVM
       vals = LLVM::Support.allocate_pointers(size_or_values, &block)
       from_ptr C.const_struct(vals, vals.size / vals.type_size, packed ? 1 : 0)
     end
+
+    def self.named_const(type, size_or_values, &block)
+      vals = LLVM::Support.allocate_pointers(size_or_values, &block)
+      from_ptr C.const_named_struct(type, vals, vals.size / vals.type_size)
+    end
   end
 
   class ConstantVector < Constant
@@ -607,7 +678,11 @@ module LLVM
     end
 
     def type
-      Type.from_ptr(C.type_of(self), :function)
+      Type.from_ptr(C.type_of(self), :pointer)
+    end
+
+    def function_type
+      type.element_type
     end
 
     # @private
@@ -789,4 +864,15 @@ module LLVM
       C.add_case(self, val, block)
     end
   end
+
+
+  # @private
+  class IndirectBr < Instruction
+    # Adds a basic block reference as a destination for this indirect branch.
+    def add_dest(dest)
+      C.add_destination(self, dest)
+    end
+
+    alias :<< :add_dest
+  end
 end

data/lib/llvm/core_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.2'
+  ffi_lib 'LLVM-3.3'
   
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -651,6 +651,121 @@ module LLVM::C
     :filter, 1
   ]
   
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:thread_local_mode).</em>
+  # 
+  # === Options:
+  # :not_thread_local ::
+  #   
+  # :general_dynamic_tls_model ::
+  #   
+  # :local_dynamic_tls_model ::
+  #   
+  # :initial_exec_tls_model ::
+  #   
+  # :local_exec_tls_model ::
+  #   
+  # 
+  # @method _enum_thread_local_mode_
+  # @return [Symbol]
+  # @scope class
+  enum :thread_local_mode, [
+    :not_thread_local, 0,
+    :general_dynamic_tls_model, 1,
+    :local_dynamic_tls_model, 2,
+    :initial_exec_tls_model, 3,
+    :local_exec_tls_model, 4
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:atomic_ordering).</em>
+  # 
+  # === Options:
+  # :not_atomic ::
+  #   
+  # :unordered ::
+  #   < A load or store which is not atomic
+  # :monotonic ::
+  #   < Lowest level of atomicity, guarantees
+  #                                        somewhat sane results, lock free.
+  # :acquire ::
+  #   < guarantees that if you take all the 
+  #                                        operations affecting a specific address, 
+  #                                        a consistent ordering exists
+  # :release ::
+  #   < Acquire provides a barrier of the sort 
+  #                                      necessary to acquire a lock to access other 
+  #                                      memory with normal loads and stores.
+  # :acquire_release ::
+  #   < Release is similar to Acquire, but with 
+  #                                      a barrier of the sort necessary to release 
+  #                                      a lock.
+  # 
+  # @method _enum_atomic_ordering_
+  # @return [Symbol]
+  # @scope class
+  enum :atomic_ordering, [
+    :not_atomic, 0,
+    :unordered, 1,
+    :monotonic, 2,
+    :acquire, 4,
+    :release, 5,
+    :acquire_release, 6
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:atomic_rmw_bin_op).</em>
+  # 
+  # === Options:
+  # :xchg ::
+  #   
+  # :add ::
+  #   < Set the new value and return the one old
+  # :sub ::
+  #   < Add a value and return the old one
+  # :and_ ::
+  #   < Subtract a value and return the old one
+  # :nand ::
+  #   < And a value and return the old one
+  # :or_ ::
+  #   < Not-And a value and return the old one
+  # :xor ::
+  #   < OR a value and return the old one
+  # :max ::
+  #   < Xor a value and return the old one
+  # :min ::
+  #   < Sets the value if it's greater than the
+  #                                original using a signed comparison and return 
+  #                                the old one
+  # :u_max ::
+  #   < Sets the value if it's Smaller than the
+  #                                original using a signed comparison and return 
+  #                                the old one
+  # :u_min ::
+  #   < Sets the value if it's greater than the
+  #                                original using an unsigned comparison and return 
+  #                                the old one
+  # 
+  # @method _enum_atomic_rmw_bin_op_
+  # @return [Symbol]
+  # @scope class
+  enum :atomic_rmw_bin_op, [
+    :xchg, 0,
+    :add, 1,
+    :sub, 2,
+    :and_, 3,
+    :nand, 4,
+    :or_, 5,
+    :xor, 6,
+    :max, 7,
+    :min, 8,
+    :u_max, 9,
+    :u_min, 10
+  ]
+  
   # @}
   # 
   # @method initialize_core(r)
@@ -659,6 +774,15 @@ module LLVM::C
   # @scope class
   attach_function :initialize_core, :LLVMInitializeCore, [OpaquePassRegistry], :void
   
+  # Deallocate and destroy all ManagedStatic variables.
+  #     @see llvm::llvm_shutdown
+  #     @see ManagedStatic
+  # 
+  # @method shutdown()
+  # @return [nil] 
+  # @scope class
+  attach_function :shutdown, :LLVMShutdown, [], :void
+  
   # ===-- Error handling ----------------------------------------------------===
   # 
   # @method dispose_message(message)
@@ -3234,6 +3358,40 @@ module LLVM::C
   # @scope class
   attach_function :set_global_constant, :LLVMSetGlobalConstant, [OpaqueValue, :int], :void
   
+  # (Not documented)
+  # 
+  # @method get_thread_local_mode(global_var)
+  # @param [OpaqueValue] global_var 
+  # @return [Symbol from _enum_thread_local_mode_] 
+  # @scope class
+  attach_function :get_thread_local_mode, :LLVMGetThreadLocalMode, [OpaqueValue], :thread_local_mode
+  
+  # (Not documented)
+  # 
+  # @method set_thread_local_mode(global_var, mode)
+  # @param [OpaqueValue] global_var 
+  # @param [Symbol from _enum_thread_local_mode_] mode 
+  # @return [nil] 
+  # @scope class
+  attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [OpaqueValue, :thread_local_mode], :void
+  
+  # (Not documented)
+  # 
+  # @method is_externally_initialized(global_var)
+  # @param [OpaqueValue] global_var 
+  # @return [Integer] 
+  # @scope class
+  attach_function :is_externally_initialized, :LLVMIsExternallyInitialized, [OpaqueValue], :int
+  
+  # (Not documented)
+  # 
+  # @method set_externally_initialized(global_var, is_ext_init)
+  # @param [OpaqueValue] global_var 
+  # @param [Integer] is_ext_init 
+  # @return [nil] 
+  # @scope class
+  attach_function :set_externally_initialized, :LLVMSetExternallyInitialized, [OpaqueValue, :int], :void
+  
   # @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
   # 
   # This group contains function that operate on global alias values.
@@ -3330,6 +3488,17 @@ module LLVM::C
   # @scope class
   attach_function :add_function_attr, :LLVMAddFunctionAttr, [OpaqueValue, :attribute], :void
   
+  # Add a target-dependent attribute to a fuction
+  # @see llvm::AttrBuilder::addAttribute()
+  # 
+  # @method add_target_dependent_function_attr(fn, a, v)
+  # @param [OpaqueValue] fn 
+  # @param [String] a 
+  # @param [String] v 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_target_dependent_function_attr, :LLVMAddTargetDependentFunctionAttr, [OpaqueValue, :string, :string], :void
+  
   # Obtain an attribute from a function.
   # 
   # @see llvm::Function::getAttributes()
@@ -5158,6 +5327,19 @@ module LLVM::C
   # @scope class
   attach_function :build_ptr_diff, :LLVMBuildPtrDiff, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue
   
+  # (Not documented)
+  # 
+  # @method build_atomic_rmw(b, op, ptr, val, ordering, single_thread)
+  # @param [OpaqueBuilder] b 
+  # @param [Symbol from _enum_atomic_rmw_bin_op_] op 
+  # @param [OpaqueValue] ptr 
+  # @param [OpaqueValue] val 
+  # @param [Symbol from _enum_atomic_ordering_] ordering 
+  # @param [Integer] single_thread 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :build_atomic_rmw, :LLVMBuildAtomicRMW, [OpaqueBuilder, :atomic_rmw_bin_op, OpaqueValue, OpaqueValue, :atomic_ordering, :int], OpaqueValue
+  
   # Changes the type of M so it can be passed to FunctionPassManagers and the
   # JIT.  They take ModuleProviders for historical reasons.
   # 
@@ -5196,6 +5378,43 @@ module LLVM::C
   # @scope class
   attach_function :create_memory_buffer_with_stdin, :LLVMCreateMemoryBufferWithSTDIN, [:pointer, :pointer], :int
   
+  # (Not documented)
+  # 
+  # @method create_memory_buffer_with_memory_range(input_data, input_data_length, buffer_name, requires_null_terminator)
+  # @param [String] input_data 
+  # @param [Integer] input_data_length 
+  # @param [String] buffer_name 
+  # @param [Integer] requires_null_terminator 
+  # @return [OpaqueMemoryBuffer] 
+  # @scope class
+  attach_function :create_memory_buffer_with_memory_range, :LLVMCreateMemoryBufferWithMemoryRange, [:string, :ulong, :string, :int], OpaqueMemoryBuffer
+  
+  # (Not documented)
+  # 
+  # @method create_memory_buffer_with_memory_range_copy(input_data, input_data_length, buffer_name)
+  # @param [String] input_data 
+  # @param [Integer] input_data_length 
+  # @param [String] buffer_name 
+  # @return [OpaqueMemoryBuffer] 
+  # @scope class
+  attach_function :create_memory_buffer_with_memory_range_copy, :LLVMCreateMemoryBufferWithMemoryRangeCopy, [:string, :ulong, :string], OpaqueMemoryBuffer
+  
+  # (Not documented)
+  # 
+  # @method get_buffer_start(mem_buf)
+  # @param [OpaqueMemoryBuffer] mem_buf 
+  # @return [String] 
+  # @scope class
+  attach_function :get_buffer_start, :LLVMGetBufferStart, [OpaqueMemoryBuffer], :string
+  
+  # (Not documented)
+  # 
+  # @method get_buffer_size(mem_buf)
+  # @param [OpaqueMemoryBuffer] mem_buf 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_buffer_size, :LLVMGetBufferSize, [OpaqueMemoryBuffer], :ulong
+  
   # (Not documented)
   # 
   # @method dispose_memory_buffer(mem_buf)
@@ -5294,4 +5513,32 @@ module LLVM::C
   # @scope class
   attach_function :dispose_pass_manager, :LLVMDisposePassManager, [OpaquePassManager], :void
   
+  # Allocate and initialize structures needed to make LLVM safe for
+  #     multithreading. The return value indicates whether multithreaded
+  #     initialization succeeded. Must be executed in isolation from all
+  #     other LLVM api calls.
+  #     @see llvm::llvm_start_multithreaded
+  # 
+  # @method start_multithreaded()
+  # @return [Integer] 
+  # @scope class
+  attach_function :start_multithreaded, :LLVMStartMultithreaded, [], :int
+  
+  # Deallocate structures necessary to make LLVM safe for multithreading.
+  #     Must be executed in isolation from all other LLVM api calls.
+  #     @see llvm::llvm_stop_multithreaded
+  # 
+  # @method stop_multithreaded()
+  # @return [nil] 
+  # @scope class
+  attach_function :stop_multithreaded, :LLVMStopMultithreaded, [], :void
+  
+  # Check whether LLVM is executing in thread-safe mode or not.
+  #     @see llvm::llvm_is_multithreaded
+  # 
+  # @method is_multithreaded()
+  # @return [Integer] 
+  # @scope class
+  attach_function :is_multithreaded, :LLVMIsMultithreaded, [], :int
+  
 end