ruby-llvm 3.1.0.beta.1 → 3.2.0.beta.1

data/lib/llvm/core/pass_manager.rb

@@ -2,64 +2,68 @@ module LLVM
   # The PassManager runs a queue of passes on a module. See
   # http://llvm.org/docs/Passes.html for the list of available passes.
   class PassManager
-    # Creates a new pass manager on the given ExecutionEngine.
-    def initialize(execution_engine)
-      ptr = C.create_pass_manager()
-      C.add_target_data(
-        C.get_execution_engine_target_data(execution_engine), ptr)
-      @ptr = ptr
-
-      do_initialization
+    # Creates a new pass manager.
+    #
+    # @param [LLVM::ExecutionEngine, LLVM::TargetMachine] machine
+    def initialize(machine)
+      @ptr = C.create_pass_manager()
+      C.add_target_data(machine.data_layout, @ptr)
     end
-    
+
     # @private
     def to_ptr
       @ptr
     end
-    
+
     # Append a pass to the pass queue.
-    # @param [Symbol]
+    #
+    # @param  [Symbol] name
     # @return [LLVM::PassManager]
     def <<(name)
       send(:"#{name}!")
+
       self
     end
 
     # Run the pass queue on the given module.
-    # @param [LLVM::Module]
+    #
+    # @param  [LLVM::Module] mod
     # @return [true, false] Indicates whether the module was modified.
     def run(mod)
       C.run_pass_manager(self, mod) != 0
     end
-    
+
     # Disposes the pass manager.
     def dispose
       return if @ptr.nil?
-      do_finalization
+
+      finalize
+
       C.dispose_pass_manager(@ptr)
       @ptr = nil
     end
 
     protected
 
-    def do_initialization
-    end
-
-    def do_finalization
+    def finalize
     end
   end
 
   class FunctionPassManager < PassManager
-    # Creates a new pass manager on the given ExecutionEngine and Module.
-    def initialize(execution_engine, mod)
-      ptr = C.create_function_pass_manager_for_module(mod)
-      C.add_target_data(
-        C.get_execution_engine_target_data(execution_engine), ptr)
-      @ptr = ptr
+    # Creates a new function pass manager.
+    #
+    # @param [LLVM::ExecutionEngine, LLVM::TargetMachine] machine
+    # @param [LLVM::Module] mod
+    def initialize(machine, mod)
+      @ptr = C.create_function_pass_manager_for_module(mod)
+      C.add_target_data(machine.data_layout, @ptr)
+
+      C.initialize_function_pass_manager(self) != 0
     end
 
     # Run the pass queue on the given function.
-    # @param [LLVM::Function]
+    #
+    # @param  [LLVM::Function] fn
     # @return [true, false] indicates whether the function was modified.
     def run(fn)
       C.run_function_pass_manager(self, fn) != 0
@@ -67,11 +71,7 @@ module LLVM
 
     protected
 
-    def do_initialization
-      C.initialize_function_pass_manager(self) != 0
-    end
-
-    def do_finalization
+    def finalize
       C.finalize_function_pass_manager(self) != 0
     end
   end

data/lib/llvm/core/type.rb

@@ -1,27 +1,20 @@
-module LLVM  
+module LLVM
   class Type
+    include PointerIdentity
+
     # @private
-    def to_ptr
-      @ptr
-    end
-    
-    # LLVM's represents types uniquely, and supports pointer equality. 
-    def ==(type)
-      case type
-      when LLVM::Type
-        @ptr == type.to_ptr
-      else
-        false
+    def self.from_ptr(ptr, kind)
+      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
       end
-    end
-    
-    def hash
-      @ptr.address.hash
-    end
-    
-    # Checks if the type is equal to other.
-    def eql?(other)
-      other.instance_of?(self.class) && self == other
+      ty.instance_variable_set(:@ptr, ptr)
+      ty.instance_variable_set(:@kind, kind)
+      ty
     end
 
     # Returns a symbol representation of the types kind (ex. :pointer, :vector, :array.)
@@ -33,7 +26,7 @@ module LLVM
     def size
       LLVM::Int64.from_ptr(C.size_of(self))
     end
-    
+
     def align
       LLVM::Int64.from_ptr(C.align_of(self))
     end
@@ -60,38 +53,28 @@ module LLVM
     def pointer(address_space = 0)
       Type.pointer(self, address_space)
     end
-    
-    # @private
-    def self.from_ptr(ptr, kind)
-      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
-      end
-      ty.instance_variable_set(:@ptr, ptr)
-      ty.instance_variable_set(:@kind, kind)
-      ty
+
+    # Print the type's representation to stdout.
+    def dump
+      Support::C.dump_type(self)
     end
-    
+
     # Creates an array type of Type with the given size.
     def self.array(ty, sz = 0)
       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)
     end
