Extend -fkeep-persistent-storage-variables to cover compiler generated artifacts with reasonable mangled names that have persistent storage

[qianzhen]

Summary

This is a follow-up patch to https://reviews.llvm.org/D150221. It extends -fkeep-persistent-storage-variables to cover compiler generated artifacts—including the symbols for temporaries bound to references with persistent storage and guard variables.

Question:
The guard variables are created in each derived CXXABI class (namely ItaniumCXXABI and MicrosoftCXXABI). Hence, they are emitted after their creation accordingly in this patch. I'm not sure if there is a common place to emit them for all CXXABIs outside the derived CXXABI classes. Any suggestions would be appreciated.

clang/lib/CodeGen/CodeGenModule.cpp

ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
   llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[E];
   if (Entry) {
     Entry->replaceAllUsesWith(
         llvm::ConstantExpr::getBitCast(CV, Entry->getType()));
     llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
   }
   Entry = CV;
 
+  if (CodeGenOpts.KeepPersistentStorageVariables)
+    addUsedOrCompilerUsedGlobal(GV);
+
   return ConstantAddress(CV, Type, Align);
 }
 
 /// EmitObjCPropertyImplementations - Emit information for synthesized
 /// properties for an implementation.
 void CodeGenModule::EmitObjCPropertyImplementations(const
                                                     ObjCImplementationDecl *D) {
   for (const auto *PID : D->property_impls()) {

clang/lib/CodeGen/ItaniumCXXABI.cpp

if (!D.isLocalVarDecl() && C &&
         (CGM.getTarget().getTriple().isOSBinFormatELF() ||
          CGM.getTarget().getTriple().isOSBinFormatWasm())) {
       guard->setComdat(C);
     } else if (CGM.supportsCOMDAT() && guard->isWeakForLinker()) {
       guard->setComdat(CGM.getModule().getOrInsertComdat(guard->getName()));
     }
 
     CGM.setStaticLocalDeclGuardAddress(&D, guard);
+
+    if (CGM.getCodeGenOpts().KeepPersistentStorageVariables &&
+        (D.getStorageDuration() == SD_Static ||
+         D.getStorageDuration() == SD_Thread))
+      CGM.addUsedOrCompilerUsedGlobal(guard);
   }
 
   Address guardAddr = Address(guard, guard->getValueType(), guardAlignment);
 
   // Test whether the variable has completed initialization.
   //
   // Itanium C++ ABI 3.3.2:
   //   The following is pseudo-code showing how these functions can be used:

clang/lib/CodeGen/MicrosoftCXXABI.cpp

if (!GuardVar) {
     GuardVar->setAlignment(GuardAlign.getAsAlign());
     if (GuardVar->isWeakForLinker())
       GuardVar->setComdat(
           CGM.getModule().getOrInsertComdat(GuardVar->getName()));
     if (D.getTLSKind())
       CGM.setTLSMode(GuardVar, D);
     if (GI && !HasPerVariableGuard)
       GI->Guard = GuardVar;
+
+    if (CGM.getCodeGenOpts().KeepPersistentStorageVariables &&
+        (D.getStorageDuration() == SD_Static ||
+         D.getStorageDuration() == SD_Thread))
+      CGM.addUsedOrCompilerUsedGlobal(GuardVar);
   }
 
   ConstantAddress GuardAddr(GuardVar, GuardTy, GuardAlign);
 
   assert(GuardVar->getLinkage() == GV->getLinkage() &&
          "static local from the same function had different linkage");
 
   if (!HasPerVariableGuard) {

clang/test/CodeGen/keep-persistent-storage-variables.cpp

 // CHECK: @g5 = global i32 0, align 4
 // CHECK: @g6 = global i32 6, align 4
 // CHECK: @_ZZ5test3vE2s3 = internal global i32 0, align 4
 // CHECK: @_ZN12_GLOBAL__N_12s4E = internal global i32 42, align 4
 // CHECK: @_ZZ5test5vE3tl5 = internal thread_local global i32 1, align 4
 // CHECK: @_ZN2ST2s6E = global i32 7, align 4
 // CHECK: @_Z2v7 = internal global %union.anon zeroinitializer, align 4
 // CHECK: @_ZDC2v8E = global %struct.ST8 zeroinitializer, align 4
-// CHECK: @llvm{{(\.compiler)?}}.used = appending global [14 x ptr] [ptr @_ZL2g1, ptr @_ZL2g2, ptr @tl1, ptr @tl2, ptr @_ZL3tl3, ptr @_ZL3tl4, ptr @g5, ptr @g6, ptr @_ZZ5test3vE2s3, ptr @_ZN12_GLOBAL__N_12s4E, ptr @_ZZ5test5vE3tl5, ptr @_ZN2ST2s6E, ptr @_Z2v7, ptr @_ZDC2v8E], section "llvm.metadata"
+// CHECK: @_ZGRL2g9_ = internal global i32 55, align 4
+// CHECK: @_ZL2g9 = internal constant ptr @_ZGRL2g9_, align 8
+// CHECK: @_ZZ6test10vE3s10 = internal global i32 0, align 4
+// CHECK: @_ZGVZ6test10vE3s10 = internal global i64 0, align 8
+// CHECK: @llvm{{(\.compiler)?}}.used = appending global [18 x ptr] [ptr @_ZL2g1, ptr @_ZL2g2, ptr @tl1, ptr @tl2, ptr @_ZL3tl3, ptr @_ZL3tl4, ptr @g5, ptr @g6, ptr @_ZZ5test3vE2s3, ptr @_ZN12_GLOBAL__N_12s4E, ptr @_ZZ5test5vE3tl5, ptr @_ZN2ST2s6E, ptr @_Z2v7, ptr @_ZDC2v8E, ptr @_ZGRL2g9_, ptr @_ZL2g9, ptr @_ZGVZ6test10vE3s10, ptr @_ZZ6test10vE3s10], section "llvm.metadata"
 
 static int g1;
 static int g2 = 1;
 __thread int tl1;
 __thread int tl2 = 3;
 static __thread int tl3;
 static __thread int tl4 = 4;
 int g5;
struct ST {
   static int s6;
 };
 int ST::s6 = 7;
 
 static union { int v7; };
 
 struct ST8 { int v8; };
 auto [v8] = ST8{0};
+
+static const int &g9 = 55;
+
+int f10();
+int test10() {
+  static int s10 = f10();
+  return s10;
+}