ruby-llvm 2.9.0 → 2.9.1

data/lib/llvm/core/context.rb

@@ -2,24 +2,27 @@ module LLVM
   class Context
     private_class_method :new
 
-    def initialize(ptr) # :nodoc:
+    # @private
+    def initialize(ptr)
       @ptr = ptr
     end
     
-    def to_ptr # :nodoc:
+    # @private
+    def to_ptr
       @ptr
     end
     
-    # Creates a new Context
+    # Creates a new Context.
     def self.create
       new(C.LLVMContextCreate())
     end
     
-    # Obtains a reference to the global Context
+    # Obtains a reference to the global Context.
     def self.global
       new(C.LLVMGetGlobalContext())
     end
     
+    # Diposes the Context.
     def dispose
       C.LLVMContextDispose(@ptr)
     end

data/lib/llvm/core/module.rb

@@ -2,18 +2,22 @@ module LLVM
   class Module
     private_class_method :new
     
+    # @private
     def self.from_ptr(ptr)
       ptr.null? ? nil : new(ptr)
     end
     
-    def initialize(ptr) # :nodoc:
+    # @private
+    def initialize(ptr)
       @ptr = ptr
     end
     
-    def to_ptr # :nodoc:
+    # @private
+    def to_ptr
       @ptr
     end
     
+    # Checks if the module is equal to other.
     def ==(other)
       case other
       when LLVM::Module
@@ -23,14 +27,17 @@ module LLVM
       end
     end
 
+    # Checks if the module is equal to other.
     def eql?(other)
       other.instance_of?(self.class) && self == other
     end
 
+    # Creates a module with the given name.
     def self.create(name)
       new(C.LLVMModuleCreateWithName(name))
     end
     
+    # Returns a TypeCollection of all the Types in the module.
     def types
       @types ||= TypeCollection.new(self)
     end
@@ -40,26 +47,28 @@ module LLVM
         @module = mod
       end
       
+      # Adds the given Type to the collection with the given name (symbol or string).
       def add(name, type)
         C.LLVMAddTypeName(@module, name.to_s, type)
       end
       
+      # Returns the Type with the given name (symbol or string).
       def named(name)
-        Type.from_ptr(C.LLVMGetTypeByName(@module, name))
+        Type.from_ptr(C.LLVMGetTypeByName(@module, name.to_s))
       end
       
+      # Returns the Type with the a name equal to key (symbol or string).
       def [](key)
-        case key
-        when String then named(key)
-        when Symbol then named(key.to_s)
-        end
+        named(key)
       end
       
+      # Adds the given Type to the collection with a name equal to key (symbol or string).
       def []=(key, type)
         add(key, type)
       end
     end
     
+    # Returns an Enumerable of all the GlobalVariables in the module.
     def globals
       @globals ||= GlobalCollection.new(self)
     end
@@ -71,38 +80,45 @@ module LLVM
         @module = mod
       end
       
+      # Adds a GlobalVariable with the given type and name to the collection (symbol or string).
       def add(ty, name)
-        GlobalVariable.from_ptr(C.LLVMAddGlobal(@module, LLVM::Type(ty), name))
+        GlobalVariable.from_ptr(C.LLVMAddGlobal(@module, LLVM::Type(ty), name.to_s))
       end
       
+      # Returns the GlobalVariable with the given name (symbol or string).
       def named(name)
-        GlobalValue.from_ptr(C.LLVMGetNamedGlobal(@module, name))
+        GlobalValue.from_ptr(C.LLVMGetNamedGlobal(@module, name.to_s))
       end
       
+      # Returns the first GlobalVariable in the collection.
       def first
         GlobalValue.from_ptr(C.LLVMGetFirstGlobal(@module))
       end
       
+      # Returns the last GlobalVariable in the collection.
       def last
         GlobalValue.from_ptr(C.LLVMGetLastGlobal(@module))
       end
       
+      # Returns the next GlobalVariable in the collection after global.
       def next(global)
         GlobalValue.from_ptr(C.LLVMGetNextGlobal(global))
       end
       
