rltk 2.2.1 → 3.0.0

data/lib/rltk/cg/generated_bindings.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module RLTK::CG::Bindings
   extend FFI::Library
-  ffi_lib 'LLVM-3.0'
+  ffi_lib 'LLVM-3.4'
   
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -30,62 +30,94 @@ module RLTK::CG::Bindings
   
   DISASSEMBLER_REFERENCE_TYPE_OUT_LIT_POOL_CSTR_ADDR = 3
   
-  # The top-level container for all LLVM global data.  See the LLVMContext class.
+  DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_CF_STRING_REF = 4
+  
+  DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_MESSAGE = 5
+  
+  DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_MESSAGE_REF = 6
+  
+  DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_SELECTOR_REF = 7
+  
+  DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_CLASS_REF = 8
+  
+  DISASSEMBLER_OPTION_USE_MARKUP = 1
+  
+  DISASSEMBLER_OPTION_PRINT_IMM_HEX = 2
+  
+  DISASSEMBLER_OPTION_ASM_PRINTER_VARIANT = 4
+  
+  DISASSEMBLER_OPTION_SET_INSTR_COMMENTS = 8
+  
+  DISASSEMBLER_OPTION_PRINT_LATENCY = 16
+  
+  # The top-level container for all LLVM global data. See the LLVMContext class.
   class OpaqueContext < FFI::Struct
     layout :dummy, :char
   end
   
   # The top-level container for all other LLVM Intermediate Representation (IR)
-  # objects. See the llvm::Module class.
+  # objects.
+  # 
+  # @see llvm::Module
   class OpaqueModule < FFI::Struct
     layout :dummy, :char
   end
   
-  # Each value in the LLVM IR has a type, an LLVMTypeRef. See the llvm::Type
-  # class.
+  # Each value in the LLVM IR has a type, an LLVMTypeRef.
+  # 
+  # @see llvm::Type
   class OpaqueType < FFI::Struct
     layout :dummy, :char
   end
   
-  # (Not documented)
+  # Represents an individual value in LLVM IR.
+  # 
+  # This models llvm::Value.
   class OpaqueValue < FFI::Struct
     layout :dummy, :char
   end
   
-  # (Not documented)
+  # Represents a basic block of instructions in LLVM IR.
+  # 
+  # This models llvm::BasicBlock.
   class OpaqueBasicBlock < FFI::Struct
     layout :dummy, :char
   end
   
-  # (Not documented)
+  # Represents an LLVM basic block builder.
+  # 
+  # This models llvm::IRBuilder.
   class OpaqueBuilder < FFI::Struct
     layout :dummy, :char
   end
   
-  # Interface used to provide a module to JIT or interpreter.  This is now just a
-  # synonym for llvm::Module, but we have to keep using the different type to
-  # keep binary compatibility.
+  # Interface used to provide a module to JIT or interpreter.
+  # This is now just a synonym for llvm::Module, but we have to keep using the
+  # different type to keep binary compatibility.
   class OpaqueModuleProvider < FFI::Struct
     layout :dummy, :char
   end
   
   # Used to provide a module to JIT or interpreter.
-  # See the llvm::MemoryBuffer class.
+  # 
+  # @see llvm::MemoryBuffer
   class OpaqueMemoryBuffer < FFI::Struct
     layout :dummy, :char
   end
   
-  # See the llvm::PassManagerBase class.
+  # @see llvm::PassManagerBase
   class OpaquePassManager < FFI::Struct
     layout :dummy, :char
   end
   
-  # See the llvm::PassRegistry class.
+  # @see llvm::PassRegistry
   class OpaquePassRegistry < FFI::Struct
     layout :dummy, :char
   end
   
-  # Used to get the users and usees of a Value. See the llvm::Use class.
+  # Used to get the users and usees of a Value.
+  # 
+  # @see llvm::Use
   class OpaqueUse < FFI::Struct
     layout :dummy, :char
   end
@@ -145,8 +177,6 @@ module RLTK::CG::Bindings
   #   
   # :uw_table ::
   #   
-  # :non_lazy_bind ::
-  #   
   # 
   # @method _enum_attribute_
   # @return [Symbol]
@@ -176,8 +206,7 @@ module RLTK::CG::Bindings
     :inline_hint_attribute, 33554432,
     :stack_alignment, 469762048,
     :returns_twice, 536870912,
-    :uw_table, 1073741824,
-    :non_lazy_bind, 2147483648
+    :uw_table, 1073741824
   ]
   
   # (Not documented)
@@ -265,6 +294,8 @@ module RLTK::CG::Bindings
   #   
   # :bit_cast ::
   #   
+  # :addr_space_cast ::
+  #   
   # :i_cmp ::
   #   Other Operators
   # :f_cmp ::
@@ -301,8 +332,6 @@ module RLTK::CG::Bindings
   #   Exception Handling Operators
   # :landing_pad ::
   #   
-  # :unwind ::
-  #   
   # 
   # @method _enum_opcode_
   # @return [Symbol]
@@ -348,6 +377,7 @@ module RLTK::CG::Bindings
     :ptr_to_int, 39,
     :int_to_ptr, 40,
     :bit_cast, 41,
+    :addr_space_cast, 60,
     :i_cmp, 42,
     :f_cmp, 43,
     :phi, 44,
@@ -365,8 +395,7 @@ module RLTK::CG::Bindings
     :atomic_cmp_xchg, 56,
     :atomic_rmw, 57,
     :resume, 58,
-    :landing_pad, 59,
-    :unwind, 60
+    :landing_pad, 59
   ]
   
   # (Not documented)
@@ -376,8 +405,10 @@ module RLTK::CG::Bindings
   # === Options:
   # :void ::
   #   
-  # :float ::
+  # :half ::
   #   < type with no size
+  # :float ::
+  #   < 16 bit floating point type
   # :double ::
   #   < 32 bit floating point type
   # :x86_fp80 ::
@@ -410,20 +441,21 @@ module RLTK::CG::Bindings
   # @scope class
   enum :type_kind, [
     :void, 0,
-    :float, 1,
-    :double, 2,
-    :x86_fp80, 3,
-    :fp128, 4,
-    :ppc_fp128, 5,
-    :label, 6,
-    :integer, 7,
-    :function, 8,
-    :struct, 9,
-    :array, 10,
-    :pointer, 11,
-    :vector, 12,
-    :metadata, 13,
-    :x86_mmx, 14
+    :half, 1,
+    :float, 2,
+    :double, 3,
+    :x86_fp80, 4,
+    :fp128, 5,
+    :ppc_fp128, 6,
+    :label, 7,
+    :integer, 8,
+    :function, 9,
+    :struct, 10,
+    :array, 11,
+    :pointer, 12,
+    :vector, 13,
+    :metadata, 14,
+    :x86_mmx, 15
   ]
   
   # (Not documented)
@@ -439,9 +471,11 @@ module RLTK::CG::Bindings
   #   
   # :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 ::
+  #   < Obsolete
   # :weak_odr ::
   #   < Keep one copy of function when linking (weak)
   # :appending ::
@@ -466,8 +500,6 @@ module RLTK::CG::Bindings
   #   < 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]
@@ -477,19 +509,19 @@ module RLTK::CG::Bindings
     :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)
@@ -524,6 +556,10 @@ module RLTK::CG::Bindings
   #   
   # :cold ::
   #   
+  # :web_kit_js ::
+  #   
+  # :any_reg ::
+  #   
   # :x86_stdcall ::
   #   
   # :x86_fastcall ::
@@ -536,6 +572,8 @@ module RLTK::CG::Bindings
     :c, 0,
     :fast, 8,
     :cold, 9,
+    :web_kit_js, 12,
+    :any_reg, 13,
     :x86_stdcall, 64,
     :x86_fastcall, 65
   ]
@@ -662,35 +700,202 @@ module RLTK::CG::Bindings
   
   # (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)
   # @param [OpaquePassRegistry] r 
   # @return [nil] 
   # @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 create_message(message)
+  # @param [String] message 
+  # @return [String] 
+  # @scope class
+  attach_function :create_message, :LLVMCreateMessage, [:string], :string
+  
+  # (Not documented)
+  # 
   # @method dispose_message(message)
   # @param [String] message 
   # @return [nil] 
   # @scope class
   attach_function :dispose_message, :LLVMDisposeMessage, [:string], :void
   
-  # Create and destroy contexts.
+  # Install a fatal error handler. By default, if LLVM detects a fatal error, it
+  # will call exit(1). This may not be appropriate in many contexts. For example,
+  # doing exit(1) will bypass many crash reporting/tracing system tools. This
+  # function allows you to install a callback that will be invoked prior to the
+  # call to exit(1).
+  # 
+  # @method install_fatal_error_handler(handler)
+  # @param [FFI::Pointer(FatalErrorHandler)] handler 
+  # @return [nil] 
+  # @scope class
+  attach_function :install_fatal_error_handler, :LLVMInstallFatalErrorHandler, [:pointer], :void
+  
+  # Reset the fatal error handler. This resets LLVM's fatal error handling
+  # behavior to the default.
+  # 
+  # @method reset_fatal_error_handler()
+  # @return [nil] 
+  # @scope class
+  attach_function :reset_fatal_error_handler, :LLVMResetFatalErrorHandler, [], :void
+  
+  # Enable LLVM's built-in stack trace code. This intercepts the OS's crash
+  # signals and prints which component of LLVM you were in at the time if the
+  # crash.
+  # 
+  # @method enable_pretty_stack_trace()
+  # @return [nil] 
+  # @scope class
+  attach_function :enable_pretty_stack_trace, :LLVMEnablePrettyStackTrace, [], :void
+  
+  # Create a new context.
+  # 
+  # Every call to this function should be paired with a call to
+  # LLVMContextDispose() or the context will leak memory.
   # 
   # @method context_create()
   # @return [OpaqueContext] 
   # @scope class
   attach_function :context_create, :LLVMContextCreate, [], OpaqueContext
   
-  # (Not documented)
+  # Obtain the global context instance.
   # 
   # @method get_global_context()
   # @return [OpaqueContext] 
   # @scope class
   attach_function :get_global_context, :LLVMGetGlobalContext, [], OpaqueContext
   
-  # (Not documented)
+  # Destroy a context instance.
+  # 
+  # This should be called for every call to LLVMContextCreate() or memory
+  # will be leaked.
   # 
   # @method context_dispose(c)
   # @param [OpaqueContext] c 
@@ -717,7 +922,13 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_md_kind_id, :LLVMGetMDKindID, [:string, :uint], :uint
   
-  # See llvm::Module::Module.
+  # Create a new, empty module in the global context.
+  # 
+  # This is equivalent to calling LLVMModuleCreateWithNameInContext with
+  # LLVMGetGlobalContext() as the context parameter.
+  # 
+  # Every invocation should be paired with LLVMDisposeModule() or memory
+  # will be leaked.
   # 
   # @method module_create_with_name(module_id)
   # @param [String] module_id 
@@ -725,7 +936,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :module_create_with_name, :LLVMModuleCreateWithName, [:string], OpaqueModule
   
-  # (Not documented)
+  # Create a new, empty module in a specific context.
+  # 
+  # Every invocation should be paired with LLVMDisposeModule() or memory
+  # will be leaked.
   # 
   # @method module_create_with_name_in_context(module_id, c)
   # @param [String] module_id 
@@ -734,7 +948,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :module_create_with_name_in_context, :LLVMModuleCreateWithNameInContext, [:string, OpaqueContext], OpaqueModule
   
-  # See llvm::Module::~Module.
+  # Destroy a module instance.
+  # 
+  # This must be called for every created module or memory will be
+  # leaked.
   # 
   # @method dispose_module(m)
   # @param [OpaqueModule] m 
@@ -742,7 +959,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :dispose_module, :LLVMDisposeModule, [OpaqueModule], :void
   
-  # Data layout. See Module::getDataLayout.
+  # Obtain the data layout for a module.
+  # 
+  # @see Module::getDataLayout()
   # 
   # @method get_data_layout(m)
   # @param [OpaqueModule] m 
@@ -750,7 +969,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_data_layout, :LLVMGetDataLayout, [OpaqueModule], :string
   
-  # (Not documented)
+  # Set the data layout for a module.
+  # 
+  # @see Module::setDataLayout()
   # 
   # @method set_data_layout(m, triple)
   # @param [OpaqueModule] m 
@@ -759,7 +980,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_data_layout, :LLVMSetDataLayout, [OpaqueModule, :string], :void
   
-  # Target triple. See Module::getTargetTriple.
+  # Obtain the target triple for a module.
+  # 
+  # @see Module::getTargetTriple()
   # 
   # @method get_target(m)
   # @param [OpaqueModule] m 
@@ -767,7 +990,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_target, :LLVMGetTarget, [OpaqueModule], :string
   
-  # (Not documented)
+  # Set the target triple for a module.
+  # 
+  # @see Module::setTargetTriple()
   # 
   # @method set_target(m, triple)
   # @param [OpaqueModule] m 
@@ -776,7 +1001,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_target, :LLVMSetTarget, [OpaqueModule, :string], :void
   
-  # See Module::dump.
+  # Dump a representation of a module to stderr.
+  # 
+  # @see Module::dump()
   # 
   # @method dump_module(m)
   # @param [OpaqueModule] m 
@@ -784,7 +1011,33 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :dump_module, :LLVMDumpModule, [OpaqueModule], :void
   
-  # See Module::setModuleInlineAsm.
+  # 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
+  
+  # Return a string representation of the module. Use
+  # LLVMDisposeMessage to free the string.
+  # 
+  # @see Module::print()
+  # 
+  # @method print_module_to_string(m)
+  # @param [OpaqueModule] m 
+  # @return [String] 
+  # @scope class
+  attach_function :print_module_to_string, :LLVMPrintModuleToString, [OpaqueModule], :string
+  
+  # Set inline assembly for a module.
+  # 
+  # @see Module::setModuleInlineAsm()
   # 
   # @method set_module_inline_asm(m, asm)
   # @param [OpaqueModule] m 
@@ -793,7 +1046,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_module_inline_asm, :LLVMSetModuleInlineAsm, [OpaqueModule, :string], :void
   
-  # See Module::getContext.
+  # Obtain the context to which this module is associated.
+  # 
+  # @see Module::getContext()
   # 
   # @method get_module_context(m)
   # @param [OpaqueModule] m 
@@ -801,7 +1056,127 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_module_context, :LLVMGetModuleContext, [OpaqueModule], OpaqueContext
   
-  # See llvm::LLVMTypeKind::getTypeID.
+  # Obtain a Type from a module by its registered name.
+  # 
+  # @method get_type_by_name(m, name)
+  # @param [OpaqueModule] m 
+  # @param [String] name 
+  # @return [OpaqueType] 
+  # @scope class
+  attach_function :get_type_by_name, :LLVMGetTypeByName, [OpaqueModule, :string], OpaqueType
+  
+  # Obtain the number of operands for named metadata in a module.
+  # 
+  # @see llvm::Module::getNamedMetadata()
+  # 
+  # @method get_named_metadata_num_operands(m, name)
+  # @param [OpaqueModule] m 
+  # @param [String] name 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [OpaqueModule, :string], :uint
+  
+  # Obtain the named metadata operands for a module.
+  # 
+  # The passed LLVMValueRef pointer should refer to an array of
+  # LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This
+  # array will be populated with the LLVMValueRef instances. Each
+  # instance corresponds to a llvm::MDNode.
+  # 
+  # @see llvm::Module::getNamedMetadata()
+  # @see llvm::MDNode::getOperand()
+  # 
+  # @method get_named_metadata_operands(m, name, dest)
+  # @param [OpaqueModule] m 
+  # @param [String] name 
+  # @param [FFI::Pointer(*ValueRef)] dest 
+  # @return [nil] 
+  # @scope class
+  attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [OpaqueModule, :string, :pointer], :void
+  
+  # Add an operand to named metadata.
+  # 
+  # @see llvm::Module::getNamedMetadata()
+  # @see llvm::MDNode::addOperand()
+  # 
+  # @method add_named_metadata_operand(m, name, val)
+  # @param [OpaqueModule] m 
+  # @param [String] name 
+  # @param [OpaqueValue] val 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_named_metadata_operand, :LLVMAddNamedMetadataOperand, [OpaqueModule, :string, OpaqueValue], :void
+  
+  # Add a function to a module under a specified name.
+  # 
+  # @see llvm::Function::Create()
+  # 
+  # @method add_function(m, name, function_ty)
+  # @param [OpaqueModule] m 
+  # @param [String] name 
+  # @param [OpaqueType] function_ty 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :add_function, :LLVMAddFunction, [OpaqueModule, :string, OpaqueType], OpaqueValue
+  
+  # Obtain a Function value from a Module by its name.
+  # 
+  # The returned value corresponds to a llvm::Function value.
+  # 
+  # @see llvm::Module::getFunction()
+  # 
+  # @method get_named_function(m, name)
+  # @param [OpaqueModule] m 
+  # @param [String] name 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :get_named_function, :LLVMGetNamedFunction, [OpaqueModule, :string], OpaqueValue
+  
+  # Obtain an iterator to the first Function in a Module.
+  # 
+  # @see llvm::Module::begin()
+  # 
+  # @method get_first_function(m)
+  # @param [OpaqueModule] m 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :get_first_function, :LLVMGetFirstFunction, [OpaqueModule], OpaqueValue
+  
+  # Obtain an iterator to the last Function in a Module.
+  # 
+  # @see llvm::Module::end()
+  # 
+  # @method get_last_function(m)
+  # @param [OpaqueModule] m 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :get_last_function, :LLVMGetLastFunction, [OpaqueModule], OpaqueValue
+  
+  # Advance a Function iterator to the next Function.
+  # 
+  # Returns NULL if the iterator was already at the end and there are no more
+  # functions.
+  # 
+  # @method get_next_function(fn)
+  # @param [OpaqueValue] fn 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :get_next_function, :LLVMGetNextFunction, [OpaqueValue], OpaqueValue
+  
+  # Decrement a Function iterator to the previous Function.
+  # 
+  # Returns NULL if the iterator was already at the beginning and there are
+  # no previous functions.
+  # 
+  # @method get_previous_function(fn)
+  # @param [OpaqueValue] fn 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :get_previous_function, :LLVMGetPreviousFunction, [OpaqueValue], OpaqueValue
+  
+  # Obtain the enumerated type of a Type instance.
+  # 
+  # @see llvm::Type:getTypeID()
   # 
   # @method get_type_kind(ty)
   # @param [OpaqueType] ty 
@@ -809,7 +1184,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_type_kind, :LLVMGetTypeKind, [OpaqueType], :type_kind
   
-  # (Not documented)
+  # Whether the type has a known size.
+  # 
+  # Things that don't have a size are abstract types, labels, and void.a
+  # 
+  # @see llvm::Type::isSized()
   # 
   # @method type_is_sized(ty)
   # @param [OpaqueType] ty 
@@ -817,7 +1196,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :type_is_sized, :LLVMTypeIsSized, [OpaqueType], :int
   
-  # See llvm::LLVMType::getContext.
+  # Obtain the context to which this type instance is associated.
+  # 
+  # @see llvm::Type::getContext()
   # 
   # @method get_type_context(ty)
   # @param [OpaqueType] ty 
