ruby-llvm 3.3.0 → 10.0.0

data/lib/llvm/linker.rb

@@ -9,25 +9,8 @@ module LLVM
     # @return [nil, String] human-readable error if linking has failed
     def link_into(other)
       LLVM.with_message_output do |msg|
-        # HACK ALERT: ffi-gen missed LLVMLinkerPreserveSource enumeration for
-        # some reason. It is inlined as a constant here.
-
-        # C.link_modules(mod, self, :linker_preserve_source, msg)
-        C.link_modules(other, self, 1, msg)
-      end
-    end
-
-    # Link the current module into +other+, and dispose the current module.
-    #
-    # @return [nil, String] human-readable error if linking has failed
-    def link_into_and_destroy(other)
-      result = LLVM.with_message_output do |msg|
-        C.link_modules(other, self, :linker_destroy_source, msg)
+        C.link_modules2(other, self)
       end
-
-      @ptr = nil
-
-      result
     end
   end
-end
+end

data/lib/llvm/linker_ffi.rb

@@ -4,42 +4,41 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.3'
-  
+  ffi_lib ["libLLVM-10.so.1", "LLVM-10"]
+
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
       (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
     end
   end
-  
-  # (Not documented)
-  # 
+
+  # This enum is provided for backwards-compatibility only. It has no effect.
+  #
   # <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 ::
-  #   
-  # 
+  # :destroy_source ::
+  #
+  # :preserve_source_removed ::
+  #   This is the default behavior.
+  #
   # @method _enum_linker_mode_
   # @return [Symbol]
   # @scope class
   enum :linker_mode, [
-    :linker_destroy_source, 0
+    :destroy_source, 0,
+    :preserve_source_removed, 1
   ]
-  
-  # 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 [FFI::Pointer(ModuleRef)] dest 
-  # @param [FFI::Pointer(ModuleRef)] src 
-  # @param [Symbol from _enum_linker_mode_] mode 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+
+  # Links the source module into the destination module. The source module is
+  # destroyed.
+  # The return value is true if an error occurred, false otherwise.
+  # Use the diagnostic handler to get any diagnostic message.
+  #
+  # @method link_modules2(dest, src)
+  # @param [FFI::Pointer(ModuleRef)] dest
+  # @param [FFI::Pointer(ModuleRef)] src
+  # @return [Integer]
   # @scope class
-  attach_function :link_modules, :LLVMLinkModules, [:pointer, :pointer, :linker_mode, :pointer], :int
-  
+  attach_function :link_modules2, :LLVMLinkModules2, [:pointer, :pointer], :int
 end

data/lib/llvm/support.rb

@@ -8,20 +8,10 @@ module LLVM
     module C
       extend FFI::Library
 
-      OpaqueValue  = LLVM::C::OpaqueValue
-      OpaqueType   = LLVM::C::OpaqueType
-      OpaqueModule = LLVM::C::OpaqueModule
-
       lib_name = FFI.map_library_name("RubyLLVMSupport-#{LLVM_VERSION}")
       lib_path = File.expand_path("../../ext/ruby-llvm-support/#{lib_name}", File.dirname(__FILE__))
       ffi_lib [lib_path]
 
-      attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int
-      attach_function :has_unnamed_addr, :LLVMHasUnnamedAddr, [OpaqueValue], :int
-      attach_function :set_unnamed_addr, :LLVMSetUnnamedAddr, [OpaqueValue, :int], :void
-      attach_function :dump_type, :LLVMDumpType, [OpaqueType], :void
-      attach_function :print_module, :LLVMPrintModuleToFD, [OpaqueModule, :int, :int, :int], :void
-
       attach_function :initialize_all_target_infos,
           :LLVMInitializeAllTargetInfos, [], :void
       attach_function :initialize_all_targets,
@@ -33,16 +23,16 @@ module LLVM
 
       attach_function :initialize_native_target,
           :LLVMInitializeNativeTarget, [], :void
-      attach_function :initialize_native_target_asm_printer,
-          :LLVMInitializeNativeTargetAsmPrinter, [], :void
+      attach_function :initialize_native_asm_printer,
+          :LLVMInitializeNativeAsmPrinter, [], :void
     end
   end
 
-  def load_library(libname)
-    Support::C.load_library_permanently(libname)
+  def self.load_library(libname)
+    if C.load_library_permanently(libname) != 0
+      raise "LLVM::Support.load_library failed"
+    end
 
     nil
   end
-
-  module_function :load_library
 end

data/lib/llvm/target.rb

@@ -4,8 +4,8 @@ require 'llvm/target_ffi'
 
 module LLVM
   # A shorthand for {LLVM::Target.init_native}
-  def self.init_jit
-    LLVM::Target.init_native
+  def self.init_jit(*args)
+    LLVM::Target.init_native(*args)
   end
 
   # @deprecated Use LLVM.init_jit or LLVM::Target.init('X86').
@@ -20,7 +20,7 @@ module LLVM
     #
     # @param [String]      target      Target name in LLVM format, e.g. "X86", "ARM" or "PowerPC".
     # @param [true, false] asm_printer Initialize corresponding AsmPrinter.
-    def self.init(target, asm_printer=false)
+    def self.init(target, asm_printer = false)
       C.module_eval do
         attach_function :"initialize_target_info_#{target}",
             :"LLVMInitialize#{target}TargetInfo", [], :void
@@ -57,7 +57,7 @@ module LLVM
     # Initializes all available targets.
     #
     # @param [true, false] asm_printer Initialize corresponding AsmPrinters.
-    def self.init_all(asm_printer=false)
+    def self.init_all(asm_printer = false)
       Support::C.initialize_all_target_infos
       Support::C.initialize_all_targets
       Support::C.initialize_all_target_mcs
@@ -68,10 +68,11 @@ module LLVM
     # Initializes native target. Useful for JIT applications.
     #
     # @param [true, false] asm_printer Initialize corresponding AsmPrinter.
-    def self.init_native(asm_printer=false)
+    #   True by default, as this is required for MCJIT to function.
+    def self.init_native(asm_printer = true)
       Support::C.initialize_native_target
 
-      Support::C.initialize_native_target_asm_printer if asm_printer
+      Support::C.initialize_native_asm_printer if asm_printer
     end
 
     # Enumerate all initialized targets.
@@ -144,8 +145,8 @@ module LLVM
     # @param  [Symbol]        reloc      :default, :static, :pic, :dynamic_no_pic
     # @param  [Symbol]        code_model :default, :jit_default, :small, :kernel, :medium, :large
     # @return [TargetMachine]
-    def create_machine(triple, cpu="", features="",
-                       opt_level=:default, reloc=:default, code_model=:default)
+    def create_machine(triple, cpu = "", features = "",
+                       opt_level = :default, reloc = :default, code_model = :default)
       TargetMachine.from_ptr(C.create_target_machine(self,
             triple, cpu, features, opt_level, reloc, code_model))
     end
@@ -191,17 +192,10 @@ module LLVM
       C.get_target_machine_feature_string(self)
     end
 
-    # Returns the data layout used for this target machine.
-    #
-    # @return [TargetDataLayout]
-    def data_layout
-      TargetDataLayout.from_ptr(C.get_target_machine_data(self))
-    end
-
     # Emits an asm or object file for the given module.
     #
     # @param [Symbol] codegen :assembly, :object
-    def emit(mod, filename, codegen=:assembly)
+    def emit(mod, filename, codegen = :assembly)
       LLVM.with_error_output do |err|
         C.target_machine_emit_to_file(self, mod, filename.to_s, codegen, err)
       end
@@ -262,14 +256,14 @@ module LLVM
     # Returns the pointer size in bytes for a target.
     #
     # @param [Integer] addr_space address space number
-    def pointer_size(addr_space=0)
+    def pointer_size(addr_space = 0)
       C.pointer_size_for_as(self, addr_space)
     end
 
     # Returns the integer type that is the same size as a pointer on a target.
     #
     # @param [Integer] addr_space address space number
-    def int_ptr_type(addr_space=0)
+    def int_ptr_type(addr_space = 0)
       Type.from_ptr(C.int_ptr_type_for_as(self, addr_space), :integer)
     end
 

data/lib/llvm/target_ffi.rb

@@ -4,24 +4,24 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.3'
-  
+  ffi_lib ["libLLVM-10.so.1", "LLVM-10"]
+
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
       (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
     end
   end
-  
+
   # (Not documented)
-  # 
+  #
   # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:byte_ordering).</em>
-  # 
+  #
   # === Options:
   # :big_endian ::
-  #   
+  #
   # :little_endian ::
-  #   
-  # 
+  #
+  #
   # @method _enum_byte_ordering_
   # @return [Symbol]
   # @scope class
@@ -29,314 +29,323 @@ module LLVM::C
     :big_endian, 0,
     :little_endian, 1
   ]
-  
+
   # (Not documented)
   class OpaqueTargetData < FFI::Struct
     layout :dummy, :char
   end
-  
+
   # (Not documented)
   class OpaqueTargetLibraryInfotData < FFI::Struct
     layout :dummy, :char
   end
-  
-  # (Not documented)
-  class StructLayout < FFI::Struct
-    layout :dummy, :char
-  end
-  
+
   # (Not documented)
-  # 
+  #
   # @method initialize_all_target_infos()
-  # @return [nil] 
+  # @return [nil]
   # @scope class
   attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :void
-  
-  # LLVMInitializeAllTargets - The main program should call this function if it
-  #     wants to link in all available targets that LLVM is configured to
-  #     support.
-  # 
+
+  # (Not documented)
+  #
   # @method initialize_all_targets()
-  # @return [nil] 
+  # @return [nil]
   # @scope class
   attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void
-  
-  # LLVMInitializeAllTargetMCs - The main program should call this function if
-  #     it wants access to all available target MC that LLVM is configured to
-  #     support.
-  # 
+
+  # (Not documented)
+  #
   # @method initialize_all_target_m_cs()
-  # @return [nil] 
+  # @return [nil]
   # @scope class
   attach_function :initialize_all_target_m_cs, :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.
-  # 
+
+  # (Not documented)
+  #
   # @method initialize_all_asm_printers()
-  # @return [nil] 
+  # @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.
-  # 
+
+  # (Not documented)
+  #
   # @method initialize_all_asm_parsers()
-  # @return [nil] 
+  # @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.
-  # 
+
+  # (Not documented)
+  #
   # @method initialize_all_disassemblers()
-  # @return [nil] 
+  # @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.
-  # 
+
+  # (Not documented)
+  #
   # @method initialize_native_target()
-  # @return [Integer] 
+  # @return [Integer]
   # @scope class
   attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int
-  
-  # Creates target data from a target layout string.
-  #     See the constructor llvm::DataLayout::DataLayout.
-  # 
+
+  # (Not documented)
+  #
+  # @method initialize_native_asm_parser()
+  # @return [Integer]
+  # @scope class
+  attach_function :initialize_native_asm_parser, :LLVMInitializeNativeAsmParser, [], :int
+
+  # (Not documented)
+  #
+  # @method initialize_native_asm_printer()
+  # @return [Integer]
+  # @scope class
+  attach_function :initialize_native_asm_printer, :LLVMInitializeNativeAsmPrinter, [], :int
+
+  # (Not documented)
+  #
+  # @method initialize_native_disassembler()
+  # @return [Integer]
+  # @scope class
+  attach_function :initialize_native_disassembler, :LLVMInitializeNativeDisassembler, [], :int
+
+  # (Not documented)
+  #
+  # @method get_module_data_layout(m)
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @return [OpaqueTargetData]
+  # @scope class
+  attach_function :get_module_data_layout, :LLVMGetModuleDataLayout, [:pointer], OpaqueTargetData
+
+  # (Not documented)
+  #
+  # @method set_module_data_layout(m, dl)
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [OpaqueTargetData] dl
+  # @return [nil]
+  # @scope class
+  attach_function :set_module_data_layout, :LLVMSetModuleDataLayout, [:pointer, OpaqueTargetData], :void
+
+  # (Not documented)
+  #
   # @method create_target_data(string_rep)
-  # @param [String] string_rep 
-  # @return [OpaqueTargetData] 
+  # @param [String] string_rep
+  # @return [OpaqueTargetData]
   # @scope class
   attach_function :create_target_data, :LLVMCreateTargetData, [:string], OpaqueTargetData
-  
-  # Adds target data information to a pass manager. This does not take ownership
-  #     of the target data.
-  #     See the method llvm::PassManagerBase::add.
-  # 
-  # @method add_target_data(opaque_target_data, pass_manager_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(PassManagerRef)] pass_manager_ref 
-  # @return [nil] 
-  # @scope class
-  attach_function :add_target_data, :LLVMAddTargetData, [OpaqueTargetData, :pointer], :void
-  
-  # Adds target library information to a pass manager. This does not take
-  #     ownership of the target library info.
-  #     See the method llvm::PassManagerBase::add.
-  # 
-  # @method add_target_library_info(opaque_target_library_infot_data, pass_manager_ref)
-  # @param [OpaqueTargetLibraryInfotData] opaque_target_library_infot_data 
-  # @param [FFI::Pointer(PassManagerRef)] pass_manager_ref 
-  # @return [nil] 
+
+  # (Not documented)
+  #
+  # @method dispose_target_data(td)
+  # @param [OpaqueTargetData] td
+  # @return [nil]
+  # @scope class
+  attach_function :dispose_target_data, :LLVMDisposeTargetData, [OpaqueTargetData], :void
+
+  # (Not documented)
+  #
+  # @method add_target_library_info(tli, pm)
+  # @param [OpaqueTargetLibraryInfotData] tli
+  # @param [FFI::Pointer(PassManagerRef)] pm
+  # @return [nil]
   # @scope class
   attach_function :add_target_library_info, :LLVMAddTargetLibraryInfo, [OpaqueTargetLibraryInfotData, :pointer], :void
-  
-  # Converts target data to a target layout string. The string must be disposed
-  #     with LLVMDisposeMessage.
-  #     See the constructor llvm::DataLayout::DataLayout.
-  # 
-  # @method copy_string_rep_of_target_data(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @return [String] 
+
+  # (Not documented)
+  #
+  # @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::DataLayout::isLittleEndian.
-  # 
-  # @method byte_order(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @return [Symbol from _enum_byte_ordering_] 
+
+  # (Not documented)
+  #
+  # @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::DataLayout::getPointerSize.
-  # 
-  # @method pointer_size(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @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(opaque_target_data, as)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [Integer] as 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @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::DataLayout::getIntPtrType.
-  # 
-  # @method int_ptr_type(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @return [FFI::Pointer(TypeRef)] 
+
+  # (Not documented)
+  #
+  # @method int_ptr_type(td)
+  # @param [OpaqueTargetData] td
+  # @return [FFI::Pointer(TypeRef)]
   # @scope class
   attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], :pointer