+      # Returns the previous GlobalVariable in the collection before global.
       def previous(global)
         GlobalValue.from_ptr(C.LLVMGetPreviousGlobal(global))
       end
       
+      # Deletes the GlobalVariable from the collection.
       def delete(global)
         C.LLVMDeleteGlobal(global)
       end
       
+      # Returns the GlobalVariable with a name equal to key (symbol or string) or at key (integer).
       def [](key)
         case key
-        when String then named(key)
-        when Symbol then named(key.to_s)
+        when String, Symbol then named(key)
         when Integer then
           i = 0
           g = first
@@ -114,6 +130,7 @@ module LLVM
         end
       end
       
+      # Iterates through each GlobalVariable in the collection.
       def each
         g = first
         until g.nil?
@@ -123,6 +140,7 @@ module LLVM
       end
     end
     
+    # Returns a FunctionCollection of all the Functions in the module.
     def functions
       @functions ||= FunctionCollection.new(self)
     end
@@ -134,6 +152,7 @@ module LLVM
         @module = mod
       end
       
+      # Adds a Function with the given name (symbol or string) and args (Types).
       def add(name, *args)
         if args.first.kind_of? Type
           type = args.first
@@ -150,34 +169,40 @@ module LLVM
         function        
       end
       
+      # Returns the Function with the given name (symbol or string).
       def named(name)
-        Function.from_ptr(C.LLVMGetNamedFunction(@module, name))
+        Function.from_ptr(C.LLVMGetNamedFunction(@module, name.to_s))
       end
       
+      # Returns the first Function in the collection.
       def first
         Function.from_ptr(C.LLVMGetFirstFunction(@module))
       end
       
+      # Returns the last Function in the collection.
       def last
         Function.from_ptr(C.LLVMGetLastFunction(@module))
       end
       
+      # Returns the next Function in the collection after function.
       def next(function)
         Function.from_ptr(C.LLVMGetNextFunction(function))
       end
       
+      # Returns the previous Function in the collection before function.
       def previous(function)
         Function.from_ptr(C.LLVMGetPreviousFunction(function))
       end
       
+      # Deletes the Function from the collection.
       def delete(function)
         C.LLVMDeleteFunction(function)
       end
       
+      # Returns the Function with a name equal to key (symbol or string) or at key (integer).
       def [](key)
         case key
-        when String then named(key)
-        when Symbol then named(key.to_s)
+        when String, Symbol then named(key)
         when Integer
           i = 0
           f = first
@@ -189,6 +214,7 @@ module LLVM
         end
       end
       
+      # Iterates through each Function in the collection.
       def each
         f = first
         until f.nil?
@@ -198,11 +224,12 @@ module LLVM
       end
     end
     
-    # Print the module's IR to stdout
+    # Print the module's IR to stdout.
     def dump
       C.LLVMDumpModule(self)
     end
     
+    # Dispose the module.
     def dispose
       C.LLVMDisposeModule(@ptr)
     end

data/lib/llvm/core/pass_manager.rb

