[dsymutil] Add the ability to run the DWARF verifier on the input

[JDevlieghere]

Summary

It's already possible to run the DWARF verifier on the linked dsymutil output. This patch extends this functionality and makes it possible to run the DWARF verifier on the input as well. A new option --verify-dwarf allows you to specify input, output, all and none. The existing --verify flag remains unchanged and acts and alias for --verify-dwarf=output. Input verification issues do not result in a non-zero exit code because dsymutil is capable of taking invalid DWARF as input and producing valid DWARF as output.

[avl]

llvm/tools/dsymutil/Options.td

41

there is an extra dash here: ---verify-dwarf

[avl]

llvm/tools/dsymutil/BinaryHolder.cpp

274 ↗

(On Diff #297496)

I have two suggestions/questions: 1. It would probably be better to do input verification inside DWARFLinker library(DWARFLinker::link()). Then all users of the library will be able to use this functionality. 2. Would it be useful to have failure in verification to be fatal error ?

llvm/tools/dsymutil/dsymutil.cpp

657

It makes sense to display message to the user when Options.Verify is ignored because of Options.LinkOpts.NoOutput. Probably verifyOptions() is a good place for it.

[JDevlieghere]

llvm/tools/dsymutil/BinaryHolder.cpp

274 ↗

(On Diff #297496)

I think moving it into the DWARFLinker is a good idea, we already have a DWARFContext there.

I don't think we should make input verification failure a fatal error. Depending on the issue dsymutil is capable of generating a valid dSYM from invalid DWARF.

[avl]

llvm/tools/dsymutil/BinaryHolder.cpp

274 ↗

(On Diff #297496)

I don't think we should make input verification failure a fatal error. Depending on the issue dsymutil is capable of generating a valid dSYM from invalid DWARF.

There is a final set of errors which dsymutil could cure and generate a valid DWARF. The example of such errors is "Overlapping address range". Before dsymutil, there are a lot of address ranges starting from zero(these are address ranges related to deleted code). So input verification would report error "Overlapping address range". dsymutil removes DWARF which uses these address ranges and final DWARF become valid. Other kinds of errors could not be cured by dsymutil. And then it would be useful to fail if input contains such errors.

Probably, we could add a parameter to the DWARFContext.verify() - SkipDWARLinkerKnownErrors. So that if verifier encounter only known errors it would report success, otherwise it would report failure and dsymutil would fail during input validation ?

It looks useful if dsymutil would fail on input verification if input DWARF contains errors which could not be fixed/correctly processed by dsymutil.

[clayborg]

I really like this patch as it will make detecting LTO issues easier as there are often issues in the incoming .o files.

One thing to think about is we want to only verify unique object files one time. In older LTO based code I remember seeing that same "lto.o" file in the debug map multiple time with many different sources file (N_SO) entries with the same path to the same .o file (N_OSO). If this would happen, would this patch end up running the verifier on the same file over and over?

llvm/tools/dsymutil/BinaryHolder.cpp

274 ↗

(On Diff #299885)

I believe that detection of overlapping address ranges is disabled or .o files since it is known to have unrelocated addresses.

llvm/tools/dsymutil/Options.td

49

If we aren't going to have these errors be fatal, can we possibly add an option that _can_ make verification errors cause it to be?

--verify-errors-fatal

[avl]

llvm/tools/dsymutil/BinaryHolder.cpp

274 ↗

(On Diff #299885)

probably, yes. My point is that we can ignore errors, which could be cured by dsymutil, and we could stop verifying if the error, which could not be fixed by dsymutil, was met.

[JDevlieghere]

• Rebase
• Move verification into the DWARFLinker

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

275–276

It looks useful to explicitly show that library verifies input DWARF.

787–788

It looks useful to explicitly show that library verifies input DWARF.

llvm/lib/DWARFLinker/DWARFLinker.cpp

2643

It is probably better to use DWARFLinker::reportWarning method instead of direct call to WithColor::warning().

llvm/test/tools/dsymutil/X86/verify.test

18

it would be good to test -verify-dwarf=none and -verify-dwarf=bad_value.

llvm/tools/dsymutil/LinkUtils.h

33–34

llvm/tools/dsymutil/dsymutil.cpp

88

it is not expected to have a lot of values here. Probably, uint8_t instead of unsigned would be better.

91

All = Input | Output,

may be useful later in getVerifyKind().

268

static_cast<bool>(Options.Verify & DWARFVerify::Input);

looks overweight. Probably implement a helper ?:

inline bool FlagIsSet (DWARFVerify Flags, DWARFVerify SingleFlag) {
  return static_cast<uint8_t>(Flags) & static_cast<uint8_t>(SingleFlag);
}

Options.LinkOpts.Verify = FlagIsSet(Options.Verify, DWARFVerify::Input);

[JDevlieghere]

Thanks for the prompt review, Alexey! I think I've addressed all your comments.

[avl]

Thank you Jonas! There are still several inline nits...

llvm/include/llvm/DWARFLinker/DWARFLinker.h

787

llvm/tools/dsymutil/LinkUtils.h

33

llvm/tools/dsymutil/dsymutil.cpp

88

95

now it is not used and probably might be deleted.

100

now it is not used and probably might be deleted.

105

should start from the small letter.

238

[JDevlieghere]

Address nits

[avl]

LGTM. please wait some time if other reviewers have any comment. Thanks!

[clayborg]

Most of the patch looks fine, just wanted to make sure we aren't changing it so that "--verify" can't be specified without a now required argument as it would break people's scripts for anyone that is using this flag. We are using on all iOS DWARF output right now at Facebook/Meta. I would rather us add a new "--verify-input" that can be specified, and add leave "--verify" to mean verify the output, or make a "--verify-output" as well and alias "--verify" to that flag.

llvm/tools/dsymutil/dsymutil.cpp

260

Is this now changing it so "--verify" no longer works and now requires an additional argument? It would hate to break anyone's scripts that might be currently using the "--verify" option by changing its semantics.

[clayborg]

In D89216#3320823, @clayborg wrote:

Most of the patch looks fine, just wanted to make sure we aren't changing it so that "--verify" can't be specified without a now required argument as it would break people's scripts for anyone that is using this flag. We are using on all iOS DWARF output right now at Facebook/Meta. I would rather us add a new "--verify-input" that can be specified, and add leave "--verify" to mean verify the output, or make a "--verify-output" as well and alias "--verify" to that flag.

This will teach me to read all of the posts and the original description before commenting... If everything is as it says in the description this looks good to me.

[JDevlieghere]

Yup.

@clayborg Do you still want a flag to make verification issues fatal? I'm happy to put that in a follow up patch.

[clayborg]

In D89216#3321019, @JDevlieghere wrote:

Yup.

@clayborg Do you still want a flag to make verification issues fatal? I'm happy to put that in a follow up patch.

Actually no, so much DWARF can have issues that might not fully pass verification that I am not sure it would be usable, so lets hold off for now.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

public:
   /// A number of methods setting various linking options:
 
   /// Allows to generate log of linking process to the standard output.
   void setVerbosity(bool Verbose) { Options.Verbose = Verbose; }
 
   /// Print statistics to standard output.
   void setStatistics(bool Statistics) { Options.Statistics = Statistics; }
 
+  /// Verify the input DWARF.
+  void setVerifyInputDWARF(bool Verify) { Options.VerifyInputDWARF = Verify; }
+
   /// Do not emit linked dwarf info.
   void setNoOutput(bool NoOut) { Options.NoOutput = NoOut; }
 
   /// Do not unique types according to ODR.
   void setNoODR(bool NoODR) { Options.NoODR = NoODR; }
 
   /// update existing DWARF info(for the linked binary).
   void setUpdate(bool Update) { Options.Update = Update; }
WorklistItem(DWARFDie Die, CompileUnit &CU, WorklistItemType T,
                  CompileUnit::DIEInfo *OtherInfo = nullptr)
         : Die(Die), Type(T), CU(CU), Flags(0), OtherInfo(OtherInfo) {}
 
     WorklistItem(unsigned AncestorIdx, CompileUnit &CU, unsigned Flags)
         : Type(WorklistItemType::LookForParentDIEsToKeep), CU(CU), Flags(Flags),
           AncestorIdx(AncestorIdx) {}
   };
 
+  /// Verify the given DWARF file.
+  bool verify(const DWARFFile &File);
+
   /// returns true if we need to translate strings.
   bool needToTranslateStrings() { return StringsTranslator != nullptr; }
 
   void reportWarning(const Twine &Warning, const DWARFFile &File,
                      const DWARFDie *DIE = nullptr) const {
     if (Options.WarningHandler != nullptr)
       Options.WarningHandler(Warning, File.FileName, DIE);
   }
private:
   /// linking options
   struct DWARFLinkerOptions {
     /// Generate processing log to the standard output.
     bool Verbose = false;
 
     /// Print statistics.
     bool Statistics = false;
 
+    /// Verify the input DWARF.
+    bool VerifyInputDWARF = false;
+
     /// Skip emitting output
     bool NoOutput = false;
 
     /// Do not unique types according to ODR
     bool NoODR = false;
 
     /// Update
     bool Update = false;

llvm/lib/DWARFLinker/DWARFLinker.cpp

if (Options.Verbose) {
         outs() << "OBJECT FILE: " << OptContext.File.FileName << "\n";
     }
 
     if (emitPaperTrailWarnings(OptContext.File, OffsetsStringPool))
       continue;
 
     if (!OptContext.File.Dwarf)
       continue;
+
+    if (Options.VerifyInputDWARF)
+      verify(OptContext.File);
+
     // Look for relocations that correspond to address map entries.
 
     // there was findvalidrelocations previously ... probably we need to gather
     // info here
     if (LLVM_LIKELY(!Options.Update) &&
         !OptContext.File.Addresses->hasValidRelocs()) {
       if (Options.Verbose)
         outs() << "No valid relocations found. Skipping.\n";
llvm::outs() << formatv(FormatStr, "Total", InputTotal, OutputTotal,
                             ComputePercentange(InputTotal, OutputTotal));
     outs() << "----------------------------------------------------------------"
               "---------------\n\n";
   }
 
   return true;
 }
 
+bool DWARFLinker::verify(const DWARFFile &File) {
+  assert(File.Dwarf);
+
+  DIDumpOptions DumpOpts;
+  if (!File.Dwarf->verify(llvm::outs(), DumpOpts.noImplicitRecursion())) {
+    reportWarning("input verification failed", File);
+    return false;
+  }
+  return true;
+}
+
 } // namespace llvm

llvm/test/tools/dsymutil/X86/verify.test

 # Positive tests in regular and verbose mode.
 # RUN: dsymutil -verify -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 %p/../Inputs/basic-archive.macho.x86_64 %p/../Inputs/basic-lto.macho.x86_64 %p/../Inputs/basic-lto-dw4.macho.x86_64 -o %t 2>&1 | FileCheck %s --allow-empty --check-prefix=QUIET-SUCCESS
 # RUN: dsymutil -verify -verbose -oso-prepend-path=%p/.. %p/../Inputs/basic.macho.x86_64 %p/../Inputs/basic-archive.macho.x86_64 %p/../Inputs/basic-lto.macho.x86_64 %p/../Inputs/basic-lto-dw4.macho.x86_64 -o %t 2>&1 | FileCheck %s --check-prefixes=QUIET-SUCCESS,VERBOSE
 
 # VERBOSE: Verifying DWARF for architecture: x86_64
-# QUIET-SUCCESS-NOT: error: verification failed
+# QUIET-SUCCESS-NOT: error: output verification failed
 
-# Negative tests in regular and verbose mode.
+# Negative output tests in regular and verbose mode.
 # (Invalid object generated from ../Inputs/invalid.s by modified the low PC.)
-# RUN: not dsymutil -verify -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefix=QUIET-FAIL
-# RUN: not dsymutil -verify -verbose -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefixes=QUIET-FAIL,VERBOSE
+# RUN: not dsymutil -verify -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefix=QUIET-OUTPUT-FAIL
+# RUN: not dsymutil -verify-dwarf=output -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefix=QUIET-OUTPUT-FAIL
+# RUN: not dsymutil -verify -verbose -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefixes=QUIET-OUTPUT-FAIL,VERBOSE
 
-# QUIET-FAIL: error: verification failed
+# Negative input & output tests in regular and verbose mode. Only output failures result in a non-zero exit code.
+# RUN: dsymutil -verify-dwarf=input -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefix=QUIET-INPUT-FAIL
+# RUN: dsymutil -verify-dwarf=input -verbose -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefix=QUIET-INPUT-FAIL
+# RUN: dsymutil -verify-dwarf=none -verbose -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefixes=QUIET-SUCCESS
+# RUN: not dsymutil -verify-dwarf=bogus -verbose -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefixes=BOGUS
+# RUN: not dsymutil -verify-dwarf=all -oso-prepend-path=%p/../Inputs -y %s -o %t 2>&1 | FileCheck %s --check-prefixes=QUIET-OUTPUT-FAIL,QUIET-INPUT-FAIL,VERBOSE-INPUT-FAIL
+
+# VERBOSE-INPUT-FAIL: error: Abbreviation declaration contains multiple DW_AT_language attributes.
+# QUIET-INPUT-FAIL: warning: input verification failed
+# QUIET-OUTPUT-FAIL: error: output verification failed
+# QUIET-SUCCESS-NOT: input verification failed
+# QUIET-SUCCESS-NOT: output verification failed
+# BOGUS: error: invalid verify type specified: 'bogus'
 
 ---
 triple:          'x86_64-apple-darwin'
 objects:
   - filename:        invalid.o
     timestamp:       1518197670
     symbols:
       - { sym: _main, objAddr: 0x0000000000000010, binAddr: 0x0000000100000FB0, size: 0x00000008 }
       - { sym: _g, objAddr: 0x0000000000000000, binAddr: 0x0000000100000FA0, size: 0x00000010 }
 ...

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

bool DwarfLinkerForBinary::link(const DebugMap &Map) {
 
   std::function<StringRef(StringRef)> TranslationLambda = [&](StringRef Input) {
     assert(Options.Translator);
     return Options.Translator(Input);
   };
 
   GeneralLinker.setVerbosity(Options.Verbose);
   GeneralLinker.setStatistics(Options.Statistics);
+  GeneralLinker.setVerifyInputDWARF(Options.VerifyInputDWARF);
   GeneralLinker.setNoOutput(Options.NoOutput);
   GeneralLinker.setNoODR(Options.NoODR);
   GeneralLinker.setUpdate(Options.Update);
   GeneralLinker.setNumThreads(Options.Threads);
   GeneralLinker.setAccelTableKind(Options.TheAccelTableKind);
   GeneralLinker.setPrependPath(Options.PrependPath);
   GeneralLinker.setKeepFunctionForStatic(Options.KeepFunctionForStatic);
   if (Options.Translator)

llvm/tools/dsymutil/LinkUtils.h

 
 struct LinkOptions {
   /// Verbosity
   bool Verbose = false;
 
   /// Statistics
   bool Statistics = false;
 
+  /// Verify the input DWARF.
+  bool VerifyInputDWARF = false;
+
   /// Skip emitting output
   bool NoOutput = false;
 
   /// Do not unique types according to ODR
   bool NoODR = false;
 
   /// Update
   bool Update = false;

llvm/tools/dsymutil/Options.td

HelpText<"Print statistics about the contribution of each object file to "
            "the linked debug info. This prints a table after linking with the "
            "object file name, the size of the debug info in the object file "
            "(in bytes) and the size contributed (in bytes) to the linked dSYM. "
            "The table is sorted by the output size listing the object files "
            "with the largest contribution first.">,
   Group<grp_general>;
 
 def verify: F<"verify">,
-  HelpText<"Run the DWARF verifier on the linked DWARF debug info.">,
+  HelpText<"Alias for --verify-dwarf=output">,
   Group<grp_general>;
 
+def verify_dwarf: Separate<["--", "-"], "verify-dwarf">,
+  MetaVarName<"<verification mode>">,
+  HelpText<"Run the DWARF verifier on the input and/or output. Valid options are 'input', 'output', 'all' or 'none'.">,
+  Group<grp_general>;
+def: Joined<["--", "-"], "verify-dwarf=">, Alias<verify_dwarf>;
+
 def no_output: F<"no-output">,
   HelpText<"Do the link in memory, but do not emit the result file.">,
   Group<grp_general>;
 
 def no_swiftmodule_timestamp: F<"no-swiftmodule-timestamp">,
   HelpText<"Don't check timestamp for swiftmodule files.">,
   Group<grp_general>;
 

llvm/tools/dsymutil/dsymutil.cpp

 };
 
 class DsymutilOptTable : public opt::OptTable {
 public:
   DsymutilOptTable() : OptTable(InfoTable) {}
 };
 } // namespace
 
+enum class DWARFVerify : uint8_t {
+  None = 0,
+  Input = 1 << 0,
+  Output = 1 << 1,
+  All = Input | Output,
+};
+
+inline bool flagIsSet(DWARFVerify Flags, DWARFVerify SingleFlag) {
+  return static_cast<uint8_t>(Flags) & static_cast<uint8_t>(SingleFlag);
+}
+
 struct DsymutilOptions {
   bool DumpDebugMap = false;
   bool DumpStab = false;
   bool Flat = false;
   bool InputIsYAMLDebugMap = false;
   bool PaperTrailWarnings = false;
-  bool Verify = false;
   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;
+  DWARFVerify Verify = DWARFVerify::None;
   ReproducerMode ReproMode = ReproducerMode::Off;
   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.
if (opt::Arg *Accelerator = Args.getLastArg(OPT_accelerator)) {
     return make_error<StringError>(
         "invalid accelerator type specified: '" + S +
             "'. Support values are 'Apple', 'Dwarf', 'Pub' and 'Default'.",
         inconvertibleErrorCode());
   }
   return AccelTableKind::Default;
 }
 
+static Expected<DWARFVerify> getVerifyKind(opt::InputArgList &Args) {
+  if (Args.hasArg(OPT_verify))
+    return DWARFVerify::Output;
+  if (opt::Arg *Verify = Args.getLastArg(OPT_verify_dwarf)) {
+    StringRef S = Verify->getValue();
+    if (S == "input")
+      return DWARFVerify::Input;
+    if (S == "output")
+      return DWARFVerify::Output;
+    if (S == "all")
+      return DWARFVerify::All;
+    if (S == "none")
+      return DWARFVerify::None;
+    return make_error<StringError>(
+        "invalid verify type specified: '" + S +
+            "'. Support values are 'input', 'output', 'all' and 'none'.",
+        inconvertibleErrorCode());
+  }
+  return DWARFVerify::None;
+}
+
 /// Parses the command line options into the LinkOptions struct and performs
 /// some sanity checking. Returns an error in case the latter fails.
 static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
   DsymutilOptions Options;
 
   Options.DumpDebugMap = Args.hasArg(OPT_dump_debug_map);
   Options.DumpStab = Args.hasArg(OPT_symtab);
   Options.Flat = Args.hasArg(OPT_flat);
   Options.InputIsYAMLDebugMap = Args.hasArg(OPT_yaml_input);
   Options.PaperTrailWarnings = Args.hasArg(OPT_papertrail);
-  Options.Verify = Args.hasArg(OPT_verify);
+
+  if (Expected<DWARFVerify> Verify = getVerifyKind(Args)) {
+    Options.Verify = *Verify;
+  } else {
+    return Verify.takeError();
+  }
 
   Options.LinkOpts.NoODR = Args.hasArg(OPT_no_odr);
+  Options.LinkOpts.VerifyInputDWARF =
+      flagIsSet(Options.Verify, DWARFVerify::Input);
   Options.LinkOpts.NoOutput = Args.hasArg(OPT_no_output);
   Options.LinkOpts.NoTimestamp = Args.hasArg(OPT_no_swiftmodule_timestamp);
   Options.LinkOpts.Update = Args.hasArg(OPT_update);
   Options.LinkOpts.Verbose = Args.hasArg(OPT_verbose);
   Options.LinkOpts.Statistics = Args.hasArg(OPT_statistics);
   Options.LinkOpts.KeepFunctionForStatic =
       Args.hasArg(OPT_keep_func_for_static);
 
static Error createBundleDir(StringRef BundleBase) {
   if (std::error_code EC =
           create_directories(Bundle.str(), true, sys::fs::perms::all_all))
     return make_error<StringError>(
         "cannot create bundle: " + toString(errorCodeToError(EC)), EC);
 
   return Error::success();
 }
 
-static bool verify(StringRef OutputFile, StringRef Arch, bool Verbose) {
+static bool verifyOutput(StringRef OutputFile, StringRef Arch, bool Verbose) {
   if (OutputFile == "-") {
     WithColor::warning() << "verification skipped for " << Arch
                          << "because writing to stdout.\n";
     return true;
   }
 
   Expected<OwningBinary<Binary>> BinOrErr = createBinary(OutputFile);
   if (!BinOrErr) {
     WithColor::error() << OutputFile << ": " << toString(BinOrErr.takeError());
     return false;
   }
 
   Binary &Binary = *BinOrErr.get().getBinary();
   if (auto *Obj = dyn_cast<MachOObjectFile>(&Binary)) {
     raw_ostream &os = Verbose ? errs() : nulls();
     os << "Verifying DWARF for architecture: " << Arch << "\n";
     std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(*Obj);
     DIDumpOptions DumpOpts;
     bool success = DICtx->verify(os, DumpOpts.noImplicitRecursion());
     if (!success)
-      WithColor::error() << "verification failed for " << Arch << '\n';
+      WithColor::error() << "output verification failed for " << Arch << '\n';
     return success;
   }
 
   return false;
 }
 
 namespace {
 struct OutputLocation {
for (auto &InputFile : Options.InputFiles) {
     }
     ThreadPool Threads(S);
 
     // If there is more than one link to execute, we need to generate
     // temporary files.
     const bool NeedsTempFiles =
         !Options.DumpDebugMap && (Options.OutputFile != "-") &&
         (DebugMapPtrsOrErr->size() != 1 || Options.LinkOpts.Update);
-    const bool Verify = Options.Verify && !Options.LinkOpts.NoOutput;
+    bool VerifyOutput = flagIsSet(Options.Verify, DWARFVerify::Output);
+    if (VerifyOutput && Options.LinkOpts.NoOutput) {
+      WithColor::warning()
+          << "skipping output verification because --no-output was passed\n";
+      VerifyOutput = false;
+    }
 
     SmallVector<MachOUtils::ArchAndFile, 4> TempFiles;
     std::atomic_char AllOK(1);
     for (auto &Map : *DebugMapPtrsOrErr) {
       if (Options.LinkOpts.Verbose || Options.DumpDebugMap)
         Map->print(outs());
 
       if (Options.DumpDebugMap)
for (auto &Map : *DebugMapPtrsOrErr) {
         }
       }
 
       auto LinkLambda = [&, OutputFile](std::shared_ptr<raw_fd_ostream> Stream,
                                         LinkOptions Options) {
         AllOK.fetch_and(
             linkDwarf(*Stream, BinHolder, *Map, std::move(Options)));
         Stream->flush();
-        if (Verify)
-          AllOK.fetch_and(verify(OutputFile, Map->getTriple().getArchName(),
-                                 Options.Verbose));
+        if (VerifyOutput) {
+          AllOK.fetch_and(verifyOutput(
+              OutputFile, Map->getTriple().getArchName(), Options.Verbose));
+        }
       };
 
       // 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