Add a unit field to DIGlobalVariable, mirroring the design of DISubprogram.

[aprantl]

Summary

This has been suggested as an incremental follow-up to https://reviews.llvm.org/D26769.

Adding a unit field to DIGlobalVariable makes the design consistent with the design of DISubprogram
(DISubprogram definitions that are attached to Functions also have a unit field).
It also allows us to more efficiently process global variables in the DWARF backend.

After this patch, global variables occur in three forms in the debug info metadata:

1. Variable definitions are reachable via a !dbg attachment on a global that points to a DIGlobalVariableExpression which points to a distinct DIGlobalVariable (and an optional DIExpression) with a unit field pointing to the variable's DICompileUnit.

2. Constant definitions are reachable via the DICompileUnit's list of globals which points to a DIGlobalVariableExpression with a DIGlobalVariable without a unit field and a DIExpression describing a constant value.

3. Declarations are DIGlobalVariables without a unit field that are only reachable via a DIImportedEntity and have isDefinition set to false.

[aprantl]

lib/Bitcode/Writer/BitcodeWriter.cpp

1697

Note that I accidentally overwrote my correct bitocde upgrade code with an older revision while separating this patch out of my WIP D26769 patch. Will post the correct code and a bitcode upgrade testcase here soon.

[aprantl]

Upload latest WIP.

[aprantl]

Rebased patch on trunk and fixed the remaining test cases. This is now good to review :-)

[dblaikie]

docs/SourceLevelDebugging.rst

452

Probably could omit the reference to linkonce_odr and let the rest of the definition stand.

That way if anything were to duplicate other globals (eg: thinlto might import globals, etc) they could/would use this functionality as well, potentially.

456–458

Is this true? Do we go and change the DIGlobalVariable if we collapse an llvm::GlobalValue into a constant? So that it doesn't have a unit field anymore? I assume we don't do that, so some constants might point to DIGlobalVariables with a non-null unit field.

460–461

Is this correct? If all DIGlobalVariables referenced by DIImportedEntities can have no unit field (& thus be emitted into any unit that references them) - should any DIGlobalVariables have unit fields?

[aprantl]

docs/SourceLevelDebugging.rst

452

If the compile unit the global variable gets emitted into doesn't matter (such as a linkonce_odr symbol), ...

456–458

Good catch, I should implement this.

460–461

We added the unit field to DIGlobalVariables definitions (hanging off a global's !dbg attachment) so we can efficiently determine where to emit it. It's not strictly necessary, but it mirrors the DISubprogram design.

A pure declaration doesn't need one (and having one would prevent uniquing the DIImportedEntity) because it will be emitted as a locationless declaration in the CU it is being imported into (which should always be a correct one).

[aprantl]

Rebased on trunk and marked outstanding review comments as done.

[dblaikie]

docs/SourceLevelDebugging.rst

456–458

Does this happen now? Where should I look for the code and test case?

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

510–515

This is a rather deeply nested data structure and I'm not sure the type aliases do enough to help improve readability. I wonder if it'd be worth writing a small class with named functions, some structs (rather than several std::pairs), etc. At least some more detailed commentary about the structure and invariants of this data structure. (eg: I'm a bit confused by how the contents of the GVMapType and WorklistType relate, or don't)

For example the GVMapType and WorklistType probably deserve a type rather than only std::pair - since insertIntoWorklist uses both seems they're sort of connected-ish.

513

Not sure if this is the best terminology here. At least my thought when I see "worklist" is an algorithm that starts with a list of things to process and the act of processing those things can add new things to the worklist. That doesn't seem to be the case here

547

Would be marginally more efficient not to add an element to UnitGVs that will never be used/retrieved/queried. Maybe not worth the added verbosity, though.

554

llvm::none_of?

555

I'd generally suggest using [&] rather than explicit captures if the lambda doesn't outlive its scope.

[dexonsmith]

Getting this off my queue since dblaikie is already providing feedback.

docs/SourceLevelDebugging.rst

.. code-block:: text
   ;;
   !llvm.dbg.cu = !{!1}
 
   ;; Some unrelated metadata.
   !llvm.module.flags = !{!6, !7}
   !llvm.ident = !{!8}
 
   ;; Define the global variable itself
-  !0 = distinct !DIGlobalVariable(name: "MyGlobal", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true, align: 64)
+  !0 = !DIGlobalVariableExpression(var: !1)
+  !1 = distinct !DIGlobalVariable(name: "MyGlobal", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true, align: 64, unit: !2)
 
   ;; Define the compile unit.
-  !1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2,
+  !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3,
                                producer: "clang version 4.0.0 (http://llvm.org/git/clang.git ae4deadbea242e8ea517eef662c30443f75bd086) (http://llvm.org/git/llvm.git 818b4c1539df3e51dc7e62c89ead4abfd348827d)",
-                               isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug,
-                               enums: !3, globals: !4)
+                               isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug)
 
   ;;
   ;; Define the file
   ;;
-  !2 = !DIFile(filename: "/dev/stdin",
+  !3 = !DIFile(filename: "/dev/stdin",
                directory: "/Users/dexonsmith/data/llvm/debug-info")
 
-  ;; An empty array.
-  !3 = !{}
-
   ;; The Array of Global Variables
   !4 = !{!0}
 
   ;;
   ;; Define the type
   ;;
   !5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 
   ;; Dwarf version to output.
   !6 = !{i32 2, !"Dwarf Version", i32 4}
 
   ;; Debug info schema version.
   !7 = !{i32 2, !"Debug Info Version", i32 3}
 
   ;; Compiler identification
   !8 = !{!"clang version 4.0.0 (http://llvm.org/git/clang.git ae4deadbea242e8ea517eef662c30443f75bd086) (http://llvm.org/git/llvm.git 818b4c1539df3e51dc7e62c89ead4abfd348827d)"}
 
 
 The align value in DIGlobalVariable description specifies variable alignment in
 case it was forced by C11 _Alignas(), C++11 alignas() keywords or compiler
 attribute __attribute__((aligned ())). In other case (when this field is missing)
 alignment is considered default. This is used when producing DWARF output
 for DW_AT_alignment value.
 
+Global variables occur in three forms in the debug info metadata:
+1. *Variable definitions* are reachable via a !dbg attachment on a global that
+   points to a DIGlobalVariableExpression which typically points to a distinct
+   DIGlobalVariable (and an optional DIExpression) with a unit field pointing to
+   the variable's DICompileUnit.  If the compile unit the global variable gets
+   emitted into doesn't matter (e.g., for linkonce_odr symbols), the
+   DIGlobalVariable may instead be unique (i.e., not distinct) and not have a
+   unit field.
+
+2. *Constant definitions* are reachable via the DICompileUnit's list of globals
+   which points to a DIGlobalVariableExpression with a DIGlobalVariable without
+   a unit field and a DIExpression describing a constant value.
+
+3. *Declarations* are DIGlobalVariables without a unit field that are only
+   reachable via a DIImportedEntity and have isDefinition set to false.
+
 C/C++ function information
 --------------------------
 
 Given a function declared as follows:
 
 .. code-block:: c
 
   int main(int argc, char *argv[]) {

include/llvm/IR/DIBuilder.h

public:
     /// \param File        File where this variable is defined.
     /// \param LineNo      Line number.
     /// \param Ty          Variable Type.
     /// \param isLocalToUnit Boolean flag indicate whether this variable is
     ///                      externally visible or not.
     /// \param Expr        The location of the global relative to the attached
     ///                    GlobalVariable.
     /// \param Decl        Reference to the corresponding declaration.
-    /// \param AlignInBits Variable alignment(or 0 if no alignment attr was
-    ///                    specified)
+    /// \param AlignInBits Variable alignment (or 0 if no alignment attr was
+    ///                    specified).
+    /// \param Shared      This will create a unique node that is not
+    ///                    associated with a specific \a DICompileUnit and is
+    ///                    intended to be used with linkonce_odr globals.
     DIGlobalVariableExpression *createGlobalVariableExpression(
         DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
         unsigned LineNo, DIType *Ty, bool isLocalToUnit,
         DIExpression *Expr = nullptr, MDNode *Decl = nullptr,
-        uint32_t AlignInBits = 0);
+        uint32_t AlignInBits = 0, bool Shared = false);
 
     /// Identical to createGlobalVariable
     /// except that the resulting DbgNode is temporary and meant to be RAUWed.
     DIGlobalVariable *createTempGlobalVariableFwdDecl(
         DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
         unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr,
         uint32_t AlignInBits = 0);
 

include/llvm/IR/DebugInfoMetadata.h

class DIGlobalVariable : public DIVariable {
 
   DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line,
                    bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits,
                    ArrayRef<Metadata *> Ops)
       : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits),
         IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {}
   ~DIGlobalVariable() = default;
 
-  static DIGlobalVariable *getImpl(LLVMContext &Context, DIScope *Scope,
-                                   StringRef Name, StringRef LinkageName,
-                                   DIFile *File, unsigned Line, DITypeRef Type,
-                                   bool IsLocalToUnit, bool IsDefinition,
-                                   DIDerivedType *StaticDataMemberDeclaration,
-                                   uint32_t AlignInBits, StorageType Storage,
-                                   bool ShouldCreate = true) {
+  static DIGlobalVariable *
+  getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
+          StringRef LinkageName, DIFile *File, unsigned Line, DITypeRef Type,
+          DIDerivedType *StaticDataMemberDeclaration, uint32_t AlignInBits,
+          DICompileUnit *Unit, StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
                    IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
-                   AlignInBits, Storage, ShouldCreate);
+                   AlignInBits, Unit, Storage, ShouldCreate);
   }
   static DIGlobalVariable *
   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
           bool IsLocalToUnit, bool IsDefinition,
           Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits,
-          StorageType Storage, bool ShouldCreate = true);
+          Metadata *Unit, StorageType Storage, bool ShouldCreate = true);
 
   TempDIGlobalVariable cloneImpl() const {
     return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
                         getFile(), getLine(), getType(), isLocalToUnit(),
                         isDefinition(), getStaticDataMemberDeclaration(),
-                        getAlignInBits());
+                        getAlignInBits(), getUnit());
   }
 
 public:
   DEFINE_MDNODE_GET(DIGlobalVariable,
-                    (DIScope * Scope, StringRef Name, StringRef LinkageName,
+                    (DIScope *Scope, StringRef Name, StringRef LinkageName,
                      DIFile *File, unsigned Line, DITypeRef Type,
                      bool IsLocalToUnit, bool IsDefinition,
                      DIDerivedType *StaticDataMemberDeclaration,
-                     uint32_t AlignInBits),
+                     uint32_t AlignInBits, DICompileUnit *Unit),
                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
-                     IsDefinition, StaticDataMemberDeclaration, AlignInBits))
+                     IsDefinition, StaticDataMemberDeclaration, AlignInBits,
+                     Unit))
   DEFINE_MDNODE_GET(DIGlobalVariable,
-                    (Metadata * Scope, MDString *Name, MDString *LinkageName,
+                    (Metadata *Scope, MDString *Name, MDString *LinkageName,
                      Metadata *File, unsigned Line, Metadata *Type,
                      bool IsLocalToUnit, bool IsDefinition,
                      Metadata *StaticDataMemberDeclaration,
-                     uint32_t AlignInBits),
+                     uint32_t AlignInBits, Metadata *Unit),
                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
-                     IsDefinition, StaticDataMemberDeclaration, AlignInBits))
+                     IsDefinition, StaticDataMemberDeclaration, AlignInBits,
+                     Unit))
 
   TempDIGlobalVariable clone() const { return cloneImpl(); }
 
   bool isLocalToUnit() const { return IsLocalToUnit; }
   bool isDefinition() const { return IsDefinition; }
   StringRef getDisplayName() const { return getStringOperand(4); }
   StringRef getLinkageName() const { return getStringOperand(5); }
   DIDerivedType *getStaticDataMemberDeclaration() const {
     return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
   }
+  DICompileUnit *getUnit() const {
+    return cast_or_null<DICompileUnit>(getRawUnit());
+  }
 
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
   Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
+  Metadata *getRawUnit() const { return getOperand(7); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIGlobalVariableKind;
   }
 };
 
 /// Local variable.
 ///

lib/AsmParser/LLParser.cpp

#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(scope, MDField, );                                                  \
   OPTIONAL(linkageName, MDStringField, );                                      \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
   OPTIONAL(type, MDField, );                                                   \
   OPTIONAL(isLocal, MDBoolField, );                                            \
   OPTIONAL(isDefinition, MDBoolField, (true));                                 \
   OPTIONAL(declaration, MDField, );                                            \