@@ -2,6 +2,7 @@ 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.LLVMCreatePassManager()
       C.LLVMAddTargetData(
@@ -9,7 +10,8 @@ module LLVM
       @ptr = ptr
     end
     
-    def to_ptr # :nodoc:
+    # @private
+    def to_ptr
       @ptr
     end
     
@@ -24,16 +26,19 @@ module LLVM
     def do_finalization
     end
 
+    # Runs the passes on the given module.
     def run(mod)
       C.LLVMRunPassManager(self, mod)
     end
     
+    # Disposes the pass manager.
     def dispose
       C.LLVMDisposePassManager(self)
     end
   end
 
   class FunctionPassManager < PassManager
+    # Creates a new pass manager on the given ExecutionEngine and Module.
     def initialize(execution_engine, mod)
       ptr = C.LLVMCreateFunctionPassManagerForModule(mod)
       C.LLVMAddTargetData(
@@ -49,6 +54,7 @@ module LLVM
       C.LLVMFinalizeFunctionPassManager(self) != 0
     end
 
+    # Runs the passes on the given function.
     def run(fn)
       C.LLVMRunFunctionPassManager(self, fn)
     end

data/lib/llvm/core/type.rb

@@ -2,11 +2,13 @@ module LLVM
   class Type
     private_class_method :new
     
-    def initialize(ptr) # :nodoc:
+    # @private
+    def initialize(ptr)
       @ptr = ptr
     end
     
-    def to_ptr # :nodoc:
+    # @private
+    def to_ptr
       @ptr
     end
     
@@ -20,14 +22,17 @@ module LLVM
       end
     end
 
+    # Checks if the type is equal to other.
     def eql?(other)
       other.instance_of?(self.class) && self == other
     end
 
+    # Returns a symbol representation of the types kind (ex. :pointer, :vector, :array.)
     def kind
-        C.LLVMGetTypeKind(self)
+      C.LLVMGetTypeKind(self)
     end
 
+    # Returns the size of the type.
     def size
       Int64.from_ptr(C.LLVMSizeOf(self))
     end
@@ -36,6 +41,7 @@ module LLVM
       Int64.from_ptr(C.LLVMAlignOf(self))
     end
 
+    # Returns the type of this types elements (works only for Pointer, Vector, and Array types.)
     def element_type
       case self.kind
       when :pointer, :vector, :array
@@ -43,14 +49,17 @@ module LLVM
       end
     end
 
+    # Returns a null pointer ConstantExpr of this type.
     def null_pointer
       ConstantExpr.from_ptr(C.LLVMConstPointerNull(self))
     end
 
+    # Returns a null ConstantExpr of this type.
     def null
       ConstantExpr.from_ptr(C.LLVMConstNull(self))
     end
 
+    # Creates a pointer type with this type and the given address space.
     def pointer(address_space = 0)
       Type.pointer(self, address_space)
     end
@@ -59,18 +68,23 @@ module LLVM
       ptr.null? ? nil : new(ptr)
     end
     
+    # Creates an array type of Type with the given size.
     def self.array(ty, sz = 0)
       from_ptr(C.LLVMArrayType(LLVM::Type(ty), sz))
     end
     
+    # Creates the pointer type of Type with the given address space.
     def self.pointer(ty, address_space = 0)
       from_ptr(C.LLVMPointerType(LLVM::Type(ty), address_space))
     end
     
+    # Creates a vector type of Type with the given element count.
     def self.vector(ty, element_count)
       from_ptr(C.LLVMVectorType(LLVM::Type(ty), element_count))
     end
     
+    # 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) }
       arg_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * arg_types.size)
@@ -78,6 +92,7 @@ module LLVM
       from_ptr(C.LLVMFunctionType(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0))
     end
     
+    # Creates a struct type with the given array of element types.
     def self.struct(elt_types, is_packed)
       elt_types.map! { |ty| LLVM::Type(ty) }
       elt_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * elt_types.size)
@@ -85,10 +100,12 @@ module LLVM
       from_ptr(C.LLVMStructType(elt_types_ptr, elt_types.size, is_packed ? 1 : 0))
     end
 
+    # Creates a void type.
     def self.void
       from_ptr(C.LLVMVoidType)
     end
     
+    # Creates an opaque type.
     def self.opaque
       from_ptr(C.LLVMOpaqueType)
     end
@@ -105,6 +122,7 @@ module LLVM
     end
   end
   
+  # Creates a Type from the given object.
   def LLVM.Type(ty)
     case ty
     when LLVM::Type then ty
@@ -112,26 +130,32 @@ module LLVM
     end
   end
   
+  # Shortcut to Type.array.
   def LLVM.Array(ty, sz = 0)
     LLVM::Type.array(ty, sz)
   end
   
+  # Shortcut to Type.pointer.
   def LLVM.Pointer(ty)
     LLVM::Type.pointer(ty)
   end
   
+  # Shortcut to Type.vector.
   def LLVM.Vector(ty, sz)
     LLVM::Type.vector(ty, sz)
   end
   
+  # Shortcut to Type.function.
   def LLVM.Function(argtypes, rettype, options = {})
     LLVM::Type.function(argtypes, rettype, options)
   end
   
+  # Shortcut to Type.struct.
   def LLVM.Struct(*elt_types)
     LLVM::Type.struct(elt_types, false)
   end
 