@@ -825,7 +1206,28 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_type_context, :LLVMGetTypeContext, [OpaqueType], OpaqueContext
   
-  # Operations on integer types
+  # Dump a representation of a type to stderr.
+  # 
+  # @see llvm::Type::dump()
+  # 
+  # @method dump_type(val)
+  # @param [OpaqueType] val 
+  # @return [nil] 
+  # @scope class
+  attach_function :dump_type, :LLVMDumpType, [OpaqueType], :void
+  
+  # Return a string representation of the type. Use
+  # LLVMDisposeMessage to free the string.
+  # 
+  # @see llvm::Type::print()
+  # 
+  # @method print_type_to_string(val)
+  # @param [OpaqueType] val 
+  # @return [String] 
+  # @scope class
+  attach_function :print_type_to_string, :LLVMPrintTypeToString, [OpaqueType], :string
+  
+  # Obtain an integer type from a context with specified bit width.
   # 
   # @method int1_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -874,7 +1276,8 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :int_type_in_context, :LLVMIntTypeInContext, [OpaqueContext, :uint], OpaqueType
   
-  # (Not documented)
+  # Obtain an integer type from the global context with a specified bit
+  # width.
   # 
   # @method int1_type()
   # @return [OpaqueType] 
@@ -925,7 +1328,15 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_int_type_width, :LLVMGetIntTypeWidth, [OpaqueType], :uint
   
-  # Operations on real types
+  # Obtain a 16-bit floating point type from a context.
+  # 
+  # @method half_type_in_context(c)
+  # @param [OpaqueContext] c 
+  # @return [OpaqueType] 
+  # @scope class
+  attach_function :half_type_in_context, :LLVMHalfTypeInContext, [OpaqueContext], OpaqueType
+  
+  # Obtain a 32-bit floating point type from a context.
   # 
   # @method float_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -933,7 +1344,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :float_type_in_context, :LLVMFloatTypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # Obtain a 64-bit floating point type from a context.
   # 
   # @method double_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -941,7 +1352,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :double_type_in_context, :LLVMDoubleTypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # Obtain a 80-bit floating point type (X87) from a context.
   # 
   # @method x86fp80_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -949,7 +1360,8 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # Obtain a 128-bit floating point type (112-bit mantissa) from a
+  # context.
   # 
   # @method fp128_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -957,7 +1369,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :fp128_type_in_context, :LLVMFP128TypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # Obtain a 128-bit floating point type (two 64-bits) from a context.
   # 
   # @method ppcfp128_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -965,6 +1377,15 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [OpaqueContext], OpaqueType
   
+  # Obtain a floating point type from the global context.
+  # 
+  # These map to the functions in this group of the same name.
+  # 
+  # @method half_type()
+  # @return [OpaqueType] 
+  # @scope class
+  attach_function :half_type, :LLVMHalfType, [], OpaqueType
+  
   # (Not documented)
   # 
   # @method float_type()
@@ -1000,7 +1421,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :ppcfp128_type, :LLVMPPCFP128Type, [], OpaqueType
   
-  # Operations on function types
+  # Obtain a function type consisting of a specified signature.
+  # 
+  # The function is defined as a tuple of a return Type, a list of
+  # parameter types, and whether the function is variadic.
   # 
   # @method function_type(return_type, param_types, param_count, is_var_arg)
   # @param [OpaqueType] return_type 
@@ -1011,7 +1435,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :function_type, :LLVMFunctionType, [OpaqueType, :pointer, :uint, :int], OpaqueType
   
-  # (Not documented)
+  # Returns whether a function type is variadic.
   # 
   # @method is_function_var_arg(function_ty)
   # @param [OpaqueType] function_ty 
@@ -1019,7 +1443,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [OpaqueType], :int
   
-  # (Not documented)
+  # Obtain the Type this function Type returns.
   # 
   # @method get_return_type(function_ty)
   # @param [OpaqueType] function_ty 
@@ -1027,7 +1451,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_return_type, :LLVMGetReturnType, [OpaqueType], OpaqueType
   
-  # (Not documented)
+  # Obtain the number of parameters this function accepts.
   # 
   # @method count_param_types(function_ty)
   # @param [OpaqueType] function_ty 
@@ -1035,7 +1459,15 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :count_param_types, :LLVMCountParamTypes, [OpaqueType], :uint
   
-  # (Not documented)
+  # Obtain the types of a function's parameters.
+  # 
+  # The Dest parameter should point to a pre-allocated array of
+  # LLVMTypeRef at least LLVMCountParamTypes() large. On return, the
+  # first LLVMCountParamTypes() entries in the array will be populated
+  # with LLVMTypeRef instances.
+  # 
+  # @param FunctionTy The function type to operate on.
+  # @param Dest Memory address of an array to be filled with result.
   # 
   # @method get_param_types(function_ty, dest)
   # @param [OpaqueType] function_ty 
@@ -1044,7 +1476,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_param_types, :LLVMGetParamTypes, [OpaqueType, :pointer], :void
   
-  # Operations on struct types
+  # Create a new structure type in a context.
+  # 
+  # A structure is specified by a list of inner elements/types and
+  # whether these can be packed together.
+  # 
+  # @see llvm::StructType::create()
   # 
   # @method struct_type_in_context(c, element_types, element_count, packed)
   # @param [OpaqueContext] c 
@@ -1055,7 +1492,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :struct_type_in_context, :LLVMStructTypeInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueType
   
-  # (Not documented)
+  # Create a new structure type in the global context.
+  # 
+  # @see llvm::StructType::create()
   # 
   # @method struct_type(element_types, element_count, packed)
   # @param [FFI::Pointer(*TypeRef)] element_types 
@@ -1065,7 +1504,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :struct_type, :LLVMStructType, [:pointer, :uint, :int], OpaqueType
   
-  # (Not documented)
+  # Create an empty structure in a context having a specified name.
+  # 
+  # @see llvm::StructType::create()
   # 
   # @method struct_create_named(c, name)
   # @param [OpaqueContext] c 
@@ -1074,7 +1515,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :struct_create_named, :LLVMStructCreateNamed, [OpaqueContext, :string], OpaqueType
   
-  # (Not documented)
+  # Obtain the name of a structure.
+  # 
+  # @see llvm::StructType::getName()
   # 
   # @method get_struct_name(ty)
   # @param [OpaqueType] ty 
@@ -1082,7 +1525,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_struct_name, :LLVMGetStructName, [OpaqueType], :string
   
-  # (Not documented)
+  # Set the contents of a structure type.
+  # 
+  # @see llvm::StructType::setBody()
   # 
   # @method struct_set_body(struct_ty, element_types, element_count, packed)
   # @param [OpaqueType] struct_ty 
@@ -1093,7 +1538,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :struct_set_body, :LLVMStructSetBody, [OpaqueType, :pointer, :uint, :int], :void
   
-  # (Not documented)
+  # Get the number of elements defined inside the structure.
+  # 
+  # @see llvm::StructType::getNumElements()
   # 
   # @method count_struct_element_types(struct_ty)
   # @param [OpaqueType] struct_ty 
@@ -1101,7 +1548,14 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :count_struct_element_types, :LLVMCountStructElementTypes, [OpaqueType], :uint
   
-  # (Not documented)
+  # Get the elements within a structure.
+  # 
+  # The function is passed the address of a pre-allocated array of
+  # LLVMTypeRef at least LLVMCountStructElementTypes() long. After
+  # invocation, this array will be populated with the structure's
+  # elements. The objects in the destination array will have a lifetime
+  # of the structure type itself, which is the lifetime of the context it
+  # is contained in.
   # 
   # @method get_struct_element_types(struct_ty, dest)
   # @param [OpaqueType] struct_ty 
@@ -1110,7 +1564,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_struct_element_types, :LLVMGetStructElementTypes, [OpaqueType, :pointer], :void
   
-  # (Not documented)
+  # Determine whether a structure is packed.
+  # 
+  # @see llvm::StructType::isPacked()
   # 
   # @method is_packed_struct(struct_ty)
   # @param [OpaqueType] struct_ty 
@@ -1118,7 +1574,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_packed_struct, :LLVMIsPackedStruct, [OpaqueType], :int
   
-  # (Not documented)
+  # Determine whether a structure is opaque.
+  # 
+  # @see llvm::StructType::isOpaque()
   # 
   # @method is_opaque_struct(struct_ty)
   # @param [OpaqueType] struct_ty 
@@ -1126,16 +1584,24 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [OpaqueType], :int
   
-  # (Not documented)
+  # Obtain the type of elements within a sequential type.
   # 
-  # @method get_type_by_name(m, name)
-  # @param [OpaqueModule] m 
-  # @param [String] name 
+  # This works on array, vector, and pointer types.
+  # 
+  # @see llvm::SequentialType::getElementType()
+  # 
+  # @method get_element_type(ty)
+  # @param [OpaqueType] ty 
   # @return [OpaqueType] 
   # @scope class
-  attach_function :get_type_by_name, :LLVMGetTypeByName, [OpaqueModule, :string], OpaqueType
+  attach_function :get_element_type, :LLVMGetElementType, [OpaqueType], OpaqueType
   
-  # Operations on array, pointer, and vector types (sequence types)
+  # Create a fixed size array type that refers to a specific type.
+  # 
+  # The created type will exist in the context that its element type
+  # exists in.
+  # 
+  # @see llvm::ArrayType::get()
   # 
   # @method array_type(element_type, element_count)
   # @param [OpaqueType] element_type 
@@ -1144,7 +1610,24 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :array_type, :LLVMArrayType, [OpaqueType, :uint], OpaqueType
   
-  # (Not documented)
+  # Obtain the length of an array type.
+  # 
+  # This only works on types that represent arrays.
+  # 
+  # @see llvm::ArrayType::getNumElements()
+  # 
+  # @method get_array_length(array_ty)
+  # @param [OpaqueType] array_ty 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_array_length, :LLVMGetArrayLength, [OpaqueType], :uint
+  
+  # Create a pointer type that points to a defined type.
+  # 
+  # The created type will exist in the context that its pointee type
+  # exists in.
+  # 
+  # @see llvm::PointerType::get()
   # 
   # @method pointer_type(element_type, address_space)
   # @param [OpaqueType] element_type 
@@ -1153,7 +1636,25 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :pointer_type, :LLVMPointerType, [OpaqueType, :uint], OpaqueType
   
-  # (Not documented)
+  # Obtain the address space of a pointer type.
+  # 
+  # This only works on types that represent pointers.
+  # 
+  # @see llvm::PointerType::getAddressSpace()
+  # 
+  # @method get_pointer_address_space(pointer_ty)
+  # @param [OpaqueType] pointer_ty 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_pointer_address_space, :LLVMGetPointerAddressSpace, [OpaqueType], :uint
+  
+  # Create a vector type that contains a defined type and has a specific
+  # number of elements.
+  # 
+  # The created type will exist in the context thats its element type
+  # exists in.
+  # 
+  # @see llvm::VectorType::get()
   # 
   # @method vector_type(element_type, element_count)
   # @param [OpaqueType] element_type 
@@ -1162,31 +1663,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :vector_type, :LLVMVectorType, [OpaqueType, :uint], OpaqueType
   
-  # (Not documented)
-  # 
-  # @method get_element_type(ty)
-  # @param [OpaqueType] ty 
-  # @return [OpaqueType] 
-  # @scope class
-  attach_function :get_element_type, :LLVMGetElementType, [OpaqueType], OpaqueType
-  
-  # (Not documented)
+  # Obtain the number of elements in a vector type.
   # 
-  # @method get_array_length(array_ty)
-  # @param [OpaqueType] array_ty 
-  # @return [Integer] 
-  # @scope class
-  attach_function :get_array_length, :LLVMGetArrayLength, [OpaqueType], :uint
-  
-  # (Not documented)
+  # This only works on types that represent vectors.
   # 
-  # @method get_pointer_address_space(pointer_ty)
-  # @param [OpaqueType] pointer_ty 
-  # @return [Integer] 
-  # @scope class
-  attach_function :get_pointer_address_space, :LLVMGetPointerAddressSpace, [OpaqueType], :uint
-  
-  # (Not documented)
+  # @see llvm::VectorType::getNumElements()
   # 
   # @method get_vector_size(vector_ty)
   # @param [OpaqueType] vector_ty 
@@ -1194,7 +1675,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_vector_size, :LLVMGetVectorSize, [OpaqueType], :uint
   
-  # Operations on other types
+  # Create a void type in a context.
   # 
   # @method void_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -1202,7 +1683,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :void_type_in_context, :LLVMVoidTypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # Create a label type in a context.
   # 
   # @method label_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -1210,7 +1691,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :label_type_in_context, :LLVMLabelTypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # Create a X86 MMX type in a context.
   # 
   # @method x86mmx_type_in_context(c)
   # @param [OpaqueContext] c 
@@ -1218,7 +1699,8 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [OpaqueContext], OpaqueType
   
-  # (Not documented)
+  # These are similar to the above functions except they operate on the
+  # global context.
   # 
   # @method void_type()
   # @return [OpaqueType] 
@@ -1239,7 +1721,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :x86mmx_type, :LLVMX86MMXType, [], OpaqueType
   
-  # Operations on all values
+  # Obtain the type of a value.
+  # 
+  # @see llvm::Value::getType()
   # 
   # @method type_of(val)
   # @param [OpaqueValue] val 
@@ -1247,7 +1731,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :type_of, :LLVMTypeOf, [OpaqueValue], OpaqueType
   
-  # (Not documented)
+  # Obtain the string name of a value.
+  # 
+  # @see llvm::Value::getName()
   # 
   # @method get_value_name(val)
   # @param [OpaqueValue] val 
@@ -1255,7 +1741,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_value_name, :LLVMGetValueName, [OpaqueValue], :string
   
-  # (Not documented)
+  # Set the string name of a value.
+  # 
+  # @see llvm::Value::setName()
   # 
   # @method set_value_name(val, name)
   # @param [OpaqueValue] val 
@@ -1264,7 +1752,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_value_name, :LLVMSetValueName, [OpaqueValue, :string], :void
   
-  # (Not documented)
+  # Dump a representation of a value to stderr.
+  # 
+  # @see llvm::Value::dump()
   # 
   # @method dump_value(val)
   # @param [OpaqueValue] val 
@@ -1272,7 +1762,20 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :dump_value, :LLVMDumpValue, [OpaqueValue], :void
   
-  # (Not documented)
+  # Return a string representation of the value. Use
+  # LLVMDisposeMessage to free the string.
+  # 
+  # @see llvm::Value::print()
+  # 
+  # @method print_value_to_string(val)
+  # @param [OpaqueValue] val 
+  # @return [String] 
+  # @scope class
+  attach_function :print_value_to_string, :LLVMPrintValueToString, [OpaqueValue], :string
+  
+  # Replace all uses of a value with another one.
+  # 
+  # @see llvm::Value::replaceAllUsesWith()
   # 
   # @method replace_all_uses_with(old_val, new_val)
   # @param [OpaqueValue] old_val 
@@ -1281,34 +1784,31 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :replace_all_uses_with, :LLVMReplaceAllUsesWith, [OpaqueValue, OpaqueValue], :void
   
-  # (Not documented)
+  # Determine whether the specified constant instance is constant.
   # 
-  # @method has_metadata(val)
+  # @method is_constant(val)
   # @param [OpaqueValue] val 
   # @return [Integer] 
   # @scope class
-  attach_function :has_metadata, :LLVMHasMetadata, [OpaqueValue], :int
+  attach_function :is_constant, :LLVMIsConstant, [OpaqueValue], :int
   
-  # (Not documented)
+  # Determine whether a value instance is undefined.
   # 
-  # @method get_metadata(val, kind_id)
+  # @method is_undef(val)
   # @param [OpaqueValue] val 
-  # @param [Integer] kind_id 
-  # @return [OpaqueValue] 
+  # @return [Integer] 
   # @scope class
-  attach_function :get_metadata, :LLVMGetMetadata, [OpaqueValue, :uint], OpaqueValue
+  attach_function :is_undef, :LLVMIsUndef, [OpaqueValue], :int
   
-  # (Not documented)
+  # Convert value instances between types.
   # 
-  # @method set_metadata(val, kind_id, node)
-  # @param [OpaqueValue] val 
-  # @param [Integer] kind_id 
-  # @param [OpaqueValue] node 
-  # @return [nil] 
-  # @scope class
-  attach_function :set_metadata, :LLVMSetMetadata, [OpaqueValue, :uint, OpaqueValue], :void
-  
-  # (Not documented)
+  # Internally, an LLVMValueRef is "pinned" to a specific type. This
+  # series of functions allows you to cast an instance to a specific
+  # type.
+  # 
+  # If the cast is not valid for the specified type, NULL is returned.
+  # 
+  # @see llvm::dyn_cast_or_null<>
   # 
   # @method is_a_argument(val)
   # @param [OpaqueValue] val 
@@ -1316,7 +1816,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_argument, :LLVMIsAArgument, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_basic_block(val)
   # @param [OpaqueValue] val 
@@ -1324,7 +1824,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_basic_block, :LLVMIsABasicBlock, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_inline_asm(val)
   # @param [OpaqueValue] val 
@@ -1332,7 +1832,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_amd_node(val)
   # @param [OpaqueValue] val 
@@ -1340,7 +1840,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_amd_node, :LLVMIsAMDNode, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_amd_string(val)
   # @param [OpaqueValue] val 
@@ -1348,7 +1848,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_amd_string, :LLVMIsAMDString, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_user(val)
   # @param [OpaqueValue] val 
@@ -1356,7 +1856,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_user, :LLVMIsAUser, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant(val)
   # @param [OpaqueValue] val 
@@ -1364,7 +1864,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant, :LLVMIsAConstant, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_block_address(val)
   # @param [OpaqueValue] val 
@@ -1372,7 +1872,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_block_address, :LLVMIsABlockAddress, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_aggregate_zero(val)
   # @param [OpaqueValue] val 
@@ -1380,7 +1880,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_array(val)
   # @param [OpaqueValue] val 
@@ -1388,7 +1888,31 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_array, :LLVMIsAConstantArray, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
+  # 
+  # @method is_a_constant_data_sequential(val)
+  # @param [OpaqueValue] val 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :is_a_constant_data_sequential, :LLVMIsAConstantDataSequential, [OpaqueValue], OpaqueValue
+  
+  # @}
+  # 
+  # @method is_a_constant_data_array(val)
+  # @param [OpaqueValue] val 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :is_a_constant_data_array, :LLVMIsAConstantDataArray, [OpaqueValue], OpaqueValue
+  
+  # @}
+  # 
+  # @method is_a_constant_data_vector(val)
+  # @param [OpaqueValue] val 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :is_a_constant_data_vector, :LLVMIsAConstantDataVector, [OpaqueValue], OpaqueValue
+  
+  # @}
   # 
   # @method is_a_constant_expr(val)
   # @param [OpaqueValue] val 
@@ -1396,7 +1920,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_fp(val)
   # @param [OpaqueValue] val 
@@ -1404,7 +1928,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_int(val)
   # @param [OpaqueValue] val 