-  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));
+  OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX));                           \
+  OPTIONAL(unit, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result = GET_OR_DISTINCT(DIGlobalVariable,
-                           (Context, scope.Val, name.Val, linkageName.Val,
-                            file.Val, line.Val, type.Val, isLocal.Val,
-                            isDefinition.Val, declaration.Val, align.Val));
+  Result =
+      GET_OR_DISTINCT(DIGlobalVariable,
+                      (Context, scope.Val, name.Val, linkageName.Val, file.Val,
+                       line.Val, type.Val, isLocal.Val, isDefinition.Val,
+                       declaration.Val, align.Val, unit.Val));
   return false;
 }
 
 /// ParseDILocalVariable:
 ///   ::= !DILocalVariable(arg: 7, scope: !0, name: "foo",
 ///                        file: !1, line: 7, type: !2, arg: 2, flags: 7,
 ///                        align: 8)
 ///   ::= !DILocalVariable(scope: !0, name: "foo",

lib/Bitcode/Reader/MetadataLoader.cpp

class MetadataLoader::MetadataLoaderImpl {
   SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
 
   // Map the bitcode's custom MDKind ID to the Module's MDKind ID.
   DenseMap<unsigned, unsigned> MDKindMap;
 
   bool StripTBAA = false;
   bool HasSeenOldLoopTags = false;
   bool NeedUpgradeToDIGlobalVariableExpression = false;
+  /// Are there DIGLobalVariables without a unit field that must be upgraded?
+  bool DIGlobalVariablesWithoutUnits = false;
 
   /// True if metadata is being parsed for a module being ThinLTO imported.
   bool IsImporting = false;
 
   Error parseOneMetadata(SmallVectorImpl<uint64_t> &Record, unsigned Code,
                          PlaceholderQueue &Placeholders, StringRef Blob,
                          unsigned &NextMetadataNo);
   Error parseMetadataStrings(ArrayRef<uint64_t> Record, StringRef Blob,
for (auto &GV : TheModule.globals()) {
           auto *DGVE =
               DIGlobalVariableExpression::getDistinct(Context, DGV, nullptr);
           GV.addMetadata(LLVMContext::MD_dbg, *DGVE);
         } else
           GV.addMetadata(LLVMContext::MD_dbg, *MD);
     }
   }
 
+  /// Upgrade global variables without units.
+  void upgradeVariablesWithoutUnits() {
+    if (!DIGlobalVariablesWithoutUnits)
+      return;
+    if (auto *CUs = TheModule.getNamedMetadata("llvm.dbg.cu"))
+      for (auto *N : CUs->operands())
+        if (auto *CU = dyn_cast_or_null<DICompileUnit>(N))
+          if (auto *GVEs =
+                  dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
+            for (auto &N1 : GVEs->operands())
+              if (auto *GVE = dyn_cast_or_null<DIGlobalVariableExpression>(N1))
+                if (auto *GV = GVE->getVariable())
+                  if (GV->isDefinition())
+                    GV->replaceOperandWith(7, CU);
+  }
+
   void upgradeDebugInfo() {
     upgradeCUSubprograms();
     upgradeCUVariables();
+    upgradeVariablesWithoutUnits();
   }
 
 public:
   MetadataLoaderImpl(BitstreamCursor &Stream, Module &TheModule,
                      BitcodeReaderValueList &ValueList,
                      std::function<Type *(unsigned)> getTypeByID,
                      bool IsImporting)
       : MetadataList(TheModule.getContext()), ValueList(ValueList),
#define GET_OR_DISTINCT(CLASS, ARGS)                                           \
   }
   case bitc::METADATA_GLOBAL_VAR: {
     if (Record.size() < 11 || Record.size() > 12)
       return error("Invalid record");
 
     IsDistinct = Record[0] & 1;
     unsigned Version = Record[0] >> 1;
 
-    if (Version == 1) {
+    if (Version == 2) {
+      MetadataList.assignValue(
+          GET_OR_DISTINCT(
+              DIGlobalVariable,
+              (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
+               getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
+               getDITypeRefOrNull(Record[6]), Record[7], Record[8],
+               getMDOrNull(Record[9]), Record[10], getMDOrNull(Record[11]))),
+          NextMetadataNo);
+      NextMetadataNo++;
+    } else if (Version == 1) {
+      DIGlobalVariablesWithoutUnits = true;
       MetadataList.assignValue(
           GET_OR_DISTINCT(DIGlobalVariable,
                           (Context, getMDOrNull(Record[1]),
                            getMDString(Record[2]), getMDString(Record[3]),
                            getMDOrNull(Record[4]), Record[5],
                            getDITypeRefOrNull(Record[6]), Record[7], Record[8],
-                           getMDOrNull(Record[10]), Record[11])),
+                           nullptr, Record[10], getMDOrNull(Record[11]))),
           NextMetadataNo);
       NextMetadataNo++;
     } else if (Version == 0) {
       // Upgrade old metadata, which stored a global variable reference or a
       // ConstantInt here.
+      DIGlobalVariablesWithoutUnits = true;
       NeedUpgradeToDIGlobalVariableExpression = true;
       Metadata *Expr = getMDOrNull(Record[9]);
       uint32_t AlignInBits = 0;
       if (Record.size() > 11) {
         if (Record[11] > (uint64_t)std::numeric_limits<uint32_t>::max())
           return error("Alignment value is too large");
         AlignInBits = Record[11];
       }
if (Version == 2) {
           Expr = nullptr;
         }
       }
       DIGlobalVariable *DGV = GET_OR_DISTINCT(
           DIGlobalVariable,
           (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
            getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
            getDITypeRefOrNull(Record[6]), Record[7], Record[8],
-           getMDOrNull(Record[10]), AlignInBits));
+          getMDOrNull(Record[10]), AlignInBits, nullptr));
 
       DIGlobalVariableExpression *DGVE = nullptr;
       if (Attach || Expr)
         DGVE = DIGlobalVariableExpression::getDistinct(Context, DGV, Expr);
       if (Attach)
         Attach->addDebugInfo(DGVE);
 
       auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDITemplateValueParameter(
 
   Stream.EmitRecord(bitc::METADATA_TEMPLATE_VALUE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIGlobalVariable(
     const DIGlobalVariable *N, SmallVectorImpl<uint64_t> &Record,
     unsigned Abbrev) {
-  const uint64_t Version = 1 << 1;
-  Record.push_back((uint64_t)N->isDistinct() | Version);
+  const uint64_t Version = 2;
+  Record.push_back((uint64_t)N->isDistinct() | (Version << 1));
   Record.push_back(VE.getMetadataOrNullID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawLinkageName()));
   Record.push_back(VE.getMetadataOrNullID(N->getFile()));
   Record.push_back(N->getLine());
   Record.push_back(VE.getMetadataOrNullID(N->getType()));
   Record.push_back(N->isLocalToUnit());
   Record.push_back(N->isDefinition());
-  Record.push_back(/* expr */ 0);
   Record.push_back(VE.getMetadataOrNullID(N->getStaticDataMemberDeclaration()));
   Record.push_back(N->getAlignInBits());
+  Record.push_back(VE.getMetadataOrNullID(N->getUnit()));
 
   Stream.EmitRecord(bitc::METADATA_GLOBAL_VAR, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDILocalVariable(
     const DILocalVariable *N, SmallVectorImpl<uint64_t> &Record,
     unsigned Abbrev) {

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

std::sort(GVEs.begin(), GVEs.end(),
               if (A.Expr != B.Expr && A.Expr && B.Expr) {
     auto FragmentA = A.Expr->getFragmentInfo();
     auto FragmentB = B.Expr->getFragmentInfo();
     if (FragmentA && FragmentB)
       return FragmentA->OffsetInBits < FragmentB->OffsetInBits;
         }
               return false;
             });
-  GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
-                         [](DwarfCompileUnit::GlobalExpr A,
-                            DwarfCompileUnit::GlobalExpr B) {
-                           return A.Expr == B.Expr;
-                         }),
-             GVEs.end());
   return GVEs;
 }
 
 // Emit all Dwarf sections that should come prior to the content. Create
 // global DIEs and emit initial debug info sections. This is invoked by
 // the target AsmPrinter.
 void DwarfDebug::beginModule() {
   NamedRegionTimer T(DbgTimerName, DbgTimerDescription, DWARFGroupName,
                      DWARFGroupDescription, TimePassesIsEnabled);
   if (DisableDebugInfoPrinting)
     return;
 
   const Module *M = MMI->getModule();
 
   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
                                        M->debug_compile_units_end());
   // Tell MMI whether we have debug info.
   MMI->setDebugInfoAvailability(NumDebugCUs > 0);
   SingleCU = NumDebugCUs == 1;
-  DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
-      GVMap;
+  // Collect DIGlobalVariables reachable via global variable !dbg attachments.
+  // For each CU we keep a worklist to preserve the globals' relative order.
+  using GlobalExpr = DwarfCompileUnit::GlobalExpr;
+  using ExprListType = SmallVector<GlobalExpr, 1>;
+  using GVMapType = DenseMap<DIGlobalVariable *, std::unique_ptr<ExprListType>>;
+  using WorklistType =
+      std::vector<std::pair<DIGlobalVariable *, ExprListType *>>;
+  DenseMap<DICompileUnit *, std::pair<GVMapType, WorklistType>> UnitGVs;
+
+  // Insert Var into GVMap and add a worklist entry if none exists.
+  auto insertIntoWorklist = [](GVMapType &GVMap, WorklistType &Worklist,
+                               DIGlobalVariable *Var) -> ExprListType & {
+    auto EntrySuccess = GVMap.insert({Var, llvm::make_unique<ExprListType>()});
+    auto Entry = EntrySuccess.first;
+    ExprListType &Exprs = *Entry->second;
+    if (EntrySuccess.second)
+      Worklist.push_back({Var, &Exprs});
+    return Exprs;
+  };
+
   for (const GlobalVariable &Global : M->globals()) {
     SmallVector<DIGlobalVariableExpression *, 1> GVs;
     Global.getDebugInfo(GVs);
-    for (auto *GVE : GVs)
-      GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
+    for (auto *GVE : GVs) {
+      auto *Var = GVE->getVariable();
+      auto &GVMapWorklist = UnitGVs[Var->getUnit()];
+      GVMapType &GVMap = GVMapWorklist.first;
+      WorklistType &Worklist = GVMapWorklist.second;
+      ExprListType &Exprs = insertIntoWorklist(GVMap, Worklist, Var);
+      Exprs.push_back({&Global, GVE->getExpression()});
+    }
   }
 
   for (DICompileUnit *CUNode : M->debug_compile_units()) {
     DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
     for (auto *IE : CUNode->getImportedEntities())
       CU.addImportedEntity(IE);
 
-    // Global Variables.
-    for (auto *GVE : CUNode->getGlobalVariables())
-      GVMap[GVE->getVariable()].push_back({nullptr, GVE->getExpression()});
-    DenseSet<DIGlobalVariable *> Processed;
+    // Collect DIGlobalVariables reachable via the DICompileUnit.
+    auto &GVMapWorklist = UnitGVs[CUNode];
+    GVMapType &GVMap = GVMapWorklist.first;
+    WorklistType &Worklist = GVMapWorklist.second;
      for (auto *GVE : CUNode->getGlobalVariables()) {
-      DIGlobalVariable *GV = GVE->getVariable();
-      if (Processed.insert(GV).second)
-        CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
+      auto *Var = GVE->getVariable();
+      auto *Expr = GVE->getExpression();
+      ExprListType &Exprs = insertIntoWorklist(GVMap, Worklist, Var);
+      if (std::none_of(Exprs.begin(), Exprs.end(),
+                       [&Expr](GlobalExpr &GE) { return GE.Expr == Expr; }))
+        Exprs.push_back({nullptr, Expr});
+    }
+
+    // Emit all DIGlobalVariables belonging to the current CU.
+    for (auto &GVEntry : Worklist) {
+      DIGlobalVariable *GV = GVEntry.first;
+      ExprListType &Exprs = *GVEntry.second;
+      CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(Exprs));
     }
 
     for (auto *Ty : CUNode->getEnumTypes()) {
       // The enum types array by design contains pointers to
       // MDNodes rather than DIRefs. Unique them here.
       CU.getOrCreateTypeDIE(cast<DIType>(Ty));
     }
     for (auto *Ty : CUNode->getRetainedTypes()) {

lib/IR/AsmWriter.cpp

static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printMetadata("file", N->getRawFile());
   Printer.printInt("line", N->getLine());
   Printer.printMetadata("type", N->getRawType());
   Printer.printBool("isLocal", N->isLocalToUnit());
   Printer.printBool("isDefinition", N->isDefinition());
   Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
   Printer.printInt("align", N->getAlignInBits());
+  Printer.printMetadata("unit", N->getUnit());
   Out << ")";
 }
 
 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
                                  TypePrinting *TypePrinter,
                                  SlotTracker *Machine, const Module *Context) {
   Out << "!DILocalVariable(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

lib/IR/DIBuilder.cpp

 #ifndef NDEBUG
   if (auto *CT =
           dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context)))
     assert(CT->getIdentifier().empty() &&
            "Context of a global variable should not be a type with identifier");
 #endif
 }
 
