llrb 0.0.1

data/ext/llrb/cruby_extra/probes.h

@@ -0,0 +1,80 @@
+/* -*- c -*- */
+
+#ifndef	_PROBES_H
+#define	_PROBES_H
+#define DTRACE_PROBES_DISABLED 1
+
+#define RUBY_DTRACE_METHOD_ENTRY_ENABLED() 0
+#define RUBY_DTRACE_METHOD_ENTRY(classname, methodname, filename, lineno) do {} while (0)
+#define RUBY_DTRACE_METHOD_RETURN_ENABLED() 0
+#define RUBY_DTRACE_METHOD_RETURN(classname, methodname, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() 0
+#define RUBY_DTRACE_CMETHOD_ENTRY(classname, methodname, filename, lineno) do {} while (0)
+#define RUBY_DTRACE_CMETHOD_RETURN_ENABLED() 0
+#define RUBY_DTRACE_CMETHOD_RETURN(classname, methodname, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_REQUIRE_ENTRY_ENABLED() 0
+#define RUBY_DTRACE_REQUIRE_ENTRY(rquiredfile, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_REQUIRE_RETURN_ENABLED() 0
+#define RUBY_DTRACE_REQUIRE_RETURN(requiredfile, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_FIND_REQUIRE_ENTRY_ENABLED() 0
+#define RUBY_DTRACE_FIND_REQUIRE_ENTRY(requiredfile, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_FIND_REQUIRE_RETURN_ENABLED() 0
+#define RUBY_DTRACE_FIND_REQUIRE_RETURN(requiredfile, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_LOAD_ENTRY_ENABLED() 0
+#define RUBY_DTRACE_LOAD_ENTRY(loadedfile, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_LOAD_RETURN_ENABLED() 0
+#define RUBY_DTRACE_LOAD_RETURN(loadedfile, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_RAISE_ENABLED() 0
+#define RUBY_DTRACE_RAISE(classname, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_OBJECT_CREATE_ENABLED() 0
+#define RUBY_DTRACE_OBJECT_CREATE(classname, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_ARRAY_CREATE_ENABLED() 0
+#define RUBY_DTRACE_ARRAY_CREATE(length, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_HASH_CREATE_ENABLED() 0
+#define RUBY_DTRACE_HASH_CREATE(length, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_STRING_CREATE_ENABLED() 0
+#define RUBY_DTRACE_STRING_CREATE(length, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_SYMBOL_CREATE_ENABLED() 0
+#define RUBY_DTRACE_SYMBOL_CREATE(str, filename, lineno) do {} while (0)
+
+#define RUBY_DTRACE_PARSE_BEGIN_ENABLED() 0
+#define RUBY_DTRACE_PARSE_BEGIN(sourcefile, lineno) do {} while (0)
+
+#define RUBY_DTRACE_PARSE_END_ENABLED() 0
+#define RUBY_DTRACE_PARSE_END(sourcefile, lineno) do {} while (0)
+
+#define RUBY_DTRACE_INSN_ENABLED() 0
+#define RUBY_DTRACE_INSN(insns_name) do {} while (0)
+#define RUBY_DTRACE_INSN_OPERAND_ENABLED() 0
+#define RUBY_DTRACE_INSN_OPERAND(val, insns_name) do {} while (0)
+
+#define RUBY_DTRACE_GC_MARK_BEGIN_ENABLED() 0
+#define RUBY_DTRACE_GC_MARK_BEGIN() do {} while (0)
+
+#define RUBY_DTRACE_GC_MARK_END_ENABLED() 0
+#define RUBY_DTRACE_GC_MARK_END() do {} while (0)
+
+#define RUBY_DTRACE_GC_SWEEP_BEGIN_ENABLED() 0
+#define RUBY_DTRACE_GC_SWEEP_BEGIN() do {} while (0)
+
+#define RUBY_DTRACE_GC_SWEEP_END_ENABLED() 0
+#define RUBY_DTRACE_GC_SWEEP_END() do {} while (0)
+
+#define RUBY_DTRACE_METHOD_CACHE_CLEAR_ENABLED() 0
+#define RUBY_DTRACE_METHOD_CACHE_CLEAR(class, filename, lineno) do {} while (0)
+
+#endif	/* _PROBES_H */
+