@@ -1412,7 +1936,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_int, :LLVMIsAConstantInt, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_pointer_null(val)
   # @param [OpaqueValue] val 
@@ -1420,7 +1944,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_struct(val)
   # @param [OpaqueValue] val 
@@ -1428,7 +1952,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_constant_vector(val)
   # @param [OpaqueValue] val 
@@ -1436,7 +1960,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_global_value(val)
   # @param [OpaqueValue] val 
@@ -1444,7 +1968,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_global_value, :LLVMIsAGlobalValue, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_function(val)
   # @param [OpaqueValue] val 
@@ -1452,7 +1976,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_function, :LLVMIsAFunction, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_global_alias(val)
   # @param [OpaqueValue] val 
@@ -1460,7 +1984,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_global_variable(val)
   # @param [OpaqueValue] val 
@@ -1468,7 +1992,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_undef_value(val)
   # @param [OpaqueValue] val 
@@ -1476,7 +2000,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_undef_value, :LLVMIsAUndefValue, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_instruction(val)
   # @param [OpaqueValue] val 
@@ -1484,7 +2008,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_instruction, :LLVMIsAInstruction, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_binary_operator(val)
   # @param [OpaqueValue] val 
@@ -1492,7 +2016,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_call_inst(val)
   # @param [OpaqueValue] val 
@@ -1500,7 +2024,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_call_inst, :LLVMIsACallInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_intrinsic_inst(val)
   # @param [OpaqueValue] val 
@@ -1508,7 +2032,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_dbg_info_intrinsic(val)
   # @param [OpaqueValue] val 
@@ -1516,7 +2040,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_dbg_declare_inst(val)
   # @param [OpaqueValue] val 
@@ -1524,23 +2048,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
-  # 
-  # @method is_aeh_exception_inst(val)
-  # @param [OpaqueValue] val 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :is_aeh_exception_inst, :LLVMIsAEHExceptionInst, [OpaqueValue], OpaqueValue
-  
-  # (Not documented)
-  # 
-  # @method is_aeh_selector_inst(val)
-  # @param [OpaqueValue] val 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :is_aeh_selector_inst, :LLVMIsAEHSelectorInst, [OpaqueValue], OpaqueValue
-  
-  # (Not documented)
+  # @}
   # 
   # @method is_a_mem_intrinsic(val)
   # @param [OpaqueValue] val 
@@ -1548,7 +2056,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_mem_cpy_inst(val)
   # @param [OpaqueValue] val 
@@ -1556,7 +2064,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_mem_move_inst(val)
   # @param [OpaqueValue] val 
@@ -1564,7 +2072,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_mem_set_inst(val)
   # @param [OpaqueValue] val 
@@ -1572,7 +2080,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_cmp_inst(val)
   # @param [OpaqueValue] val 
@@ -1580,7 +2088,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_af_cmp_inst(val)
   # @param [OpaqueValue] val 
@@ -1588,7 +2096,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_ai_cmp_inst(val)
   # @param [OpaqueValue] val 
@@ -1596,7 +2104,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_extract_element_inst(val)
   # @param [OpaqueValue] val 
@@ -1604,7 +2112,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_get_element_ptr_inst(val)
   # @param [OpaqueValue] val 
@@ -1612,7 +2120,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_insert_element_inst(val)
   # @param [OpaqueValue] val 
@@ -1620,7 +2128,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_insert_value_inst(val)
   # @param [OpaqueValue] val 
@@ -1628,7 +2136,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_landing_pad_inst(val)
   # @param [OpaqueValue] val 
@@ -1636,7 +2144,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_aphi_node(val)
   # @param [OpaqueValue] val 
@@ -1644,7 +2152,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_aphi_node, :LLVMIsAPHINode, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_select_inst(val)
   # @param [OpaqueValue] val 
@@ -1652,7 +2160,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_select_inst, :LLVMIsASelectInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_shuffle_vector_inst(val)
   # @param [OpaqueValue] val 
@@ -1660,7 +2168,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_store_inst(val)
   # @param [OpaqueValue] val 
@@ -1668,7 +2176,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_store_inst, :LLVMIsAStoreInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_terminator_inst(val)
   # @param [OpaqueValue] val 
@@ -1676,7 +2184,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_branch_inst(val)
   # @param [OpaqueValue] val 
@@ -1684,7 +2192,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_branch_inst, :LLVMIsABranchInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_indirect_br_inst(val)
   # @param [OpaqueValue] val 
@@ -1692,7 +2200,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_invoke_inst(val)
   # @param [OpaqueValue] val 
@@ -1700,7 +2208,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_return_inst(val)
   # @param [OpaqueValue] val 
@@ -1708,7 +2216,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_return_inst, :LLVMIsAReturnInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_switch_inst(val)
   # @param [OpaqueValue] val 
@@ -1716,7 +2224,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_unreachable_inst(val)
   # @param [OpaqueValue] val 
@@ -1724,7 +2232,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_resume_inst(val)
   # @param [OpaqueValue] val 
@@ -1732,7 +2240,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_unary_instruction(val)
   # @param [OpaqueValue] val 
@@ -1740,7 +2248,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_alloca_inst(val)
   # @param [OpaqueValue] val 
@@ -1748,7 +2256,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_cast_inst(val)
   # @param [OpaqueValue] val 
@@ -1756,7 +2264,15 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_cast_inst, :LLVMIsACastInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
+  # 
+  # @method is_a_addr_space_cast_inst(val)
+  # @param [OpaqueValue] val 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :is_a_addr_space_cast_inst, :LLVMIsAAddrSpaceCastInst, [OpaqueValue], OpaqueValue
+  
+  # @}
   # 
   # @method is_a_bit_cast_inst(val)
   # @param [OpaqueValue] val 
@@ -1764,7 +2280,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_afp_ext_inst(val)
   # @param [OpaqueValue] val 
@@ -1772,7 +2288,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_afp_to_si_inst(val)
   # @param [OpaqueValue] val 
@@ -1780,7 +2296,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_afp_to_ui_inst(val)
   # @param [OpaqueValue] val 
@@ -1788,7 +2304,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_afp_trunc_inst(val)
   # @param [OpaqueValue] val 
@@ -1796,7 +2312,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_int_to_ptr_inst(val)
   # @param [OpaqueValue] val 
@@ -1804,7 +2320,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_ptr_to_int_inst(val)
   # @param [OpaqueValue] val 
@@ -1812,7 +2328,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_as_ext_inst(val)
   # @param [OpaqueValue] val 
@@ -1820,7 +2336,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_as_ext_inst, :LLVMIsASExtInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_asi_to_fp_inst(val)
   # @param [OpaqueValue] val 
@@ -1828,7 +2344,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_trunc_inst(val)
   # @param [OpaqueValue] val 
@@ -1836,7 +2352,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_aui_to_fp_inst(val)
   # @param [OpaqueValue] val 
@@ -1844,7 +2360,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_az_ext_inst(val)
   # @param [OpaqueValue] val 
@@ -1852,7 +2368,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_extract_value_inst(val)
   # @param [OpaqueValue] val 
@@ -1860,7 +2376,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_a_load_inst(val)
   # @param [OpaqueValue] val 
@@ -1868,7 +2384,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_a_load_inst, :LLVMIsALoadInst, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # @}
   # 
   # @method is_ava_arg_inst(val)
   # @param [OpaqueValue] val 
@@ -1876,7 +2392,14 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [OpaqueValue], OpaqueValue
   
-  # Operations on Uses
+  # Obtain the first use of a value.
+  # 
+  # 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 until
+  # LLVMGetNextUse() returns NULL.
+  # 
+  # @see llvm::Value::use_begin()
   # 
   # @method get_first_use(val)
   # @param [OpaqueValue] val 
@@ -1884,7 +2407,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_first_use, :LLVMGetFirstUse, [OpaqueValue], OpaqueUse
   
-  # (Not documented)
+  # Obtain the next use of a value.
+  # 
+  # This effectively advances the iterator. It returns NULL if you are on
+  # the final use and no more are available.
   # 
   # @method get_next_use(u)
   # @param [OpaqueUse] u 
@@ -1892,7 +2418,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_next_use, :LLVMGetNextUse, [OpaqueUse], OpaqueUse
   
-  # (Not documented)
+  # Obtain the user value for a user.
+  # 
+  # The returned value corresponds to a llvm::User type.
+  # 
+  # @see llvm::Use::getUser()
   # 
   # @method get_user(u)
   # @param [OpaqueUse] u 
@@ -1900,7 +2430,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_user, :LLVMGetUser, [OpaqueUse], OpaqueValue
   
-  # (Not documented)
+  # Obtain the value this use corresponds to.
+  # 
+  # @see llvm::Use::get().
   # 
   # @method get_used_value(u)
   # @param [OpaqueUse] u 
@@ -1908,7 +2440,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_used_value, :LLVMGetUsedValue, [OpaqueUse], OpaqueValue
   
-  # Operations on Users
+  # Obtain an operand at a specific index in a llvm::User value.
+  # 
+  # @see llvm::User::getOperand()
   # 
   # @method get_operand(val, index)
   # @param [OpaqueValue] val 
@@ -1917,7 +2451,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_operand, :LLVMGetOperand, [OpaqueValue, :uint], OpaqueValue
   
-  # (Not documented)
+  # Set an operand at a specific index in a llvm::User value.
+  # 
+  # @see llvm::User::setOperand()
   # 
   # @method set_operand(user, index, val)
   # @param [OpaqueValue] user 
@@ -1927,7 +2463,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_operand, :LLVMSetOperand, [OpaqueValue, :uint, OpaqueValue], :void
   
-  # (Not documented)
+  # Obtain the number of operands in a llvm::User value.
+  # 
+  # @see llvm::User::getNumOperands()
   # 
   # @method get_num_operands(val)
   # @param [OpaqueValue] val 
@@ -1935,7 +2473,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_num_operands, :LLVMGetNumOperands, [OpaqueValue], :int
   
-  # Operations on constants of any type
+  # Obtain a constant value referring to the null instance of a type.
+  # 
+  # @see llvm::Constant::getNullValue()
   # 
   # @method const_null(ty)
   # @param [OpaqueType] ty 
@@ -1943,7 +2483,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_null, :LLVMConstNull, [OpaqueType], OpaqueValue
   
-  # all zeroes
+  # Obtain a constant value referring to the instance of a type
+  # consisting of all ones.
+  # 
+  # This is only valid for integer types.
+  # 
+  # @see llvm::Constant::getAllOnesValue()
   # 
   # @method const_all_ones(ty)
   # @param [OpaqueType] ty 
@@ -1951,7 +2496,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_all_ones, :LLVMConstAllOnes, [OpaqueType], OpaqueValue
   
-  # only for int/vector
+  # Obtain a constant value referring to an undefined value of a type.
+  # 
+  # @see llvm::UndefValue::get()
   # 
   # @method get_undef(ty)
   # @param [OpaqueType] ty 
@@ -1959,15 +2506,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_undef, :LLVMGetUndef, [OpaqueType], OpaqueValue
   
-  # (Not documented)
+  # Determine whether a value instance is null.
   # 
-  # @method is_constant(val)
-  # @param [OpaqueValue] val 
-  # @return [Integer] 
-  # @scope class
-  attach_function :is_constant, :LLVMIsConstant, [OpaqueValue], :int
-  
-  # (Not documented)
+  # @see llvm::Constant::isNullValue()
   # 
   # @method is_null(val)
   # @param [OpaqueValue] val 
@@ -1975,15 +2516,8 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_null, :LLVMIsNull, [OpaqueValue], :int
   
-  # (Not documented)
-  # 
-  # @method is_undef(val)
-  # @param [OpaqueValue] val 
-  # @return [Integer] 
-  # @scope class
-  attach_function :is_undef, :LLVMIsUndef, [OpaqueValue], :int
-  
-  # (Not documented)
+  # Obtain a constant that is a constant pointer pointing to NULL for a
+  # specified type.
   # 
   # @method const_pointer_null(ty)
   # @param [OpaqueType] ty 
@@ -1991,110 +2525,43 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_pointer_null, :LLVMConstPointerNull, [OpaqueType], OpaqueValue
   
-  # Operations on metadata
+  # Obtain a constant value for an integer type.
   # 
-  # @method md_string_in_context(c, str, s_len)
-  # @param [OpaqueContext] c 
-  # @param [String] str 
-  # @param [Integer] s_len 
+  # The returned value corresponds to a llvm::ConstantInt.
+  # 
+  # @see llvm::ConstantInt::get()
+  # 
+  # @param IntTy Integer type to obtain value of.
+  # @param N The value the returned instance should refer to.
+  # @param SignExtend Whether to sign extend the produced value.
+  # 
+  # @method const_int(int_ty, n, sign_extend)
+  # @param [OpaqueType] int_ty 
+  # @param [Integer] n 
+  # @param [Integer] sign_extend 
   # @return [OpaqueValue] 
   # @scope class
-  attach_function :md_string_in_context, :LLVMMDStringInContext, [OpaqueContext, :string, :uint], OpaqueValue
+  attach_function :const_int, :LLVMConstInt, [OpaqueType, :ulong_long, :int], OpaqueValue
   
-  # (Not documented)
+  # Obtain a constant value for an integer of arbitrary precision.
   # 
-  # @method md_string(str, s_len)
-  # @param [String] str 
-  # @param [Integer] s_len 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :md_string, :LLVMMDString, [:string, :uint], OpaqueValue
-  
-  # (Not documented)
-  # 
-  # @method md_node_in_context(c, vals, count)
-  # @param [OpaqueContext] c 
-  # @param [FFI::Pointer(*ValueRef)] vals 
-  # @param [Integer] count 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :md_node_in_context, :LLVMMDNodeInContext, [OpaqueContext, :pointer, :uint], OpaqueValue
-  
-  # (Not documented)
-  # 
-  # @method md_node(vals, count)
-  # @param [FFI::Pointer(*ValueRef)] vals 
-  # @param [Integer] count 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :md_node, :LLVMMDNode, [:pointer, :uint], OpaqueValue
-  
-  # (Not documented)
-  # 
-  # @method get_md_string(v, len)
-  # @param [OpaqueValue] v 
-  # @param [FFI::Pointer(*UInt)] len 
-  # @return [String] 
-  # @scope class
-  attach_function :get_md_string, :LLVMGetMDString, [OpaqueValue, :pointer], :string
-  
-  # (Not documented)
-  # 
-  # @method get_md_node_num_operands(v)
-  # @param [OpaqueValue] v 
-  # @return [Integer] 
-  # @scope class
-  attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [OpaqueValue], :int
-  
-  # (Not documented)
-  # 
-  # @method get_md_node_operand(v, i)
-  # @param [OpaqueValue] v 
-  # @param [Integer] i 
-  # @return [FFI::Pointer(*ValueRef)] 
-  # @scope class
-  attach_function :get_md_node_operand, :LLVMGetMDNodeOperand, [OpaqueValue, :uint], :pointer
-  
-  # (Not documented)
-  # 
-  # @method get_named_metadata_num_operands(m, name)
-  # @param [OpaqueModule] m 
-  # @param [String] name 
-  # @return [Integer] 
-  # @scope class
-  attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [OpaqueModule, :string], :uint
-  
-  # (Not documented)
-  # 
-  # @method get_named_metadata_operands(m, name, dest)
-  # @param [OpaqueModule] m 
-  # @param [String] name 
-  # @param [FFI::Pointer(*ValueRef)] dest 
-  # @return [nil] 
-  # @scope class
-  attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [OpaqueModule, :string, :pointer], :void
-  
-  # Operations on scalar constants
-  # 
-  # @method const_int(int_ty, n, sign_extend)
-  # @param [OpaqueType] int_ty 
-  # @param [Integer] n 
-  # @param [Integer] sign_extend 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :const_int, :LLVMConstInt, [OpaqueType, :ulong_long, :int], OpaqueValue
-  
-  # (Not documented)
+  # @see llvm::ConstantInt::get()
   # 
   # @method const_int_of_arbitrary_precision(int_ty, num_words, words)
   # @param [OpaqueType] int_ty 
   # @param [Integer] num_words 
-  # @param [FFI::Pointer(*Uint64T)] words 
+  # @param [unexposed] words 
   # @return [OpaqueValue] 
   # @scope class
-  attach_function :const_int_of_arbitrary_precision, :LLVMConstIntOfArbitraryPrecision, [OpaqueType, :uint, :pointer], OpaqueValue
+  attach_function :const_int_of_arbitrary_precision, :LLVMConstIntOfArbitraryPrecision, [OpaqueType, :uint, :char], OpaqueValue
   
-  # (Not documented)
+  # Obtain a constant value for an integer parsed from a string.
+  # 
+  # A similar API, LLVMConstIntOfStringAndSize is also available. If the
+  # string's length is available, it is preferred to call that function
+  # instead.
+  # 
+  # @see llvm::ConstantInt::get()
   # 
   # @method const_int_of_string(int_ty, text, radix)
   # @param [OpaqueType] int_ty 
@@ -2104,7 +2571,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_int_of_string, :LLVMConstIntOfString, [OpaqueType, :string, :uchar], OpaqueValue
   
-  # (Not documented)
+  # Obtain a constant value for an integer parsed from a string with
+  # specified length.
+  # 
+  # @see llvm::ConstantInt::get()
   # 
   # @method const_int_of_string_and_size(int_ty, text, s_len, radix)
   # @param [OpaqueType] int_ty 
@@ -2115,7 +2585,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_int_of_string_and_size, :LLVMConstIntOfStringAndSize, [OpaqueType, :string, :uint, :uchar], OpaqueValue
   
-  # (Not documented)
+  # Obtain a constant value referring to a double floating point value.
   # 
   # @method const_real(real_ty, n)
   # @param [OpaqueType] real_ty 
@@ -2124,7 +2594,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_real, :LLVMConstReal, [OpaqueType, :double], OpaqueValue
   
-  # (Not documented)
+  # Obtain a constant for a floating point value parsed from a string.
+  # 
+  # A similar API, LLVMConstRealOfStringAndSize is also available. It
+  # should be used if the input string's length is known.
   # 
   # @method const_real_of_string(real_ty, text)
   # @param [OpaqueType] real_ty 
@@ -2133,7 +2606,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_real_of_string, :LLVMConstRealOfString, [OpaqueType, :string], OpaqueValue
   
-  # (Not documented)
+  # Obtain a constant for a floating point value parsed from a string.
   # 
   # @method const_real_of_string_and_size(real_ty, text, s_len)
   # @param [OpaqueType] real_ty 
@@ -2143,7 +2616,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_real_of_string_and_size, :LLVMConstRealOfStringAndSize, [OpaqueType, :string, :uint], OpaqueValue
   
-  # (Not documented)
+  # Obtain the zero extended value for an integer constant value.
+  # 
+  # @see llvm::ConstantInt::getZExtValue()
   # 
   # @method const_int_get_z_ext_value(constant_val)
   # @param [OpaqueValue] constant_val 
@@ -2151,7 +2626,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_int_get_z_ext_value, :LLVMConstIntGetZExtValue, [OpaqueValue], :ulong_long
   