+template <class... Ts>
+static DIGlobalVariable *getGlobalVariable(bool IsDistinct, Ts &&... Args) {
+  if (IsDistinct)
+    return DIGlobalVariable::getDistinct(std::forward<Ts>(Args)...);
+  return DIGlobalVariable::get(std::forward<Ts>(Args)...);
+}
+
 DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool isLocalToUnit, DIExpression *Expr,
-    MDNode *Decl, uint32_t AlignInBits) {
+    MDNode *Decl, uint32_t AlignInBits, bool Shared) {
   checkGlobalVariableScope(Context);
 
-  auto *GV = DIGlobalVariable::getDistinct(
-      VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
+  bool Distinct = !Shared;
+  auto *GV = getGlobalVariable(
+      Distinct, VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
       LineNumber, Ty, isLocalToUnit, true, cast_or_null<DIDerivedType>(Decl),
-      AlignInBits);
+      AlignInBits, Distinct ? CUNode : nullptr);
   auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr);
   AllGVs.push_back(N);
   return N;
 }
 
 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool isLocalToUnit, MDNode *Decl,
     uint32_t AlignInBits) {
   checkGlobalVariableScope(Context);
 
   return DIGlobalVariable::getTemporary(
              VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
              LineNumber, Ty, isLocalToUnit, false,
-             cast_or_null<DIDerivedType>(Decl), AlignInBits)
+             cast_or_null<DIDerivedType>(Decl), AlignInBits, nullptr)
       .release();
 }
 
 static DILocalVariable *createLocalVariable(
     LLVMContext &VMContext,
     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags,

lib/IR/DebugInfoMetadata.cpp

DITemplateValueParameter *DITemplateValueParameter::getImpl(
   DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops);
 }
 
 DIGlobalVariable *
 DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
                           MDString *LinkageName, Metadata *File, unsigned Line,
                           Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
                           Metadata *StaticDataMemberDeclaration,
-                          uint32_t AlignInBits, StorageType Storage,
-                          bool ShouldCreate) {
+                          uint32_t AlignInBits, Metadata *Unit,
+                          StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   assert(isCanonical(LinkageName) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIGlobalVariable,
                         (Scope, Name, LinkageName, File, Line, Type,
                          IsLocalToUnit, IsDefinition,
-                         StaticDataMemberDeclaration, AlignInBits));
+                         StaticDataMemberDeclaration, AlignInBits, Unit));
   Metadata *Ops[] = {
-      Scope, Name, File, Type, Name, LinkageName, StaticDataMemberDeclaration};
+      Scope, Name, File, Type, Name, LinkageName, StaticDataMemberDeclaration,
+      Unit};
   DEFINE_GETIMPL_STORE(DIGlobalVariable,
                        (Line, IsLocalToUnit, IsDefinition, AlignInBits),
                        Ops);
 }
 
 DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
                                           MDString *Name, Metadata *File,
                                           unsigned Line, Metadata *Type,

lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
   unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
 };
 
 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
   Metadata *Scope;
   MDString *Name;
   MDString *LinkageName;
   Metadata *File;
-  unsigned Line;
   Metadata *Type;
+  Metadata *StaticDataMemberDeclaration;
+  Metadata *Unit;
+  unsigned Line;
   bool IsLocalToUnit;
   bool IsDefinition;
-  Metadata *StaticDataMemberDeclaration;
   uint32_t AlignInBits;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
                 Metadata *File, unsigned Line, Metadata *Type,
                 bool IsLocalToUnit, bool IsDefinition,
-                Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits)
+                Metadata *StaticDataMemberDeclaration, uint32_t AlignInBits,
+                Metadata *Unit)
       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
-        Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
-        IsDefinition(IsDefinition),
-        StaticDataMemberDeclaration(StaticDataMemberDeclaration),
-        AlignInBits(AlignInBits) {}
+        Type(Type), StaticDataMemberDeclaration(StaticDataMemberDeclaration),
+        Unit(Unit), Line(Line), IsLocalToUnit(IsLocalToUnit),
+        IsDefinition(IsDefinition), AlignInBits(AlignInBits) {}
   MDNodeKeyImpl(const DIGlobalVariable *N)
       : Scope(N->getRawScope()), Name(N->getRawName()),
         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
-        Line(N->getLine()), Type(N->getRawType()),
-        IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
+        Type(N->getRawType()),
         StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
+        Unit(N->getRawUnit()), Line(N->getLine()),
+        IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
         AlignInBits(N->getAlignInBits()) {}
 
   bool isKeyOf(const DIGlobalVariable *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            LinkageName == RHS->getRawLinkageName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&
            Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
            IsDefinition == RHS->isDefinition() &&
            StaticDataMemberDeclaration ==
                RHS->getRawStaticDataMemberDeclaration() &&
-           AlignInBits == RHS->getAlignInBits();
+           AlignInBits == RHS->getAlignInBits() && Unit == RHS->getRawUnit();
   }
   unsigned getHashValue() const {
     // We do not use AlignInBits in hashing function here on purpose:
     // in most cases this param for local variable is zero (for function param
     // it is always zero). This leads to lots of hash collisions and errors on
     // cases with lots of similar variables.
     // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
     // generated IR is random for each run and test fails with Align included.

lib/IR/Verifier.cpp

Assert(!GV.hasDLLImportStorageClass() ||
              (GV.isDeclaration() && GV.hasExternalLinkage()) ||
              GV.hasAvailableExternallyLinkage(),
          "Global is marked as dllimport, but not external", &GV);
 
   // Visit any debug info attachments.
   SmallVector<MDNode *, 1> MDs;
   GV.getMetadata(LLVMContext::MD_dbg, MDs);
   for (auto *MD : MDs) {
-    if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD))
-      visitDIGlobalVariableExpression(*GVE);
-    else
+    if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(MD)) {
+      AssertDI(GVE->getVariable(), "missing DIGlobalVariable");
+      if (auto *GV = GVE->getVariable()) {
+        if (GV->isDistinct())
+          AssertDI(GV->getUnit(), "missing unit field");
+        else 
+          AssertDI(!GV->getUnit(), "unique variable with a unit field");
+      }
+      visitDIGlobalVariableExpression(*GVE);
+    } else
       AssertDI(false, "!dbg attachment of global variable must be a "
                       "DIGlobalVariableExpression");
   }
 
   if (!GV.hasInitializer()) {
     visitGlobalValue(GV);
     return;
   }
 
   // Walk any aggregate initializers looking for bitcasts between address spaces
+  if (GV.hasInitializer())
     visitConstantExprsRecursively(GV.getInitializer());
 
   visitGlobalValue(GV);
 }
 
 void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
   SmallPtrSet<const GlobalAlias*, 4> Visited;
   Visited.insert(&GA);
   visitAliaseeSubExpr(Visited, GA, C);
for (Metadata *Op : N.getRetainedTypes()->operands()) {
                       (isa<DISubprogram>(Op) &&
                        !cast<DISubprogram>(Op)->isDefinition())),
                "invalid retained type", &N, Op);
     }
   }
   if (auto *Array = N.getRawGlobalVariables()) {
     AssertDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
     for (Metadata *Op : N.getGlobalVariables()->operands()) {
-      AssertDI(Op && (isa<DIGlobalVariableExpression>(Op)),
-               "invalid global variable ref", &N, Op);
+      if (auto *GVE = dyn_cast_or_null<DIGlobalVariableExpression>(Op))
+        visitDIGlobalVariableExpression(*GVE);
+      else
+        AssertDI(false, "invalid global variable ref", &N, Op);
     }
   }
   if (auto *Array = N.getRawImportedEntities()) {
     AssertDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
     for (Metadata *Op : N.getImportedEntities()->operands()) {
       AssertDI(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref",
                &N, Op);
     }

test/Bitcode/DIGlobalVariable-unit.ll

+; RUN: llvm-dis -o - %s.bc | FileCheck %s
+@g = common global i32 0, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!9, !10, !11}
+!llvm.ident = !{!12}
+
+!0 = !DIGlobalVariableExpression(var: !1)
+; CHECK: distinct !DIGlobalVariable(name: "g", {{.*}}, unit: ![[CU:[0-9]+]])
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
+; CHECK: ![[CU]] = distinct !DICompileUnit
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, imports: !5)
+!3 = !DIFile(filename: "t.c", directory: "/")
+!4 = !{!0}
+!5 = !{!6}
+!6 = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "h", scope: !2, entity: !7, line: 1)
+; CHECK: distinct !DIGlobalVariable(name: "h", {{.*}}, isDefinition: false)
+!7 = distinct !DIGlobalVariable(name: "h", scope: !2, file: !3, line: 3, type: !8, isLocal: false, isDefinition: false)
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = !{i32 2, !"Dwarf Version", i32 4}
+!10 = !{i32 2, !"Debug Info Version", i32 3}
+!11 = !{i32 1, !"PIC Level", i32 2}
+!12 = !{!"clang version 4.0.0 (trunk 290265)"}

test/Bitcode/diglobalvariable-3.8.ll

 ; RUN: llvm-dis -o - %s.bc | FileCheck %s
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8}
 
 ; CHECK: !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.1", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.1", isOptimized: true, runtimeVersion: 0, emissionKind: 1, enums: !2, globals: !3)
 !1 = !DIFile(filename: "g.c", directory: "/")
 !2 = !{}
 ; CHECK: !3 = !{!4}
 !3 = !{!4}
 ; CHECK: !4 = {{.*}}!DIGlobalVariableExpression(var: !5, expr: !8)
-; CHECK: !5 = !DIGlobalVariable(name: "c", scope: !0, file: !1, line: 1, type: !6, isLocal: false, isDefinition: true)
+; CHECK: !5 = !DIGlobalVariable(name: "c", scope: !0, file: !1, line: 1, type: !6, isLocal: false, isDefinition: true, unit: !0)
 ; CHECK: !8 = !DIExpression(DW_OP_constu, 42, DW_OP_stack_value)
 !4 = !DIGlobalVariable(name: "c", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, variable: i32 42)
 !5 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !6)
 !6 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !7 = !{i32 2, !"Dwarf Version", i32 2}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 

test/CodeGen/ARM/2011-01-19-MergedGlobalDbg.ll

 ; 0x03 DW_OP_addr
 ; 0x.. .long __MergedGlobals
 ; 0x10 DW_OP_constu
 ; 0x.. offset
 ; 0x22 DW_OP_plus
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
+; CHECK:    DW_AT_name {{.*}} "x5"
+; CHECK: DW_TAG_variable
+; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}} "x1"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:    DW_AT_location [DW_FORM_exprloc]        (<0x5> 03 [[ADDR:.. .. .. ..]]   )
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK:    DW_AT_name {{.*}} "x2"
 ; CHECK-NOT: {{DW_TAG|NULL}}
 ; CHECK:    DW_AT_location [DW_FORM_exprloc]        (<0x7> 03 [[ADDR]] 23 01  )

 
 attributes #0 = { nounwind optsize }
 attributes #1 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!12}
 !llvm.module.flags = !{!15}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "x1", scope: !2, file: !2, line: 3, type: !3, isLocal: true, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "x1", scope: !2, file: !2, line: 3, type: !3, isLocal: true, isDefinition: true, unit: !12)
 !2 = !DIFile(filename: "foo.c", directory: "/tmp/")
 !3 = !DIBasicType(name: "_Bool", size: 8, align: 8, encoding: DW_ATE_boolean)
 !4 = !DIGlobalVariableExpression(var: !5)