data/ext/llrb/extconf.rb

@@ -0,0 +1,102 @@
+require 'mkmf'
+
+module LLRBExtconf
+  class << self
+    def configure
+      remove_invalid_warnflags
+      add_cflags
+      link_llvm
+    end
+
+    def compile_bitcodes
+      Dir.chdir(extdir) { Dir.glob('*.c') }.each do |c_file|
+        compile_bitcode(c_file, c_file.sub(/\.c\z/, '.bc'))
+      end
+    end
+
+    private
+
+    def remove_invalid_warnflags
+      # cc1plus: warning: command line option ‘-Wimplicit-int’ is valid for C/ObjC but not for C++
+      # cc1plus: warning: command line option ‘-Wdeclaration-after-statement’ is valid for C/ObjC but not for C++
+      # cc1plus: warning: command line option ‘-Wimplicit-function-declaration’ is valid for C/ObjC but not for C++
+      # cc1plus: warning: unrecognized command line option ‘-Wno-self-assign’
+      # cc1plus: warning: unrecognized command line option ‘-Wno-constant-logical-operand’
+      # cc1plus: warning: unrecognized command line option ‘-Wno-parentheses-equality’
+      # cc1plus: warning: unrecognized command line option ‘-Wno-tautological-compare’
+      %w[
+        -Wimplicit-int
+        -Wdeclaration-after-statement
+        -Wimplicit-function-declaration
+        -Wno-self-assign
+        -Wno-constant-logical-operand
+        -Wno-parentheses-equality
+        -Wno-tautological-compare
+      ].each do |flag|
+        CONFIG['warnflags'].gsub!(flag, '')
+      end
+    end
+
+    def add_cflags
+      # To include ccan/*, add ext/llrb/cruby under include path. "cruby_extra" dir has CRuby's dynamic headers.
+      $INCFLAGS = "#{$INCFLAGS} -I$(srcdir)/cruby -I$(srcdir)/cruby_extra"
+
+      bitcode_dir = File.expand_path("#{__dir__}/..")
+      $CFLAGS = "#{$CFLAGS} -DLLRB_BITCODE_DIR='\"#{bitcode_dir}\"' -Wall -Werror -W" # remove -Werror later
+      $CXXFLAGS = "#{$CXXFLAGS} -Wall -Werror -W" # remove -Werror later
+    end
+
+    def link_llvm
+      unless system('which llvm-config 2>&1 >/dev/null')
+        raise "llvm-config(1) must be available!\nNot found in PATH='#{ENV['PATH']}'"
+      end
+
+      $CFLAGS = "#{$CFLAGS} #{`llvm-config --cflags`.rstrip}"
+      $CXXFLAGS = "#{$CXXFLAGS} #{`llvm-config --cxxflags`.rstrip}"
+      $LDFLAGS = "#{$LDFLAGS} #{`llvm-config --ldflags`.rstrip} #{`llvm-config --libs core engine passes`}"
+    end
+
+    def compile_bitcode(c_file, bc_file)
+      unless bc_file.end_with?('.bc')
+        raise ArgumentError, "bitcode file should end with .bc but got '#{bc_file}'"
+      end
+      ll_file = bc_file.sub(/\.bc\z/, '.ll')
+
+      incflags = [
+        __dir__,
+        "#{__dir__}/cruby",
+        "#{__dir__}/cruby_extra",
+        RbConfig::CONFIG['rubyhdrdir'],
+        RbConfig::CONFIG['rubyarchhdrdir'],
+      ].map {|d| "-I#{d}" }.join(' ')
+
+      ruby_cflags = RbConfig::CONFIG['cflags'].dup.tap do |flags|
+        %w[
+          -Wno-packed-bitfield-compat
+          -Wsuggest-attribute=noreturn
+          -Wsuggest-attribute=format
+          -Wno-maybe-uninitialized
+        ].each { |f| flags.sub!(f, '') } # maybe caused by compiling ruby with gcc and this with clang.
+      end
+
+      debug_flags = "-Xclang -print-stats" if false
+
+      sh "clang #{incflags} #{ruby_cflags} #{debug_flags} -Werror -O2 -S -emit-llvm -o #{extdir}/#{ll_file} #{extdir}/#{c_file}" # remove -Werror later
+      sh "llvm-as -o #{extdir}/#{bc_file} #{extdir}/#{ll_file}"
+    end
+
+    def sh(command)
+      $stderr.puts command
+      system(command) || raise("Failed to execute '#{command}'")
+    end
+
+    def extdir
+      File.expand_path("#{__dir__}/..")
+    end
+  end
+end
+
+LLRBExtconf.compile_bitcodes
+LLRBExtconf.configure
+
+create_makefile('llrb/llrb')

