[Immediate] [SILGen] Implement on-demand compilation of globals

Author: Zak Kent

include/swift/AST/SILGenRequests.h

@@ -21,6 +21,7 @@
 #include "swift/AST/EvaluatorDependencies.h"
 #include "swift/AST/SimpleRequest.h"
 #include "swift/AST/SourceFile.h"
+#include "swift/AST/TBDGenRequests.h"
 #include "swift/SIL/SILDeclRef.h"
 
 namespace swift {
@@ -43,6 +44,8 @@ void reportEvaluatedRequest(UnifiedStatsReporter &stats,
 
 using SILRefsToEmit = llvm::SmallVector<SILDeclRef, 1>;
 
+using SymbolSources = llvm::SmallVector<SymbolSource, 1>;
+
 /// Describes a file or module to be lowered to SIL.
 struct ASTLoweringDescriptor {
   llvm::PointerUnion<FileUnit *, ModuleDecl *> context;
@@ -52,20 +55,17 @@ struct ASTLoweringDescriptor {
 
   /// A specific set of SILDeclRefs to emit. If set, only these refs will be
   /// emitted. Otherwise the entire \c context will be emitted.
-  llvm::Optional<SILRefsToEmit> refsToEmit;
+  llvm::Optional<SymbolSources> SourcesToEmit;
 
   friend llvm::hash_code hash_value(const ASTLoweringDescriptor &owner) {
     return llvm::hash_combine(owner.context, (void *)&owner.conv,
-                              (void *)&owner.opts,
-                              owner.refsToEmit);
+                              (void *)&owner.opts, owner.SourcesToEmit);
   }
 
   friend bool operator==(const ASTLoweringDescriptor &lhs,
                          const ASTLoweringDescriptor &rhs) {
-    return lhs.context == rhs.context &&
-           &lhs.conv == &rhs.conv &&
-           &lhs.opts == &rhs.opts &&
-           lhs.refsToEmit == rhs.refsToEmit;
+    return lhs.context == rhs.context && &lhs.conv == &rhs.conv &&
+           &lhs.opts == &rhs.opts && lhs.SourcesToEmit == rhs.SourcesToEmit;
   }
 
   friend bool operator!=(const ASTLoweringDescriptor &lhs,
@@ -76,17 +76,19 @@ struct ASTLoweringDescriptor {
 public:
   static ASTLoweringDescriptor
   forFile(FileUnit &sf, Lowering::TypeConverter &conv, const SILOptions &opts,
-          llvm::Optional<SILRefsToEmit> refsToEmit = llvm::None,
+          llvm::Optional<SymbolSources> SourcesToEmit = llvm::None,
           const IRGenOptions *irgenOptions = nullptr) {
-    return ASTLoweringDescriptor{&sf, conv, opts, irgenOptions, refsToEmit};
+    return ASTLoweringDescriptor{&sf, conv, opts, irgenOptions,
+                                 std::move(SourcesToEmit)};
   }
 
   static ASTLoweringDescriptor
   forWholeModule(ModuleDecl *mod, Lowering::TypeConverter &conv,
                  const SILOptions &opts,
-                 llvm::Optional<SILRefsToEmit> refsToEmit = llvm::None,
+                 llvm::Optional<SymbolSources> SourcesToEmit = llvm::None,
                  const IRGenOptions *irgenOptions = nullptr) {
-    return ASTLoweringDescriptor{mod, conv, opts, irgenOptions, refsToEmit};
+    return ASTLoweringDescriptor{mod, conv, opts, irgenOptions,
+                                 std::move(SourcesToEmit)};
   }
 
   /// Retrieves the files to generate SIL for. If the descriptor is configured

include/swift/AST/TBDGenRequests.h

@@ -17,6 +17,8 @@
 #ifndef SWIFT_TBDGEN_REQUESTS_H
 #define SWIFT_TBDGEN_REQUESTS_H
 
+#include "llvm/ExecutionEngine/JITSymbol.h"
+
 #include "swift/AST/ASTTypeIDs.h"
 #include "swift/AST/SimpleRequest.h"
 #include "swift/IRGen/Linking.h"
@@ -148,6 +150,10 @@ class SymbolSource {
     /// A symbol introduced when emitting a SIL decl.
     SIL,
 
+    /// A symbol introduced when emitting a SIL global variable.
+    /// Only used in piecewise compilation for Immediate mode.
+    Global,
+
     /// A symbol introduced when emitting LLVM IR.
     IR,
 
@@ -162,13 +168,17 @@ class SymbolSource {
 
 private:
   union {
+    VarDecl *Global;
     SILDeclRef silDeclRef;
     irgen::LinkEntity irEntity;
   };
 
   explicit SymbolSource(SILDeclRef ref) : kind(Kind::SIL) {
     silDeclRef = ref;
   }
+
+  SymbolSource(VarDecl *Global) : kind(Kind::Global), Global(Global) {}
+
   explicit SymbolSource(irgen::LinkEntity entity) : kind(Kind::IR) {
     irEntity = entity;
   }
@@ -180,6 +190,9 @@ class SymbolSource {
   static SymbolSource forSILDeclRef(SILDeclRef ref) {
     return SymbolSource{ref};
   }
+
+  static SymbolSource forGlobal(VarDecl *Global) { return Global; }
+
   static SymbolSource forIRLinkEntity(irgen::LinkEntity entity) {
     return SymbolSource{entity};
   }
@@ -198,10 +211,84 @@ class SymbolSource {
     assert(kind == Kind::SIL);
     return silDeclRef;
   }
+
+  VarDecl *getGlobal() const {
+    assert(kind == Kind::Global);
+    return Global;
+  }
+
   irgen::LinkEntity getIRLinkEntity() const {
     assert(kind == Kind::IR);
     return irEntity;
   }
+
+  /// Typecheck the entity wrapped by this `SymbolSource`
+  void typecheck() const {
+    switch (kind) {
+    case Kind::SIL: {
+      if (auto *AFD = silDeclRef.getAbstractFunctionDecl())
+        // If this entity is a `SILFunction`, check its body
+        AFD->getTypecheckedBody();
+      break;
+    }
+    case Kind::Global:
+    case Kind::IR:
+    case Kind::LinkerDirective:
+    case Kind::Unknown:
+      // Nothing to do
+      break;
+    }
+  }
+
+  friend llvm::hash_code hash_value(const SymbolSource &S) {
+    auto Kind = S.kind;
+    switch (Kind) {
+    case Kind::SIL:
+      return llvm::hash_combine(Kind, S.silDeclRef);
+    case Kind::Global:
+      return llvm::hash_combine(Kind, S.Global);
+    case Kind::IR:
+      return llvm::hash_combine(Kind, S.irEntity);
+    case Kind::LinkerDirective:
+    case Kind::Unknown:
+      return llvm::hash_value(Kind);
+    }
+  }
+
+  friend bool operator==(const SymbolSource &LHS, const SymbolSource &RHS) {
+    if (LHS.kind != RHS.kind)
+      return false;
+    switch (LHS.kind) {
+    case Kind::SIL:
+      return LHS.silDeclRef == RHS.silDeclRef;
+    case Kind::Global:
+      return LHS.Global == RHS.Global;
+    case Kind::IR:
+      return LHS.irEntity == RHS.irEntity;
+    case Kind::LinkerDirective:
+    case Kind::Unknown:
+      return true;
+    }
+  }
+
+  friend bool operator!=(const SymbolSource &LHS, const SymbolSource &RHS) {
+    return !(LHS == RHS);
+  }
+
+  llvm::JITSymbolFlags getJITSymbolFlags() const {
+    switch (kind) {
+    case Kind::SIL:
+      return llvm::JITSymbolFlags::Callable | llvm::JITSymbolFlags::Exported;
+    case Kind::Global:
+      return llvm::JITSymbolFlags::Exported;
+    case Kind::IR:
+      llvm_unreachable("Unimplemented: Symbol flags for LinkEntities");
+    case Kind::LinkerDirective:
+      llvm_unreachable("Unsupported: Symbol flags for linker directives");
+    case Kind::Unknown:
+      llvm_unreachable("Unsupported: Symbol flags for unknown source");
+    }
+  }
 };
 
 /// Maps a symbol back to its source for lazy compilation.

include/swift/IRGen/Linking.h

@@ -515,6 +515,20 @@ class LinkEntity {
     return Kind(LINKENTITY_GET_FIELD(Data, Kind));
   }
 
+  friend llvm::hash_code hash_value(const LinkEntity &Entity) {
+    return llvm::hash_combine(Entity.Pointer, Entity.SecondaryPointer,
+                              Entity.Data);
+  }
+
+  friend bool operator==(const LinkEntity &LHS, const LinkEntity &RHS) {
+    return LHS.Pointer == RHS.Pointer &&
+           LHS.SecondaryPointer == RHS.SecondaryPointer && LHS.Data == RHS.Data;
+  }
+
+  friend bool operator!=(const LinkEntity &LHS, const LinkEntity &RHS) {
+    return !(LHS == RHS);
+  }
+
   static bool isDeclKind(Kind k) {
     return k <= Kind::AsyncFunctionPointerAST;
   }

include/swift/Subsystems.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_SUBSYSTEMS_H
 #define SWIFT_SUBSYSTEMS_H
 
+#include "swift/AST/TBDGenRequests.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptionSet.h"
 #include "swift/Basic/PrimarySpecificPaths.h"
@@ -193,7 +194,7 @@ namespace swift {
   /// SIL of all files in the module is present in the SILModule.
   std::unique_ptr<SILModule>
   performASTLowering(CompilerInstance &CI,
-                     llvm::SmallVector<SILDeclRef, 1> Refs);
+                     llvm::SmallVector<SymbolSource, 1> Sources);
 
   /// Turn a source file into SIL IR.
   std::unique_ptr<SILModule>

lib/IRGen/IRGen.cpp

@@ -1097,6 +1097,7 @@ getSymbolSourcesToEmit(const IRGenDescriptor &desc) {
       break;
     case SymbolSource::Kind::LinkerDirective:
     case SymbolSource::Kind::Unknown:
+    case SymbolSource::Kind::Global:
       llvm_unreachable("Not supported");
     }
   }
@@ -1122,9 +1123,8 @@ GeneratedModule IRGenRequest::evaluate(Evaluator &evaluator,
   // SIL for the file or module.
   auto SILMod = std::unique_ptr<SILModule>(desc.SILMod);
   if (!SILMod) {
-    auto loweringDesc = ASTLoweringDescriptor{
-        desc.Ctx, desc.Conv, desc.SILOpts, nullptr,
-        symsToEmit.transform([](const auto &x) { return x.silRefsToEmit; })};
+    auto loweringDesc = ASTLoweringDescriptor{desc.Ctx, desc.Conv, desc.SILOpts,
+                                              nullptr, llvm::None};
     SILMod = llvm::cantFail(Ctx.evaluator(LoweredSILRequest{loweringDesc}));
 
     // If there was an error, bail.

lib/IRGen/TBDGen.cpp

@@ -441,9 +441,8 @@ void TBDGenVisitor::addFunction(StringRef name, SILDeclRef declRef) {
 }
 
 void TBDGenVisitor::addGlobalVar(VarDecl *VD) {
-  // FIXME: We ought to have a symbol source for this.
   Mangle::ASTMangler mangler;
-  addSymbol(mangler.mangleEntity(VD), SymbolSource::forUnknown());
+  addSymbol(mangler.mangleEntity(VD), SymbolSource::forGlobal(VD));
 }
 
 void TBDGenVisitor::addLinkEntity(LinkEntity entity) {

lib/Immediate/SwiftMaterializationUnit.cpp

@@ -298,14 +298,15 @@ LazySwiftMaterializationUnit::Create(SwiftJIT &JIT, CompilerInstance &CI) {
   llvm::orc::SymbolFlagsMap PublicInterface;
   for (const auto &Entry : *Sources) {
     const auto &Source = Entry.getValue();
-    if (Source.kind != SymbolSource::Kind::SIL) {
-      continue;
-    }
     const auto &SymbolName = Entry.getKey();
-    auto Flags =
-        llvm::JITSymbolFlags::Callable | llvm::JITSymbolFlags::Exported;
-    auto MangledName = mangle(SymbolName);
-    PublicInterface[JIT.intern(MangledName)] = Flags;
+    auto Flags = Source.getJITSymbolFlags();
+    if (Flags.isCallable()) {
+      // Only create lazy reexports for callable symbols
+      auto MangledName = mangle(SymbolName);
+      PublicInterface[JIT.intern(MangledName)] = Flags;
+    } else {
+      PublicInterface[JIT.intern(SymbolName)] = Flags;
+    }
   }
   return std::unique_ptr<LazySwiftMaterializationUnit>(
       new LazySwiftMaterializationUnit(JIT, CI, std::move(Sources),
@@ -324,24 +325,22 @@ LazySwiftMaterializationUnit::LazySwiftMaterializationUnit(
 
 void LazySwiftMaterializationUnit::materialize(
     std::unique_ptr<llvm::orc::MaterializationResponsibility> MR) {
-  SILRefsToEmit Refs;
+  SymbolSources Entities;
   const auto &RS = MR->getRequestedSymbols();
   for (auto &Sym : RS) {
     auto Name = demangle(*Sym);
     auto itr = Sources->find(Name);
     assert(itr != Sources->end() && "Requested symbol doesn't have source?");
     const auto &Source = itr->getValue();
-    auto Ref = Source.getSILDeclRef();
-    if (auto *AFD = Ref.getAbstractFunctionDecl()) {
-      AFD->getTypecheckedBody();
-      if (CI.getASTContext().hadError()) {
-        MR->failMaterialization();
-        return;
-      }
+    Source.typecheck();
+    if (CI.getASTContext().hadError()) {
+      // If encounter type error, bail out
+      MR->failMaterialization();
+      return;
     }
-    Refs.push_back(std::move(Ref));
+    Entities.push_back(Source);
   }
-  auto SM = performASTLowering(CI, std::move(Refs));
+  auto SM = performASTLowering(CI, std::move(Entities));
 
   // Promote linkages of SIL entities
   // defining requested symbols so they are

lib/SIL/IR/SILModule.cpp

@@ -865,9 +865,27 @@ void SILModule::installSILRemarkStreamer() {
 }
 
 void SILModule::promoteLinkages() {
-  for (auto &Fn : functions)
+  for (auto &Fn : functions) {
+    // Ignore functions with shared linkage
+    if (Fn.getLinkage() == SILLinkage::Shared)
+      continue;
+
     if (Fn.isDefinition())
       Fn.setLinkage(SILLinkage::Public);
+    else
+      Fn.setLinkage(SILLinkage::PublicExternal);
+  }
+
+  for (auto &Global : silGlobals) {
+    // Ignore globals with shared linkage
+    if (Global.getLinkage() == SILLinkage::Shared)
+      continue;
+
+    if (Global.isDefinition())
+      Global.setLinkage(SILLinkage::Public);
+    else
+      Global.setLinkage(SILLinkage::PublicExternal);
+  }
 
   // TODO: Promote linkage of other SIL entities
 }