ruby-llvm 3.0.0.beta → 3.0.0

data/lib/llvm/core/context.rb

@@ -1,7 +1,7 @@
 module LLVM  
   class Context
     def initialize(ptr = nil)
-      @ptr = ptr || C.LLVMContextCreate()
+      @ptr = ptr || C.context_create()
     end
 
     # @private
@@ -11,12 +11,14 @@ module LLVM
 
     # Obtains a reference to the global Context.
     def self.global
-      new(C.LLVMGetGlobalContext())
+      new(C.get_global_context())
     end
 
     # Diposes the Context.
     def dispose
-      C.LLVMContextDispose(@ptr)
+      return if @ptr.nil?
+      C.context_dispose(@ptr)
+      @ptr = nil
     end
   end
 end

data/lib/llvm/core/module.rb

@@ -8,8 +8,15 @@ module LLVM
       mod
     end
     
+    # Important: Call #dispose to free backend memory after use, but not when using JITCompiler with this module.
     def initialize(name)
-      @ptr = C.LLVMModuleCreateWithName(name)
+      @ptr = C.module_create_with_name(name)
+    end
+    
+    def dispose
+      return if @ptr.nil?
+      C.dispose_module(@ptr)
+      @ptr = nil
     end
     
     # @private
@@ -44,7 +51,7 @@ module LLVM
       
       # Returns the Type with the given name (symbol or string).
       def named(name)
-        Type.from_ptr(C.LLVMGetTypeByName(@module, name.to_s))
+        Type.from_ptr(C.get_type_by_name(@module, name.to_s), nil)
       end
       
       # Returns the Type with the a name equal to key (symbol or string).
@@ -72,37 +79,37 @@ module LLVM
       
       # 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.to_s))
+        GlobalVariable.from_ptr(C.add_global(@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.to_s))
+        GlobalValue.from_ptr(C.get_named_global(@module, name.to_s))
       end
       
       # Returns the first GlobalVariable in the collection.
       def first
-        GlobalValue.from_ptr(C.LLVMGetFirstGlobal(@module))
+        GlobalValue.from_ptr(C.get_first_global(@module))
       end
       
       # Returns the last GlobalVariable in the collection.
       def last
-        GlobalValue.from_ptr(C.LLVMGetLastGlobal(@module))
+        GlobalValue.from_ptr(C.get_last_global(@module))
       end
       
       # Returns the next GlobalVariable in the collection after global.
       def next(global)
-        GlobalValue.from_ptr(C.LLVMGetNextGlobal(global))
+        GlobalValue.from_ptr(C.get_next_global(global))
       end
       
       # Returns the previous GlobalVariable in the collection before global.
       def previous(global)
-        GlobalValue.from_ptr(C.LLVMGetPreviousGlobal(global))
+        GlobalValue.from_ptr(C.get_previous_global(global))
       end
       
       # Deletes the GlobalVariable from the collection.
       def delete(global)
-        C.LLVMDeleteGlobal(global)
+        C.delete_global(global)
       end
       
       # Returns the GlobalVariable with a name equal to key (symbol or string) or at key (integer).
@@ -149,7 +156,7 @@ module LLVM
         else
           type = Type.function(*args)
         end
-        function = Function.from_ptr(C.LLVMAddFunction(@module, name.to_s, type))
+        function = Function.from_ptr(C.add_function(@module, name.to_s, type))
         
         if block_given?
           params = (0...function.params.size).map { |i| function.params[i] }
@@ -161,32 +168,32 @@ module LLVM
       
       # Returns the Function with the given name (symbol or string).
       def named(name)
-        Function.from_ptr(C.LLVMGetNamedFunction(@module, name.to_s))
+        Function.from_ptr(C.get_named_function(@module, name.to_s))
       end
       
       # Returns the first Function in the collection.
       def first
-        Function.from_ptr(C.LLVMGetFirstFunction(@module))
+        Function.from_ptr(C.get_first_function(@module))
       end
       
       # Returns the last Function in the collection.
       def last
