ruby-llvm 3.5.0 → 13.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e559929d919c913ffacaef820430b37093a23adc
-  data.tar.gz: d98b42343be29f103dbbb9f518cc304542d0fdff
+SHA256:
+  metadata.gz: e4728b4463e1ffaea0e8b00c976923fe77404b01c55ff3c25b015aa2fef5decf
+  data.tar.gz: 35e6017a7035f29b9a39cfd6cbf18116a181f9e2706b12c0318a251525250bc7
 SHA512:
-  metadata.gz: 3ad54d41292618fb2c48a56b89812e97ce66fd4a8708858d5137ac7064721fbe339eefe3c938f57af1c596acc8f019ff278f9e62d3a6e259e638cbd7dfcdd029
-  data.tar.gz: 2743c5a6ef7e374eb158f436d01ca39f1f0dd5f218957060f57fb54d5d205f14322ffc2957b39f4cf2f60e78feefd5cb314723fb11012d76885b0c001beecf6e
+  metadata.gz: 5353f3dfc22fcaa701ffa5bc70d5987e03a678881ad03a530ed99f4baada579396c9d8720a999cb9fff9fb93d4efad13fb2cd4ed6486b9a0658f54ad5676f663
+  data.tar.gz: 95cbae2bfda937b9d8eb1a821083bc04858a3e19942ffbf8c195671f51f817d17be2829c51015e3bcd9b699eb467e9dca127e0ff0bb743a2f76288180014846d

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'rake/clean'
 require 'ffi'
@@ -21,7 +23,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 +36,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 +56,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 +77,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 +87,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.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'llvm'
 require 'llvm/core'
 require 'llvm/target'

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-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
-  
+
   # @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-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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'llvm/core/bitcode_ffi'
 
 module LLVM
@@ -9,7 +11,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 +26,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-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
-  
+
   # (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

data/lib/llvm/core/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LLVM
   class Builder
     # Important: Call #dispose to free backend memory after use.
@@ -118,8 +120,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 +822,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,6 @@
-module LLVM  
+# frozen_string_literal: true
+
+module LLVM
   class Context
     def initialize(ptr = nil)
       @ptr = ptr || C.context_create()

data/lib/llvm/core/module.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LLVM
   class Module
     include PointerIdentity

data/lib/llvm/core/pass_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LLVM
   # The PassManager runs a queue of passes on a module. See
   # http://llvm.org/docs/Passes.html for the list of available passes.
@@ -5,9 +7,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module LLVM
   class Type
     include PointerIdentity
@@ -33,7 +35,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
@@ -59,6 +61,11 @@ module LLVM
       C.dump_type(self)
     end
 
+    # Build string of LLVM type representation.
+    def to_s
+      C.print_type_to_string(self)
+    end
+
     # Creates an array type of Type with the given size.
     def self.array(ty, sz = 0)
       from_ptr(C.array_type(LLVM::Type(ty), sz), :array)
@@ -128,7 +135,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?