-    
+
     # Creates a vector type of Type with the given element count.
     def self.vector(ty, element_count)
       from_ptr(C.vector_type(LLVM::Type(ty), element_count), :vector)
     end
-    
-    # Creates a function type. Takes an array of argument Types and the result Type. The only option is <tt>:varargs</tt>, 
+
+    # Creates a function type. Takes an array of argument Types and the result Type. The only option is <tt>:varargs</tt>,
     # which when set to true makes the function type take a variable number of args.
     def self.function(arg_types, result_type, options = {})
       arg_types.map! { |ty| LLVM::Type(ty) }
@@ -99,7 +82,7 @@ module LLVM
       arg_types_ptr.write_array_of_pointer(arg_types)
       from_ptr(C.function_type(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0), :function)
     end
-    
+
     # Creates a struct type with the given array of element types.
     def self.struct(elt_types, is_packed, name = nil)
       elt_types.map! { |ty| LLVM::Type(ty) }
@@ -152,13 +135,13 @@ module LLVM
       C.LLVMIsFunctionVarArg(self)
     end
   end
-  
+
   class StructType < Type
     # Returns the name of the struct.
     def name
       C.get_struct_name(self)
     end
-    
+
     # Returns the element types of the struct.
     def element_types
       count = C.count_struct_element_types(self)
@@ -169,7 +152,7 @@ module LLVM
       end
       elt_types
     end
-    
+
     # Sets the struct body.
     def element_types=(elt_types)
       elt_types.map! { |ty| LLVM::Type(ty) }
@@ -180,7 +163,7 @@ module LLVM
   end
 
   module_function
-  
+
   # Creates a Type from the given object.
   def Type(ty)
     case ty
@@ -188,27 +171,27 @@ module LLVM
     else ty.type
     end
   end
-  
+
   # Shortcut to Type.array.
   def Array(ty, sz = 0)
     LLVM::Type.array(ty, sz)
   end
-  
+
   # Shortcut to Type.pointer.
   def Pointer(ty)
     LLVM::Type.pointer(ty)
   end
-  
+
   # Shortcut to Type.vector.
   def Vector(ty, sz)
     LLVM::Type.vector(ty, sz)
   end
-  
+
   # Shortcut to Type.function.
   def Function(argtypes, rettype, options = {})
     LLVM::Type.function(argtypes, rettype, options)
   end
-  
+
   # Shortcut to Type.struct.
   def Struct(*elt_types)
     name = if elt_types.last.is_a? String

data/lib/llvm/core/value.rb

@@ -1,5 +1,7 @@
 module LLVM
   class Value
+    include PointerIdentity
+
     # @private
     def self.from_ptr(ptr)
       return if ptr.null?
@@ -8,30 +10,6 @@ module LLVM
       val
     end
 
-    # @private
-    def to_ptr
-      @ptr
-    end
-
-    # Checks if the value is equal to other.
-    def ==(other)
-      case other
-      when LLVM::Value
-        @ptr == other.to_ptr
-      else
-        false
-      end
-    end
-
-    def hash
-      @ptr.address.hash
-    end
-
-    # Checks if the value is equal to other.
-    def eql?(other)
-      other.instance_of?(self.class) && self == other
-    end
-
     # Returns the Value type. This is abstract and is overidden by its subclasses.
     def self.type
       raise NotImplementedError, "#{self.name}.type() is abstract."
@@ -313,10 +291,12 @@ module LLVM
     end
 
     # Boolean negation.
-    def not
+    def ~@
       self.class.from_ptr(C.const_not(self))
     end
 
+    alias not ~
+
     # Addition.
     def +(rhs)
       self.class.from_ptr(C.const_add(self, rhs))
@@ -594,6 +574,14 @@ module LLVM
     def global_constant=(flag)
       C.set_global_constant(self, flag)
     end
+
+    def unnamed_addr?
+      Support::C.has_unnamed_addr(self) != 0
+    end
+
+    def unnamed_addr=(flag)
+      Support::C.set_unnamed_addr(self, flag ? 1 : 0)
+    end
   end
 
   class Function < GlobalValue

data/lib/llvm/core_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.1'
+  ffi_lib 'LLVM-3.2'
   
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -39,7 +39,7 @@ module LLVM::C
     layout :dummy, :char
   end
   
-  # Represents a basic block of instruction in LLVM IR.
+  # Represents a basic block of instructions in LLVM IR.
   # 
   # This models llvm::BasicBlock.
   class OpaqueBasicBlock < FFI::Struct
@@ -430,9 +430,11 @@ module LLVM::C
   #   
   # :link_once_odr ::
   #   < Keep one copy of function when linking (inline)
-  # :weak_any ::
+  # :link_once_odr_auto_hide ::
   #   < Same, but only replaced by something
   #                               equivalent.
