Allows for dsymutil crashes to generate reproduceable information

[JDevlieghere]

Summary

This change to dsymutil allows for, when dsymutil crashes, the user to collect and submit
the object files and a map file so the crash can be reproduced

[feg208]

Fixed clang-tidy warnings

[feg208]

Missing more clang-tidy checks

[JDevlieghere]

How is collect-crash-inputs different from gan-reproducer? It seems like they're essentially doing the same thing. Can we implement the crash recovery in terms of llvm::dsymutil::Reproducer?

[feg208]

This alters the prior commit by incorporating the Reproducer for the purpose of persisting the files on crash

[feg208]

Forgot to remove raise(SIGSEGV)

[feg208]

Cleans up clang-tidy/format issues and some minor branch pecadillos

[feg208]

clang-format misses

[JDevlieghere]

llvm/tools/dsymutil/Reproducer.cpp

57–80

If we split this into a separate class, this can remain here, and have the crash variant print the "PLEASE ATTACH THE FILES IN THE FOLLOWING DIRECTORY TO THE BUG REPORT" in the generate crash class.

llvm/tools/dsymutil/Reproducer.h

84

I think we probably want a separate class that corresponds to GenerateForCrash.

llvm/tools/dsymutil/dsymutil.cpp

490–491

Spurious newline

713–737

This seems like it should be part of the reproducers class.

[feg208]

Addresses some review comments

[feg208]

I think I addressed all the comments? If so I can't push the changes into the repo. Could you? Assuming there aren't outstanding concerns of course.

[feg208]

Broke a regression test

[feg208]

I am wondering if I could get someone to look at this? I think I have addressed the review comments but I'd be happy to fix anything I missed

[aprantl]

I think I have addressed the review comments but I'd be happy to fix anything I missed

Pinging @JDevlieghere ^

[JDevlieghere]

llvm/tools/dsymutil/Reproducer.cpp

37

This should be consistent with the header. It's fine (and common) to use the same name for the argument and member variable.

38

