Remove LLVM/Clang dependency in headers (#341)

* remove llvm/clang dependency in headers

* copy elision

src/ngraph/codegen/compiler.cpp

@@ -31,6 +31,8 @@
 #include <clang/Lex/Preprocessor.h>
 #include <clang/Lex/PreprocessorOptions.h>
 #include <llvm/ADT/Statistic.h>
+#include <llvm/ExecutionEngine/MCJIT.h> // forces JIT to link in
+#include <llvm/IR/Module.h>
 #include <llvm/LinkAllPasses.h>
 #include <llvm/Option/Arg.h>
 #include <llvm/Option/ArgList.h>
@@ -72,6 +74,20 @@ using namespace ngraph::codegen;
 static StaticCompiler s_static_compiler;
 static std::mutex m_mutex;
 
+ngraph::codegen::Module::Module(std::unique_ptr<llvm::Module> module)
+    : m_module(move(module))
+{
+}
+
+ngraph::codegen::Module::~Module()
+{
+}
+
+std::unique_ptr<llvm::Module> ngraph::codegen::Module::take_module()
+{
+    return move(m_module);
+}
+
 Compiler::Compiler()
 {
 }
@@ -90,7 +106,7 @@ void Compiler::add_header_search_path(const std::string& path)
     s_static_compiler.add_header_search_path(path);
 }
 
-std::unique_ptr<llvm::Module> Compiler::compile(const std::string& source)
+std::unique_ptr<ngraph::codegen::Module> Compiler::compile(const std::string& source)
 {
     lock_guard<mutex> lock(m_mutex);
     return s_static_compiler.compile(compiler_action, source);
@@ -231,7 +247,7 @@ void StaticCompiler::add_header_search_path(const string& path)
     }
 }
 
-std::unique_ptr<llvm::Module>
+std::unique_ptr<ngraph::codegen::Module>
     StaticCompiler::compile(std::unique_ptr<clang::CodeGenAction>& compiler_action,
                             const string& source)
 {
@@ -264,7 +280,7 @@ std::unique_ptr<llvm::Module>
 
     m_compiler->getInvocation().getPreprocessorOpts().clearRemappedFiles();
 
-    return rc;
+    return unique_ptr<ngraph::codegen::Module>(new ngraph::codegen::Module(move(rc)));
 }
 
 void StaticCompiler::generate_pch(const string& source)

src/ngraph/codegen/compiler.hpp

@@ -17,18 +17,13 @@
 #include <functional>
 #include <memory>
 #include <string>
-
-#include <clang/CodeGen/CodeGenAction.h>
-
-#include <llvm/ExecutionEngine/MCJIT.h> // forces JIT to link in
-#include <llvm/ExecutionEngine/SectionMemoryManager.h>
-#include <llvm/Option/Arg.h>
+#include <vector>
 
 namespace ngraph
 {
     namespace codegen
     {
-        class module;
+        class Module;
         class Compiler;
         class StaticCompiler;
         class HeaderCache;
@@ -39,11 +34,21 @@ namespace clang
 {
     class HeaderSearchOptions;
     class CompilerInstance;
+    class CodeGenAction;
+}
+
+namespace llvm
+{
+    class Module;
 }
 
-class ngraph::codegen::module
+class ngraph::codegen::Module
 {
 public:
+    Module(std::unique_ptr<llvm::Module> module);
+    ~Module();
+    std::unique_ptr<llvm::Module> take_module();
+
 private:
     std::unique_ptr<llvm::Module> m_module;
 };
@@ -55,13 +60,13 @@ public:
     ~Compiler();
     void set_precompiled_header_source(const std::string& source);
     void add_header_search_path(const std::string& path);
-    std::unique_ptr<llvm::Module> compile(const std::string& source);
+    std::unique_ptr<ngraph::codegen::Module> compile(const std::string& source);
     std::unique_ptr<clang::CodeGenAction>& get_compiler_action() { return compiler_action; }
 private:
     std::unique_ptr<clang::CodeGenAction> compiler_action;
 };
 
-class ngraph::codegen::StaticCompiler : public llvm::SectionMemoryManager
+class ngraph::codegen::StaticCompiler
 {
 public:
     StaticCompiler();
@@ -75,8 +80,8 @@ public:
     }
     void add_header_search_path(const std::string& path);
 
-    std::unique_ptr<llvm::Module> compile(std::unique_ptr<clang::CodeGenAction>& compiler_action,
-                                          const std::string& source);
+    std::unique_ptr<ngraph::codegen::Module>
+        compile(std::unique_ptr<clang::CodeGenAction>& compiler_action, const std::string& source);
     void generate_pch(const std::string& source);
 
 private:

src/ngraph/codegen/execution_engine.cpp

@@ -13,7 +13,6 @@
 // ----------------------------------------------------------------------------
 
 #include <llvm/ExecutionEngine/ExecutionEngine.h>
-#include <llvm/ExecutionEngine/SectionMemoryManager.h>
 
 #include "ngraph/codegen/execution_engine.hpp"
 
@@ -32,13 +31,13 @@ codegen::ExecutionEngine::~ExecutionEngine()
     }
 }
 
