[Heavy] Add LoadModuleOp for runtime dependency graph

Author: ricejasonf

heavy/include/heavy/Ops.td

@@ -275,6 +275,22 @@ def heavy_LoadGlobalOp : HeavyOp<"load_global"> {
   ];
 }
 
+def heavy_LoadModuleOp : HeavyOp<"load_module"> {
+  let summary = "load_module";
+  let description = [{
+    Load a module by its mangled name and initialize it.
+    This also enables the creation of a runtime dependency graph
+    for exporting to bytecode files.
+  }];
+
+  let arguments = (ins FlatSymbolRefAttr:$name);
+  let results   = (outs);
+
+  let builders = [
+    OpBuilder<(ins "::llvm::StringRef":$name)>
+  ];
+}
+
 def heavy_ExportOp : HeavyOp<"export", [Symbol, IsolatedFromAbove,
                                         NoTerminator]> {
   let summary = "export";

heavy/lib/Builtins.cpp

@@ -692,6 +692,10 @@ void compile(Context& C, ValueRefs Args) {
     return;
   }
 
+  // Clear any errors in the compiler too keep the dream alive.
+  if (heavy::OpGen* OpGen = Env->GetOpGen())
+    OpGen->ClearError();
+
   // If there is a provided handler then we save the results in an
   // improper, reversed ordered list (stack) to pass to the handler.
   Value ResultHandler = Undefined();

heavy/lib/Context.cpp

@@ -871,7 +871,8 @@ namespace {
                      llvm::SmallVectorImpl<char>& Output) { 
     llvm::StringRef ModulePath =
         HEAVY_BASE_VAR(module_path).get(C).getStringRef();
-    llvm::Twine(ModulePath, "/").toVector(Output);
+    if (!ModulePath.empty())
+      llvm::Twine(ModulePath, "/").toVector(Output);
 
     llvm::StringRef Input = MangledName;
     Input.consume_front(Mangler::getManglePrefix());

heavy/lib/Dialect.cpp

@@ -160,6 +160,11 @@ void LoadGlobalOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
   LoadGlobalOp::build(B, OpState, HeavyValueT, SymName);
 }
 
+void LoadModuleOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
+                         llvm::StringRef SymName) {
+  LoadModuleOp::build(B, OpState, {}, SymName);
+}
+
 void MatchOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
                     heavy::Value val, mlir::Value input) {
   assert((!isa<Pair, Vector>(val)) && "expected non-structural constant");

heavy/lib/OpEval.cpp

@@ -95,7 +95,7 @@ class OpEvalImpl {
   }
 
   void Eval(mlir::Operation* Op) {
-    if (isa<GlobalOp, CommandOp>(Op)) {
+    if (isa<GlobalOp, CommandOp, LoadModuleOp>(Op)) {
       BlockItrTy Itr = Visit(Op);
 
       if (Itr == BlockItrTy())
@@ -192,7 +192,6 @@ class OpEvalImpl {
          if (isa<BindingOp>(Op))      return Visit(cast<BindingOp>(Op));
     else if (isa<LiteralOp>(Op))      return Visit(cast<LiteralOp>(Op));
     else if (isa<ApplyOp>(Op))        return Visit(cast<ApplyOp>(Op));
-    //else if (isa<BuiltinOp>(Op))      return Visit(cast<BuiltinOp>(Op));
     else if (isa<ContOp>(Op))         return Visit(cast<ContOp>(Op));
     else if (isa<GlobalOp>(Op))       return Visit(cast<GlobalOp>(Op));
     else if (isa<LoadClosureOp>(Op))  return Visit(cast<LoadClosureOp>(Op));
@@ -213,6 +212,7 @@ class OpEvalImpl {
     else if (isa<RenameOp>(Op))       return Visit(cast<RenameOp>(Op));
     else if (isa<ToVectorOp>(Op))     return Visit(cast<ToVectorOp>(Op));
     else if (isa<VectorOp>(Op))       return Visit(cast<VectorOp>(Op));
+    else if (isa<LoadModuleOp>(Op))   return Visit(cast<LoadModuleOp>(Op));
     else if (isa<SyntaxClosureOp>(Op))
       return Visit(cast<SyntaxClosureOp>(Op));
     else if (isa<SourceLocOp>(Op))    return Visit(cast<SourceLocOp>(Op));
@@ -485,6 +485,19 @@ class OpEvalImpl {
     return next(Op);
   }
 
+  BlockItrTy Visit(LoadModuleOp Op) {
+    heavy::Symbol* ModuleName = Context.CreateSymbol(Op.getName());
+    Context.PushCont([](heavy::Context& C, ValueRefs) {
+      heavy::Symbol* ModuleName = cast<Symbol>(C.getCapture(0));
+      C.PushCont([](heavy::Context& C, ValueRefs) {
+        heavy::Symbol* ModuleName = cast<Symbol>(C.getCapture(0));
+        C.InitModule(ModuleName);
+      }, CaptureList{ModuleName});
+      C.LoadModule(ModuleName);
+    }, CaptureList{ModuleName});
+    return BlockItrTy();
+  }
+
   BlockItrTy Visit(LoadGlobalOp Op) {
     Value Val = Context.GetKnownValue(Op.getName());
     if (!Val) {

heavy/lib/OpGen.cpp

@@ -90,12 +90,8 @@ mlir::ModuleOp OpGen::getModuleOp() {
 
 void OpGen::createLoadModule(heavy::SourceLocation Loc,
                              heavy::Symbol* MangledName) {
-  mlir::Value Fn = createGlobal(Loc, HEAVY_LOAD_MODULE_VAR);
-  mlir::Value LiteralOp = createLiteral(MangledName);
-  mlir::Value Args[] = {LiteralOp};
-  createCall(Loc, Fn, Args);
-  // We only want this evaluated when loading stand-alone bytecode files.
-  FinishTopLevelOp();
+  TopLevelOp = createHelper<heavy::LoadModuleOp>(ModuleBuilder, Loc,
+                                    MangledName->getStringRef());
 }
 
 mlir::Value OpGen::GetSingleResult(heavy::Value V) {
@@ -316,7 +312,8 @@ void OpGen::VisitTopLevel(Value V) {
 }
 
 void OpGen::FinishTopLevelOp() {
-  assert((TopLevelOp == nullptr || isa<CommandOp, GlobalOp>(TopLevelOp)) &&
+  assert((TopLevelOp == nullptr ||
+          isa<CommandOp, GlobalOp, LoadModuleOp>(TopLevelOp)) &&
       "Top level operation must be CommandOp or GlobalOp");
 
   if (heavy::CommandOp CommandOp =
@@ -920,10 +917,14 @@ mlir::Value OpGen::createGlobal(SourceLocation Loc,
   auto GlobalOp = cast<heavy::GlobalOp>(G);
 
   // Localize globals by the GlobalOp's Operation*
-  mlir::Value LocalV = BindingTable.lookup(CanonicalValue);
+  mlir::Value LocalV;
+  // If no TopLevelOp exists then no binding scope exists either.
+  if (TopLevelOp)
+    LocalV = BindingTable.lookup(CanonicalValue);
   if (!LocalV) {
     LocalV = create<LoadGlobalOp>(Loc, GlobalOp.getName());
     BindingTable.insert(CanonicalValue, LocalV);
+    return LocalV;
   }
 
   return LocalizeValue(LocalV, CanonicalValue);

heavy/test/Evaluate/Inputs/my/lib.sld

@@ -1,6 +1,7 @@
 (import (heavy base))
 (define-library (my lib)
   (import (heavy base))
+  (import (heavy mlir))
   (begin
     (define (hello-module x)
       (write "hello module!")