Merge pull request #29753 from slavapestov/got-entry-cleanup

IRGen GOT entry cleanup

Author: slavapestov

include/swift/Basic/Statistics.def

@@ -286,10 +286,10 @@ FRONTEND_STATISTIC(SILModule, NumSILOptWitnessTables)
 FRONTEND_STATISTIC(SILModule, NumSILOptDefaultWitnessTables)
 FRONTEND_STATISTIC(SILModule, NumSILOptGlobalVariables)
 
-/// The next 9 statistics count kinds of LLVM entities produced
+/// The next 10 statistics count kinds of LLVM entities produced
 /// during the IRGen phase: globals, functions, aliases, ifuncs,
 /// named metadata, value and comdat symbols, basic blocks,
-/// and instructions.
+/// instructions, and GOT entries.
 FRONTEND_STATISTIC(IRModule, NumIRGlobals)
 FRONTEND_STATISTIC(IRModule, NumIRFunctions)
 FRONTEND_STATISTIC(IRModule, NumIRAliases)
@@ -299,6 +299,7 @@ FRONTEND_STATISTIC(IRModule, NumIRValueSymbols)
 FRONTEND_STATISTIC(IRModule, NumIRComdatSymbols)
 FRONTEND_STATISTIC(IRModule, NumIRBasicBlocks)
 FRONTEND_STATISTIC(IRModule, NumIRInsts)
+FRONTEND_STATISTIC(IRModule, NumGOTEntries)
 
 /// Number of bytes written to the object-file output stream
 /// of the frontend job, which should be the same as the size of

include/swift/IRGen/Linking.h

