[GlobalDCE] Support of conditionally used global variables

[kubamracek]

Summary

As part of the optimization work to emit dead-strippable symbols for Swift and enable GlobalDCE to remove those symbols when possible, we need to mark some Swift symbols as conditionally used based on a set of other symbols. Some background info can be found here: https://bugs.swift.org/browse/SR-14509.

We are proposing to add a module-level name metadata llvm.used.conditional. It contains a list of metadata triplets. Each triplet has the following form:

• The first element is the global variable from llvm.used that we are conditionally mark it as used.
• The second element is a boolean flag. 1 means when all GVs in the third element are alive, mark the first element as used. 0 means when any GV in the third element is alive, mark the first element as used.
• The third element is a list of GVs.

One example use case is for Swift protocol conformance data, we want to mark them as conditionally used, depending on the protocol descriptor and the nominal type descriptor. During GlobalDCE, we separate out the entries that are in llvm.used and also in llvm.used.conditional as the first element. We iteratively mark entries in this set as used by checking the GVs in the third element according to the flag in the second element. When one entry is marked as used, it can trigger other entries to be alive.

We are open to other alternatives to express this conditional usage.

The patch is based on initial patch from Kuba + some clean up. Testing cases will be added if this is the right approach to move forward.

[lebedev.ri]

Tests missing

[kubamracek]

Commandeering this to upload a new diff with added tests. Manman, feel free to commandeer it back :)

[kubamracek]

Adding tests that, also they showcase how the llvm.used.conditional works in practice.

[kubamracek]

Adding another test.

[pcc]

0 means when any GV in the third element is alive, mark the first element as used.

This sounds like !associated metadata.

1 means when all GVs in the third element are alive, mark the first element as used.

Do you have an example of a use case for this?

[kubamracek]

In D104496#2935794, @pcc wrote:

1 means when all GVs in the third element are alive, mark the first element as used.

Do you have an example of a use case for this?

The example is Swift's "Protocol Conformance Record" — it's a record that is referencing two things, a type and a protocol. We want to allow discarding this record if *either* the type or the protocol can be discarded.

[kubamracek]

https://lists.llvm.org/pipermail/llvm-dev/2021-August/152183.html

[kubamracek]

https://lists.llvm.org/pipermail/llvm-dev/2021-September/152654.html
https://lists.llvm.org/pipermail/llvm-dev/2021-September/152655.html
https://lists.llvm.org/pipermail/llvm-dev/2021-September/152656.html

[kubamracek]

@MaskRay, @pcc, @fhahn, this is now ready for review. I've simplified/cleaned up the implementation as much as I could, and added a formalization of the !llvm.used.conditional concept into LangRef.

[fhahn]

llvm/docs/LangRef.rst

7346 ↗

