[Symbolize] Check if the PE file has a PDB and emit an error if we can't load it

[rnk]

Summary

Previously we would try to load PDBs for every PE executable we tried to
symbolize. If that failed, we would fall back to DWARF. If there wasn't
any DWARF, we'd print mostly useless symbol information using the export
table.

With this change, we only try to load PDBs for executables that claim to
have them. If that fails, we can now print an error rather than falling
back silently. This should make it a lot easier to diagnose and fix
common symbolization issues, such as not having DIA or not having a PDB.

[zturner]

lib/DebugInfo/Symbolize/Symbolize.cpp

56–60 ↗

(On Diff #59605)

I think this is usually written:

SymbolizableModule *Info = nullptr;
if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
  Info = InfoOrErr.get();
else
  return InfoOrErr;

Almost wonder if we need a macro for this considering how frequently we do it.

[rnk]

• Use the standard error return check

llvm/trunk/include/llvm/DebugInfo/Symbolize/Symbolize.h

Options(FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName,
           DefaultArch(std::move(DefaultArch)) {}
   };
 
   LLVMSymbolizer(const Options &Opts = Options()) : Opts(Opts) {}
   ~LLVMSymbolizer() {
     flush();
   }
 
-  ErrorOr<DILineInfo> symbolizeCode(const std::string &ModuleName,
+  Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
                                      uint64_t ModuleOffset);
-  ErrorOr<DIInliningInfo> symbolizeInlinedCode(const std::string &ModuleName,
+  Expected<DIInliningInfo> symbolizeInlinedCode(const std::string &ModuleName,
                                                 uint64_t ModuleOffset);
-  ErrorOr<DIGlobal> symbolizeData(const std::string &ModuleName,
+  Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
                                    uint64_t ModuleOffset);
   void flush();
   static std::string DemangleName(const std::string &Name,
                                   const SymbolizableModule *ModInfo);
 
 private:
   // Bundles together object file with code/data and object file with
   // corresponding debug info. These objects can be the same.
   typedef std::pair<ObjectFile*, ObjectFile*> ObjectPair;
 
-  ErrorOr<SymbolizableModule *>
+  /// Returns a SymbolizableModule or an error if loading debug info failed.
+  /// Only one attempt is made to load a module, and errors during loading are
+  /// only reported once. Subsequent calls to get module info for a module that
+  /// failed to load will return nullptr.
+  Expected<SymbolizableModule *>
   getOrCreateModuleInfo(const std::string &ModuleName);
+
   ObjectFile *lookUpDsymFile(const std::string &Path,
                              const MachOObjectFile *ExeObj,
                              const std::string &ArchName);
   ObjectFile *lookUpDebuglinkObject(const std::string &Path,
                                     const ObjectFile *Obj,
                                     const std::string &ArchName);
 
   /// \brief Returns pair of pointers to object and debug object.
-  ErrorOr<ObjectPair> getOrCreateObjectPair(const std::string &Path,
+  Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path,
                                             const std::string &ArchName);
 
   /// \brief Return a pointer to object file at specified path, for a specified
   /// architecture (e.g. if path refers to a Mach-O universal binary, only one
   /// object file from it will be returned).
-  ErrorOr<ObjectFile *> getOrCreateObject(const std::string &Path,
+  Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
                                           const std::string &ArchName);
 
-  std::map<std::string, ErrorOr<std::unique_ptr<SymbolizableModule>>> Modules;
+  std::map<std::string, std::unique_ptr<SymbolizableModule>> Modules;
 
   /// \brief Contains cached results of getOrCreateObjectPair().
-  std::map<std::pair<std::string, std::string>, ErrorOr<ObjectPair>>
+  std::map<std::pair<std::string, std::string>, ObjectPair>
       ObjectPairForPathArch;
 
   /// \brief Contains parsed binary for each path, or parsing error.
-  std::map<std::string, ErrorOr<OwningBinary<Binary>>> BinaryForPath;
+  std::map<std::string, OwningBinary<Binary>> BinaryForPath;
 
   /// \brief Parsed object file for path/architecture pair, where "path" refers
   /// to Mach-O universal binary.
-  std::map<std::pair<std::string, std::string>, ErrorOr<std::unique_ptr<ObjectFile>>>
+  std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>>
       ObjectForUBPathAndArch;
 
   Options Opts;
 };
 
 } // namespace symbolize
 } // namespace llvm
 
 #endif