-!5 = !DIGlobalVariable(name: "x2", scope: !2, file: !2, line: 6, type: !3, isLocal: true, isDefinition: true)
+!5 = distinct !DIGlobalVariable(name: "x2", scope: !2, file: !2, line: 6, type: !3, isLocal: true, isDefinition: true, unit: !12)
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = !DIGlobalVariable(name: "x3", scope: !2, file: !2, line: 9, type: !3, isLocal: true, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "x3", scope: !2, file: !2, line: 9, type: !3, isLocal: true, isDefinition: true, unit: !12)
 !8 = !DIGlobalVariableExpression(var: !9)
-!9 = !DIGlobalVariable(name: "x4", scope: !2, file: !2, line: 12, type: !3, isLocal: true, isDefinition: true)
+!9 = distinct !DIGlobalVariable(name: "x4", scope: !2, file: !2, line: 12, type: !3, isLocal: true, isDefinition: true, unit: !12)
 !10 = !DIGlobalVariableExpression(var: !11)
-!11 = !DIGlobalVariable(name: "x5", scope: !2, file: !2, line: 15, type: !3, isLocal: false, isDefinition: true)
+!11 = distinct !DIGlobalVariable(name: "x5", scope: !2, file: !2, line: 15, type: !3, isLocal: false, isDefinition: true, unit: !12)
 !12 = distinct !DICompileUnit(language: DW_LANG_C89, file: !2, producer: "4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2369.8)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !13, retainedTypes: !13, globals: !14, imports: !13)
 !13 = !{}
 !14 = !{!0, !4, !6, !8, !10}
 !15 = !{i32 1, !"Debug Info Version", i32 3}
 !16 = distinct !DISubprogram(name: "get1", linkageName: "get1", scope: !2, file: !2, line: 4, type: !17, isLocal: false, isDefinition: true, scopeLine: 4, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true, unit: !12, variables: !19)
 !17 = !DISubroutineType(types: !18)
 !18 = !{!3, !3}
 !19 = !{!20, !21}

test/CodeGen/ARM/2011-08-02-MergedGlobalDbg.ll

 
 attributes #0 = { nounwind optsize ssp }
 attributes #1 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!9}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "x1", scope: !2, file: !3, line: 4, type: !8, isLocal: true, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "x1", scope: !2, file: !3, line: 4, type: !8, isLocal: true, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !5, imports: !4)
 !3 = !DIFile(filename: "ss3.c", directory: "/private/tmp")
 !4 = !{}
 !5 = !{!0, !6}
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = !DIGlobalVariable(name: "x2", scope: !2, file: !3, line: 7, type: !8, isLocal: true, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "x2", scope: !2, file: !3, line: 7, type: !8, isLocal: true, isDefinition: true, unit: !2)
 !8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = !{i32 1, !"Debug Info Version", i32 3}
 !10 = distinct !DISubprogram(name: "get1", scope: !3, file: !3, line: 5, type: !11, isLocal: false, isDefinition: true, scopeLine: 5, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true, unit: !2, variables: !13)
 !11 = !DISubroutineType(types: !12)
 !12 = !{!8}
 !13 = !{!14, !15}
 !14 = !DILocalVariable(name: "a", arg: 1, scope: !10, file: !3, line: 5, type: !8)
 !15 = !DILocalVariable(name: "b", scope: !16, file: !3, line: 5, type: !8)

test/CodeGen/ARM/no-cfi.ll

 ; RUN: llc < %s | FileCheck %s
 ; RUN: llc -mtriple=arm-netbsd-eabi < %s | FileCheck %s
 ; CHECK-NOT: .cfi_startproc
 ; CHECK-NOT: .cfi_sections
 
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "armv4t--linux"
 
 @f = common global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!7, !8, !9, !10}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "f", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "f", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 4.0.0 (trunk 290216)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "test2.c", directory: "/tmp")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 !9 = !{i32 1, !"wchar_size", i32 4}
 !10 = !{i32 1, !"min_enum_size", i32 4}

test/CodeGen/X86/dwarf-headers.ll

 
 @s = global %struct.S zeroinitializer, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!10, !11}
 !llvm.ident = !{!12}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 5, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 5, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 295942)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "t.cpp", directory: "/home/probinson/projects/scratch")
 !4 = !{}
 !5 = !{!0}
 !6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !3, line: 1, size: 32, elements: !7, identifier: "_ZTS1S")
 !7 = !{!8}
 !8 = !DIDerivedType(tag: DW_TAG_member, name: "s1", scope: !6, file: !3, line: 2, baseType: !9, size: 32)
 !9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !10 = !{i32 2, !"Dwarf Version", i32 4}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
 !12 = !{!"clang version 5.0.0 (trunk 295942)"}

test/CodeGen/X86/machine-outliner-debuginfo.ll

 
 attributes #0 = { noredzone nounwind ssp uwtable "no-frame-pointer-elim"="true" }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!7, !8, !9}
 !llvm.ident = !{!10}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 2, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 2, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 5.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "debug-test.c", directory: "dir")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 !9 = !{i32 1, !"PIC Level", i32 2}

test/DebugInfo/AMDGPU/variable-locations-dwarf-v1.ll

 }
 
 !llvm.dbg.cu = !{!2}
 !opencl.ocl.version = !{!9}
 !llvm.module.flags = !{!10, !11}
 !llvm.ident = !{!12}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "GlobA", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "GlobA", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 5.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "variable-locations-dwarf-v1.cl", directory: "/some/random/directory")
 !4 = !{}
 !5 = !{!0, !6}
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = distinct !DIGlobalVariable(name: "GlobB", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "GlobB", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !9 = !{i32 2, i32 0}
 !10 = !{i32 2, !"Dwarf Version", i32 1}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
 !12 = !{!"clang version 5.0.0"}
 !13 = distinct !DISubprogram(name: "kernel1", scope: !3, file: !3, line: 4, type: !14, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
 !14 = !DISubroutineType(types: !15)
 !15 = !{null, !16, !17, !17}

test/DebugInfo/AMDGPU/variable-locations.ll

 }
 
 !llvm.dbg.cu = !{!2}
 !opencl.ocl.version = !{!9}
 !llvm.module.flags = !{!10, !11}
 !llvm.ident = !{!12}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "GlobA", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "GlobA", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 5.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "variable-locations.cl", directory: "/some/random/directory")
 !4 = !{}
 !5 = !{!0, !6}
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = distinct !DIGlobalVariable(name: "GlobB", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "GlobB", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !9 = !{i32 2, i32 0}
 !10 = !{i32 2, !"Dwarf Version", i32 2}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
 !12 = !{!"clang version 5.0.0"}
 !13 = distinct !DISubprogram(name: "kernel1", scope: !3, file: !3, line: 4, type: !14, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
 !14 = !DISubroutineType(types: !15)
 !15 = !{null, !16, !17, !17}

test/DebugInfo/ARM/tls.ll

 ; CHECK: .byte 12
 ; The debug relocation of the address of the tls variable
 ; CHECK: .long x(tlsldo)
 
 ; TODO: Add expected output for -emulated-tls tests.
 ; EMU-NOT: .long x(tlsldo)
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "x", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "x", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !4)
 !2 = !DIFile(filename: "tls.c", directory: "/tmp")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.5 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
 !6 = !{!0}
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 1, !"Debug Info Version", i32 3}
 !9 = !{!"clang version 3.5 "}
 