-        Function.from_ptr(C.LLVMGetLastFunction(@module))
+        Function.from_ptr(C.get_last_function(@module))
       end
       
       # Returns the next Function in the collection after function.
       def next(function)
-        Function.from_ptr(C.LLVMGetNextFunction(function))
+        Function.from_ptr(C.get_next_function(function))
       end
       
       # Returns the previous Function in the collection before function.
       def previous(function)
-        Function.from_ptr(C.LLVMGetPreviousFunction(function))
+        Function.from_ptr(C.get_previous_function(function))
       end
       
       # Deletes the Function from the collection.
       def delete(function)
-        C.LLVMDeleteFunction(function)
+        C.delete_function(function)
       end
       
       # Returns the Function with a name equal to key (symbol or string) or at key (integer).
@@ -216,12 +223,7 @@ module LLVM
     
     # Print the module's IR to stdout.
     def dump
-      C.LLVMDumpModule(self)
-    end
-    
-    # Dispose the module.
-    def dispose
-      C.LLVMDisposeModule(@ptr)
+      C.dump_module(self)
     end
   end
 end

data/lib/llvm/core/pass_manager.rb

@@ -4,9 +4,9 @@ module LLVM
   class PassManager
     # Creates a new pass manager on the given ExecutionEngine.
     def initialize(execution_engine)
-      ptr = C.LLVMCreatePassManager()
-      C.LLVMAddTargetData(
-        C.LLVMGetExecutionEngineTargetData(execution_engine), ptr)
+      ptr = C.create_pass_manager()
+      C.add_target_data(
+        C.get_execution_engine_target_data(execution_engine), ptr)
       @ptr = ptr
 
       do_initialization
@@ -29,13 +29,15 @@ module LLVM
     # @param [LLVM::Module]
     # @return [true, false] Indicates whether the module was modified.
     def run(mod)
-      C.LLVMRunPassManager(self, mod) != 0
+      C.run_pass_manager(self, mod) != 0
     end
     
     # Disposes the pass manager.
     def dispose
+      return if @ptr.nil?
       do_finalization
-      C.LLVMDisposePassManager(self)
+      C.dispose_pass_manager(@ptr)
+      @ptr = nil
     end
 
     protected
@@ -50,9 +52,9 @@ module LLVM
   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(
-        C.LLVMGetExecutionEngineTargetData(execution_engine), ptr)
+      ptr = C.create_function_pass_manager_for_module(mod)
+      C.add_target_data(
+        C.get_execution_engine_target_data(execution_engine), ptr)
       @ptr = ptr
     end
 
@@ -60,17 +62,17 @@ module LLVM
     # @param [LLVM::Function]
     # @return [true, false] indicates whether the function was modified.
     def run(fn)
-      C.LLVMRunFunctionPassManager(self, fn) != 0
+      C.run_function_pass_manager(self, fn) != 0
     end
 
     protected
 
     def do_initialization
-      C.LLVMInitializeFunctionPassManager(self) != 0
+      C.initialize_function_pass_manager(self) != 0
     end
 
     def do_finalization
-      C.LLVMFinalizeFunctionPassManager(self) != 0
+      C.finalize_function_pass_manager(self) != 0
     end
   end
 end

data/lib/llvm/core/type.rb

@@ -14,7 +14,11 @@ module LLVM
         false
       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
@@ -22,34 +26,34 @@ module LLVM
 
     # Returns a symbol representation of the types kind (ex. :pointer, :vector, :array.)
     def kind
-      C.LLVMGetTypeKind(self)
+      @kind
     end
 
     # Returns the size of the type.
     def size
-      LLVM::Int64.from_ptr(C.LLVMSizeOf(self))
+      LLVM::Int64.from_ptr(C.size_of(self))
     end
     
     def align
