[LLD] Normalize PDB error messages

[aganea]

Summary

The intent of this change initially was to:

• standardize LLD's PDB errors/messages
• provide more context when an error occurs
• add test coverage for all possible PDB warnings/errors kinds in LLD
• prepare errors for the upcoming precompiled headers ( D45213 )

It seemed along the way that some other changes were needed:

1. It is sometimes hard to cleanly represent the 'source' of an error. We know the error, but not which file caused it. I've added a minimal FileError for that purpose (llvm/Support/Error.h). Some more changes will be needed later on, such as a takeError() function, currently not required.
2. All the error types in llvm/.../DebugInfo/... were having the same kind of functionality, so I normalized that into DebugInfoError (llvm/Support/Error.h) - a better class name suggestion is welcome.
3. I realized that from a UX perspective, the overall printing of error & warnings in LLVM is not uniform, uses different wording, different layout, etc. (see below) It would be good on the long run to: a. decide on a consistent output for most common cases; b. maybe raise the abstraction for the error system to constrain how errors are printed.

Other changes in this patch at a glance:

• Renamed GenericError into PDBError (llvm/Debuginfo/PDB/GenericError.h)
• Changed some PDBError messages because they weren't consistent with their origin.
• Clarified the error type when the PDB signature doesn't match.
• The same error message is now printed when a PDB fails loading a second time (referenced from different .objs).
• Retry loading a PDB with filename works only if the previous error was "No such file or directory"
• Add more context when a PDB (or a precompiled headers .obj) error occurs. Previously, only the .obj name was displayed.

As for the error inconsistencies I've noted so far:

Bad: Inconsistent period at the end of error strings:

• _readobj_error_category::message() has it:

std::string _readobj_error_category::message(int EV) const {
  switch (static_cast<readobj_error>(EV)) {
  case readobj_error::success: return "Success";
  case readobj_error::file_not_found:
    return "No such file.";

• CoverageMappingErrorCategoryType::message() does not:

static std::string getCoverageMapErrString(coveragemap_error Err) {
  switch (Err) {
  case coveragemap_error::success:
    return "Success";
  case coveragemap_error::eof:
    return "End of File";
  case coveragemap_error::no_data_found:
    return "No coverage data found";

I'm currently torn between whether a std::error_code should print the ending period of not. At first sight, it seems not printing it would be better.

Good: Most error_category::message() implementations start with an uppercase.

Bad: Tool error messages sometimes start with an uppercase...

(LLD/COFF/PDB.cpp)
  warn("Cannot open input file: " + File);

...sometimes with a lowercase:

(llvm-objdump.cpp)
  errs() << ToolName << ": error reading file: " << EC.message() << ".\n";

Bad: ExitOnError vs. printing errors "by hand" - ExitOnError uses logAllUnhandledErrors() which currently does not allow for adding an ending period which isn't there.

Bad: Some printers inherently add two CRs, one by going through logAllUnhandledErrors() and one externally while logging the message.

Bad: Some printers add an extra ending period character, one from the original error message, and one from the manual error printer (see llvm-objdump example above).

Those topics should probably be discussed, but I simply want to have you feeling overall.

[zturner]

I would split this into 3 separate patches.

Patch 1: Add FileError and DebugInfoError
Patch 2: Make new subclasses of DebugInfoError
Patch 3: Update LLD to use 1 and 2.

lld/trunk/COFF/PDB.cpp

857–859

We might be doing a cross-build, so this should probably be native path style.

lld/trunk/test/COFF/Inputs/bad-block-size.pdb

2

Is it necessary to check in a PDB for this? Would yaml2pdb be able to generate this file?

llvm/trunk/include/llvm/Support/Error.h

1236

ManagedStatic in a header file seems bad, because every TU that includes this will get a different copy of it, no?

[aganea]

lld/trunk/test/COFF/Inputs/bad-block-size.pdb

2

The PDB is a mere 29 bytes. yaml2pdb seems to only generates valid PDB files (un)fortunately.

This file is a copy of /llvm/trunk/test/DebugInfo/PDB/Inputs/bad-block-size.pdb. I don't think referencing that file across depots would be a good thing?

llvm/trunk/include/llvm/Support/Error.h

1236

Moved specializations to own .cpp - I will update the diff shortly.

[aganea]

Corrected issues. Please let me know if there's anything else.
I will split the patch as suggested.

[aganea]

Closing this, I will reopen a new review which reflects better the remaining changes.

lld/trunk/COFF/PDB.cpp

private:
 
   std::vector<pdb::SecMapEntry> SectionMap;
 
   /// Type index mappings of type server PDBs that we've loaded so far.
   std::map<GUID, CVIndexMap> TypeServerIndexMappings;
 
   /// List of TypeServer PDBs which cannot be loaded.
   /// Cached to prevent repeated load attempts.
-  std::set<GUID> MissingTypeServerPDBs;
+  std::map<GUID, std::string> MissingTypeServerPDBs;
 };
 }
 
 static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
                                 StringRef Name) {
   for (SectionChunk *C : Sections)
     if (C->getSectionName() == Name)
       return C;
tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
   // All PDB Files should have an Info stream.
   if (!ExpectedInfo)
     return ExpectedInfo.takeError();
 
   // Just because a file with a matching name was found and it was an actual
   // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
   // must match the GUID specified in the TypeServer2 record.
   if (ExpectedInfo->getGuid() != GuidFromObj)
-    return make_error<pdb::GenericError>(
-        pdb::generic_error_code::type_server_not_found, TSPath);
+    return make_error<pdb::PDBError>(
+        pdb::pdb_error_code::signature_out_of_date);
 
   return std::move(NS);
 }
 
 Expected<const CVIndexMap&> PDBLinker::maybeMergeTypeServerPDB(ObjFile *File,
                                                                TypeServer2Record &TS) {
-  const GUID& TSId = TS.getGuid();
+  const GUID &TSId = TS.getGuid();
   StringRef TSPath = TS.getName();
 
   // First, check if the PDB has previously failed to load.
-  if (MissingTypeServerPDBs.count(TSId))
-    return make_error<pdb::GenericError>(
-      pdb::generic_error_code::type_server_not_found, TSPath);
+  auto PrevErr = MissingTypeServerPDBs.find(TSId);
+  if (PrevErr != MissingTypeServerPDBs.end())
+    return createFileError(TSPath, std::move(make_error<StringError>(PrevErr->second, inconvertibleErrorCode())));
 
   // Second, check if we already loaded a PDB with this GUID. Return the type
   // index mapping if we have it.
   auto Insertion = TypeServerIndexMappings.insert({TSId, CVIndexMap()});
   CVIndexMap &IndexMap = Insertion.first->second;
   if (!Insertion.second)
     return IndexMap;
 
   // Mark this map as a type server map.
   IndexMap.IsTypeServerMap = true;
 
   // Check for a PDB at:
   // 1. The given file path
   // 2. Next to the object file or archive file
-  auto ExpectedSession = tryToLoadPDB(TSId, TSPath);
-  if (!ExpectedSession) {
-    consumeError(ExpectedSession.takeError());
+  auto ExpectedSession = handleExpected(
+      tryToLoadPDB(TSId, TSPath),
+      [&]() {
         StringRef LocalPath =
             !File->ParentName.empty() ? File->ParentName : File->getName();
         SmallString<128> Path = sys::path::parent_path(LocalPath);
         sys::path::append(
             Path, sys::path::filename(TSPath, sys::path::Style::windows));
-    ExpectedSession = tryToLoadPDB(TSId, Path);
-  }
+        return tryToLoadPDB(TSId, Path);
+      },
+      [&](std::unique_ptr<ECError> EC) -> Error {
+        auto SysErr = EC->convertToErrorCode();
+        // Only re-try loading if the previous error was "No such file or
+        // directory"
+        if (SysErr.category() == std::generic_category() &&
+            SysErr.value() == ENOENT)
+          return Error::success();
+        return Error(std::move(EC));
+      });
+
   if (auto E = ExpectedSession.takeError()) {
     TypeServerIndexMappings.erase(TSId);
-    MissingTypeServerPDBs.emplace(TSId);
-    return std::move(E);
+
+    // Flatten the error to a string, for later display, if the error occurs
+    // again on the same PDB.
+    std::string ErrMsg;
+    raw_string_ostream S(ErrMsg);
+    S << E;
+    auto It = MissingTypeServerPDBs.emplace(TSId, S.str());
+
+    return createFileError(TSPath, std::move(E));
   }
 
   pdb::NativeSession *Session = ExpectedSession->get();
 
   // Keep a strong reference to this PDB, so that it's safe to hold pointers
   // into the file.
   LoadedPDBs.push_back(std::move(*ExpectedSession));
 
void PDBLinker::addObjFile(ObjFile *File) {
   // type information, file checksums, and the string table.  Add type info to
   // the PDB first, so that we can get the map from object file type and item
   // indices to PDB type and item indices.
   CVIndexMap ObjectIndexMap;
   auto IndexMapResult = mergeDebugT(File, ObjectIndexMap);
 
   // If the .debug$T sections fail to merge, assume there is no debug info.
   if (!IndexMapResult) {
-    warn("Type server PDB for " + Name + " is invalid, ignoring debug info. " +
-         toString(IndexMapResult.takeError()));
+    auto FileName = sys::path::filename(Path);
+    warn("Cannot use debug info for '" + FileName + "'\n" +
+         "  failed to load referenced file " + StringRef(toString(IndexMapResult.takeError())) + ".");
     return;
   }
 
   const CVIndexMap &IndexMap = *IndexMapResult;
 
   ScopedTimer T(SymbolMergingTimer);
 
   // Now do all live .debug$S sections.
case COFF::IMAGE_FILE_MACHINE_ARMNT:
     return codeview::CPUType::ARMNT;
   case COFF::IMAGE_FILE_MACHINE_I386:
     return codeview::CPUType::Intel80386;
   default:
     llvm_unreachable("Unsupported CPU Type");
   }
 }
 
+static std::string quote(ArrayRef<StringRef> Args) {
+  std::string ArgStr;
+  ArgStr.reserve(256);
+  for (StringRef Arg : Args) {
+    if (!ArgStr.empty())
+      ArgStr.push_back(' ');
+    bool HasWS = Arg.find(' ') != StringRef::npos;
+    if (HasWS)
+      ArgStr.push_back('"');
+    ArgStr.append(Arg);
+    if (HasWS)
+      ArgStr.push_back('"');
+  }
+  return ArgStr;
+}
+
 static void addCommonLinkerModuleSymbols(StringRef Path,
                                          pdb::DbiModuleDescriptorBuilder &Mod,
                                          BumpPtrAllocator &Allocator) {
   ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
   Compile3Sym CS(SymbolRecordKind::Compile3Sym);
   EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
 
   ONS.Name = "* Linker *";
static void addCommonLinkerModuleSymbols(StringRef Path,
   CS.VersionFrontendBuild = 0;
   CS.VersionFrontendMajor = 0;
   CS.VersionFrontendMinor = 0;
   CS.VersionFrontendQFE = 0;
   CS.Version = "LLVM Linker";
   CS.setLanguage(SourceLanguage::Link);
 
   ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
-  std::string ArgStr = llvm::join(Args, " ");
+  // Mimic MSVC which surrounds arguments containing whitespace with quotes.
+  std::string ArgStr = quote(Args);
   EBS.Fields.push_back("cwd");
   SmallString<64> cwd;
   sys::fs::current_path(cwd);
   EBS.Fields.push_back(cwd);
   EBS.Fields.push_back("exe");
   SmallString<64> exe = Config->Argv[0];
   llvm::sys::fs::make_absolute(exe);
   EBS.Fields.push_back(exe);

lld/trunk/Common/ErrorHandler.cpp

 }
 
 ErrorHandler &lld::errorHandler() {
   static ErrorHandler Handler;
   return Handler;
 }
 
 void lld::exitLld(int Val) {
-  // Delete the output buffer so that any tempory file is deleted.
+  // Delete the output buffer so that any temporary file is deleted.
   errorHandler().OutputBuffer.reset();
 
   // Dealloc/destroy ManagedStatic variables before calling
   // _exit(). In a non-LTO build, this is a nop. In an LTO
   // build allows us to get the output of -time-passes.
   llvm_shutdown();
 
   outs().flush();

lld/trunk/test/COFF/Inputs/bad-block-size.pdb

+Microsoft C/C++ MSF 7.00
+␚DS
 No newline at end of file

lld/trunk/test/COFF/Inputs/pdb-type-server-missing-2.yaml

+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            '.debug$T'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Types:
+      - Kind:            LF_TYPESERVER2
+        TypeServer2:
+          Guid:            '{01DF191B-22BF-6B42-96CE-5258B8329FE5}'
+          Age:             18
+          Name:            'C:\src\llvm-project\build\definitely_not_found_for_sure.pdb'
+  - Name:            '.text$mn'
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     33C0C3
+symbols:
+  - Name:            '.debug$T'
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          564
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+...

lld/trunk/test/COFF/Inputs/pdb-type-server-valid-signature.yaml

+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            '.debug$S'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Subsections:
+      - !Symbols
+        Records:
+          - Kind:            S_GPROC32_ID
+            ProcSym:
+              CodeSize:        3
+              DbgStart:        0
+              DbgEnd:          2
+              FunctionType:    4199
+              Flags:           [  ]
+              DisplayName:     main
+          - Kind:            S_FRAMEPROC
+            FrameProcSym:
+              TotalFrameBytes: 0
+              PaddingFrameBytes: 0
+              OffsetToPadding: 0
+              BytesOfCalleeSavedRegisters: 0
+              OffsetOfExceptionHandler: 0
+              SectionIdOfExceptionHandler: 0
+              Flags:           [ AsynchronousExceptionHandling, OptimizedForSpeed ]
+          - Kind:            S_PROC_ID_END
+            ScopeEndSym:
+      - !Lines
+        CodeSize:        3
+        Flags:           [  ]
+        RelocOffset:     0
+        RelocSegment:    0
+        Blocks:
+          - FileName:        'c:\src\llvm-project\build\t.c'
+            Lines:
+              - Offset:          0
+                LineStart:       1
+                IsStatement:     true
+                EndDelta:        0
+            Columns:
+      - !FileChecksums
+        Checksums:
+          - FileName:        'c:\src\llvm-project\build\t.c'
+            Kind:            MD5
+            Checksum:        270A878DCC1B845655B162F56C4F5020
+      - !StringTable
+        Strings:
+          - 'c:\src\llvm-project\build\t.c'
+    Relocations:
+      - VirtualAddress:  44
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECREL
+      - VirtualAddress:  48
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECTION
+      - VirtualAddress:  100
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECREL
+      - VirtualAddress:  104
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECTION
+  - Name:            '.debug$T'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Types:
+      - Kind:            LF_TYPESERVER2
+        TypeServer2:
+          Guid:            '{8DABD2A0-28FF-CB43-9BAF-175B77B76414}'
+          Age:             18
+          Name:            'pdb-diff-cl.pdb'
+  - Name:            '.text$mn'
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     33C0C3
+symbols:
+  - Name:            '.debug$S'
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          328
+      NumberOfRelocations: 4
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            '.debug$T'
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          564
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            '.text$mn'
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          3
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        4021952397
+      Number:          0
+  - Name:            main
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...

lld/trunk/test/COFF/pdb-linker-module.test

 RUN: echo "/nodefaultlib" > %t.rsp
-RUN: lld-link /debug /pdb:%t.pdb @%t.rsp /entry:main %S/Inputs/pdb-diff.obj
+RUN: lld-link /debug /pdb:%t.pdb /nodefaultlib /entry:main /manifestuac:"level='asInvoker' uiAccess='false'" %S/Inputs/pdb-diff.obj
 RUN: llvm-pdbutil dump -modules %t.pdb | FileCheck --check-prefix=MODS %s
 RUN: llvm-pdbutil dump -symbols %t.pdb | FileCheck --check-prefix=SYMS %s
 
 MODS:      Mod 0001 | `* Linker *`
 MODS-NEXT:             Obj: ``:
 MODS-NEXT:             debug stream: 12, # files: 0, has ec info: false
 MODS-NEXT:             pdb file ni: 1 `{{.*}}pdb-linker-module.test.tmp.pdb`, src file ni: 0 ``
 
 SYMS:      Mod 0001 | `* Linker *`
 SYMS-NEXT:  4 | S_OBJNAME [size = 20] sig=0, `* Linker *`
 SYMS-NEXT: 24 | S_COMPILE3 [size = 40]
 SYMS-NEXT:      machine = intel 80386, Ver = LLVM Linker, language = link
 SYMS-NEXT:      frontend = 0.0.0.0, backend = 14.10.25019.0
 SYMS-NEXT:      flags = none
 SYMS-NEXT: 64 | S_ENVBLOCK
 SYMS-NEXT: - cwd
 SYMS-NEXT: -
 SYMS-NEXT: - exe
 SYMS-NEXT: - {{.*}}lld-link
 SYMS-NEXT: - pdb
 SYMS-NEXT: - {{.*}}pdb-linker-module{{.*}}pdb
 SYMS-NEXT: - cmd
-SYMS-NEXT: - /debug /pdb:{{.*}}pdb-linker-module{{.*}}pdb /nodefaultlib /entry:main {{.*}}pdb-diff.obj
+SYMS-NEXT: - /debug /pdb:{{.*}}pdb-linker-module{{.*}}pdb /nodefaultlib /entry:main "/manifestuac:level='asInvoker' uiAccess='false'" {{.*}}pdb-diff.obj

lld/trunk/test/COFF/pdb-type-server-invalid-signature.yaml

+
+# RUN: cd %S/Inputs
+# RUN: yaml2obj %s -o %t.obj
+# RUN: lld-link %t.obj -out:%t.exe -debug -pdb:%t.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s
+# RUN: cd %S
+
+# CHECK: warning: Cannot use debug info for {{.*}}.obj
+# CHECK-NEXT: The signature does not match; the file(s) might be out of date
+
+# Also test a valid match
+
+# RUN: cd %S/Inputs
+# RUN: yaml2obj %S/Inputs/pdb-type-server-valid-signature.yaml -o %t2.obj
+# RUN: lld-link %t2.obj -out:%t2.exe -debug -pdb:%t2.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s -check-prefix=VALID-SIGNATURE -allow-empty
+# RUN: cd %S
+
+# VALID-SIGNATURE-NOT: warning: Cannot use debug info for {{.*}}.obj
+# VALID-SIGNATURE-NOT: The signature does not match; the file(s) might be out of date
+
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            '.debug$S'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Subsections:
+      - !Symbols
+        Records:
+          - Kind:            S_GPROC32_ID
+            ProcSym:
+              CodeSize:        3
+              DbgStart:        0
+              DbgEnd:          2
+              FunctionType:    4199
+              Flags:           [  ]
+              DisplayName:     main
+          - Kind:            S_FRAMEPROC
+            FrameProcSym:
+              TotalFrameBytes: 0
+              PaddingFrameBytes: 0
+              OffsetToPadding: 0
+              BytesOfCalleeSavedRegisters: 0
+              OffsetOfExceptionHandler: 0
+              SectionIdOfExceptionHandler: 0
+              Flags:           [ AsynchronousExceptionHandling, OptimizedForSpeed ]
+          - Kind:            S_PROC_ID_END
+            ScopeEndSym:
+      - !Lines
+        CodeSize:        3
+        Flags:           [  ]
+        RelocOffset:     0
+        RelocSegment:    0
+        Blocks:
+          - FileName:        'c:\src\llvm-project\build\t.c'
+            Lines:
+              - Offset:          0
+                LineStart:       1
+                IsStatement:     true
+                EndDelta:        0
+            Columns:
+      - !FileChecksums
+        Checksums:
+          - FileName:        'c:\src\llvm-project\build\t.c'
+            Kind:            MD5
+            Checksum:        270A878DCC1B845655B162F56C4F5020
+      - !StringTable
+        Strings:
+          - 'c:\src\llvm-project\build\t.c'
+    Relocations:
+      - VirtualAddress:  44
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECREL
+      - VirtualAddress:  48
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECTION
+      - VirtualAddress:  100
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECREL
+      - VirtualAddress:  104
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECTION
+  - Name:            '.debug$T'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Types:
+      - Kind:            LF_TYPESERVER2
+        TypeServer2:
+          Guid:            '{01DF191B-22BF-6B42-96CE-5258B8329FE5}'
+          Age:             18
+          Name:            'pdb-diff-cl.pdb'
+  - Name:            '.text$mn'
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     33C0C3
+symbols:
+  - Name:            '.debug$S'
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          328
+      NumberOfRelocations: 4
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            '.debug$T'
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          564
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            '.text$mn'
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          3
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        4021952397
+      Number:          0
+  - Name:            main
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...

lld/trunk/test/COFF/pdb-type-server-missing.yaml

 # This is an object compiled with /Zi (see the LF_TYPESERVER2 record) without an
 # adjacent type server PDB. Test that LLD fails gracefully on it.
 
-# RUN: yaml2obj %s -o %t.obj
-# RUN: lld-link %t.obj -out:%t.exe -debug -pdb:%t.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s
+# RUN: yaml2obj %s -o %t1.obj
+# RUN: yaml2obj %p/Inputs/pdb-type-server-missing-2.yaml -o %t2.obj
+# RUN: lld-link %t1.obj %t2.obj -out:%t.exe -debug -pdb:%t.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s
 
-# CHECK: warning: Type server PDB for {{.*}}.obj is invalid, ignoring debug info.
+# CHECK: warning: Cannot use debug info for {{.*}}.obj
+# CHECK-NEXT: {{N|n}}o such file or directory
+
+# CHECK: warning: Cannot use debug info for {{.*}}.obj
+# CHECK-NEXT: {{N|n}}o such file or directory
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: [  ]
 sections:
   - Name:            '.debug$S'
     Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]

lld/trunk/test/COFF/pdb-type-server-native-errors.yaml

+
+# RUN: cd %S/Inputs
+# RUN: yaml2obj %s -o %t.obj
+# RUN: lld-link %t.obj -out:%t.exe -debug -pdb:%t.pdb -nodefaultlib -entry:main 2>&1 | FileCheck %s
+# RUN: cd %S
+
+# CHECK: warning: Cannot use debug info for {{.*}}.obj
+# CHECK-NEXT: The PDB file is corrupt. MSF superblock is missing
+
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            '.debug$S'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Subsections:
+      - !Symbols
+        Records:
+          - Kind:            S_GPROC32_ID
+            ProcSym:
+              CodeSize:        3
+              DbgStart:        0
+              DbgEnd:          2
+              FunctionType:    4199
+              Flags:           [  ]
+              DisplayName:     main
+          - Kind:            S_FRAMEPROC
+            FrameProcSym:
+              TotalFrameBytes: 0
+              PaddingFrameBytes: 0
+              OffsetToPadding: 0
+              BytesOfCalleeSavedRegisters: 0
+              OffsetOfExceptionHandler: 0
+              SectionIdOfExceptionHandler: 0
+              Flags:           [ AsynchronousExceptionHandling, OptimizedForSpeed ]
+          - Kind:            S_PROC_ID_END
+            ScopeEndSym:
+      - !Lines
+        CodeSize:        3
+        Flags:           [  ]
+        RelocOffset:     0
+        RelocSegment:    0
+        Blocks:
+          - FileName:        'c:\src\llvm-project\build\t.c'
+            Lines:
+              - Offset:          0
+                LineStart:       1
+                IsStatement:     true
+                EndDelta:        0
+            Columns:
+      - !FileChecksums
+        Checksums:
+          - FileName:        'c:\src\llvm-project\build\t.c'
+            Kind:            MD5
+            Checksum:        270A878DCC1B845655B162F56C4F5020
+      - !StringTable
+        Strings:
+          - 'c:\src\llvm-project\build\t.c'
+    Relocations:
+      - VirtualAddress:  44
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECREL
+      - VirtualAddress:  48
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECTION
+      - VirtualAddress:  100
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECREL
+      - VirtualAddress:  104
+        SymbolName:      main
+        Type:            IMAGE_REL_AMD64_SECTION
+  - Name:            '.debug$T'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Types:
+      - Kind:            LF_TYPESERVER2
+        TypeServer2:
+          Guid:            '{01DF191B-22BF-6B42-96CE-5258B8329FE5}'
+          Age:             18
+          Name:            'bad-block-size.pdb'
+  - Name:            '.text$mn'
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     33C0C3
+symbols:
+  - Name:            '.debug$S'
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          328
+      NumberOfRelocations: 4
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            '.debug$T'
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          564
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            '.text$mn'
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          3
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        4021952397
+      Number:          0
+  - Name:            main
+    Value:           0
+    SectionNumber:   3
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...

llvm/trunk/include/llvm/DebugInfo/CodeView/CodeViewError.h

enum class cv_error_code {
   unspecified = 1,
   insufficient_buffer,
   operation_unsupported,
   corrupt_record,
   no_records,
   unknown_member_record,
 };
 
+class CodeViewErrorCategory : public std::error_category {
+public:
+  const char *name() const noexcept override;
+  std::string message(int Condition) const override;
+};
+
 /// Base class for errors originating when parsing raw PDB files
-class CodeViewError : public ErrorInfo<CodeViewError> {
+class CodeViewError : public DebugErrorInfo<CodeViewError, cv_error_code, CodeViewErrorCategory> {
 public:
-  static char ID;
-  CodeViewError(cv_error_code C);
-  CodeViewError(const std::string &Context);
-  CodeViewError(cv_error_code C, const std::string &Context);
-
-  void log(raw_ostream &OS) const override;
-  const std::string &getErrorMessage() const;
-  std::error_code convertToErrorCode() const override;
-
-private:
-  std::string ErrMsg;
-  cv_error_code Code;
+  using DebugErrorInfo<CodeViewError, cv_error_code, CodeViewErrorCategory>::DebugErrorInfo;
 };
-}
-}
+
+} // namespace codeview
+} // namespace llvm
 #endif