-  
-  # 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(opaque_target_data, as)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [Integer] as 
-  # @return [FFI::Pointer(TypeRef)] 
+
+  # (Not documented)
+  #
+  # @method int_ptr_type_for_as(td, as)
+  # @param [OpaqueTargetData] td
+  # @param [Integer] as
+  # @return [FFI::Pointer(TypeRef)]
   # @scope class
   attach_function :int_ptr_type_for_as, :LLVMIntPtrTypeForAS, [OpaqueTargetData, :uint], :pointer
-  
-  # Computes the size of a type in bytes for a target.
-  #     See the method llvm::DataLayout::getTypeSizeInBits.
-  # 
-  # @method size_of_type_in_bits(opaque_target_data, type_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(TypeRef)] type_ref 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method int_ptr_type_in_context(c, td)
+  # @param [FFI::Pointer(ContextRef)] c
+  # @param [OpaqueTargetData] td
+  # @return [FFI::Pointer(TypeRef)]
+  # @scope class
+  attach_function :int_ptr_type_in_context, :LLVMIntPtrTypeInContext, [:pointer, OpaqueTargetData], :pointer
+
+  # (Not documented)
+  #
+  # @method int_ptr_type_for_as_in_context(c, td, as)
+  # @param [FFI::Pointer(ContextRef)] c
+  # @param [OpaqueTargetData] td
+  # @param [Integer] as
+  # @return [FFI::Pointer(TypeRef)]
+  # @scope class
+  attach_function :int_ptr_type_for_as_in_context, :LLVMIntPtrTypeForASInContext, [:pointer, OpaqueTargetData, :uint], :pointer
+
+  # (Not documented)
+  #
+  # @method size_of_type_in_bits(td, ty)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @return [Integer]
   # @scope class
   attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, :pointer], :ulong_long
