ruby-llvm-next 10.0.0

data/lib/llvm/linker.rb

@@ -0,0 +1,16 @@
+require 'llvm'
+require 'llvm/core'
+require 'llvm/linker_ffi'
+
+module LLVM
+  class Module
+    # Link the current module into +other+.
+    #
+    # @return [nil, String] human-readable error if linking has failed
+    def link_into(other)
+      LLVM.with_message_output do |msg|
+        C.link_modules2(other, self)
+      end
+    end
+  end
+end

data/lib/llvm/linker_ffi.rb

@@ -0,0 +1,44 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  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
+
+  # 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:
+  # :destroy_source ::
+  #
+  # :preserve_source_removed ::
+  #   This is the default behavior.
+  #
+  # @method _enum_linker_mode_
+  # @return [Symbol]
+  # @scope class
+  enum :linker_mode, [
+    :destroy_source, 0,
+    :preserve_source_removed, 1
+  ]
+
+  # 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_modules2, :LLVMLinkModules2, [:pointer, :pointer], :int
+end

data/lib/llvm/support.rb

@@ -0,0 +1,38 @@
+require 'llvm/core_ffi'
+
+module LLVM
+
+  module Support
+    # @private
+
+    module C
+      extend FFI::Library
+
+      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 :initialize_all_target_infos,
+          :LLVMInitializeAllTargetInfos, [], :void
+      attach_function :initialize_all_targets,
+          :LLVMInitializeAllTargets, [], :void
+      attach_function :initialize_all_target_mcs,
+          :LLVMInitializeAllTargetMCs, [], :void
+      attach_function :initialize_all_asm_printers,
+          :LLVMInitializeAllAsmPrinters, [], :void
+
+      attach_function :initialize_native_target,
+          :LLVMInitializeNativeTarget, [], :void
+      attach_function :initialize_native_asm_printer,
+          :LLVMInitializeNativeAsmPrinter, [], :void
+    end
+  end
+
+  def self.load_library(libname)
+    if C.load_library_permanently(libname) != 0
+      raise "LLVM::Support.load_library failed"
+    end
+
+    nil
+  end
+end

data/lib/llvm/target.rb