llvm/trunk/include/llvm/Object/COFF.h

public:
   /// code if the RVA and size is not contained completely within a valid
   /// section.
   std::error_code getRvaAndSizeAsBytes(uint32_t RVA, uint32_t Size,
                                        ArrayRef<uint8_t> &Contents) const;
 
   std::error_code getHintName(uint32_t Rva, uint16_t &Hint,
                               StringRef &Name) const;
 
+  /// Get PDB information out of a codeview debug directory entry.
   std::error_code getDebugPDBInfo(const debug_directory *DebugDir,
                                   const debug_pdb_info *&Info,
                                   StringRef &PDBFileName) const;
 
+  /// Get PDB information from an executable. If the information is not present,
+  /// Info will be set to nullptr and PDBFileName will be empty. An error is
+  /// returned only on corrupt object files. Convenience accessor that can be
+  /// used if the debug directory is not already handy.
+  std::error_code getDebugPDBInfo(const debug_pdb_info *&Info,
+                                  StringRef &PDBFileName) const;
+
   bool isRelocatableObject() const override;
   bool is64() const { return PE32PlusHeader; }
 
   static inline bool classof(const Binary *v) { return v->isCOFF(); }
 };
 
 // The iterator for the import directory table.
 class ImportDirectoryEntryRef {

llvm/trunk/lib/DebugInfo/Symbolize/Symbolize.cpp

 #ifdef IMAGE_FILE_MACHINE_I386
 #undef IMAGE_FILE_MACHINE_I386
 #endif
 #endif
 
 namespace llvm {
 namespace symbolize {
 
-ErrorOr<DILineInfo> LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
+Expected<DILineInfo> LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
                                                   uint64_t ModuleOffset) {
-  auto InfoOrErr = getOrCreateModuleInfo(ModuleName);
-  if (auto EC = InfoOrErr.getError())
-    return EC;
-  SymbolizableModule *Info = InfoOrErr.get();
+  SymbolizableModule *Info;
+  if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
+    Info = InfoOrErr.get();
+  else
+    return InfoOrErr.takeError();
+
+  // A null module means an error has already been reported. Return an empty
+  // result.
+  if (!Info)
+    return DILineInfo();
 
   // If the user is giving us relative addresses, add the preferred base of the
   // object to the offset before we do the query. It's what DIContext expects.
   if (Opts.RelativeAddresses)
     ModuleOffset += Info->getModulePreferredBase();
 
   DILineInfo LineInfo = Info->symbolizeCode(ModuleOffset, Opts.PrintFunctions,
                                             Opts.UseSymbolTable);
   if (Opts.Demangle)
     LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info);
   return LineInfo;
 }
 
-ErrorOr<DIInliningInfo>
+Expected<DIInliningInfo>
 LLVMSymbolizer::symbolizeInlinedCode(const std::string &ModuleName,
                                      uint64_t ModuleOffset) {
-  auto InfoOrErr = getOrCreateModuleInfo(ModuleName);
-  if (auto EC = InfoOrErr.getError())
-    return EC;
-  SymbolizableModule *Info = InfoOrErr.get();
+  SymbolizableModule *Info;
+  if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
+    Info = InfoOrErr.get();
+  else
+    return InfoOrErr.takeError();
+
+  // A null module means an error has already been reported. Return an empty
+  // result.
+  if (!Info)
+    return DIInliningInfo();
 
   // If the user is giving us relative addresses, add the preferred base of the
   // object to the offset before we do the query. It's what DIContext expects.
   if (Opts.RelativeAddresses)
     ModuleOffset += Info->getModulePreferredBase();
 
   DIInliningInfo InlinedContext = Info->symbolizeInlinedCode(
       ModuleOffset, Opts.PrintFunctions, Opts.UseSymbolTable);
   if (Opts.Demangle) {
     for (int i = 0, n = InlinedContext.getNumberOfFrames(); i < n; i++) {
       auto *Frame = InlinedContext.getMutableFrame(i);
       Frame->FunctionName = DemangleName(Frame->FunctionName, Info);
     }
   }
   return InlinedContext;
 }
 
-ErrorOr<DIGlobal> LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
+Expected<DIGlobal> LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
                                                  uint64_t ModuleOffset) {
-  auto InfoOrErr = getOrCreateModuleInfo(ModuleName);
-  if (auto EC = InfoOrErr.getError())
-    return EC;
-  SymbolizableModule *Info = InfoOrErr.get();
+  SymbolizableModule *Info;
+  if (auto InfoOrErr = getOrCreateModuleInfo(ModuleName))
+    Info = InfoOrErr.get();
+  else
+    return InfoOrErr.takeError();
+
+  // A null module means an error has already been reported. Return an empty
+  // result.
+  if (!Info)
+    return DIGlobal();
 
   // If the user is giving us relative addresses, add the preferred base of
   // the object to the offset before we do the query. It's what DIContext
   // expects.
   if (Opts.RelativeAddresses)
     ModuleOffset += Info->getModulePreferredBase();
 
   DIGlobal Global = Info->symbolizeData(ModuleOffset);
ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
   std::vector<std::string> DsymPaths;
   StringRef Filename = sys::path::filename(ExePath);
   DsymPaths.push_back(getDarwinDWARFResourceForPath(ExePath, Filename));
   for (const auto &Path : Opts.DsymHints) {
     DsymPaths.push_back(getDarwinDWARFResourceForPath(Path, Filename));
   }
   for (const auto &Path : DsymPaths) {
     auto DbgObjOrErr = getOrCreateObject(Path, ArchName);
-    if (!DbgObjOrErr)
+    if (!DbgObjOrErr) {
+      // Ignore errors, the file might not exist.
+      consumeError(DbgObjOrErr.takeError());
       continue;
+    }
     ObjectFile *DbgObj = DbgObjOrErr.get();
+    if (!DbgObj)
+      continue;
     const MachOObjectFile *MachDbgObj = dyn_cast<const MachOObjectFile>(DbgObj);
     if (!MachDbgObj)
       continue;
     if (darwinDsymMatchesBinary(MachDbgObj, MachExeObj))
       return DbgObj;
   }
   return nullptr;
 }
 
 ObjectFile *LLVMSymbolizer::lookUpDebuglinkObject(const std::string &Path,
                                                   const ObjectFile *Obj,
                                                   const std::string &ArchName) {
   std::string DebuglinkName;
   uint32_t CRCHash;
   std::string DebugBinaryPath;
   if (!getGNUDebuglinkContents(Obj, DebuglinkName, CRCHash))
     return nullptr;
   if (!findDebugBinary(Path, DebuglinkName, CRCHash, DebugBinaryPath))
     return nullptr;
   auto DbgObjOrErr = getOrCreateObject(DebugBinaryPath, ArchName);
-  if (!DbgObjOrErr)
+  if (!DbgObjOrErr) {
+    // Ignore errors, the file might not exist.
+    consumeError(DbgObjOrErr.takeError());
     return nullptr;
+  }
   return DbgObjOrErr.get();
 }
 