test/DebugInfo/Generic/accel-table-hash-collisions.ll

 @_ZNK5clang12OverrideAttr5cloneERNS_10ASTContextE = common global i32 0, align 4, !dbg !25
 @_ZN4llvm22MachineModuleInfoMachOD2Ev = common global i32 0, align 4, !dbg !27
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!29, !30, !31}
 !llvm.ident = !{!32}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "ForceTopDown", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "ForceTopDown", scope: !2, file: !3, line: 1, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 3.7.0 (trunk 231548) (llvm/trunk 231547)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !5, imports: !4)
 !3 = !DIFile(filename: "hash-collisions.c", directory: "/tmp")
 !4 = !{}
 !5 = !{!0, !6, !9, !11, !13, !15, !17, !19, !21, !23, !25, !27}
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = !DIGlobalVariable(name: "_ZNSt3__116allocator_traitsINS_9allocatorINS_11__tree_nodeINS_12__value_typeIPN4llvm10BasicBlockEPNS4_10RegionNodeEEEPvEEEEE11__constructIS9_JNS_4pairIS6_S8_EEEEEvNS_17integral_constantIbLb1EEERSC_PT_DpOT0_", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "_ZNSt3__116allocator_traitsINS_9allocatorINS_11__tree_nodeINS_12__value_typeIPN4llvm10BasicBlockEPNS4_10RegionNodeEEEPvEEEEE11__constructIS9_JNS_4pairIS6_S8_EEEEEvNS_17integral_constantIbLb1EEERSC_PT_DpOT0_", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = !DIGlobalVariableExpression(var: !10)
-!10 = !DIGlobalVariable(name: "_ZN5clang23DataRecursiveASTVisitorIN12_GLOBAL__N_124UnusedBackingIvarCheckerEE26TraverseCUDAKernelCallExprEPNS_18CUDAKernelCallExprE", scope: !2, file: !3, line: 3, type: !8, isLocal: false, isDefinition: true)
+!10 = distinct !DIGlobalVariable(name: "_ZN5clang23DataRecursiveASTVisitorIN12_GLOBAL__N_124UnusedBackingIvarCheckerEE26TraverseCUDAKernelCallExprEPNS_18CUDAKernelCallExprE", scope: !2, file: !3, line: 3, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !11 = !DIGlobalVariableExpression(var: !12)
-!12 = !DIGlobalVariable(name: "_ZN4llvm16DenseMapIteratorIPNS_10MDLocationENS_6detail13DenseSetEmptyENS_10MDNodeInfoIS1_EENS3_12DenseSetPairIS2_EELb0EE23AdvancePastEmptyBucketsEv", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+!12 = distinct !DIGlobalVariable(name: "_ZN4llvm16DenseMapIteratorIPNS_10MDLocationENS_6detail13DenseSetEmptyENS_10MDNodeInfoIS1_EENS3_12DenseSetPairIS2_EELb0EE23AdvancePastEmptyBucketsEv", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !13 = !DIGlobalVariableExpression(var: !14)
-!14 = !DIGlobalVariable(name: "_ZNK4llvm12LivePhysRegs5printERNS_11raw_ostreamE", scope: !2, file: !3, line: 5, type: !8, isLocal: false, isDefinition: true)
+!14 = distinct !DIGlobalVariable(name: "_ZNK4llvm12LivePhysRegs5printERNS_11raw_ostreamE", scope: !2, file: !3, line: 5, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !15 = !DIGlobalVariableExpression(var: !16)
-!16 = !DIGlobalVariable(name: "_ZN4llvm15ScalarEvolution14getSignedRangeEPKNS_4SCEVE", scope: !2, file: !3, line: 6, type: !8, isLocal: false, isDefinition: true)
+!16 = distinct !DIGlobalVariable(name: "_ZN4llvm15ScalarEvolution14getSignedRangeEPKNS_4SCEVE", scope: !2, file: !3, line: 6, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !17 = !DIGlobalVariableExpression(var: !18)
-!18 = !DIGlobalVariable(name: "k1", scope: !2, file: !3, line: 7, type: !8, isLocal: false, isDefinition: true)
+!18 = distinct !DIGlobalVariable(name: "k1", scope: !2, file: !3, line: 7, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !19 = !DIGlobalVariableExpression(var: !20)
-!20 = !DIGlobalVariable(name: "is", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true)
+!20 = distinct !DIGlobalVariable(name: "is", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !21 = !DIGlobalVariableExpression(var: !22)
-!22 = !DIGlobalVariable(name: "setStmt", scope: !2, file: !3, line: 9, type: !8, isLocal: false, isDefinition: true)
+!22 = distinct !DIGlobalVariable(name: "setStmt", scope: !2, file: !3, line: 9, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !23 = !DIGlobalVariableExpression(var: !24)
-!24 = !DIGlobalVariable(name: "_ZN4llvm5TwineC1Ei", scope: !2, file: !3, line: 10, type: !8, isLocal: false, isDefinition: true)
+!24 = distinct !DIGlobalVariable(name: "_ZN4llvm5TwineC1Ei", scope: !2, file: !3, line: 10, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !25 = !DIGlobalVariableExpression(var: !26)
-!26 = !DIGlobalVariable(name: "_ZNK5clang12OverrideAttr5cloneERNS_10ASTContextE", scope: !2, file: !3, line: 11, type: !8, isLocal: false, isDefinition: true)
+!26 = distinct !DIGlobalVariable(name: "_ZNK5clang12OverrideAttr5cloneERNS_10ASTContextE", scope: !2, file: !3, line: 11, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !27 = !DIGlobalVariableExpression(var: !28)
-!28 = !DIGlobalVariable(name: "_ZN4llvm22MachineModuleInfoMachOD2Ev", scope: !2, file: !3, line: 12, type: !8, isLocal: false, isDefinition: true)
+!28 = distinct !DIGlobalVariable(name: "_ZN4llvm22MachineModuleInfoMachOD2Ev", scope: !2, file: !3, line: 12, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !29 = !{i32 2, !"Dwarf Version", i32 2}
 !30 = !{i32 2, !"Debug Info Version", i32 3}
 !31 = !{i32 1, !"PIC Level", i32 2}
 !32 = !{!"clang version 3.7.0 (trunk 231548) (llvm/trunk 231547)"}
 

test/DebugInfo/MIR/X86/live-debug-values-spill.mir

--- |
   attributes #3 = { nounwind readnone }
   attributes #4 = { nounwind }
   
   !llvm.dbg.cu = !{!2}
   !llvm.module.flags = !{!17, !18}
   !llvm.ident = !{!19}
   
   !0 = !DIGlobalVariableExpression(var: !1)
-  !1 = distinct !DIGlobalVariable(name: "glob0", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+  !1 = distinct !DIGlobalVariable(name: "glob0", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
   !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 5.0.0 (trunk 292962)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
   !3 = !DIFile(filename: "spill1.c", directory: "/home/test")
   !4 = !{}
   !5 = !{!0, !6, !9, !11, !13, !15}
   !6 = !DIGlobalVariableExpression(var: !7)
-  !7 = distinct !DIGlobalVariable(name: "glob1", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+  !7 = distinct !DIGlobalVariable(name: "glob1", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
   !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
   !9 = !DIGlobalVariableExpression(var: !10)
-  !10 = distinct !DIGlobalVariable(name: "glob2", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+  !10 = distinct !DIGlobalVariable(name: "glob2", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
   !11 = !DIGlobalVariableExpression(var: !12)
-  !12 = distinct !DIGlobalVariable(name: "glob3", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+  !12 = distinct !DIGlobalVariable(name: "glob3", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
   !13 = !DIGlobalVariableExpression(var: !14)
-  !14 = distinct !DIGlobalVariable(name: "glob4", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+  !14 = distinct !DIGlobalVariable(name: "glob4", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
   !15 = !DIGlobalVariableExpression(var: !16)
-  !16 = distinct !DIGlobalVariable(name: "glob5", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true)
+  !16 = distinct !DIGlobalVariable(name: "glob5", scope: !2, file: !3, line: 4, type: !8, isLocal: false, isDefinition: true, unit: !2)
   !17 = !{i32 2, !"Dwarf Version", i32 4}
   !18 = !{i32 2, !"Debug Info Version", i32 3}
   !19 = !{!"clang version 5.0.0 (trunk 292962)"}
   !20 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 6, type: !21, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: true, unit: !2, variables: !23)
   !21 = !DISubroutineType(types: !22)
   !22 = !{null, !8, !8, !8, !8, !8, !8, !8}
   !23 = !{!24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37}
   !24 = !DILocalVariable(name: "b0", arg: 1, scope: !20, file: !3, line: 6, type: !8)

test/DebugInfo/Mips/tls.ll

 ; RUN: llc -O0 -march=mips -mcpu=mips32r2 -filetype=asm < %s | FileCheck %s -check-prefix=CHECK-WORD
 ; RUN: llc -O0 -march=mips64 -mcpu=mips64r2 -filetype=asm < %s | FileCheck %s -check-prefix=CHECK-DWORD
 
 @x = thread_local global i32 5, align 4, !dbg !0
 
 ; CHECK-WORD: .dtprelword x+32768
 ; CHECK-DWORD: .dtpreldword x+32768
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!7, !8}
 !llvm.ident = !{!9}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 4.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "tls.c", directory: "/tmp")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 !9 = !{!"clang version 4.0.0"}

test/DebugInfo/PowerPC/tls-fission.ll

 source_filename = "test/DebugInfo/PowerPC/tls-fission.ll"
 
 @tls = thread_local global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!7, !8}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "tls", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "tls", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !4)
 !2 = !DIFile(filename: "tls.cpp", directory: "/tmp")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.4 ", isOptimized: false, runtimeVersion: 0, splitDebugFilename: "tls.dwo", emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
 !6 = !{!0}
 !7 = !{i32 2, !"Dwarf Version", i32 3}
 !8 = !{i32 1, !"Debug Info Version", i32 3}
 

test/DebugInfo/PowerPC/tls.ll

 source_filename = "test/DebugInfo/PowerPC/tls.ll"
 
 @tls = thread_local global i32 7, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!7, !8}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "tls", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "tls", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !4)
 !2 = !DIFile(filename: "tls.cpp", directory: "/tmp")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.4 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
 !6 = !{!0}
 !7 = !{i32 2, !"Dwarf Version", i32 3}
 !8 = !{i32 1, !"Debug Info Version", i32 3}
 

test/DebugInfo/X86/FrameIndexExprs.ll

 }
 
 attributes #0 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!9, !10, !11}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "f", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "f", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "PR31381.c", directory: "/")
 !4 = !{}
 !5 = !{!0, !6}
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = distinct !DIGlobalVariable(name: "h", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "h", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true, unit: !2)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !9 = !{i32 2, !"Dwarf Version", i32 4}
 !10 = !{i32 2, !"Debug Info Version", i32 3}
 !11 = !{i32 1, !"PIC Level", i32 2}
 !12 = distinct !DISubprogram(name: "fn4", scope: !3, file: !3, line: 31, type: !13, isLocal: false, isDefinition: true, scopeLine: 32, isOptimized: true, unit: !2, variables: !4)
 !13 = !DISubroutineType(types: !14)
 !14 = !{null}
 !15 = !DILocalVariable(name: "p", arg: 1, scope: !16, file: !3, line: 19, type: !19)

test/DebugInfo/X86/arange-and-stub.ll

%tmp1 = landingpad { i8*, i32 }
           filter [1 x i8*] [i8* bitcast (i8** @_ZTId to i8*)]
   ret void
 }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!15, !16}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "zed", scope: !2, file: !6, line: 6, type: !7, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "zed", scope: !2, file: !6, line: 6, type: !7, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 3.7.0 (trunk 234308) (llvm/trunk 234310)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !5, imports: !4)
 !3 = !DIFile(filename: "/Users/espindola/llvm/<stdin>", directory: "/Users/espindola/llvm/build")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIFile(filename: "/Users/espindola/llvm/test.cpp", directory: "/Users/espindola/llvm/build")
 !7 = !DICompositeType(tag: DW_TAG_array_type, baseType: !8, size: 64, align: 64, elements: !13)
 !8 = !DIDerivedType(tag: DW_TAG_typedef, name: "vifunc", file: !6, line: 5, baseType: !9)
 !9 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64, align: 64)

test/DebugInfo/X86/arange.ll

 @f = global %struct.foo zeroinitializer, align 1, !dbg !0
 @i = external global i32
 
 !llvm.dbg.cu = !{!9}
 !llvm.module.flags = !{!12, !13}
 !llvm.ident = !{!14}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "f", scope: null, file: !2, line: 6, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "f", scope: null, file: !2, line: 6, type: !3, isLocal: false, isDefinition: true, unit: !9)
 !2 = !DIFile(filename: "simple.cpp", directory: "/tmp/dbginfo")
 !3 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo<&i>", file: !2, line: 3, size: 8, align: 8, elements: !4, templateParams: !5, identifier: "_ZTS3fooIXadL_Z1iEEE")
 !4 = !{}
 !5 = !{!6}
 !6 = !DITemplateValueParameter(name: "x", type: !7, value: i32* @i)
 !7 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !8, size: 64, align: 64)
 !8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.5 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !10, globals: !11, imports: !4)
 !10 = !{!3}
 !11 = !{!0}
 !12 = !{i32 2, !"Dwarf Version", i32 4}
 !13 = !{i32 1, !"Debug Info Version", i32 3}
 !14 = !{!"clang version 3.5 "}
 

test/DebugInfo/X86/debug-info-static-member.ll

 
 attributes #0 = { nounwind uwtable }
 attributes #1 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!22}
 !llvm.module.flags = !{!25}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "a", linkageName: "_ZN1C1aE", scope: null, file: !2, line: 14, type: !3, isLocal: false, isDefinition: true, declaration: !4)
+!1 = distinct !DIGlobalVariable(name: "a", linkageName: "_ZN1C1aE", scope: null, file: !2, line: 14, type: !3, isLocal: false, isDefinition: true, declaration: !4, unit: !22)
 !2 = !DIFile(filename: "/usr/local/google/home/blaikie/Development/llvm/src/tools/clang/test/CodeGenCXX/debug-info-static-member.cpp", directory: "/home/blaikie/local/Development/llvm/build/clang/x86-64/Debug/llvm")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !5, file: !2, line: 3, baseType: !3, flags: DIFlagPrivate | DIFlagStaticMember)
 !5 = !DICompositeType(tag: DW_TAG_class_type, name: "C", file: !2, line: 1, size: 32, align: 32, elements: !6)
 !6 = !{!4, !7, !10, !11, !14, !15, !17}
 !7 = !DIDerivedType(tag: DW_TAG_member, name: "const_a", scope: !5, file: !2, line: 4, baseType: !8, flags: DIFlagPrivate | DIFlagStaticMember, extraData: i1 true)
 !8 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !9)
 !9 = !DIBasicType(name: "bool", size: 8, align: 8, encoding: DW_ATE_boolean)
 !10 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !5, file: !2, line: 6, baseType: !3, flags: DIFlagProtected | DIFlagStaticMember)
 !11 = !DIDerivedType(tag: DW_TAG_member, name: "const_b", scope: !5, file: !2, line: 7, baseType: !12, flags: DIFlagProtected | DIFlagStaticMember, extraData: float 0x40091EB860000000)
 !12 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !13)
 !13 = !DIBasicType(name: "float", size: 32, align: 32, encoding: DW_ATE_float)
 !14 = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: !5, file: !2, line: 9, baseType: !3, flags: DIFlagPublic | DIFlagStaticMember)
 !15 = !DIDerivedType(tag: DW_TAG_member, name: "const_c", scope: !5, file: !2, line: 10, baseType: !16, flags: DIFlagPublic | DIFlagStaticMember, extraData: i32 18)
 !16 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !3)
 !17 = !DIDerivedType(tag: DW_TAG_member, name: "d", scope: !5, file: !2, line: 11, baseType: !3, size: 32, align: 32, flags: DIFlagPublic)
 !18 = !DIGlobalVariableExpression(var: !19)
-!19 = !DIGlobalVariable(name: "b", linkageName: "_ZN1C1bE", scope: null, file: !2, line: 15, type: !3, isLocal: false, isDefinition: true, declaration: !10)
+!19 = distinct !DIGlobalVariable(name: "b", linkageName: "_ZN1C1bE", scope: null, file: !2, line: 15, type: !3, isLocal: false, isDefinition: true, declaration: !10, unit: !22)
 !20 = !DIGlobalVariableExpression(var: !21)
-!21 = !DIGlobalVariable(name: "c", linkageName: "_ZN1C1cE", scope: null, file: !2, line: 16, type: !3, isLocal: false, isDefinition: true, declaration: !14)
+!21 = distinct !DIGlobalVariable(name: "c", linkageName: "_ZN1C1cE", scope: null, file: !2, line: 16, type: !3, isLocal: false, isDefinition: true, declaration: !14, unit: !22)
 !22 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.3 (trunk 171914)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !23, retainedTypes: !23, globals: !24, imports: !23)
 !23 = !{}
 !24 = !{!0, !18, !20}
 !25 = !{i32 1, !"Debug Info Version", i32 3}
 !26 = distinct !DISubprogram(name: "main", scope: !2, file: !2, line: 18, type: !27, isLocal: false, isDefinition: true, scopeLine: 23, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !22, variables: !23)
 !27 = !DISubroutineType(types: !28)
 !28 = !{!3}
 !29 = !DILocalVariable(name: "instance_C", scope: !26, file: !2, line: 20, type: !5)

test/DebugInfo/X86/dwarf-aranges-no-dwarf-labels.ll

 attributes #0 = { nounwind readnone uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { nounwind readonly uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #2 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!7, !8}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "global", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "global", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !4)
 !2 = !DIFile(filename: "tmp/debug_ranges/a.cc", directory: "/")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.4 (191881)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
 !6 = !{!0}
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 1, !"Debug Info Version", i32 3}
 !9 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !2, file: !2, line: 2, type: !10, isLocal: false, isDefinition: true, scopeLine: 2, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true, unit: !4, variables: !12)

