Track (previously deferred) emitted symbol; put back as deferred if unloaded.

`EmittedDeferredDecls` is a map from "global value emitted because a deferred definition was needed" to the entries of the DeferredDecls to be put back when the global value is unloaded.
Fix the unloading of definitions of emitted deferred symbols, and the unloading of declarations from the DeferredDecls.
forgetDecl() only needs to act on weak declarations with a definition (strong symbols are emitted, those without a definition cannot enter DeferredDecls).

Author: Axel-Naumann

interpreter/llvm/src/tools/clang/lib/CodeGen/CodeGenModule.cpp

@@ -1332,7 +1332,6 @@ void CodeGenModule::EmitDeferred() {
 
     // Otherwise, emit the definition and move on to the next one.
     EmitGlobalDefinition(D, GV);
-    EmittedDeferredDecls[GV->getName()] = D;
 
     // If we found out that we need to emit more decls, do that recursively.
     // This has the advantage that the decls are emitted in a DFS and related
@@ -1971,6 +1970,7 @@ CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
       // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
       // don't need it anymore).
       addDeferredDeclToEmit(F, DDI->second);
+      EmittedDeferredDecls[F] = std::make_pair(DDI->first, DDI->second);
       DeferredDecls.erase(DDI);
 
       // Otherwise, there are cases we have to worry about where we're
@@ -2168,6 +2168,7 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
     // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
     // list, and remove it from DeferredDecls (since we don't need it anymore).
     addDeferredDeclToEmit(GV, DDI->second);
+    EmittedDeferredDecls[GV] = std::make_pair(DDI->first, DDI->second);
     DeferredDecls.erase(DDI);
   }
 

interpreter/llvm/src/tools/clang/lib/CodeGen/CodeGenModule.h

@@ -36,6 +36,8 @@
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
 
+#include <unordered_map>
+
 namespace llvm {
 class Module;
 class Constant;
@@ -321,7 +323,11 @@ class CodeGenModule : public CodeGenTypeCache {
   }
 
   /// Enables unloading of emitted symbols that need to become deferred.
-  llvm::StringMap<GlobalDecl> EmittedDeferredDecls;
+  /// Key is the emitted definition, value is symbol name + Decl created
+  /// while marking this deferred, i.e. the content of DeferredDecls.
+  std::unordered_map<llvm::GlobalValue*,
+                     std::pair<llvm::StringRef, GlobalDecl>>
+    EmittedDeferredDecls;
 
 
   /// List of alias we have emitted. Used to make sure that what they point to

interpreter/llvm/src/tools/clang/lib/CodeGen/ModuleBuilder.cpp

@@ -287,29 +287,47 @@ namespace clang {
         }
       }
 
-      if (GV->isWeakForLinker() && !GV->isDeclaration()) {
-        auto IEmittedDeferredDecl
-          = Builder->EmittedDeferredDecls.find(GV->getName());
-        if (IEmittedDeferredDecl != Builder->EmittedDeferredDecls.end()) {
-          Builder->DeferredDecls[GV->getName()] = IEmittedDeferredDecl->second;
-          Builder->EmittedDeferredDecls.erase(IEmittedDeferredDecl);
+      if (GV->isWeakForLinker()) {
+        if (!GV->isDeclaration()) {
+          // This is a definition. If if was emitted as deferred, move it
+          // back into deferred state.
+          auto IEmittedDeferredDecl
+            = Builder->EmittedDeferredDecls.find(GV);
+          if (IEmittedDeferredDecl != Builder->EmittedDeferredDecls.end()) {
+            // Use the name of the original GV, not that of our definition
+            // that's soon to be erased.
+            Builder->DeferredDecls[IEmittedDeferredDecl->second.first]
+              = IEmittedDeferredDecl->second.second;
+            Builder->EmittedDeferredDecls.erase(IEmittedDeferredDecl);
+          }
+        } else {
+          // might be an entry in the deferred decls, if so: remove!
+          auto IDeferredDecl = Builder->DeferredDecls.find(GV->getName());
+          if (IDeferredDecl != Builder->DeferredDecls.end()) {
+            // yes, pointer comparison.
+            if (IDeferredDecl->first.data() == GV->getName().data())
+              Builder->DeferredDecls.erase(IDeferredDecl);
+          }
         }
       }
     }
 
     void forgetDecl(const GlobalDecl& GD) {
-      StringRef MangledName = Builder->getMangledName(GD);
-      auto IEmittedDeferredDecl
-        = Builder->EmittedDeferredDecls.find(MangledName);
-      if (IEmittedDeferredDecl != Builder->EmittedDeferredDecls.end()) {
-        assert(IEmittedDeferredDecl->getValue() == GD
-               && "Removing wrong EmittedDeferredDecl");
-        Builder->EmittedDeferredDecls.erase(IEmittedDeferredDecl);
+      if (const auto VD = dyn_cast<VarDecl>(GD.getDecl())) {
+        if (!VD->isWeak() || !VD->isThisDeclarationADefinition())
+          return;
+      } else if (const auto FD = dyn_cast<FunctionDecl>(GD.getDecl())) {
+        if (!FD->isWeak() || !FD->isThisDeclarationADefinition())
+          return;
       } else {
-        auto IDeferredDecl = Builder->DeferredDecls.find(MangledName);
-        if (IDeferredDecl != Builder->DeferredDecls.end()) {
+        return;
+      }
+      // It's a weak, defined var or function decl.
+      StringRef MangledName = Builder->getMangledName(GD);
+      auto IDeferredDecl = Builder->DeferredDecls.find(MangledName);
+      if (IDeferredDecl != Builder->DeferredDecls.end()) {
+        if (IDeferredDecl->second == GD)
           Builder->DeferredDecls.erase(IDeferredDecl);
-        }
       }
     }