-bool codegen::ExecutionEngine::add_module(std::unique_ptr<llvm::Module>& module)
+bool codegen::ExecutionEngine::add_module(std::unique_ptr<ngraph::codegen::Module>& module)
 {
     if (module)
     {
         if (!m_execution_engine)
         {
-            m_execution_engine.reset(llvm::EngineBuilder(move(module))
+            m_execution_engine.reset(llvm::EngineBuilder(module->take_module())
                                          .setEngineKind(llvm::EngineKind::JIT)
                                          .setOptLevel(llvm::CodeGenOpt::Aggressive)
                                          .setMCPU(llvm::sys::getHostCPUName())
@@ -74,3 +73,8 @@ void codegen::ExecutionEngine::finalize()
             (m_jit_error.empty() ? "Could not create an execution engine" : m_jit_error));
     }
 }
+
+void* codegen::ExecutionEngine::get_pointer_to_named_function(const std::string& func_name)
+{
+    return m_execution_engine->getPointerToNamedFunction(func_name);
+}

src/ngraph/codegen/execution_engine.hpp

@@ -16,9 +16,7 @@
 
 #include <memory>
 
-#include <llvm/ExecutionEngine/MCJIT.h> // forces JIT to link in
-#include <llvm/ExecutionEngine/SectionMemoryManager.h>
-#include <llvm/Option/Arg.h>
+#include "ngraph/codegen/compiler.hpp"
 
 namespace ngraph
 {
@@ -28,27 +26,32 @@ namespace ngraph
     }
 }
 
+namespace llvm
+{
+    class Module;
+    class ExecutionEngine;
+}
+
 class ngraph::codegen::ExecutionEngine
 {
 public:
     ExecutionEngine();
     ~ExecutionEngine();
 
-    bool add_module(std::unique_ptr<llvm::Module>& module);
+    bool add_module(std::unique_ptr<ngraph::codegen::Module>& module);
     void finalize();
 
     template <typename ftype>
     std::function<ftype> find_function(const std::string& func_name)
     {
-        auto f = m_execution_engine->getPointerToNamedFunction(func_name);
-
-        return f_cast<ftype>(f);
+        return f_cast<ftype>(get_pointer_to_named_function(func_name));
     }
 
 private:
     std::unique_ptr<llvm::ExecutionEngine> m_execution_engine;
     std::string m_jit_error;
 
+    void* get_pointer_to_named_function(const std::string& func_name);
     template <typename signature>
     std::function<signature> f_cast(void* f)
     {

src/ngraph/runtime/cpu/cpu_external_function.cpp

@@ -76,7 +76,6 @@
 #include "ngraph/ops/tan.hpp"
 #include "ngraph/ops/tanh.hpp"
 #include "ngraph/ops/xla_get_tuple_element.hpp"
-#include "ngraph/ops/xla_get_tuple_element.hpp"
 #include "ngraph/ops/xla_tuple.hpp"
 #include "ngraph/pass/assign_layout.hpp"
 #include "ngraph/pass/dump_sorted.hpp"
@@ -571,13 +570,13 @@ using namespace ngraph::runtime;
 
     m_compiler->set_precompiled_header_source(pch_header_source);
 
-    auto llvm_module = m_compiler->compile(code);
+    auto codegen_module = m_compiler->compile(code);
 
-    if (llvm_module == nullptr)
+    if (codegen_module == nullptr)
     {
         throw runtime_error("function failed to compile");
     }
-    m_execution_engine->add_module(llvm_module);
+    m_execution_engine->add_module(codegen_module);
     m_execution_engine->finalize();
     m_compiled_function = m_execution_engine->find_function<EntryPoint_t>(function_name);
     assert(m_compiled_function);