-  # (Not documented)
+  # Obtain the sign extended value for an integer constant value.
+  # 
+  # @see llvm::ConstantInt::getSExtValue()
   # 
   # @method const_int_get_s_ext_value(constant_val)
   # @param [OpaqueValue] constant_val 
@@ -2159,7 +2636,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_int_get_s_ext_value, :LLVMConstIntGetSExtValue, [OpaqueValue], :long_long
   
-  # Operations on composite constants
+  # Create a ConstantDataSequential and initialize it with a string.
+  # 
+  # @see llvm::ConstantDataArray::getString()
   # 
   # @method const_string_in_context(c, str, length, dont_null_terminate)
   # @param [OpaqueContext] c 
@@ -2170,18 +2649,13 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_string_in_context, :LLVMConstStringInContext, [OpaqueContext, :string, :uint, :int], OpaqueValue
   
-  # (Not documented)
+  # Create a ConstantDataSequential with string content in the global context.
   # 
-  # @method const_struct_in_context(c, constant_vals, count, packed)
-  # @param [OpaqueContext] c 
-  # @param [FFI::Pointer(*ValueRef)] constant_vals 
-  # @param [Integer] count 
-  # @param [Integer] packed 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :const_struct_in_context, :LLVMConstStructInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueValue
-  
-  # (Not documented)
+  # This is the same as LLVMConstStringInContext except it operates on the
+  # global context.
+  # 
+  # @see LLVMConstStringInContext()
+  # @see llvm::ConstantDataArray::getString()
   # 
   # @method const_string(str, length, dont_null_terminate)
   # @param [String] str 
@@ -2191,17 +2665,25 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_string, :LLVMConstString, [:string, :uint, :int], OpaqueValue
   
-  # (Not documented)
+  # Create an anonymous ConstantStruct with the specified values.
   # 
-  # @method const_array(element_ty, constant_vals, length)
-  # @param [OpaqueType] element_ty 
+  # @see llvm::ConstantStruct::getAnon()
+  # 
+  # @method const_struct_in_context(c, constant_vals, count, packed)
+  # @param [OpaqueContext] c 
   # @param [FFI::Pointer(*ValueRef)] constant_vals 
-  # @param [Integer] length 
+  # @param [Integer] count 
+  # @param [Integer] packed 
   # @return [OpaqueValue] 
   # @scope class
-  attach_function :const_array, :LLVMConstArray, [OpaqueType, :pointer, :uint], OpaqueValue
+  attach_function :const_struct_in_context, :LLVMConstStructInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueValue
   
-  # (Not documented)
+  # Create a ConstantStruct in the global Context.
+  # 
+  # This is the same as LLVMConstStructInContext except it operates on the
+  # global Context.
+  # 
+  # @see LLVMConstStructInContext()
   # 
   # @method const_struct(constant_vals, count, packed)
   # @param [FFI::Pointer(*ValueRef)] constant_vals 
@@ -2211,7 +2693,21 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_struct, :LLVMConstStruct, [:pointer, :uint, :int], OpaqueValue
   
-  # (Not documented)
+  # Create a ConstantArray from values.
+  # 
+  # @see llvm::ConstantArray::get()
+  # 
+  # @method const_array(element_ty, constant_vals, length)
+  # @param [OpaqueType] element_ty 
+  # @param [FFI::Pointer(*ValueRef)] constant_vals 
+  # @param [Integer] length 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :const_array, :LLVMConstArray, [OpaqueType, :pointer, :uint], OpaqueValue
+  
+  # Create a non-anonymous ConstantStruct from values.
+  # 
+  # @see llvm::ConstantStruct::get()
   # 
   # @method const_named_struct(struct_ty, constant_vals, count)
   # @param [OpaqueType] struct_ty 
@@ -2221,7 +2717,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_named_struct, :LLVMConstNamedStruct, [OpaqueType, :pointer, :uint], OpaqueValue
   
-  # (Not documented)
+  # Create a ConstantVector from values.
+  # 
+  # @see llvm::ConstantVector::get()
   # 
   # @method const_vector(scalar_constant_vals, size)
   # @param [FFI::Pointer(*ValueRef)] scalar_constant_vals 
@@ -2230,7 +2728,13 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_vector, :LLVMConstVector, [:pointer, :uint], OpaqueValue
   
-  # Constant expressions
+  # @defgroup LLVMCCoreValueConstantExpressions Constant Expressions
+  # 
+  # Functions in this group correspond to APIs on llvm::ConstantExpr.
+  # 
+  # @see llvm::ConstantExpr.
+  # 
+  # @{
   # 
   # @method get_const_opcode(constant_val)
   # @param [OpaqueValue] constant_val 
@@ -2667,6 +3171,15 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :const_bit_cast, :LLVMConstBitCast, [OpaqueValue, OpaqueType], OpaqueValue
   
+  # (Not documented)
+  # 
+  # @method const_addr_space_cast(constant_val, to_type)
+  # @param [OpaqueValue] constant_val 
+  # @param [OpaqueType] to_type 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :const_addr_space_cast, :LLVMConstAddrSpaceCast, [OpaqueValue, OpaqueType], OpaqueValue
+  
   # (Not documented)
   # 
   # @method const_z_ext_or_bit_cast(constant_val, to_type)
@@ -2803,7 +3316,14 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :block_address, :LLVMBlockAddress, [OpaqueValue, OpaqueBasicBlock], OpaqueValue
   
-  # Operations on global variables, functions, and aliases (globals)
+  # @defgroup LLVMCCoreValueConstantGlobals Global Values
+  # 
+  # This group contains functions that operate on global values. Functions in
+  # this group relate to functions in the llvm::GlobalValue class tree.
+  # 
+  # @see llvm::GlobalValue
+  # 
+  # @{
   # 
   # @method get_global_parent(global)
   # @param [OpaqueValue] global 
@@ -2870,24 +3390,36 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_visibility, :LLVMSetVisibility, [OpaqueValue, :visibility], :void
   
-  # (Not documented)
+  # Obtain the preferred alignment of the value.
+  # @see llvm::LoadInst::getAlignment()
+  # @see llvm::StoreInst::getAlignment()
+  # @see llvm::GlobalValue::getAlignment()
   # 
-  # @method get_alignment(global)
-  # @param [OpaqueValue] global 
+  # @method get_alignment(v)
+  # @param [OpaqueValue] v 
   # @return [Integer] 
   # @scope class
   attach_function :get_alignment, :LLVMGetAlignment, [OpaqueValue], :uint
   
-  # (Not documented)
+  # Set the preferred alignment of the value.
+  # @see llvm::LoadInst::setAlignment()
+  # @see llvm::StoreInst::setAlignment()
+  # @see llvm::GlobalValue::setAlignment()
   # 
-  # @method set_alignment(global, bytes)
-  # @param [OpaqueValue] global 
+  # @method set_alignment(v, bytes)
+  # @param [OpaqueValue] v 
   # @param [Integer] bytes 
   # @return [nil] 
   # @scope class
   attach_function :set_alignment, :LLVMSetAlignment, [OpaqueValue, :uint], :void
   
-  # Operations on global variables
+  # @defgroup LLVMCoreValueConstantGlobalVariable Global Variables
+  # 
+  # This group contains functions that operate on global variable values.
+  # 
+  # @see llvm::GlobalVariable
+  # 
+  # @{
   # 
   # @method add_global(m, ty, name)
   # @param [OpaqueModule] m 
@@ -3008,69 +3540,60 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_global_constant, :LLVMSetGlobalConstant, [OpaqueValue, :int], :void
   
-  # Operations on aliases
-  # 
-  # @method add_alias(m, ty, aliasee, name)
-  # @param [OpaqueModule] m 
-  # @param [OpaqueType] ty 
-  # @param [OpaqueValue] aliasee 
-  # @param [String] name 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :add_alias, :LLVMAddAlias, [OpaqueModule, OpaqueType, OpaqueValue, :string], OpaqueValue
-  
-  # Operations on functions
-  # 
-  # @method add_function(m, name, function_ty)
-  # @param [OpaqueModule] m 
-  # @param [String] name 
-  # @param [OpaqueType] function_ty 
-  # @return [OpaqueValue] 
-  # @scope class
-  attach_function :add_function, :LLVMAddFunction, [OpaqueModule, :string, OpaqueType], OpaqueValue
-  
   # (Not documented)
   # 
-  # @method get_named_function(m, name)
-  # @param [OpaqueModule] m 
-  # @param [String] name 
-  # @return [OpaqueValue] 
+  # @method get_thread_local_mode(global_var)
+  # @param [OpaqueValue] global_var 
+  # @return [Symbol from _enum_thread_local_mode_] 
   # @scope class
-  attach_function :get_named_function, :LLVMGetNamedFunction, [OpaqueModule, :string], OpaqueValue
+  attach_function :get_thread_local_mode, :LLVMGetThreadLocalMode, [OpaqueValue], :thread_local_mode
   
   # (Not documented)
   # 
-  # @method get_first_function(m)
-  # @param [OpaqueModule] m 
-  # @return [OpaqueValue] 
+  # @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 :get_first_function, :LLVMGetFirstFunction, [OpaqueModule], OpaqueValue
+  attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [OpaqueValue, :thread_local_mode], :void
   
   # (Not documented)
   # 
-  # @method get_last_function(m)
-  # @param [OpaqueModule] m 
-  # @return [OpaqueValue] 
+  # @method is_externally_initialized(global_var)
+  # @param [OpaqueValue] global_var 
+  # @return [Integer] 
   # @scope class
-  attach_function :get_last_function, :LLVMGetLastFunction, [OpaqueModule], OpaqueValue
+  attach_function :is_externally_initialized, :LLVMIsExternallyInitialized, [OpaqueValue], :int
   
   # (Not documented)
   # 
-  # @method get_next_function(fn)
-  # @param [OpaqueValue] fn 
-  # @return [OpaqueValue] 
+  # @method set_externally_initialized(global_var, is_ext_init)
+  # @param [OpaqueValue] global_var 
+  # @param [Integer] is_ext_init 
+  # @return [nil] 
   # @scope class
-  attach_function :get_next_function, :LLVMGetNextFunction, [OpaqueValue], OpaqueValue
+  attach_function :set_externally_initialized, :LLVMSetExternallyInitialized, [OpaqueValue, :int], :void
   
-  # (Not documented)
+  # @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases
   # 
-  # @method get_previous_function(fn)
-  # @param [OpaqueValue] fn 
+  # This group contains function that operate on global alias values.
+  # 
+  # @see llvm::GlobalAlias
+  # 
+  # @{
+  # 
+  # @method add_alias(m, ty, aliasee, name)
+  # @param [OpaqueModule] m 
+  # @param [OpaqueType] ty 
+  # @param [OpaqueValue] aliasee 
+  # @param [String] name 
   # @return [OpaqueValue] 
   # @scope class
-  attach_function :get_previous_function, :LLVMGetPreviousFunction, [OpaqueValue], OpaqueValue
+  attach_function :add_alias, :LLVMAddAlias, [OpaqueModule, OpaqueType, OpaqueValue, :string], OpaqueValue
   
-  # (Not documented)
+  # Remove a function from its containing module and deletes it.
+  # 
+  # @see llvm::Function::eraseFromParent()
   # 
   # @method delete_function(fn)
   # @param [OpaqueValue] fn 
@@ -3078,7 +3601,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :delete_function, :LLVMDeleteFunction, [OpaqueValue], :void
   
-  # (Not documented)
+  # Obtain the ID number from a function instance.
+  # 
+  # @see llvm::Function::getIntrinsicID()
   # 
   # @method get_intrinsic_id(fn)
   # @param [OpaqueValue] fn 
@@ -3086,7 +3611,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_intrinsic_id, :LLVMGetIntrinsicID, [OpaqueValue], :uint
   
-  # (Not documented)
+  # Obtain the calling function of a function.
+  # 
+  # The returned value corresponds to the LLVMCallConv enumeration.
+  # 
+  # @see llvm::Function::getCallingConv()
   # 
   # @method get_function_call_conv(fn)
   # @param [OpaqueValue] fn 
@@ -3094,7 +3623,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_function_call_conv, :LLVMGetFunctionCallConv, [OpaqueValue], :uint
   
-  # (Not documented)
+  # Set the calling convention of a function.
+  # 
+  # @see llvm::Function::setCallingConv()
+  # 
+  # @param Fn Function to operate on
+  # @param CC LLVMCallConv to set calling convention to
   # 
   # @method set_function_call_conv(fn, cc)
   # @param [OpaqueValue] fn 
@@ -3103,7 +3637,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_function_call_conv, :LLVMSetFunctionCallConv, [OpaqueValue, :uint], :void
   
-  # (Not documented)
+  # Obtain the name of the garbage collector to use during code
+  # generation.
+  # 
+  # @see llvm::Function::getGC()
   # 
   # @method get_gc(fn)
   # @param [OpaqueValue] fn 
@@ -3111,7 +3648,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_gc, :LLVMGetGC, [OpaqueValue], :string
   
-  # (Not documented)
+  # Define the garbage collector to use during code generation.
+  # 
+  # @see llvm::Function::setGC()
   # 
   # @method set_gc(fn, name)
   # @param [OpaqueValue] fn 
@@ -3120,7 +3659,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_gc, :LLVMSetGC, [OpaqueValue, :string], :void
   
-  # (Not documented)
+  # Add an attribute to a function.
+  # 
+  # @see llvm::Function::addAttribute()
   # 
   # @method add_function_attr(fn, pa)
   # @param [OpaqueValue] fn 
@@ -3129,7 +3670,20 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_function_attr, :LLVMAddFunctionAttr, [OpaqueValue, :attribute], :void
   
-  # (Not documented)
+  # 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()
   # 
   # @method get_function_attr(fn)
   # @param [OpaqueValue] fn 
@@ -3137,7 +3691,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_function_attr, :LLVMGetFunctionAttr, [OpaqueValue], :attribute
   
-  # (Not documented)
+  # Remove an attribute from a function.
   # 
   # @method remove_function_attr(fn, pa)
   # @param [OpaqueValue] fn 
@@ -3146,7 +3700,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :remove_function_attr, :LLVMRemoveFunctionAttr, [OpaqueValue, :attribute], :void
   
-  # Operations on parameters
+  # Obtain the number of parameters in a function.
+  # 
+  # @see llvm::Function::arg_size()
   # 
   # @method count_params(fn)
   # @param [OpaqueValue] fn 
@@ -3154,7 +3710,15 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :count_params, :LLVMCountParams, [OpaqueValue], :uint
   
-  # (Not documented)
+  # Obtain the parameters in a function.
+  # 
+  # The takes a pointer to a pre-allocated array of LLVMValueRef that is
+  # at least LLVMCountParams() long. This array will be filled with
+  # LLVMValueRef instances which correspond to the parameters the
+  # function receives. Each LLVMValueRef corresponds to a llvm::Argument
+  # instance.
+  # 
+  # @see llvm::Function::arg_begin()
   # 
   # @method get_params(fn, params)
   # @param [OpaqueValue] fn 
@@ -3163,7 +3727,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_params, :LLVMGetParams, [OpaqueValue, :pointer], :void
   
-  # (Not documented)
+  # Obtain the parameter at the specified index.
+  # 
+  # Parameters are indexed from 0.
+  # 
+  # @see llvm::Function::arg_begin()
   # 
   # @method get_param(fn, index)
   # @param [OpaqueValue] fn 
@@ -3172,7 +3740,13 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_param, :LLVMGetParam, [OpaqueValue, :uint], OpaqueValue
   
-  # (Not documented)
+  # Obtain the function to which this argument belongs.
+  # 
+  # Unlike other functions in this group, this one takes an LLVMValueRef
+  # that corresponds to a llvm::Attribute.
+  # 
+  # The returned LLVMValueRef is the llvm::Function to which this
+  # argument belongs.
   # 
   # @method get_param_parent(inst)
   # @param [OpaqueValue] inst 
@@ -3180,7 +3754,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_param_parent, :LLVMGetParamParent, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Obtain the first parameter to a function.
+  # 
+  # @see llvm::Function::arg_begin()
   # 
   # @method get_first_param(fn)
   # @param [OpaqueValue] fn 
@@ -3188,7 +3764,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_first_param, :LLVMGetFirstParam, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Obtain the last parameter to a function.
+  # 
+  # @see llvm::Function::arg_end()
   # 
   # @method get_last_param(fn)
   # @param [OpaqueValue] fn 
@@ -3196,7 +3774,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_last_param, :LLVMGetLastParam, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Obtain the next parameter to a function.
+  # 
+  # This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is
+  # actually a wrapped iterator) and obtains the next parameter from the
+  # underlying iterator.
   # 
   # @method get_next_param(arg)
   # @param [OpaqueValue] arg 
@@ -3204,7 +3786,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_next_param, :LLVMGetNextParam, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Obtain the previous parameter to a function.
+  # 
+  # This is the opposite of LLVMGetNextParam().
   # 
   # @method get_previous_param(arg)
   # @param [OpaqueValue] arg 
@@ -3212,7 +3796,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_previous_param, :LLVMGetPreviousParam, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Add an attribute to a function argument.
+  # 
+  # @see llvm::Argument::addAttr()
   # 
   # @method add_attribute(arg, pa)
   # @param [OpaqueValue] arg 
@@ -3221,7 +3807,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_attribute, :LLVMAddAttribute, [OpaqueValue, :attribute], :void
   
-  # (Not documented)
+  # Remove an attribute from a function argument.
+  # 
+  # @see llvm::Argument::removeAttr()
   # 
   # @method remove_attribute(arg, pa)
   # @param [OpaqueValue] arg 
@@ -3230,7 +3818,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :remove_attribute, :LLVMRemoveAttribute, [OpaqueValue, :attribute], :void
   
-  # (Not documented)
+  # Get an attribute from a function argument.
   # 
   # @method get_attribute(arg)
   # @param [OpaqueValue] arg 
@@ -3238,7 +3826,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_attribute, :LLVMGetAttribute, [OpaqueValue], :attribute
   
-  # (Not documented)
+  # Set the alignment for a function parameter.
+  # 
+  # @see llvm::Argument::addAttr()
+  # @see llvm::AttrBuilder::addAlignmentAttr()
   # 
   # @method set_param_alignment(arg, align)
   # @param [OpaqueValue] arg 
@@ -3247,7 +3838,94 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_param_alignment, :LLVMSetParamAlignment, [OpaqueValue, :uint], :void
   
