[Heavy] Add plugin system

Author: ricejasonf

heavy/CMakeLists.txt

@@ -53,5 +53,6 @@ add_subdirectory(tools/heavy-scheme)
 add_subdirectory(test)
 add_subdirectory(unittests)
 add_subdirectory(include/nbdl_gen)
+add_subdirectory(plugins/HelloWorld)
 
 add_subdirectory(cmake/modules)

heavy/cmake/modules/AddHeavy.cmake

@@ -2,30 +2,29 @@ include(AddLLVM)
 include(LLVMDistributionSupport)
 
 function(add_heavy_library name)
-set(options "")
-set(one_value_args "")
-set(multi_value_args "")
-cmake_parse_arguments(ARG "${options}" "${one_value_args}"
-                      "${multi_value_args}" "${ARGN}")
-llvm_add_library(${name} ${ARG_UNPARSED_ARGUMENTS})
-get_target_export_arg(${name} Heavy export_arg UMBRELLA heavy-libraries)
-install(TARGETS ${name}
-        COMPONENT ${name}
-        ${export_arg})
+  set(options "")
+  set(one_value_args "")
+  set(multi_value_args "")
+  cmake_parse_arguments(ARG "${options}" "${one_value_args}"
+                        "${multi_value_args}" "${ARGN}")
+  llvm_add_library(${name} ${ARG_UNPARSED_ARGUMENTS})
+  get_target_export_arg(${name} Heavy export_arg UMBRELLA heavy-libraries)
+  install(TARGETS ${name}
+          COMPONENT ${name}
+          ${export_arg})
 
-add_llvm_install_targets(install-${name}
-                         DEPENDS ${name}
-                         COMPONENT ${name})
-set_property(GLOBAL APPEND PROPERTY HEAVY_EXPORTS ${name})
+  add_llvm_install_targets(install-${name}
+                           DEPENDS ${name}
+                           COMPONENT ${name})
+  set_property(GLOBAL APPEND PROPERTY HEAVY_EXPORTS ${name})
 endfunction(add_heavy_library)
 
-# add_heavy_scheme_module
-# - Create a scheme module that is, by default, dynamically loaded.
-# - TODO Implement this.
-function(add_heavy_scheme_module name)
-set(options STATIC)
-set(one_value_args "")
-set(multi_value_args "")
-cmake_parse_arguments(ARG "${options}" "${one_value_args}"
-                      "${multi_value_args}")
-endfunction(add_heavy_scheme_module name)
+# Create a scheme module that is compiled as a dynamically loaded library.
+function(add_heavy_scheme_plugin name filename)
+  set(options "")
+  set(one_value_args "")
+  set(multi_value_args)
+  cmake_parse_arguments(ARG "${options}" "${one_value_args}"
+                        "${multi_value_args}")
+  add_library(${name} MODULE ${filename})
+endfunction(add_heavy_scheme_plugin)

heavy/lib/Builtins.cpp

@@ -19,6 +19,7 @@
 #include "heavy/Value.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/DynamicLibrary.h"
 #include "cassert"
 #include "memory"
 
@@ -93,6 +94,8 @@ heavy::ExternFunction source_loc;
 heavy::ExternFunction source_loc_valid;
 heavy::ExternFunction dump_source_loc;
 heavy::ExternFunction make_syntactic_closure;
+heavy::ExternFunction load_plugin;
+heavy::ExternFunction load_builtin;
 
 heavy::ExternFunction eval;
 heavy::ExternFunction op_eval;
@@ -1250,6 +1253,45 @@ void make_syntactic_closure(Context& C, ValueRefs Args) {
   Value Result = C.CreateSyntaxClosure(Loc, Expr, Env);
   C.Cont(Result);
 }
+
+// Dynamically load a native shared library.
+void load_plugin(Context& C, ValueRefs Args) {
+  if (Args.size() != 1)
+    return C.RaiseError("invalid arity");
+
+  llvm::StringRef Filename = Args.front().getStringRef();
+  if (Filename.empty())
+    return C.RaiseError("expecting nonempty string-like object: {}",
+                        Args.front());
+
+  std::string ErrMsg;
+  if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename.data(),
+                                                        &ErrMsg)) {
+    // TODO Make a "note" with Msg.
+    String* Msg = C.CreateString(ErrMsg);
+    return C.RaiseError("Failed to load plugin: {}\n{}", {Args.front(), Msg});
+  }
+
+  C.Cont();
+}
+
+// Dynamically load a Builtin from a heavy::ValueFn.
+void load_builtin(Context& C, ValueRefs Args) {
+  if (Args.size() != 1)
+    return C.RaiseError("invalid arity");
+
+  llvm::StringRef FuncName = Args.front().getStringRef();
+  if (FuncName.empty())
+    return C.RaiseError("expecting nonempty string-like object: {}",
+                        Args.front());
+
+  void* FuncVoidPtr
+    = llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(FuncName.data());
+  if (FuncVoidPtr == nullptr)
+    return C.RaiseError("unable to load builtin: {}", Args.front());
+  heavy::ValueFn Fn = reinterpret_cast<heavy::ValueFn>(FuncVoidPtr);
+  C.Cont(C.CreateBuiltin(Fn));
+}
 } // end of namespace heavy::builtins
 
 // initialize the module for run-time independent of the compiler
