WIP: Feature: ExecutionEngine - initial

CMakeLists.txt

@@ -22,7 +22,7 @@ file(GLOB SOURCE_FILES
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 
-llvm_map_components_to_libnames(llvm_libs ${LLVM_TARGETS_TO_BUILD} bitwriter codegen core support tablegen target)
+llvm_map_components_to_libnames(llvm_libs ${LLVM_TARGETS_TO_BUILD} bitwriter codegen core support tablegen target executionengine)
 
 # Link against LLVM libraries
 target_link_libraries(${PROJECT_NAME} ${llvm_libs} ${CMAKE_JS_LIB} )

llvm-node.d.ts

@@ -683,6 +683,14 @@ declare namespace llvm {
     getTypeByName(name: string): StructType | null;
   }
 
+  class ExecutionEngine {
+    /**
+     * Add a Module to the list of modules that we can JIT from.
+     * @param module
+     */
+    addModule(module: Module): void;
+  }
+
   // support
   class TargetRegistry {
     private constructor();

src/execution-engine/execution-engine-module.h

@@ -0,0 +1,12 @@
+
+#ifndef LLVM_NODE_EXECUTION_ENGINE_MODULE_H
+#define LLVM_NODE_EXECUTION_ENGINE_MODULE_H
+
+#include <nan.h>
+#include "execution-engine.h"
+
+NAN_MODULE_INIT(InitExecutionEngine) {
+    ExecutionEngineWrapper::Init(target);
+}
+
+#endif //LLVM_NODE_EXECUTION_ENGINE_MODULE_H

src/execution-engine/execution-engine.cc

@@ -0,0 +1,36 @@
+
+#include "execution-engine.h"
+#include "../ir/module.h"
+
+Nan::Persistent<v8::ObjectTemplate> ExecutionEngineWrapper::executionEngineTemplate {};
+
+NAN_MODULE_INIT(ExecutionEngineWrapper::Init) {
+    auto objectTemplate = Nan::New<v8::ObjectTemplate>();
+    objectTemplate->SetInternalFieldCount(1);
+
+    Nan::SetMethod(objectTemplate, "addModule", ExecutionEngineWrapper::addModule);
+
+    executionEngineTemplate.Reset(objectTemplate);
+}
+
+NAN_METHOD(ExecutionEngineWrapper::addModule) {
+    if (info.Length() != 1 || !ModuleWrapper::isInstance(info[0])) {
+        return Nan::ThrowTypeError("addModule needs to be called with: mod: Module");
+    }
+
+    auto* module = ModuleWrapper::FromValue(info[0])->getModule();
+
+    auto* executionEngine = ExecutionEngineWrapper::FromValue(info.Holder())->executionEngine;
+    executionEngine->addModule(std::unique_ptr<llvm::Module>(module));
+}
+
+v8::Local<v8::Object> ExecutionEngineWrapper::of(llvm::ExecutionEngine *executionEnginePtr) {
+    Nan::EscapableHandleScope escapeScope {};
+    v8::Local<v8::ObjectTemplate> tpl = Nan::New(executionEngineTemplate);
+
+    auto object = Nan::NewInstance(tpl).ToLocalChecked();
+    auto* wrapper = new ExecutionEngineWrapper { executionEnginePtr };
+    wrapper->Wrap(object);
+
+    return escapeScope.Escape(object);
+}

src/execution-engine/execution-engine.h

@@ -0,0 +1,25 @@
+
+#ifndef LLVM_NODE_EXECUTION_ENGINE_H
+#define LLVM_NODE_EXECUTION_ENGINE_H
+
+#include <nan.h>
+#include <llvm/ExecutionEngine/ExecutionEngine.h>
+#include "../util/from-value-mixin.h"
+
+class ExecutionEngineWrapper: public Nan::ObjectWrap, public FromValueMixin<ExecutionEngineWrapper> {
+public:
+    static NAN_MODULE_INIT(Init);
+    static v8::Local<v8::Object> of(llvm::ExecutionEngine *ptr);
+
+private:
+    llvm::ExecutionEngine* executionEngine;
+    static Nan::Persistent<v8::ObjectTemplate> executionEngineTemplate;
+
+    explicit ExecutionEngineWrapper(llvm::ExecutionEngine* executionEngine): executionEngine { executionEngine } {
+        assert(executionEngine && "No execute engine passed");
+    }
+
+    static NAN_METHOD(addModule);
+};
+
+#endif //LLVM_NODE_EXECUTION_ENGINE_H

src/llvm-node.cc

@@ -5,13 +5,14 @@
 #include "config/config.h"
 #include "support/support.h"
 #include "target/target.h"
+#include "execution-engine/execution-engine-module.h"
 
 NAN_MODULE_INIT(InitAll) {
     InitBitCode(target);
     InitConfig(target);
     InitIR(target);
     InitSupport(target);
-    InitTarget(target);
+    InitExecutionEngine(target);
 }
 
 NODE_MODULE(llvm, InitAll)