@@ -0,0 +1,318 @@
+require 'llvm'
+require 'llvm/core'
+require 'llvm/target_ffi'
+
+module LLVM
+  # A shorthand for {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').
+  def self.init_x86
+    warn "LLVM.init_x86 is deprecated. Use LLVM.init_jit or LLVM::Target.init('X86')."
+    LLVM::Target.init('X86')
+  end
+
+  # You need to call {Target.init} for a target to be usable.
+  class Target
+    # Initializes target +target+; in particular, TargetInfo, Target and TargetMC.
+    #
+    # @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)
+      C.module_eval do
+        attach_function :"initialize_target_info_#{target}",
+            :"LLVMInitialize#{target}TargetInfo", [], :void
+        attach_function :"initialize_target_#{target}",
+            :"LLVMInitialize#{target}Target", [], :void
+        attach_function :"initialize_target_#{target}_mc",
+            :"LLVMInitialize#{target}TargetMC", [], :void
+
+        attach_function :"initialize_#{target}_asm_printer",
+            :"LLVMInitialize#{target}AsmPrinter", [], :void
+        attach_function :"initialize_#{target}_asm_parser",
+            :"LLVMInitialize#{target}AsmParser", [], :void
+        attach_function :"initialize_#{target}_disassembler",
+            :"LLVMInitialize#{target}Disassembler", [], :void
+      end
+
+      begin
+        %W(initialize_target_info_#{target}
+           initialize_target_#{target}
+           initialize_target_#{target}_mc).each do |init|
+          C.send init
+        end
+      rescue FFI::NotFoundError
+        raise ArgumentError, "LLVM target #{target} is not linked in. Try `llvm-config-#{LLVM_VERSION} --targets-built'."
+      end
+
+      begin
+        C.send :"initialize_#{target}_asm_printer" if asm_printer
+      rescue FFI::NotFoundError => e
+        raise ArgumentError, "LLVM target #{target} does not implement an ASM routime: #{e.message}"
+      end
+    end
+
+    # Initializes all available targets.
+    #
+    # @param [true, false] asm_printer Initialize corresponding AsmPrinters.
+    def self.init_all(asm_printer = false)
+      Support::C.initialize_all_target_infos
+      Support::C.initialize_all_targets
+      Support::C.initialize_all_target_mcs
+
+      Support::C.initialize_all_asm_printers if asm_printer
+    end
+
+    # Initializes native target. Useful for JIT applications.
+    #
+    # @param [true, false] asm_printer Initialize corresponding AsmPrinter.
+    #   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_asm_printer if asm_printer
+    end
+
+    # Enumerate all initialized targets.
+    #
+    # @yield [Target]
+    def self.each(&block)
+      return to_enum(:each) if block.nil?
+
+      target = C.get_first_target
+      until target.null?
+        yield from_ptr(target)
+
+        target = C.get_next_target(target)
+      end
+    end
+
+    # Fetch a target by its name.
+    #
+    # @return [Target]
+    def self.by_name(name)
+      each do |target|
+        return target if target.name == name
+      end
+    end
+
+    include PointerIdentity
+
+    # @private
+    def self.from_ptr(ptr)
+      target = allocate
+      target.instance_variable_set :@ptr, ptr
+      target
+    end
+
+    # Returns the name of the target.
+    #
+    # @return [String]
+    def name
+      C.get_target_name(self)
+    end
+
+    # Returns the description of the target.
+    #
+    # @return [String]
+    def description
+      C.get_target_description(self)
+    end
+
+    # Returns if the target has a JIT.
+    def jit?
+      !C.target_has_jit(self).zero?
+    end
+
+    # Returns if the target has a TargetMachine associated.
+    def target_machine?
+      !C.target_has_target_machine(self).zero?
+    end
+
+    # Returns if the target has an ASM backend (required for emitting output).
+    def asm_backend?
+      !C.target_has_asm_backend(self).zero?
+    end
+
+    # Constructs a TargetMachine.
+    #
+    # @param  [String]        triple     Target triple
+    # @param  [String]        cpu        Target CPU
+    # @param  [String]        features   Target feature string
+    # @param  [Symbol]        opt_level  :none, :less, :default, :aggressive
+    # @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)
+      TargetMachine.from_ptr(C.create_target_machine(self,
+            triple, cpu, features, opt_level, reloc, code_model))
+    end
+  end
+
+  class TargetMachine
+    include PointerIdentity
+
+    # @private
+    def self.from_ptr(ptr)
+      target = allocate
+      target.instance_variable_set :@ptr, ptr
+      target
+    end
+
+    # Destroys this instance of TargetMachine.
+    def dispose
+      return if @ptr.nil?
+
+      C.dispose_target_machine(self)
+      @ptr = nil
+    end
+
+    # Returns the corresponding Target.
+    #
+    # @return [Target]
+    def target
+      Target.from_ptr(C.get_target_machine_target(self))
+    end
+
+    # Returns the triple used for creating this target machine.
+    def triple
+      C.get_target_machine_triple(self)
+    end
+
+    # Returns the CPU used for creating this target machine.
+    def cpu
+      C.get_target_machine_cpu(self)
+    end
+
+    # Returns the feature string used for creating this target machine.
+    def features
+      C.get_target_machine_feature_string(self)
+    end
+
+    # Emits an asm or object file for the given module.
+    #
+    # @param [Symbol] codegen :assembly, :object
+    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
+    end
+  end
+
+  # @private
+  module C
+    # ffi_gen autodetects :string, which is too weak to be usable
+    # with LLVMDisposeMessage
+    attach_function :copy_string_rep_of_target_data, :LLVMCopyStringRepOfTargetData, [OpaqueTargetData], :pointer
+  end
+
+  class TargetDataLayout
+    # Creates a target data layout from a string representation.
+    #
+    # @param [String] representation
+    def initialize(representation)
+      @ptr = C.create_target_data(representation.to_s)
+    end
+
+    # @private
+    def self.from_ptr(ptr)
+      target = allocate
+      target.instance_variable_set :@ptr, ptr
+      target
+    end
+
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Destroys this instance of TargetDataLayout.
+    def dispose
+      return if ptr.nil?
+
+      C.dispose_target_data(self)
+      @ptr = nil
+    end
+
+    # Returns string representation of target data layout.
+    #
+    # @return [String]
+    def to_s
+      string_ptr = C.copy_string_rep_of_target_data(self)
+      string = string_ptr.read_string
+      C.dispose_message(string_ptr)
+
+      string
+    end
+
+    # Returns the byte order of a target, either :big_endian or :little_endian.
+    def byte_order
+      C.byte_order(self)
+    end
+
+    # Returns the pointer size in bytes for a target.
+    #
+    # @param [Integer] addr_space address space number
+    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)
+      Type.from_ptr(C.int_ptr_type_for_as(self, addr_space), :integer)
+    end
+
+    # Computes the size of a type in bits for a target.
+    def bit_size_of(type)
+      C.size_of_type_in_bits(self, type)
+    end
+
+    # Computes the storage size of a type in bytes for a target.
+    def storage_size_of(type)
+      C.store_size_of_type(self, type)
+    end
+
+    # Computes the ABI size of a type in bytes for a target.
+    def abi_size_of(type)
+      C.abi_size_of_type(self, type)
+    end
+
+    # Computes the ABI alignment of a type in bytes for a target.
+    def abi_alignment_of(type)
+      C.abi_alignment_of_type(self, type)
+    end
+
+    # Computes the call frame alignment of a type in bytes for a target.
+    def call_frame_alignment_of(type)
+      C.call_frame_alignment_of_type(self, type)
+    end
+
+    # Computes the preferred alignment of a type or a global variable in bytes
+    # for a target.
+    #
+    # @param [LLVM::Type, LLVM::GlobalValue] entity
+    def preferred_alignment_of(entity)
+      case entity
+      when LLVM::Type
+        C.preferred_alignment_of_type(self, entity)
+      when LLVM::GlobalValue
+        C.preferred_alignment_of_global(self, entity)
+      end
+    end
+
+    # Computes the structure element that contains the byte offset for a target.
+    def element_at_offset(type, offset)
+      C.element_at_offset(self, type, offset)
+    end
+
+    # Computes the byte offset of the indexed struct element for a target.
+    def offset_of_element(type, element)
+      C.offset_of_element(self, type, element)
+    end
+  end
+end