-  
-  # Computes the storage size of a type in bytes for a target.
-  #     See the method llvm::DataLayout::getTypeStoreSize.
-  # 
-  # @method store_size_of_type(opaque_target_data, type_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(TypeRef)] type_ref 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method store_size_of_type(td, ty)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @return [Integer]
   # @scope class
   attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, :pointer], :ulong_long
-  
-  # Computes the ABI size of a type in bytes for a target.
-  #     See the method llvm::DataLayout::getTypeAllocSize.
-  # 
-  # @method abi_size_of_type(opaque_target_data, type_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(TypeRef)] type_ref 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method abi_size_of_type(td, ty)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @return [Integer]
   # @scope class
   attach_function :abi_size_of_type, :LLVMABISizeOfType, [OpaqueTargetData, :pointer], :ulong_long
-  
-  # Computes the ABI alignment of a type in bytes for a target.
-  #     See the method llvm::DataLayout::getTypeABISize.
-  # 
-  # @method abi_alignment_of_type(opaque_target_data, type_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(TypeRef)] type_ref 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method abi_alignment_of_type(td, ty)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @return [Integer]
   # @scope class
   attach_function :abi_alignment_of_type, :LLVMABIAlignmentOfType, [OpaqueTargetData, :pointer], :uint
-  
-  # Computes the call frame alignment of a type in bytes for a target.
-  #     See the method llvm::DataLayout::getTypeABISize.
-  # 
-  # @method call_frame_alignment_of_type(opaque_target_data, type_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(TypeRef)] type_ref 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method call_frame_alignment_of_type(td, ty)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @return [Integer]
   # @scope class
   attach_function :call_frame_alignment_of_type, :LLVMCallFrameAlignmentOfType, [OpaqueTargetData, :pointer], :uint