@@ -1346,6 +1388,8 @@ void HEAVY_BASE_INIT(heavy::Context& Context) {
   HEAVY_BASE_VAR(apply) = heavy::builtins::apply;
   HEAVY_BASE_VAR(make_syntactic_closure)
                         = heavy::builtins::make_syntactic_closure;
+  HEAVY_BASE_VAR(load_plugin) = heavy::builtins::load_plugin;
+  HEAVY_BASE_VAR(load_builtin) = heavy::builtins::load_builtin;
 }
 
 // initializes the module and loads lookup information
@@ -1444,6 +1488,8 @@ void HEAVY_BASE_LOAD_MODULE(heavy::Context& Context) {
     {"source-value?", HEAVY_BASE_VAR(is_source_value)},
     {"apply", HEAVY_BASE_VAR(apply)},
     {"make-syntactic-closure", HEAVY_BASE_VAR(make_syntactic_closure)},
+    {"load-plugin", HEAVY_BASE_VAR(load_plugin)},
+    {"load-builtin", HEAVY_BASE_VAR(load_builtin)},
   });
 }
 

heavy/lib/Context.cpp

@@ -1123,6 +1123,7 @@ void Context::IncludeModuleFile(heavy::SourceLocation Loc,
         C.OpGen->SetTopLevelHandler(HEAVY_BASE_VAR(op_eval));
         C.OpGen->VisitTopLevelSequence(Args[0]);
       });
+      // Load and parse the file.
       heavy::Value Parse = HEAVY_BASE_VAR(parse_source_file).get(C);
       heavy::Value SourceVal = C.CreateSourceValue(Loc);
       heavy::Value Filename = C.getCapture(0);

heavy/plugins/HelloWorld/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.13.4)
+add_heavy_scheme_plugin(heavyHelloWorld
+  hello_world.cpp)

heavy/plugins/HelloWorld/hello_world.cpp

@@ -0,0 +1,13 @@
+#include <heavy/Context.h>
+#include <heavy/Value.h>
+
+extern "C" {
+void heavy_hello_world_compute_answer(heavy::Context& C, heavy::ValueRefs) {
+  C.Cont(heavy::Int(42));
+}
+
+void heavy_hello_world_my_write(heavy::Context& C, heavy::ValueRefs Args) {
+  heavy::write(llvm::outs(), Args[0]);
+  C.Cont();
+}
+}

heavy/test/Plugin/hello_world.cpp

@@ -0,0 +1,21 @@
+// RUN: clang++ -I %S/Inputs -fsyntax-only -Xclang -fheavy -Xclang -verify %s
+// expected-no-diagnostics
+
+heavy_scheme {
+(import (heavy builtins)
+        (heavy clang))
+
+(load-plugin "libheavyHelloWorld.so")
+
+(define compute-answer
+  (load-builtin "heavy_hello_world_compute_answer"))
+
+(define forty-two 'forty-two)
+
+(write-lexer forty-two "static constexpr int forty_two = ")
+(write-lexer forty-two (number->string (compute-answer)))
+(write-lexer 0 ";")
+}
+
+static_assert(forty_two == 42);
+int main() { }

heavy/test/Plugin/hello_world.scm

@@ -0,0 +1,18 @@
+; RUN: heavy-scheme %s | FileCheck %s
+(import (heavy builtins))
+
+(load-plugin "libheavyHelloWorld.so")
+(define my-write
+  (load-builtin "heavy_hello_world_my_write"))
+
+(define compute-answer
+  (load-builtin "heavy_hello_world_compute_answer"))
+
+; CHECK: (hello world)
+(my-write '(hello world))
+
+
+; CHECK: 42
+(write (compute-answer))
+(newline)
+

heavy/tools/heavy-scheme/CMakeLists.txt

@@ -4,6 +4,7 @@ add_llvm_executable(heavy-scheme heavy_main.cpp)
 llvm_map_components_to_libnames(LLVM_LIBS core support)
 
 target_link_libraries(heavy-scheme PRIVATE heavy ${LLVM_LIBS})
+set_target_properties(heavy-scheme PROPERTIES ENABLE_EXPORTS 1)
 
 add_llvm_install_targets(install-heavy-scheme
   DEPENDS heavy-scheme

heavy/tools/heavy-scheme/heavy_main.cpp

@@ -91,8 +91,8 @@ void SetModulePath(heavy::HeavyScheme& HeavyScheme) {
 
 int main(int argc, char const** argv) {
 #if 0
-  // TODO Provide interactive looping which requires support
-  //      in Parser/Lexer possibly. Also look at llvm::LineEditor.
+  // TODO Provide interactive looping.
+  //      Also look at llvm::LineEditor.
   bool IsInteractive = llvm::sys::Process::StandardInIsUserInput();
 #endif
   llvm::InitLLVM LLVM_(argc, argv);