llvm/trunk/include/llvm/DebugInfo/MSF/MSFError.h

enum class msf_error_code {
   unspecified = 1,
   insufficient_buffer,
   not_writable,
   no_stream,
   invalid_format,
   block_in_use
 };
 
+class MSFErrorCategory : public std::error_category {
+public:
+  const char *name() const noexcept override;
+  std::string message(int Condition) const override;
+};
+
 /// Base class for errors originating when parsing raw PDB files
-class MSFError : public ErrorInfo<MSFError> {
+class MSFError : public DebugErrorInfo<MSFError, msf_error_code, MSFErrorCategory> {
 public:
-  static char ID;
-  MSFError(msf_error_code C);
-  MSFError(const std::string &Context);
-  MSFError(msf_error_code C, const std::string &Context);
-
-  void log(raw_ostream &OS) const override;
-  const std::string &getErrorMessage() const;
-  std::error_code convertToErrorCode() const override;
-
-private:
-  std::string ErrMsg;
-  msf_error_code Code;
+  using DebugErrorInfo<MSFError, msf_error_code, MSFErrorCategory>::DebugErrorInfo;
 };
 } // namespace msf
 } // namespace llvm
 
 #endif // LLVM_DEBUGINFO_MSF_MSFERROR_H

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIAError.h