-  
-  # Computes the preferred alignment of a type in bytes for a target.
-  #     See the method llvm::DataLayout::getTypeABISize.
-  # 
-  # @method preferred_alignment_of_type(opaque_target_data, type_ref)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(TypeRef)] type_ref 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method preferred_alignment_of_type(td, ty)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @return [Integer]
   # @scope class
   attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, :pointer], :uint
-  
-  # Computes the preferred alignment of a global variable in bytes for a target.
-  #     See the method llvm::DataLayout::getPreferredAlignment.
-  # 
-  # @method preferred_alignment_of_global(opaque_target_data, global_var)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @param [FFI::Pointer(ValueRef)] global_var 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method preferred_alignment_of_global(td, global_var)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(ValueRef)] global_var
+  # @return [Integer]
   # @scope class
   attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, :pointer], :uint
-  
-  # 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 
-  # @param [FFI::Pointer(TypeRef)] struct_ty 
-  # @param [Integer] offset 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method element_at_offset(td, struct_ty, offset)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] struct_ty
+  # @param [Integer] offset
+  # @return [Integer]
   # @scope class
   attach_function :element_at_offset, :LLVMElementAtOffset, [OpaqueTargetData, :pointer, :ulong_long], :uint
-  
-  # 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 
-  # @param [FFI::Pointer(TypeRef)] struct_ty 
-  # @param [Integer] element 
-  # @return [Integer] 
+
+  # (Not documented)
+  #
+  # @method offset_of_element(td, struct_ty, element)
+  # @param [OpaqueTargetData] td
+  # @param [FFI::Pointer(TypeRef)] struct_ty
+  # @param [Integer] element
+  # @return [Integer]
   # @scope class
   attach_function :offset_of_element, :LLVMOffsetOfElement, [OpaqueTargetData, :pointer, :uint], :ulong_long
