ruby-llvm 3.4.0 → 11.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 878b8916b8491bdbe2853e9595d7e462f3409b7e
-  data.tar.gz: eb5a2758a1f1711f7f7832974459a00571ffe9bf
+SHA256:
+  metadata.gz: a863554200f16a07a9cd989d7a3dcd397c0e52e212308316cc39af2bb9a3394f
+  data.tar.gz: 79c3543ca89b7136dd3ff241b472738968fd74ffa7ec82713c6230590e0d8149
 SHA512:
-  metadata.gz: 76d69849283e05f5ef6352c4f2e0acd60184ff16c1835485163327bff58c0401b99ea4d2562aa996d1a721b1c04a95befca5eb3a5feec128d712f82a121f4944
-  data.tar.gz: 21a27d8d676573270a0e412e76d2e29ad1649b8850297fe51a7f370dbeca127fb4fd7f8ac235e0c286c1d0c3206f90f58966681e5149789945d32a962a3a739e
+  metadata.gz: caac65e20ca51936477266a9b5e41f18786f55ee347efbc86773be12f98074764baea28f27e9e0c0a39e658fc8b82da97d91fc7940654f3f8d4467c257eec91c
+  data.tar.gz: '020822c2c9e802ad4483ae25863a4e0aa43a24e9e397b74caa902ad5f84f7c1803a662ca099b65d212b6a8ab70e35d049ab0a28789ec33719611e5a43af34ef0'

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-11 (specifically llvm-c 11).
 
 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
 
@@ -32,8 +32,11 @@ def find_llvm_config
 
     begin
       actual_version = `#{llvm_config} --version`.strip
+      actual_maj, actual_min, _ = actual_version.split('.')
 
-      actual_version == LLVM_VERSION
+      required_maj, required_min = LLVM_REQUIRED_VERSION.split('.')
+
+      actual_maj == required_maj && actual_min == required_min
     rescue Errno::ENOENT
       false
     end
@@ -41,8 +44,8 @@ def find_llvm_config
 end
 
 def find_cxx
-  check_for('C++ compiler', %W(clang++ g++), 'CXX') do |cxx|
-    system(cxx, "--version", out: :close, err: :close)
+  check_for('C++ compiler', %W(g++ clang++), 'CXX') do |cxx|
+    system(cxx, "--version", out: File::NULL, err: File::NULL)
     $?.success?
   end
 end
@@ -51,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}")
@@ -63,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 -lLLVM-#{LLVM_VERSION} #{task.prerequisites.join(' ')} " \
-     "#{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 = [
@@ -73,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/ext/ruby-llvm-support/support.cpp

@@ -2,29 +2,9 @@
  * Extended bindings for LLVM.
  */
 
-#include <llvm-c/Core.h>
-#include <llvm/IR/Type.h>
-#include <llvm/IR/Module.h>
-#include <llvm/IR/GlobalValue.h>
-#include <llvm/Support/DynamicLibrary.h>
 #include <llvm/Support/TargetSelect.h>
-#include <llvm/Support/raw_ostream.h>
 
 extern "C" {
-  using namespace llvm;
-
-  int LLVMLoadLibraryPermanently(const char* filename) {
-    return llvm::sys::DynamicLibrary::LoadLibraryPermanently(filename);
-  }
-
-  LLVMBool LLVMHasUnnamedAddr(LLVMValueRef global) {
-    return unwrap<GlobalValue>(global)->hasUnnamedAddr();
-  }
-
-  void LLVMSetUnnamedAddr(LLVMValueRef global, LLVMBool val) {
-    unwrap<GlobalValue>(global)->setUnnamedAddr(val != 0);
-  }
-
   void LLVMInitializeAllTargetInfos() {
     llvm::InitializeAllTargetInfos();
   }

data/lib/llvm.rb

@@ -4,12 +4,6 @@ module LLVM
   require 'llvm/version'
   require 'llvm/support'
 
-  # @private
-  module C
-    extend ::FFI::Library
-    ffi_lib ["LLVM-#{LLVM_VERSION}"]
-  end
-
   module PointerIdentity
     # @private
     def to_ptr

data/lib/llvm/analysis_ffi.rb

@@ -4,26 +4,29 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.4'
-  
+  ffi_lib ["libLLVM-11.so.1", "libLLVM.so.11", "LLVM-11"]
+
   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)
-  # 
+
+  # @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
@@ -32,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", "linker", "lto", "mc", "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", "powerpcinfo", "r600", "r600asmprinter", "r600codegen", "r600desc", "r600info", "runtimedyld", "scalaropts", "selectiondag", "sparc", "sparccodegen", "sparcdesc", "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", "AArch64", "ARM", "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.4/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-11/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,107 +4,129 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.4'
-  
+  ffi_lib ["libLLVM-11.so.1", "libLLVM.so.11", "LLVM-11"]
+
   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
-  
-  # Reads a module from the specified path, returning via the OutMP parameter
-  #     a module provider which performs lazy deserialization. Returns 0 on success.
-  #     Optionally returns a human-readable error message via OutMessage.
-  # 
+
+  # (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_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_in_context2, :LLVMGetBitcodeModuleInContext2, [: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] 
+  # @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, :LLVMGetBitcodeModule, [:pointer, :pointer, :pointer], :int
-  
-  # Deprecated: Use LLVMGetBitcodeModuleInContext instead.
-  # 
-  # @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] 
-  # @scope class
-  attach_function :get_bitcode_module_provider_in_context, :LLVMGetBitcodeModuleProviderInContext, [:pointer, :pointer, :pointer, :pointer], :int
-  
-  # Deprecated: Use LLVMGetBitcodeModule instead.
-  # 
-  # @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] 
-  # @scope class
-  attach_function :get_bitcode_module_provider, :LLVMGetBitcodeModuleProvider, [:pointer, :pointer, :pointer], :int
-  
+
   # (Not documented)
-  # 
+  #
+  # @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_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