-  # Operations on basic blocks
+  # Obtain a MDString value from a context.
+  # 
+  # The returned instance corresponds to the llvm::MDString class.
+  # 
+  # The instance is specified by string data of a specified length. The
+  # string content is copied, so the backing memory can be freed after
+  # this function returns.
+  # 
+  # @method md_string_in_context(c, str, s_len)
+  # @param [OpaqueContext] c 
+  # @param [String] str 
+  # @param [Integer] s_len 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :md_string_in_context, :LLVMMDStringInContext, [OpaqueContext, :string, :uint], OpaqueValue
+  
+  # Obtain a MDString value from the global context.
+  # 
+  # @method md_string(str, s_len)
+  # @param [String] str 
+  # @param [Integer] s_len 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :md_string, :LLVMMDString, [:string, :uint], OpaqueValue
+  
+  # Obtain a MDNode value from a context.
+  # 
+  # The returned value corresponds to the llvm::MDNode class.
+  # 
+  # @method md_node_in_context(c, vals, count)
+  # @param [OpaqueContext] c 
+  # @param [FFI::Pointer(*ValueRef)] vals 
+  # @param [Integer] count 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :md_node_in_context, :LLVMMDNodeInContext, [OpaqueContext, :pointer, :uint], OpaqueValue
+  
+  # Obtain a MDNode value from the global context.
+  # 
+  # @method md_node(vals, count)
+  # @param [FFI::Pointer(*ValueRef)] vals 
+  # @param [Integer] count 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :md_node, :LLVMMDNode, [:pointer, :uint], OpaqueValue
+  
+  # Obtain the underlying string from a MDString value.
+  # 
+  # @param V Instance to obtain string from.
+  # @param Len Memory address which will hold length of returned string.
+  # @return String data in MDString.
+  # 
+  # @method get_md_string(v, len)
+  # @param [OpaqueValue] v 
+  # @param [FFI::Pointer(*UInt)] len 
+  # @return [String] 
+  # @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)
   # @param [OpaqueBasicBlock] bb 
@@ -3255,7 +3933,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :basic_block_as_value, :LLVMBasicBlockAsValue, [OpaqueBasicBlock], OpaqueValue
   
-  # (Not documented)
+  # Determine whether an LLVMValueRef is itself a basic block.
   # 
   # @method value_is_basic_block(val)
   # @param [OpaqueValue] val 
@@ -3263,7 +3941,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :value_is_basic_block, :LLVMValueIsBasicBlock, [OpaqueValue], :int
   
-  # (Not documented)
+  # Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
   # 
   # @method value_as_basic_block(val)
   # @param [OpaqueValue] val 
@@ -3271,7 +3949,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :value_as_basic_block, :LLVMValueAsBasicBlock, [OpaqueValue], OpaqueBasicBlock
   
-  # (Not documented)
+  # Obtain the function to which a basic block belongs.
+  # 
+  # @see llvm::BasicBlock::getParent()
   # 
   # @method get_basic_block_parent(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3279,7 +3959,14 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_basic_block_parent, :LLVMGetBasicBlockParent, [OpaqueBasicBlock], OpaqueValue
   
-  # (Not documented)
+  # Obtain the terminator instruction for a basic block.
+  # 
+  # If the basic block does not have a terminator (it is not well-formed
+  # if it doesn't), then NULL is returned.
+  # 
+  # The returned LLVMValueRef corresponds to a llvm::TerminatorInst.
+  # 
+  # @see llvm::BasicBlock::getTerminator()
   # 
   # @method get_basic_block_terminator(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3287,7 +3974,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_basic_block_terminator, :LLVMGetBasicBlockTerminator, [OpaqueBasicBlock], OpaqueValue
   
-  # (Not documented)
+  # Obtain the number of basic blocks in a function.
+  # 
+  # @param Fn Function value to operate on.
   # 
   # @method count_basic_blocks(fn)
   # @param [OpaqueValue] fn 
@@ -3295,7 +3984,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :count_basic_blocks, :LLVMCountBasicBlocks, [OpaqueValue], :uint
   
-  # (Not documented)
+  # Obtain all of the basic blocks in a function.
+  # 
+  # This operates on a function value. The BasicBlocks parameter is a
+  # pointer to a pre-allocated array of LLVMBasicBlockRef of at least
+  # LLVMCountBasicBlocks() in length. This array is populated with
+  # LLVMBasicBlockRef instances.
   # 
   # @method get_basic_blocks(fn, basic_blocks)
   # @param [OpaqueValue] fn 
@@ -3304,7 +3998,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_basic_blocks, :LLVMGetBasicBlocks, [OpaqueValue, :pointer], :void
   
-  # (Not documented)
+  # Obtain the first basic block in a function.
+  # 
+  # The returned basic block can be used as an iterator. You will likely
+  # eventually call into LLVMGetNextBasicBlock() with it.
+  # 
+  # @see llvm::Function::begin()
   # 
   # @method get_first_basic_block(fn)
   # @param [OpaqueValue] fn 
@@ -3312,7 +4011,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_first_basic_block, :LLVMGetFirstBasicBlock, [OpaqueValue], OpaqueBasicBlock
   
-  # (Not documented)
+  # Obtain the last basic block in a function.
+  # 
+  # @see llvm::Function::end()
   # 
   # @method get_last_basic_block(fn)
   # @param [OpaqueValue] fn 
@@ -3320,7 +4021,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_last_basic_block, :LLVMGetLastBasicBlock, [OpaqueValue], OpaqueBasicBlock
   
-  # (Not documented)
+  # Advance a basic block iterator.
   # 
   # @method get_next_basic_block(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3328,7 +4029,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_next_basic_block, :LLVMGetNextBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock
   
-  # (Not documented)
+  # Go backwards in a basic block iterator.
   # 
   # @method get_previous_basic_block(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3336,7 +4037,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_previous_basic_block, :LLVMGetPreviousBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock
   
-  # (Not documented)
+  # Obtain the basic block that corresponds to the entry point of a
+  # function.
+  # 
+  # @see llvm::Function::getEntryBlock()
   # 
   # @method get_entry_basic_block(fn)
   # @param [OpaqueValue] fn 
@@ -3344,7 +4048,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_entry_basic_block, :LLVMGetEntryBasicBlock, [OpaqueValue], OpaqueBasicBlock
   
-  # (Not documented)
+  # Append a basic block to the end of a function.
+  # 
+  # @see llvm::BasicBlock::Create()
   # 
   # @method append_basic_block_in_context(c, fn, name)
   # @param [OpaqueContext] c 
@@ -3354,26 +4060,36 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :append_basic_block_in_context, :LLVMAppendBasicBlockInContext, [OpaqueContext, OpaqueValue, :string], OpaqueBasicBlock
   
-  # (Not documented)
+  # Append a basic block to the end of a function using the global
+  # context.
   # 
-  # @method insert_basic_block_in_context(c, bb, name)
-  # @param [OpaqueContext] c 
-  # @param [OpaqueBasicBlock] bb 
+  # @see llvm::BasicBlock::Create()
+  # 
+  # @method append_basic_block(fn, name)
+  # @param [OpaqueValue] fn 
   # @param [String] name 
   # @return [OpaqueBasicBlock] 
   # @scope class
-  attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [OpaqueContext, OpaqueBasicBlock, :string], OpaqueBasicBlock
+  attach_function :append_basic_block, :LLVMAppendBasicBlock, [OpaqueValue, :string], OpaqueBasicBlock
   
-  # (Not documented)
+  # Insert a basic block in a function before another basic block.
   # 
-  # @method append_basic_block(fn, name)
-  # @param [OpaqueValue] fn 
+  # The function to add to is determined by the function of the
+  # passed basic block.
+  # 
+  # @see llvm::BasicBlock::Create()
+  # 
+  # @method insert_basic_block_in_context(c, bb, name)
+  # @param [OpaqueContext] c 
+  # @param [OpaqueBasicBlock] bb 
   # @param [String] name 
   # @return [OpaqueBasicBlock] 
   # @scope class
-  attach_function :append_basic_block, :LLVMAppendBasicBlock, [OpaqueValue, :string], OpaqueBasicBlock
+  attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [OpaqueContext, OpaqueBasicBlock, :string], OpaqueBasicBlock
   
-  # (Not documented)
+  # Insert a basic block in a function using the global context.
+  # 
+  # @see llvm::BasicBlock::Create()
   # 
   # @method insert_basic_block(insert_before_bb, name)
   # @param [OpaqueBasicBlock] insert_before_bb 
@@ -3382,7 +4098,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :insert_basic_block, :LLVMInsertBasicBlock, [OpaqueBasicBlock, :string], OpaqueBasicBlock
   
-  # (Not documented)
+  # Remove a basic block from a function and delete it.
+  # 
+  # This deletes the basic block from its containing function and deletes
+  # the basic block itself.
+  # 
+  # @see llvm::BasicBlock::eraseFromParent()
   # 
   # @method delete_basic_block(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3390,7 +4111,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :delete_basic_block, :LLVMDeleteBasicBlock, [OpaqueBasicBlock], :void
   
-  # (Not documented)
+  # Remove a basic block from a function.
+  # 
+  # This deletes the basic block from its containing function but keep
+  # the basic block alive.
+  # 
+  # @see llvm::BasicBlock::removeFromParent()
   # 
   # @method remove_basic_block_from_parent(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3398,7 +4124,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :remove_basic_block_from_parent, :LLVMRemoveBasicBlockFromParent, [OpaqueBasicBlock], :void
   
-  # (Not documented)
+  # Move a basic block to before another one.
+  # 
+  # @see llvm::BasicBlock::moveBefore()
   # 
   # @method move_basic_block_before(bb, move_pos)
   # @param [OpaqueBasicBlock] bb 
@@ -3407,7 +4135,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [OpaqueBasicBlock, OpaqueBasicBlock], :void
   
-  # (Not documented)
+  # Move a basic block to after another one.
+  # 
+  # @see llvm::BasicBlock::moveAfter()
   # 
   # @method move_basic_block_after(bb, move_pos)
   # @param [OpaqueBasicBlock] bb 
@@ -3416,7 +4146,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :move_basic_block_after, :LLVMMoveBasicBlockAfter, [OpaqueBasicBlock, OpaqueBasicBlock], :void
   
-  # (Not documented)
+  # Obtain the first instruction in a basic block.
+  # 
+  # The returned LLVMValueRef corresponds to a llvm::Instruction
+  # instance.
   # 
   # @method get_first_instruction(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3424,7 +4157,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_first_instruction, :LLVMGetFirstInstruction, [OpaqueBasicBlock], OpaqueValue
   
-  # (Not documented)
+  # Obtain the last instruction in a basic block.
+  # 
+  # The returned LLVMValueRef corresponds to an LLVM:Instruction.
   # 
   # @method get_last_instruction(bb)
   # @param [OpaqueBasicBlock] bb 
@@ -3432,7 +4167,36 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_last_instruction, :LLVMGetLastInstruction, [OpaqueBasicBlock], OpaqueValue
   
-  # Operations on instructions
+  # Determine whether an instruction has any metadata attached.
+  # 
+  # @method has_metadata(val)
+  # @param [OpaqueValue] val 
+  # @return [Integer] 
+  # @scope class
+  attach_function :has_metadata, :LLVMHasMetadata, [OpaqueValue], :int
+  
+  # Return metadata associated with an instruction value.
+  # 
+  # @method get_metadata(val, kind_id)
+  # @param [OpaqueValue] val 
+  # @param [Integer] kind_id 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :get_metadata, :LLVMGetMetadata, [OpaqueValue, :uint], OpaqueValue
+  
+  # Set metadata associated with an instruction value.
+  # 
+  # @method set_metadata(val, kind_id, node)
+  # @param [OpaqueValue] val 
+  # @param [Integer] kind_id 
+  # @param [OpaqueValue] node 
+  # @return [nil] 
+  # @scope class
+  attach_function :set_metadata, :LLVMSetMetadata, [OpaqueValue, :uint, OpaqueValue], :void
+  
+  # Obtain the basic block to which an instruction belongs.
+  # 
+  # @see llvm::Instruction::getParent()
   # 
   # @method get_instruction_parent(inst)
   # @param [OpaqueValue] inst 
@@ -3440,7 +4204,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_instruction_parent, :LLVMGetInstructionParent, [OpaqueValue], OpaqueBasicBlock
   
-  # (Not documented)
+  # Obtain the instruction that occurs after the one specified.
+  # 
+  # The next instruction will be from the same basic block.
+  # 
+  # If this is the last instruction in a basic block, NULL will be
+  # returned.
   # 
   # @method get_next_instruction(inst)
   # @param [OpaqueValue] inst 
@@ -3448,7 +4217,10 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_next_instruction, :LLVMGetNextInstruction, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Obtain the instruction that occurred before this one.
+  # 
+  # If the instruction is the first instruction in a basic block, NULL
+  # will be returned.
   # 
   # @method get_previous_instruction(inst)
   # @param [OpaqueValue] inst 
@@ -3456,7 +4228,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_previous_instruction, :LLVMGetPreviousInstruction, [OpaqueValue], OpaqueValue
   
-  # (Not documented)
+  # Remove and delete an instruction.
+  # 
+  # The instruction specified is removed from its containing building
+  # block and then deleted.
+  # 
+  # @see llvm::Instruction::eraseFromParent()
   # 
   # @method instruction_erase_from_parent(inst)
   # @param [OpaqueValue] inst 
@@ -3464,7 +4241,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [OpaqueValue], :void
   
-  # (Not documented)
+  # Obtain the code opcode for an individual instruction.
+  # 
+  # @see llvm::Instruction::getOpCode()
   # 
   # @method get_instruction_opcode(inst)
   # @param [OpaqueValue] inst 
@@ -3472,7 +4251,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_instruction_opcode, :LLVMGetInstructionOpcode, [OpaqueValue], :opcode
   
-  # (Not documented)
+  # Obtain the predicate of an instruction.
+  # 
+  # This is only valid for instructions that correspond to llvm::ICmpInst
+  # or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.
+  # 
+  # @see llvm::ICmpInst::getPredicate()
   # 
   # @method get_i_cmp_predicate(inst)
   # @param [OpaqueValue] inst 
@@ -3480,7 +4264,13 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_i_cmp_predicate, :LLVMGetICmpPredicate, [OpaqueValue], :int_predicate
   
-  # Operations on call sites
+  # Set the calling convention for a call instruction.
+  # 
+  # This expects an LLVMValueRef that corresponds to a llvm::CallInst or
+  # llvm::InvokeInst.
+  # 
+  # @see llvm::CallInst::setCallingConv()
+  # @see llvm::InvokeInst::setCallingConv()
   # 
   # @method set_instruction_call_conv(instr, cc)
   # @param [OpaqueValue] instr 
@@ -3489,7 +4279,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [OpaqueValue, :uint], :void
   
-  # (Not documented)
+  # Obtain the calling convention for a call instruction.
+  # 
+  # This is the opposite of LLVMSetInstructionCallConv(). Reads its
+  # usage.
+  # 
+  # @see LLVMSetInstructionCallConv()
   # 
   # @method get_instruction_call_conv(instr)
   # @param [OpaqueValue] instr 
@@ -3527,7 +4322,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_instr_param_alignment, :LLVMSetInstrParamAlignment, [OpaqueValue, :uint, :uint], :void
   
-  # Operations on call instructions (only)
+  # Obtain whether a call instruction is a tail call.
+  # 
+  # This only works on llvm::CallInst instructions.
+  # 
+  # @see llvm::CallInst::isTailCall()
   # 
   # @method is_tail_call(call_inst)
   # @param [OpaqueValue] call_inst 
@@ -3535,7 +4334,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :is_tail_call, :LLVMIsTailCall, [OpaqueValue], :int
   
-  # (Not documented)
+  # Set whether a call instruction is a tail call.
+  # 
+  # This only works on llvm::CallInst instructions.
+  # 
+  # @see llvm::CallInst::setTailCall()
   # 
   # @method set_tail_call(call_inst, is_tail_call)
   # @param [OpaqueValue] call_inst 
@@ -3544,7 +4347,11 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :set_tail_call, :LLVMSetTailCall, [OpaqueValue, :int], :void
   
-  # Operations on switch instructions (only)
+  # Obtain the default destination basic block of a switch instruction.
+  # 
+  # This only works on llvm::SwitchInst instructions.
+  # 
+  # @see llvm::SwitchInst::getDefaultDest()
   # 
   # @method get_switch_default_dest(switch_instr)
   # @param [OpaqueValue] switch_instr 
@@ -3552,7 +4359,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [OpaqueValue], OpaqueBasicBlock
   
-  # Operations on phi nodes
+  # Add an incoming value to the end of a PHI list.
   # 
   # @method add_incoming(phi_node, incoming_values, incoming_blocks, count)
   # @param [OpaqueValue] phi_node 
@@ -3563,7 +4370,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_incoming, :LLVMAddIncoming, [OpaqueValue, :pointer, :pointer, :uint], :void
   
-  # (Not documented)
+  # Obtain the number of incoming basic blocks to a PHI node.
   # 
   # @method count_incoming(phi_node)
   # @param [OpaqueValue] phi_node 
@@ -3571,7 +4378,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :count_incoming, :LLVMCountIncoming, [OpaqueValue], :uint
   
-  # (Not documented)
+  # Obtain an incoming value to a PHI node as an LLVMValueRef.
   # 
   # @method get_incoming_value(phi_node, index)
   # @param [OpaqueValue] phi_node 
@@ -3580,7 +4387,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_incoming_value, :LLVMGetIncomingValue, [OpaqueValue, :uint], OpaqueValue
   
-  # (Not documented)
+  # Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
   # 
   # @method get_incoming_block(phi_node, index)
   # @param [OpaqueValue] phi_node 
@@ -3589,8 +4396,12 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_incoming_block, :LLVMGetIncomingBlock, [OpaqueValue, :uint], OpaqueBasicBlock
   
-  # An instruction builder represents a point within a basic block, and is the
-  # exclusive means of building instructions using the C interface.
+  # @defgroup LLVMCCoreInstructionBuilder Instruction Builders
+  # 
+  # An instruction builder represents a point within a basic block and is
+  # the exclusive means of building instructions using the C interface.
+  # 
+  # @{
   # 
   # @method create_builder_in_context(c)
   # @param [OpaqueContext] c 
@@ -4313,6 +5124,23 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :build_global_string_ptr, :LLVMBuildGlobalStringPtr, [OpaqueBuilder, :string, :string], OpaqueValue
   
+  # (Not documented)
+  # 
+  # @method get_volatile(memory_access_inst)
+  # @param [OpaqueValue] memory_access_inst 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_volatile, :LLVMGetVolatile, [OpaqueValue], :int
+  
+  # (Not documented)
+  # 
+  # @method set_volatile(memory_access_inst, is_volatile)
+  # @param [OpaqueValue] memory_access_inst 
+  # @param [Integer] is_volatile 
+  # @return [nil] 
+  # @scope class
+  attach_function :set_volatile, :LLVMSetVolatile, [OpaqueValue, :int], :void
+  
   # Casts
   # 
   # @method build_trunc(opaque_builder, val, dest_ty, name)
@@ -4445,6 +5273,17 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :build_bit_cast, :LLVMBuildBitCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue
   
+  # (Not documented)
+  # 
+  # @method build_addr_space_cast(opaque_builder, val, dest_ty, name)
+  # @param [OpaqueBuilder] opaque_builder 
+  # @param [OpaqueValue] val 
+  # @param [OpaqueType] dest_ty 
+  # @param [String] name 
+  # @return [OpaqueValue] 
+  # @scope class
+  attach_function :build_addr_space_cast, :LLVMBuildAddrSpaceCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue
+  
   # (Not documented)
   # 
   # @method build_z_ext_or_bit_cast(opaque_builder, val, dest_ty, name)
@@ -4681,6 +5520,19 @@ module RLTK::CG::Bindings
   # @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.
   # 
