Prevent GlobalOpts from dropping ASANitized global variables

[aprantl]

Summary

ASAN transforms global variables into an array with extra storage at the end and RAUWs the global value with a GEP into the array. GlobalOpts will think that the GEP constexpr is dead because its only use is a Metadata node and eliminate it, thus dropping the storage from the debug info.
This patch fixes this by adding a flag to Constant::removeDeadConstantUsers() to optionally ignore metadata users.

[dexonsmith]

Ugh, this is ugly. We should really start using a !dbg attachment on
global variables, much like we changed functions. Then ASan can update
the attachment (if necessary), and we don't rely on RAUW to get things
right. (I'm not sure that needs to happen before we fix this bug.)

Comments inline.

[aprantl]

Prevent the new behavior from affecting code generation.

[aprantl]

I added a check to catch the case where the GV is only kept alive by a constant that is only kept alive by metadata.

[llvm-commits]

I'm concerned that fixing up GlobalOpt::deleteIfDead isn't enough
to avoid affecting CodeGen. There are other places in the
pipeline that will check Value::use_empty and/or have logic like
(or use directly) Function::isDefTriviallyDead. I think it's
important that the call to GV.removeDeadConstantUsers() has the
same effect on use-lists whether or not there's any debug info.
Moreover, GlobalOpt::deleteIfDead should have the same effect on
the entire module (including use-lists) regardless of debug info.

(But in case you can convince me, more comments below.)

[aprantl]

Alright, I'm not sure if I want to invest any more time in this patch. I will investigate how much work it is to reverse the pointers between CU and global variables next.

[aprantl]

Attaching a WIP patch for reversing the ownership between DIGlobalVariable and GlobalVariable.

[dexonsmith]

In D18109#423819, @aprantl wrote:

Attaching a WIP patch for reversing the ownership between DIGlobalVariable and GlobalVariable.

"Requesting changes" as I assume this at least needs to be rebased, but I still think it's a good direction. Is the a reason this wasn't pursued further?

include/llvm/IR/Constant.h

   /// them. This method is useful for clients that want to check to see if a
   /// global is unused, but don't want to deal with potentially dead constants
   /// hanging off of the globals.
-  void removeDeadConstantUsers() const;
+  void removeDeadConstantUsers(bool SkipMetadataUses = true) const;
 
   Constant *stripPointerCasts() {
     return cast<Constant>(Value::stripPointerCasts());

include/llvm/IR/DebugInfoMetadata.h

   iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
 };
 
+/// A list of pairs (DIGlobalVariable, DIExpression).
+///
+/// TODO: Implement optimized underlying storage instead of using an
+/// MDTuple.
+class DIGlobalVarExprList {
+  const MDTuple *N = nullptr;
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+public:
+  typedef std::pair<DIGlobalVariable *, DIExpression *> DIGlobalVarExpr;
+  DIGlobalVarExprList(const MDTuple *N)
+    : N(N) { assert(!N || N->getNumOperands() % 2 == 0); }
+  ~DIGlobalVarExprList() = default;
+
+  explicit operator bool() const { return get(); }
+  explicit operator MDTuple *() const { return get(); }
+
+  MDTuple *get() const { return const_cast<MDTuple *>(N); }
+  MDTuple *operator->() const { return get(); }
+  MDTuple &operator*() const { return *get(); }
+
+  DIGlobalVarExpr operator[](unsigned I) const {
+    return {cast<DIGlobalVariable>(N->getOperand(2 * I)),
+            cast<DIExpression>(N->getOperand(2 * I + 1))};
+  }
+
+  class iterator : std::iterator<std::input_iterator_tag, DIGlobalVarExpr,
+                                 std::ptrdiff_t, void, DIGlobalVarExpr> {
+    MDNode::op_iterator I = nullptr;
+
+  public:
+    iterator() = default;
+    explicit iterator(MDNode::op_iterator I) : I(I) {}
+    DIGlobalVarExpr operator*() const {
+      return {cast<DIGlobalVariable>(*I), cast<DIExpression>(*std::next(I))};
+    }
+    iterator &operator++() {
+      std::advance(I, 2);
+      return *this;
+    }
+    iterator operator++(int) {
+      iterator Temp(*this);
+      std::advance(I, 2);
+      return Temp;
+    }
+    bool operator==(const iterator &X) const { return I == X.I; }
+    bool operator!=(const iterator &X) const { return I != X.I; }
+  };
+
+  iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
+  iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
+};
+
 /// \brief Tagged DWARF-like metadata node.
 ///
 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,

   }
 };
 