+  # Shortcut to Type.void.
   def LLVM.Void
     LLVM::Type.void
   end

data/lib/llvm/core/value.rb

@@ -1,19 +1,23 @@
 module LLVM
   class Value
+    # @private
     def self.from_ptr(ptr)
       new(ptr) unless ptr.null?
     end
 
     private_class_method :new
 
+    # @private
     def initialize(ptr)
       @ptr = ptr
     end
 
-    def to_ptr # :nodoc:
+    # @private
+    def to_ptr
       @ptr
     end
 
+    # Checks if the value is equal to other.
     def ==(other)
       case other
       when LLVM::Value
@@ -23,10 +27,12 @@ module LLVM
       end
     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."
     end
@@ -35,23 +41,28 @@ module LLVM
       type.to_ptr
     end
 
+    # Returns the value's type.
     def type
       Type.from_ptr(C.LLVMTypeOf(self))
     end
 
+    # Returns the value's name.
     def name
       C.LLVMGetValueName(self)
     end
 
+    # Sets the value's name to str.
     def name=(str)
       C.LLVMSetValueName(self, str)
       str
     end
 
+    # Print the value's IR to stdout.
     def dump
       C.LLVMDumpValue(self)
     end
 
+    # Returns whether the value is constant.
     def constant?
       case C.LLVMIsConstant(self)
       when 0 then false
@@ -59,6 +70,7 @@ module LLVM
       end
     end
 
+    # Returns whether the value is null.
     def null?
       case C.LLVMIsNull(self)
       when 0 then false
@@ -66,6 +78,7 @@ module LLVM
       end
     end
 
+    # Returns whether the value is undefined.
     def undefined?
       case C.LLVMIsUndef(self)
       when 0 then false
@@ -73,6 +86,7 @@ module LLVM
       end
     end
 
+    # Adds attr to this value's attributes.
     def add_attribute(attr)
       C.LLVMAddAttribute(self, attr)
     end
@@ -82,10 +96,12 @@ module LLVM
   end
 
   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.LLVMAppendBasicBlock(fun, name))
     end
 
+    # Build the basic block with the given builder. Creates a new one if nil. Yields the builder.
     def build(builder = nil)
       if builder.nil?
         builder = Builder.create
@@ -99,16 +115,19 @@ module LLVM
       builder.dispose if islocal
     end
 
+    # Returns the parent of this basic block (a Function).
     def parent
       fp = C.LLVMGetBasicBlockParent(self)
       LLVM::Function.from_ptr(fp) unless fp.null?
     end
 
+    # Returns the next basic block in the sequence.
     def next
       ptr = C.LLVMGetNextBasicBlock(self)
       BasicBlock.from_ptr(ptr) unless ptr.null?
     end
 
+    # Returns the previous basic block in the sequence.
     def previous
       ptr = C.LLVMGetPreviousBasicBlock(self)
       BasicBlock.from_ptr(ptr) unless ptr.null?
@@ -122,10 +141,12 @@ module LLVM
       instructions.last
     end
 
+    # Returns an Enumerable of the Instructions in the current block.
     def instructions
       @instructions ||= InstructionCollection.new(self)
     end
 
+    # @private
     class InstructionCollection
       include Enumerable
 
@@ -133,6 +154,7 @@ module LLVM
         @block = block
       end
 
+      # Iterates through each Instruction in the collection.
       def each
         return to_enum :each unless block_given?
         inst, last = first, last
@@ -146,11 +168,13 @@ module LLVM
         self
       end
 
+      # Returns the first Instruction in the collection.
       def first
         ptr = C.LLVMGetFirstInstruction(@block)
         LLVM::Instruction.from_ptr(ptr) unless ptr.null?
       end
 
+      # Returns the last Instruction in the collection.
       def last
         ptr = C.LLVMGetLastInstruction(@block)
         LLVM::Instruction.from_ptr(ptr) unless ptr.null?
@@ -159,10 +183,12 @@ module LLVM
   end
 
   class User < Value
+    # Returns an Enumerable of the operands in this user.
     def operands
       @operand_collection ||= OperandCollection.new(self)
     end
 