@@ -4698,7 +5550,9 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :dispose_module_provider, :LLVMDisposeModuleProvider, [OpaqueModuleProvider], :void
   
-  # ===-- Memory buffers ----------------------------------------------------===
+  # @defgroup LLVMCCoreMemoryBuffers Memory Buffers
+  # 
+  # @{
   # 
   # @method create_memory_buffer_with_contents_of_file(path, out_mem_buf, out_message)
   # @param [String] path 
@@ -4717,6 +5571,43 @@ module RLTK::CG::Bindings
   # @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)
@@ -4726,7 +5617,7 @@ module RLTK::CG::Bindings
   attach_function :dispose_memory_buffer, :LLVMDisposeMemoryBuffer, [OpaqueMemoryBuffer], :void
   
   # Return the global pass registry, for use with initialization functions.
-  #     See llvm::PassRegistry::getPassRegistry.
+  #     @see llvm::PassRegistry::getPassRegistry
   # 
   # @method get_global_pass_registry()
   # @return [OpaquePassRegistry] 
@@ -4735,7 +5626,7 @@ module RLTK::CG::Bindings
   
   # Constructs a new whole-module pass pipeline. This type of pipeline is
   #     suitable for link-time optimization and whole-module transformations.
-  #     See llvm::PassManager::PassManager.
+  #     @see llvm::PassManager::PassManager
   # 
   # @method create_pass_manager()
   # @return [OpaquePassManager] 
@@ -4745,7 +5636,7 @@ module RLTK::CG::Bindings
   # Constructs a new function-by-function pass pipeline over the module
   #     provider. It does not take ownership of the module provider. This type of
   #     pipeline is suitable for code generation and JIT compilation tasks.
-  #     See llvm::FunctionPassManager::FunctionPassManager.
+  #     @see llvm::FunctionPassManager::FunctionPassManager
   # 
   # @method create_function_pass_manager_for_module(m)
   # @param [OpaqueModule] m 
@@ -4763,7 +5654,8 @@ module RLTK::CG::Bindings
   
   # Initializes, executes on the provided module, and finalizes all of the
   #     passes scheduled in the pass manager. Returns 1 if any of the passes
-  #     modified the module, 0 otherwise. See llvm::PassManager::run(Module&).
+  #     modified the module, 0 otherwise.
+  #     @see llvm::PassManager::run(Module&)
   # 
   # @method run_pass_manager(pm, m)
   # @param [OpaquePassManager] pm 
@@ -4774,7 +5666,7 @@ module RLTK::CG::Bindings
   
   # Initializes all of the function passes scheduled in the function pass
   #     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
-  #     See llvm::FunctionPassManager::doInitialization.
+  #     @see llvm::FunctionPassManager::doInitialization
   # 
   # @method initialize_function_pass_manager(fpm)
   # @param [OpaquePassManager] fpm 
@@ -4785,7 +5677,7 @@ module RLTK::CG::Bindings
   # Executes all of the function passes scheduled in the function pass manager
   #     on the provided function. Returns 1 if any of the passes modified the
   #     function, false otherwise.
-  #     See llvm::FunctionPassManager::run(Function&).
+  #     @see llvm::FunctionPassManager::run(Function&)
   # 
   # @method run_function_pass_manager(fpm, f)
   # @param [OpaquePassManager] fpm 
@@ -4796,7 +5688,7 @@ module RLTK::CG::Bindings
   
   # Finalizes all of the function passes scheduled in in the function pass
   #     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
-  #     See llvm::FunctionPassManager::doFinalization.
+  #     @see llvm::FunctionPassManager::doFinalization
   # 
   # @method finalize_function_pass_manager(fpm)
   # @param [OpaquePassManager] fpm 
@@ -4806,7 +5698,7 @@ module RLTK::CG::Bindings
   
   # Frees the memory of a pass pipeline. For function pipelines, does not free
   #     the module provider.
-  #     See llvm::PassManagerBase::~PassManagerBase.
+  #     @see llvm::PassManagerBase::~PassManagerBase.
   # 
   # @method dispose_pass_manager(pm)
   # @param [OpaquePassManager] pm 
@@ -4814,6 +5706,34 @@ module RLTK::CG::Bindings
   # @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
+  
   # (Not documented)
   # 
   # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:verifier_failure_action).</em>
@@ -4980,7 +5900,7 @@ module RLTK::CG::Bindings
   # instruction are specified by the Offset parameter and its byte widith is the
   # size parameter.  For instructions sets with fixed widths and one symbolic
   # operand per instruction, the Offset parameter will be zero and Size parameter
-  # will be the instruction width.  The information is returned in TagBuf and is 
+  # will be the instruction width.  The information is returned in TagBuf and is
   # Triple specific with its specific information defined by the value of
   # TagType for that Triple.  If symbolic information is returned the function
   # returns 1, otherwise it returns 0.
@@ -5073,7 +5993,8 @@ module RLTK::CG::Bindings
   # by passing a block of information in the DisInfo parameter and specifying the
   # TagType and callback functions as described above.  These can all be passed
   # as NULL.  If successful, this returns a disassembler context.  If not, it
-  # returns NULL.
+  # returns NULL. This function is equivalent to calling LLVMCreateDisasmCPU()
+  # with an empty CPU name.
   # 
   # @method create_disasm(triple_name, dis_info, tag_type, get_op_info, symbol_look_up)
   # @param [String] triple_name 
@@ -5085,6 +6006,33 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :create_disasm, :LLVMCreateDisasm, [:string, :pointer, :int, :op_info_callback, :symbol_lookup_callback], :pointer
   
+  # Create a disassembler for the TripleName and a specific CPU.  Symbolic
+  # disassembly is supported by passing a block of information in the DisInfo
+  # parameter and specifying the TagType and callback functions as described
+  # above.  These can all be passed * as NULL.  If successful, this returns a
+  # disassembler context.  If not, it returns NULL.
+  # 
+  # @method create_disasm_cpu(triple, cpu, dis_info, tag_type, get_op_info, symbol_look_up)
+  # @param [String] triple 
+  # @param [String] cpu 
+  # @param [FFI::Pointer(*Void)] dis_info 
+  # @param [Integer] tag_type 
+  # @param [Proc(_callback_op_info_callback_)] get_op_info 
+  # @param [Proc(_callback_symbol_lookup_callback_)] symbol_look_up 
+  # @return [FFI::Pointer(DisasmContextRef)] 
+  # @scope class
+  attach_function :create_disasm_cpu, :LLVMCreateDisasmCPU, [:string, :string, :pointer, :int, :op_info_callback, :symbol_lookup_callback], :pointer
+  
+  # Set the disassembler's options.  Returns 1 if it can set the Options and 0
+  # otherwise.
+  # 
+  # @method set_disasm_options(dc, options)
+  # @param [FFI::Pointer(DisasmContextRef)] dc 
+  # @param [Integer] options 
+  # @return [Integer] 
+  # @scope class
+  attach_function :set_disasm_options, :LLVMSetDisasmOptions, [:pointer, :ulong], :int
+  
   # Dispose of a disassembler context.
   # 
   # @method disasm_dispose(dc)
@@ -5102,10 +6050,16 @@ module RLTK::CG::Bindings
   # function returns the number of bytes in the instruction or zero if there was
   # no valid instruction.
   # 
-  # @method disasm_instruction()
+  # @method disasm_instruction(dc, bytes, bytes_size, pc, out_string, out_string_size)
+  # @param [FFI::Pointer(DisasmContextRef)] dc 
+  # @param [FFI::Pointer(*Uint8T)] bytes 
+  # @param [Integer] bytes_size 
+  # @param [Integer] pc 
+  # @param [String] out_string 
+  # @param [Integer] out_string_size 
   # @return [Integer] 
   # @scope class
-  attach_function :disasm_instruction, :LLVMDisasmInstruction, [], :int
+  attach_function :disasm_instruction, :LLVMDisasmInstruction, [:pointer, :pointer, :ulong, :ulong, :string, :ulong], :ulong
   
   # (Not documented)
   # 
@@ -5135,11 +6089,6 @@ module RLTK::CG::Bindings
     layout :dummy, :char
   end
   
-  # (Not documented)
-  class StructLayout < FFI::Struct
-    layout :dummy, :char
-  end
-  
   # (Not documented)
   # 
   # @method initialize_all_target_infos()
@@ -5156,8 +6105,44 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void
   
-  # LLVMInitializeNativeTarget - The main program should call this function to
-  #     initialize the native target corresponding to the host.  This is useful 
+  # LLVMInitializeAllTargetMCs - The main program should call this function if
+  #     it wants access to all available target MC that LLVM is configured to
+  #     support.
+  # 
+  # @method initialize_all_target_m_cs()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_all_target_mcs, :LLVMInitializeAllTargetMCs, [], :void
+  
+  # LLVMInitializeAllAsmPrinters - The main program should call this function if
+  #     it wants all asm printers that LLVM is configured to support, to make them
+  #     available via the TargetRegistry.
+  # 
+  # @method initialize_all_asm_printers()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void
+  
+  # LLVMInitializeAllAsmParsers - The main program should call this function if
+  #     it wants all asm parsers that LLVM is configured to support, to make them
+  #     available via the TargetRegistry.
+  # 
+  # @method initialize_all_asm_parsers()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void
+  
+  # LLVMInitializeAllDisassemblers - The main program should call this function
+  #     if it wants all disassemblers that LLVM is configured to support, to make
+  #     them available via the TargetRegistry.
+  # 
+  # @method initialize_all_disassemblers()
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void
+  
+  # LLVMInitializeNativeTarget - The main program should call this function to
+  #     initialize the native target corresponding to the host.  This is useful
   #     for JIT applications to ensure that the target gets linked in correctly.
   # 
   # @method initialize_native_target()
@@ -5165,8 +6150,35 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int
   
+  # LLVMInitializeNativeTargetAsmParser - The main program should call this
+  #     function to initialize the parser for the native target corresponding to the
+  #     host.
+  # 
+  # @method initialize_native_asm_parser()
+  # @return [Integer] 
+  # @scope class
+  attach_function :initialize_native_asm_parser, :LLVMInitializeNativeAsmParser, [], :int
+  
+  # LLVMInitializeNativeTargetAsmPrinter - The main program should call this
+  #     function to initialize the printer for the native target corresponding to
+  #     the host.
+  # 
+  # @method initialize_native_asm_printer()
+  # @return [Integer] 
+  # @scope class
+  attach_function :initialize_native_asm_printer, :LLVMInitializeNativeAsmPrinter, [], :int
+  
+  # LLVMInitializeNativeTargetDisassembler - The main program should call this
+  #     function to initialize the disassembler for the native target corresponding
+  #     to the host.
+  # 
+  # @method initialize_native_disassembler()
+  # @return [Integer] 
+  # @scope class
+  attach_function :initialize_native_disassembler, :LLVMInitializeNativeDisassembler, [], :int
+  
   # Creates target data from a target layout string.
-  #     See the constructor llvm::TargetData::TargetData.
+  #     See the constructor llvm::DataLayout::DataLayout.
   # 
   # @method create_target_data(string_rep)
   # @param [String] string_rep 
@@ -5178,9 +6190,9 @@ module RLTK::CG::Bindings
   #     of the target data.
   #     See the method llvm::PassManagerBase::add.
   # 
-  # @method add_target_data(opaque_target_data, opaque_pass_manager)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaquePassManager] opaque_pass_manager 
+  # @method add_target_data(td, pm)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaquePassManager] pm 
   # @return [nil] 
   # @scope class
   attach_function :add_target_data, :LLVMAddTargetData, [OpaqueTargetData, OpaquePassManager], :void
@@ -5189,116 +6201,160 @@ module RLTK::CG::Bindings
   #     ownership of the target library info.
   #     See the method llvm::PassManagerBase::add.
   # 
-  # @method add_target_library_info(opaque_target_library_infot_data, opaque_pass_manager)
-  # @param [OpaqueTargetLibraryInfotData] opaque_target_library_infot_data 
-  # @param [OpaquePassManager] opaque_pass_manager 
+  # @method add_target_library_info(tli, pm)
+  # @param [OpaqueTargetLibraryInfotData] tli 
+  # @param [OpaquePassManager] pm 
   # @return [nil] 
   # @scope class
   attach_function :add_target_library_info, :LLVMAddTargetLibraryInfo, [OpaqueTargetLibraryInfotData, OpaquePassManager], :void
   
   # Converts target data to a target layout string. The string must be disposed
   #     with LLVMDisposeMessage.
-  #     See the constructor llvm::TargetData::TargetData.
+  #     See the constructor llvm::DataLayout::DataLayout.
   # 
-  # @method copy_string_rep_of_target_data(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method copy_string_rep_of_target_data(td)
+  # @param [OpaqueTargetData] td 
   # @return [String] 
   # @scope class
   attach_function :copy_string_rep_of_target_data, :LLVMCopyStringRepOfTargetData, [OpaqueTargetData], :string
   
   # Returns the byte order of a target, either LLVMBigEndian or
   #     LLVMLittleEndian.
-  #     See the method llvm::TargetData::isLittleEndian.
+  #     See the method llvm::DataLayout::isLittleEndian.
   # 
-  # @method byte_order(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method byte_order(td)
+  # @param [OpaqueTargetData] td 
   # @return [Symbol from _enum_byte_ordering_] 
   # @scope class
   attach_function :byte_order, :LLVMByteOrder, [OpaqueTargetData], :byte_ordering
   
   # Returns the pointer size in bytes for a target.
-  #     See the method llvm::TargetData::getPointerSize.
+  #     See the method llvm::DataLayout::getPointerSize.
   # 
-  # @method pointer_size(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method pointer_size(td)
+  # @param [OpaqueTargetData] td 
   # @return [Integer] 
   # @scope class
   attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint
   
+  # Returns the pointer size in bytes for a target for a specified
+  #     address space.
+  #     See the method llvm::DataLayout::getPointerSize.
+  # 
+  # @method pointer_size_for_as(td, as)
+  # @param [OpaqueTargetData] td 
+  # @param [Integer] as 
+  # @return [Integer] 
+  # @scope class
+  attach_function :pointer_size_for_as, :LLVMPointerSizeForAS, [OpaqueTargetData, :uint], :uint
+  
   # Returns the integer type that is the same size as a pointer on a target.
-  #     See the method llvm::TargetData::getIntPtrType.
+  #     See the method llvm::DataLayout::getIntPtrType.
   # 
-  # @method int_ptr_type(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method int_ptr_type(td)
+  # @param [OpaqueTargetData] td 
   # @return [OpaqueType] 
   # @scope class
   attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], OpaqueType
   
+  # Returns the integer type that is the same size as a pointer on a target.
+  #     This version allows the address space to be specified.
+  #     See the method llvm::DataLayout::getIntPtrType.
+  # 
+  # @method int_ptr_type_for_as(td, as)
+  # @param [OpaqueTargetData] td 
+  # @param [Integer] as 
+  # @return [OpaqueType] 
+  # @scope class
+  attach_function :int_ptr_type_for_as, :LLVMIntPtrTypeForAS, [OpaqueTargetData, :uint], OpaqueType
+  
+  # Returns the integer type that is the same size as a pointer on a target.
+  #     See the method llvm::DataLayout::getIntPtrType.
+  # 
+  # @method int_ptr_type_in_context(c, td)
+  # @param [OpaqueContext] c 
+  # @param [OpaqueTargetData] td 
+  # @return [OpaqueType] 
+  # @scope class
+  attach_function :int_ptr_type_in_context, :LLVMIntPtrTypeInContext, [OpaqueContext, OpaqueTargetData], OpaqueType
+  
+  # Returns the integer type that is the same size as a pointer on a target.
+  #     This version allows the address space to be specified.
+  #     See the method llvm::DataLayout::getIntPtrType.
+  # 
+  # @method int_ptr_type_for_as_in_context(c, td, as)
+  # @param [OpaqueContext] c 
+  # @param [OpaqueTargetData] td 
+  # @param [Integer] as 
+  # @return [OpaqueType] 
+  # @scope class
+  attach_function :int_ptr_type_for_as_in_context, :LLVMIntPtrTypeForASInContext, [OpaqueContext, OpaqueTargetData, :uint], OpaqueType
+  
   # Computes the size of a type in bytes for a target.
-  #     See the method llvm::TargetData::getTypeSizeInBits.
+  #     See the method llvm::DataLayout::getTypeSizeInBits.
   # 
-  # @method size_of_type_in_bits(opaque_target_data, opaque_type)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaqueType] opaque_type 
+  # @method size_of_type_in_bits(td, ty)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaqueType] ty 
   # @return [Integer] 
   # @scope class
   attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, OpaqueType], :ulong_long
   
   # Computes the storage size of a type in bytes for a target.
-  #     See the method llvm::TargetData::getTypeStoreSize.
+  #     See the method llvm::DataLayout::getTypeStoreSize.
   # 
-  # @method store_size_of_type(opaque_target_data, opaque_type)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaqueType] opaque_type 
+  # @method store_size_of_type(td, ty)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaqueType] ty 
   # @return [Integer] 
   # @scope class
   attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, OpaqueType], :ulong_long
   
   # Computes the ABI size of a type in bytes for a target.
-  #     See the method llvm::TargetData::getTypeAllocSize.
+  #     See the method llvm::DataLayout::getTypeAllocSize.
   # 
-  # @method abi_size_of_type(opaque_target_data, opaque_type)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaqueType] opaque_type 
+  # @method abi_size_of_type(td, ty)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaqueType] ty 
   # @return [Integer] 
   # @scope class
   attach_function :abi_size_of_type, :LLVMABISizeOfType, [OpaqueTargetData, OpaqueType], :ulong_long
   
   # Computes the ABI alignment of a type in bytes for a target.
-  #     See the method llvm::TargetData::getTypeABISize.
+  #     See the method llvm::DataLayout::getTypeABISize.
   # 
-  # @method abi_alignment_of_type(opaque_target_data, opaque_type)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaqueType] opaque_type 
+  # @method abi_alignment_of_type(td, ty)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaqueType] ty 
   # @return [Integer] 
   # @scope class
   attach_function :abi_alignment_of_type, :LLVMABIAlignmentOfType, [OpaqueTargetData, OpaqueType], :uint
   
   # Computes the call frame alignment of a type in bytes for a target.
-  #     See the method llvm::TargetData::getTypeABISize.
+  #     See the method llvm::DataLayout::getTypeABISize.
   # 
-  # @method call_frame_alignment_of_type(opaque_target_data, opaque_type)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaqueType] opaque_type 
+  # @method call_frame_alignment_of_type(td, ty)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaqueType] ty 
   # @return [Integer] 
   # @scope class
   attach_function :call_frame_alignment_of_type, :LLVMCallFrameAlignmentOfType, [OpaqueTargetData, OpaqueType], :uint
   
   # Computes the preferred alignment of a type in bytes for a target.
-  #     See the method llvm::TargetData::getTypeABISize.
+  #     See the method llvm::DataLayout::getTypeABISize.
   # 