test/DebugInfo/X86/dwarf-aranges.ll

entry:
   store i32 %add1, i32* @some_bss, align 4, !dbg !16
   ret void, !dbg !17
 }
 
 !llvm.dbg.cu = !{!8}
 !llvm.module.flags = !{!11, !12}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "some_data", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "some_data", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !8)
 !2 = !DIFile(filename: "test.c", directory: "/home/kayamon")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = !DIGlobalVariableExpression(var: !5)
-!5 = !DIGlobalVariable(name: "some_other", scope: null, file: !2, line: 3, type: !3, isLocal: false, isDefinition: true)
+!5 = distinct !DIGlobalVariable(name: "some_other", scope: null, file: !2, line: 3, type: !3, isLocal: false, isDefinition: true, unit: !8)
 !6 = !DIGlobalVariableExpression(var: !7)
-!7 = !DIGlobalVariable(name: "some_bss", scope: null, file: !2, line: 2, type: !3, isLocal: false, isDefinition: true)
+!7 = distinct !DIGlobalVariable(name: "some_bss", scope: null, file: !2, line: 2, type: !3, isLocal: false, isDefinition: true, unit: !8)
 !8 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.4 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !9, retainedTypes: !9, globals: !10, imports: !9)
 !9 = !{}
 !10 = !{!0, !4, !6}
 !11 = !{i32 2, !"Dwarf Version", i32 4}
 !12 = !{i32 1, !"Debug Info Version", i32 3}
 !13 = distinct !DISubprogram(name: "some_code", scope: !2, file: !2, line: 5, type: !14, isLocal: false, isDefinition: true, scopeLine: 6, virtualIndex: 6, isOptimized: false, unit: !8, variables: !9)
 !14 = !DISubroutineType(types: !15)
 !15 = !{null}
 !16 = !DILocation(line: 7, scope: !13)
 !17 = !DILocation(line: 8, scope: !13)
 

test/DebugInfo/X86/dwarf-public-names.ll

 
 attributes #0 = { nounwind uwtable }
 attributes #1 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!20}
 !llvm.module.flags = !{!22}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "static_member_variable", linkageName: "_ZN1C22static_member_variableE", scope: !2, file: !3, line: 7, type: !6, isLocal: false, isDefinition: true, declaration: !5)
+!1 = distinct !DIGlobalVariable(name: "static_member_variable", linkageName: "_ZN1C22static_member_variableE", scope: !2, file: !3, line: 7, type: !6, isLocal: false, isDefinition: true, declaration: !5, unit: !20)
 !2 = !DICompositeType(tag: DW_TAG_structure_type, name: "C", file: !3, line: 1, size: 8, elements: !4)
 !3 = !DIFile(filename: "dwarf-public-names.cpp", directory: "/usr2/kparzysz/s.hex/t")
 !4 = !{!5, !7, !12}
 !5 = !DIDerivedType(tag: DW_TAG_member, name: "static_member_variable", scope: !2, file: !3, line: 4, baseType: !6, flags: DIFlagStaticMember)
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: false, scopeLine: 2, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, variables: !11)
 !8 = !DISubroutineType(types: !9)
 !9 = !{null, !10}
 !10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !2, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !11 = !{}
 !12 = !DISubprogram(name: "static_member_function", linkageName: "_ZN1C22static_member_functionEv", scope: !2, file: !3, line: 3, type: !13, isLocal: false, isDefinition: false, scopeLine: 3, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, variables: !11)
 !13 = !DISubroutineType(types: !14)
 !14 = !{!6}
 !15 = !DIGlobalVariableExpression(var: !16)
-!16 = !DIGlobalVariable(name: "global_variable", scope: null, file: !3, line: 17, type: !2, isLocal: false, isDefinition: true) ; previously: invalid DW_TAG_base_type
+!16 = distinct !DIGlobalVariable(name: "global_variable", scope: null, file: !3, line: 17, type: !2, isLocal: false, isDefinition: true, unit: !20) ; previously: invalid DW_TAG_base_type
 !17 = !DIGlobalVariableExpression(var: !18)
-!18 = !DIGlobalVariable(name: "global_namespace_variable", linkageName: "_ZN2ns25global_namespace_variableE", scope: !19, file: !3, line: 27, type: !6, isLocal: false, isDefinition: true)
+!18 = distinct !DIGlobalVariable(name: "global_namespace_variable", linkageName: "_ZN2ns25global_namespace_variableE", scope: !19, file: !3, line: 27, type: !6, isLocal: false, isDefinition: true, unit: !20)
 !19 = !DINamespace(name: "ns", scope: null, file: !3, line: 23)
 !20 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 3.3 (http://llvm.org/git/clang.git a09cd8103a6a719cb2628cdf0c91682250a17bd2) (http://llvm.org/git/llvm.git 47d03cec0afca0c01ae42b82916d1d731716cd20)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !11, retainedTypes: !11, globals: !21, imports: !11) ; previously: invalid DW_TAG_base_type
 !21 = !{!0, !15, !17}
 !22 = !{i32 1, !"Debug Info Version", i32 3}
 !23 = distinct !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", scope: null, file: !3, line: 9, type: !8, isLocal: false, isDefinition: true, scopeLine: 9, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !20, declaration: !7, variables: !11)
 !24 = !DILocalVariable(name: "this", arg: 1, scope: !23, file: !3, line: 9, type: !25, flags: DIFlagArtificial | DIFlagObjectPointer)
 !25 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !2, size: 64)
 !26 = !DIExpression()

test/DebugInfo/X86/fission-cu.ll

 ; RUN: llc -split-dwarf=Enable -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
 ; RUN: llvm-dwarfdump -debug-dump=all %t | FileCheck %s
 ; RUN: llvm-readobj --relocations %t | FileCheck --check-prefix=OBJ %s
 ; RUN: llvm-objdump -h %t | FileCheck --check-prefix=HDR %s
 
 source_filename = "test/DebugInfo/X86/fission-cu.ll"
 
 @a = common global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!7}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "a", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "a", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !4)
 !2 = !DIFile(filename: "baz.c", directory: "/usr/local/google/home/echristo/tmp")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.3 (trunk 169021) (llvm/trunk 169020)", isOptimized: false, runtimeVersion: 0, splitDebugFilename: "baz.dwo", emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
 ; Check that the skeleton compile unit contains the proper attributes:
 ; This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
 ; DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
 ; DW_AT_ranges_base, DW_AT_addr_base.

test/DebugInfo/X86/gnu-public-names-tu.ll

 
 @b = global %struct.bar zeroinitializer, align 1, !dbg !0
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!11, !12}
 !llvm.ident = !{!13}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 8, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 8, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 293904) (llvm/trunk 293908)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "type.cpp", directory: "/tmp/dbginfo")
 !4 = !{}
 !5 = !{!0}
 !6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "bar", file: !3, line: 5, size: 8, elements: !7, identifier: "_ZTS3bar")
 !7 = !{!8}
 !8 = !DIDerivedType(tag: DW_TAG_member, name: "f", scope: !6, file: !3, line: 6, baseType: !9, size: 8)
 !9 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "foo", scope: !10, file: !3, line: 2, size: 8, elements: !4, identifier: "_ZTSN2ns3fooE")
 !10 = !DINamespace(name: "ns", scope: null, file: !3, line: 1)
 !11 = !{i32 2, !"Dwarf Version", i32 4}
 !12 = !{i32 2, !"Debug Info Version", i32 3}
 !13 = !{!"clang version 5.0.0 (trunk 293904) (llvm/trunk 293908)"}
 

test/DebugInfo/X86/gnu-public-names.ll

 attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!48, !49}
 !llvm.ident = !{!50}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "static_member_variable", linkageName: "_ZN1C22static_member_variableE", scope: !2, file: !3, line: 7, type: !9, isLocal: false, isDefinition: true, declaration: !8)
+!1 = distinct !DIGlobalVariable(name: "static_member_variable", linkageName: "_ZN1C22static_member_variableE", scope: !2, file: !3, line: 7, type: !9, isLocal: false, isDefinition: true, declaration: !8, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 3.7.0 (trunk 234897) (llvm/trunk 234911)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !5, globals: !21, imports: !44)
 !3 = !DIFile(filename: "gnu-public-names.cpp", directory: "/tmp/dbginfo")
 !4 = !{}
 !5 = !{!6, !17}
 !6 = !DICompositeType(tag: DW_TAG_structure_type, name: "C", file: !3, line: 1, size: 8, align: 8, elements: !7, identifier: "_ZTS1C")
 !7 = !{!8, !10, !14}
 !8 = !DIDerivedType(tag: DW_TAG_member, name: "static_member_variable", scope: !6, file: !3, line: 4, baseType: !9, flags: DIFlagStaticMember)
 !9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", scope: !6, file: !3, line: 2, type: !11, isLocal: false, isDefinition: false, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false)
 !11 = !DISubroutineType(types: !12)
 !12 = !{null, !13}
 !13 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64, align: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !14 = !DISubprogram(name: "static_member_function", linkageName: "_ZN1C22static_member_functionEv", scope: !6, file: !3, line: 3, type: !15, isLocal: false, isDefinition: false, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: false)
 !15 = !DISubroutineType(types: !16)
 !16 = !{!9}
 !17 = !DICompositeType(tag: DW_TAG_structure_type, name: "D", scope: !18, file: !3, line: 29, size: 32, align: 32, elements: !19, identifier: "_ZTSN2ns1DE")
 !18 = !DINamespace(name: "ns", scope: null, file: !3, line: 23)
 !19 = !{!20}
 !20 = !DIDerivedType(tag: DW_TAG_member, name: "A", scope: !17, file: !3, line: 30, baseType: !9, size: 32, align: 32)
 !21 = !{!0, !22, !24, !26, !28, !34, !37, !40}
 !22 = !DIGlobalVariableExpression(var: !23)
-!23 = !DIGlobalVariable(name: "global_variable", scope: !2, file: !3, line: 17, type: !6, isLocal: false, isDefinition: true)
+!23 = distinct !DIGlobalVariable(name: "global_variable", scope: !2, file: !3, line: 17, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !24 = !DIGlobalVariableExpression(var: !25)
-!25 = !DIGlobalVariable(name: "global_namespace_variable", linkageName: "_ZN2ns25global_namespace_variableE", scope: !18, file: !3, line: 27, type: !9, isLocal: false, isDefinition: true)
+!25 = distinct !DIGlobalVariable(name: "global_namespace_variable", linkageName: "_ZN2ns25global_namespace_variableE", scope: !18, file: !3, line: 27, type: !9, isLocal: false, isDefinition: true, unit: !2)
 !26 = !DIGlobalVariableExpression(var: !27)
-!27 = !DIGlobalVariable(name: "d", linkageName: "_ZN2ns1dE", scope: !18, file: !3, line: 31, type: !17, isLocal: false, isDefinition: true)
+!27 = distinct !DIGlobalVariable(name: "d", linkageName: "_ZN2ns1dE", scope: !18, file: !3, line: 31, type: !17, isLocal: false, isDefinition: true, unit: !2)
 !28 = !DIGlobalVariableExpression(var: !29)
-!29 = !DIGlobalVariable(name: "z", scope: !30, file: !3, line: 41, type: !9, isLocal: true, isDefinition: true)
+!29 = distinct !DIGlobalVariable(name: "z", scope: !30, file: !3, line: 41, type: !9, isLocal: true, isDefinition: true, unit: !2)
 !30 = distinct !DISubprogram(name: "f3", linkageName: "_Z2f3v", scope: !3, file: !3, line: 40, type: !31, isLocal: false, isDefinition: true, scopeLine: 40, flags: DIFlagPrototyped, isOptimized: false, unit: !2, variables: !4)
 !31 = !DISubroutineType(types: !32)
 !32 = !{!33}
 !33 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64, align: 64)
 !34 = !DIGlobalVariableExpression(var: !35)
-!35 = !DIGlobalVariable(name: "i", linkageName: "_ZN12_GLOBAL__N_11iE", scope: !36, file: !3, line: 37, type: !9, isLocal: true, isDefinition: true)
+!35 = distinct !DIGlobalVariable(name: "i", linkageName: "_ZN12_GLOBAL__N_11iE", scope: !36, file: !3, line: 37, type: !9, isLocal: true, isDefinition: true, unit: !2)
 !36 = !DINamespace(scope: null, file: !3, line: 36)
 !37 = !DIGlobalVariableExpression(var: !38)
