dsymutil: Follow references to clang modules and recursively clone the debug info

[aprantl]

Summary

This patch teaches llvm-dsymutil to follow references to clang modules and recursively clone the debug info therein.
This does not yet resolve external type references.

[aprantl]

Got rid of ModuleDIEAlloc.

[friss]

test/tools/dsymutil/X86/modules.map

2–9

The name of that file is a bit confusing because of the context it addresses. I'd like to see the actual module map file committed, and if you could rework that test to look like the other newer ones (and thus get rid of this map in favor of dummy-debug-map.map), this would be great.

test/tools/dsymutil/X86/modules.test

4

Is that copying really necessary?

5–6

I usually ditch the tmp file in favor of -o - | llvm-dwarfdump

tools/dsymutil/DwarfLinker.cpp

395

I think that for your work, this line would be sufficient in this loop. The rest will be needed for --update support, but I need to first figure out accelerator tables.

1145–1146

Can you do that refactoring in a preparatory NFC commit?

1479

StringSet?

1499–1501

Making that a static helper could be a separate NFC commit too, right?

2653–2657

Took me some time to remember why we need that (or rather why we didn't need it before). Usually, the last DIE is always a NULL. It can happen that the input file is just a single compile_unit DIE though and that would crash here because we don't have a terminating NULL. A comment explaining that we should do that optimization would be nice.

3119–3121

It might help the reader if there was a comment describing the layout of debug info containing a module reference so that it's trivial to understand how this function works.

3174

this should be sys::TimeValue::PosixZeroTime().

3188

That condition seems unlikely to trigger.

tools/dsymutil/dsymutil.h

31

Separate NFC patch?

[aprantl]

tools/dsymutil/DwarfLinker.cpp

1145–1146

248310

1499–1501

248311

tools/dsymutil/dsymutil.h

31

248312

[aprantl]

Addressed remaining review feedback. Thanks!

[friss]

LGTM once you address one nit:

tools/dsymutil/DwarfLinker.cpp

2653–2656

The next DIE isn't usually NULL, but it is usually valid because there's nearly always at least a NULL after it.

[aprantl]

Thanks, r248331.

test/tools/dsymutil/X86/modules.map

+---
+triple:          'x86_64-apple-darwin'
+objects:         
+  - filename:        /Inputs/modules.macho.x86_64
+    timestamp:       1442276341
+    symbols:         
+      - { sym: _main, objAddr: 0x0000000000000000, binAddr: 0x0000000100000F90, size: 0x0000001E }
+...

test/tools/dsymutil/X86/modules.test

+RUN: rm -rf %T/modules
+RUN: mkdir -p %T/modules
+RUN: cat %p/modules.map > %T/modules/modules.map
+RUN: llvm-dsymutil -y -f -oso-prepend-path=%p/.. %T/modules/modules.map -o %t.dSYM
+RUN: llvm-dwarfdump --debug-dump=info %t.dSYM | FileCheck %s
+
+
+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"
+
+struct Bar {
+  int value;
+};
+
+Foo.h
+-----
+CHECK: DW_TAG_compile_unit
+CHECK:   DW_TAG_module
+CHECK-NEXT: DW_AT_name{{.*}}"Foo"
+CHECK:      DW_TAG_typedef
+#include "Bar.h"
+typedef struct Bar Bar;
+
+modules.c
+---------
+
+CHECK: DW_TAG_compile_unit
+CHECK:   DW_TAG_subprogram
+CHECK:     DW_AT_name {{.*}}"main"
+// clang -cc1 -emit-obj -fmodules -fimplicit-module-maps -fmodule-format=obj -dwarf-ext-refs -fmodules-cache-path=. -fdisable-module-hash modules.c
+// /usr/bin/ld -demangle -dynamic -arch x86_64 -macosx_version_min 10.10.0 -o modules modules.o -lSystem
+#include "Foo.h"
+int main(int argc, char **argv) {
+  Bar bar;
+  bar.value = 42;
+  return bar.value;
+}
+

tools/dsymutil/DwarfLinker.cpp

const std::vector<PatchLocation> &getRangesAttributes() const {
     return RangeAttributes;
   }
 
   const std::vector<std::pair<PatchLocation, int64_t>> &
   getLocationAttributes() const {
     return LocationAttributes;
   }
 
+  void setHasInterestingContent() { HasInterestingContent = true; }
+  bool hasInterestingContent() { return HasInterestingContent; }
+
+  /// Mark every DIE in this unit as kept. This function also
+  /// marks variables as InDebugMap so that they appear in the
+  /// reconstructed accelerator tables.
+  void markEverythingAsKept();
+
   /// \brief Compute the end offset for this unit. Must be
   /// called after the CU's DIEs have been cloned.
   /// \returns the next unit offset (which is also the current
   /// debug_info section size).
   uint64_t computeNextUnitOffset();
 
   /// \brief Keep track of a forward reference to DIE \p Die in \p
   /// RefUnit by \p Attr. The attribute should be fixed up later to
private:
   std::vector<AccelInfo> Pubtypes;
   /// @}
 
   /// 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;
 };
 