+    # @private
     class OperandCollection
       include Enumerable
 
@@ -170,19 +196,23 @@ module LLVM
         @user = user
       end
 
+      # Get a reference to an operand by index.
       def [](i)
         ptr = C.LLVMGetOperand(@user, i)
         Value.from_ptr(ptr) unless ptr.null?
       end
 
+      # Set or replace an operand by index.
       def []=(i, v)
         C.LLVMSetOperand(@user, i, v)
       end
 
+      # Returns the number of operands in the collection.
       def size
         C.LLVMGetNumOperands(@user)
       end
 
+      # Iterates through each operand in the collection.
       def each
         return to_enum :each unless block_given?
         0.upto(size-1) { |i| yield self[i] }
@@ -192,22 +222,28 @@ module LLVM
   end
 
   class Constant < User
-    def self.null
+    # Creates a null constant of Type.
+    def self.null(type)
       from_ptr(C.LLVMConstNull(type))
     end
 
-    def self.undef
+    # Creates a undefined constant of Type.
+    def self.undef(type)
       from_ptr(C.LLVMGetUndef(type))
     end
 
-    def self.null_ptr
+    # Creates a null pointer constant of Type.
+    def self.null_ptr(type)
       from_ptr(C.LLVMConstPointerNull(type))
     end
 
+    # Bitcast this constant to Type.
     def bitcast_to(type)
       ConstantExpr.from_ptr(C.LLVMConstBitCast(self, type))
     end
 
+    # 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)
       indices = Array(indices)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
@@ -255,6 +291,7 @@ module LLVM
       from_ptr(C.LLVMConstAllOnes(type))
     end
 
+    # Creates a ConstantInt from an integer.
     def self.from_i(n, signed = true)
       from_ptr(C.LLVMConstInt(type, n, signed ? 1 : 0))
     end
@@ -263,72 +300,100 @@ module LLVM
       from_ptr(C.LLVMConstIntOfString(type, str, radix))
     end
 
+    # Negation.
     def -@
       self.class.from_ptr(C.LLVMConstNeg(self))
     end
 
+    # Boolean negation.
     def not
       self.class.from_ptr(C.LLVMConstNot(self))
     end
 
+    # Addition.
     def +(rhs)
       self.class.from_ptr(C.LLVMConstAdd(self, rhs))
     end
 
+    # "No signed wrap" addition. See
+    # http://llvm.org/docs/LangRef.html#i_add for discusison.
     def nsw_add(rhs)
       self.class.from_ptr(C.LLVMConstNSWAdd(self, rhs))
     end
 
+    # Multiplication.
     def *(rhs)
       self.class.from_ptr(C.LLVMConstMul(self, rhs))
     end
 
+    # Unsigned division.
     def udiv(rhs)
       self.class.from_ptr(C.LLVMConstUDiv(self, rhs))
     end
 
+    # Signed division.
     def /(rhs)
       self.class.from_ptr(C.LLVMConstSDiv(self, rhs))
     end
 
+    # Unsigned remainder.
     def urem(rhs)
       self.class.from_ptr(C.LLVMConstURem(self, rhs))
     end
 
+    # Signed remainder.
     def rem(rhs)
       self.class.from_ptr(C.LLVMConstSRem(self, rhs))
     end
 
-    def and(rhs) # Ruby's && cannot be overloaded
+    # Integer AND.
+    def and(rhs)
       self.class.from_ptr(C.LLVMConstAnd(self, rhs))
     end
 
-    def or(rhs) # Nor is ||.
+    # Integer OR.
+    def or(rhs)
       self.class.from_ptr(C.LLVMConstOr(self, rhs))
     end
 
-    def xor(rhs) # Nor is ||.
+    # Integer XOR.
+    def xor(rhs)
       self.class.from_ptr(C.LLVMConstXor(self, rhs))
     end
 
+    # Integer comparison using the predicate specified via the first parameter.
+    # Predicate can be any of:
+    #   :eq  - equal to
+    #   :ne  - not equal to
+    #   :ugt - unsigned greater than
+    #   :uge - unsigned greater than or equal to
+    #   :ult - unsigned less than
+    #   :ule - unsigned less than or equal to
+    #   :sgt - signed greater than
+    #   :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.LLVMConstICmp(pred, self, rhs))
     end
 