(On Diff #376716)

nit: @llvm.used?

Does the global have to be in @llvm.used or could this requirement be dropped?

7358 ↗

(On Diff #376716)

I'm not sure if we should add any swift-specific mentions here. If you want to add an example, I'd suggest keeping it very generic with respect to the type names. I'd also only focus on the !llvm.used.conditional part.

llvm/lib/Transforms/IPO/GlobalDCE.cpp

370

this makes sense, but the change should also add llvm.used.conditional verification to the IR verifier. Then we can rely on the entries being valid here.

llvm/lib/Transforms/IPO/GlobalOpt.cpp

2313

this change and compareNames could be moved to a NFC patch to reduce the size of the diff here.

[kubamracek]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

2313

https://reviews.llvm.org/D111096

[kubamracek]

llvm/docs/LangRef.rst

7346 ↗

(On Diff #376716)

Does the global have to be in @llvm.used or could this requirement be dropped?

The way I'm thinking about it, using !llvm.used.conditional *only makes sense* if the target is also listed in @llvm.used, because the effect of the GlobalDCE optimization is that if the conditions are satisfied, the global is *removed* from @llvm.used.

I think I could add something like "If the global is not in llvm.used, then there is no effect". Would that work?

[kubamracek]

Added IR Verifier for llvm.used.conditional.

[kubamracek]

@MaskRay, @pcc friendly ping on the review request :)

[fhahn]

Thanks for adding the verifier changes! Do we have a test case with a cycle between target & dependencies in the existing tests?

llvm/lib/IR/Verifier.cpp

843 ↗

(On Diff #377025)

Is this intentional?

[kubamracek]

Removed the leftover debug print. Added a test case for a circular dependency.

[dexonsmith]

I think it'd be good to add a test for llvm/lib/Linker to confirm expected output with symbol merging in LTO (e.g., two linkonce_odr symbols, or a weak and a strong symbol).

• Linking a defined symbol that has this with an external symbol
• Linking two weak symbols...
  • if they both have this and it's the same
  • if they both have this and it's different
  • if only one has this

llvm/docs/LangRef.rst

7376–7386 ↗

(On Diff #379770)

Have you considered using a metadata attachment on @record instead of a global array?

Specifically, I think this would be a simpler schema to reason about and update:

@record = internal global [...] {
  @a, @b
} !llvm.used.conditional !1

@llvm.used = appending global [...] [ ..., @record ]

!1 = !{1, !{@a, @b}}

This schema would not have the flexibility to have multiple list-of-implicit-users assigned to the same global, but IIUC that wouldn't be meaningful anyway. It also wouldn't allow referencing external symbols; also not meaningful I think?
(I haven't looked at the verifier code, but if you stick with the existing schema (and I'm right about what's meaningful), please add verifiers for those two cases.).

You might also consider creating a custom metadata type for this, similar to the debug info metadata. It'd be nice if the IR looked like this instead:

@record = internal global [...] {
  @a, @b
} !llvm.used.conditional !MDImplicitUsers(type: All, users: !{@a, @b})

@llvm.used = appending global [...] [ ..., @record ]

(despite the IR example, this is an independent suggestion of whether you change the schema)

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

 //===-- ModuleUtils.h - Functions to manipulate Modules ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This family of functions perform manipulations on Modules.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
 #define LLVM_TRANSFORMS_UTILS_MODULEUTILS_H
 
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <utility> // for std::pair
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
 class Module;
 class Function;
 class FunctionCallee;
 class GlobalValue;
+class GlobalVariable;
 class Constant;
 class Value;
 class Type;
 
 /// Append F to the list of global ctors of module M with the given Priority.
 /// This wraps the function in the appropriate structure and stores it along
 /// side other global constructors. For details see
 /// http://llvm.org/docs/LangRef.html#intg_global_ctors

 bool nameUnamedGlobals(Module &M);
 
 /// Adds global values to the llvm.used list.
 void appendToUsed(Module &M, ArrayRef<GlobalValue *> Values);
 
 /// Adds global values to the llvm.compiler.used list.
 void appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values);
 
+/// Replaces llvm.used or llvm.compiler.used list with a new set of values.
+GlobalVariable *setUsedInitializer(GlobalVariable &V,
+                                   const SmallPtrSetImpl<GlobalValue *> &Init);
+
 /// Filter out potentially dead comdat functions where other entries keep the
 /// entire comdat group alive.
 ///
 /// This is designed for cases where functions appear to become dead but remain
 /// alive due to other live entries in their comdat group.
 ///
 /// The \p DeadComdatFunctions container should only have pointers to
 /// `Function`s which are members of a comdat group and are believed to be

llvm/lib/Transforms/IPO/GlobalDCE.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/CtorUtils.h"
 #include "llvm/Transforms/Utils/GlobalStatus.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "globaldce"
 
 static cl::opt<bool>
     ClEnableVFE("enable-vfe", cl::Hidden, cl::init(true), cl::ZeroOrMore,
                 cl::desc("Enable virtual function elimination"));

 PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) {
   bool Changed = false;
 
   // The algorithm first computes the set L of global variables that are
   // trivially live.  Then it walks the initialization of these variables to
   // compute the globals used to initialize them, which effectively builds a
   // directed graph where nodes are global variables, and an edge from A to B
   // means B is used to initialize A.  Finally, it propagates the liveness
-  // information through the graph starting from the nodes in L. Nodes note
+  // information through the graph starting from the nodes in L. Nodes not
   // marked as alive are discarded.
 
   // Remove empty functions from the global ctors list.
   Changed |= optimizeGlobalCtorsList(M, isEmptyFunction);
 
   // Collect the set of members for each comdat.
   for (Function &F : M)
     if (Comdat *C = F.getComdat())
       ComdatMembers.insert(std::make_pair(C, &F));
   for (GlobalVariable &GV : M.globals())
     if (Comdat *C = GV.getComdat())
       ComdatMembers.insert(std::make_pair(C, &GV));
   for (GlobalAlias &GA : M.aliases())
     if (Comdat *C = GA.getComdat())
       ComdatMembers.insert(std::make_pair(C, &GA));
 
   // Add dependencies between virtual call sites and the virtual functions they
   // might call, if we have that information.
   AddVirtualFunctionDependencies(M);
 
+  auto *Used = M.getGlobalVariable("llvm.used");
+  auto *UsedConditional = M.getNamedMetadata("llvm.used.conditional");
+  if (UsedConditional && UsedConditional->getNumOperands() == 0)
+    UsedConditional = nullptr;
+  SmallPtrSet<GlobalValue *, 8> NewUsedArray;
+  if (Used) {
+    // Construct a set of conditionally used targets.
+    SmallPtrSet<GlobalValue *, 8> UsedConditionalTargets;
+    if (UsedConditional) {
+      for (auto *M : UsedConditional->operands()) {
+        assert(M->getNumOperands() == 3);
+        auto *V = mdconst::extract_or_null<GlobalValue>(M->getOperand(0));
+        if (!V)
+          continue;
+        UsedConditionalTargets.insert(V);
+      }
+    }
+
+    // Strip away all conditionally used targets from @llvm.used.
+    const ConstantArray *Init = cast<ConstantArray>(Used->getInitializer());
+    for (Value *Op : Init->operands()) {
+      GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
+      // G is one of the conditional targets, don't mark it as live.
+      if (UsedConditionalTargets.contains(G))
+        continue;
+      NewUsedArray.insert(G);
+    }
+    Used = setUsedInitializer(*Used, NewUsedArray);
+  }
+
   // Loop over the module, adding globals which are obviously necessary.
   for (GlobalObject &GO : M.global_objects()) {
     Changed |= RemoveUnusedGlobalValue(GO);
     // Functions with external linkage are needed if they have a body.
     // Externally visible & appending globals are needed, if they have an
     // initializer.
     if (!GO.isDeclaration())
       if (!GO.isDiscardableIfUnused())
         MarkLive(GO);
 
     UpdateGVDependencies(GO);
   }
 
   // Compute direct dependencies of aliases.
   for (GlobalAlias &GA : M.aliases()) {
     Changed |= RemoveUnusedGlobalValue(GA);
     // Externally visible aliases are needed.
     if (!GA.isDiscardableIfUnused())
       MarkLive(GA);
 
     UpdateGVDependencies(GA);
   }
 
   // Compute direct dependencies of ifuncs.
   for (GlobalIFunc &GIF : M.ifuncs()) {
     Changed |= RemoveUnusedGlobalValue(GIF);
     // Externally visible ifuncs are needed.
     if (!GIF.isDiscardableIfUnused())
       MarkLive(GIF);
 
     UpdateGVDependencies(GIF);
   }
 
+  // We need to repeat this, if a conditional used variable is marked alive and
+  // added to NewUsedArray, we should check if that will enable other
+  // conditional used variables to become alive.
+  bool HasUpdateInIteration = true;
+  while (Used && UsedConditional && HasUpdateInIteration) {
+    // Propagate liveness from collected Global Values through the computed
+    // dependencies.
+    SmallVector<GlobalValue *, 8> NewLiveGVs{AliveGlobals.begin(),
+                                             AliveGlobals.end()};
+    while (!NewLiveGVs.empty()) {
+      GlobalValue *LGV = NewLiveGVs.pop_back_val();
+      for (auto *GVD : GVDependencies[LGV]) {
+        MarkLive(*GVD, &NewLiveGVs);
+      }
+    }
+
+    unsigned OldSize = NewUsedArray.size();
+    for (auto *M : UsedConditional->operands()) {
+      assert(M->getNumOperands() == 3);
+      auto *V = mdconst::extract_or_null<GlobalValue>(M->getOperand(0));
+      if (!V)
+        continue;
+
+      auto *T = mdconst::extract_or_null<ConstantInt>(M->getOperand(1));
+      if (!T)
+        continue;
+      APInt Type = T->getValue();
+
+      SmallPtrSet<GlobalValue *, 8> Others;
+      if (M->getOperand(2) == nullptr) {
+        Others.insert(nullptr);
+      } else {
+        if (auto *SingleOther =
+                mdconst::dyn_extract_or_null<GlobalValue>(M->getOperand(2))) {
+          Others.insert(SingleOther);
+        } else {
+          Metadata *MultipleOthers = M->getOperand(2).get();
+          MDNode *Node = dyn_cast_or_null<MDNode>(MultipleOthers);
+          for (auto &X : Node->operands()) {
+            auto *Y = X.get();
+            if (!Y)
+              continue;
+            auto *C = mdconst::extract_or_null<Constant>(Y);
+            C = C->stripPointerCasts();
+            auto *O = cast<GlobalValue>(C);
+            Others.insert(O);
+          }
+        }
+      }
+
+      bool AllOthersAlive = true;
+      bool AnyOtherAlive = false;
+      for (auto *GV : Others) {
+        bool Live = AliveGlobals.count(GV) != 0;
+        if (Live)
+          AnyOtherAlive = true;
+        else
+          AllOthersAlive = false;
+      }
+
+      if ((Type == 0 && AnyOtherAlive) || (Type == 1 && AllOthersAlive)) {
+        NewUsedArray.insert(V);
+        MarkLive(*V);
+        LLVM_DEBUG(dbgs() << "Mark conditional used GV " << V->getName()
+                          << " to be live.\n");
+      }
+    }
+    LLVM_DEBUG(dbgs() << "Optimizing UsedConditional iteration end " << OldSize
+                      << ' ' << NewUsedArray.size() << "\n");
+    HasUpdateInIteration = NewUsedArray.size() > OldSize;
+  }
+  if (Used && UsedConditional) {
+    Used = setUsedInitializer(*Used, NewUsedArray);
+    MarkLive(*Used);
+  }
+
   // Propagate liveness from collected Global Values through the computed
   // dependencies.
   SmallVector<GlobalValue *, 8> NewLiveGVs{AliveGlobals.begin(),
                                            AliveGlobals.end()};
   while (!NewLiveGVs.empty()) {
     GlobalValue *LGV = NewLiveGVs.pop_back_val();
     for (auto *GVD : GVDependencies[LGV])
       MarkLive(*GVD, &NewLiveGVs);

llvm/lib/Transforms/IPO/GlobalOpt.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/CtorUtils.h"
 #include "llvm/Transforms/Utils/Evaluator.h"
 #include "llvm/Transforms/Utils/GlobalStatus.h"
 #include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
 #include <cassert>
 #include <cstdint>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "globalopt"
if (EvalSuccess) {
     BatchCommitValueTo(Eval.getMutatedMemory());
     for (GlobalVariable *GV : Eval.getInvariants())
       GV->setConstant(true);
   }
 
   return EvalSuccess;
 }
 
-static int compareNames(Constant *const *A, Constant *const *B) {
-  Value *AStripped = (*A)->stripPointerCasts();
-  Value *BStripped = (*B)->stripPointerCasts();
-  return AStripped->getName().compare(BStripped->getName());
-}
-
-static void setUsedInitializer(GlobalVariable &V,
-                               const SmallPtrSetImpl<GlobalValue *> &Init) {
-  if (Init.empty()) {
-    V.eraseFromParent();
-    return;
-  }
-
-  // Type of pointer to the array of pointers.
-  PointerType *Int8PtrTy = Type::getInt8PtrTy(V.getContext(), 0);
-
-  SmallVector<Constant *, 8> UsedArray;
-  for (GlobalValue *GV : Init) {
-    Constant *Cast
-      = ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, Int8PtrTy);
-    UsedArray.push_back(Cast);
-  }
-  // Sort to get deterministic order.
-  array_pod_sort(UsedArray.begin(), UsedArray.end(), compareNames);
-  ArrayType *ATy = ArrayType::get(Int8PtrTy, UsedArray.size());
-
-  Module *M = V.getParent();
-  V.removeFromParent();
-  GlobalVariable *NV =
-      new GlobalVariable(*M, ATy, false, GlobalValue::AppendingLinkage,
-                         ConstantArray::get(ATy, UsedArray), "");
-  NV->takeName(&V);
-  NV->setSection("llvm.metadata");
-  delete &V;
-}
-
 namespace {
 
 /// An easy to access representation of llvm.used and llvm.compiler.used.
 class LLVMUsed {
   SmallPtrSet<GlobalValue *, 4> Used;
   SmallPtrSet<GlobalValue *, 4> CompilerUsed;
   GlobalVariable *UsedV;
   GlobalVariable *CompilerUsedV;

llvm/lib/Transforms/Utils/ModuleUtils.cpp

 void llvm::appendToUsed(Module &M, ArrayRef<GlobalValue *> Values) {
   appendToUsedList(M, "llvm.used", Values);
 }
 
 void llvm::appendToCompilerUsed(Module &M, ArrayRef<GlobalValue *> Values) {
   appendToUsedList(M, "llvm.compiler.used", Values);
 }
 
+static int compareNames(Constant *const *A, Constant *const *B) {
+  Value *AStripped = (*A)->stripPointerCasts();
+  Value *BStripped = (*B)->stripPointerCasts();
+  return AStripped->getName().compare(BStripped->getName());
+}
+
+GlobalVariable *llvm::setUsedInitializer(
+    GlobalVariable &V, const SmallPtrSetImpl<GlobalValue *> &Init) {
+  if (Init.empty()) {
+    V.eraseFromParent();
+    return nullptr;
+  }
+
+  // Type of pointer to the array of pointers.
+  PointerType *Int8PtrTy = Type::getInt8PtrTy(V.getContext(), 0);
+
+  SmallVector<Constant *, 8> UsedArray;
+  for (GlobalValue *GV : Init) {
+    Constant *Cast
+      = ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, Int8PtrTy);
+    UsedArray.push_back(Cast);
+  }
+  // Sort to get deterministic order.
+  array_pod_sort(UsedArray.begin(), UsedArray.end(), compareNames);
+  ArrayType *ATy = ArrayType::get(Int8PtrTy, UsedArray.size());
+
+  Module *M = V.getParent();
+  V.removeFromParent();
+  GlobalVariable *NV =
+      new GlobalVariable(*M, ATy, false, GlobalValue::AppendingLinkage,
+                         ConstantArray::get(ATy, UsedArray), "");
+  NV->takeName(&V);
+  NV->setSection("llvm.metadata");
+  delete &V;
+  return NV;
+}
+
 FunctionCallee
 llvm::declareSanitizerInitFunction(Module &M, StringRef InitName,
                                    ArrayRef<Type *> InitArgTypes) {
   assert(!InitName.empty() && "Expected init function name");
   return M.getOrInsertFunction(
       InitName,
       FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false),
       AttributeList());

llvm/test/Transforms/GlobalDCE/used.conditional1.ll

+; RUN: opt -S -globaldce < %s | FileCheck %s
+
+;
+; (1) a regular dead global referenced in @llvm.used is kept alive
+;
+define internal void @func_marked_as_used() {
+  ; CHECK: @func_marked_as_used
+  ret void
+}
+
+;
+; (2) a dead global referenced in @llvm.used, but marked as conditionally used
+; in !llvm.used.conditional where the condition is alive, is kept alive
+;
+define internal void @func_conditionally_used_and_live() {
+  ; CHECK: @func_conditionally_used_and_live
+  ret void
+}
+
+;
+; (3) a dead global referenced in @llvm.used, but marked as conditionally used
+; in !llvm.used.conditional where the condition is dead, is eliminated
+;
+define internal void @func_conditionally_used_and_dead() {
+  ; CHECK-NOT: @func_conditionally_used_and_dead
+  ret void
+}
+
+@condition_live = internal unnamed_addr constant i64 42
+@condition_dead = internal unnamed_addr constant i64 42
+
[e-mail] = appending global [4 x i8*] [
+   i8* bitcast (void ()* @func_marked_as_used to i8*),
+   i8* bitcast (i64* @condition_live to i8*),
+   i8* bitcast (void ()* @func_conditionally_used_and_live to i8*),
+   i8* bitcast (void ()* @func_conditionally_used_and_dead to i8*)
+], section "llvm.metadata"
+
+!1 = !{void ()* @func_conditionally_used_and_live, i32 0, i64* @condition_live}
+!2 = !{void ()* @func_conditionally_used_and_dead, i32 0, i64* @condition_dead}
+!llvm.used.conditional = !{!1, !2}

llvm/test/Transforms/GlobalDCE/used.conditional2.ll

+; RUN: opt -S -globaldce < %s | FileCheck %s
+
+;
+; (1) a dead global referenced in @llvm.used, but marked as conditionally used
+; by both @condition_live and @condition_dead, with an *ANY* type, is alive
+;
+define internal void @func_conditionally_by_two_conditions_any() {
+  ; CHECK: @func_conditionally_by_two_conditions_any
+  ret void
+}
+
+;
+; (2) a dead global referenced in @llvm.used, but marked as conditionally used
+; by both @condition_live and @condition_dead, with an *ALL* type, is removed
+;
+define internal void @func_conditionally_by_two_conditions_all() {
+  ; CHECK-NOT: @func_conditionally_by_two_conditions_all
+  ret void
+}
+
+@condition_live = internal unnamed_addr constant i64 42
+@condition_dead = internal unnamed_addr constant i64 42
+
[e-mail] = appending global [3 x i8*] [
+   i8* bitcast (i64* @condition_live to i8*),
+   i8* bitcast (void ()* @func_conditionally_by_two_conditions_any to i8*),
+   i8* bitcast (void ()* @func_conditionally_by_two_conditions_all to i8*)
+], section "llvm.metadata"
+
+!1 = !{void ()* @func_conditionally_by_two_conditions_any, i32 0, !{ i64* @condition_live, i64* @condition_dead } }
+!2 = !{void ()* @func_conditionally_by_two_conditions_all, i32 1, !{ i64* @condition_live, i64* @condition_dead } }
+!llvm.used.conditional = !{!1, !2}

llvm/test/Transforms/GlobalDCE/used.conditional3.ll

+; RUN: opt -S -globaldce < %s | FileCheck %s
+
+; Test that when performing llvm.used.conditional removals, we discover globals
+; that might trigger other llvm.used.conditional liveness. See the following
+; diagram of dependencies between the globals:
+;
+; @a -\
+;      \ (conditional, see !1, satisfied)
+;       \-> @b -\
+;                \ (regular usage)
+;                 \-> @c -\
+;                          \ (conditional, see !2, satisfied)
+;                           \-> @d
+
+@a = internal unnamed_addr constant i64 42
+@b = internal unnamed_addr constant i64* @c
+@c = internal unnamed_addr constant i64 42
+@d = internal unnamed_addr constant i64 42
+
+; All four, and mainly @d need to stay alive:
+; CHECK: @a = internal unnamed_addr constant i64 42
+; CHECK: @b = internal unnamed_addr constant i64* @c
+; CHECK: @c = internal unnamed_addr constant i64 42
+; CHECK: @d = internal unnamed_addr constant i64 42
+
[e-mail] = appending global [3 x i8*] [
+  i8* bitcast (i64* @a to i8*),
+  i8* bitcast (i64** @b to i8*),
+  i8* bitcast (i64* @d to i8*)
+], section "llvm.metadata"
+
+!1 = !{i64** @b, i32 0, i64* @a}
+!2 = !{i64* @d, i32 0, i64* @c}
+!llvm.used.conditional = !{!1, !2}