LLVM generally does not prefer braced initializer lists (https://llvm.org/docs/CodingStandards.html#do-not-use-braced-initializer-lists-to-call-a-constructor)

106

You should use LLVM_FALLTHROUGH, otherwise this won't work if the host compiler is not clang.

108–110

No braces around single line statements (https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements)

llvm/tools/dsymutil/Reproducer.h

24

Maybe GenerateOnCrash?

40

LLVM doesn't use exceptions (and generally builds without them).

50

If we're going to store the root, this might as well take a std::string too and move it into Root.

52

Rather than returning a small string with arbitrary lengths, the common pattern in llvm is to take let the caller decide on the storage type and pass in a llvm::SmallVectorImpl<char>& that the function then populates. This also avoids any potential copies.

llvm/tools/dsymutil/dsymutil.cpp

493–495

I don't think auto is a good fit here (https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable)

682–686

Unrelated whitespace change?

717

721–729

Why is this needed?

751

[feg208]

I rolled up all the comments save one where I just have an outstanding question and then I'll roll that up as well

llvm/tools/dsymutil/Reproducer.cpp

38

Got it. Thanks for passing this along. I really should have reviewed it before this submission but I certainly will before the next

llvm/tools/dsymutil/dsymutil.cpp

682–686

yeah. Sorry it snuck in.

721–729

So my understanding is that when dsymutil crashes we want the mapping.yaml file, the binary and associated .o file (assuming its compiled with -g). The latter maybe for some workflows? Reusing this gets us the object file but at the cost of parsing the debug map. So maybe I should just copy the binary in? I can do that or just parse enough to recreate the object files. Or maybe I am misunderstanding this entirely?

[feg208]

Gets some review comments

[JDevlieghere]

llvm/tools/dsymutil/Reproducer.cpp

56–80

We need the whole directory, so might as well ask the reporter to include it as a whole.

********************
PLEASE ATTACH THE FOLLOWING DIRECTORY TO THE BUG REPORT:

101

The nullptr here is redundant.

llvm/tools/dsymutil/Reproducer.h

40

Don't use auto here, it's not obvious from context what the type is.

llvm/tools/dsymutil/dsymutil.cpp

492

Let's be consistent with all the surrounding code and the style guide.

721–729

744–753

I actually don't think this is going to work. You're creating the reproducer after we've crashed and you're not telling dsymutil to use the VFS from that Reproducer instance. It's the VFS that records all access and is what will allow us to copy all the files in place if we decide we need to keep the reproducer.

The way I would imagine this to work is:

1. Parse the command line options. If we crash at this point we won't have a reproducer, which I think is acceptable.
2. Initialize the reproducer.
3. Call CRC.RunSafely to do the actual work. We pass it the reproducer, so it captures all file accesses, which is everything we need for the reproducer.

4a. If we crash, we generate the reproducer and print the dsymutil invocation to replay the reproducer.
4b. If we don't crash, but --gen-reproducer was passed, we do the same

Does that make sense?

[feg208]

I think this covers the comments

llvm/tools/dsymutil/dsymutil.cpp

492

Oh right. Oops.

744–753

Yeah this makes sense and answers my confusion about the right way to go here.

[feg208]

Rolled up review comments

[feg208]

Fixes the broken tests

[feg208]

This is not yet complete. I missed step 4a. "4a. If we crash, we generate the reproducer and print the dsymutil invocation to replay the reproducer." It currently doesn't print the command line

[feg208]

Added command line print

[feg208]

Clang-tidy checks cleaned up and test fixes

[feg208]

Forgot the clang-tidy checks

[feg208]

I'd just wanted to follow up and see if, minimally, my changes addressed the concerns raised or if you think there is further work here?

[JDevlieghere]

llvm/tools/dsymutil/Reproducer.cpp

106

Why is this a fallthrough? It seems like now, if we fail to create the ReproducerGenerateForCrash instance, we'll try creating a regular ReproducerGenerate and only then print the error message? I think we should just handle the EC immediately.

llvm/tools/dsymutil/Reproducer.h

66–68

Do we still need the ability to specify the mode?

97

100

Why do we need a move ctor?

110

I'm not sure if this is really something we want, with any real-world project the number of object files can quickly become overwhelming. Even if we do, this should probably be a property of the ReproducerGenerate and not be specific for the crash one.

[feg208]

Addresses some review comments

[feg208]

I have a few outstanding questions

llvm/tools/dsymutil/Reproducer.cpp

106

I don't think so. But maybe my read is incorrect? The unique_ptr would still get created and thus the nullptr check wouldn't pass and so the ec check below would still do its thing.

llvm/tools/dsymutil/Reproducer.h

66–68

thats there for the classof dyn_cast business.

100

So the answer is found around line 734 in dsymutil.cpp. Since we pass a unique_ptr into the main function for the Reproducer if the user selects -gen-reproducer and the program then crashes we need to move the ReproducerGenerate object into the GenerateForCrash so we get the expected messages.

110

Since we are passing the Reproducer unique_ptr into the main function and then, in the case where no -gen-reproducer is passed and the program didn't crash we need to make sure we don't dump the files. That was the intent here. But I can (and did) move it to the parent class. So a question that arises from your comment...should we clean up the dumped files on a crash back to just the binary plus mapping file?

[JDevlieghere]

I was thinking about it some more and a bunch of complexity here seems to come from the fact that some stuff happens within the CrashRecoveryContext (i.e. dsymutilMain). I believe we can avoid the majority of it by parsing the option, initializing the reproducer, and then running the remaining work in the RunSafely lamba.

I also think we should be able to avoid the dyn_cast and rely on polymorphism instead. For example we could have a virtual generate(bool crashed) method that is called after CRC.RunSafely. For ReproducerGenerate it would unconditionally generate the reproducer. For ReproducerGenerateOnCrash it would only do so if crashed == true.

llvm/tools/dsymutil/Reproducer.cpp

106

I would prefer to handle the error immediately and make every switch case self contained.

[JDevlieghere]

I took a stab at the way I had in mind in https://reviews.llvm.org/D127441

llvm/test/tools/dsymutil/X86/reproducer.test

 CHECK:    DW_TAG_const_type
 CHECK-NEXT:      DW_AT_type (0x00000079
 CHECK:    DW_TAG_base_type
 CHECK-NEXT:      DW_AT_name ("char")
 CHECK-NEXT:      DW_AT_encoding (DW_ATE_signed_char)
 CHECK-NEXT:      DW_AT_byte_size (0x01)
 CHECK:      NULL
 
-REPRODUCER: reproducer written
+REPRODUCER: Reproducer Directory
 ERROR: error: cannot parse the debug map
 CONFLICT: cannot combine --gen-reproducer and --use-reproducer

llvm/tools/dsymutil/Reproducer.h

 //===- tools/dsymutil/Reproducer.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_DSYMUTIL_REPRODUCER_H
 #define LLVM_TOOLS_DSYMUTIL_REPRODUCER_H
 
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileCollector.h"
 #include "llvm/Support/VirtualFileSystem.h"
 
+#include <string>
+
 namespace llvm {
 namespace dsymutil {
 
 /// The reproducer mode.
 enum class ReproducerMode {
   Generate,
+  GenerateOnCrash,
   Use,
   Off,
 };
 
 /// The reproducer class manages the sate related to reproducers in dsymutil.
 /// Instances should be created with Reproducer::createReproducer. An instance
 /// of this class is returned when reproducers are off. The VFS returned by
 /// this instance is the real file system.
 class Reproducer {
 public:
   Reproducer();
   virtual ~Reproducer();
 
   IntrusiveRefCntPtr<vfs::FileSystem> getVFS() const { return VFS; }
 
+  const std::string &getRoot() const { return Root; }
+
+  /// Get the mode of this reproducer
+  ReproducerMode getMode() const { return Mode; }
+
   /// Create a Reproducer instance based on the given mode.
   static llvm::Expected<std::unique_ptr<Reproducer>>
   createReproducer(ReproducerMode Mode, StringRef Root);
 
 protected:
+  Reproducer(std::string Root, ReproducerMode Mode);
+
+  void getMappingFileName(SmallVectorImpl<char> &Mapping) const;
+
   IntrusiveRefCntPtr<vfs::FileSystem> VFS;
+
+  /// The path to the reproducer.
+  std::string Root;
+  ReproducerMode Mode = ReproducerMode::Off;
 };
 
 /// Reproducer instance used to generate a new reproducer. The VFS returned by
 /// this instance is a FileCollectorFileSystem that tracks every file used by
 /// dsymutil.
 class ReproducerGenerate : public Reproducer {
 public:
-  ReproducerGenerate(std::error_code &EC);
+  ReproducerGenerate(std::error_code &EC,
+                     ReproducerMode Mode = ReproducerMode::Generate);
   ~ReproducerGenerate() override;
 
-private:
-  /// The path to the reproducer.
-  std::string Root;
+  /// Define classof to be able to use isa<>, cast<>, dyn_cast<>, etc
+  static bool classof(const Reproducer *R) {
+    return R->getMode() == ReproducerMode::Generate;
+  }
+
+  void dodump(bool DoDataDump);
+
+  ReproducerGenerate(ReproducerGenerate &&);
 
+protected:
   /// The FileCollector used by the FileCollectorFileSystem.
   std::shared_ptr<FileCollector> FC;
+  bool DumpFiles = true;
+};
+
+class ReproducerGenerateForCrash : public ReproducerGenerate {
+public:
+  ReproducerGenerateForCrash(std::error_code &EC);
+  ReproducerGenerateForCrash(ReproducerGenerate &&);
+  ~ReproducerGenerateForCrash() override;
+
+  /// Define classof to be able to use isa<>, cast<>, dyn_cast<>, etc
+  static bool classof(const Reproducer *R) {
+    return R->getMode() == ReproducerMode::GenerateOnCrash;
+  }
 };
 
 /// Reproducer instance used to use an existing reproducer. The VFS returned by
 /// this instance is a RedirectingFileSystem that remaps paths to their
 /// counterpart in the reproducer.
 class ReproducerUse : public Reproducer {
 public:
   ReproducerUse(StringRef Root, std::error_code &EC);
   ~ReproducerUse() override;
 
-private:
-  /// The path to the reproducer.
-  std::string Root;
 };
 
 } // end namespace dsymutil
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_DSYMUTIL_REPRODUCER_H

llvm/tools/dsymutil/Reproducer.cpp

 //===- Reproducer.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Reproducer.h"
 #include "llvm/Support/Path.h"
+#include <cstdlib>
+#include <memory>
+#include <utility>
 
 using namespace llvm;
 using namespace llvm::dsymutil;
 
 static std::string createReproducerDir(std::error_code &EC) {
   SmallString<128> Root;
   if (const char *Path = getenv("DSYMUTIL_REPRODUCER_PATH")) {
     Root.assign(Path);
     EC = sys::fs::create_directory(Root);
   } else {
     EC = sys::fs::createUniqueDirectory("dsymutil", Root);
   }
   return EC ? "" : std::string(Root);
 }
 
+void Reproducer::getMappingFileName(SmallVectorImpl<char> &Mapping) const {
+  Mapping.assign(Root.begin(), Root.end());
+  sys::path::append(Mapping, "mapping.yaml");
+}
+
 Reproducer::Reproducer() : VFS(vfs::getRealFileSystem()) {}
 Reproducer::~Reproducer() = default;
 
-ReproducerGenerate::ReproducerGenerate(std::error_code &EC)
-    : Root(createReproducerDir(EC)), FC() {
+Reproducer::Reproducer(std::string Root, ReproducerMode Mode)
+    : VFS(vfs::getRealFileSystem()), Root(std::move(Root)), Mode(Mode) {}
+
+ReproducerGenerate::ReproducerGenerate(std::error_code &EC, ReproducerMode Mode)
+    : Reproducer(createReproducerDir(EC), Mode), FC() {
   if (!Root.empty())
     FC = std::make_shared<FileCollector>(Root, Root);
   VFS = FileCollector::createCollectorVFS(vfs::getRealFileSystem(), FC);
 }
 
+ReproducerGenerate::ReproducerGenerate(ReproducerGenerate &&Other)
+    : Reproducer(static_cast<Reproducer &&>(Other)), FC(std::move(Other.FC)) {}
+
 ReproducerGenerate::~ReproducerGenerate() {
   if (!FC)
     return;
   FC->copyFiles(false);
-  SmallString<128> Mapping(Root);
-  sys::path::append(Mapping, "mapping.yaml");
+  SmallString<128> Mapping;
+  getMappingFileName(Mapping);
   FC->writeMapping(Mapping.str());
-  outs() << "reproducer written to " << Root << '\n';
+  outs() << "Reproducer Directory: " << getRoot() << '\n';
+}
+
+ReproducerGenerateForCrash::ReproducerGenerateForCrash(std::error_code &EC)
+    : ReproducerGenerate(EC, ReproducerMode::GenerateOnCrash) {}
+
+void ReproducerGenerate::dodump(bool DoDataDump) { DumpFiles = DoDataDump; }
+
+ReproducerGenerateForCrash::ReproducerGenerateForCrash(
+    ReproducerGenerate &&Other)
+    : ReproducerGenerate(std::move(Other)) {}
+
+ReproducerGenerateForCrash::~ReproducerGenerateForCrash() {
+  if (!DumpFiles) {
+    FC.reset();
+    return;
+  }
+  dbgs() << "\n********************\n\n"
+            "PLEASE ATTACH THE FOLLOWING DIRECTORY TO THE BUG "
+            "REPORT:\nBinar(ies|y), object file(s) and associated debug map "
+            "are located at:\n";
+  // Once the reproducer exits then the mapping will be dumped
+  // by the parent class destructor
 }
 
 ReproducerUse::~ReproducerUse() = default;
 
-ReproducerUse::ReproducerUse(StringRef Root, std::error_code &EC) {
-  SmallString<128> Mapping(Root);
-  sys::path::append(Mapping, "mapping.yaml");
+ReproducerUse::ReproducerUse(StringRef Root, std::error_code &EC)
+    : Reproducer{Root.str(), ReproducerMode::Use} {
+  SmallString<128> Mapping;
+  getMappingFileName(Mapping);
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
       vfs::getRealFileSystem()->getBufferForFile(Mapping.str());
 
   if (!Buffer) {
     EC = Buffer.getError();
     return;
   }
 
   VFS = llvm::vfs::getVFSFromYAML(std::move(Buffer.get()), nullptr, Mapping);
 }
 
 llvm::Expected<std::unique_ptr<Reproducer>>
 Reproducer::createReproducer(ReproducerMode Mode, StringRef Root) {
-  switch (Mode) {
-  case ReproducerMode::Generate: {
-    std::error_code EC;
-    std::unique_ptr<Reproducer> Repro =
-        std::make_unique<ReproducerGenerate>(EC);
+  std::unique_ptr<Reproducer> Repro;
+  switch (Mode) {
+  case ReproducerMode::GenerateOnCrash:
+    Repro = std::make_unique<ReproducerGenerateForCrash>(EC);
+    LLVM_FALLTHROUGH;
+  case ReproducerMode::Generate:
+    if (Repro == nullptr)
+      Repro = std::make_unique<ReproducerGenerate>(EC);
+
     if (EC)
       return errorCodeToError(EC);
     return std::move(Repro);
-  }
-  case ReproducerMode::Use: {
-    std::error_code EC;
-    std::unique_ptr<Reproducer> Repro =
-        std::make_unique<ReproducerUse>(Root, EC);
+  case ReproducerMode::Use:
+    Repro = std::make_unique<ReproducerUse>(Root, EC);
     if (EC)
       return errorCodeToError(EC);
     return std::move(Repro);
-  }
   case ReproducerMode::Off:
     return std::make_unique<Reproducer>();
   }
   llvm_unreachable("All cases handled above.");
 }

llvm/tools/dsymutil/dsymutil.cpp

 #include "MachOUtils.h"
 #include "Reproducer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/FileCollector.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/thread.h"
 #include <algorithm>
 #include <cstdint>
 #include <cstdlib>
struct DsymutilOptions {
   bool ForceKeepFunctionForStatic = false;
   std::string SymbolMap;
   std::string OutputFile;
   std::string Toolchain;
   std::string ReproducerPath;
   std::vector<std::string> Archs;
   std::vector<std::string> InputFiles;
   unsigned NumThreads;
-  ReproducerMode ReproMode = ReproducerMode::Off;
+  ReproducerMode ReproMode = ReproducerMode::GenerateOnCrash;
   dsymutil::LinkOptions LinkOpts;
 };
 
 /// Return a list of input files. This function has logic for dealing with the
 /// special case where we might have dSYM bundles as input. The function
 /// returns an error when the directory structure doesn't match that of a dSYM
 /// bundle.
 static Expected<std::vector<std::string>> getInputs(opt::InputArgList &Args,
getOutputFileName(StringRef InputFile, const DsymutilOptions &Options) {
   }
 
   sys::path::append(Path, "Contents", "Resources");
   std::string ResourceDir = std::string(Path.str());
   sys::path::append(Path, "DWARF", sys::path::filename(DwarfFile));
   return OutputLocation(std::string(Path.str()), ResourceDir);
 }
 
-int main(int argc, char **argv) {
-  InitLLVM X(argc, argv);
-
-  // Parse arguments.
+static int dsymutilMain(std::unique_ptr<Reproducer> &Repro, int Argc,
+                        char **Argv) {
+  std::string ProgName(Argv[0]);
   DsymutilOptTable T;
   unsigned MAI;
   unsigned MAC;
-  ArrayRef<const char *> ArgsArr = makeArrayRef(argv + 1, argc - 1);
-  opt::InputArgList Args = T.ParseArgs(ArgsArr, MAI, MAC);
-
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1);
+  auto Args = T.ParseArgs(ArgsArr, MAI, MAC);
   void *P = (void *)(intptr_t)getOutputFileName;
-  std::string SDKPath = sys::fs::getMainExecutable(argv[0], P);
+  std::string SDKPath = sys::fs::getMainExecutable(Argv[0], P);
   SDKPath = std::string(sys::path::parent_path(SDKPath));
 
   for (auto *Arg : Args.filtered(OPT_UNKNOWN)) {
     WithColor::warning() << "ignoring unknown option: " << Arg->getSpelling()
                          << '\n';
   }
 
   if (Args.hasArg(OPT_help)) {
     T.printHelp(
-        outs(), (std::string(argv[0]) + " [options] <input files>").c_str(),
+        outs(), (ProgName + " [options] <input files>").c_str(),
         "manipulate archived DWARF debug symbol files.\n\n"
         "dsymutil links the DWARF debug information found in the object files\n"
         "for the executable <input file> by using debug symbols information\n"
         "contained in its symbol table.\n",
         false);
     return EXIT_SUCCESS;
   }
 
static int dsymutilMain(std::unique_ptr<Reproducer> &Repro, int Argc,
 
   auto &Options = *OptionsOrErr;
 
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllTargets();
   InitializeAllAsmPrinters();
 
-  auto Repro =
+  auto IsRepro =
       Reproducer::createReproducer(Options.ReproMode, Options.ReproducerPath);
-  if (!Repro) {
-    WithColor::error() << toString(Repro.takeError());
+  if (!IsRepro) {
+    WithColor::error() << toString(IsRepro.takeError());
     return EXIT_FAILURE;
   }
 
-  Options.LinkOpts.VFS = (*Repro)->getVFS();
+  Repro = std::move(*IsRepro);
+
+  Options.LinkOpts.VFS = Repro->getVFS();
 
   for (const auto &Arch : Options.Archs)
     if (Arch != "*" && Arch != "all" &&
         !object::MachOObjectFile::isValidArch(Arch)) {
       WithColor::error() << "unsupported cpu architecture: '" << Arch << "'\n";
       return EXIT_FAILURE;
     }
 
for (auto &Map : *DebugMapPtrsOrErr) {
 
       // FIXME: The DwarfLinker can have some very deep recursion that can max
       // out the (significantly smaller) stack when using threads. We don't
       // want this limitation when we only have a single thread.
       if (S.ThreadsRequested == 1)
         LinkLambda(OS, Options.LinkOpts);
       else
         Threads.async(LinkLambda, OS, Options.LinkOpts);
     }
 
     Threads.wait();
 
     if (!AllOK)
       return EXIT_FAILURE;
 
     if (NeedsTempFiles) {
       if (!MachOUtils::generateUniversalBinary(TempFiles,
                                                OutputLocationOrErr->DWARFFile,
                                                Options.LinkOpts, SDKPath))
         return EXIT_FAILURE;
     }
if (stat) {
                               "object file format.";
         return EXIT_FAILURE;
       }
     }
   }
 
   return EXIT_SUCCESS;
 }
+
+// NOLINTNEXTLINE(readability-identifier-naming)
+int main(int argc, char **argv) {
+  InitLLVM X(argc, argv);
+  setBugReportMsg(
+      "PLEASE submit a bug report to " BUG_REPORT_URL
+      " and include the crash backtrace, object files and debug map.\n");
+  CrashRecoveryContext::Enable();
+  CrashRecoveryContext CRC;
+  CRC.DumpStackAndCleanupOnFailure = true;
+  int Rval = 0;
+  std::unique_ptr<Reproducer> Repro;
+  if (!CRC.RunSafely([&Rval, &Repro, argc, argv]() {
+        Rval = dsymutilMain(Repro, argc, argv);
+      })) {
+    bool DidRepro = false;
+    if (Repro != nullptr) {
+      if (auto *RPtr =
+              llvm::dyn_cast<ReproducerGenerateForCrash>(Repro.get())) {
+        Repro.reset(); // Generate reproducer on teardown
+        DidRepro = true;
+      } else if (auto *RPtr = llvm::dyn_cast<ReproducerGenerate>(Repro.get())) {
+        ReproducerGenerateForCrash CrashRepro(std::move(*RPtr));
+        DidRepro = true;
+      }
+    }
+    if (!DidRepro)
+      WithColor::error() << "Unable to create crash reproducer.\n";
+    dbgs() << "Command: dsymutil ";
+    for (auto ArgIndex = 1; ArgIndex < argc; ArgIndex++) {
+      dbgs() << argv[ArgIndex] << " ";
+    }
+    dbgs() << "\n";
+    return CRC.RetCode;
+  }
+  if (Repro != nullptr) {
+    if (auto *RPtr = llvm::dyn_cast<ReproducerGenerateForCrash>(Repro.get())) {
+      RPtr->dodump(false);
+    }
+  }
+  return Rval;
+}