dsymutil: Resolve forward decls for types defined in clang modules.

[aprantl]

Summary

This patch extends llvm-dsymutil's ODR type uniquing machinery to also resolve forward decls for types defined in clang modules.

[aprantl]

Rebased patch.

[friss]

Basically looks good. Some comments/questions:

tools/dsymutil/DwarfLinker.cpp

1665–1677

I like the simplicity of adding modules as some kind of namespace. The fact that we hash the Tag here prevents us from uniquing what's in a module and standard namespaces. However the FIXME above only talks about backward compatibility. Maybe we should remove that FIXME and instead explain that it avoid conflicts between modules and other Decl scopes (and add a small note about preventing uniquing a struct with a class of the same name, but that this corner case doesn't warrant making that conditional).

1755–1756

We should really rename that and change the comment (it should have done before, but your patch makes it even more meaningless). Maybe gatherInitialDIEInfo ? Or gatherDIEScopes ? Pick whichever you want (or an even more awesome name that I couldn't come up with).

1805–1810

Wouldn't that logic always prune the TAG_module? or am I reading this wrong?

2223–2224

I would have expected Prune to override Keep. What is the '&& !AlreadyKept' handling?

[aprantl]

tools/dsymutil/DwarfLinker.cpp

1805–1810

It will prune all DW_TAG_modules that have no children or whose children were pruned.
But what about imported empty modules? (See below).

2223–2224

It's handling an otherwise pruned (but imported) DW_TAG_module.

[aprantl]

Address review comments.

tools/dsymutil/DwarfLinker.cpp

1665–1677

The fact that we hash the Tag here prevents us from uniquing what's in a module and standard namespaces.

Even if we wouldn't hash the Tag, we would still hash the module's name (NameRef) which is crucial in order to support (Obj)C because it is legal to have conflicting definitions for the same type in two differently named modules.

In order to support uniquing in C++ between module types and other types, we should change clang to not emit C++ types inside a DW_TAG_module instead.

1755–1756

I tried analyzeContextInfo(). We can still rename it if we can come up with something better.

[friss]

tools/dsymutil/DwarfLinker.cpp

1665–1677

The fact that we hash the Tag here prevents us from uniquing what's in a module and standard namespaces.

Even if we wouldn't hash the Tag, we would still hash the module's name (NameRef) which is crucial in order to support (Obj)C because it is legal to have conflicting definitions for the same type in two differently named modules.

Yes, I know that. I'm thinking of something different. Let's take a C++ program that uses a module called Foo. If the same program has a namespace called Foo (unrelated to the module), then we could have ODR uniquing collisions between unrelated things if we didn't hash the Tag.

I'm just saying that we should promote the FIXME comment from a bug I wanted to remove to a feature that's needed.

1755–1767

I tried analyzeContextInfo(). We can still rename it if we can come up with something better.

Sounds good.

1805–1810

It will prune all DW_TAG_modules that have no children or whose children were pruned.

Sorry I misread the code. Can you add a comment to the function explaining the meaning of the return value please?

[friss]

test/tools/dsymutil/X86/modules.m

59–73

Could you make all the CHECKs in this test a bit more rigorous? (some more CHECK-NOT DW_TAG|NULL)

[aprantl]

• made the tests stricter
• clarified comments

tools/dsymutil/DwarfLinker.cpp

1665–1677

Got it now. I thought you were getting at that we aren't be able to unique types if one file imports a module and a second file is compiled without -fmodules and just #includes the module header.

[aprantl]

• add a comment about the return value of analyzeContextInfo().

[friss]

You'll need to to rebase to the latest sources, but this LGTM.

Thanks!

[aprantl]

Thanks!
Committed as r248398

test/tools/dsymutil/X86/modules.m

 
 // RUN: llvm-dsymutil -f -oso-prepend-path=%p/../Inputs/modules \
 // RUN:   -y %p/dummy-debug-map.map -o - \
 // RUN:     | llvm-dwarfdump --debug-dump=info - | FileCheck %s
 
 // ---------------------------------------------------------------------
 #ifdef BAR_H
 // ---------------------------------------------------------------------
-// CHECK: DW_TAG_compile_unit
-// CHECK:   DW_TAG_module
-// CHECK-NEXT: DW_AT_name {{.*}}"Bar"
-// CHECK:   DW_TAG_member
-// CHECK:     DW_AT_name {{.*}}"value"
+// CHECK:            DW_TAG_compile_unit
+// CHECK-NOT:        DW_TAG
+// CHECK:              DW_TAG_module
+// CHECK-NEXT:           DW_AT_name{{.*}}"Bar"
+// CHECK-NOT:            DW_TAG
+// CHECK: 0x0[[BAR:.*]]: DW_TAG_structure_type
+// CHECK:                  DW_AT_name {{.*}}"Bar"
+// CHECK-NOT:              DW_TAG
+// CHECK:                  DW_TAG_member
+// CHECK:                    DW_AT_name {{.*}}"value"
 
 struct Bar {
   int value;
 };
 
 #else
 // ---------------------------------------------------------------------
 #ifdef FOO_H
 // ---------------------------------------------------------------------
-// CHECK: 55{{.*}}DW_TAG_compile_unit
-// CHECK:   DW_TAG_module
-// CHECK-NEXT: DW_AT_name {{.*}}"Foo"
-// CHECK:      DW_TAG_typedef
+// CHECK:               DW_TAG_compile_unit
+// CHECK-NOT:             DW_TAG
+// CHECK: 0x0[[FOO:.*]]:  DW_TAG_module
+// CHECK-NEXT:              DW_AT_name{{.*}}"Foo"
+// CHECK-NOT:               DW_TAG
+// CHECK:                   DW_TAG_typedef
 @import Bar;
 typedef struct Bar Bar;
 struct S {};
 
 // ---------------------------------------------------------------------
 #else
 // ---------------------------------------------------------------------
 
-// CHECK: DW_TAG_compile_unit
+// CHECK:   DW_TAG_compile_unit
+// CHECK:     DW_TAG_module
+// CHECK-NEXT:  DW_AT_name{{.*}}"Bar"
+// CHECK:     DW_TAG_module
+// CHECK-NEXT:  DW_AT_name{{.*}}"Foo"
+// CHECK-NOT:   DW_TAG
+// CHECK:       DW_TAG_typedef
+// CHECK-NOT:     DW_TAG
+// CHECK:         DW_AT_type [DW_FORM_ref_addr] (0x{{0*}}[[BAR]])
+//
+// CHECK:   DW_TAG_imported_declaration
+// CHECK-NOT: DW_TAG
+// CHECK:     DW_AT_import [DW_FORM_ref_addr] (0x{{0*}}[[FOO]]
+//
 // CHECK:   DW_TAG_subprogram
 // CHECK:     DW_AT_name {{.*}}"main"
 @import Foo;
 int main(int argc, char **argv) {
   Bar bar;
   bar.value = 42;
   return bar.value;
 }
 #endif
 #endif

tools/dsymutil/DwarfLinker.cpp

 class CompileUnit {
 public:
   /// \brief Information gathered about a DIE in the object file.
   struct DIEInfo {
     int64_t AddrAdjust; ///< Address offset to apply to the described entity.
     DeclContext *Ctxt;  ///< ODR Declaration context.
     DIE *Clone;         ///< Cloned version of that DIE.
     uint32_t ParentIdx; ///< The index of this DIE's parent.
-    bool Keep;          ///< Is the DIE part of the linked output?
-    bool InDebugMap;    ///< Was this DIE's entity found in the map?
+    bool Keep : 1;      ///< Is the DIE part of the linked output?
+    bool InDebugMap : 1;///< Was this DIE's entity found in the map?
+    bool Prune : 1;     ///< Is this a pure forward declaration we can strip?
   };
 
-  CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR)
+  CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
+              StringRef ClangModuleName)
       : OrigUnit(OrigUnit), ID(ID), LowPc(UINT64_MAX), HighPc(0), RangeAlloc(),