-      LLVM::Int64.from_ptr(C.LLVMAlignOf(self))
+      LLVM::Int64.from_ptr(C.align_of(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
-        Type.from_ptr(C.LLVMGetElementType(self))
+        Type.from_ptr(C.get_element_type(self), nil)
       end
     end
 
     # Returns a null pointer ConstantExpr of this type.
     def null_pointer
-      ConstantExpr.from_ptr(C.LLVMConstPointerNull(self))
+      ConstantExpr.from_ptr(C.const_pointer_null(self))
     end
 
     # Returns a null ConstantExpr of this type.
     def null
-      ConstantExpr.from_ptr(C.LLVMConstNull(self))
+      ConstantExpr.from_ptr(C.const_null(self))
     end
 
     # Creates a pointer type with this type and the given address space.
@@ -57,32 +61,34 @@ module LLVM
       Type.pointer(self, address_space)
     end
     
-    # Returns the name of the struct type.
-    def name
-      C.LLVMGetStructName(self)
-    end
-    
     # @private
-    def self.from_ptr(ptr)
+    def self.from_ptr(ptr, kind)
       return if ptr.null?
-      ty = allocate
+      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
     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))
+      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.LLVMPointerType(LLVM::Type(ty), address_space))
+      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.LLVMVectorType(LLVM::Type(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>, 
@@ -91,7 +97,7 @@ module LLVM
       arg_types.map! { |ty| LLVM::Type(ty) }
       arg_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * arg_types.size)
       arg_types_ptr.write_array_of_pointer(arg_types)
-      FunctionType.from_ptr(C.LLVMFunctionType(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0))
+      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.
@@ -100,17 +106,17 @@ module LLVM
       elt_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * elt_types.size)
       elt_types_ptr.write_array_of_pointer(elt_types)
       if name
-        struct = from_ptr(C.LLVMStructCreateNamed(Context.global, name))
-        C.LLVMStructSetBody(struct, elt_types_ptr, elt_types.size, is_packed ? 1 : 0)
+        struct = from_ptr(C.struct_create_named(Context.global, name), :struct)
+        C.struct_set_body(struct, elt_types_ptr, elt_types.size, is_packed ? 1 : 0) unless elt_types.empty?
         struct
       else
-        from_ptr(C.LLVMStructType(elt_types_ptr, elt_types.size, is_packed ? 1 : 0))
+        from_ptr(C.struct_type(elt_types_ptr, elt_types.size, is_packed ? 1 : 0), :struct)
       end
     end
 
     # Creates a void type.
     def self.void
-      from_ptr(C.LLVMVoidType)
+      from_ptr(C.void_type, :void)
     end
     
     def self.rec
@@ -123,13 +129,39 @@ module LLVM
 
   class IntType < Type
     def width
-      C.LLVMGetIntTypeWidth(self)
+      C.get_int_type_width(self)
     end
   end
 
   class FunctionType < Type
     def return_type
-      LLVM::Type.from_ptr(C.LLVMGetReturnType(self))
+      Type.from_ptr(C.get_return_type(self), nil)
+    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)
+      elt_types = nil
+      FFI::MemoryPointer.new(FFI.type_size(:pointer) * count) do |types_ptr|
+        C.get_struct_element_types(self, types_ptr)
+        elt_types = types_ptr.read_array_of_pointer(count).map { |type_ptr| Type.from_ptr(type_ptr, nil) }
+      end
+      elt_types
+    end
+    
+    # Sets the struct body.
+    def element_types=(elt_types)
+      elt_types.map! { |ty| LLVM::Type(ty) }
+      elt_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * elt_types.size)
+      elt_types_ptr.write_array_of_pointer(elt_types)
+      C.struct_set_body(self, elt_types_ptr, elt_types.size, 0)
     end
   end
 

data/lib/llvm/core/value.rb

@@ -43,28 +43,28 @@ module LLVM
 
     # Returns the value's type.
     def type
-      Type.from_ptr(C.LLVMTypeOf(self))
+      Type.from_ptr(C.type_of(self), nil)
     end
 
     # Returns the value's name.
     def name
-      C.LLVMGetValueName(self)
+      C.get_value_name(self)
     end
 
     # Sets the value's name to str.
     def name=(str)