enum class dia_error_code {
   unspecified = 1,
   could_not_create_impl,
   invalid_file_format,
   invalid_parameter,
   already_loaded,
   debug_info_mismatch,
 };
 
-/// Base class for errors originating in DIA SDK, e.g. COM calls
-class DIAError : public ErrorInfo<DIAError> {
+class DIAErrorCategory : public std::error_category {
 public:
-  static char ID;
-  DIAError(dia_error_code C);
-  DIAError(StringRef Context);
-  DIAError(dia_error_code C, StringRef Context);
-
-  void log(raw_ostream &OS) const override;
-  StringRef getErrorMessage() const;
-  std::error_code convertToErrorCode() const override;
+  const char *name() const noexcept override;
+  std::string message(int Condition) const override;
+};
 
-private:
-  std::string ErrMsg;
-  dia_error_code Code;
+/// Base class for errors originating in DIA SDK, e.g. COM calls
+class DIAError : public DebugErrorInfo<DIAError, dia_error_code, DIAErrorCategory> {
+public:
+  using DebugErrorInfo<DIAError, dia_error_code, DIAErrorCategory>::DebugErrorInfo;
 };
-}
-}
+} // namespace pdb
+} // namespace llvm
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/GenericError.h

 #define LLVM_DEBUGINFO_PDB_ERROR_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 
-enum class generic_error_code {
-  invalid_path = 1,
+enum class pdb_error_code {
+  invalid_utf8_path = 1,
   dia_sdk_not_present,
-  type_server_not_found,
+  dia_failed_loading,
+  signature_out_of_date,
   unspecified,
 };
 
+class PDBErrorCategory : public std::error_category {
+public:
+  const char *name() const noexcept override;
+  std::string message(int Condition) const override;
+};
+
 /// Base class for errors originating when parsing raw PDB files
-class GenericError : public ErrorInfo<GenericError> {
+class PDBError : public DebugErrorInfo<PDBError, pdb_error_code, PDBErrorCategory> {
 public:
-  static char ID;
-  GenericError(generic_error_code C);
-  GenericError(StringRef Context);
-  GenericError(generic_error_code C, StringRef Context);
-
-  void log(raw_ostream &OS) const override;
-  StringRef getErrorMessage() const;
-  std::error_code convertToErrorCode() const override;
-
-private:
-  std::string ErrMsg;
-  generic_error_code Code;
+  using DebugErrorInfo<PDBError, pdb_error_code, PDBErrorCategory>::DebugErrorInfo;
 };
-}
-}
+} // namespace pdb
+} // namespace llvm
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/Native/RawError.h

enum class raw_error_code {
   invalid_block_address,
   duplicate_entry,
   no_entry,
   not_writable,
   stream_too_long,
   invalid_tpi_hash,
 };
 
+class RawErrorCategory : public std::error_category {
+public:
+  const char *name() const noexcept override;
+  std::string message(int Condition) const override;
+};
+
 /// Base class for errors originating when parsing raw PDB files
-class RawError : public ErrorInfo<RawError> {
+class RawError : public DebugErrorInfo<RawError, raw_error_code, RawErrorCategory> {
 public:
-  static char ID;
-  RawError(raw_error_code C);
-  RawError(const std::string &Context);
-  RawError(raw_error_code C, const std::string &Context);
-
-  void log(raw_ostream &OS) const override;
-  const std::string &getErrorMessage() const;
-  std::error_code convertToErrorCode() const override;
-
-private:
-  std::string ErrMsg;
-  raw_error_code Code;
+  using DebugErrorInfo<RawError, raw_error_code, RawErrorCategory>::DebugErrorInfo;
 };
-}
-}
+} // namespace pdb
+} // namespace llvm
 #endif

