ruby-llvm 3.5.0 → 10.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e559929d919c913ffacaef820430b37093a23adc
-  data.tar.gz: d98b42343be29f103dbbb9f518cc304542d0fdff
+SHA256:
+  metadata.gz: c7077c05ecee582525cd5526bfc87670921c5e54acff2fe5ebc011004fabd2b3
+  data.tar.gz: b4626a00ec972c15f9f069ff3f3d9d2022bcf2ad2d6c78c20faaaa8d7c91df71
 SHA512:
-  metadata.gz: 3ad54d41292618fb2c48a56b89812e97ce66fd4a8708858d5137ac7064721fbe339eefe3c938f57af1c596acc8f019ff278f9e62d3a6e259e638cbd7dfcdd029
-  data.tar.gz: 2743c5a6ef7e374eb158f436d01ca39f1f0dd5f218957060f57fb54d5d205f14322ffc2957b39f4cf2f60e78feefd5cb314723fb11012d76885b0c001beecf6e
+  metadata.gz: 07ed15a10baad306e15107741224880c8bcffb4739b345cd3542d53cd4501d8b05222b10c1f0faf705dcfef889cf60e038521b1d08acdda2b86b347788a2a4a1
+  data.tar.gz: 134a6f2d90c03f5ad318985eb017e2076095a6be2a91abcdf0b467a3aea18b5901f6e723ff4339e7db5afd721e2b340f2f2749858db1e43433852a5bfd97f152

data/README.md