+ 
 /// \brief Local variable.
 ///
 /// TODO: Split up flags.

include/llvm/IR/Function.h

   /// Bits from GlobalObject::GlobalObjectSubclassData.
   enum {
     /// Whether this function is materializable.
-    IsMaterializableBit = 1 << 0,
-    HasMetadataHashEntryBit = 1 << 1
+    IsMaterializableBit = 1 << 0
   };
-  void setGlobalObjectBit(unsigned Mask, bool Value) {
-    setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
-                                (Value ? Mask : 0u));
-  }
 
   friend class SymbolTableListTraits<Function>;
 

   /// setjmp or other function that gcc recognizes as "returning twice".
   bool callsFunctionThatReturnsTwice() const;
 
-  /// \brief Check if this has any metadata.
-  bool hasMetadata() const { return hasMetadataHashEntry(); }
-
-  /// \brief Get the current metadata attachment, if any.
-  ///
-  /// Returns \c nullptr if such an attachment is missing.
-  /// @{
-  MDNode *getMetadata(unsigned KindID) const;
-  MDNode *getMetadata(StringRef Kind) const;
-  /// @}
-
-  /// \brief Set a particular kind of metadata attachment.
-  ///
-  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
-  /// replacing it if it already exists.
-  /// @{
-  void setMetadata(unsigned KindID, MDNode *MD);
-  void setMetadata(StringRef Kind, MDNode *MD);
-  /// @}
-
-  /// \brief Get all current metadata attachments.
-  void
-  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
-
-  /// \brief Drop metadata not in the given list.
-  ///
-  /// Drop all metadata from \c this not included in \c KnownIDs.
-  void dropUnknownMetadata(ArrayRef<unsigned> KnownIDs);
-
   /// \brief Set the attached subprogram.
   ///
   /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.

     Value::setValueSubclassData(D);
   }
   void setValueSubclassDataBit(unsigned Bit, bool On);
-
-  bool hasMetadataHashEntry() const {
-    return getGlobalObjectSubClassData() & HasMetadataHashEntryBit;
-  }
-  void setHasMetadataHashEntry(bool HasEntry) {
-    setGlobalObjectBit(HasMetadataHashEntryBit, HasEntry);
-  }
-
-  void clearMetadata();
 };
 
 template <>