data/ext/llrb/llrb.c

@@ -0,0 +1,148 @@
+/*
+ * llrb.c: Has Ruby interface and native code generation.
+ *
+ * LLRB's internal design:
+ *   parser.c:     llrb_parse_iseq()         # ISeq -> Control Flow Graph
+ *   compiler.c:   llrb_compile_cfg()        # Control Flow Graph -> LLVM IR
+ *   optimizer.cc: llrb_optimize_function()  # LLVM IR -> optimized LLVM IR
+ *   llrb.c:       llrb_create_native_func() # optimized LLVM IR -> Native code
+ */
+#include <stdbool.h>
+#include "llvm-c/Core.h"
+#include "llvm-c/ExecutionEngine.h"
+#include "cruby.h"
+#include "cruby_extra/insns.inc"
+
+static const char *llrb_funcname = "llrb_exec";
+
+LLVMModuleRef llrb_compile_iseq(const struct rb_iseq_constant_body *body, const VALUE *new_iseq_encoded, const char* funcname);
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
+
+static uint64_t
+llrb_create_native_func(LLVMModuleRef mod, const char *funcname)
+{
+  LLVMExecutionEngineRef engine;
+  char *error;
+  if (LLVMCreateJITCompilerForModule(&engine, mod, LLVMCodeGenLevelAggressive, &error) != 0) {
+    fprintf(stderr, "Failed to create JIT compiler...\n");
+
+    if (error) {
+      fprintf(stderr, "LLVMCreateJITCompilerForModule: %s\n", error);
+      LLVMDisposeMessage(error);
+      return 0;
+    }
+  }
+  return LLVMGetFunctionAddress(engine, funcname);
+}
+
+static void
+llrb_replace_iseq_with_cfunc(const rb_iseq_t *iseq, VALUE *new_iseq_encoded, rb_insn_func_t funcptr)
+{
+  new_iseq_encoded[0] = (VALUE)rb_vm_get_insns_address_table()[YARVINSN_opt_call_c_function];
+  new_iseq_encoded[1] = (VALUE)funcptr;
+
+  // JIT code may change program counter to address after `new_iseq_encoded[2]` to get `catch_table` work.
+  // So filling "leave" insns is necessary here.
+  for (unsigned int i = 2; i < iseq->body->iseq_size; i++) {
+    // Is there a case that last insn is not "leave"?
+    new_iseq_encoded[i] = (VALUE)rb_vm_get_insns_address_table()[YARVINSN_leave];
+  }
+
+  // Changing iseq->body->iseq_encoded will not break threads executing old iseq_encoded
+  // because program counter will still point to old iseq's address. This operation is considered safe.
+  // But in the same time it's hard to free memory of old iseq_encoded.
+  iseq->body->iseq_encoded = new_iseq_encoded;
+}
+
+static bool
+llrb_check_already_compiled(const rb_iseq_t *iseq)
+{
+  return iseq->body->iseq_size >= 3
+    && iseq->body->iseq_encoded[0] == (VALUE)rb_vm_get_insns_address_table()[YARVINSN_opt_call_c_function]
+    && iseq->body->iseq_encoded[2] == (VALUE)rb_vm_get_insns_address_table()[YARVINSN_leave];
+}
+
+static bool
+llrb_should_not_compile(const rb_iseq_t *iseq)
+{
+  extern bool llrb_check_not_compilable(const rb_iseq_t *iseq);
+  return llrb_check_already_compiled(iseq) || llrb_check_not_compilable(iseq);
+}
+
+// LLRB::JIT.preview_iseq
+// @param  [Array]   iseqw - RubyVM::InstructionSequence instance
+// @return [Boolean] return true if compiled
+static VALUE
+rb_jit_preview_iseq(RB_UNUSED_VAR(VALUE self), VALUE iseqw)
+{
+  const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+  if (llrb_should_not_compile(iseq)) return Qfalse;
+
+  LLVMModuleRef mod = llrb_compile_iseq(iseq->body, iseq->body->iseq_encoded, llrb_funcname);
+  LLVMDumpModule(mod);
+  LLVMDisposeModule(mod);
+  return Qtrue;
+}
+
+// Used by profiler.c too
+VALUE
+llrb_compile_iseq_to_method(const rb_iseq_t *iseq)
+{
+  if (llrb_should_not_compile(iseq)) return Qfalse;
+
+  // Creating new_iseq_encoded before compilation to calculate program counter.
+  VALUE *new_iseq_encoded = ALLOC_N(VALUE, iseq->body->iseq_size); // Never freed.
+  LLVMModuleRef mod = llrb_compile_iseq(iseq->body, new_iseq_encoded, llrb_funcname);
+
+  uint64_t func = llrb_create_native_func(mod, llrb_funcname);
+  //LLVMDisposeModule(mod); // This causes SEGV: "corrupted double-linked list".
+  if (!func) {
+    fprintf(stderr, "Failed to create native function...\n");
+    return Qfalse;
+  }
+
+  llrb_replace_iseq_with_cfunc(iseq, new_iseq_encoded, (rb_insn_func_t)func);
+  return Qtrue;
+}
+
+// LLRB::JIT.compile_iseq
+// @param  [Array]   iseqw  - RubyVM::InstructionSequence instance
+// @return [Boolean] return true if compiled
+static VALUE
+rb_jit_compile_iseq(RB_UNUSED_VAR(VALUE self), VALUE iseqw)
+{
+  const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+  return llrb_compile_iseq_to_method(iseq);
+}
+
+static VALUE
+rb_jit_is_compiled(RB_UNUSED_VAR(VALUE self), VALUE iseqw)
+{
+  const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+  return llrb_check_already_compiled(iseq) ? Qtrue : Qfalse;
+}
+
+void
+Init_llrb(void)
+{
+  // Required to generate native code.
+  LLVMInitializeNativeTarget();
+  LLVMInitializeNativeAsmPrinter();
+  LLVMInitializeNativeAsmParser();
+  LLVMLinkInMCJIT();
+
+  VALUE rb_mLLRB = rb_define_module("LLRB");
+  VALUE rb_mJIT = rb_define_module_under(rb_mLLRB, "JIT");
+  rb_define_singleton_method(rb_mJIT, "preview_iseq", RUBY_METHOD_FUNC(rb_jit_preview_iseq), 1);
+  rb_define_singleton_method(rb_mJIT, "compile_iseq", RUBY_METHOD_FUNC(rb_jit_compile_iseq), 1);
+  rb_define_singleton_method(rb_mJIT, "is_compiled",  RUBY_METHOD_FUNC(rb_jit_is_compiled), 1);
+
+  extern void Init_profiler(VALUE rb_mJIT);
+  Init_profiler(rb_mJIT);
+
+  extern void Init_parser(VALUE rb_mJIT);
+  Init_parser(rb_mJIT);
+
+  extern void Init_compiler(VALUE rb_mJIT);
+  Init_compiler(rb_mJIT);
+}