+    # Shift left.
     def <<(bits)
-      self.class.from_ptr(C.LLVMConstShl(self, rhs))
+      self.class.from_ptr(C.LLVMConstShl(self, bits))
     end
 
+    # Shift right.
     def >>(bits)
-      self.class.from_ptr(C.LLVMConstLShr(self, rhs))
+      self.class.from_ptr(C.LLVMConstLShr(self, bits))
     end
 
+    # Arithmatic shift right.
     def ashr(bits)
-      self.class.from_ptr(C.LLVMConstAShr(self, rhs))
+      self.class.from_ptr(C.LLVMConstAShr(self, bits))
     end
   end
 
-  def LLVM.const_missing(const) # :nodoc:
+  def LLVM.const_missing(const)
     case const.to_s
     when /Int(\d+)/
       width = $1.to_i
@@ -349,6 +414,7 @@ module LLVM
   # Native integer type
   ::LLVM::Int = const_get("Int#{NATIVE_INT_SIZE}")
 
+  # Creates a LLVM Int (subclass of ConstantInt) at the NATIVE_INT_SIZE from a integer (val).
   def LLVM.Int(val)
     case val
     when LLVM::ConstantInt then val
@@ -357,45 +423,71 @@ module LLVM
   end
 
   class ConstantReal < Constant
+    # Creates a ConstantReal from a float of Type.
     def self.from_f(n)
       from_ptr(C.LLVMConstReal(type, n))
     end
 
-    def self.parse(str)
+    def self.parse(type, str)
       from_ptr(C.LLVMConstRealOfString(type, str))
     end
 
+    # Negation.
     def -@
       self.class.from_ptr(C.LLVMConstFNeg(self))
     end
 
+    # Returns the result of adding this ConstantReal to rhs.
     def +(rhs)
       self.class.from_ptr(C.LLVMConstFAdd(self, rhs))
     end
 
+    # Returns the result of multiplying this ConstantReal by rhs.
     def *(rhs)
       self.class.from_ptr(C.LLVMConstFMul(self, rhs))
     end
 
+    # Returns the result of dividing this ConstantReal by rhs.
     def /(rhs)
       self.class.from_ptr(C.LLVMConstFDiv(self, rhs))
     end
 
+    # Remainder.
     def rem(rhs)
       self.class.from_ptr(C.LLVMConstFRem(self, rhs))
     end
 
+    # Floating point comparison using the predicate specified via the first
+    # parameter. Predicate can be any of:
+    #   :ord  - ordered
+    #   :uno  - unordered: isnan(X) | isnan(Y)
+    #   :oeq  - ordered and equal to
+    #   :oeq  - unordered and equal to
+    #   :one  - ordered and not equal to
+    #   :one  - unordered and not equal to
+    #   :ogt  - ordered and greater than
+    #   :uge  - unordered and greater than or equal to
+    #   :olt  - ordered and less than
+    #   :ule  - unordered and less than or equal to
+    #   :oge  - ordered and greater than or equal to
+    #   :sge  - unordered and greater than or equal to
+    #   :ole  - ordered and less than or equal to
+    #   :sle  - unordered and less than or equal to
+    #   :true - always true
+    #   :false- always false
     def fcmp(pred, rhs)
       self.class.from_ptr(C.LLMVConstFCmp(pred, self, rhs))
     end
   end
 
   class Float < ConstantReal
+    # Return a Type representation of the float.
     def self.type
       Type.from_ptr(C.LLVMFloatType)
     end
   end
 
+  # Create a LLVM::Float from a Ruby Float (val).
   def LLVM.Float(val)
     Float.from_f(val)
   end
@@ -485,23 +577,28 @@ module LLVM
   end
 
   class Function < GlobalValue
+    # Sets the function's calling convention and returns it.
     def call_conv=(conv)
       C.LLVMSetFunctionCallConv(self, conv)
       conv
     end
 
+    # Adds the given attribute to the function.
     def add_attribute(attr)
       C.LLVMAddFunctionAttr(self, attr)
     end
 