+static bool inFunctionScope(CompileUnit &U, unsigned Idx) {
+  if (Idx == 0)
+    return false;
+  if (U.getOrigUnit().getDIEAtIndex(Idx)->getTag() == dwarf::DW_TAG_subprogram)
+    return true;
+  return inFunctionScope(U, U.getInfo(Idx).ParentIdx);
+}
+
+void CompileUnit::markEverythingAsKept() {
+  unsigned Idx = 0;
+
+  for (auto &I : Info) {
+    I.Keep = true;
+    const auto *DIE = OrigUnit.getDIEAtIndex(Idx++);
+
+    // Try to guess which DIEs must go to the accelerator tables. We
+    // do that just for variables, because functions will be handled
+    // depending on wether they carry a DW_AT_low_pc attribute or not.
+    if (DIE->getTag() != dwarf::DW_TAG_variable &&
+         DIE->getTag() != dwarf::DW_TAG_constant)
+      continue;
+    DWARFFormValue Value;
+    if (!DIE->getAttributeValue(&OrigUnit, dwarf::DW_AT_location, Value)) {
+      if (DIE->getAttributeValue(&OrigUnit, dwarf::DW_AT_const_value, Value) &&
+          !inFunctionScope(*this, I.ParentIdx))
+        I.InDebugMap = true;
+      continue;
+    }
+    if (auto Block = Value.getAsBlock()) {
+      if (Block->size() >= OrigUnit.getAddressByteSize() + 1 &&
+          (*Block)[0] == dwarf::DW_OP_addr)
+        I.InDebugMap = true;
+    }
+  }
+}
+
 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)
     NextUnitOffset += CUDie->getSize();
   return NextUnitOffset;
public:
   ~DwarfLinker() {
     for (auto *Abbrev : Abbreviations)
       delete Abbrev;
   }
 
   /// \brief Link the contents of the DebugMap.
   bool link(const DebugMap &);
 
+  void reportWarning(const Twine &Warning, const DWARFUnit *Unit = nullptr,
+                     const DWARFDebugInfoEntryMinimal *DIE = nullptr) const;
+
 private:
   /// \brief Called at the start of a debug object link.
   void startDebugObject(DWARFContext &, DebugMapObject &);
 
   /// \brief Called at the end of a debug object link.
   void endDebugObject();
 
   /// Keeps track of relocations.
private:
   /// @{
   /// \brief Recursively walk the \p DIE tree and look for DIEs to
   /// keep. Store that information in \p CU's DIEInfo.
   void lookForDIEsToKeep(RelocationManager &RelocMgr,
                          const DWARFDebugInfoEntryMinimal &DIE,
                          const DebugMapObject &DMO, CompileUnit &CU,
                          unsigned Flags);
 
+  /// If this CU is really a skeleton clang module reference,
+  /// register it in ClangModules and return true.
+  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);
+
   /// \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.
     TF_SkipPC = 1 << 5,          ///< Skip all location attributes.