-  
-  # Deallocates a TargetData.
-  #     See the destructor llvm::DataLayout::~DataLayout.
-  # 
-  # @method dispose_target_data(opaque_target_data)
-  # @param [OpaqueTargetData] opaque_target_data 
-  # @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
+    # @return [Integer]
     def has_jit()
       LLVM::C.target_has_jit(self)
     end
-    
+
+    # @return [Integer]
     def has_target_machine()
       LLVM::C.target_has_target_machine(self)
     end
-    
+
+    # @return [Integer]
     def has_asm_backend()
       LLVM::C.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
@@ -346,21 +355,21 @@ module LLVM::C
     :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
@@ -370,25 +379,25 @@ module LLVM::C
     :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
@@ -400,17 +409,17 @@ module LLVM::C
     :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
@@ -418,155 +427,202 @@ module LLVM::C
     :assembly, 0,
     :object, 1
   ]
-  
+
   # Returns the first llvm::Target in the registered targets list.
-  # 
+  #
   # @method get_first_target()
-  # @return [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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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] 
+  # @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
-  
+
+  # Create a DataLayout based on the targetMachine.
+  #
+  # @method create_target_data_layout(t)
+  # @param [OpaqueTargetMachine] t
+  # @return [OpaqueTargetData]
+  # @scope class
+  attach_function :create_target_data_layout, :LLVMCreateTargetDataLayout, [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 [FFI::Pointer(ModuleRef)] m 
-  # @param [String] filename 
-  # @param [Symbol from _enum_code_gen_file_type_] codegen 
-  # @param [FFI::Pointer(**CharS)] error_message 
-  # @return [Integer] 
+  # @param [OpaqueTargetMachine] t
+  # @param [FFI::Pointer(ModuleRef)] 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, :pointer, :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 [FFI::Pointer(ModuleRef)] 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] 
+  # @param [OpaqueTargetMachine] t
+  # @param [FFI::Pointer(ModuleRef)] 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, :pointer, :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
+
+  # Adds the target-specific analysis passes to the pass manager.
+  #
+  # @method add_analysis_passes(t, pm)
+  # @param [OpaqueTargetMachine] t
+  # @param [FFI::Pointer(PassManagerRef)] pm
+  # @return [nil]
+  # @scope class
+  attach_function :add_analysis_passes, :LLVMAddAnalysisPasses, [OpaqueTargetMachine, :pointer], :void
+
 end