-ErrorOr<LLVMSymbolizer::ObjectPair>
+Expected<LLVMSymbolizer::ObjectPair>
 LLVMSymbolizer::getOrCreateObjectPair(const std::string &Path,
                                       const std::string &ArchName) {
   const auto &I = ObjectPairForPathArch.find(std::make_pair(Path, ArchName));
-  if (I != ObjectPairForPathArch.end())
+  if (I != ObjectPairForPathArch.end()) {
     return I->second;
+  }
 
   auto ObjOrErr = getOrCreateObject(Path, ArchName);
-  if (auto EC = ObjOrErr.getError()) {
-    ObjectPairForPathArch.insert(
-        std::make_pair(std::make_pair(Path, ArchName), EC));
-    return EC;
+  if (!ObjOrErr) {
+    ObjectPairForPathArch.insert(std::make_pair(std::make_pair(Path, ArchName),
+                                                ObjectPair(nullptr, nullptr)));
+    return ObjOrErr.takeError();
   }
 
   ObjectFile *Obj = ObjOrErr.get();
   assert(Obj != nullptr);
   ObjectFile *DbgObj = nullptr;
 
   if (auto MachObj = dyn_cast<const MachOObjectFile>(Obj))
     DbgObj = lookUpDsymFile(Path, MachObj, ArchName);
   if (!DbgObj)
     DbgObj = lookUpDebuglinkObject(Path, Obj, ArchName);
   if (!DbgObj)
     DbgObj = Obj;
   ObjectPair Res = std::make_pair(Obj, DbgObj);
   ObjectPairForPathArch.insert(
       std::make_pair(std::make_pair(Path, ArchName), Res));
   return Res;
 }
 
-ErrorOr<ObjectFile *>
+Expected<ObjectFile *>
 LLVMSymbolizer::getOrCreateObject(const std::string &Path,
                                   const std::string &ArchName) {
   const auto &I = BinaryForPath.find(Path);
   Binary *Bin = nullptr;
   if (I == BinaryForPath.end()) {
     Expected<OwningBinary<Binary>> BinOrErr = createBinary(Path);
     if (!BinOrErr) {
-      auto EC = errorToErrorCode(BinOrErr.takeError());
-      BinaryForPath.insert(std::make_pair(Path, EC));
-      return EC;
+      BinaryForPath.insert({Path, OwningBinary<Binary>()});
+      return BinOrErr.takeError();
     }
     Bin = BinOrErr->getBinary();
     BinaryForPath.insert(std::make_pair(Path, std::move(BinOrErr.get())));
-  } else if (auto EC = I->second.getError()) {
-    return EC;
   } else {
-    Bin = I->second->getBinary();
+    Bin = I->second.getBinary();
   }
 
-  assert(Bin != nullptr);
+  if (!Bin)
+    return static_cast<ObjectFile *>(nullptr);
 
-  if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(Bin)) {
+  if (MachOUniversalBinary *UB = dyn_cast_or_null<MachOUniversalBinary>(Bin)) {
     const auto &I = ObjectForUBPathAndArch.find(std::make_pair(Path, ArchName));
     if (I != ObjectForUBPathAndArch.end()) {
-      if (auto EC = I->second.getError())
-        return EC;
-      return I->second->get();
+      return I->second.get();
     }
     Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
         UB->getObjectForArch(ArchName);
     if (!ObjOrErr) {
-      auto EC = errorToErrorCode(ObjOrErr.takeError());
-      ObjectForUBPathAndArch.insert(
-          std::make_pair(std::make_pair(Path, ArchName), EC));
-      return EC;
+      ObjectForUBPathAndArch.insert(std::make_pair(
+          std::make_pair(Path, ArchName), std::unique_ptr<ObjectFile>()));
+      return ObjOrErr.takeError();
     }
     ObjectFile *Res = ObjOrErr->get();
     ObjectForUBPathAndArch.insert(std::make_pair(std::make_pair(Path, ArchName),
                                                  std::move(ObjOrErr.get())));
     return Res;
   }
   if (Bin->isObject()) {
     return cast<ObjectFile>(Bin);
   }
-  return object_error::arch_not_found;
+  return errorCodeToError(object_error::arch_not_found);
 }
 
-ErrorOr<SymbolizableModule *>
+Expected<SymbolizableModule *>
 LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
   const auto &I = Modules.find(ModuleName);
   if (I != Modules.end()) {
-    auto &InfoOrErr = I->second;
-    if (auto EC = InfoOrErr.getError())
-      return EC;
-    return InfoOrErr->get();
+    return I->second.get();
   }
   std::string BinaryName = ModuleName;
   std::string ArchName = Opts.DefaultArch;
   size_t ColonPos = ModuleName.find_last_of(':');
   // Verify that substring after colon form a valid arch name.
   if (ColonPos != std::string::npos) {
     std::string ArchStr = ModuleName.substr(ColonPos + 1);
     if (Triple(ArchStr).getArch() != Triple::UnknownArch) {
       BinaryName = ModuleName.substr(0, ColonPos);
       ArchName = ArchStr;
     }
   }
   auto ObjectsOrErr = getOrCreateObjectPair(BinaryName, ArchName);
-  if (auto EC = ObjectsOrErr.getError()) {
+  if (!ObjectsOrErr) {
     // Failed to find valid object file.
-    Modules.insert(std::make_pair(ModuleName, EC));
-    return EC;
+    Modules.insert(
+        std::make_pair(ModuleName, std::unique_ptr<SymbolizableModule>()));
+    return ObjectsOrErr.takeError();
   }
   ObjectPair Objects = ObjectsOrErr.get();
 
   std::unique_ptr<DIContext> Context;
+  // If this is a COFF object containing PDB info, use a PDBContext to
+  // symbolize. Otherwise, use DWARF.
   if (auto CoffObject = dyn_cast<COFFObjectFile>(Objects.first)) {
+    const debug_pdb_info *PDBInfo;
+    StringRef PDBFileName;
+    auto EC = CoffObject->getDebugPDBInfo(PDBInfo, PDBFileName);
+    if (!EC && PDBInfo != nullptr) {
       using namespace pdb;
-    // If this is a COFF object, assume it contains PDB debug information.  If
-    // we don't find any we will fall back to the DWARF case.
       std::unique_ptr<IPDBSession> Session;
-    auto Error = loadDataForEXE(
-        PDB_ReaderType::DIA, Objects.first->getFileName(), Session);
-    if (!Error) {
+      if (auto Err = loadDataForEXE(PDB_ReaderType::DIA,
+                                    Objects.first->getFileName(), Session)) {
+        Modules.insert(
+            std::make_pair(ModuleName, std::unique_ptr<SymbolizableModule>()));
+        return std::move(Err);
+      }
       Context.reset(new PDBContext(*CoffObject, std::move(Session)));
-    } else {
-      // Drop error
-      handleAllErrors(std::move(Error),
-                      [](const ErrorInfoBase &) { return Error::success(); });
     }
   }
   if (!Context)
     Context.reset(new DWARFContextInMemory(*Objects.second));
   assert(Context);
   auto InfoOrErr =
       SymbolizableObjectFile::create(Objects.first, std::move(Context));
+  std::unique_ptr<SymbolizableModule> SymMod;
+  if (InfoOrErr)
+    SymMod = std::move(InfoOrErr.get());
   auto InsertResult =
-      Modules.insert(std::make_pair(ModuleName, std::move(InfoOrErr)));
+      Modules.insert(std::make_pair(ModuleName, std::move(SymMod)));
   assert(InsertResult.second);
-  if (auto EC = InsertResult.first->second.getError())
-    return EC;
-  return InsertResult.first->second->get();
+  if (auto EC = InfoOrErr.getError())
+    return errorCodeToError(EC);
+  return InsertResult.first->second.get();
 }
 
 namespace {
 
 // Undo these various manglings for Win32 extern "C" functions:
 // cdecl       - _foo
 // stdcall     - _foo@12
 // fastcall    - @foo@12

llvm/trunk/lib/Object/COFFObjectFile.cpp

std::error_code COFFObjectFile::getDebugPDBInfo(const debug_directory *DebugDir,
   InfoBytes = InfoBytes.drop_front(sizeof(debug_pdb_info));
   PDBFileName = StringRef(reinterpret_cast<const char *>(InfoBytes.data()),
                           InfoBytes.size());
   // Truncate the name at the first null byte. Ignore any padding.
   PDBFileName = PDBFileName.split('\0').first;
   return std::error_code();
 }
 
+std::error_code COFFObjectFile::getDebugPDBInfo(const debug_pdb_info *&PDBInfo,
+                                                StringRef &PDBFileName) const {
+  for (const debug_directory &D : debug_directories())
+    if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW)
+      return getDebugPDBInfo(&D, PDBInfo, PDBFileName);
+  // If we get here, there is no PDB info to return.
+  PDBInfo = nullptr;
+  PDBFileName = StringRef();
+  return std::error_code();
+}
+
 // Find the import table.
 std::error_code COFFObjectFile::initImportTablePtr() {
   // First, we get the RVA of the import table. If the file lacks a pointer to
   // the import table, do nothing.
   const data_directory *DataEntry;
   if (getDataDirectory(COFF::IMPORT_TABLE, DataEntry))
     return std::error_code();
 

llvm/trunk/test/tools/llvm-symbolizer/pdb/missing_pdb.test

+RUN: grep '^ADDR:' %s | sed -s 's/ADDR: //' \
+RUN:    | llvm-symbolizer -obj="%p/Inputs/missing_pdb.exe" 2>%t.err \
+RUN:    | FileCheck %s
+RUN: FileCheck --check-prefix=ERROR %s < %t.err
+
+ADDR: 0x401000
+ADDR: 0x401001
+
+llvm-symbolizer should print one error and two unknown line info records.
+
+ERROR: LLVMSymbolizer: error reading file: PDB Error: Unable to load PDB.  Make sure the file exists and is readable.
+ERROR-NOT: error reading file
+
+CHECK: ??
+CHECK: ??:0:0
+CHECK: ??
+CHECK: ??:0:0

llvm/trunk/tools/llvm-symbolizer/llvm-symbolizer.cpp

 static cl::opt<bool>
     ClPrettyPrint("pretty-print", cl::init(false),
                   cl::desc("Make the output more human friendly"));
 
 static cl::opt<int> ClPrintSourceContextLines(
     "print-source-context-lines", cl::init(0),
     cl::desc("Print N number of source file context"));
 
-static bool error(std::error_code ec) {
-  if (!ec)
+template<typename T>
+static bool error(Expected<T> &ResOrErr) {
+  if (ResOrErr)
     return false;
-  errs() << "LLVMSymbolizer: error reading file: " << ec.message() << ".\n";
+  logAllUnhandledErrors(ResOrErr.takeError(), errs(),
+                        "LLVMSymbolizer: error reading file: ");
   return true;
 }
 
 static bool parseCommand(StringRef InputString, bool &IsData,
                          std::string &ModuleName, uint64_t &ModuleOffset) {
   const char *kDataCmd = "DATA ";
   const char *kCodeCmd = "CODE ";
   const char kDelimiters[] = " \n\r";
while (true) {
     if (ClPrintAddress) {
       outs() << "0x";
       outs().write_hex(ModuleOffset);
       StringRef Delimiter = (ClPrettyPrint == true) ? ": " : "\n";
       outs() << Delimiter;
     }
     if (IsData) {
       auto ResOrErr = Symbolizer.symbolizeData(ModuleName, ModuleOffset);
-      Printer << (error(ResOrErr.getError()) ? DIGlobal() : ResOrErr.get());
+      Printer << (error(ResOrErr) ? DIGlobal() : ResOrErr.get());
     } else if (ClPrintInlining) {
       auto ResOrErr = Symbolizer.symbolizeInlinedCode(ModuleName, ModuleOffset);
-      Printer << (error(ResOrErr.getError()) ? DIInliningInfo()
+      Printer << (error(ResOrErr) ? DIInliningInfo()
                                              : ResOrErr.get());
     } else {
       auto ResOrErr = Symbolizer.symbolizeCode(ModuleName, ModuleOffset);
-      Printer << (error(ResOrErr.getError()) ? DILineInfo() : ResOrErr.get());
+      Printer << (error(ResOrErr) ? DILineInfo() : ResOrErr.get());
     }
     outs() << "\n";
     outs().flush();
   }
 
   return 0;
 }

llvm/trunk/tools/sancov/sancov.cc

static void FailIfError(std::error_code Error) {
   errs() << "Error: " << Error.message() << "(" << Error.value() << ")\n";
   exit(1);
 }
 
 template <typename T> static void FailIfError(const ErrorOr<T> &E) {
   FailIfError(E.getError());
 }
 
+template <typename T> static void FailIfError(Expected<T> &E) {
+  if (E)
+    return;
+  logAllUnhandledErrors(E.takeError(), errs(), "Error: ");
+}
+
 static void FailIfNotEmpty(const llvm::Twine &E) {
   if (E.str().empty())
     return;
   Fail(E);
 }
 
 template <typename T>
 static void FailIfEmpty(const std::unique_ptr<T> &Ptr,

llvm/trunk/tools/sanstats/sanstats.cpp

while (1) {
 
     if (Begin > End)
       return nullptr;
     if (Addr == 0 && Data == 0)
       return Begin;
     if (Begin == End)
       return nullptr;
 
-    ErrorOr<DILineInfo> LineInfo = Symbolizer.symbolizeCode(Filename, Addr);
-    if (LineInfo) {
+    if (Expected<DILineInfo> LineInfo =
+            Symbolizer.symbolizeCode(Filename, Addr)) {
       llvm::outs() << LineInfo->FileName << ':' << LineInfo->Line << ' '
                    << LineInfo->FunctionName << ' ';
     } else {
-      llvm::outs() << "<error> ";
+      logAllUnhandledErrors(LineInfo.takeError(), llvm::outs(), "<error> ");
     }
 
     switch (KindFromData(Data, SizeofPtr)) {
     case SanStat_CFI_VCall:
       llvm::outs() << "cfi-vcall";
       break;
     case SanStat_CFI_NVCall:
       llvm::outs() << "cfi-nvcall";