private:
   /// @}
 
   /// ODR Contexts for that link.
   DeclContextTree ODRContexts;
 
   /// \defgroup Helpers Various helper methods.
   ///
   /// @{
-  const DWARFDebugInfoEntryMinimal *
-  resolveDIEReference(const DWARFFormValue &RefValue, const DWARFUnit &Unit,
-                      const DWARFDebugInfoEntryMinimal &DIE,
-                      CompileUnit *&ReferencedCU);
-
-  CompileUnit *getUnitForOffset(unsigned Offset);
-
-  void reportWarning(const Twine &Warning, const DWARFUnit *Unit = nullptr,
-                     const DWARFDebugInfoEntryMinimal *DIE = nullptr) const;
-
   bool createStreamer(Triple TheTriple, StringRef OutputFilename);
 
   /// \brief Attempt to load a debug object from disk.
   ErrorOr<const object::ObjectFile &> loadObject(BinaryHolder &BinaryHolder,
                                                  DebugMapObject &Obj,
                                                  const DebugMap &Map);
   /// @}
 
-private:
   std::string OutputFilename;
   LinkOptions Options;
   BinaryHolder BinHolder;
   std::unique_ptr<DwarfStreamer> Streamer;
   uint64_t OutputDebugInfoSize;
+  unsigned UnitID; ///< A unique ID that identifies each compile unit.
 
   /// The units of the current debug map object.
   std::vector<CompileUnit> Units;
 
   /// The debug map object curently under consideration.
   DebugMapObject *CurrentDebugObject;
 
   /// \brief The Dwarf string pool
private:
   /// section. The actual CIE data serves a the key to this StringMap,
   /// this takes care of comparing the semantics of CIEs defined in
   /// different object files.
   StringMap<uint32_t> EmittedCIEs;
 
   /// Offset of the last CIE that has been emitted in the output
   /// debug_frame section.
   uint32_t LastCIEOffset;
+
+  /// FIXME: We may need to use something more resilient than the PCM filename.
+  StringMap<bool> ClangModules;
+  BumpPtrAllocator ModuleDIEAlloc;
 };
 