data/lib/llvm/target_ffi.rb

@@ -0,0 +1,628 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  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
+  enum :byte_ordering, [
+    :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)
+  #
+  # @method initialize_all_target_infos()
+  # @return [nil]
+  # @scope class
+  attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :void
+
+  # (Not documented)
+  #
+  # @method initialize_all_targets()
+  # @return [nil]
+  # @scope class
+  attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void
+
+  # (Not documented)
+  #
+  # @method initialize_all_target_m_cs()
+  # @return [nil]
+  # @scope class
+  attach_function :initialize_all_target_m_cs, :LLVMInitializeAllTargetMCs, [], :void
+
+  # (Not documented)
+  #
+  # @method initialize_all_asm_printers()
+  # @return [nil]
+  # @scope class
+  attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void
+
+  # (Not documented)
+  #
+  # @method initialize_all_asm_parsers()
+  # @return [nil]
+  # @scope class
+  attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void
+
+  # (Not documented)
+  #
+  # @method initialize_all_disassemblers()
+  # @return [nil]
+  # @scope class
+  attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void
+
+  # (Not documented)
+  #
+  # @method initialize_native_target()
+  # @return [Integer]
+  # @scope class
+  attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int
+
+  # (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]
+  # @scope class
+  attach_function :create_target_data, :LLVMCreateTargetData, [:string], OpaqueTargetData
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (Not documented)
+  #
+  # @method pointer_size(td)
+  # @param [OpaqueTargetData] td
+  # @return [Integer]
+  # @scope class
+  attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint
+
+  # (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
+
+  # (Not documented)
+  #
+  # @method int_ptr_type(td)
+  # @param [OpaqueTargetData] td
+  # @return [FFI::Pointer(TypeRef)]
+  # @scope class
+  attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], :pointer
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+
+  # (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
+  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
+
+  # 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]
+  # @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]
+  # @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