-  # @method preferred_alignment_of_type(opaque_target_data, opaque_type)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [OpaqueType] opaque_type 
+  # @method preferred_alignment_of_type(td, ty)
+  # @param [OpaqueTargetData] td 
+  # @param [OpaqueType] ty 
   # @return [Integer] 
   # @scope class
   attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, OpaqueType], :uint
   
   # Computes the preferred alignment of a global variable in bytes for a target.
-  #     See the method llvm::TargetData::getPreferredAlignment.
+  #     See the method llvm::DataLayout::getPreferredAlignment.
   # 
-  # @method preferred_alignment_of_global(opaque_target_data, global_var)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method preferred_alignment_of_global(td, global_var)
+  # @param [OpaqueTargetData] td 
   # @param [OpaqueValue] global_var 
   # @return [Integer] 
   # @scope class
@@ -5307,8 +6363,8 @@ module RLTK::CG::Bindings
   # Computes the structure element that contains the byte offset for a target.
   #     See the method llvm::StructLayout::getElementContainingOffset.
   # 
-  # @method element_at_offset(opaque_target_data, struct_ty, offset)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method element_at_offset(td, struct_ty, offset)
+  # @param [OpaqueTargetData] td 
   # @param [OpaqueType] struct_ty 
   # @param [Integer] offset 
   # @return [Integer] 
@@ -5318,8 +6374,8 @@ module RLTK::CG::Bindings
   # Computes the byte offset of the indexed struct element for a target.
   #     See the method llvm::StructLayout::getElementContainingOffset.
   # 
-  # @method offset_of_element(opaque_target_data, struct_ty, element)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method offset_of_element(td, struct_ty, element)
+  # @param [OpaqueTargetData] td 
   # @param [OpaqueType] struct_ty 
   # @param [Integer] element 
   # @return [Integer] 
@@ -5327,14 +6383,323 @@ module RLTK::CG::Bindings
   attach_function :offset_of_element, :LLVMOffsetOfElement, [OpaqueTargetData, OpaqueType, :uint], :ulong_long
   
   # Deallocates a TargetData.
-  #     See the destructor llvm::TargetData::~TargetData.
+  #     See the destructor llvm::DataLayout::~DataLayout.
   # 
-  # @method dispose_target_data(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
+  # @method dispose_target_data(td)
+  # @param [OpaqueTargetData] td 
   # @return [nil] 
   # @scope class
   attach_function :dispose_target_data, :LLVMDisposeTargetData, [OpaqueTargetData], :void
   
+  # (Not documented)
+  class OpaqueTargetMachine < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # (Not documented)
+  module TargetWrappers
+    def has_jit()
+      RLTK::CG::Bindings.target_has_jit(self)
+    end
+    
+    def has_target_machine()
+      RLTK::CG::Bindings.target_has_target_machine(self)
+    end
+    
+    def has_asm_backend()
+      RLTK::CG::Bindings.target_has_asm_backend(self)
+    end
+  end
+  
+  class Target < FFI::Struct
+    include TargetWrappers
+    layout :dummy, :char
+  end
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_gen_opt_level).</em>
+  # 
+  # === Options:
+  # :none ::
+  #   
+  # :less ::
+  #   
+  # :default ::
+  #   
+  # :aggressive ::
+  #   
+  # 
+  # @method _enum_code_gen_opt_level_
+  # @return [Symbol]
+  # @scope class
+  enum :code_gen_opt_level, [
+    :none, 0,
+    :less, 1,
+    :default, 2,
+    :aggressive, 3
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:reloc_mode).</em>
+  # 
+  # === Options:
+  # :default ::
+  #   
+  # :static ::
+  #   
+  # :pic ::
+  #   
+  # :dynamic_no_pic ::
+  #   
+  # 
+  # @method _enum_reloc_mode_
+  # @return [Symbol]
+  # @scope class
+  enum :reloc_mode, [
+    :default, 0,
+    :static, 1,
+    :pic, 2,
+    :dynamic_no_pic, 3
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_model).</em>
+  # 
+  # === Options:
+  # :default ::
+  #   
+  # :jit_default ::
+  #   
+  # :small ::
+  #   
+  # :kernel ::
+  #   
+  # :medium ::
+  #   
+  # :large ::
+  #   
+  # 
+  # @method _enum_code_model_
+  # @return [Symbol]
+  # @scope class
+  enum :code_model, [
+    :default, 0,
+    :jit_default, 1,
+    :small, 2,
+    :kernel, 3,
+    :medium, 4,
+    :large, 5
+  ]
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_gen_file_type).</em>
+  # 
+  # === Options:
+  # :assembly ::
+  #   
+  # :object ::
+  #   
+  # 
+  # @method _enum_code_gen_file_type_
+  # @return [Symbol]
+  # @scope class
+  enum :code_gen_file_type, [
+    :assembly, 0,
+    :object, 1
+  ]
+  
+  # Returns the first llvm::Target in the registered targets list.
+  # 
+  # @method get_first_target()
+  # @return [Target] 
+  # @scope class
+  attach_function :get_first_target, :LLVMGetFirstTarget, [], Target
+  
+  # Returns the next llvm::Target given a previous one (or null if there's none)
+  # 
+  # @method get_next_target(t)
+  # @param [Target] t 
+  # @return [Target] 
+  # @scope class
+  attach_function :get_next_target, :LLVMGetNextTarget, [Target], Target
+  
+  # Finds the target corresponding to the given name and stores it in \p T. 
+  #   Returns 0 on success.
+  # 
+  # @method get_target_from_name(name)
+  # @param [String] name 
+  # @return [Target] 
+  # @scope class
+  attach_function :get_target_from_name, :LLVMGetTargetFromName, [:string], Target
+  
+  # Finds the target corresponding to the given triple and stores it in \p T.
+  #   Returns 0 on success. Optionally returns any error in ErrorMessage.
+  #   Use LLVMDisposeMessage to dispose the message.
+  # 
+  # @method get_target_from_triple(triple, t, error_message)
+  # @param [String] triple 
+  # @param [FFI::Pointer(*TargetRef)] t 
+  # @param [FFI::Pointer(**CharS)] error_message 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_target_from_triple, :LLVMGetTargetFromTriple, [:string, :pointer, :pointer], :int
+  
+  # Returns the name of a target. See llvm::Target::getName
+  # 
+  # @method get_target_name(t)
+  # @param [Target] t 
+  # @return [String] 
+  # @scope class
+  attach_function :get_target_name, :LLVMGetTargetName, [Target], :string
+  
+  # Returns the description  of a target. See llvm::Target::getDescription
+  # 
+  # @method get_target_description(t)
+  # @param [Target] t 
+  # @return [String] 
+  # @scope class
+  attach_function :get_target_description, :LLVMGetTargetDescription, [Target], :string
+  
+  # Returns if the target has a JIT
+  # 
+  # @method target_has_jit(t)
+  # @param [Target] t 
+  # @return [Integer] 
+  # @scope class
+  attach_function :target_has_jit, :LLVMTargetHasJIT, [Target], :int
+  
+  # Returns if the target has a TargetMachine associated
+  # 
+  # @method target_has_target_machine(t)
+  # @param [Target] t 
+  # @return [Integer] 
+  # @scope class
+  attach_function :target_has_target_machine, :LLVMTargetHasTargetMachine, [Target], :int
+  
+  # Returns if the target as an ASM backend (required for emitting output)
+  # 
+  # @method target_has_asm_backend(t)
+  # @param [Target] t 
+  # @return [Integer] 
+  # @scope class
+  attach_function :target_has_asm_backend, :LLVMTargetHasAsmBackend, [Target], :int
+  
+  # Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine
+  # 
+  # @method create_target_machine(t, triple, cpu, features, level, reloc, code_model)
+  # @param [Target] t 
+  # @param [String] triple 
+  # @param [String] cpu 
+  # @param [String] features 
+  # @param [Symbol from _enum_code_gen_opt_level_] level 
+  # @param [Symbol from _enum_reloc_mode_] reloc 
+  # @param [Symbol from _enum_code_model_] code_model 
+  # @return [OpaqueTargetMachine] 
+  # @scope class
+  attach_function :create_target_machine, :LLVMCreateTargetMachine, [Target, :string, :string, :string, :code_gen_opt_level, :reloc_mode, :code_model], OpaqueTargetMachine
+  
+  # Dispose the LLVMTargetMachineRef instance generated by
+  #   LLVMCreateTargetMachine.
+  # 
+  # @method dispose_target_machine(t)
+  # @param [OpaqueTargetMachine] t 
+  # @return [nil] 
+  # @scope class
+  attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [OpaqueTargetMachine], :void
+  
+  # Returns the Target used in a TargetMachine
+  # 
+  # @method get_target_machine_target(t)
+  # @param [OpaqueTargetMachine] t 
+  # @return [Target] 
+  # @scope class
+  attach_function :get_target_machine_target, :LLVMGetTargetMachineTarget, [OpaqueTargetMachine], Target
+  
+  # Returns the triple used creating this target machine. See
+  #   llvm::TargetMachine::getTriple. The result needs to be disposed with
+  #   LLVMDisposeMessage.
+  # 
+  # @method get_target_machine_triple(t)
+  # @param [OpaqueTargetMachine] t 
+  # @return [String] 
+  # @scope class
+  attach_function :get_target_machine_triple, :LLVMGetTargetMachineTriple, [OpaqueTargetMachine], :string
+  
+  # Returns the cpu used creating this target machine. See
+  #   llvm::TargetMachine::getCPU. The result needs to be disposed with
+  #   LLVMDisposeMessage.
+  # 
+  # @method get_target_machine_cpu(t)
+  # @param [OpaqueTargetMachine] t 
+  # @return [String] 
+  # @scope class
+  attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [OpaqueTargetMachine], :string
+  
+  # Returns the feature string used creating this target machine. See
+  #   llvm::TargetMachine::getFeatureString. The result needs to be disposed with
+  #   LLVMDisposeMessage.
+  # 
+  # @method get_target_machine_feature_string(t)
+  # @param [OpaqueTargetMachine] t 
+  # @return [String] 
+  # @scope class
+  attach_function :get_target_machine_feature_string, :LLVMGetTargetMachineFeatureString, [OpaqueTargetMachine], :string
+  
+  # Returns the llvm::DataLayout used for this llvm:TargetMachine.
+  # 
+  # @method get_target_machine_data(t)
+  # @param [OpaqueTargetMachine] t 
+  # @return [OpaqueTargetData] 
+  # @scope class
+  attach_function :get_target_machine_data, :LLVMGetTargetMachineData, [OpaqueTargetMachine], OpaqueTargetData
+  
+  # Set the target machine's ASM verbosity.
+  # 
+  # @method set_target_machine_asm_verbosity(t, verbose_asm)
+  # @param [OpaqueTargetMachine] t 
+  # @param [Integer] verbose_asm 
+  # @return [nil] 
+  # @scope class
+  attach_function :set_target_machine_asm_verbosity, :LLVMSetTargetMachineAsmVerbosity, [OpaqueTargetMachine, :int], :void
+  
+  # Emits an asm or object file for the given module to the filename. This
+  #   wraps several c++ only classes (among them a file stream). Returns any
+  #   error in ErrorMessage. Use LLVMDisposeMessage to dispose the message.
+  # 
+  # @method target_machine_emit_to_file(t, m, filename, codegen, error_message)
+  # @param [OpaqueTargetMachine] t 
+  # @param [OpaqueModule] m 
+  # @param [String] filename 
+  # @param [Symbol from _enum_code_gen_file_type_] codegen 
+  # @param [FFI::Pointer(**CharS)] error_message 
+  # @return [Integer] 
+  # @scope class
+  attach_function :target_machine_emit_to_file, :LLVMTargetMachineEmitToFile, [OpaqueTargetMachine, OpaqueModule, :string, :code_gen_file_type, :pointer], :int
+  
+  # Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf.
+  # 
+  # @method target_machine_emit_to_memory_buffer(t, m, codegen, error_message, out_mem_buf)
+  # @param [OpaqueTargetMachine] t 
+  # @param [OpaqueModule] m 
+  # @param [Symbol from _enum_code_gen_file_type_] codegen 
+  # @param [FFI::Pointer(**CharS)] error_message 
+  # @param [FFI::Pointer(*MemoryBufferRef)] out_mem_buf 
+  # @return [Integer] 
+  # @scope class
+  attach_function :target_machine_emit_to_memory_buffer, :LLVMTargetMachineEmitToMemoryBuffer, [OpaqueTargetMachine, OpaqueModule, :code_gen_file_type, :pointer, :pointer], :int
+  
+  # Get a triple for the host machine as a string. The result needs to be
+  #   disposed with LLVMDisposeMessage.
+  # 
+  # @method get_default_target_triple()
+  # @return [String] 
+  # @scope class
+  attach_function :get_default_target_triple, :LLVMGetDefaultTargetTriple, [], :string
+  
   # (Not documented)
   # 
   # @method link_in_jit()
@@ -5342,6 +6707,13 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :link_in_jit, :LLVMLinkInJIT, [], :void
   
+  # (Not documented)
+  # 
+  # @method link_in_mcjit()
+  # @return [nil] 
+  # @scope class
+  attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void
+  
   # (Not documented)
   # 
   # @method link_in_interpreter()
@@ -5359,6 +6731,32 @@ module RLTK::CG::Bindings
     layout :dummy, :char
   end
   
+  # (Not documented)
+  class OpaqueMCJITMemoryManager < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # (Not documented)
+  # 
+  # = Fields:
+  # :opt_level ::
+  #   (Integer) 
+  # :code_model ::
+  #   (Symbol from _enum_code_model_) 
+  # :no_frame_pointer_elim ::
+  #   (Integer) 
+  # :enable_fast_i_sel ::
+  #   (Integer) 
+  # :mcjmm ::
+  #   (OpaqueMCJITMemoryManager) 
+  class MCJITCompilerOptions < FFI::Struct
+    layout :opt_level, :uint,
+           :code_model, :code_model,
+           :no_frame_pointer_elim, :int,
+           :enable_fast_i_sel, :int,
+           :mcjmm, OpaqueMCJITMemoryManager
+  end
+  
   # ===-- Operations on generic values --------------------------------------===
   # 
   # @method create_generic_value_of_int(ty, n, is_signed)
@@ -5459,6 +6857,41 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, OpaqueModule, :uint, :pointer], :int
   
+  # (Not documented)
+  # 
+  # @method initialize_mcjit_compiler_options(options, size_of_options)
+  # @param [MCJITCompilerOptions] options 
+  # @param [Integer] size_of_options 
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void
+  
+  # Create an MCJIT execution engine for a module, with the given options. It is
+  # the responsibility of the caller to ensure that all fields in Options up to
+  # the given SizeOfOptions are initialized. It is correct to pass a smaller
+  # value of SizeOfOptions that omits some fields. The canonical way of using
+  # this is:
+  # 
+  # LLVMMCJITCompilerOptions options;
+  # LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
+  # ... fill in those options you care about
+  # LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
+  #                                  &error);
+  # 
+  # Note that this is also correct, though possibly suboptimal:
+  # 
+  # LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
+  # 
+  # @method create_mcjit_compiler_for_module(out_jit, m, options, size_of_options, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit 
+  # @param [OpaqueModule] m 
+  # @param [MCJITCompilerOptions] options 
+  # @param [Integer] size_of_options 
+  # @param [FFI::Pointer(**CharS)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_mcjit_compiler_for_module, :LLVMCreateMCJITCompilerForModule, [:pointer, OpaqueModule, MCJITCompilerOptions, :ulong, :pointer], :int
+  
   # Deprecated: Use LLVMCreateExecutionEngineForModule instead.
   # 
   # @method create_execution_engine(out_ee, mp, out_error)
@@ -5632,29 +7065,113 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, OpaqueValue], :pointer
   
+  # ===-- Operations on memory managers -------------------------------------===
+  # 
+  # <em>This entry is only for documentation and no real method.</em>
+  # 
+  # @method _callback_memory_manager_allocate_code_section_callback_(opaque, size, alignment, section_id, section_name)
+  # @param [FFI::Pointer(*Void)] opaque 
+  # @param [Integer] size 
+  # @param [Integer] alignment 
+  # @param [Integer] section_id 
+  # @param [String] section_name 
+  # @return [Integer] 
+  # @scope class
+  callback :memory_manager_allocate_code_section_callback, [:pointer, :ulong, :uint, :uint, :string], :uchar
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method.</em>
+  # 
+  # @method _callback_memory_manager_allocate_data_section_callback_(opaque, size, alignment, section_id, section_name, is_read_only)
+  # @param [FFI::Pointer(*Void)] opaque 
+  # @param [Integer] size 
+  # @param [Integer] alignment 
+  # @param [Integer] section_id 
+  # @param [String] section_name 
+  # @param [Integer] is_read_only 
+  # @return [Integer] 
+  # @scope class
+  callback :memory_manager_allocate_data_section_callback, [:pointer, :ulong, :uint, :uint, :string, :int], :uchar
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method.</em>
+  # 
+  # @method _callback_memory_manager_finalize_memory_callback_(opaque, err_msg)
+  # @param [FFI::Pointer(*Void)] opaque 
+  # @param [FFI::Pointer(**CharS)] err_msg 
+  # @return [Integer] 
+  # @scope class
+  callback :memory_manager_finalize_memory_callback, [:pointer, :pointer], :int
+  
+  # Create a simple custom MCJIT memory manager. This memory manager can
+  # intercept allocations in a module-oblivious way. This will return NULL
+  # if any of the passed functions are NULL.
+  # 
+  # @param Opaque An opaque client object to pass back to the callbacks.
+  # @param AllocateCodeSection Allocate a block of memory for executable code.
+  # @param AllocateDataSection Allocate a block of memory for data.
+  # @param FinalizeMemory Set page permissions and flush cache. Return 0 on
+  #   success, 1 on error.
+  # 
+  # @method create_simple_mcjit_memory_manager(opaque, allocate_code_section, allocate_data_section, finalize_memory, destroy)
+  # @param [FFI::Pointer(*Void)] opaque 
+  # @param [Proc(_callback_memory_manager_allocate_code_section_callback_)] allocate_code_section 
+  # @param [Proc(_callback_memory_manager_allocate_data_section_callback_)] allocate_data_section 
+  # @param [Proc(_callback_memory_manager_finalize_memory_callback_)] finalize_memory 
+  # @param [FFI::Pointer(MemoryManagerDestroyCallback)] destroy 
+  # @return [OpaqueMCJITMemoryManager] 
+  # @scope class
+  attach_function :create_simple_mcjit_memory_manager, :LLVMCreateSimpleMCJITMemoryManager, [:pointer, :memory_manager_allocate_code_section_callback, :memory_manager_allocate_data_section_callback, :memory_manager_finalize_memory_callback, :pointer], OpaqueMCJITMemoryManager
+  
+  # (Not documented)
+  # 
+  # @method dispose_mcjit_memory_manager(mm)
+  # @param [OpaqueMCJITMemoryManager] mm 
+  # @return [nil] 
+  # @scope class
+  attach_function :dispose_mcjit_memory_manager, :LLVMDisposeMCJITMemoryManager, [OpaqueMCJITMemoryManager], :void
+  
   # (Not documented)
   # 
   # @method initialize_core(r)
   # @param [OpaquePassRegistry] r 
   # @return [nil] 
   # @scope class