data/ext/llrb/optimizer.cc

@@ -0,0 +1,118 @@
+/*
+ * optimizer.cc: Optimizes LLVM IR using LLVM Passes.
+ *
+ * This file is created as C++ file for following 2 reasons:
+ *
+ *   1. LLVM needs to be linked by C++ linker, even if we use LLVM-C API.
+ *      C extension is linked using C++ linker if we have *.cc file.
+ *      We should find a better way to do that.
+ *
+ *   2. Just to make it easy to port opt(1)'s code. Sometimes LLVM-C APIs
+ *      don't include C++'s ones. But it looks current implementation
+ *      doesn't depend on such APIs. So this reason can be fixed.
+ *
+ */
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Verifier.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Transforms/IPO.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
+#include "llvm/Transforms/Scalar.h"
+
+namespace llrb {
+
+static inline std::string GetFeaturesStr()
+{
+  llvm::SubtargetFeatures ret;
+  llvm::StringMap<bool> features;
+
+  if (llvm::sys::getHostCPUFeatures(features)) {
+    for (auto &feature : features) {
+      ret.AddFeature(feature.first(), feature.second);
+    }
+  }
+
+  return ret.getString();
+}
+
+// Setting function attributes is required for function inlining.
+static void
+SetFunctionAttributes(llvm::Module *mod)
+{
+  std::string cpu = llvm::sys::getHostCPUName();
+  std::string features = GetFeaturesStr();
+
+  for (auto &func : *mod) {
+    auto &ctx = func.getContext();
+    llvm::AttributeSet attrs = func.getAttributes(), newAttrs;
+
+    if (!cpu.empty()) {
+      newAttrs = newAttrs.addAttribute(ctx, llvm::AttributeSet::FunctionIndex, "target-cpu", cpu);
+    }
+    if (!features.empty()) {
+      newAttrs = newAttrs.addAttribute(ctx, llvm::AttributeSet::FunctionIndex, "target-features", features);
+    }
+
+    newAttrs = attrs.addAttributes(ctx, llvm::AttributeSet::FunctionIndex, newAttrs);
+    func.setAttributes(newAttrs);
+  }
+}
+
+static void
+RunFunctionPasses(llvm::Module *mod, llvm::Function *func)
+{
+  std::unique_ptr<llvm::legacy::FunctionPassManager> fpm;
+  fpm.reset(new llvm::legacy::FunctionPassManager(mod));
+
+  fpm->add(llvm::createVerifierPass());
+
+  llvm::PassManagerBuilder builder;
+  builder.OptLevel  = 3;
+  builder.SizeLevel = 0;
+  builder.populateFunctionPassManager(*fpm);
+
+  fpm->doInitialization();
+  for (llvm::Function &f : *mod) {
+    fpm->run(f);
+  }
+  fpm->doFinalization();
+}
+
+static void
+RunModulePasses(llvm::Module *mod)
+{
+  llvm::legacy::PassManager mpm;
+
+  llvm::PassManagerBuilder builder;
+  builder.OptLevel  = 3;
+  builder.SizeLevel = 0;
+  builder.Inliner = llvm::createFunctionInliningPass(builder.OptLevel, builder.SizeLevel);
+  builder.populateModulePassManager(mpm);
+
+  mpm.add(llvm::createVerifierPass());
+  mpm.run(*mod);
+}
+
+static void
+OptimizeFunction(llvm::Module *mod, llvm::Function *func)
+{
+  SetFunctionAttributes(mod);
+  RunFunctionPasses(mod, func);
+  RunModulePasses(mod);
+}
+
+} // namespace llrb
+
+extern "C" {
+void
+llrb_optimize_function(LLVMModuleRef cmod, LLVMValueRef cfunc)
+{
+  llvm::Module *mod = llvm::unwrap(cmod);
+  llvm::Function *func = llvm::unwrap<llvm::Function>(cfunc);
+  llrb::OptimizeFunction(mod, func);
+}
+} // extern "C"