-        Ranges(RangeAlloc) {
+        Ranges(RangeAlloc), ClangModuleName(ClangModuleName) {
     Info.resize(OrigUnit.getNumDIEs());
 
     const auto *CUDie = OrigUnit.getUnitDIE(false);
     unsigned Lang = CUDie->getAttributeValueAsUnsignedConstant(
         &OrigUnit, dwarf::DW_AT_language, 0);
     HasODR = CanUseODR && (Lang == dwarf::DW_LANG_C_plus_plus ||
                            Lang == dwarf::DW_LANG_C_plus_plus_03 ||
                            Lang == dwarf::DW_LANG_C_plus_plus_11 ||
public:
   DWARFUnit &getOrigUnit() const { return OrigUnit; }
 
   unsigned getUniqueID() const { return ID; }
 
   DIE *getOutputUnitDIE() const { return CUDie; }
   void setOutputUnitDIE(DIE *Die) { CUDie = Die; }
 
   bool hasODR() const { return HasODR; }
+  bool isClangModule() const { return !ClangModuleName.empty(); }
+  const std::string &getClangModuleName() const { return ClangModuleName; }
 
   DIEInfo &getInfo(unsigned Idx) { return Info[Idx]; }
   const DIEInfo &getInfo(unsigned Idx) const { return Info[Idx]; }
 
   uint64_t getStartOffset() const { return StartOffset; }
   uint64_t getNextUnitOffset() const { return NextUnitOffset; }
   void setStartOffset(uint64_t DebugInfoSize) { StartOffset = DebugInfoSize; }
 
private:
 
   /// Cached resolved paths from the line table.
   std::vector<std::string> ResolvedPaths;
 
   /// Is this unit subject to the ODR rule?
   bool HasODR;
   /// Did a DIE actually contain a valid reloc?
   bool HasInterestingContent;
+  /// If this is a Clang module, this holds the module's name.
+  std::string ClangModuleName;
 };
 
 void CompileUnit::markEverythingAsKept() {
   for (auto &I : Info)
-    I.Keep = true;
+    // Mark everything that wasn't explicity marked for pruning.
+    I.Keep = !I.Prune;
 }
 
 uint64_t CompileUnit::computeNextUnitOffset() {
   NextUnitOffset = StartOffset + 11 /* Header size */;
   // The root DIE might be null, meaning that the Unit had nothing to
   // contribute to the linked output. In that case, we will emit the
   // unit header without any actual DIE.
   if (CUDie)
private:
   bool registerModuleReference(const DWARFDebugInfoEntryMinimal &CUDie,
                                const DWARFUnit &Unit, DebugMap &ModuleMap,
                                unsigned Indent = 0);
 
   /// Recursively add the debug info in this clang module .pcm
   /// file (and all the modules imported by it in a bottom-up fashion)
   /// to Units.
   void loadClangModule(StringRef Filename, StringRef ModulePath,
-                       DebugMap &ModuleMap, unsigned Indent = 0);
+                       StringRef ModuleName, DebugMap &ModuleMap,
+                       unsigned Indent = 0);
 
   /// \brief Flags passed to DwarfLinker::lookForDIEsToKeep
   enum TravesalFlags {
     TF_Keep = 1 << 0,            ///< Mark the traversed DIEs as kept.
     TF_InFunctionScope = 1 << 1, ///< Current scope is a fucntion scope.
     TF_DependencyWalk = 1 << 2,  ///< Walking the dependencies of a kept DIE.
     TF_ParentWalk = 1 << 3,      ///< Walking up the parents of a kept DIE.
     TF_ODR = 1 << 4,             ///< Use the ODR whhile keeping dependants.
PointerIntPair<DeclContext *, 1> DeclContextTree::getChildDeclContext(
   // FIXME: dsymutil-classic compat: We should bail out here if we
   // have a specification or an abstract_origin. We will get the
   // parent context wrong here.
 
   switch (Tag) {
   default:
     // By default stop gathering child contexts.
     return PointerIntPair<DeclContext *, 1>(nullptr);
+  case dwarf::DW_TAG_module:
+    break;
   case dwarf::DW_TAG_compile_unit:
-    // FIXME: Add support for DW_TAG_module.
     return PointerIntPair<DeclContext *, 1>(&Context);
   case dwarf::DW_TAG_subprogram:
     // Do not unique anything inside CU local functions.
     if ((Context.getTag() == dwarf::DW_TAG_namespace ||
          Context.getTag() == dwarf::DW_TAG_compile_unit) &&
         !DIE->getAttributeValueAsUnsignedConstant(&U.getOrigUnit(),
                                                   dwarf::DW_AT_external, 0))
       return PointerIntPair<DeclContext *, 1>(nullptr);
PointerIntPair<DeclContext *, 1> DeclContextTree::getChildDeclContext(
   std::string File;
   unsigned Line = 0;
   unsigned ByteSize = 0;
 
   // Gather some discriminating data about the DeclContext we will be
   // creating: File, line number and byte size. This shouldn't be
   // necessary, because the ODR is just about names, but given that we
   // do some approximations with overloaded functions and anonymous
-  // namespaces, use these additional data points to make the process safer.
+  // namespaces, use these additional data points to make the process
+  // safer.  This is disabled for clang modules, because forward
+  // declarations of module-defined types do not have a file and line.
   ByteSize = DIE->getAttributeValueAsUnsignedConstant(
       &U.getOrigUnit(), dwarf::DW_AT_byte_size, UINT64_MAX);
-  if (Tag != dwarf::DW_TAG_namespace || !Name) {
+  if (!U.isClangModule() && (Tag != dwarf::DW_TAG_namespace || !Name)) {
     if (unsigned FileNum = DIE->getAttributeValueAsUnsignedConstant(
             &U.getOrigUnit(), dwarf::DW_AT_decl_file, 0)) {
       if (const auto *LT = U.getOrigUnit().getContext().getLineTableForUnit(
               &U.getOrigUnit())) {
         // FIXME: dsymutil-classic compatibility. I'd rather not
         // unique anything in anonymous namespaces, but if we do, then
         // verify that the file and line correspond.
         if (!Name && Tag == dwarf::DW_TAG_namespace)

 #endif
           FileRef = StringPool.internString(File);
         }
       }
     }
   }
 
   if (!Line && NameRef.empty())
     return PointerIntPair<DeclContext *, 1>(nullptr);
   
-  // FIXME: dsymutil-classic compat won't unique the same type
-  // presented once as a struct and once as a class. Use the Tag in
-  // the fully qualified name hash to get the same effect.
   // We hash NameRef, which is the mangled name, in order to get most
-  // overloaded functions resolvec correctly.
+  // overloaded functions resolve correctly.
+  //
+  // Strictly speaking, hashing the Tag is only necessary for a
+  // DW_TAG_module, to prevent uniquing of a module and a namespace
+  // with the same name.
+  //
+  // FIXME: dsymutil-classic won't unique the same type presented
+  // once as a struct and once as a class. Using the Tag in the fully
+  // qualified name hash to get the same effect.
   unsigned Hash = hash_combine(Context.getQualifiedNameHash(), Tag, NameRef);
 
   // FIXME: dsymutil-classic compatibility: when we don't have a name,
   // use the filename.
   if (Tag == dwarf::DW_TAG_namespace && NameRef == "(anonymous namespace)")
     Hash = hash_combine(Hash, FileRef);
 
   // Now look if this context already exists.
   DeclContext Key(Hash, Line, ByteSize, Tag, NameRef, FileRef, Context);

 
 bool DwarfLinker::createStreamer(Triple TheTriple, StringRef OutputFilename) {
   if (Options.NoOutput)
     return true;
 
   Streamer = llvm::make_unique<DwarfStreamer>();
   return Streamer->init(TheTriple, OutputFilename);
 }
 
-/// \brief Recursive helper to gather the child->parent relationships in the
-/// original compile unit.
-static void gatherDIEParents(const DWARFDebugInfoEntryMinimal *DIE,
+/// Recursive helper to build the global DeclContext information and
+/// gather the child->parent relationships in the original compile unit.
+///
+/// \return true when this DIE and all of its children are only
+/// forward declarations to types defined in external clang modules
+/// (i.e., forward declarations that are children of a DW_TAG_module).
+static bool analyzeContextInfo(const DWARFDebugInfoEntryMinimal *DIE,
                                unsigned ParentIdx, CompileUnit &CU,
                                DeclContext *CurrentDeclContext,
                                NonRelocatableStringpool &StringPool,
-                             DeclContextTree &Contexts) {
+                               DeclContextTree &Contexts,
+                               bool InTagModule = false) {
   unsigned MyIdx = CU.getOrigUnit().getDIEIndex(DIE);
   CompileUnit::DIEInfo &Info = CU.getInfo(MyIdx);
 
+  // Clang imposes an ODR on modules(!) regardless of the language:
+  //  "The module-id should consist of only a single identifier,
+  //   which provides the name of the module being defined. Each
+  //   module shall have a single definition."
+  //
+  // This does not extend to the types inside the modules:
+  //  "[I]n C, this implies that if two structs are defined in
+  //   different submodules with the same name, those two types are
+  //   distinct types (but may be compatible types if their
+  //   definitions match)."
+  //
+  // We treat non-C++ modules like namespaces for this reason.
+  if (DIE->getTag() == dwarf::DW_TAG_module)
+    InTagModule = true;
+  
   Info.ParentIdx = ParentIdx;
-  if (CU.hasODR()) {
+  if (CU.hasODR() || CU.isClangModule() || InTagModule) {
     if (CurrentDeclContext) {
       auto PtrInvalidPair = Contexts.getChildDeclContext(*CurrentDeclContext,
                                                          DIE, CU, StringPool);
       CurrentDeclContext = PtrInvalidPair.getPointer();
       Info.Ctxt =
           PtrInvalidPair.getInt() ? nullptr : PtrInvalidPair.getPointer();
     } else
       Info.Ctxt = CurrentDeclContext = nullptr;
   }
 
+  Info.Prune = InTagModule;
   if (DIE->hasChildren())
     for (auto *Child = DIE->getFirstChild(); Child && !Child->isNULL();
          Child = Child->getSibling())
-      gatherDIEParents(Child, MyIdx, CU, CurrentDeclContext, StringPool,
-                       Contexts);
+      Info.Prune &= analyzeContextInfo(Child, MyIdx, CU, CurrentDeclContext,
+                                       StringPool, Contexts, InTagModule);
+
+  // Prune this DIE if it is either a forward declaration inside a
+  // DW_TAG_module or a DW_TAG_module that contains nothing but
+  // forward declarations.
+  Info.Prune &= (DIE->getTag() == dwarf::DW_TAG_module) ||
+                DIE->getAttributeValueAsUnsignedConstant(
+                    &CU.getOrigUnit(), dwarf::DW_AT_declaration, 0);
+
+  return Info.Prune;
 }
 
 static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag) {
   switch (Tag) {
   default:
     return false;
   case dwarf::DW_TAG_subprogram:
   case dwarf::DW_TAG_lexical_block:

 /// traversal we are currently doing.
 void DwarfLinker::lookForDIEsToKeep(RelocationManager &RelocMgr,
                                     const DWARFDebugInfoEntryMinimal &Die,
                                     const DebugMapObject &DMO, CompileUnit &CU,
                                     unsigned Flags) {
   unsigned Idx = CU.getOrigUnit().getDIEIndex(&Die);
   CompileUnit::DIEInfo &MyInfo = CU.getInfo(Idx);
   bool AlreadyKept = MyInfo.Keep;
+  if (MyInfo.Prune && !AlreadyKept)
+    return;
 
   // If the Keep flag is set, we are marking a required DIE's
   // dependencies. If our target is already marked as kept, we're all
   // set.
   if ((Flags & TF_DependencyWalk) && AlreadyKept)
     return;
 
   // We must not call shouldKeepDIE while called from keepDIEAndDependencies,
DIE *DwarfLinker::DIECloner::cloneDIE(
   uint32_t Offset = InputDIE.getOffset();
   // The DIE might have been already created by a forward reference
   // (see cloneDieReferenceAttribute()).
   DIE *Die = Info.Clone;
   if (!Die)
     Die = Info.Clone = DIE::get(DIEAlloc, dwarf::Tag(InputDIE.getTag()));
   assert(Die->getTag() == InputDIE.getTag());
   Die->setOffset(OutOffset);
-  if (Unit.hasODR() && Die->getTag() != dwarf::DW_TAG_namespace && Info.Ctxt &&
+  if ((Unit.hasODR() || Unit.isClangModule()) &&
+      Die->getTag() != dwarf::DW_TAG_namespace && Info.Ctxt &&
       Info.Ctxt != Unit.getInfo(Info.ParentIdx).Ctxt &&
       !Info.Ctxt->getCanonicalDIEOffset()) {
     // We are about to emit a DIE that is the root of its own valid
     // DeclContext tree. Make the current offset the canonical offset
     // for this context.
     Info.Ctxt->setCanonicalDIEOffset(OutOffset + Unit.getStartOffset());
   }
 
std::string PCMfile =
       CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_GNU_dwo_name, "");
   if (PCMfile.empty())
     return false;
 
   // Clang module DWARF skeleton CUs abuse this for the path to the module.
   std::string PCMpath =
       CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_comp_dir, "");
 
+  std::string Name =
+      CUDie.getAttributeValueAsString(&Unit, dwarf::DW_AT_name, "");
+  if (Name.empty()) {
+    reportWarning("Anonymous module skeleton CU for " + PCMfile);
+    return true;
+  }
+
   if (Options.Verbose) {
     outs().indent(Indent);
     outs() << "Found clang module reference " << PCMfile;
   }
 
   if (ClangModules.count(PCMfile)) {
     if (Options.Verbose)
       outs() << " [cached].\n";
     return true;
   }
   if (Options.Verbose)
     outs() << " ...\n";
 
   // Cyclic dependencies are disallowed by Clang, but we still
   // shouldn't run into an infinite loop, so mark it as processed now.
   ClangModules.insert(PCMfile);
-  loadClangModule(PCMfile, PCMpath, ModuleMap, Indent + 2);
+  loadClangModule(PCMfile, PCMpath, Name, ModuleMap, Indent + 2);
   return true;
 }
 
 ErrorOr<const object::ObjectFile &>
 DwarfLinker::loadObject(BinaryHolder &BinaryHolder, DebugMapObject &Obj,
                         const DebugMap &Map) {
   auto ErrOrObjs =
       BinaryHolder.GetObjectFiles(Obj.getObjectFilename(), Obj.getTimestamp());
   if (std::error_code EC = ErrOrObjs.getError()) {
     reportWarning(Twine(Obj.getObjectFilename()) + ": " + EC.message());
     return EC;
   }
   auto ErrOrObj = BinaryHolder.Get(Map.getTriple());
   if (std::error_code EC = ErrOrObj.getError())
     reportWarning(Twine(Obj.getObjectFilename()) + ": " + EC.message());
   return ErrOrObj;
 }
 
 void DwarfLinker::loadClangModule(StringRef Filename, StringRef ModulePath,
-                                  DebugMap &ModuleMap, unsigned Indent) {
+                                  StringRef ModuleName, DebugMap &ModuleMap,
+                                  unsigned Indent) {
   SmallString<80> Path(Options.PrependPath);
   if (sys::path::is_relative(Filename))
     sys::path::append(Path, ModulePath, Filename);
   else
     sys::path::append(Path, Filename);
   BinaryHolder ObjHolder(Options.Verbose);
   auto &Obj =
       ModuleMap.addDebugMapObject(Path, sys::TimeValue::PosixZeroTime());
for (const auto &CU : DwarfContext.compile_units()) {
     // Recursively get all modules imported by this one.
     if (!registerModuleReference(*CUDie, *CU, ModuleMap, Indent)) {
       // Add this module.
       if (Unit) {
         errs() << Filename << ": Clang modules are expected to have exactly"
                << " 1 compile unit.\n";
         exitDsymutil(1);
       }
-      Unit = new CompileUnit(*CU, UnitID++, !Options.NoODR);
+      Unit = new CompileUnit(*CU, UnitID++, !Options.NoODR, ModuleName);
       Unit->setHasInterestingContent();
-      gatherDIEParents(CUDie, 0, *Unit, &ODRContexts.getRoot(), StringPool,
+      analyzeContextInfo(CUDie, 0, *Unit, &ODRContexts.getRoot(), StringPool,
                          ODRContexts);
       // Keep everything.
       Unit->markEverythingAsKept();
     }
   }
   if (Options.Verbose) {
     outs().indent(Indent);
     outs() << "cloning .debug_info from " << Filename << "\n";
   }
for (const auto &Obj : Map.objects()) {
     // parent links that we will use during the next phase.
     for (const auto &CU : DwarfContext.compile_units()) {
       auto *CUDie = CU->getUnitDIE(false);
       if (Options.Verbose) {
         outs() << "Input compilation unit:";
         CUDie->dump(outs(), CU.get(), 0);
       }
       if (!registerModuleReference(*CUDie, *CU, ModuleMap)) {
-        Units.emplace_back(*CU, UnitID++, !Options.NoODR);
-        gatherDIEParents(CUDie, 0, Units.back(), &ODRContexts.getRoot(),
+        Units.emplace_back(*CU, UnitID++, !Options.NoODR, "");
+        analyzeContextInfo(CUDie, 0, Units.back(), &ODRContexts.getRoot(),
                            StringPool, ODRContexts);
       }
     }
 
     // Then mark all the DIEs that need to be present in the linked
     // output and collect some information about them. Note that this
     // loop can not be merged with the previous one becaue cross-cu
     // references require the ParentIdx to be setup for every CU in
     // the object file before calling this.