-      C.LLVMSetValueName(self, str)
+      C.set_value_name(self, str)
       str
     end
 
     # Print the value's IR to stdout.
     def dump
-      C.LLVMDumpValue(self)
+      C.dump_value(self)
     end
 
     # Returns whether the value is constant.
     def constant?
-      case C.LLVMIsConstant(self)
+      case C.is_constant(self)
       when 0 then false
       when 1 then true
       end
@@ -72,7 +72,7 @@ module LLVM
 
     # Returns whether the value is null.
     def null?
-      case C.LLVMIsNull(self)
+      case C.is_null(self)
       when 0 then false
       when 1 then true
       end
@@ -80,7 +80,7 @@ module LLVM
 
     # Returns whether the value is undefined.
     def undefined?
-      case C.LLVMIsUndef(self)
+      case C.is_undef(self)
       when 0 then false
       when 1 then true
       end
@@ -88,7 +88,7 @@ module LLVM
 
     # Adds attr to this value's attributes.
     def add_attribute(attr)
-      C.LLVMAddAttribute(self, attr)
+      C.add_attribute(self, attr)
     end
   end
 
@@ -98,38 +98,37 @@ 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.LLVMAppendBasicBlock(fun, name))
+      self.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.
     def build(builder = nil)
       if builder.nil?
         builder = Builder.new
-        islocal = true
+        builder.position_at_end(self)
+        yield builder
+        builder.dispose
       else
-        islocal = false
+        builder.position_at_end(self)
+        yield builder
       end
-      builder.position_at_end(self)
-      yield builder
-    ensure
-      builder.dispose if islocal
     end
 
     # Returns the parent of this basic block (a Function).
     def parent
-      fp = C.LLVMGetBasicBlockParent(self)
+      fp = C.get_basic_block_parent(self)
       LLVM::Function.from_ptr(fp) unless fp.null?
     end
 
     # Returns the next basic block in the sequence.
     def next
-      ptr = C.LLVMGetNextBasicBlock(self)
+      ptr = C.get_next_basic_block(self)
       BasicBlock.from_ptr(ptr) unless ptr.null?
     end
 
     # Returns the previous basic block in the sequence.
     def previous
-      ptr = C.LLVMGetPreviousBasicBlock(self)
+      ptr = C.get_previous_basic_block(self)
       BasicBlock.from_ptr(ptr) unless ptr.null?
     end
 
@@ -170,13 +169,13 @@ module LLVM
 
       # Returns the first Instruction in the collection.
       def first
-        ptr = C.LLVMGetFirstInstruction(@block)
+        ptr = C.get_first_instruction(@block)
         LLVM::Instruction.from_ptr(ptr) unless ptr.null?
       end
 
       # Returns the last Instruction in the collection.
       def last
-        ptr = C.LLVMGetLastInstruction(@block)
+        ptr = C.get_last_instruction(@block)
         LLVM::Instruction.from_ptr(ptr) unless ptr.null?
       end
     end
@@ -198,18 +197,18 @@ module LLVM
 
       # Get a reference to an operand by index.
       def [](i)
-        ptr = C.LLVMGetOperand(@user, i)
+        ptr = C.get_operand(@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)
+        C.set_operand(@user, i, v)
       end
 
       # Returns the number of operands in the collection.
       def size
-        C.LLVMGetNumOperands(@user)
+        C.get_num_operands(@user)
       end
 
       # Iterates through each operand in the collection.
@@ -224,22 +223,22 @@ module LLVM
   class Constant < User
     # Creates a null constant of Type.
     def self.null(type)
-      from_ptr(C.LLVMConstNull(type))
+      from_ptr(C.const_null(type))
     end
 
     # Creates a undefined constant of Type.
     def self.undef(type)
-      from_ptr(C.LLVMGetUndef(type))
+      from_ptr(C.get_undef(type))
     end
 
     # Creates a null pointer constant of Type.
     def self.null_ptr(type)