+  # :weak_any ::
+  #   < Like LinkOnceODR, but possibly hidden.
   # :weak_odr ::
   #   < Keep one copy of function when linking (weak)
   # :appending ::
@@ -457,8 +459,6 @@ module LLVM::C
   #   < Tentative definitions
   # :linker_private_weak ::
   #   < Like Private, but linker removes.
-  # :linker_private_weak_def_auto ::
-  #   < Like LinkerPrivate, but is weak.
   # 
   # @method _enum_linkage_
   # @return [Symbol]
@@ -468,19 +468,19 @@ module LLVM::C
     :available_externally, 1,
     :link_once_any, 2,
     :link_once_odr, 3,
-    :weak_any, 4,
-    :weak_odr, 5,
-    :appending, 6,
-    :internal, 7,
-    :private, 8,
-    :dll_import, 9,
-    :dll_export, 10,
-    :external_weak, 11,
-    :ghost, 12,
-    :common, 13,
-    :linker_private, 14,
-    :linker_private_weak, 15,
-    :linker_private_weak_def_auto, 16
+    :link_once_odr_auto_hide, 4,
+    :weak_any, 5,
+    :weak_odr, 6,
+    :appending, 7,
+    :internal, 8,
+    :private, 9,
+    :dll_import, 10,
+    :dll_export, 11,
+    :external_weak, 12,
+    :ghost, 13,
+    :common, 14,
+    :linker_private, 15,
+    :linker_private_weak, 16
   ]
   
   # (Not documented)
@@ -803,6 +803,19 @@ module LLVM::C
   # @scope class
   attach_function :dump_module, :LLVMDumpModule, [OpaqueModule], :void
   
+  # Print a representation of a module to a file. The ErrorMessage needs to be
+  # disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.
+  # 
+  # @see Module::print()
+  # 
+  # @method print_module_to_file(m, filename, error_message)
+  # @param [OpaqueModule] m 
+  # @param [String] filename 
+  # @param [FFI::Pointer(**CharS)] error_message 
+  # @return [Integer] 
+  # @scope class
+  attach_function :print_module_to_file, :LLVMPrintModuleToFile, [OpaqueModule, :string, :pointer], :int
+  
   # Set inline assembly for a module.
   # 
   # @see Module::setModuleInlineAsm()
@@ -2092,7 +2105,7 @@ module LLVM::C
   # 
   # Uses are obtained in an iterator fashion. First, call this function
   # to obtain a reference to the first use. Then, call LLVMGetNextUse()
-  # on that instance and all subsequently obtained instances untl
+  # on that instance and all subsequently obtained instances until
   # LLVMGetNextUse() returns NULL.
   # 
   # @see llvm::Value::use_begin()
@@ -3465,7 +3478,7 @@ module LLVM::C
   # Set the alignment for a function parameter.
   # 
   # @see llvm::Argument::addAttr()
-  # @see llvm::Attribute::constructAlignmentFromInt()
+  # @see llvm::AttrBuilder::addAlignmentAttr()
   # 
   # @method set_param_alignment(arg, align)
   # @param [OpaqueValue] arg 
@@ -3533,6 +3546,34 @@ module LLVM::C
   # @scope class
   attach_function :get_md_string, :LLVMGetMDString, [OpaqueValue, :pointer], :string
   
+  # Obtain the number of operands from an MDNode value.
+  # 
+  # @param V MDNode to get number of operands from.
+  # @return Number of operands of the MDNode.
+  # 
+  # @method get_md_node_num_operands(v)
+  # @param [OpaqueValue] v 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [OpaqueValue], :uint
+  
+  # Obtain the given MDNode's operands.
+  # 
+  # The passed LLVMValueRef pointer should point to enough memory to hold all of
+  # the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as
+  # LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
+  # MDNode's operands.
+  # 
+  # @param V MDNode to get the operands from.
+  # @param Dest Destination array for operands.
+  # 
+  # @method get_md_node_operands(v, dest)
+  # @param [OpaqueValue] v 
+  # @param [FFI::Pointer(*ValueRef)] dest 
+  # @return [nil] 
+  # @scope class
+  attach_function :get_md_node_operands, :LLVMGetMDNodeOperands, [OpaqueValue, :pointer], :void
+  
   # Convert a basic block instance to a value type.
   # 
   # @method basic_block_as_value(bb)
@@ -3825,7 +3866,7 @@ module LLVM::C
   # @scope class
   attach_function :get_next_instruction, :LLVMGetNextInstruction, [OpaqueValue], OpaqueValue
   
-  # Obtain the instruction that occured before this one.
+  # Obtain the instruction that occurred before this one.
   # 
   # If the instruction is the first instruction in a basic block, NULL
   # will be returned.