-!38 = !DIGlobalVariable(name: "b", linkageName: "_ZN12_GLOBAL__N_15inner1bE", scope: !39, file: !3, line: 47, type: !9, isLocal: true, isDefinition: true)
+!38 = distinct !DIGlobalVariable(name: "b", linkageName: "_ZN12_GLOBAL__N_15inner1bE", scope: !39, file: !3, line: 47, type: !9, isLocal: true, isDefinition: true, unit: !2)
 !39 = !DINamespace(name: "inner", scope: !36, file: !3, line: 46)
 !40 = !DIGlobalVariableExpression(var: !41)
-!41 = !DIGlobalVariable(name: "c", linkageName: "_ZN5outer12_GLOBAL__N_11cE", scope: !42, file: !3, line: 53, type: !9, isLocal: true, isDefinition: true)
+!41 = distinct !DIGlobalVariable(name: "c", linkageName: "_ZN5outer12_GLOBAL__N_11cE", scope: !42, file: !3, line: 53, type: !9, isLocal: true, isDefinition: true, unit: !2)
 !42 = !DINamespace(scope: !43, file: !3, line: 52)
 !43 = !DINamespace(name: "outer", scope: null, file: !3, line: 51)
 !44 = !{!45, !47}
 !45 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !2, entity: !46, line: 34)
-!46 = !DIGlobalVariable(name: "global_namespace_variable_decl", linkageName: "_ZN2ns30global_namespace_variable_declE", scope: !18, file: !3, line: 28, type: !9, isLocal: false, isDefinition: false)
+!46 = distinct !DIGlobalVariable(name: "global_namespace_variable_decl", linkageName: "_ZN2ns30global_namespace_variable_declE", scope: !18, file: !3, line: 28, type: !9, isLocal: false, isDefinition: false, unit: !2)
 !47 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !43, entity: !42, line: 43)
 !48 = !{i32 2, !"Dwarf Version", i32 4}
 !49 = !{i32 2, !"Debug Info Version", i32 3}
 !50 = !{!"clang version 3.7.0 (trunk 234897) (llvm/trunk 234911)"}
 !51 = distinct !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", scope: !6, file: !3, line: 9, type: !11, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !2, declaration: !10, variables: !4)
 !52 = !DILocalVariable(name: "this", arg: 1, scope: !51, type: !53, flags: DIFlagArtificial | DIFlagObjectPointer)
 !53 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !6, size: 64, align: 64)
 !54 = !DIExpression()

test/DebugInfo/X86/multiple-aranges.ll

 
 @kittens = global i32 4, align 4, !dbg !0
 @rainbows = global i32 5, align 4, !dbg !4
 
 !llvm.dbg.cu = !{!7, !10}
 !llvm.module.flags = !{!12, !13}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "kittens", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "kittens", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !7)
 !2 = !DIFile(filename: "test1.c", directory: "/home/kayamon")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = !DIGlobalVariableExpression(var: !5)
-!5 = !DIGlobalVariable(name: "rainbows", scope: null, file: !6, line: 1, type: !3, isLocal: false, isDefinition: true)
+!5 = distinct !DIGlobalVariable(name: "rainbows", scope: null, file: !6, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !10)
 !6 = !DIFile(filename: "test2.c", directory: "/home/kayamon")
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.4 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, retainedTypes: !8, globals: !9, imports: !8)
 !8 = !{}
 !9 = !{!0}
 !10 = distinct !DICompileUnit(language: DW_LANG_C99, file: !6, producer: "clang version 3.4 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, retainedTypes: !8, globals: !11, imports: !8)
 !11 = !{!4}
 !12 = !{i32 2, !"Dwarf Version", i32 4}
 !13 = !{i32 1, !"Debug Info Version", i32 3}
 

test/DebugInfo/X86/split-global.ll

 @point.y = global i32 2, align 4, !dbg !13
 @point.x = global i32 1, align 4, !dbg !12
 
 @part_const.x = global i32 1, align 4, !dbg !15
 
 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!10, !11}
 
-!0 = distinct !DIGlobalVariable(name: "point", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
+!0 = distinct !DIGlobalVariable(name: "point", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true, unit: !1)
 !1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !4)
 !2 = !DIFile(filename: "g.c", directory: "/")
 !3 = !{}
 !4 = !{!12, !13, !14, !15, !17, !18}
 !5 = distinct !DICompositeType(tag: DW_TAG_structure_type, file: !2, line: 1, size: 64, elements: !6)
 !6 = !{!7, !9}
 !7 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !5, file: !2, line: 1, baseType: !8, size: 32)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !9 = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: !5, file: !2, line: 1, baseType: !8, size: 32, offset: 32)
 !10 = !{i32 2, !"Dwarf Version", i32 4}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
 !12 = !DIGlobalVariableExpression(var: !0,  expr: !DIExpression(DW_OP_LLVM_fragment,  0, 32))
 !13 = !DIGlobalVariableExpression(var: !0,  expr: !DIExpression(DW_OP_LLVM_fragment, 32, 32))
 !14 = !DIGlobalVariableExpression(var: !16, expr: !DIExpression(DW_OP_LLVM_fragment,  0, 32))
 !15 = !DIGlobalVariableExpression(var: !16, expr: !DIExpression(DW_OP_constu, 2,
                                              DW_OP_stack_value, DW_OP_LLVM_fragment, 32, 32))
-!16 = distinct !DIGlobalVariable(name: "part_const", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
+!16 = distinct !DIGlobalVariable(name: "part_const", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true, unit: !1)
 !17 = !DIGlobalVariableExpression(var: !19, expr: !DIExpression(DW_OP_constu, 1,
                                              DW_OP_stack_value, DW_OP_LLVM_fragment,  0, 32))
 !18 = !DIGlobalVariableExpression(var: !19, expr: !DIExpression(DW_OP_constu, 2,
                                              DW_OP_stack_value, DW_OP_LLVM_fragment, 32, 32))
 !19 = distinct !DIGlobalVariable(name: "full_const", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)

test/DebugInfo/X86/stack-value-dwarf4.ll

 @g = global i32 0, !dbg !2
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang", file: !4, globals: !1, emissionKind: FullDebug)
 !1 = !{!2}
 !2 = !DIGlobalVariableExpression(var: !8, expr: !3)
 !3 = !DIExpression(DW_OP_constu, 4, DW_OP_constu, 4, DW_OP_stack_value)
 !4 = !DIFile(filename: "<stdin>", directory: "/")
 !5 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
-
 !6 = !{i32 2, !"Dwarf Version", i32 2}
 !7 = !{i32 2, !"Debug Info Version", i32 3}
-!8 = distinct !DIGlobalVariable(name: "a", scope: null, isLocal: false, isDefinition: true, type: !5)
+!8 = distinct !DIGlobalVariable(name: "a", scope: null, isLocal: false, isDefinition: true, type: !5, unit: !0)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!6, !7}

test/DebugInfo/X86/static_member_array.ll

 @_ZN1A15fully_specifiedE = global i32 0, align 4, !dbg !0
 @_ZN1A4smemE = global [4 x i32] [i32 0, i32 1, i32 2, i32 3], align 16, !dbg !6
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!19, !20, !21}
 !llvm.ident = !{!22}
 
 !0 = distinct !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "fully_specified", linkageName: "_ZN1A15fully_specifiedE", scope: !2, file: !3, line: 7, type: !9, isLocal: false, isDefinition: true, declaration: !15)
+!1 = distinct !DIGlobalVariable(name: "fully_specified", linkageName: "_ZN1A15fully_specifiedE", scope: !2, file: !3, line: 7, type: !9, isLocal: false, isDefinition: true, declaration: !15, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 4.0.0 (trunk 286129) (llvm/trunk 286128)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "static_member_array.cpp", directory: "/Volumes/Data/radar/28706946")
 !4 = !{}
 !5 = !{!0, !6}
 !6 = distinct !DIGlobalVariableExpression(var: !7)
-!7 = !DIGlobalVariable(name: "smem", linkageName: "_ZN1A4smemE", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true, declaration: !12)
+!7 = distinct !DIGlobalVariable(name: "smem", linkageName: "_ZN1A4smemE", scope: !2, file: !3, line: 8, type: !8, isLocal: false, isDefinition: true, declaration: !12, unit: !2)
 !8 = !DICompositeType(tag: DW_TAG_array_type, baseType: !9, size: 128, elements: !10)
 !9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !10 = !{!11}
 !11 = !DISubrange(count: 4)
 !12 = !DIDerivedType(tag: DW_TAG_member, name: "smem", scope: !13, file: !3, line: 4, baseType: !16, flags: DIFlagStaticMember)
 !13 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A", file: !3, line: 1, size: 8, elements: !14, identifier: "_ZTS1A")
 !14 = !{!15, !12}
 !15 = !DIDerivedType(tag: DW_TAG_member, name: "fully_specified", scope: !13, file: !3, line: 3, baseType: !9, flags: DIFlagStaticMember)
 !16 = !DICompositeType(tag: DW_TAG_array_type, baseType: !9, elements: !17)
 !17 = !{!18}
 !18 = !DISubrange(count: -1)
 !19 = !{i32 2, !"Dwarf Version", i32 4}
 !20 = !{i32 2, !"Debug Info Version", i32 3}
 !21 = !{i32 1, !"PIC Level", i32 2}
 !22 = !{!"clang version 4.0.0 (trunk 286129) (llvm/trunk 286128)"}
 

test/DebugInfo/X86/stringpool.ll

 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s --check-prefix=LINUX
 ; RUN: llc -mtriple=x86_64-darwin < %s | FileCheck %s --check-prefix=DARWIN
 
 source_filename = "test/DebugInfo/X86/stringpool.ll"
 
 @yyyy = common global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!7}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "yyyy", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "yyyy", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !4)
 !2 = !DIFile(filename: "z.c", directory: "/home/nicholas")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.1 (trunk 143009)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
 ; Verify that "yyyy" ended up in the stringpool.
 ; LINUX: .section .debug_str,"MS",@progbits,1
 ; LINUX: yyyy
 ; DARWIN: .section __DWARF,__debug_str,regular,debug

test/DebugInfo/X86/tls.ll

 
 attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!6}
 !llvm.module.flags = !{!9, !10}
 !llvm.ident = !{!11}
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = !DIGlobalVariable(name: "tls", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "tls", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true, unit: !6)
 !2 = !DIFile(filename: "tls.cpp", directory: "/tmp/dbginfo")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = !DIGlobalVariableExpression(var: !5)
-!5 = !DIGlobalVariable(name: "glbl", scope: null, file: !2, line: 2, type: !3, isLocal: false, isDefinition: true)
+!5 = distinct !DIGlobalVariable(name: "glbl", scope: null, file: !2, line: 2, type: !3, isLocal: false, isDefinition: true, unit: !6)
 !6 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang version 3.5 ", isOptimized: false, runtimeVersion: 0, splitDebugFilename: "-.dwo", emissionKind: FullDebug, enums: !7, retainedTypes: !7, globals: !8, imports: !7)
 !7 = !{}
 !8 = !{!0, !4}
 !9 = !{i32 2, !"Dwarf Version", i32 4}
 !10 = !{i32 1, !"Debug Info Version", i32 3}
 !11 = !{!"clang version 3.5 "}
 !12 = distinct !DISubprogram(name: "func<&glbl>", linkageName: "_Z4funcIXadL_Z4glblEEEiv", scope: !2, file: !2, line: 5, type: !13, isLocal: false, isDefinition: true, scopeLine: 5, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !6, templateParams: !15, variables: !7)
 !13 = !DISubroutineType(types: !14)
 !14 = !{!3}
 !15 = !{!16}
 !16 = !DITemplateValueParameter(name: "I", type: !17, value: i32* @glbl)
 !17 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !3, size: 64, align: 64)
 !18 = !DILocation(line: 6, scope: !12)
 

test/Linker/debug-info-global-var.ll

 !2 = !DIFile(filename: "debug-info-global-var.c", directory: "/")
 !3 = !{}
 !4 = !{!0}
 !5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !6 = !{i32 2, !"Dwarf Version", i32 4}
 !7 = !{i32 2, !"Debug Info Version", i32 3}
 !8 = !{i32 1, !"PIC Level", i32 2}
 !9 = !{!"clang version 4.0.0 (trunk 286129) (llvm/trunk 286128)"}