include/llvm/IR/GlobalObject.h

 
 namespace llvm {
 class Comdat;
+class MDNode;
 class Module;
 
 class GlobalObject : public GlobalValue {

   Comdat *ObjComdat;
   static const unsigned AlignmentBits = 5;
   static const unsigned GlobalObjectSubClassDataBits =
-      GlobalValueSubClassDataBits - AlignmentBits;
+      GlobalValueSubClassDataBits - AlignmentBits - 1;
+
+  /// Bits from GlobalObject::GlobalObjectSubclassData.
+  enum {
+    HasMetadataHashEntryBit = 1 << 1
+  };
+
+  void setGlobalObjectBit(unsigned Mask, bool Value) {
+    setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
+                                (Value ? Mask : 0u));
+  }
+
+  void clearMetadata();
 
 private:
   static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
 
+  bool hasMetadataHashEntry() const {
+    return getGlobalObjectSubClassData() & HasMetadataHashEntryBit;
+  }
+  void setHasMetadataHashEntry(bool HasEntry) {
+    setGlobalObjectBit(HasMetadataHashEntryBit, HasEntry);
+  }
+
 public:
   unsigned getAlignment() const {
     unsigned Data = getGlobalValueSubClassData();

 
   void copyAttributesFrom(const GlobalValue *Src) override;
 
+
+  /// Check if this has any metadata.
+  bool hasMetadata() const { return hasMetadataHashEntry(); }
+
+  /// Get the current metadata attachment, if any.
+  ///
+  /// Returns \c nullptr if such an attachment is missing.
+  /// @{
+  MDNode *getMetadata(unsigned KindID) const;
+  MDNode *getMetadata(StringRef Kind) const;
+  /// @}
+
+  /// Set a particular kind of metadata attachment.
+  ///
+  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
+  /// replacing it if it already exists.
+  /// @{
+  void setMetadata(unsigned KindID, MDNode *MD);
+  void setMetadata(StringRef Kind, MDNode *MD);
+  /// @}
+
+  /// Get all current metadata attachments.
+  void
+  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
+
+  /// Drop metadata not in the given list.
+  ///
+  /// Drop all metadata from \c this not included in \c KnownIDs.
+  void dropUnknownMetadata(ArrayRef<unsigned> KnownIDs);
+  
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::FunctionVal ||

include/llvm/IR/GlobalValue.h

   friend class Constant;
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
   
 protected:
   /// \brief The intrinsic ID for this subclass (which must be a Function).
   ///

include/llvm/IR/GlobalVariable.h

 
 class Module;
 class Constant;
+class DIGlobalVarExprList;
 template <typename ValueSubClass> class SymbolTableListTraits;
 
 class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {

   static inline bool classof(const Value *V) {
     return V->getValueID() == Value::GlobalVariableVal;
   }
+
+  /// Set the attached DIGlobalVarExprList.
+  ///
+  /// Calls \a setMetadata() with \a LLVMContext::MD_dbg.
+  void setGlobalVarExprs(DIGlobalVarExprList SP);
+
+  /// Get the attached DIGlobalVarExprList.
+  ///
+  /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
+  /// to \a DIGlobalVariable.
+  DIGlobalVarExprList getGlobalVarExprs() const;
 };
 
 template <>

lib/AsmParser/LLParser.cpp

 /// ParseGlobal
 ///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
-///       OptionalExternallyInitialized GlobalType Type Const
+///       OptionalExternallyInitialized GlobalType Type Const (, !dbg !42)
 ///   ::= OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
-///       OptionalExternallyInitialized GlobalType Type Const
+///       OptionalExternallyInitialized GlobalType Type Const (, !dbg !42)
 ///
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.

   // Parse attributes on the global.
   while (Lex.getKind() == lltok::comma) {
     Lex.Lex();
-
-    if (Lex.getKind() == lltok::kw_section) {
+    if (Lex.getKind() == lltok::MetadataVar) {
+      unsigned MDK;
+      MDNode *N;
+      if (ParseMetadataAttachment(MDK, N))
+        return true;
+      GV->setMetadata(MDK, N);
+    } else if (Lex.getKind() == lltok::kw_section) {
       Lex.Lex();
       GV->setSection(Lex.getStrVal());
       if (ParseToken(lltok::StringConstant, "expected global section string"))

lib/Bitcode/Reader/BitcodeReader.cpp

       if (Record.size() != 11)
         return error("Invalid record");
 
-      MetadataList.assignValue(
-          GET_OR_DISTINCT(DIGlobalVariable, Record[0],
-                          (Context, getMDOrNull(Record[1]),
-                           getMDString(Record[2]), getMDString(Record[3]),
-                           getMDOrNull(Record[4]), Record[5],
-                           getMDOrNull(Record[6]), Record[7], Record[8],
-                           getMDOrNull(Record[9]), getMDOrNull(Record[10]))),
-          NextMetadataNo++);
+      auto *MD = GET_OR_DISTINCT(
+          DIGlobalVariable, Record[0],
+          (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
+           getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
+           getMDOrNull(Record[6]), Record[7], Record[8], getMDOrNull(Record[9]),
+           nullptr));
+
+      MetadataList.assignValue(MD, NextMetadataNo++);
+
+      // Make a best effort to upgrade the global metadata graph.
+      if (auto *Var = getMDOrNull(Record[10]))
+        if (auto *Val = dyn_cast_or_null<ValueAsMetadata>(Var))
+          if (auto *GO = dyn_cast_or_null<GlobalVariable>(Val->getValue()))
+            GO->setGlobalVarExprs(MDTuple::getDistinct(
+                Context, {cast<DIGlobalVariable>(MD), nullptr}));
+
       break;
     }
     case bitc::METADATA_LOCAL_VAR: {

   SmallVector<uint64_t, 64> Record;
   std::vector<std::string> SectionTable;
   std::vector<std::string> GCTable;
+  std::vector<std::pair<GlobalVariable *, unsigned>> GlobalVarMetadata;
 
   // Read all the records for this module.
   while (1) {

     switch (Entry.Kind) {
     case BitstreamEntry::Error:
       return error("Malformed block");
-    case BitstreamEntry::EndBlock:
+    case BitstreamEntry::EndBlock: {
+      for (auto &GVID : GlobalVarMetadata)
+        if (MDNode *MD = MetadataList.getMDNodeFwdRefOrNull(GVID.second))
+          GVID.first->setMetadata(LLVMContext::MD_dbg, MD);
+        else
+          return error("Invalid debug info node");
       return globalCleanup();
+    }
 
     case BitstreamEntry::SubBlock:
       switch (Entry.ID) {

     // GLOBALVAR: [pointer type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat]
+    //             comdat, metadata]
     case bitc::MODULE_CODE_GLOBALVAR: {
       if (Record.size() < 6)
         return error("Invalid record");

       } else if (hasImplicitComdat(RawLinkage)) {
         NewGV->setComdat(reinterpret_cast<Comdat *>(1));
       }
+
+      if (Record.size() > 12 && Record[12]) {
+        llvm::errs()<<Record[12]<<"\n";
+        // Defer this until the METADATA_VALUES block has been read.
+        GlobalVarMetadata.push_back({NewGV, Record[12] - 1});
+      }
       break;
     }
     // FUNCTION:  [type, callingconv, isproto, linkage, paramattr,

lib/Bitcode/Writer/BitcodeWriter.cpp

     // GLOBALVAR: [type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat]
+    //             comdat, metadata]
     Vals.push_back(VE.getTypeID(GV.getValueType()));
     Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
     Vals.push_back(GV.isDeclaration() ? 0 :

         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.hasUnnamedAddr() || GV.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
-        GV.hasComdat()) {
+        GV.hasComdat() || GV.hasMetadata()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(GV.hasUnnamedAddr());
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
+      Vals.push_back(VE.getMetadataOrNullID(GV.getGlobalVarExprs().get()));
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }

lib/Bitcode/Writer/ValueEnumerator.cpp

   for (const GlobalVariable &GV : M.globals())
     if (GV.hasInitializer())
       EnumerateValue(GV.getInitializer());
     
   // Enumerate the aliasees.
   for (const GlobalAlias &GA : M.aliases())
     EnumerateValue(GA.getAliasee());

   EnumerateNamedMetadata(M);
 
   SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
+  for (const GlobalVariable &GV : M.globals()) {
+    GV.getAllMetadata(MDs);
+    for (const auto &I : MDs)
+      EnumerateMetadata(I.second);
+  }
 
   // Enumerate types used by function bodies and argument lists.
   for (const Function &F : M) {

lib/IR/AsmWriter.cpp

   for (const GlobalVariable &Var : TheModule->globals()) {
     if (!Var.hasName())
       CreateModuleSlot(&Var);
+
+    SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
+    Var.getAllMetadata(MDs);
+    for (auto &MD : MDs)
+      CreateMetadataSlot(MD.second);
   }
 
   for (const GlobalAlias &A : TheModule->aliases()) {

   if (GV->getAlignment())
     Out << ", align " << GV->getAlignment();
 
+  SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
+  GV->getAllMetadata(MDs);
+  printMetadataAttachments(MDs, ", ");
+  
   printInfoComment(*GV);
 }
 

lib/IR/Constants.cpp

 /// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove
 /// it.  This involves recursively eliminating any dead users of the
 /// constantexpr.
-static bool removeDeadUsersOfConstant(const Constant *C) {
+static bool removeDeadUsersOfConstant(const Constant *C, bool SkipMetadataUses) {
   if (isa<GlobalValue>(C)) return false; // Cannot remove this
 
   while (!C->use_empty()) {
     const Constant *User = dyn_cast<Constant>(C->user_back());
     if (!User) return false; // Non-constant usage;
-    if (!removeDeadUsersOfConstant(User))
+    if (!removeDeadUsersOfConstant(User, SkipMetadataUses))
       return false; // Constant wasn't dead
   }
 
+  if (!SkipMetadataUses && C->isUsedByMetadata())
+    return false;
+
   const_cast<Constant*>(C)->destroyConstant();
   return true;
 }

 /// off of this constant, remove them.  This method is useful for clients
 /// that want to check to see if a global is unused, but don't want to deal
 /// with potentially dead constants hanging off of the globals.
-void Constant::removeDeadConstantUsers() const {
+void Constant::removeDeadConstantUsers(bool SkipMetadataUses) const {
   Value::const_user_iterator I = user_begin(), E = user_end();
   Value::const_user_iterator LastNonDeadUser = E;
   while (I != E) {

       continue;
     }
 
-    if (!removeDeadUsersOfConstant(User)) {
+    if (!removeDeadUsersOfConstant(User, SkipMetadataUses)) {
       // If the constant wasn't dead, remember that this was the last live use
       // and move on to the next constant.
       LastNonDeadUser = I;

lib/IR/LLVMContextImpl.h

   /// Collection of per-instruction metadata used in this context.
   DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
 
-  /// Collection of per-function metadata used in this context.
-  DenseMap<const Function *, MDAttachmentMap> FunctionMetadata;
+  /// Collection of per-GO metadata used in this context.
+  DenseMap<const GlobalObject *, MDAttachmentMap> GlobalObjectMetadata;
 
   /// DiscriminatorTable - This table maps file:line locations to an
   /// integer representing the next DWARF path discriminator to assign to

lib/IR/Metadata.cpp

   setHasMetadataHashEntry(false);
 }
 
-MDNode *Function::getMetadata(unsigned KindID) const {
+MDNode *GlobalObject::getMetadata(unsigned KindID) const {
   if (!hasMetadata())
     return nullptr;
-  return getContext().pImpl->FunctionMetadata[this].lookup(KindID);
+  return getContext().pImpl->GlobalObjectMetadata[this].lookup(KindID);
 }
 
-MDNode *Function::getMetadata(StringRef Kind) const {
+MDNode *GlobalObject::getMetadata(StringRef Kind) const {
   if (!hasMetadata())
     return nullptr;
   return getMetadata(getContext().getMDKindID(Kind));
 }
 
-void Function::setMetadata(unsigned KindID, MDNode *MD) {
+void GlobalObject::setMetadata(unsigned KindID, MDNode *MD) {
   if (MD) {
     if (!hasMetadata())
       setHasMetadataHashEntry(true);
 
-    getContext().pImpl->FunctionMetadata[this].set(KindID, *MD);
+    getContext().pImpl->GlobalObjectMetadata[this].set(KindID, *MD);
     return;
   }
 

   if (!hasMetadata())
     return;
 
-  auto &Store = getContext().pImpl->FunctionMetadata[this];
+  auto &Store = getContext().pImpl->GlobalObjectMetadata[this];
   Store.erase(KindID);
   if (Store.empty())
     clearMetadata();
 }
 
-void Function::setMetadata(StringRef Kind, MDNode *MD) {
+void GlobalObject::setMetadata(StringRef Kind, MDNode *MD) {
   if (!MD && !hasMetadata())
     return;
   setMetadata(getContext().getMDKindID(Kind), MD);
 }
 
-void Function::getAllMetadata(
+void GlobalObject::getAllMetadata(
     SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
   MDs.clear();
 
   if (!hasMetadata())
     return;
 
-  getContext().pImpl->FunctionMetadata[this].getAll(MDs);
+  getContext().pImpl->GlobalObjectMetadata[this].getAll(MDs);
 }
 
-void Function::dropUnknownMetadata(ArrayRef<unsigned> KnownIDs) {
+void GlobalObject::dropUnknownMetadata(ArrayRef<unsigned> KnownIDs) {
   if (!hasMetadata())
     return;
   if (KnownIDs.empty()) {

   SmallSet<unsigned, 5> KnownSet;
   KnownSet.insert(KnownIDs.begin(), KnownIDs.end());
 
-  auto &Store = getContext().pImpl->FunctionMetadata[this];
+  auto &Store = getContext().pImpl->GlobalObjectMetadata[this];
   assert(!Store.empty());
 
   Store.remove_if([&KnownSet](const std::pair<unsigned, TrackingMDNodeRef> &I) {

     clearMetadata();
 }
 
-void Function::clearMetadata() {
+void GlobalObject::clearMetadata() {
   if (!hasMetadata())
     return;
-  getContext().pImpl->FunctionMetadata.erase(this);
+  getContext().pImpl->GlobalObjectMetadata.erase(this);
   setHasMetadataHashEntry(false);
 }
 

 DISubprogram *Function::getSubprogram() const {
   return cast_or_null<DISubprogram>(getMetadata(LLVMContext::MD_dbg));
 }
+
+void GlobalVariable::setGlobalVarExprs(DIGlobalVarExprList L) {
+  setMetadata(LLVMContext::MD_dbg, L.get());
+}
+
+DIGlobalVarExprList GlobalVariable::getGlobalVarExprs() const {
+  return DIGlobalVarExprList(
+      cast_or_null<MDTuple>(getMetadata(LLVMContext::MD_dbg)));
+}

test/Assembler/diglobalvariable.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
-@foo = global i32 0
+@foo = global i32 0, !dbg !10
 
 ; CHECK: !named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9}
 !named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9}

 
 ; CHECK: !9 = !DIGlobalVariable(name: "mem", scope: !0, isLocal: false, isDefinition: true, declaration: !8)
 !9 = !DIGlobalVariable(name: "mem", scope: !0, declaration: !8)
+!10 = distinct !{!6, null}