@@ -1,3 +1,5 @@
+[![Known Vulnerabilities](https://snyk.io/test/github/ruby-llvm/ruby-llvm/badge.svg)](https://snyk.io/test/github/ruby-llvm/ruby-llvm)
+
 Ruby-LLVM
 =========
 
@@ -7,10 +9,10 @@ library. LLVM allows users to create just-in-time (JIT) compilers, ahead-of-time
 bindings can also be used to speed up Ruby code by compiling and loading
 computationally intensive algorithms on the fly.
 
-Requirements
-------------
-* LLVM 3.4, including libLLVM-3.4 (compile LLVM with --enable-shared).
-* In order to ensure the usability of JIT features (i.e. create_jit_compiler), compile LLVM with --enable-jit as well.
+Current version
+---------------
+
+This library currently binds to LLVM-10 (specifically llvm-c 10).
 
 About version numbers
 ---------------------
@@ -20,13 +22,26 @@ major and minor version of LLVM. The third digit refers to the ruby-llvm
 release itself. Because LLVM's api changes often, this coupling between
 LLVM and ruby-llvm versions is useful.
 
+Debian/Ubuntu
+-------------
+
+[LLVM Debian/Ubuntu Packages](https://apt.llvm.org/)
+
 Homebrew
 --------
+
 LLVM can be installed with Homebrew by executing `brew install llvm --shared`
 
+Source and other binaries
+-------------------------
+
+* [LLVM Download Page](https://releases.llvm.org/download.html)
+* If compiling from source the --enable-shared and --enable-jit flags may be needed.
+
 See Also
 --------
 * [The LLVM project](http://llvm.org)
+* [Mirror of llvm-c on github](https://github.com/llvm-mirror/llvm/tree/master/include/llvm-c)
 * [ffi-gen](https://github.com/neelance/ffi-gen) – Generate
   [FFI](https://github.com/ffi/ffi) bindings with LLVM and Clang
 

data/ext/ruby-llvm-support/Rakefile

@@ -21,7 +21,7 @@ def check_for(what, variants, env_var)
   if result
     result
   else
-    raise RuntimeError, "Cannot find #{what}: tried #{variants}"
+    raise "Cannot find #{what}: tried #{variants}"
   end
 end
 
@@ -34,7 +34,7 @@ def find_llvm_config
       actual_version = `#{llvm_config} --version`.strip
       actual_maj, actual_min, _ = actual_version.split('.')
 
-      required_maj, required_min = LLVM_VERSION.split('.')
+      required_maj, required_min = LLVM_REQUIRED_VERSION.split('.')
 
       actual_maj == required_maj && actual_min == required_min
     rescue Errno::ENOENT
@@ -54,7 +54,16 @@ LLVM_CONFIG = find_llvm_config
 CXX         = find_cxx
 
 def invoke_llvm_config(options)
-  `#{LLVM_CONFIG} #{options}`.gsub("\n", " ")
+  `#{LLVM_CONFIG} #{options}`.tr("\n", " ")
+end
+
+def llvm_lib_name
+  lib_dir = invoke_llvm_config('--libdir').strip
+  lib_name = 'LLVM'
+  versioned_lib_name = "#{lib_name}-#{LLVM_VERSION}"
+  versioned_lib_pattern = "lib#{versioned_lib_name}.*"
+  versioned_lib_found = Dir.glob(File.join(lib_dir, versioned_lib_pattern)) != []
+  versioned_lib_found ? versioned_lib_name : lib_name
 end
 
 SUPPORT_LIB = FFI.map_library_name("RubyLLVMSupport-#{LLVM_VERSION}")
@@ -66,8 +75,8 @@ desc "Build the shared library and config module"
 task :default => [SUPPORT_LIB, CONFIG_MOD]
 
 file SUPPORT_LIB => %w(support.cpp) do |task|
-  sh "#{CXX} -shared #{task.prerequisites.join(' ')} -lLLVM-#{LLVM_VERSION} " \
-     "#{invoke_llvm_config('--cxxflags --ldflags')} -o #{SUPPORT_LIB}"
+  sh "#{CXX} -shared #{task.prerequisites.join(' ')} -l#{llvm_lib_name} " \
+     "#{invoke_llvm_config('--cxxflags --ldflags')} -fPIC -o #{SUPPORT_LIB}"
 end
 
 LLVM_CONFIG_OPTS = [
@@ -76,7 +85,7 @@ LLVM_CONFIG_OPTS = [
   ['HOST_TARGET',   :string, '--host-target'],
   ['BUILD_MODE',    :string, '--build-mode'],
   ['CFLAGS',        :string, '--cflags'],
-]
+].freeze
 
 file CONFIG_MOD do
   open(CONFIG_MOD, 'w') do |f|

data/lib/llvm/analysis_ffi.rb

@@ -4,29 +4,29 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-3.5.so.1", "LLVM-3.5"]
-  
+  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
-  
+
   # @defgroup LLVMCAnalysis Analysis
   # @ingroup LLVMC
-  # 
+  #
   # @{
-  # 
+  #
   # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:verifier_failure_action).</em>
-  # 
+  #
   # === Options:
   # :abort_process ::
-  #   
+  #
   # :print_message ::
   #   verifier will print to stderr and abort()
   # :return_status ::
   #   verifier will print to stderr and return 1
-  # 
+  #
   # @method _enum_verifier_failure_action_
   # @return [Symbol]
   # @scope class
@@ -35,44 +35,43 @@ module LLVM::C
     :print_message, 1,
     :return_status, 2
   ]
-  
+
   # Verifies that a module is valid, taking the specified action if not.
   #    Optionally returns a human-readable description of any invalid constructs.
   #    OutMessage must be disposed with LLVMDisposeMessage.
-  # 
+  #
   # @method verify_module(m, action, out_message)
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @param [Symbol from _enum_verifier_failure_action_] action 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [Symbol from _enum_verifier_failure_action_] action
+  # @param [FFI::Pointer(**CharS)] out_message
+  # @return [Integer]
   # @scope class
   attach_function :verify_module, :LLVMVerifyModule, [:pointer, :verifier_failure_action, :pointer], :int
-  
+
   # Verifies that a single function is valid, taking the specified action. Useful
   #    for debugging.
-  # 
+  #
   # @method verify_function(fn, action)
-  # @param [FFI::Pointer(ValueRef)] fn 
-  # @param [Symbol from _enum_verifier_failure_action_] action 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ValueRef)] fn
+  # @param [Symbol from _enum_verifier_failure_action_] action
+  # @return [Integer]
   # @scope class
   attach_function :verify_function, :LLVMVerifyFunction, [:pointer, :verifier_failure_action], :int
-  
+
   # Open up a ghostview window that displays the CFG of the current function.
   #    Useful for debugging.
-  # 
+  #
   # @method view_function_cfg(fn)
-  # @param [FFI::Pointer(ValueRef)] fn 
-  # @return [nil] 
+  # @param [FFI::Pointer(ValueRef)] fn
+  # @return [nil]
   # @scope class
   attach_function :view_function_cfg, :LLVMViewFunctionCFG, [:pointer], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method view_function_cfg_only(fn)
-  # @param [FFI::Pointer(ValueRef)] fn 
-  # @return [nil] 
+  # @param [FFI::Pointer(ValueRef)] fn
+  # @return [nil]
   # @scope class
   attach_function :view_function_cfg_only, :LLVMViewFunctionCFGOnly, [:pointer], :void
-  
 end

data/lib/llvm/config.rb

@@ -1,10 +1,10 @@
 # Generated by ruby-llvm. Please do not change this file by hand.
 module LLVM
   module CONFIG
-    COMPONENTS = ["aarch64", "aarch64asmparser", "aarch64asmprinter", "aarch64codegen", "aarch64desc", "aarch64disassembler", "aarch64info", "aarch64utils", "all", "all-targets", "analysis", "arm", "armasmparser", "armasmprinter", "armcodegen", "armdesc", "armdisassembler", "arminfo", "asmparser", "asmprinter", "bitreader", "bitwriter", "codegen", "core", "cppbackend", "cppbackendcodegen", "cppbackendinfo", "debuginfo", "engine", "executionengine", "hexagon", "hexagonasmprinter", "hexagoncodegen", "hexagondesc", "hexagoninfo", "instcombine", "instrumentation", "interpreter", "ipa", "ipo", "irreader", "jit", "lineeditor", "linker", "lto", "mc", "mcanalysis", "mcdisassembler", "mcjit", "mcparser", "mips", "mipsasmparser", "mipsasmprinter", "mipscodegen", "mipsdesc", "mipsdisassembler", "mipsinfo", "msp430", "msp430asmprinter", "msp430codegen", "msp430desc", "msp430info", "native", "nativecodegen", "nvptx", "nvptxasmprinter", "nvptxcodegen", "nvptxdesc", "nvptxinfo", "objcarcopts", "object", "option", "powerpc", "powerpcasmparser", "powerpcasmprinter", "powerpccodegen", "powerpcdesc", "powerpcdisassembler", "powerpcinfo", "profiledata", "r600", "r600asmprinter", "r600codegen", "r600desc", "r600info", "runtimedyld", "scalaropts", "selectiondag", "sparc", "sparcasmparser", "sparcasmprinter", "sparccodegen", "sparcdesc", "sparcdisassembler", "sparcinfo", "support", "systemz", "systemzasmparser", "systemzasmprinter", "systemzcodegen", "systemzdesc", "systemzdisassembler", "systemzinfo", "tablegen", "target", "transformutils", "vectorize", "x86", "x86asmparser", "x86asmprinter", "x86codegen", "x86desc", "x86disassembler", "x86info", "x86utils", "xcore", "xcoreasmprinter", "xcorecodegen", "xcoredesc", "xcoredisassembler", "xcoreinfo"]
-    TARGETS_BUILT = ["X86", "Sparc", "PowerPC", "ARM", "AArch64", "Mips", "XCore", "MSP430", "CppBackend", "NVPTX", "Hexagon", "SystemZ", "R600"]
+    COMPONENTS = ["aarch64", "aarch64asmparser", "aarch64codegen", "aarch64desc", "aarch64disassembler", "aarch64info", "aarch64utils", "aggressiveinstcombine", "all", "all-targets", "amdgpu", "amdgpuasmparser", "amdgpucodegen", "amdgpudesc", "amdgpudisassembler", "amdgpuinfo", "amdgpuutils", "analysis", "arm", "armasmparser", "armcodegen", "armdesc", "armdisassembler", "arminfo", "armutils", "asmparser", "asmprinter", "avr", "avrasmparser", "avrcodegen", "avrdesc", "avrdisassembler", "avrinfo", "binaryformat", "bitreader", "bitstreamreader", "bitwriter", "bpf", "bpfasmparser", "bpfcodegen", "bpfdesc", "bpfdisassembler", "bpfinfo", "cfguard", "codegen", "core", "coroutines", "coverage", "debuginfocodeview", "debuginfodwarf", "debuginfogsym", "debuginfomsf", "debuginfopdb", "demangle", "dlltooldriver", "dwarflinker", "engine", "executionengine", "frontendopenmp", "fuzzmutate", "globalisel", "hexagon", "hexagonasmparser", "hexagoncodegen", "hexagondesc", "hexagondisassembler", "hexagoninfo", "instcombine", "instrumentation", "interpreter", "ipo", "irreader", "jitlink", "lanai", "lanaiasmparser", "lanaicodegen", "lanaidesc", "lanaidisassembler", "lanaiinfo", "libdriver", "lineeditor", "linker", "lto", "mc", "mca", "mcdisassembler", "mcjit", "mcparser", "mips", "mipsasmparser", "mipscodegen", "mipsdesc", "mipsdisassembler", "mipsinfo", "mirparser", "msp430", "msp430asmparser", "msp430codegen", "msp430desc", "msp430disassembler", "msp430info", "native", "nativecodegen", "nvptx", "nvptxcodegen", "nvptxdesc", "nvptxinfo", "objcarcopts", "object", "objectyaml", "option", "orcerror", "orcjit", "passes", "perfjitevents", "powerpc", "powerpcasmparser", "powerpccodegen", "powerpcdesc", "powerpcdisassembler", "powerpcinfo", "profiledata", "remarks", "riscv", "riscvasmparser", "riscvcodegen", "riscvdesc", "riscvdisassembler", "riscvinfo", "riscvutils", "runtimedyld", "scalaropts", "selectiondag", "sparc", "sparcasmparser", "sparccodegen", "sparcdesc", "sparcdisassembler", "sparcinfo", "support", "symbolize", "systemz", "systemzasmparser", "systemzcodegen", "systemzdesc", "systemzdisassembler", "systemzinfo", "tablegen", "target", "textapi", "transformutils", "vectorize", "webassembly", "webassemblyasmparser", "webassemblycodegen", "webassemblydesc", "webassemblydisassembler", "webassemblyinfo", "windowsmanifest", "x86", "x86asmparser", "x86codegen", "x86desc", "x86disassembler", "x86info", "x86utils", "xcore", "xcorecodegen", "xcoredesc", "xcoredisassembler", "xcoreinfo", "xray"]
+    TARGETS_BUILT = ["AArch64", "AMDGPU", "ARM", "BPF", "Hexagon", "Lanai", "Mips", "MSP430", "NVPTX", "PowerPC", "RISCV", "Sparc", "SystemZ", "WebAssembly", "X86", "XCore", "AVR"]
     HOST_TARGET = "x86_64-pc-linux-gnu "
-    BUILD_MODE = "Release "
-    CFLAGS = "-I/usr/lib/llvm-3.5/include  -DNDEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -g -O2 -fomit-frame-pointer -fPIC "
+    BUILD_MODE = "RelWithDebInfo "
+    CFLAGS = "-I/usr/lib/llvm-10/include  -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS "
   end
 end

data/lib/llvm/core.rb

@@ -6,6 +6,49 @@ module LLVM
   # @private
   module C
     attach_function :dispose_message, :LLVMDisposeMessage, [:pointer], :void
+
+    # typedef unsigned LLVMAttributeIndex;
+    typedef(:uint, :llvmattributeindex)
+
+    # void LLVMAddAttributeAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef A);
+    attach_function :add_attribute_at_index, :LLVMAddAttributeAtIndex, [:pointer, :llvmattributeindex, :pointer], :void
+
+    # void LLVMRemoveEnumAttributeAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID);
+    attach_function :remove_enum_attribute_at_index, :LLVMRemoveEnumAttributeAtIndex, [:pointer, :llvmattributeindex, :uint], :void
+
+    # LLVMAttributeRef LLVMCreateEnumAttribute
+    # (LLVMContextRef C, unsigned KindID, uint64_t Val);
+    attach_function :create_enum_attribute, :LLVMCreateEnumAttribute, [:pointer, :uint, :uint64], :pointer
+
+    # unsigned LLVMGetEnumAttributeKindForName
+    # (const char *Name, size_t SLen);
+    attach_function :get_enum_attribute_kind_for_name, :LLVMGetEnumAttributeKindForName, [:pointer, :size_t], :uint
+
+    # unsigned LLVMGetAttributeCountAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx);
+    attach_function :get_attribute_count_at_index, :LLVMGetAttributeCountAtIndex, [:pointer, :llvmattributeindex], :uint
+
+    # void LLVMGetAttributesAtIndex
+    # (LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs);
+    attach_function :get_attributes_at_index, :LLVMGetAttributesAtIndex, [:pointer, :llvmattributeindex, :pointer], :void
+
+    # unsigned LLVMGetEnumAttributeKind
+    # (LLVMAttributeRef A);
+    attach_function :get_enum_attribute_kind, :LLVMGetEnumAttributeKind, [:pointer], :uint
+
+    # uint64_t LLVMGetEnumAttributeValue
+    # (LLVMAttributeRef A);
+    attach_function :get_enum_attribute_value, :LLVMGetEnumAttributeKind, [:pointer], :uint64
+
+    # const char *LLVMGetStringAttributeKind
+    # (LLVMAttributeRef A, unsigned *Length);
+    attach_function :get_string_attribute_kind, :LLVMGetStringAttributeKind, [:pointer, :pointer], :pointer
+
+    # const char *LLVMGetStringAttributeValue
+    # (LLVMAttributeRef A, unsigned *Length);
+    attach_function :get_string_attribute_value, :LLVMGetStringAttributeValue, [:pointer, :pointer], :pointer
   end
 
   # Yields a pointer suitable for storing an LLVM output message.
@@ -23,7 +66,7 @@ module LLVM
       msg_ptr = str.read_pointer
 
       if result != 0
-        raise RuntimeError, "Error is signalled, but msg_ptr is null" if msg_ptr.null?
+        raise "Error is signalled, but msg_ptr is null" if msg_ptr.null?
 
         message = msg_ptr.read_string
         C.dispose_message msg_ptr
@@ -41,7 +84,7 @@ module LLVM
   def self.with_error_output(&block)
     error = with_message_output(&block)
 
-    raise RuntimeError, error unless error.nil?
+    raise error unless error.nil?
   end
 
   require 'llvm/core/context'

data/lib/llvm/core/bitcode.rb

@@ -9,7 +9,7 @@ module LLVM
       memory_buffer = case path_or_memory_buffer
                       when MemoryBuffer then path_or_memory_buffer
                       else MemoryBuffer.from_file(path_or_memory_buffer)
-                      end
+      end
       FFI::MemoryPointer.new(:pointer) do |mod_ref|
         FFI::MemoryPointer.new(:pointer) do |msg_ref|
           status = C.parse_bitcode(memory_buffer, mod_ref, msg_ref)
@@ -24,15 +24,15 @@ module LLVM
     # @return [true, false] Success
     def write_bitcode(path_or_io)
       status = if path_or_io.respond_to?(:path)
-                 C.write_bitcode_to_file(self, path_or_io.path)
-               elsif path_or_io.respond_to?(:fileno)
-                 C.write_bitcode_to_fd(self, path_or_io.fileno, 0, 1)
-               elsif path_or_io.kind_of?(Integer)
-                 C.write_bitcode_to_fd(self, path_or_io, 0, 1)
-               else
-                 C.write_bitcode_to_file(self, path_or_io.to_str)
-               end
-      return status == 0
+        C.write_bitcode_to_file(self, path_or_io.path)
+      elsif path_or_io.respond_to?(:fileno)
+        C.write_bitcode_to_fd(self, path_or_io.fileno, 0, 1)
+      elsif path_or_io.kind_of?(Integer)
+        C.write_bitcode_to_fd(self, path_or_io, 0, 1)
+      else
+        C.write_bitcode_to_file(self, path_or_io.to_str)
+      end
+      status == 0
     end
   end
 

data/lib/llvm/core/bitcode_ffi.rb

@@ -4,105 +4,129 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-3.5.so.1", "LLVM-3.5"]
-  
+  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)
-  # 
+  #
   # @method parse_bitcode(mem_buf, out_module, out_message)
-  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf 
-  # @param [FFI::Pointer(*ModuleRef)] out_module 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_module
+  # @param [FFI::Pointer(**CharS)] out_message
+  # @return [Integer]
   # @scope class
   attach_function :parse_bitcode, :LLVMParseBitcode, [:pointer, :pointer, :pointer], :int
-  
+
+  # (Not documented)
+  #
+  # @method parse_bitcode2(mem_buf, out_module)
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_module
+  # @return [Integer]
+  # @scope class
+  attach_function :parse_bitcode2, :LLVMParseBitcode2, [:pointer, :pointer], :int
+
   # (Not documented)
-  # 
+  #
   # @method parse_bitcode_in_context(context_ref, mem_buf, out_module, out_message)
-  # @param [FFI::Pointer(ContextRef)] context_ref 
-  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf 
-  # @param [FFI::Pointer(*ModuleRef)] out_module 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ContextRef)] context_ref
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_module
+  # @param [FFI::Pointer(**CharS)] out_message
+  # @return [Integer]
   # @scope class
   attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [:pointer, :pointer, :pointer, :pointer], :int
-  
+
   # (Not documented)
-  # 
+  #
+  # @method parse_bitcode_in_context2(context_ref, mem_buf, out_module)
+  # @param [FFI::Pointer(ContextRef)] context_ref
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_module
+  # @return [Integer]
+  # @scope class
+  attach_function :parse_bitcode_in_context2, :LLVMParseBitcodeInContext2, [:pointer, :pointer, :pointer], :int
+
+  # (Not documented)
+  #
   # @method get_bitcode_module_in_context(context_ref, mem_buf, out_m, out_message)
-  # @param [FFI::Pointer(ContextRef)] context_ref 
-  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf 
-  # @param [FFI::Pointer(*ModuleRef)] out_m 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ContextRef)] context_ref
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_m
+  # @param [FFI::Pointer(**CharS)] out_message
+  # @return [Integer]
   # @scope class
   attach_function :get_bitcode_module_in_context, :LLVMGetBitcodeModuleInContext, [:pointer, :pointer, :pointer, :pointer], :int
-  
+
   # (Not documented)
-  # 
-  # @method get_bitcode_module(mem_buf, out_m, out_message)
-  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf 
-  # @param [FFI::Pointer(*ModuleRef)] out_m 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  #
+  # @method get_bitcode_module_in_context2(context_ref, mem_buf, out_m)
+  # @param [FFI::Pointer(ContextRef)] context_ref
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_m
+  # @return [Integer]
   # @scope class
-  attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [:pointer, :pointer, :pointer], :int
-  
+  attach_function :get_bitcode_module_in_context2, :LLVMGetBitcodeModuleInContext2, [:pointer, :pointer, :pointer], :int
+
   # (Not documented)
-  # 
-  # @method get_bitcode_module_provider_in_context(context_ref, mem_buf, out_mp, out_message)
-  # @param [FFI::Pointer(ContextRef)] context_ref 
-  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf 
-  # @param [FFI::Pointer(*ModuleProviderRef)] out_mp 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  #
+  # @method get_bitcode_module(mem_buf, out_m, out_message)
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_m
+  # @param [FFI::Pointer(**CharS)] out_message
+  # @return [Integer]
   # @scope class
-  attach_function :get_bitcode_module_provider_in_context, :LLVMGetBitcodeModuleProviderInContext, [:pointer, :pointer, :pointer, :pointer], :int
-  
+  attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [:pointer, :pointer, :pointer], :int
+
   # (Not documented)
-  # 
-  # @method get_bitcode_module_provider(mem_buf, out_mp, out_message)
-  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf 
-  # @param [FFI::Pointer(*ModuleProviderRef)] out_mp 
-  # @param [FFI::Pointer(**CharS)] out_message 
-  # @return [Integer] 
+  #
+  # @method get_bitcode_module2(mem_buf, out_m)
+  # @param [FFI::Pointer(MemoryBufferRef)] mem_buf
+  # @param [FFI::Pointer(*ModuleRef)] out_m
+  # @return [Integer]
   # @scope class
-  attach_function :get_bitcode_module_provider, :LLVMGetBitcodeModuleProvider, [:pointer, :pointer, :pointer], :int
-  
+  attach_function :get_bitcode_module2, :LLVMGetBitcodeModule2, [:pointer, :pointer], :int
+
   # Writes a module to the specified path. Returns 0 on success.
-  # 
+  #
   # @method write_bitcode_to_file(m, path)
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @param [String] path 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [String] path
+  # @return [Integer]
   # @scope class
   attach_function :write_bitcode_to_file, :LLVMWriteBitcodeToFile, [:pointer, :string], :int
-  
+
   # Writes a module to an open file descriptor. Returns 0 on success.
-  # 
+  #
   # @method write_bitcode_to_fd(m, fd, should_close, unbuffered)
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @param [Integer] fd 
-  # @param [Integer] should_close 
-  # @param [Integer] unbuffered 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [Integer] fd
+  # @param [Integer] should_close
+  # @param [Integer] unbuffered
+  # @return [Integer]
   # @scope class
   attach_function :write_bitcode_to_fd, :LLVMWriteBitcodeToFD, [:pointer, :int, :int, :int], :int
-  
+
   # Deprecated for LLVMWriteBitcodeToFD. Writes a module to an open file
   #     descriptor. Returns 0 on success. Closes the Handle.
-  # 
+  #
   # @method write_bitcode_to_file_handle(m, handle)
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @param [Integer] handle 
-  # @return [Integer] 
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [Integer] handle
+  # @return [Integer]
   # @scope class
   attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [:pointer, :int], :int
-  
+
+  # Writes a module to a new memory buffer and returns it.
+  #
+  # @method write_bitcode_to_memory_buffer(m)
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @return [FFI::Pointer(MemoryBufferRef)]
+  # @scope class
+  attach_function :write_bitcode_to_memory_buffer, :LLVMWriteBitcodeToMemoryBuffer, [:pointer], :pointer
 end