-!10 = distinct !DIGlobalVariable(name: "g", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
+!10 = distinct !DIGlobalVariable(name: "g", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true, unit: !1)

test/Transforms/ConstantMerge/merge-dbg.ll

 !llvm.module.flags = !{!7, !8}
 
 ; CHECK: [[A]] = !DIGlobalVariableExpression(var: [[VA:![0-9]+]])
 ; CHECK: [[VA]] = distinct !DIGlobalVariable(name: "y"
 ; CHECK: [[B]] = !DIGlobalVariableExpression(var: [[VB:![0-9]+]])
 ; CHECK: [[VB]] = distinct !DIGlobalVariable(name: "x"
 
 !0 = !DIGlobalVariableExpression(var: !1)
-!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!1 = distinct !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true, unit: !2)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 297227) (llvm/trunk 297234)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
 !3 = !DIFile(filename: "1.cc", directory: "/build")
 !4 = !{}
 !5 = !{!0}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 
 !9 = !DIGlobalVariableExpression(var: !10)
-!10 = distinct !DIGlobalVariable(name: "y", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!10 = distinct !DIGlobalVariable(name: "y", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true, unit: !2)

test/Verifier/DIGlobalVariable-no-unit.ll

+; RUN: not opt -S <%s 2>&1| FileCheck %s
+
+; CHECK: missing unit field
+@g = common global i32 0, align 4, !dbg !3
+
+!llvm.dbg.cu = !{!1}
+!llvm.module.flags = !{!6, !7}
+
+!0 = distinct !DIGlobalVariable(name: "g", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
+!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, emissionKind: FullDebug)
+!2 = !DIFile(filename: "a.c", directory: "/")
+!3 = !DIGlobalVariableExpression(var: !0)
+!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!6 = !{i32 2, !"Dwarf Version", i32 4}
+!7 = !{i32 2, !"Debug Info Version", i32 3}

test/tools/llvm-objdump/Hexagon/source-interleave-hexagon.ll

 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!6, !7}
 !llvm.ident = !{!8}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 4.0.0 (http://llvm.org/git/clang d19a95e94dc57c5a72fd25d64f26134aa7d25fa0) (http://llvm.org/git/llvm.git 313924e6ff8a332063f61d3fda03812c220762f6)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
 !1 = !DIFile(filename: "source-interleave-hexagon.c", directory: "SRC_COMPDIR")
 !2 = !{}
 !3 = !{!4}
-!4 = !DIGlobalVariableExpression(var: !DIGlobalVariable(name: "a", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true))
+!4 = !DIGlobalVariableExpression(var: !24)
 !5 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = !{i32 2, !"Dwarf Version", i32 4}
 !7 = !{i32 2, !"Debug Info Version", i32 3}
 !8 = !{!"clang version 4.0.0 (http://llvm.org/git/clang d19a95e94dc57c5a72fd25d64f26134aa7d25fa0) (http://llvm.org/git/llvm.git 313924e6ff8a332063f61d3fda03812c220762f6)"}
 !9 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 2, type: !10, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: false, unit: !0, variables: !2)
 !10 = !DISubroutineType(types: !11)
 !11 = !{!5}
 !12 = !DILocation(line: 3, column: 10, scope: !9)
 !13 = !DILocation(line: 3, column: 3, scope: !9)
 !14 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 6, type: !10, isLocal: false, isDefinition: true, scopeLine: 6, isOptimized: false, unit: !0, variables: !2)
 !15 = !DILocalVariable(name: "b", scope: !14, file: !1, line: 7, type: !16)
 !16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !5, size: 32, align: 32)
 !17 = !DIExpression()
 !18 = !DILocation(line: 7, column: 8, scope: !14)
 !19 = !DILocation(line: 8, column: 11, scope: !14)
 !20 = !DILocation(line: 8, column: 10, scope: !14)
 !21 = !DILocation(line: 8, column: 15, scope: !14)
 !22 = !DILocation(line: 8, column: 13, scope: !14)
 !23 = !DILocation(line: 8, column: 3, scope: !14)
+!24 = distinct !DIGlobalVariable(name: "a", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, unit: !0)
 ; LINES: main:
 ; LINES-NEXT: SRC_COMPDIR/source-interleave-hexagon.c:6
 
 ; SOURCE: main:
 ; SOURCE-NEXT: int main() {

test/tools/llvm-objdump/X86/source-interleave-x86_64.ll

 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!6, !7}
 !llvm.ident = !{!8}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 4.0.0 (http://llvm.org/git/clang d19a95e94dc57c5a72fd25d64f26134aa7d25fa0) (http://llvm.org/git/llvm.git 313924e6ff8a332063f61d3fda03812c220762f6)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
 !1 = !DIFile(filename: "source-interleave-x86_64.c", directory: "SRC_COMPDIR")
 !2 = !{}
 !3 = !{!4}
-!4 = !DIGlobalVariableExpression(var: !DIGlobalVariable(name: "a", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true))
+!4 = distinct !DIGlobalVariable(name: "a", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true)
 !5 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = !{i32 2, !"Dwarf Version", i32 4}
 !7 = !{i32 2, !"Debug Info Version", i32 3}
 !8 = !{!"clang version 4.0.0 (http://llvm.org/git/clang d19a95e94dc57c5a72fd25d64f26134aa7d25fa0) (http://llvm.org/git/llvm.git 313924e6ff8a332063f61d3fda03812c220762f6)"}
 !9 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 2, type: !10, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: false, unit: !0, variables: !2)
 !10 = !DISubroutineType(types: !11)
 !11 = !{!5}
 !12 = !DILocation(line: 3, column: 10, scope: !9)

unittests/IR/MetadataTest.cpp

TEST_F(DIGlobalVariableTest, get) {
   DIFile *File = getFile();
   unsigned Line = 5;
   DIType *Type = getDerivedType();
   bool IsLocalToUnit = false;
   bool IsDefinition = true;
   DIDerivedType *StaticDataMemberDeclaration =
       cast<DIDerivedType>(getDerivedType());
   uint32_t AlignInBits = 8;
+  DICompileUnit *Unit = getUnit();
 
-  auto *N = DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
-                                  Type, IsLocalToUnit, IsDefinition,
-                                  StaticDataMemberDeclaration, AlignInBits);
+  auto *N = DIGlobalVariable::get(
+      Context, Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
+      IsDefinition, StaticDataMemberDeclaration, AlignInBits, Unit);
   EXPECT_EQ(dwarf::DW_TAG_variable, N->getTag());
   EXPECT_EQ(Scope, N->getScope());
   EXPECT_EQ(Name, N->getName());
   EXPECT_EQ(LinkageName, N->getLinkageName());
   EXPECT_EQ(File, N->getFile());
   EXPECT_EQ(Line, N->getLine());
   EXPECT_EQ(Type, N->getType());
   EXPECT_EQ(IsLocalToUnit, N->isLocalToUnit());
   EXPECT_EQ(IsDefinition, N->isDefinition());
   EXPECT_EQ(StaticDataMemberDeclaration, N->getStaticDataMemberDeclaration());
   EXPECT_EQ(AlignInBits, N->getAlignInBits());
+  EXPECT_EQ(Unit, N->getUnit());
   EXPECT_EQ(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
                                      Line, Type, IsLocalToUnit, IsDefinition,
-                                     StaticDataMemberDeclaration, AlignInBits));
+                                     StaticDataMemberDeclaration, AlignInBits,
+                                     Unit));
 
-  EXPECT_NE(N,
-            DIGlobalVariable::get(Context, getSubprogram(), Name, LinkageName,
-                                  File, Line, Type, IsLocalToUnit, IsDefinition,
-                                  StaticDataMemberDeclaration, AlignInBits));
+  EXPECT_NE(
+      N, DIGlobalVariable::get(Context, getSubprogram(), Name, LinkageName,
+                               StaticDataMemberDeclaration, AlignInBits, Unit));
   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, "other", LinkageName, File,
                                      Line, Type, IsLocalToUnit, IsDefinition,
-                                     StaticDataMemberDeclaration, AlignInBits));
+                                     StaticDataMemberDeclaration, AlignInBits,
+                                     Unit));
   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, "other", File, Line,
                                      Type, IsLocalToUnit, IsDefinition,
-                                     StaticDataMemberDeclaration, AlignInBits));
-  EXPECT_NE(N,
-            DIGlobalVariable::get(Context, Scope, Name, LinkageName, getFile(),
-                                  Line, Type, IsLocalToUnit, IsDefinition,
-                                  StaticDataMemberDeclaration, AlignInBits));
-  EXPECT_NE(N,
-            DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
-                                  Line + 1, Type, IsLocalToUnit, IsDefinition,
-                                  StaticDataMemberDeclaration, AlignInBits));
-  EXPECT_NE(N,
-            DIGlobalVariable::get(Context, Scope, Name, LinkageName, File, Line,
-                                  getDerivedType(), IsLocalToUnit, IsDefinition,
-                                  StaticDataMemberDeclaration, AlignInBits));
+                                     StaticDataMemberDeclaration, AlignInBits,
+                                     Unit));
+  EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName,
+                                     getFile(), Line, Type, IsLocalToUnit,
+                                     IsDefinition, StaticDataMemberDeclaration,
+                                     AlignInBits, Unit));
+  EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
+                                     Line + 1, Type, IsLocalToUnit,
+                                     IsDefinition, StaticDataMemberDeclaration,
+                                     AlignInBits, Unit));
+  EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
+                                     Line, getDerivedType(), IsLocalToUnit,
+                                     IsDefinition, StaticDataMemberDeclaration,
+                                     AlignInBits, Unit));
   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
                                      Line, Type, !IsLocalToUnit, IsDefinition,
-                                     StaticDataMemberDeclaration, AlignInBits));
+                                     StaticDataMemberDeclaration, AlignInBits,
+                                     Unit));
   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
                                      Line, Type, IsLocalToUnit, !IsDefinition,
-                                     StaticDataMemberDeclaration, AlignInBits));
+                                     StaticDataMemberDeclaration, AlignInBits,
+                                     Unit));
   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
                                      Line, Type, IsLocalToUnit, IsDefinition,
                                      cast<DIDerivedType>(getDerivedType()),
-                                     AlignInBits));
+                                     AlignInBits, Unit));
   EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
                                      Line, Type, IsLocalToUnit, IsDefinition,
                                      StaticDataMemberDeclaration,
-                                     (AlignInBits << 1)));
+                                     (AlignInBits << 1), Unit));
+  EXPECT_NE(N, DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
+                                     Line, Type, IsLocalToUnit, IsDefinition,
+                                     StaticDataMemberDeclaration, AlignInBits,
+                                     nullptr));
 
   TempDIGlobalVariable Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 typedef MetadataTest DIGlobalVariableExpressionTest;
 
 TEST_F(DIGlobalVariableExpressionTest, get) {
   DIScope *Scope = getSubprogram();
   StringRef Name = "name";
   StringRef LinkageName = "linkage";
   DIFile *File = getFile();
   unsigned Line = 5;
   DIType *Type = getDerivedType();
   bool IsLocalToUnit = false;
   bool IsDefinition = true;
   auto *Expr = DIExpression::get(Context, {1, 2});
   auto *Expr2 = DIExpression::get(Context, {1, 2, 3});
   DIDerivedType *StaticDataMemberDeclaration =
       cast<DIDerivedType>(getDerivedType());
   uint32_t AlignInBits = 8;
+  DICompileUnit *Unit = getUnit();
 
   auto *Var = DIGlobalVariable::get(Context, Scope, Name, LinkageName, File,
                                     Line, Type, IsLocalToUnit, IsDefinition,
-                                    StaticDataMemberDeclaration, AlignInBits);
+                                    StaticDataMemberDeclaration, AlignInBits, Unit);
   auto *Var2 = DIGlobalVariable::get(Context, Scope, "other", LinkageName, File,
                                      Line, Type, IsLocalToUnit, IsDefinition,
-                                     StaticDataMemberDeclaration, AlignInBits);
+                                     StaticDataMemberDeclaration, AlignInBits, Unit);
   auto *N = DIGlobalVariableExpression::get(Context, Var, Expr);
 
   EXPECT_EQ(Var, N->getVariable());
   EXPECT_EQ(Expr, N->getExpression());
   EXPECT_EQ(N, DIGlobalVariableExpression::get(Context, Var, Expr));
   EXPECT_NE(N, DIGlobalVariableExpression::get(Context, Var2, Expr));
   EXPECT_NE(N, DIGlobalVariableExpression::get(Context, Var, Expr2));