[NFC] Add a utility to easily emit lazy variable definitions

Author: rjmccall

lib/IRGen/GenDecl.cpp

@@ -3357,6 +3357,20 @@ static llvm::Constant *getElementBitCast(llvm::Constant *ptr,
   }
 }
 
+llvm::Constant *
+IRGenModule::getOrCreateLazyGlobalVariable(LinkEntity entity,
+    llvm::function_ref<ConstantInitFuture(ConstantInitBuilder &)> build,
+    llvm::function_ref<void(llvm::GlobalVariable *)> finish) {
+  auto defaultType = entity.getDefaultDeclarationType(*this);
+
+  LazyConstantInitializer lazyInitializer = {
+    defaultType, build, finish
+  };
+  return getAddrOfLLVMVariable(entity,
+                               ConstantInit::getLazy(&lazyInitializer),
+                               DebugTypeInfo(), defaultType);
+}
+
 /// Return a reference to an object that's suitable for being used for
 /// the given kind of reference.
 ///
@@ -3429,7 +3443,7 @@ IRGenModule::getAddrOfLLVMVariable(LinkEntity entity,
 
     // If we're looking to define something, we may need to replace a
     // forward declaration.
-    if (definitionType) {
+    if (!definition.isLazy() && definitionType) {
       assert(existing->isDeclaration() && "already defined");
       updateLinkageForDefinition(*this, existing, entity);
 
@@ -3461,6 +3475,21 @@ IRGenModule::getAddrOfLLVMVariable(LinkEntity entity,
   if (auto existing = Module.getNamedGlobal(link.getName()))
     return getElementBitCast(existing, defaultType);
 
+  const LazyConstantInitializer *lazyInitializer = nullptr;
+  Optional<ConstantInitBuilder> lazyBuilder;
+  if (definition.isLazy()) {
+    lazyInitializer = definition.getLazy();
+    lazyBuilder.emplace(*this);
+
+    // Build the lazy initializer as a future.
+    auto future = lazyInitializer->Build(*lazyBuilder);
+
+    // Set the future as our definition and set its type as the
+    // definition type.
+    definitionType = future.getType();
+    definition = future;
+  }
+
   // If we're not defining the object now, forward declare it with the default
   // type.
   if (!definitionType) definitionType = defaultType;
@@ -3474,6 +3503,11 @@ IRGenModule::getAddrOfLLVMVariable(LinkEntity entity,
     definition.getInit().installInGlobal(var);
   }
 
+  // Call the creation callback.
+  if (lazyInitializer) {
+    lazyInitializer->Create(var);
+  }
+
   // If we have an existing entry, destroy it, replacing it with the
   // new variable.
   if (entry) {

lib/IRGen/IRGen.h

@@ -36,6 +36,7 @@ namespace swift {
 
 namespace irgen {
   using Lowering::AbstractionPattern;
+  class ConstantInitBuilder;
   using clang::CodeGen::ConstantInitFuture;
   class IRGenFunction;
 
@@ -166,48 +167,85 @@ enum class SymbolReferenceKind : uint8_t {
   Far_Relative_Indirectable,
 };
 
+/// A lazy constant initializer.
+struct LazyConstantInitializer {
+  llvm::Type *DefaultType;
+  llvm::function_ref<ConstantInitFuture(ConstantInitBuilder &)> Build;
+  llvm::function_ref<void(llvm::GlobalVariable *)> Create;
+};
+
 /// An initial value for a definition of an llvm::GlobalVariable.
 class ConstantInit {
-  llvm::PointerUnion<ConstantInitFuture, llvm::Type*> Data;
+  union {
+    ConstantInitFuture Future;
+    const LazyConstantInitializer *Lazy;
+    llvm::Type *Delayed;
+  };
+  enum class Kind {
+    None, Future, Lazy, Delayed
+  } TheKind;
+
 public:
   /// No initializer is given.  When this is used as an argument to
   /// a getAddrOf... API, it means that only a declaration is being
   /// requested.
-  ConstantInit() {}
+  ConstantInit() : TheKind(Kind::None) {}
 
   /// Use a concrete value as a concrete initializer.
   ConstantInit(llvm::Constant *initializer)
-    : Data(ConstantInitFuture(initializer)) {}
+    : Future(ConstantInitFuture(initializer)), TheKind(Kind::Future) {}
 
   /// Use a ConstantInitBuilder future as a concrete initializer.
-  /*implicit*/ ConstantInit(ConstantInitFuture future) : Data(future) {
+  /*implicit*/ ConstantInit(ConstantInitFuture future)
+    : Future(future), TheKind(Kind::Future) {
     assert(future && "don't pass around null futures");
   }
 
+  static ConstantInit getLazy(const LazyConstantInitializer *initializer) {
+    assert(initializer && "null lazy initializer");
+    auto result = ConstantInit();
+    result.TheKind = Kind::Lazy;
+    result.Lazy = initializer;
+    return result;
+  }
+
   /// There will be a definition (with the given type), but we don't
   /// have it yet.
   static ConstantInit getDelayed(llvm::Type *type) {
     auto result = ConstantInit();
-    result.Data = type;
+    result.TheKind = Kind::Delayed;
+    result.Delayed = type;
     return result;
   }
 
-  explicit operator bool() const { return bool(Data); }
+  explicit operator bool() const { return TheKind != Kind::None; }
 
   inline llvm::Type *getType() const {
-    assert(Data && "not a definition");
-    if (auto type = Data.dyn_cast<llvm::Type*>()) {
-      return type;
+    assert(TheKind != Kind::None && "not a definition");
+    if (TheKind == Kind::Delayed) {
+      return Delayed;
+    } else if (TheKind == Kind::Lazy) {
+      return Lazy->DefaultType;
     } else {
-      return Data.get<ConstantInitFuture>().getType();
+      assert(TheKind == Kind::Future);
+      return Future.getType();
     }
   }
 
+  bool isLazy() const {
+    return TheKind == Kind::Lazy;
+  }
+  const LazyConstantInitializer *getLazy() const {
+    assert(isLazy());
+    return Lazy;
+  }
+
   bool hasInit() const {
-    return Data.is<ConstantInitFuture>();
+    return TheKind == Kind::Future;
   }
   ConstantInitFuture getInit() const {
-    return Data.get<ConstantInitFuture>();
+    assert(hasInit());
+    return Future;
   }
 };
 

lib/IRGen/IRGenModule.h

@@ -1062,6 +1062,10 @@ class IRGenModule {
 
   ConstantIntegerLiteral getConstantIntegerLiteral(APInt value);
 
+  llvm::Constant *getOrCreateLazyGlobalVariable(LinkEntity entity,
+      llvm::function_ref<ConstantInitFuture(ConstantInitBuilder &)> build,
+      llvm::function_ref<void(llvm::GlobalVariable *)> finish);
+
   void addUsedGlobal(llvm::GlobalValue *global);
   void addCompilerUsedGlobal(llvm::GlobalValue *global);
   void addObjCClass(llvm::Constant *addr, bool nonlazy);