ruby-llvm 3.4.2 → 13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b4c3ca01e2020b5ce26bdf7db68f78f33d4fefbe
-  data.tar.gz: 4580027aed01abdc1c9055dfd4d3736f1fae4606
+SHA256:
+  metadata.gz: 93a0f0ec49145c009677352d8765f8c1f79d4aa0b88aa7c17bb005d4b18f44c1
+  data.tar.gz: '03604842f13d9f1108e36ff5f2089884fe3673f43a08866d8c73bb5135f05cb8'
 SHA512:
-  metadata.gz: b111187af62e59fd09acd472f241f0e64913832f956f99cf2fb3faf16806f7b61957840f4fe0246181a41521c9180d0b18420356915077635fa5a9690853b81e
-  data.tar.gz: 108a673c529d5b7621c7206f169b8704473cc518fafed2e10880f2f96fbe58537e8b2f47cab56b5ac0dabf3c2ef7affa9a0166c0e2cf1511a1ba98b5f6ed824e
+  metadata.gz: 0ef8e20027e12ea46c5f4764fe50f4e7e07aab58579e84c2692ad323c5fb2c6b77c329bc97ae742d226eba0c345c5b9e774ef8381f8336db8927d4d678159691
+  data.tar.gz: 29c3b9e27042468d2db9d6bf0745675390d665824fd0149e9c55617c6d4da1627635576ced6722e8638fd3061b46127b49aaf449ad5e957105a903409d23dd06

data/README.md

@@ -1,3 +1,7 @@
+[![Known Vulnerabilities](https://snyk.io/test/github/ruby-llvm/ruby-llvm/badge.svg)](https://snyk.io/test/github/ruby-llvm/ruby-llvm)
+[![Code Climate Maintainability](https://codeclimate.com/github/ruby-llvm/ruby-llvm/badges/gpa.svg)](https://codeclimate.com/github/ruby-llvm/ruby-llvm)
+[![Code Climate Issue Count](https://codeclimate.com/github/ruby-llvm/ruby-llvm/badges/issue_count.svg)](https://codeclimate.com/github/ruby-llvm/ruby-llvm/issues)
+
 Ruby-LLVM
 =========
 
@@ -7,10 +11,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-13 (specifically llvm-c 13).
 
 About version numbers
 ---------------------
@@ -20,13 +24,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/ext/ruby-llvm-support/support.cpp

@@ -2,21 +2,9 @@
  * Extended bindings for LLVM.
  */
 
-#include <llvm-c/Core.h>
-#include <llvm/IR/GlobalValue.h>
 #include <llvm/Support/TargetSelect.h>
 
 extern "C" {
-  using namespace llvm;
-
-  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/analysis_ffi.rb

@@ -4,26 +4,29 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.4'
-  
+  ffi_lib ["libLLVM-13.so.1", "libLLVM.so.13", "LLVM-13"]
+
   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/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-13.so.1", "libLLVM.so.13", "LLVM-13"]
+
   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

data/lib/llvm/core/builder.rb

@@ -118,8 +118,8 @@ module LLVM
     # @return [LLVM::Instruction]
     def switch(val, default, cases)
       inst = SwitchInst.from_ptr(C.build_switch(self, val, default, cases.size))
-      cases.each do |(val, block)|
-        inst.add_case(val, block)
+      cases.each do |(c, block)|
+        inst.add_case(c, block)
       end
       inst
     end
@@ -820,7 +820,6 @@ module LLVM
     # @return [LLVM::Instruction] The phi node
     # @LLVMinst phi
     def phi(ty, incoming, name = "")
-
       phi = Phi.from_ptr(C.build_phi(self, LLVM::Type(ty), name))
       phi.add_incoming(incoming)
       phi

data/lib/llvm/core/context.rb

@@ -1,4 +1,4 @@
-module LLVM  
+module LLVM
   class Context
     def initialize(ptr = nil)
       @ptr = ptr || C.context_create()

data/lib/llvm/core/pass_manager.rb

@@ -5,9 +5,11 @@ module LLVM
     # Creates a new pass manager.
     #
     # @param [LLVM::ExecutionEngine, LLVM::TargetMachine] machine
-    def initialize(machine)
+    def initialize(machine = nil)
+      if machine
+        warn("[DEPRECATION] PassManager.new should be called without parameters")
+      end
       @ptr = C.create_pass_manager()
-      C.add_target_data(machine.data_layout, @ptr)
     end
 
     # @private

data/lib/llvm/core/type.rb

@@ -33,7 +33,7 @@ module LLVM
 
     # Returns the type of this types elements (works only for Pointer, Vector, and Array types.)
     def element_type
-      case self.kind
+      case kind
       when :pointer, :vector, :array
         Type.from_ptr(C.get_element_type(self), nil)
       end
@@ -128,7 +128,7 @@ module LLVM
         C.get_param_types(self, types_ptr)
         result = types_ptr.read_array_of_pointer(size)
       end
-      result.map{ |p| Type.from_ptr(p, nil) }
+      result.map { |p| Type.from_ptr(p, nil) }
     end
 
     def vararg?