-      from_ptr(C.LLVMConstPointerNull(type))
+      from_ptr(C.const_pointer_null(type))
     end
 
     # Bitcast this constant to Type.
     def bitcast_to(type)
-      ConstantExpr.from_ptr(C.LLVMConstBitCast(self, type))
+      ConstantExpr.from_ptr(C.const_bit_cast(self, type))
     end
 
     # Returns the element pointer at the given indices of the constant.
@@ -249,7 +248,7 @@ module LLVM
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
         indices_ptr.write_array_of_pointer(indices)
         return ConstantExpr.from_ptr(
-          C.LLVMConstGEP(self, indices_ptr, indices.size))
+          C.const_gep(self, indices_ptr, indices.size))
       end
     end
   end
@@ -272,14 +271,14 @@ module LLVM
 
   class ConstantArray < Constant
     def self.string(str, null_terminate = true)
-      from_ptr(C.LLVMConstString(str, str.length, null_terminate ? 0 : 1))
+      from_ptr(C.const_string(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)
       vals = LLVM::Support.allocate_pointers(size_or_values, &block)
-      from_ptr C.LLVMConstArray(type, vals, vals.size / vals.type_size)
+      from_ptr C.const_array(type, vals, vals.size / vals.type_size)
     end
   end
 
@@ -288,77 +287,77 @@ module LLVM
 
   class ConstantInt < Constant
     def self.all_ones
-      from_ptr(C.LLVMConstAllOnes(type))
+      from_ptr(C.const_all_ones(type))
     end
 
     # Creates a ConstantInt from an integer.
     def self.from_i(n, signed = true)
-      from_ptr(C.LLVMConstInt(type, n, signed ? 1 : 0))
+      from_ptr(C.const_int(type, n, signed ? 1 : 0))
     end
 
     def self.parse(str, radix = 10)
-      from_ptr(C.LLVMConstIntOfString(type, str, radix))
+      from_ptr(C.const_int_of_string(type, str, radix))
     end
 
     # Negation.
     def -@
-      self.class.from_ptr(C.LLVMConstNeg(self))
+      self.class.from_ptr(C.const_neg(self))
     end
 
     # Boolean negation.
     def not
-      self.class.from_ptr(C.LLVMConstNot(self))
+      self.class.from_ptr(C.const_not(self))
     end
 
     # Addition.
     def +(rhs)
-      self.class.from_ptr(C.LLVMConstAdd(self, 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.
     def nsw_add(rhs)
-      self.class.from_ptr(C.LLVMConstNSWAdd(self, rhs))
+      self.class.from_ptr(C.const_nsw_add(self, rhs))
     end
 
     # Multiplication.
     def *(rhs)
-      self.class.from_ptr(C.LLVMConstMul(self, rhs))
+      self.class.from_ptr(C.const_mul(self, rhs))
     end
 
     # Unsigned division.
     def udiv(rhs)
-      self.class.from_ptr(C.LLVMConstUDiv(self, rhs))
+      self.class.from_ptr(C.const_u_div(self, rhs))
     end
 
     # Signed division.
     def /(rhs)
-      self.class.from_ptr(C.LLVMConstSDiv(self, rhs))
+      self.class.from_ptr(C.const_s_div(self, rhs))
     end
 
     # Unsigned remainder.
     def urem(rhs)
-      self.class.from_ptr(C.LLVMConstURem(self, rhs))
+      self.class.from_ptr(C.const_u_rem(self, rhs))
     end
 
     # Signed remainder.
     def rem(rhs)
-      self.class.from_ptr(C.LLVMConstSRem(self, rhs))
+      self.class.from_ptr(C.const_s_rem(self, rhs))
     end
 
     # Integer AND.
     def and(rhs)
-      self.class.from_ptr(C.LLVMConstAnd(self, rhs))
+      self.class.from_ptr(C.const_and(self, rhs))
     end
 
     # Integer OR.
     def or(rhs)
-      self.class.from_ptr(C.LLVMConstOr(self, rhs))
+      self.class.from_ptr(C.const_or(self, rhs))
     end
 
     # Integer XOR.
     def xor(rhs)
-      self.class.from_ptr(C.LLVMConstXor(self, rhs))
+      self.class.from_ptr(C.const_xor(self, rhs))
     end
 
     # Integer comparison using the predicate specified via the first parameter.
@@ -374,22 +373,22 @@ module LLVM
     #   :slt - signed less than
     #   :sle - signed less than or equal to
     def icmp(pred, rhs)
-      self.class.from_ptr(C.LLVMConstICmp(pred, self, rhs))
+      self.class.from_ptr(C.const_i_cmp(pred, self, rhs))
     end
 
     # Shift left.
     def <<(bits)
-      self.class.from_ptr(C.LLVMConstShl(self, bits))
+      self.class.from_ptr(C.const_shl(self, bits))
     end
 
     # Shift right.
     def >>(bits)
-      self.class.from_ptr(C.LLVMConstLShr(self, bits))
+      self.class.from_ptr(C.const_l_shr(self, bits))
     end
 
     # Arithmatic shift right.
     def ashr(bits)
-      self.class.from_ptr(C.LLVMConstAShr(self, bits))
+      self.class.from_ptr(C.const_a_shr(self, bits))
     end
   end
 
@@ -401,7 +400,7 @@ module LLVM
       eval <<-KLASS
         class #{name} < ConstantInt
           def self.type
-            IntType.from_ptr(C.LLVMIntType(#{width}))
+            Type.from_ptr(C.int_type(#{width}), :integer)
           end
         end
       KLASS
@@ -430,36 +429,36 @@ module LLVM
   class ConstantReal < Constant
     # Creates a ConstantReal from a float of Type.
     def self.from_f(n)
-      from_ptr(C.LLVMConstReal(type, n))
+      from_ptr(C.const_real(type, n))
     end
 
     def self.parse(type, str)
-      from_ptr(C.LLVMConstRealOfString(type, str))
+      from_ptr(C.const_real_of_string(type, str))
     end
 
     # Negation.
     def -@
-      self.class.from_ptr(C.LLVMConstFNeg(self))
+      self.class.from_ptr(C.const_f_neg(self))
     end
 
     # Returns the result of adding this ConstantReal to rhs.
     def +(rhs)
-      self.class.from_ptr(C.LLVMConstFAdd(self, rhs))
+      self.class.from_ptr(C.const_f_add(self, rhs))
     end
 
     # Returns the result of multiplying this ConstantReal by rhs.
     def *(rhs)
-      self.class.from_ptr(C.LLVMConstFMul(self, rhs))
+      self.class.from_ptr(C.const_f_mul(self, rhs))
     end
 
     # Returns the result of dividing this ConstantReal by rhs.
     def /(rhs)
-      self.class.from_ptr(C.LLVMConstFDiv(self, rhs))
+      self.class.from_ptr(C.const_f_div(self, rhs))
     end
 
     # Remainder.
     def rem(rhs)
-      self.class.from_ptr(C.LLVMConstFRem(self, rhs))
+      self.class.from_ptr(C.const_f_rem(self, rhs))
     end
 
     # Floating point comparison using the predicate specified via the first
@@ -481,14 +480,14 @@ module LLVM
     #   :true - always true
     #   :false- always false
     def fcmp(pred, rhs)
-      self.class.from_ptr(C.LLMVConstFCmp(pred, self, rhs))
+      self.class.from_ptr(C.llmv_const_f_cmp(pred, self, rhs))
     end
   end
 
   class Float < ConstantReal
     # Return a Type representation of the float.
     def self.type
-      Type.from_ptr(C.LLVMFloatType)
+      Type.from_ptr(C.float_type, :float)
     end
   end
 
@@ -499,7 +498,7 @@ module LLVM
 
   class Double < ConstantReal
     def self.type
-      Type.from_ptr(C.LLVMDoubleType)
+      Type.from_ptr(C.double_type, :double)
     end
   end
 
@@ -512,90 +511,90 @@ module LLVM
     # ConstantStruct.const([...])
     def self.const(size_or_values, packed = false, &block)
       vals = LLVM::Support.allocate_pointers(size_or_values, &block)
-      from_ptr C.LLVMConstStruct(vals, vals.size / vals.type_size, packed ? 1 : 0)
+      from_ptr C.const_struct(vals, vals.size / vals.type_size, packed ? 1 : 0)
     end
   end
 
   class ConstantVector < Constant
     def self.all_ones
-      from_ptr(C.LLVMConstAllOnes(type))
+      from_ptr(C.const_all_ones(type))
     end
 
     def self.const(size_or_values, &block)
       vals = LLVM::Support.allocate_pointers(size_or_values, &block)
-      from_ptr(C.LLVMConstVector(vals, vals.size / vals.type_size))
+      from_ptr(C.const_vector(vals, vals.size / vals.type_size))
     end
   end
 
   class GlobalValue < Constant
     def declaration?
-      C.LLVMIsDeclaration(self)
+      C.is_declaration(self)
     end
 
     def linkage
-      C.LLVMGetLinkage(self)
+      C.get_linkage(self)
     end
 
     def linkage=(linkage)
-      C.LLVMSetLinkage(self, linkage)
+      C.set_linkage(self, linkage)
     end
 
     def section
-      C.LLVMGetSection(self)
+      C.get_section(self)
     end
 
     def section=(section)
-      C.LLVMSetSection(self, section)
+      C.set_section(self, section)
     end
 
     def visibility
-      C.LLVMGetVisibility(self)
+      C.get_visibility(self)
     end
 
     def visibility=(viz)
-      C.LLVMSetVisibility(self, viz)
+      C.set_visibility(self, viz)
     end
 
     def alignment
-      C.LLVMGetAlignment(self)
+      C.get_alignment(self)
     end
 
     def alignment=(bytes)
-      C.LLVMSetAlignment(self, bytes)
+      C.set_alignment(self, bytes)
     end
 
     def initializer
-      Value.from_ptr(C.LLVMGetInitializer(self))
+      Value.from_ptr(C.get_initializer(self))
     end
 
     def initializer=(val)
-      C.LLVMSetInitializer(self, val)
+      C.set_initializer(self, val)
     end
 
     def global_constant?
-      C.LLVMIsGlobalConstant(self)
+      C.is_global_constant(self)
     end
 
     def global_constant=(flag)
-      C.LLVMSetGlobalConstant(self, flag)
+      C.set_global_constant(self, flag)
     end
   end
 
   class Function < GlobalValue
     # Sets the function's calling convention and returns it.
     def call_conv=(conv)
-      C.LLVMSetFunctionCallConv(self, conv)
+      C.set_function_call_conv(self, conv)
       conv
     end
 
     # Adds the given attribute to the function.
     def add_attribute(attr)
-      C.LLVMAddFunctionAttr(self, attr)
+      C.add_function_attr(self, attr)
     end
 
     # Removes the given attribute from the function.
     def remove_attribute(attr)
-      C.LLVMRemoveFunctionAttr(self, attr)
+      C.remove_function_attr(self, attr)
     end
 
     # Returns an Enumerable of the BasicBlocks in this function.
@@ -604,7 +603,7 @@ module LLVM
     end
 
     def type
-      FunctionType.from_ptr(C.LLVMTypeOf(self))
+      Type.from_ptr(C.type_of(self), :function)
     end
 
     # @private
@@ -617,17 +616,17 @@ module LLVM
 
       # Returns the number of BasicBlocks in the collection.
       def size
-        C.LLVMCountBasicBlocks(@fun)
+        C.count_basic_blocks(@fun)
       end
 
       # Iterates through each BasicBlock in the collection.
       def each
         return to_enum :each unless block_given?
 
-        ptr = C.LLVMGetFirstBasicBlock(@fun)
+        ptr = C.get_first_basic_block(@fun)
         0.upto(size-1) do |i|
           yield BasicBlock.from_ptr(ptr)
-          ptr = C.LLVMGetNextBasicBlock(ptr)
+          ptr = C.get_next_basic_block(ptr)
         end
 
         self
@@ -641,18 +640,18 @@ module LLVM
       # Returns the entry BasicBlock in the collection. This is the block the
       # function starts on.
       def entry
-        BasicBlock.from_ptr(C.LLVMGetEntryBasicBlock(@fun))
+        BasicBlock.from_ptr(C.get_entry_basic_block(@fun))
       end
 
       # Returns the first BasicBlock in the collection.
       def first
-        ptr = C.LLVMGetFirstBasicBlock(@fun)
+        ptr = C.get_first_basic_block(@fun)
         BasicBlock.from_ptr(ptr) unless ptr.null?
       end
 
       # Returns the last BasicBlock in the collection.
       def last
-        ptr = C.LLVMGetLastBasicBlock(@fun)
+        ptr = C.get_last_basic_block(@fun)
         BasicBlock.from_ptr(ptr) unless ptr.null?
       end
     end
@@ -673,12 +672,12 @@ module LLVM
         sz = self.size
         i = sz + i if i < 0
         return unless 0 <= i && i < sz
-        Value.from_ptr(C.LLVMGetParam(@fun, i))
+        Value.from_ptr(C.get_param(@fun, i))
       end
 
       # Returns the number of paramters in the collection.
       def size
-        C.LLVMCountParams(@fun)
+        C.count_params(@fun)
       end
 
       include Enumerable
@@ -697,41 +696,41 @@ module LLVM
 
   class GlobalVariable < GlobalValue
     def initializer
-      Value.from_ptr(C.LLVMGetInitializer(self))
+      Value.from_ptr(C.get_initializer(self))
     end
 
     def initializer=(val)
-      C.LLVMSetInitializer(self, val)
+      C.set_initializer(self, val)
     end
 
     def thread_local?
-      case C.LLVMIsThreadLocal(self)
+      case C.is_thread_local(self)
       when 0 then false
       else true
       end
     end
 
     def thread_local=(local)
-      C.LLVMSetThreadLocal(self, local ? 1 : 0)
+      C.set_thread_local(self, local ? 1 : 0)
     end
   end
 
   class Instruction < User
     # Returns the parent of the instruction (a BasicBlock).
     def parent
-      ptr = C.LLVMGetInstructionParent(self)
+      ptr = C.get_instruction_parent(self)
       LLVM::BasicBlock.from_ptr(ptr) unless ptr.null?
     end
 
     # Returns the next instruction after this one.
     def next
-      ptr = C.LLVMGetNextInstruction(self)
+      ptr = C.get_next_instruction(self)
       LLVM::Instruction.from_ptr(ptr) unless ptr.null?
     end
 
     # Returns the previous instruction before this one.
     def previous
-      ptr = C.LLVMGetPreviousInstruction(self)
+      ptr = C.get_previous_instruction(self)
       LLVM::Instruction.from_ptr(ptr) unless ptr.null?
     end
   end
@@ -739,13 +738,13 @@ module LLVM
   class CallInst < Instruction
     # Sets the call convention to conv.
     def call_conv=(conv)
-      C.LLVMSetInstructionCallConv(self, conv)
+      C.set_instruction_call_conv(self, conv)
       conv
     end
 
     # Returns the call insatnce's call convention.
     def call_conv
-      C.LLVMGetInstructionCallConv(self)
+      C.get_instruction_call_conv(self)
     end
   end
 
@@ -763,7 +762,7 @@ module LLVM
         vals_ptr.write_array_of_pointer(vals)
         FFI::MemoryPointer.new(FFI.type_size(:pointer) * size) do |blks_ptr|
           blks_ptr.write_array_of_pointer(blks)
-          C.LLVMAddIncoming(self, vals_ptr, blks_ptr, vals.size)
+          C.add_incoming(self, vals_ptr, blks_ptr, vals.size)
         end
       end
 
@@ -776,7 +775,7 @@ module LLVM
     # 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)
+      C.add_case(self, val, block)
     end
   end
 end