llvm/trunk/include/llvm/Support/Error.h

 #include "llvm/Config/abi-breaking.h"
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/ManagedStatic.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
 #include <functional>
 #include <memory>
 #include <new>
 #include <string>

 /// that it has a void return type, and requires all errors to be handled and
 /// no new errors be returned. It prevents errors (assuming they can all be
 /// handled) from having to be bubbled all the way to the top-level.
 ///
 /// *All* Error instances must be checked before destruction, even if
 /// they're moved-assigned or constructed from Success values that have already
 /// been checked. This enforces checking through all levels of the call stack.
 class LLVM_NODISCARD Error {
-  // ErrorList needs to be able to yank ErrorInfoBase pointers out of this
-  // class to add to the error list.
+  // Both ErrorList and FileError needs to be able to yank ErrorInfoBase
+  // pointers out of this class to add to the error list.
   friend class ErrorList;
+  friend class FileError;
 
   // handleErrors needs to be able to set the Checked flag.
   template <typename... HandlerTs>
   friend Error handleErrors(Error E, HandlerTs &&... Handlers);
 
   // Expected<T> needs to be able to steal the payload when constructed from an
   // error.
   template <typename T> friend class Expected;

 ///   enum FooStrategy { Aggressive, Conservative };
 ///   Expected<Foo> foo(FooStrategy S);
 ///
 ///   auto ResultOrErr =
 ///     handleExpected(
 ///       foo(Aggressive),
 ///       []() { return foo(Conservative); },
 ///       [](AggressiveStrategyError&) {
-///         // Implicitly conusme this - we'll recover by using a conservative
+///         // Implicitly consume this - we'll recover by using a conservative
 ///         // strategy.
 ///       });
 ///
 ///   @endcode
 template <typename T, typename RecoveryFtor, typename... HandlerTs>
 Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
                            HandlerTs &&... Handlers) {
   if (ValOrErr)
Error createStringError(std::error_code EC, char const *Fmt,
   std::string Buffer;
   raw_string_ostream Stream(Buffer);
   Stream << format(Fmt, Vals...);
   return make_error<StringError>(Stream.str(), EC);
 }
 
 Error createStringError(std::error_code EC, char const *Msg);
 
+/// This class wraps a filename and another Error.
+///
+/// In some cases, an error needs to live along a 'source' name, in order to
+/// show more detailed information to the user.
+class FileError final : public ErrorInfo<FileError> {
+
+  friend Error createFileError(std::string, Error);
+
+public:
+  void log(raw_ostream &OS) const override {
+    OS << "'" << FileName << "': ";
+    Err->log(OS);
+  }
+
+  std::error_code convertToErrorCode() const override;
+
+  // Used by ErrorInfo::classID.
+  static char ID;
+
+private:
+  FileError(std::string F, std::unique_ptr<ErrorInfoBase> Payload) {
+    FileName = F;
+    Err = std::move(Payload);
+  }
+
+  static Error build(std::string F, Error E) {
+    return Error(std::unique_ptr<FileError>(
+        new FileError(F, E.takePayload())));
+  }
+
+  std::string FileName;
+  std::unique_ptr<ErrorInfoBase> Err;
+};
+
+/// Concatenate a source file path and/or name with an Error. The resulting
+/// Error is unchecked.
+inline Error createFileError(std::string F, Error E) {
+  return FileError::build(F, std::move(E));
+}
+
+/// This class provides the combined features of ECError and StringError, while
+/// allowing for sub typing.
+///
+/// DebugErrorInfo<> is useful when an Error sub type is required, for later
+/// inspection, along with an std::error_code and an optional String, such as:
+///
+///   @code{.cpp}
+///   Expected<int> foo() {
+///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
+///                                        "Additional information");
+///   }
+///   @endcode
+///
+/// When implementing the class, the following shall be provided:
+/// - a custom enumeration, starting at 1, where a 'unspecified'
+/// element should be present
+/// - a custom std::error_category with a fully defined singleton object.
+/// - an Error subtype of DebugErrorInfo<>
+///
+template <typename ThisErrT, typename EC, typename ECat>
+class DebugErrorInfo : public ErrorInfo<ThisErrT> {
+public:
+  DebugErrorInfo(EC C) : DebugErrorInfo(C, "") {}
+  DebugErrorInfo(Twine Context)
+      : DebugErrorInfo(EC::unspecified, Context.str()) {}
+  DebugErrorInfo(EC C, StringRef Context) : Code(C) {
+    if (Code == EC::unspecified)
+      ErrMsg += Context;
+    else {
+      ErrMsg += convertToErrorCode().message();
+      if (!Context.empty())
+        ErrMsg += (" " + Context).str();
+    }
+  }
+
+  void log(raw_ostream &OS) const override { OS << ErrMsg; }
+  StringRef getErrorMessage() const { return ErrMsg; }
+  EC getError() const { return Code; }
+
+  static ManagedStatic<ECat> Category;
+
+  std::error_code convertToErrorCode() const override {
+    return std::error_code(static_cast<int>(Code), *Category);
+  }
+
+  // Used by ErrorInfo::classID.
+  static char ID;
+
+protected:
+  std::string ErrMsg;
+  EC Code;
+};
+
+#define DEFINE_DEBUGERRORINFO(C, EC, Cat)                                      \
+  template <> char DebugErrorInfo<C, EC, Cat>::ID;                             \
+  template <> ManagedStatic<Cat> DebugErrorInfo<C, EC, Cat>::Category;
+
 /// Helper for check-and-exit error handling.
 ///
 /// For tool use only. NOT FOR USE IN LIBRARY CODE.
 ///
 class ExitOnError {
 public:
   /// Create an error on exit helper.
   ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
       : Banner(std::move(Banner)),

llvm/trunk/lib/DebugInfo/CodeView/CodeViewError.cpp

 //===- CodeViewError.cpp - Error extensions for CodeView --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
-namespace {
 // FIXME: This class is only here to support the transition to llvm::Error. It
 // will be removed once this transition is complete. Clients should prefer to
 // deal with the Error value directly, rather than converting to error_code.
-class CodeViewErrorCategory : public std::error_category {
-public:
-  const char *name() const noexcept override { return "llvm.codeview"; }
+const char *llvm::codeview::CodeViewErrorCategory::name() const noexcept {
+  return "llvm.codeview";
+}
 
-  std::string message(int Condition) const override {
-    switch (static_cast<cv_error_code>(Condition)) {
-    case cv_error_code::unspecified:
-      return "An unknown error has occurred.";
-    case cv_error_code::insufficient_buffer:
-      return "The buffer is not large enough to read the requested number of "
-             "bytes.";
-    case cv_error_code::corrupt_record:
-      return "The CodeView record is corrupted.";
-    case cv_error_code::no_records:
-      return "There are no records";
-    case cv_error_code::operation_unsupported:
-      return "The requested operation is not supported.";
-    case cv_error_code::unknown_member_record:
-      return "The member record is of an unknown type.";
-    }
-    llvm_unreachable("Unrecognized cv_error_code");
-  }
-};
-} // end anonymous namespace
-
-static ManagedStatic<CodeViewErrorCategory> Category;
-
-char CodeViewError::ID = 0;
-
-CodeViewError::CodeViewError(cv_error_code C) : CodeViewError(C, "") {}
-
-CodeViewError::CodeViewError(const std::string &Context)
-    : CodeViewError(cv_error_code::unspecified, Context) {}
-
-CodeViewError::CodeViewError(cv_error_code C, const std::string &Context)
-    : Code(C) {
-  ErrMsg = "CodeView Error: ";
-  std::error_code EC = convertToErrorCode();
-  if (Code != cv_error_code::unspecified)
-    ErrMsg += EC.message() + "  ";
-  if (!Context.empty())
-    ErrMsg += Context;
-}
-
-void CodeViewError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+std::string llvm::codeview::CodeViewErrorCategory::message(int Condition) const {
+    return "There are no records.";
 
-const std::string &CodeViewError::getErrorMessage() const { return ErrMsg; }
-
-std::error_code CodeViewError::convertToErrorCode() const {
-  return std::error_code(static_cast<int>(Code), *Category);
-}
+DEFINE_DEBUGERRORINFO(CodeViewError, cv_error_code, CodeViewErrorCategory)

llvm/trunk/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

while (!LastError && NumBadIndices > 0) {
 
     if (auto EC = remapAllTypes(Types))
       return EC;
 
     assert(NumBadIndices <= BadIndicesRemaining &&
            "second pass found more bad indices");
     if (!LastError && NumBadIndices == BadIndicesRemaining) {
       return llvm::make_error<CodeViewError>(
-          cv_error_code::corrupt_record, "input type graph contains cycles");
+          cv_error_code::corrupt_record, "Input type graph contains cycles");
     }
   }
 
   if (LastError)
     return std::move(*LastError);
   return Error::success();
 }
 

llvm/trunk/lib/DebugInfo/MSF/MSFError.cpp

 //===- MSFError.cpp - Error extensions for MSF files ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/MSF/MSFError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::msf;
 
-namespace {
 // FIXME: This class is only here to support the transition to llvm::Error. It
 // will be removed once this transition is complete. Clients should prefer to
 // deal with the Error value directly, rather than converting to error_code.
-class MSFErrorCategory : public std::error_category {
-public:
-  const char *name() const noexcept override { return "llvm.msf"; }
+const char *llvm::msf::MSFErrorCategory::name() const noexcept {
+  return "llvm.msf";
+}
 
-  std::string message(int Condition) const override {
-    switch (static_cast<msf_error_code>(Condition)) {
-    case msf_error_code::unspecified:
-      return "An unknown error has occurred.";
-    case msf_error_code::insufficient_buffer:
-      return "The buffer is not large enough to read the requested number of "
-             "bytes.";
-    case msf_error_code::not_writable:
-      return "The specified stream is not writable.";
-    case msf_error_code::no_stream:
-      return "The specified stream does not exist.";
-    case msf_error_code::invalid_format:
-      return "The data is in an unexpected format.";
-    case msf_error_code::block_in_use:
-      return "The block is already in use.";
-    }
-    llvm_unreachable("Unrecognized msf_error_code");
-  }
-};
-} // end anonymous namespace
-
-static ManagedStatic<MSFErrorCategory> Category;
-
-char MSFError::ID = 0;
-
-MSFError::MSFError(msf_error_code C) : MSFError(C, "") {}
-
-MSFError::MSFError(const std::string &Context)
-    : MSFError(msf_error_code::unspecified, Context) {}
-
-MSFError::MSFError(msf_error_code C, const std::string &Context) : Code(C) {
-  ErrMsg = "MSF Error: ";
-  std::error_code EC = convertToErrorCode();
-  if (Code != msf_error_code::unspecified)
-    ErrMsg += EC.message() + "  ";
-  if (!Context.empty())
-    ErrMsg += Context;
-}
-
-void MSFError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+std::string llvm::msf::MSFErrorCategory::message(int Condition) const {
 
-const std::string &MSFError::getErrorMessage() const { return ErrMsg; }
-
-std::error_code MSFError::convertToErrorCode() const {
-  return std::error_code(static_cast<int>(Code), *Category);
-}
+DEFINE_DEBUGERRORINFO(MSFError, msf_error_code, MSFErrorCategory)

llvm/trunk/lib/DebugInfo/PDB/DIA/DIAError.cpp

 #include "llvm/DebugInfo/PDB/DIA/DIAError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 // FIXME: This class is only here to support the transition to llvm::Error. It
 // will be removed once this transition is complete. Clients should prefer to
 // deal with the Error value directly, rather than converting to error_code.
-class DIAErrorCategory : public std::error_category {
-public:
-  const char *name() const noexcept override { return "llvm.pdb.dia"; }
+const char *llvm::pdb::DIAErrorCategory::name() const noexcept {
+  return "llvm.pdb.dia";
+}
 
-  std::string message(int Condition) const override {
-    switch (static_cast<dia_error_code>(Condition)) {
-    case dia_error_code::could_not_create_impl:
-      return "Failed to connect to DIA at runtime.  Verify that Visual Studio "
-             "is properly installed, or that msdiaXX.dll is in your PATH.";
-    case dia_error_code::invalid_file_format:
-      return "Unable to load PDB.  The file has an unrecognized format.";
-    case dia_error_code::invalid_parameter:
-      return "The parameter is incorrect.";
-    case dia_error_code::already_loaded:
-      return "Unable to load the PDB or EXE, because it is already loaded.";
-    case dia_error_code::debug_info_mismatch:
-      return "The PDB file and the EXE file do not match.";
-    case dia_error_code::unspecified:
-      return "An unknown error has occurred.";
-    }
-    llvm_unreachable("Unrecognized DIAErrorCode");
-  }
-};
-
-static ManagedStatic<DIAErrorCategory> Category;
-
-char DIAError::ID = 0;
-
-DIAError::DIAError(dia_error_code C) : DIAError(C, "") {}
-
-DIAError::DIAError(StringRef Context)
-    : DIAError(dia_error_code::unspecified, Context) {}
-
-DIAError::DIAError(dia_error_code C, StringRef Context) : Code(C) {
-  ErrMsg = "DIA Error: ";
-  std::error_code EC = convertToErrorCode();
-  ErrMsg += EC.message() + "  ";
-  if (!Context.empty())
-    ErrMsg += Context;
-}
-
-void DIAError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+std::string llvm::pdb::DIAErrorCategory::message(int Condition) const {
+    return "Failed to connect to DIA at runtime. Verify that Visual Studio "
+    return "Unable to load PDB. The file has an unrecognized format.";
 
-StringRef DIAError::getErrorMessage() const { return ErrMsg; }
-
-std::error_code DIAError::convertToErrorCode() const {
-  return std::error_code(static_cast<int>(Code), *Category);
-}
+DEFINE_DEBUGERRORINFO(DIAError, dia_error_code, DIAErrorCategory)

llvm/trunk/lib/DebugInfo/PDB/DIA/DIASession.cpp

static Error ErrorFromHResult(HRESULT Result, const char *Str, Ts &&... Args) {
   if (sizeof...(Args) > 0) {
     MessageStorage = formatv(Str, std::forward<Ts>(Args)...).str();
     Context = MessageStorage;
   } else
     Context = Str;
 
   switch (Result) {
   case E_PDB_NOT_FOUND:
-    return make_error<GenericError>(generic_error_code::invalid_path, Context);
+    return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
   case E_PDB_FORMAT:
     return make_error<DIAError>(dia_error_code::invalid_file_format, Context);
   case E_INVALIDARG:
     return make_error<DIAError>(dia_error_code::invalid_parameter, Context);
   case E_UNEXPECTED:
     return make_error<DIAError>(dia_error_code::already_loaded, Context);
   case E_PDB_INVALID_SIG:
   case E_PDB_INVALID_AGE:
static Error LoadDIA(CComPtr<IDiaDataSource> &DiaDataSource) {
   if (SUCCEEDED(CoCreateInstance(CLSID_DiaSource, nullptr, CLSCTX_INPROC_SERVER,
                                  IID_IDiaDataSource,
                                  reinterpret_cast<LPVOID *>(&DiaDataSource))))
     return Error::success();
 
 // If the CoCreateInstance call above failed, msdia*.dll is not registered.
 // Try loading the DLL corresponding to the #included DIA SDK.
 #if !defined(_MSC_VER)
-  return llvm::make_error<GenericError>(
-      "DIA is only supported when using MSVC.");
+  return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading);
 #else
   const wchar_t *msdia_dll = nullptr;
 #if _MSC_VER >= 1900 && _MSC_VER < 2000
   msdia_dll = L"msdia140.dll"; // VS2015
 #elif _MSC_VER >= 1800
   msdia_dll = L"msdia120.dll"; // VS2013
 #else
 #error "Unknown Visual Studio version."
Error DIASession::createFromPdb(StringRef Path,
   CComPtr<IDiaSession> DiaSession;
 
   // We assume that CoInitializeEx has already been called by the executable.
   if (auto E = LoadDIA(DiaDataSource))
     return E;
 
   llvm::SmallVector<UTF16, 128> Path16;
   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
-    return make_error<GenericError>(generic_error_code::invalid_path);
+    return make_error<PDBError>(pdb_error_code::invalid_utf8_path, Path);
 
   const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
   HRESULT HR;
   if (FAILED(HR = DiaDataSource->loadDataFromPdb(Path16Str))) {
     return ErrorFromHResult(HR, "Calling loadDataFromPdb {0}", Path);
   }
 
   if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
Error DIASession::createFromExe(StringRef Path,
   CComPtr<IDiaSession> DiaSession;
 
   // We assume that CoInitializeEx has already been called by the executable.
   if (auto EC = LoadDIA(DiaDataSource))
     return EC;
 
   llvm::SmallVector<UTF16, 128> Path16;
   if (!llvm::convertUTF8ToUTF16String(Path, Path16))
-    return make_error<GenericError>(generic_error_code::invalid_path, Path);
+    return make_error<PDBError>(pdb_error_code::invalid_utf8_path, Path);
 
   const wchar_t *Path16Str = reinterpret_cast<const wchar_t *>(Path16.data());
   HRESULT HR;
   if (FAILED(HR = DiaDataSource->loadDataForExe(Path16Str, nullptr, nullptr)))
     return ErrorFromHResult(HR, "Calling loadDataForExe");
 
   if (FAILED(HR = DiaDataSource->openSession(&DiaSession)))
     return ErrorFromHResult(HR, "Calling openSession");

llvm/trunk/lib/DebugInfo/PDB/GenericError.cpp

 //===- Error.cpp - system_error extensions for PDB --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
-namespace {
 // FIXME: This class is only here to support the transition to llvm::Error. It
 // will be removed once this transition is complete. Clients should prefer to
 // deal with the Error value directly, rather than converting to error_code.
-class GenericErrorCategory : public std::error_category {
-public:
-  const char *name() const noexcept override { return "llvm.pdb"; }
+const char *llvm::pdb::PDBErrorCategory::name() const noexcept {
+  return "llvm.pdb";
+}
 
-  std::string message(int Condition) const override {
-    switch (static_cast<generic_error_code>(Condition)) {
-    case generic_error_code::unspecified:
-      return "An unknown error has occurred.";
-    case generic_error_code::type_server_not_found:
-      return "Type server PDB was not found.";
-    case generic_error_code::dia_sdk_not_present:
-      return "LLVM was not compiled with support for DIA.  This usually means "
-             "that you are not using MSVC, or your Visual Studio "
-             "installation "
-             "is corrupt.";
-    case generic_error_code::invalid_path:
-      return "Unable to load PDB.  Make sure the file exists and is readable.";
-    }
-    llvm_unreachable("Unrecognized generic_error_code");
-  }
-};
-} // end anonymous namespace
-
-static ManagedStatic<GenericErrorCategory> Category;
-
-char GenericError::ID = 0;
-
-GenericError::GenericError(generic_error_code C) : GenericError(C, "") {}
-
-GenericError::GenericError(StringRef Context)
-    : GenericError(generic_error_code::unspecified, Context) {}
-
-GenericError::GenericError(generic_error_code C, StringRef Context) : Code(C) {
-  ErrMsg = "PDB Error: ";
-  std::error_code EC = convertToErrorCode();
-  if (Code != generic_error_code::unspecified)
-    ErrMsg += EC.message() + "  ";
-  if (!Context.empty())
-    ErrMsg += Context;
-}
-
-void GenericError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+std::string llvm::pdb::PDBErrorCategory::message(int Condition) const {
+  switch (static_cast<pdb_error_code>(Condition)) {
+  case pdb_error_code::unspecified:
+  case pdb_error_code::dia_sdk_not_present:
+    return "LLVM was not compiled with support for DIA. This usually means "
+            "installation is corrupt.";
+  case pdb_error_code::dia_failed_loading:
+    return "DIA is only supported when using MSVC.";
+  case pdb_error_code::invalid_utf8_path:
+    return "The PDB file path is an invalid UTF8 sequence.";
+  case pdb_error_code::signature_out_of_date:
+    return "The signature does not match; the file(s) might be out of date";
 
-StringRef GenericError::getErrorMessage() const { return ErrMsg; }
-
-std::error_code GenericError::convertToErrorCode() const {
-  return std::error_code(static_cast<int>(Code), *Category);
-}
+DEFINE_DEBUGERRORINFO(PDBError, pdb_error_code, PDBErrorCategory)

llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp

 //===- NativeSession.cpp - Native implementation of IPDBSession -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
 #include "llvm/DebugInfo/PDB/Native/NativeBuiltinSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/NativeEnumSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
 #include "llvm/DebugInfo/PDB/Native/NativeExeSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"

llvm/trunk/lib/DebugInfo/PDB/Native/PDBFile.cpp

 Error PDBFile::parseFileHeaders() {
   BinaryStreamReader Reader(*Buffer);
 
   // Initialize SB.
   const msf::SuperBlock *SB = nullptr;
   if (auto EC = Reader.readObject(SB)) {
     consumeError(std::move(EC));
     return make_error<RawError>(raw_error_code::corrupt_file,
-                                "Does not contain superblock");
+                                "MSF superblock is missing");
   }
 
   if (auto EC = msf::validateSuperBlock(*SB))
     return EC;
 
   if (Buffer->getLength() % SB->BlockSize != 0)
     return make_error<RawError>(raw_error_code::corrupt_file,
                                 "File size is not a multiple of block size");

llvm/trunk/lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp

 //===- PDBFileBuilder.cpp - PDB File Creation -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
 
 #include "llvm/ADT/BitVector.h"
 
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
-#include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"

llvm/trunk/lib/DebugInfo/PDB/Native/RawError.cpp

 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
-namespace {
 // FIXME: This class is only here to support the transition to llvm::Error. It
 // will be removed once this transition is complete. Clients should prefer to
 // deal with the Error value directly, rather than converting to error_code.
-class RawErrorCategory : public std::error_category {
-public:
-  const char *name() const noexcept override { return "llvm.pdb.raw"; }
+const char *llvm::pdb::RawErrorCategory::name() const noexcept {
+  return "llvm.pdb.raw";
+}
 
-  std::string message(int Condition) const override {
-    switch (static_cast<raw_error_code>(Condition)) {
-    case raw_error_code::unspecified:
-      return "An unknown error has occurred.";
-    case raw_error_code::feature_unsupported:
-      return "The feature is unsupported by the implementation.";
-    case raw_error_code::invalid_format:
-      return "The record is in an unexpected format.";
-    case raw_error_code::corrupt_file:
-      return "The PDB file is corrupt.";
-    case raw_error_code::insufficient_buffer:
-      return "The buffer is not large enough to read the requested number of "
-             "bytes.";
-    case raw_error_code::no_stream:
-      return "The specified stream could not be loaded.";
-    case raw_error_code::index_out_of_bounds:
-      return "The specified item does not exist in the array.";
-    case raw_error_code::invalid_block_address:
-      return "The specified block address is not valid.";
-    case raw_error_code::duplicate_entry:
-      return "The entry already exists.";
-    case raw_error_code::no_entry:
-      return "The entry does not exist.";
-    case raw_error_code::not_writable:
-      return "The PDB does not support writing.";
-    case raw_error_code::stream_too_long:
-      return "The stream was longer than expected.";
-    case raw_error_code::invalid_tpi_hash:
-      return "The Type record has an invalid hash value.";
-    }
-    llvm_unreachable("Unrecognized raw_error_code");
-  }
-};
-} // end anonymous namespace
-
-static ManagedStatic<RawErrorCategory> Category;
-
-char RawError::ID = 0;
-
-RawError::RawError(raw_error_code C) : RawError(C, "") {}
-
-RawError::RawError(const std::string &Context)
-    : RawError(raw_error_code::unspecified, Context) {}
-
-RawError::RawError(raw_error_code C, const std::string &Context) : Code(C) {
-  ErrMsg = "Native PDB Error: ";
-  std::error_code EC = convertToErrorCode();
-  if (Code != raw_error_code::unspecified)
-    ErrMsg += EC.message() + "  ";
-  if (!Context.empty())
-    ErrMsg += Context;
-}
-
-void RawError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+std::string llvm::pdb::RawErrorCategory::message(int Condition) const {
 
-const std::string &RawError::getErrorMessage() const { return ErrMsg; }
-
-std::error_code RawError::convertToErrorCode() const {
-  return std::error_code(static_cast<int>(Code), *Category);
-}
+DEFINE_DEBUGERRORINFO(RawError, raw_error_code, RawErrorCategory)

llvm/trunk/lib/DebugInfo/PDB/PDB.cpp

 Error llvm::pdb::loadDataForPDB(PDB_ReaderType Type, StringRef Path,
                                 std::unique_ptr<IPDBSession> &Session) {
   // Create the correct concrete instance type based on the value of Type.
   if (Type == PDB_ReaderType::Native) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
         MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
                                      /*RequiresNullTerminator=*/false);
     if (!ErrorOrBuffer)
-      return make_error<GenericError>(generic_error_code::invalid_path, Path);
+      return errorCodeToError(ErrorOrBuffer.getError());
 
     return NativeSession::createFromPdb(std::move(*ErrorOrBuffer), Session);
   }
 
 #if LLVM_ENABLE_DIA_SDK
   return DIASession::createFromPdb(Path, Session);
 #else
-  return make_error<GenericError>("DIA is not installed on the system");
+  return make_error<PDBError>(pdb_error_code::dia_sdk_not_present);
 #endif
 }
 
 Error llvm::pdb::loadDataForEXE(PDB_ReaderType Type, StringRef Path,
                                 std::unique_ptr<IPDBSession> &Session) {
   // Create the correct concrete instance type based on the value of Type.
   if (Type == PDB_ReaderType::Native)
     return NativeSession::createFromExe(Path, Session);
 
 #if LLVM_ENABLE_DIA_SDK
   return DIASession::createFromExe(Path, Session);
 #else
-  return make_error<GenericError>("DIA is not installed on the system");
+  return make_error<PDBError>(pdb_error_code::dia_sdk_not_present);
 #endif
 }

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

if (auto CoffObject = dyn_cast<COFFObjectFile>(Objects.first)) {
     auto EC = CoffObject->getDebugPDBInfo(DebugInfo, PDBFileName);
     if (!EC && DebugInfo != nullptr && !PDBFileName.empty()) {
       using namespace pdb;
       std::unique_ptr<IPDBSession> Session;
       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);
+        // Return along the PDB filename to provide more context
+        return createFileError(PDBFileName, std::move(Err));
       }
       Context.reset(new PDBContext(*CoffObject, std::move(Session)));
     }
   }
   if (!Context)
     Context = DWARFContext::create(*Objects.second, nullptr,
                                    DWARFContext::defaultErrorHandler, DWPName);
   assert(Context);

llvm/trunk/lib/Support/BinaryStreamError.cpp

BinaryStreamError::BinaryStreamError(stream_error_code C, StringRef Context)
   }
 
   if (!Context.empty()) {
     ErrMsg += "  ";
     ErrMsg += Context;
   }
 }
 
-void BinaryStreamError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+void BinaryStreamError::log(raw_ostream &OS) const { OS << ErrMsg; }
 
 StringRef BinaryStreamError::getErrorMessage() const { return ErrMsg; }
 
 std::error_code BinaryStreamError::convertToErrorCode() const {
   return inconvertibleErrorCode();
 }

llvm/trunk/lib/Support/Error.cpp

 
 namespace llvm {
 
 void ErrorInfoBase::anchor() {}
 char ErrorInfoBase::ID = 0;
 char ErrorList::ID = 0;
 char ECError::ID = 0;
 char StringError::ID = 0;
+char FileError::ID = 0;
 
 void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner) {
   if (!E)
     return;
   OS << ErrorBanner;
   handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
     EI.log(OS);
     OS << "\n";
   });
 }
 
 
 std::error_code ErrorList::convertToErrorCode() const {
   return std::error_code(static_cast<int>(ErrorErrorCode::MultipleErrors),
                          *ErrorErrorCat);
 }
 
 std::error_code inconvertibleErrorCode() {
   return std::error_code(static_cast<int>(ErrorErrorCode::InconvertibleError),
                          *ErrorErrorCat);
 }
 
+std::error_code FileError::convertToErrorCode() const {
+  return inconvertibleErrorCode();
+}
+
 Error errorCodeToError(std::error_code EC) {
   if (!EC)
     return Error::success();
   return Error(llvm::make_unique<ECError>(ECError(EC)));
 }
 
 std::error_code errorToErrorCode(Error Err) {
   std::error_code EC;

llvm/trunk/test/DebugInfo/PDB/pdb-invalid-type.test

 # RUN: llvm-pdbutil yaml2pdb -pdb=%t1.pdb %p/Inputs/one-symbol.yaml
 # RUN: llvm-pdbutil yaml2pdb -pdb=%t2.pdb %s
 # RUN: not llvm-pdbutil merge -pdb=%t.pdb %t1.pdb %t2.pdb 2>&1 | FileCheck %s
 
-# CHECK: CodeView Error: The CodeView record is corrupted.
+# CHECK: The CodeView record is corrupted
 
 ---
 TpiStream:
   Records:
     # uint32_t* [Index: llvm/trunk/0x1000]
     - Kind:            LF_POINTER
       Pointer:         
         ReferentType:    4097
         Attrs:           32778
 ...

llvm/trunk/test/DebugInfo/PDB/pdbdump-headers.test

 BIG-NEXT:   Mod 0041 | `Import:api-ms-win-crt-math-l1-1-0.dll`:
 BIG-NEXT:   Mod 0042 | `api-ms-win-crt-math-l1-1-0.dll`:
 BIG-NEXT:   Mod 0043 | `Import:api-ms-win-crt-locale-l1-1-0.dll`:
 BIG-NEXT:   Mod 0044 | `api-ms-win-crt-locale-l1-1-0.dll`:
 BIG-NEXT:   Mod 0045 | `Import:api-ms-win-crt-heap-l1-1-0.dll`:
 BIG-NEXT:   Mod 0046 | `api-ms-win-crt-heap-l1-1-0.dll`:
 BIG-NEXT:   Mod 0047 | `* Linker *`:
 
-BAD-BLOCK-SIZE: Native PDB Error: The PDB file is corrupt. Does not contain superblock
+BAD-BLOCK-SIZE: The PDB file is corrupt. MSF superblock is missing

llvm/trunk/test/tools/llvm-readobj/codeview-merging-cycle.test

 ; RUN: not llvm-readobj -codeview-merged-types %S/Inputs/codeview-cycle.obj 2>&1 | FileCheck %s
 
-; CHECK: Error{{.*}} input type graph contains cycles
+; CHECK: Error{{.*}} Input type graph contains cycles
 
 ; To reproduce codeview-cycle.obj:
 ; $ cat codeview-cycle.asm
 ;       .model  flat, C
 ;       .code
 ; pfoo_list TYPEDEF PTR foo_list
 ; foo_list STRUCT
 ;       next pfoo_list ?
 ;       data dd ?
 ; foo_list ENDS
 ;       public  foo
 ; foo proc dst:ptr foo_list
 ;       ret
 ; foo   endp
 ;       end
 ; $ ml -c -Zi codeview-cycle.asm

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: LLVMSymbolizer: error reading file: {{.*}}: {{N|n}}o such file or directory
 ERROR-NOT: error reading file
 
 CHECK: ??
 CHECK: ??:0:0
 CHECK: ??
 CHECK: ??:0:0

llvm/trunk/tools/llvm-pdbutil/llvm-pdbutil.cpp

 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
-#include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBInjectedSource.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"

 
 static void yamlToPdb(StringRef Path) {
   BumpPtrAllocator Allocator;
   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
       MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
                                    /*RequiresNullTerminator=*/false);
 
   if (ErrorOrBuffer.getError()) {
-    ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path, Path));
+    ExitOnErr(createFileError(Path, errorCodeToError(ErrorOrBuffer.getError())));
   }
 
   std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
 
   llvm::yaml::Input In(Buffer->getBuffer());
   pdb::yaml::PdbObject YamlObj(Allocator);
   In >> YamlObj;
 

llvm/trunk/tools/obj2yaml/Error.cpp

 
 const std::error_category &obj2yaml_category() {
   static _obj2yaml_error_category o;
   return o;
 }
 
 char Obj2YamlError::ID = 0;
 
-void Obj2YamlError::log(raw_ostream &OS) const { OS << ErrMsg << "\n"; }
+void Obj2YamlError::log(raw_ostream &OS) const { OS << ErrMsg; }
 
 std::error_code Obj2YamlError::convertToErrorCode() const {
   return std::error_code(static_cast<int>(Code), obj2yaml_category());
 }
 
 } // namespace llvm