-  attach_function :initialize_core, :LLVMInitializeCore, [OpaquePassRegistry], :void
+  attach_function :initialize_core, :LLVMInitializeCore, [OpaquePassRegistry], :void
+  
+  # (Not documented)
+  # 
+  # @method initialize_transform_utils(r)
+  # @param [OpaquePassRegistry] r 
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_transform_utils, :LLVMInitializeTransformUtils, [OpaquePassRegistry], :void
+  
+  # (Not documented)
+  # 
+  # @method initialize_scalar_opts(r)
+  # @param [OpaquePassRegistry] r 
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_scalar_opts, :LLVMInitializeScalarOpts, [OpaquePassRegistry], :void
   
   # (Not documented)
   # 
-  # @method initialize_transform_utils(r)
+  # @method initialize_obj_carc_opts(r)
   # @param [OpaquePassRegistry] r 
   # @return [nil] 
   # @scope class
-  attach_function :initialize_transform_utils, :LLVMInitializeTransformUtils, [OpaquePassRegistry], :void
+  attach_function :initialize_objc_arc_opts, :LLVMInitializeObjCARCOpts, [OpaquePassRegistry], :void
   
   # (Not documented)
   # 
-  # @method initialize_scalar_opts(r)
+  # @method initialize_vectorization(r)
   # @param [OpaquePassRegistry] r 
   # @return [nil] 
   # @scope class
-  attach_function :initialize_scalar_opts, :LLVMInitializeScalarOpts, [OpaquePassRegistry], :void
+  attach_function :initialize_vectorization, :LLVMInitializeVectorization, [OpaquePassRegistry], :void
   
   # (Not documented)
   # 
@@ -5712,6 +7229,122 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :initialize_target, :LLVMInitializeTarget, [OpaquePassRegistry], :void
   
+  # (Not documented)
+  # 
+  # @method parse_ir_in_context(context_ref, mem_buf, out_m, out_message)
+  # @param [OpaqueContext] context_ref 
+  # @param [OpaqueMemoryBuffer] mem_buf 
+  # @param [FFI::Pointer(*ModuleRef)] out_m 
+  # @param [FFI::Pointer(**CharS)] out_message 
+  # @return [Integer] 
+  # @scope class
+  attach_function :parse_ir_in_context, :LLVMParseIRInContext, [OpaqueContext, OpaqueMemoryBuffer, :pointer, :pointer], :int
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:linker_mode).</em>
+  # 
+  # === Options:
+  # :linker_destroy_source ::
+  #   
+  # 
+  # @method _enum_linker_mode_
+  # @return [Symbol]
+  # @scope class
+  enum :linker_mode, [
+    :linker_destroy_source, 0
+  ]
+  
+  # Links the source module into the destination module, taking ownership
+  # of the source module away from the caller. Optionally returns a
+  # human-readable description of any errors that occurred in linking.
+  # OutMessage must be disposed with LLVMDisposeMessage. The return value
+  # is true if an error occurred, false otherwise.
+  # 
+  # @method link_modules(dest, src, mode, out_message)
+  # @param [OpaqueModule] dest 
+  # @param [OpaqueModule] src 
+  # @param [Symbol from _enum_linker_mode_] mode 
+  # @param [FFI::Pointer(**CharS)] out_message 
+  # @return [Integer] 
+  # @scope class
+  attach_function :link_modules, :LLVMLinkModules, [OpaqueModule, OpaqueModule, :linker_mode, :pointer], :int
+  
+  # /// This should map exactly onto the C++ enumerator LTOStatus.
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:llvm_lto_status).</em>
+  # 
+  # === Options:
+  # :unknown ::
+  #   
+  # :opt_success ::
+  #   
+  # :read_success ::
+  #   
+  # :read_failure ::
+  #   
+  # :write_failure ::
+  #   
+  # :no_target ::
+  #   
+  # :no_work ::
+  #   
+  # :module_merge_failure ::
+  #   
+  # :asm_failure ::
+  #   
+  # :null_object ::
+  #   //  Added C-specific error codes
+  # 
+  # @method _enum_llvm_lto_status_
+  # @return [Symbol]
+  # @scope class
+  enum :llvm_lto_status, [
+    :unknown, 0,
+    :opt_success, 1,
+    :read_success, 2,
+    :read_failure, 3,
+    :write_failure, 4,
+    :no_target, 5,
+    :no_work, 6,
+    :module_merge_failure, 7,
+    :asm_failure, 8,
+    :null_object, 9
+  ]
+  
+  # /// extern "C" helps, because dlopen() interface uses name to find the symbol.
+  # 
+  # @method llvm_create_optimizer()
+  # @return [FFI::Pointer(LlvmLtoT)] 
+  # @scope class
+  attach_function :llvm_create_optimizer, :llvm_create_optimizer, [], :pointer
+  
+  # (Not documented)
+  # 
+  # @method llvm_destroy_optimizer(lto)
+  # @param [FFI::Pointer(LlvmLtoT)] lto 
+  # @return [nil] 
+  # @scope class
+  attach_function :llvm_destroy_optimizer, :llvm_destroy_optimizer, [:pointer], :void
+  
+  # (Not documented)
+  # 
+  # @method llvm_read_object_file(lto, input_filename)
+  # @param [FFI::Pointer(LlvmLtoT)] lto 
+  # @param [String] input_filename 
+  # @return [Symbol from _enum_llvm_lto_status_] 
+  # @scope class
+  attach_function :llvm_read_object_file, :llvm_read_object_file, [:pointer, :string], :llvm_lto_status
+  
+  # (Not documented)
+  # 
+  # @method llvm_optimize_modules(lto, output_filename)
+  # @param [FFI::Pointer(LlvmLtoT)] lto 
+  # @param [String] output_filename 
+  # @return [Symbol from _enum_llvm_lto_status_] 
+  # @scope class
+  attach_function :llvm_optimize_modules, :llvm_optimize_modules, [:pointer, :string], :llvm_lto_status
+  
   # (Not documented)
   class OpaqueObjectFile < FFI::Struct
     layout :dummy, :char
@@ -5723,6 +7356,16 @@ module RLTK::CG::Bindings
   end
   
   # (Not documented)
+  class OpaqueSymbolIterator < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # (Not documented)
+  class OpaqueRelocationIterator < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # // ObjectFile creation
   # 
   # @method create_object_file(mem_buf)
   # @param [OpaqueMemoryBuffer] mem_buf 
@@ -5738,7 +7381,7 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :dispose_object_file, :LLVMDisposeObjectFile, [OpaqueObjectFile], :void
   
-  # (Not documented)
+  # // ObjectFile Section iterators
   # 
   # @method get_sections(object_file)
   # @param [OpaqueObjectFile] object_file 
@@ -5773,6 +7416,48 @@ module RLTK::CG::Bindings
   
   # (Not documented)
   # 
+  # @method move_to_containing_section(sect, sym)
+  # @param [OpaqueSectionIterator] sect 
+  # @param [OpaqueSymbolIterator] sym 
+  # @return [nil] 
+  # @scope class
+  attach_function :move_to_containing_section, :LLVMMoveToContainingSection, [OpaqueSectionIterator, OpaqueSymbolIterator], :void
+  
+  # // ObjectFile Symbol iterators
+  # 
+  # @method get_symbols(object_file)
+  # @param [OpaqueObjectFile] object_file 
+  # @return [OpaqueSymbolIterator] 
+  # @scope class
+  attach_function :get_symbols, :LLVMGetSymbols, [OpaqueObjectFile], OpaqueSymbolIterator
+  
+  # (Not documented)
+  # 
+  # @method dispose_symbol_iterator(si)
+  # @param [OpaqueSymbolIterator] si 
+  # @return [nil] 
+  # @scope class
+  attach_function :dispose_symbol_iterator, :LLVMDisposeSymbolIterator, [OpaqueSymbolIterator], :void
+  
+  # (Not documented)
+  # 
+  # @method is_symbol_iterator_at_end(object_file, si)
+  # @param [OpaqueObjectFile] object_file 
+  # @param [OpaqueSymbolIterator] si 
+  # @return [Integer] 
+  # @scope class
+  attach_function :is_symbol_iterator_at_end, :LLVMIsSymbolIteratorAtEnd, [OpaqueObjectFile, OpaqueSymbolIterator], :int
+  
+  # (Not documented)
+  # 
+  # @method move_to_next_symbol(si)
+  # @param [OpaqueSymbolIterator] si 
+  # @return [nil] 
+  # @scope class
+  attach_function :move_to_next_symbol, :LLVMMoveToNextSymbol, [OpaqueSymbolIterator], :void
+  
+  # // SectionRef accessors
+  # 
   # @method get_section_name(si)
   # @param [OpaqueSectionIterator] si 
   # @return [String] 
@@ -5795,6 +7480,144 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :get_section_contents, :LLVMGetSectionContents, [OpaqueSectionIterator], :string
   
+  # (Not documented)
+  # 
+  # @method get_section_address(si)
+  # @param [OpaqueSectionIterator] si 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_section_address, :LLVMGetSectionAddress, [OpaqueSectionIterator], :ulong
+  
+  # (Not documented)
+  # 
+  # @method get_section_contains_symbol(si, sym)
+  # @param [OpaqueSectionIterator] si 
+  # @param [OpaqueSymbolIterator] sym 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_section_contains_symbol, :LLVMGetSectionContainsSymbol, [OpaqueSectionIterator, OpaqueSymbolIterator], :int
+  
+  # // Section Relocation iterators
+  # 
+  # @method get_relocations(section)
+  # @param [OpaqueSectionIterator] section 
+  # @return [OpaqueRelocationIterator] 
+  # @scope class
+  attach_function :get_relocations, :LLVMGetRelocations, [OpaqueSectionIterator], OpaqueRelocationIterator
+  
+  # (Not documented)
+  # 
+  # @method dispose_relocation_iterator(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [nil] 
+  # @scope class
+  attach_function :dispose_relocation_iterator, :LLVMDisposeRelocationIterator, [OpaqueRelocationIterator], :void
+  
+  # (Not documented)
+  # 
+  # @method is_relocation_iterator_at_end(section, ri)
+  # @param [OpaqueSectionIterator] section 
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [Integer] 
+  # @scope class
+  attach_function :is_relocation_iterator_at_end, :LLVMIsRelocationIteratorAtEnd, [OpaqueSectionIterator, OpaqueRelocationIterator], :int
+  
+  # (Not documented)
+  # 
+  # @method move_to_next_relocation(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [nil] 
+  # @scope class
+  attach_function :move_to_next_relocation, :LLVMMoveToNextRelocation, [OpaqueRelocationIterator], :void
+  
+  # // SymbolRef accessors
+  # 
+  # @method get_symbol_name(si)
+  # @param [OpaqueSymbolIterator] si 
+  # @return [String] 
+  # @scope class
+  attach_function :get_symbol_name, :LLVMGetSymbolName, [OpaqueSymbolIterator], :string
+  
+  # (Not documented)
+  # 
+  # @method get_symbol_address(si)
+  # @param [OpaqueSymbolIterator] si 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_symbol_address, :LLVMGetSymbolAddress, [OpaqueSymbolIterator], :ulong
+  
+  # (Not documented)
+  # 
+  # @method get_symbol_file_offset(si)
+  # @param [OpaqueSymbolIterator] si 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_symbol_file_offset, :LLVMGetSymbolFileOffset, [OpaqueSymbolIterator], :ulong
+  
+  # (Not documented)
+  # 
+  # @method get_symbol_size(si)
+  # @param [OpaqueSymbolIterator] si 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_symbol_size, :LLVMGetSymbolSize, [OpaqueSymbolIterator], :ulong
+  
+  # // RelocationRef accessors
+  # 
+  # @method get_relocation_address(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_relocation_address, :LLVMGetRelocationAddress, [OpaqueRelocationIterator], :ulong
+  
+  # (Not documented)
+  # 
+  # @method get_relocation_offset(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_relocation_offset, :LLVMGetRelocationOffset, [OpaqueRelocationIterator], :ulong
+  
+  # (Not documented)
+  # 
+  # @method get_relocation_symbol(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [OpaqueSymbolIterator] 
+  # @scope class
+  attach_function :get_relocation_symbol, :LLVMGetRelocationSymbol, [OpaqueRelocationIterator], OpaqueSymbolIterator
+  
+  # (Not documented)
+  # 
+  # @method get_relocation_type(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [Integer] 
+  # @scope class
+  attach_function :get_relocation_type, :LLVMGetRelocationType, [OpaqueRelocationIterator], :ulong
+  
+  # // following functions.
+  # 
+  # @method get_relocation_type_name(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [String] 
+  # @scope class
+  attach_function :get_relocation_type_name, :LLVMGetRelocationTypeName, [OpaqueRelocationIterator], :string
+  
+  # (Not documented)
+  # 
+  # @method get_relocation_value_string(ri)
+  # @param [OpaqueRelocationIterator] ri 
+  # @return [String] 
+  # @scope class
+  attach_function :get_relocation_value_string, :LLVMGetRelocationValueString, [OpaqueRelocationIterator], :string
+  
+  # (Not documented)
+  # 
+  # @method load_library_permanently(filename)
+  # @param [String] filename 
+  # @return [Integer] 
+  # @scope class
+  attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int
+  
   # (Not documented)
   # 
   # @method add_argument_promotion_pass(pm)
@@ -5908,6 +7731,109 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_strip_symbols_pass, :LLVMAddStripSymbolsPass, [OpaquePassManager], :void
   
+  # (Not documented)
+  class OpaquePassManagerBuilder < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # See llvm::PassManagerBuilder.
+  # 
+  # @method pass_manager_builder_create()
+  # @return [OpaquePassManagerBuilder] 
+  # @scope class
+  attach_function :pass_manager_builder_create, :LLVMPassManagerBuilderCreate, [], OpaquePassManagerBuilder
+  
+  # (Not documented)
+  # 
+  # @method pass_manager_builder_dispose(pmb)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_dispose, :LLVMPassManagerBuilderDispose, [OpaquePassManagerBuilder], :void
+  
+  # See llvm::PassManagerBuilder::OptLevel.
+  # 
+  # @method pass_manager_builder_set_opt_level(pmb, opt_level)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] opt_level 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_opt_level, :LLVMPassManagerBuilderSetOptLevel, [OpaquePassManagerBuilder, :uint], :void
+  
+  # See llvm::PassManagerBuilder::SizeLevel.
+  # 
+  # @method pass_manager_builder_set_size_level(pmb, size_level)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] size_level 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_size_level, :LLVMPassManagerBuilderSetSizeLevel, [OpaquePassManagerBuilder, :uint], :void
+  
+  # See llvm::PassManagerBuilder::DisableUnitAtATime.
+  # 
+  # @method pass_manager_builder_set_disable_unit_at_a_time(pmb, value)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] value 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_disable_unit_at_a_time, :LLVMPassManagerBuilderSetDisableUnitAtATime, [OpaquePassManagerBuilder, :int], :void
+  
+  # See llvm::PassManagerBuilder::DisableUnrollLoops.
+  # 
+  # @method pass_manager_builder_set_disable_unroll_loops(pmb, value)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] value 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_disable_unroll_loops, :LLVMPassManagerBuilderSetDisableUnrollLoops, [OpaquePassManagerBuilder, :int], :void
+  
+  # See llvm::PassManagerBuilder::DisableSimplifyLibCalls
+  # 
+  # @method pass_manager_builder_set_disable_simplify_lib_calls(pmb, value)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] value 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_disable_simplify_lib_calls, :LLVMPassManagerBuilderSetDisableSimplifyLibCalls, [OpaquePassManagerBuilder, :int], :void
+  
+  # See llvm::PassManagerBuilder::Inliner.
+  # 
+  # @method pass_manager_builder_use_inliner_with_threshold(pmb, threshold)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] threshold 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_use_inliner_with_threshold, :LLVMPassManagerBuilderUseInlinerWithThreshold, [OpaquePassManagerBuilder, :uint], :void
+  
+  # See llvm::PassManagerBuilder::populateFunctionPassManager.
+  # 
+  # @method pass_manager_builder_populate_function_pass_manager(pmb, pm)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_populate_function_pass_manager, :LLVMPassManagerBuilderPopulateFunctionPassManager, [OpaquePassManagerBuilder, OpaquePassManager], :void
+  
+  # See llvm::PassManagerBuilder::populateModulePassManager.
+  # 
+  # @method pass_manager_builder_populate_module_pass_manager(pmb, pm)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_populate_module_pass_manager, :LLVMPassManagerBuilderPopulateModulePassManager, [OpaquePassManagerBuilder, OpaquePassManager], :void
+  
+  # See llvm::PassManagerBuilder::populateLTOPassManager.
+  # 
+  # @method pass_manager_builder_populate_lto_pass_manager(pmb, pm, internalize, run_inliner)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [OpaquePassManager] pm 
+  # @param [Integer] internalize 
+  # @param [Integer] run_inliner 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_populate_lto_pass_manager, :LLVMPassManagerBuilderPopulateLTOPassManager, [OpaquePassManagerBuilder, OpaquePassManager, :int, :int], :void
+  
   # (Not documented)
   # 
   # @method add_aggressive_dce_pass(pm)
@@ -5996,6 +7922,14 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_loop_rotate_pass, :LLVMAddLoopRotatePass, [OpaquePassManager], :void
   
+  # See llvm::createLoopRerollPass function.
+  # 
+  # @method add_loop_reroll_pass(pm)
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_loop_reroll_pass, :LLVMAddLoopRerollPass, [OpaquePassManager], :void
+  
   # See llvm::createLoopUnrollPass function.
   # 
   # @method add_loop_unroll_pass(pm)
@@ -6020,6 +7954,14 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_mem_cpy_opt_pass, :LLVMAddMemCpyOptPass, [OpaquePassManager], :void
   
+  # See llvm::createPartiallyInlineLibCallsPass function.
+  # 
+  # @method add_partially_inline_lib_calls_pass(pm)
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_partially_inline_lib_calls_pass, :LLVMAddPartiallyInlineLibCallsPass, [OpaquePassManager], :void
+  
   # See llvm::createPromoteMemoryToRegisterPass function.
   # 
   # @method add_promote_memory_to_register_pass(pm)
@@ -6149,4 +8091,28 @@ module RLTK::CG::Bindings
   # @scope class
   attach_function :add_basic_alias_analysis_pass, :LLVMAddBasicAliasAnalysisPass, [OpaquePassManager], :void
   
+  # (Not documented)
+  # 
+  # @method add_bb_vectorize_pass(pm)
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_bb_vectorize_pass, :LLVMAddBBVectorizePass, [OpaquePassManager], :void
+  
+  # See llvm::createLoopVectorizePass function.
+  # 
+  # @method add_loop_vectorize_pass(pm)
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_loop_vectorize_pass, :LLVMAddLoopVectorizePass, [OpaquePassManager], :void
+  
+  # See llvm::createSLPVectorizerPass function.
+  # 
+  # @method add_slp_vectorize_pass(pm)
+  # @param [OpaquePassManager] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_slp_vectorize_pass, :LLVMAddSLPVectorizePass, [OpaquePassManager], :void
+  
 end