-/// \brief Similar to DWARFUnitSection::getUnitForOffset(), but
-/// returning our CompileUnit object instead.
-CompileUnit *DwarfLinker::getUnitForOffset(unsigned Offset) {
+/// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
+/// CompileUnit object instead.
+static CompileUnit *getUnitForOffset(MutableArrayRef<CompileUnit> Units,
+                                     unsigned Offset) {
   auto CU =
       std::upper_bound(Units.begin(), Units.end(), Offset,
                        [](uint32_t LHS, const CompileUnit &RHS) {
                          return LHS < RHS.getOrigUnit().getNextUnitOffset();
                        });
   return CU != Units.end() ? &*CU : nullptr;
 }
 
-/// \brief Resolve the DIE attribute reference that has been
+/// Resolve the DIE attribute reference that has been
 /// extracted in \p RefValue. The resulting DIE migh be in another
 /// CompileUnit which is stored into \p ReferencedCU.
 /// \returns null if resolving fails for any reason.
-const DWARFDebugInfoEntryMinimal *DwarfLinker::resolveDIEReference(
+static const DWARFDebugInfoEntryMinimal *resolveDIEReference(
+    const DwarfLinker &Linker, MutableArrayRef<CompileUnit> Units,
     const DWARFFormValue &RefValue, const DWARFUnit &Unit,
     const DWARFDebugInfoEntryMinimal &DIE, CompileUnit *&RefCU) {
   assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
   uint64_t RefOffset = *RefValue.getAsReference(&Unit);
 
-  if ((RefCU = getUnitForOffset(RefOffset)))
+  if ((RefCU = getUnitForOffset(Units, RefOffset)))
     if (const auto *RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset))
       return RefDie;
 
-  reportWarning("could not find referenced DIE", &Unit, &DIE);
+  Linker.reportWarning("could not find referenced DIE", &Unit, &DIE);
   return nullptr;
 }
 
 /// \returns whether the passed \a Attr type might contain a DIE
 /// reference suitable for ODR uniquing.
 static bool isODRAttribute(uint16_t Attr) {
   switch (Attr) {
   default:
for (const auto &AttrSpec : Abbrev->attributes()) {
     if (!Val.isFormClass(DWARFFormValue::FC_Reference)) {
       DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset, &Unit);
       continue;
     }
 
     Val.extractValue(Data, &Offset, &Unit);
     CompileUnit *ReferencedCU;
     if (const auto *RefDIE =
-            resolveDIEReference(Val, Unit, Die, ReferencedCU)) {
+            resolveDIEReference(*this, MutableArrayRef<CompileUnit>(Units),
+                                Val, Unit, Die, ReferencedCU)) {
       uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDIE);
       CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefIdx);
       // If the referenced DIE has a DeclContext that has already been
       // emitted, then do not keep the one in this CU. We'll link to
       // the canonical DIE in cloneDieReferenceAttribute.
       // FIXME: compatibility with dsymutil-classic. UseODR shouldn't
       // be necessary and could be advantageously replaced by
       // ReferencedCU->hasODR() && CU.hasODR().
unsigned DwarfLinker::DIECloner::cloneDieReferenceAttribute(
     CompileUnit &Unit) {
   const DWARFUnit &U = Unit.getOrigUnit();
   uint32_t Ref = *Val.getAsReference(&U);
   DIE *NewRefDie = nullptr;
   CompileUnit *RefUnit = nullptr;
   DeclContext *Ctxt = nullptr;
 
   const DWARFDebugInfoEntryMinimal *RefDie =
-      Linker.resolveDIEReference(Val, U, InputDIE, RefUnit);
+    resolveDIEReference(Linker, CompileUnits, Val, U, InputDIE, RefUnit);
 
   // If the referenced DIE is not found,  drop the attribute.
   if (!RefDie)
     return 0;
 
   unsigned Idx = RefUnit->getOrigUnit().getDIEIndex(RefDie);
   CompileUnit::DIEInfo &RefInfo = RefUnit->getInfo(Idx);
 
if (Unit.hasODR() && Die->getTag() != dwarf::DW_TAG_namespace && Info.Ctxt &&
     // 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());
   }
 
   // Extract and clone every attribute.
   DataExtractor Data = U.getDebugInfoExtractor();
-  uint32_t NextOffset = U.getDIEAtIndex(Idx + 1)->getOffset();
+  uint32_t NextOffset =
+    (Idx + 1 < U.getNumDIEs())
+    ? U.getDIEAtIndex(Idx + 1)->getOffset()
+    : U.getNextUnitOffset();
   AttributesInfo AttrInfo;
 
   // We could copy the data only if we need to aply a relocation to
   // it. After testing, it seems there is no performance downside to
   // doing the copy unconditionally, and it makes the code simpler.
   SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
   Data = DataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
   // Modify the copy with relocated addresses.
   if (RelocMgr.applyValidRelocs(DIECopy, Offset, Data.isLittleEndian())) {
for (const auto &Attr : Abbrev.attributes()) {
     if (hasODR && isODRAttribute(Attr.Attr))
       Form = dwarf::DW_FORM_ref_addr;
     Copy.AddAttribute(dwarf::Attribute(Attr.Attr), dwarf::Form(Form));
   }
 
   Linker.AssignAbbrev(Copy);
 }
 
+bool DwarfLinker::registerModuleReference(
+    const DWARFDebugInfoEntryMinimal &CUDie, const DWARFUnit &Unit,
+    DebugMap &ModuleMap, unsigned Indent) {
+  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, "");
+
+  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, 0});
+  loadClangModule(PCMfile, PCMpath, 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) {
+  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::MinTime());
+  auto ErrOrObj = loadObject(ObjHolder, Obj, ModuleMap);
+  if (!ErrOrObj) {
+    ClangModules.erase(ClangModules.find(Filename));
+    return;
+  }
+
+  CompileUnit *Unit = nullptr;
+
+  // Setup access to the debug info.
+  DWARFContextInMemory DwarfContext(*ErrOrObj);
+  RelocationManager RelocMgr(*this);
+  for (const auto &CU : DwarfContext.compile_units()) {
+    auto *CUDie = CU->getUnitDIE(false);
+    if (false && Options.Verbose) {
+      outs().indent(Indent);
+      outs() << "Input compilation unit:";
+      CUDie->dump(outs(), CU.get(), 0, Indent);
+    }
+    // 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->setHasInterestingContent();
+      gatherDIEParents(CUDie, 0, *Unit, &ODRContexts.getRoot(), StringPool,
+                       ODRContexts);
+      // Keep everything.
+      Unit->markEverythingAsKept();
+    }
+  }
+  if (Options.Verbose) {
+    outs().indent(Indent);
+    outs() << "cloning .debug_info from " << Filename << "\n";
+  }
+
+  // Performance note: If this is DWARF 3 or greater, we could pass in
+  // the regular DIEAlloc.
+  DIECloner(*this, RelocMgr, ModuleDIEAlloc,
+            MutableArrayRef<CompileUnit>(*Unit), Options)
+      .cloneAllCompileUnits(DwarfContext);
+}
+
 void DwarfLinker::DIECloner::cloneAllCompileUnits(
     DWARFContextInMemory &DwarfContext) {
   if (!Linker.Streamer)
     return;
 
   for (auto &CurrentUnit : CompileUnits) {
     const auto *InputDIE = CurrentUnit.getOrigUnit().getUnitDIE();
     CurrentUnit.setStartOffset(Linker.OutputDebugInfoSize);

 bool DwarfLinker::link(const DebugMap &Map) {
 
   if (!createStreamer(Map.getTriple(), OutputFilename))
     return false;
 
   // Size of the DIEs (and headers) generated for the linked output.
   OutputDebugInfoSize = 0;
   // A unique ID that identifies each compile unit.
-  unsigned UnitID = 0;
+  UnitID = 0;
+  DebugMap ModuleMap(Map.getTriple(), Map.getBinaryPath());
+
   for (const auto &Obj : Map.objects()) {
     CurrentDebugObject = Obj.get();
 
     if (Options.Verbose)
       outs() << "DEBUG MAP OBJECT: " << Obj->getObjectFilename() << "\n";
     auto ErrOrObj = loadObject(BinHolder, *Obj, Map);
     if (!ErrOrObj)
       continue;
for (const auto &Obj : Map.objects()) {
     // In a first phase, just read in the debug info and store the DIE
     // 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(),
                          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.
     for (auto &CurrentUnit : Units)
       lookForDIEsToKeep(RelocMgr, *CurrentUnit.getOrigUnit().getUnitDIE(), *Obj,

tools/dsymutil/dsymutil.h

 
 namespace llvm {
 namespace dsymutil {
 
 struct LinkOptions {
   bool Verbose;  ///< Verbosity
   bool NoOutput; ///< Skip emitting output
   bool NoODR;    ///< Do not unique types according to ODR
-
+  std::string PrependPath; //< -oso-prepend-path
   LinkOptions() : Verbose(false), NoOutput(false) {}
 };
 
 /// \brief Extract the DebugMaps from the given file.
 /// The file has to be a MachO object file. Multiple debug maps can be
 /// returned when the file is universal (aka fat) binary.
 llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
 parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,

tools/dsymutil/dsymutil.cpp

int main(int argc, char **argv) {
   if (Version) {
     llvm::cl::PrintVersionMessage();
     return 0;
   }
 
   Options.Verbose = Verbose;
   Options.NoOutput = NoOutput;
   Options.NoODR = NoODR;
+  Options.PrependPath = OsoPrependPath;
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
 
   if (!FlatOut && OutputFileOpt == "-") {
     llvm::errs() << "error: cannot emit to standard output without --flat\n";