+    # Removes the given attribute from the function.
     def remove_attribute(attr)
       C.LLVMRemoveFunctionAttr(self, attr)
     end
 
+    # Returns an Enumerable of the BasicBlocks in this function.
     def basic_blocks
       @basic_block_collection ||= BasicBlockCollection.new(self)
     end
 
+    # @private
     class BasicBlockCollection
       include Enumerable
 
@@ -509,10 +606,12 @@ module LLVM
         @fun = fun
       end
 
+      # Returns the number of BasicBlocks in the collection.
       def size
         C.LLVMCountBasicBlocks(@fun)
       end
 
+      # Iterates through each BasicBlock in the collection.
       def each
         return to_enum :each unless block_given?
 
@@ -525,44 +624,54 @@ module LLVM
         self
       end
 
+      # Adds a BasicBlock with the given name to the end of the collection.
       def append(name = "")
         BasicBlock.create(@fun, name)
       end
 
+      # Returns the entry BasicBlock in the collection. This is the block the
+      # function starts on.
       def entry
         BasicBlock.from_ptr(C.LLVMGetEntryBasicBlock(@fun))
       end
 
+      # Returns the first BasicBlock in the collection.
       def first
         ptr = C.LLVMGetFirstBasicBlock(@fun)
         BasicBlock.from_ptr(ptr) unless ptr.null?
       end
 
+      # Returns the last BasicBlock in the collection.
       def last
         ptr = C.LLVMGetLastBasicBlock(@fun)
         BasicBlock.from_ptr(ptr) unless ptr.null?
       end
     end
 
+    # Returns an Enumerable of the parameters in the function.
     def params
       @parameter_collection ||= ParameterCollection.new(self)
     end
 
+    # @private
     class ParameterCollection
       def initialize(fun)
         @fun = fun
       end
 
+      # Returns a Value representation of the parameter at the given index.
       def [](i)
         Value.from_ptr(C.LLVMGetParam(@fun, i))
       end
 
+      # Returns the number of paramters in the collection.
       def size
         C.LLVMCountParams(@fun)
       end
 
       include Enumerable
 
+      # Iteraters through each parameter in the collection.
       def each
         return to_enum :each unless block_given?
         0.upto(size-1) { |i| yield self[i] }
@@ -596,16 +705,19 @@ module LLVM
   end
 
   class Instruction < User
+    # Returns the parent of the instruction (a BasicBlock).
     def parent
       ptr = C.LLVMGetInstructionParent(self)
       LLVM::BasicBlock.from_ptr(ptr) unless ptr.null?
     end
 
+    # Returns the next instruction after this one.
     def next
       ptr = C.LLVMGetNextInstruction(self)
       LLVM::Instruction.from_ptr(ptr) unless ptr.null?
     end
 
+    # Returns the previous instruction before this one.
     def previous
       ptr = C.LLVMGetPreviousInstruction(self)
       LLVM::Instruction.from_ptr(ptr) unless ptr.null?
@@ -613,19 +725,21 @@ module LLVM
   end
 
   class CallInst < Instruction
+    # Sets the call convention to conv.
     def call_conv=(conv)
       C.LLVMSetInstructionCallConv(self, conv)
       conv
     end
 
+    # Returns the call insatnce's call convention.
     def call_conv
       C.LLVMGetInstructionCallConv(self)
     end
   end
 
   class Phi < Instruction
-    # Add incoming branches to a phi node by passing an alternating list
-    # of resulting values and basic blocks. e.g.
+    # Add incoming branches to a phi node by passing an alternating list of
+    # resulting values and BasicBlocks. e.g.
     #   phi.add_incoming(val1, block1, val2, block2, ...)
     def add_incoming(*incoming)
       vals, blocks = [], []
@@ -651,8 +765,8 @@ module LLVM
   end
 
   class SwitchInst < Instruction
-    # Adds a case to a switch instruction. First the value to match on,
-    # then the basic block.
+    # Adds a case to a switch instruction. First the value to match on, then
+    # the basic block.
     def add_case(val, block)
       C.LLVMAddCase(self, val, block)
     end