@@ -1029,11 +1029,6 @@ class LinkEntity {
   std::string mangleAsString() const;
   SILLinkage getLinkage(ForDefinition_t isDefinition) const;
 
-  /// Returns true if this function or global variable is potentially defined
-  /// in a different module.
-  ///
-  bool isAvailableExternally(IRGenModule &IGM) const;
-
   const ValueDecl *getDecl() const {
     assert(isDeclKind(getKind()));
     return reinterpret_cast<ValueDecl*>(Pointer);
@@ -1130,16 +1125,16 @@ class LinkEntity {
   bool isSILFunction() const {
     return getKind() == Kind::SILFunction;
   }
-  bool isNominalTypeDescriptor() const {
-    return getKind() == Kind::NominalTypeDescriptor;
+  bool isDynamicallyReplaceableFunctionKey() const {
+    return getKind() == Kind::DynamicallyReplaceableFunctionKey;
   }
 
   /// Determine whether this entity will be weak-imported.
   bool isWeakImported(ModuleDecl *module) const;
 
-  /// Return the source file whose codegen should trigger emission of this
-  /// link entity, if one can be identified.
-  const SourceFile *getSourceFileForEmission() const;
+  /// Return the module scope context whose codegen should trigger emission
+  /// of this link entity, if one can be identified.
+  DeclContext *getDeclContextForEmission() const;
 
   /// Get the preferred alignment for the definition of this entity.
   Alignment getAlignment(IRGenModule &IGM) const;

lib/IRGen/GenDecl.cpp

@@ -428,7 +428,6 @@ class PrettySourceFileEmission : public llvm::PrettyStackTraceEntry {
 /// Emit all the top-level code in the source file.
 void IRGenModule::emitSourceFile(SourceFile &SF) {
   PrettySourceFileEmission StackEntry(SF);
-  llvm::SaveAndRestore<SourceFile *> SetCurSourceFile(CurSourceFile, &SF);
 
   // Emit types and other global decls.
   for (auto *decl : SF.getTopLevelDecls())
@@ -764,19 +763,9 @@ IRGenModule::getAddrOfContextDescriptorForParent(DeclContext *parent,
       // descriptor, so we'll just emit an extension context.
       auto clas = dyn_cast<ClassDecl>(nominal);
       if (!clas || clas->isForeign() || hasKnownSwiftMetadata(*this, clas)) {
-        // Some targets don't support relative references to undefined symbols.
-        // If the extension is in a different file from the original type
-        // declaration, it may not get emitted in this TU. Use an indirect
-        // reference to work around the object format limitation.
-        auto shouldBeIndirect =
-            parent->getModuleScopeContext() != ofChild->getModuleScopeContext()
-          ? ConstantReference::Indirect
-          : ConstantReference::Direct;
-        
         IRGen.noteUseOfTypeContextDescriptor(nominal, DontRequireMetadata);
         return getAddrOfLLVMVariableOrGOTEquivalent(
-                                LinkEntity::forNominalTypeDescriptor(nominal),
-                                shouldBeIndirect);
+                                LinkEntity::forNominalTypeDescriptor(nominal));
       }
     }
     return {getAddrOfExtensionContextDescriptor(ext),
@@ -2695,6 +2684,9 @@ llvm::Constant *IRGenModule::getOrCreateGOTEquivalent(llvm::Constant *global,
     return gotEntry;
   }
 
+  if (Context.Stats)
+    Context.Stats->getFrontendCounters().NumGOTEntries++;
+
   // Use the global as the initializer for an anonymous constant. LLVM can treat
   // this as equivalent to the global's GOT entry.
   auto gotEquivalent = createGOTEquivalent(*this, global, entity);
@@ -2867,16 +2859,19 @@ IRGenModule::getAddrOfLLVMVariable(LinkEntity entity,
 /// global variable. LLVM can replace relative references to this variable with
 /// relative references to the GOT entry for the variable in the object file.
 ConstantReference
-IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
-                              ConstantReference::Directness forceIndirectness) {
+IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity) {
+  auto canDirectlyReferenceSILFunction = [&](SILFunction *silFn) {
+    return (silFn->isDefinition() &&
+           !isAvailableExternally(silFn->getLinkage()) &&
+           this == IRGen.getGenModule(silFn));
+  };
+
   // Handle SILFunctions specially, because unlike other entities they aren't
   // variables and aren't kept in the GlobalVars table.
   if (entity.isSILFunction()) {
     auto *silFn = entity.getSILFunction();
     auto fn = getAddrOfSILFunction(silFn, NotForDefinition);
-    if (silFn->isDefinition() &&
-        !isAvailableExternally(silFn->getLinkage()) &&
-        this == IRGen.getGenModule(silFn)) {
+    if (canDirectlyReferenceSILFunction(silFn)) {
       return {fn, ConstantReference::Direct};
     }
 
@@ -2896,22 +2891,6 @@ IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
   // Ensure the variable is at least forward-declared.
   getAddrOfLLVMVariable(entity, ConstantInit(), DebugTypeInfo());
 
-  // Guess whether a global entry is a definition from this TU. This isn't
-  // bulletproof, but at the point we emit conformance tables, we're far enough
-  // along that we should have emitted any metadata objects we were going to.
-  auto isDefinition = [&](llvm::Constant *global) -> bool {
-    // We only emit aliases for definitions. (An extern alias would be an
-    // extern global.)
-    if (isa<llvm::GlobalAlias>(global))
-      return true;
-    // Global vars are definitions if they have an initializer.
-    if (auto var = dyn_cast<llvm::GlobalVariable>(global))
-      return var->hasInitializer();
-    // Assume anything else isn't a definition.
-    return false;
-  };
-  
-  //
   auto entry = GlobalVars[entity];
 
   /// Returns a direct reference.
@@ -2931,43 +2910,64 @@ IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
     return {gotEquivalent, ConstantReference::Indirect};
   };
 
-  // Return the GOT entry if we were asked to.
-  if (forceIndirectness == ConstantReference::Indirect)
-    return indirect();
-  
   // The integrated REPL incrementally adds new definitions, so always use
   // indirect references in this mode.
   if (IRGen.Opts.IntegratedREPL)
     return indirect();
 
-  // Nominal type descriptors are only emitted once and can only be
-  // referenced directly from the same TU.
-  if (entity.isNominalTypeDescriptor()) {
-    auto *dc = entity.getDecl()->getDeclContext();
-    if (isa<ClangModuleUnit>(dc->getModuleScopeContext()) &&
-        this != IRGen.getGenModule(dc))
-      return indirect();
-  }
+  // Dynamically replaceable function keys are stored in the GlobalVars
+  // table, but they don't have an associated Decl, so they require
+  // special treatment here.
+  if (entity.isDynamicallyReplaceableFunctionKey()) {
+    auto *silFn = entity.getSILFunction();
+    if (canDirectlyReferenceSILFunction(silFn))
+      return direct();
 
-  // If the variable has already been defined in this TU,
-  // then it definitely doesn't need a GOT entry, and we can
-  // relative-reference it directly.
-  if (!entity.isAvailableExternally(*this) || isDefinition(entry)) {
-    return direct();
+    return indirect();
   }
 
-  // If the entity will be emitted as part of the current source file
-  // (if we know what that is), then we can reference it directly.
-  if (CurSourceFile
-      && !isa<ClangModuleUnit>(CurSourceFile)
-      && CurSourceFile == entity.getSourceFileForEmission())
-    return direct();
-  
-  // TODO: If we know the target entry is going to be linked into the same
-  // binary, then we ought to be able to directly relative-reference the
-  // symbol. However, some platforms don't have the necessary relocations to
-  // represent a relative reference to an undefined symbol, so conservatively
-  // produce an indirect reference in this case.
+  if (auto *entityDC = entity.getDeclContextForEmission()) {
+    auto *entitySF = entityDC->getModuleScopeContext();
+    bool clangImportedEntity = isa<ClangModuleUnit>(entitySF);
+
+    auto &mod = getSILModule();
+
+    if (!mod.isWholeModule()) {
+      // In non-WMO builds, the associated context of the SILModule must
+      // be a source file. Every source file is its own translation unit.
+      auto *modDC = mod.getAssociatedContext();
+      auto *modSF = modDC->getModuleScopeContext();
+      assert(modSF != nullptr);
+
+      // Imported entities are in a different Swift module, but are emitted
+      // on demand and can be referenced directly. Entities in the same
+      // source file can also be referenced directly.
+      if (clangImportedEntity ||
+          modSF == entitySF)
+        return direct();
+
+      // Everything else must be referenced indirectly.
+      return indirect();
+    }
+
+    // We're performing a WMO build.
+    //
+    // The associated context of the SILModule is the entire AST ModuleDecl,
+    // but we might be doing a multi-threaded IRGen build, in which case
+    // there is one translation unit per source file.
+
+    // Imported entities are in a different Swift module and are emitted
+    // on demand. In multi-threaded builds, they will be emitted into one
+    // translation unit only.
+    if (clangImportedEntity ||
+        entitySF->getParentModule() == mod.getSwiftModule()) {
+      // If we're doing a single-threaded WMO build, or if the entity is
+      // scheduled to be emitted in the same translation unit, reference
+      // it directly.
+      if (this == IRGen.getGenModule(entitySF))
+        return direct();
+    }
+  }
 
   // Fall back to an indirect reference if we can't establish that a direct
   // reference is OK.

lib/IRGen/IRGenModule.h

@@ -542,7 +542,6 @@ class IRGenModule {
   SILModuleConventions silConv;
   ModuleDecl *ObjCModule = nullptr;
   ModuleDecl *ClangImporterModule = nullptr;
-  SourceFile *CurSourceFile = nullptr;
 
   llvm::StringMap<ModuleDecl*> OriginalModules;
   llvm::SmallString<128> OutputFilename;
@@ -1483,8 +1482,7 @@ private:                            \
   GenericEnvironment *getGenericEnvironment();
 
   ConstantReference
-  getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
-       ConstantReference::Directness forceIndirect = ConstantReference::Direct);
+  getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity);
 
   llvm::Constant *
   emitRelativeReference(ConstantReference target,

lib/IRGen/IRGenSIL.cpp

@@ -1585,12 +1585,6 @@ void IRGenModule::emitSILFunction(SILFunction *f) {
     return;
 
   PrettyStackTraceSILFunction stackTrace("emitting IR", f);
-  llvm::SaveAndRestore<SourceFile *> SetCurSourceFile(CurSourceFile);
-  if (auto dc = f->getModule().getAssociatedContext()) {
-    if (auto sf = dc->getParentSourceFile()) {
-      CurSourceFile = sf;
-    }
-  }
   IRGenSILFunction(*this, f).emitSILFunction();
 }