[COFF][LLD] Add link support for precompiled headers .objs

[aganea]

Summary

This change allows for link-time merging of debugging information from
Microsoft precompiled types .objs compiled with cl.exe /Z7 /Yc and /Yu.

Previously, LLD used to crash when encountering these .objs on the command line.

Precompiled types use two specific records:

• LF_PRECOMP at the begining of a type stream, to signify a dependence on a

external precomp .obj

• LF_ENDPRECOMP in a precomp .obj, which marks the end of the type stream which

should be used by the dependent .obj.

When a .obj with a LF_PRECOMP reference is found, we preempt the processing of
that .obj, and attempt to first load the precompiled .obj. Once the precompiled
.obj is loaded and remapped, we simply take its (remapped) type IndexMap and
paste it in the TypeStreamMerger, just before merging in the dependent .obj's
type indices. This allows for back-referencing precomp type records which have
already merged.

LF_PRECOMP and LF_ENDPRECOMP records are ultimately dropped from the target PDB.

This fixes https://bugs.llvm.org/show_bug.cgi?id=34278

[rnk]

Can you split this into a patch that adds the basic YAML serialization and dumping functionality to LLVM, and a patch that adds the type merging capabilities across LLVM and LLD? The first one should take care of a lot of the boilerplate and we can stamp it quickly and then move on to review the complex type merging code.

[aganea]

Following https://reviews.llvm.org/D45283, I've updated the review only with the type merging and LLD support.
Some extra support would be needed for llvm-readobj -codeview-merged-types, but I prefer to do that later.

lld/COFF/PDB.cpp

303 ↗

(On Diff #142078)

I choose to preempt loading of the current .obj, and load the precomp .obj here. However if (future) multithreading is a concern, I could instead push the processing of the current .obj at the end of the stack. Let me know whichever you prefer.

312 ↗

(On Diff #142078)

The magic happens here.

[aganea]

llvm/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

488 ↗

(On Diff #142078)

I'm not very happy about this - I think I'll move it to lld/COFF/PDB.cpp instead.

[aganea]

llvm/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

488 ↗

(On Diff #142078)

After thought, I'll leave it the way it is - I can't find a better way to prevent the LF_ENDPRECOMP from being added to the output TypeTable.

[zturner]

Sorry for the delay, been OOO for 3 days.

BTW, When you upload the next version, can you make sure it has full context?

lld/COFF/PDB.cpp

258 ↗

(On Diff #142078)

Variable names should be CamelCase.

293 ↗

(On Diff #142078)

Would it be possible to write this as something like:

if (isExternalTypeStreamRecord(Types))
  return handleExternalTypeStreamRecord(Types);

Then this new handle function could handle both LF_TYPESERVER2 and LF_PRECOMP, and we wouldn't need the weird function with the boolean anymore

500–501 ↗

(On Diff #142078)

This doesn't look clang formatted.

506 ↗

(On Diff #142078)

Upper case F

507–510 ↗

(On Diff #142078)

Same here. Just fix all variable names actually.

542–544 ↗

(On Diff #142078)

Eww. How about returning an Expected<const CVIndexMap&> instead?

llvm/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

489–492 ↗

(On Diff #142078)

I noticed that when precompiled headers are used, the S_OBJNAME symbol also has a matching signature. Can / should this be used somehow?

[ruiu]

lld/COFF/PDB.cpp

258 ↗

(On Diff #142078)

Generally we avoid optional parameters. Please always explicitly pass true or false.

464 ↗

(On Diff #142078)

Please add a function comment explaining what this function is for.

This function seems a bit too long to me. Please consider splitting into smaller functions.

[aganea]

Adressed @zturner's and @ruiu's comments.

[aganea]

lld/COFF/PDB.cpp

293 ↗

(On Diff #142078)

Unfortunately we can't. In one case (PDB), we must return the full TPI/IPI map; in the other case (PCH) we must load the TPI map and fallthrough.

542–544 ↗

(On Diff #142078)

Please unsee this.

llvm/lib/DebugInfo/CodeView/TypeStreamMerger.cpp

489–492 ↗

(On Diff #142078)

Yes, and the new revision (https://reviews.llvm.org/D45213?id=154301) is using it. It was probably meant there at the begining of the stream to bail out quickly, if the associated signature doesn't match the PCH session.

[aganea]

Currently splitting this in many smaller changes.

[aganea]

I've corrected the issues raised. Anything that wasn't related to this change was already commited separately.

This patch is now ready for review again.

[aganea]

Ping! Could anybody please take a look at this? Thank you!

[zturner]

How big are the object files?

lld/trunk/COFF/PDB.cpp

359–391

FWIW, all object files always start with an S_OBJNAME, even if there is no PCH support. But if there is no PCH support, the signature field will just be 0.

388

I think we should just return 0; here. As you said, if it's there, it will be first, so if it's not first, there's no point to continue looking in subsequent .debug$S sections.

458–459

I almost wonder if we should add CVTypeArray::drop_front(). You don't have to do it in this patch, just something I thought of.

666–667

Can you add static to this function?

675

In another patch we were discussing whether we should stop using path::Style::windows. When cross-compiling you might be on non-Windows, and these path comparisons would be incorrect in that case. So I think we should probably just use the default native style here.

678–679

It's hard to know exactly what to do here. Is equals_lower correct or equals? It seems like we need a sys::path::equals_path() that uses case-insensitive comparison on Windows and case-sensitive on Linux. Can you add equals_path() as a global function in this file and use that here instead?

lld/trunk/test/COFF/precomp-link.test

11

The # signs are confusing. I don't think you need to put any marker in front of them. You can just write it as code. lit and FileCheck ignore comment markers at the beginning of lines. and only match or run lines that have a RUN or CHECK line after any comments. So just putting raw code directly in the file is fine.

[zturner]

BTW, sorry this took so long for anyone to review. I think partly it's because nobody here really taken the time to understand in detail how MS precompiled headers works, so we were all hoping someone else would review it. :-/

Anyway, at least from my point of view (unless someone else chimes in) this looks good provided it works (which you say it does) and it has tests (which it does) and the last remaining issues I outlined are fixed.

[neerajksingh]

I just want to mention as a heads-up: there will later be some complexities in this PCH finding code when the /deterministic flags are added to public builds of cl.exe. PCH files paths might be replaced with environment variables that will need to be expanded when acquiring a PDB.

FYI, in the MS linker, we find out early on that a file contains precompiled type information from the presence of the debug$P section and mostly process those files before processing the non-PCT files. That avoids some need to search when acquiring the PCH data.

[rnk]

In D45213#1269836, @neerajksingh wrote:

FYI, in the MS linker, we find out early on that a file contains precompiled type information from the presence of the debug$P section and mostly process those files before processing the non-PCT files. That avoids some need to search when acquiring the PCH data.

Thanks, that's interesting.

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

46

I was hoping to come up with some way to avoid the extra out parameter, but that's my only real concern. Structurally, everything else looks like type servers, and it's pretty straightforward.

[rnk]

I meant to add more before hitting submit...

I looked at the linker part, and things make sense to me. I trust that Zach looked more at the mechanics. I think we should fix the remaining issues he highlighted, and otherwise this is ready.

[aganea]

Please see the updated diff which adresses comments.

In D45213#1259147, @zturner wrote:

How big are the object files?

65.6 KB. I want to ensure things work smoothly with cl-generated OBJs.

lld/trunk/COFF/PDB.cpp

458–459

I went ahead and added VarStreamArray::drop_front(), please let me know if that sounds good.

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

46

I agree - in a subsequent chage we could fold the "merge" behavior into a single function, add a initializer struct, and call the function with a initializer list instead, ie. mergeRecords({Dest, Types, Hashes, EP}). That way we could accomodate different merging scenarios, and have only one codepath.

[aganea]

Update diff again:

• Added more coverage tests.
• Added comment to clarify the sys::path::Style::windows and precomp OBJs situation when cross-compiling.

[aganea]

In D45213#1259147, @zturner wrote:

FWIW, all object files always start with an S_OBJNAME, even if there is no PCH support. But if there is no PCH support, the signature field will just be 0.

Just wanted to point out that it's only true for cl-generated OBJs. clang-cl does not generate the S_OBJNAME record.

lld/trunk/COFF/PDB.cpp

302

@zturner I've added this comment.

[rnk]

In D45213#1275808, @aganea wrote:

In D45213#1259147, @zturner wrote:

FWIW, all object files always start with an S_OBJNAME, even if there is no PCH support. But if there is no PCH support, the signature field will just be 0.

Just wanted to point out that it's only true for cl-generated OBJs. clang-cl does not generate the S_OBJNAME record.

True. I added S_BUILDINFO the other week.

I think @zturner had a stalled patch to add S_OBJNAME. Yeah, this: https://reviews.llvm.org/D43002. I think the lesson is that it might be better not to stuff more things into DICompileUnit than absolutely necessary.

Is there anything else that needs to be done here? I'm happy with this.

lld/trunk/COFF/InputFiles.h

 #ifndef LLD_COFF_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>
 
public:
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
 
   // Returns a Symbol object for the SymbolIndex'th symbol in the
   // underlying object file.
   Symbol *getSymbol(uint32_t SymbolIndex) {
     return Symbols[SymbolIndex];
   }
 
-  // Returns the underying COFF file.
+  // Returns the underlying COFF file.
   COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
 
+  // Whether the object was already merged into the final PDB or not
+  bool wasProcessedForPDB() const { return !!ModuleDBI; }
+
   static std::vector<ObjFile *> Instances;
 
   // Flags in the absolute @feat.00 symbol if it is present. These usually
   // indicate if an object was compiled with certain security features enabled
   // like stack guard, safeseh, /guard:cf, or other things.
   uint32_t Feat00Flags = 0;
 
   // True if this object file is compatible with SEH.  COFF-specific and
   // x86-only. COFF spec 5.10.1. The .sxdata section.
   bool hasSafeSEH() { return Feat00Flags & 0x1; }
 
   // True if this file was compiled with /guard:cf.
   bool hasGuardCF() { return Feat00Flags & 0x800; }
 
   // Pointer to the PDB module descriptor builder. Various debug info records
   // will reference object files by "module index", which is here. Things like
   // source files and section contributions are also recorded here. Will be null
   // if we are not producing a PDB.
   llvm::pdb::DbiModuleDescriptorBuilder *ModuleDBI = nullptr;
 
   const coff_section *AddrsigSec = nullptr;
 
+  // When using Microsoft precompiled headers, this is the PCH's key.
+  // The same key is used by both the precompiled object, and objects using the
+  // precompiled object. Any difference indicates out-of-date objects.
+  llvm::Optional<llvm::codeview::EndPrecompRecord> EndPrecomp;
+
 private:
   void initializeChunks();
   void initializeSymbols();
 
   SectionChunk *
   readSection(uint32_t SectionNumber,
               const llvm::object::coff_aux_section_definition *Def,
               StringRef LeaderName);

lld/trunk/COFF/PDB.cpp

 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/CVDebugRecord.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/JamCRC.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <memory>
 
 using namespace lld;
 using namespace lld::coff;

 
 namespace {
 /// Map from type index and item index in a type server PDB to the
 /// corresponding index in the destination PDB.
 struct CVIndexMap {
   SmallVector<TypeIndex, 0> TPIMap;
   SmallVector<TypeIndex, 0> IPIMap;
   bool IsTypeServerMap = false;
+  bool IsPrecompiledTypeMap = false;
 };
 
 class DebugSHandler;
 
 class PDBLinker {
   friend DebugSHandler;
 
 public:
public:
   void initialize(llvm::codeview::DebugInfo *BuildId);
 
   /// Add natvis files specified on the command line.
   void addNatvisFiles();
 
   /// Link CodeView from each object file in the symbol table into the PDB.
   void addObjectsToPDB();
 
-  /// Link CodeView from a single object file into the PDB.
-  void addObjFile(ObjFile *File);
+  /// Link CodeView from a single object file into the target (output) PDB.
+  /// When a precompiled headers object is linked, its TPI map might be provided
+  /// externally.
+  void addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap = nullptr);
 
   /// Produce a mapping from the type and item indices used in the object
   /// file to those in the destination PDB.
   ///
   /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
   /// and IPI from the type server PDB and return a map for it. Each unique type
   /// server PDB is merged at most once, so this may return an existing index
   /// mapping.
   ///
   /// If the object does not use a type server PDB (compiled with /Z7), we merge
   /// all the type and item records from the .debug$S stream and fill in the
   /// caller-provided ObjectIndexMap.
-  Expected<const CVIndexMap&> mergeDebugT(ObjFile *File,
-                                          CVIndexMap &ObjectIndexMap);
+  Expected<const CVIndexMap &> mergeDebugT(ObjFile *File,
+                                           CVIndexMap *ObjectIndexMap);
 
-  Expected<const CVIndexMap&> maybeMergeTypeServerPDB(ObjFile *File,
-                                                      TypeServer2Record &TS);
+  /// Reads and makes available a PDB.
+  Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *File,
+                                                       const CVType &FirstType);
+
+  /// Merges a precompiled headers TPI map into the current TPI map. The
+  /// precompiled headers object will also be loaded and remapped in the
+  /// process.
+  Expected<const CVIndexMap &>
+  mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
+                          CVIndexMap *ObjectIndexMap);
+
+  /// Reads and makes available a precompiled headers object.
+  ///
+  /// This is a requirement for objects compiled with cl.exe /Yu. In that
+  /// case, the referenced object (which was compiled with /Yc) has to be loaded
+  /// first. This is mainly because the current object's TPI stream has external
+  /// references to the precompiled headers object.
+  ///
+  /// If the precompiled headers object was already loaded, this function will
+  /// simply return its (remapped) TPI map.
+  Expected<const CVIndexMap &> aquirePrecompObj(ObjFile *File,
+                                                PrecompRecord Precomp);
+
+  /// Adds a precompiled headers object signature -> TPI mapping.
+  std::pair<CVIndexMap &, bool /*already there*/>
+  registerPrecompiledHeaders(uint32_t Signature);
 
   /// Add the section map and section contributions to the PDB.
   void addSections(ArrayRef<OutputSection *> OutputSections,
                    ArrayRef<uint8_t> SectionTable);
 
   /// Write the PDB to disk and store the Guid generated for it in *Guid.
   void commit(codeview::GUID *Guid);
 
private:
   /// inside of these PDBs.
   llvm::SmallVector<std::unique_ptr<pdb::NativeSession>, 2> LoadedPDBs;
 
   std::vector<pdb::SecMapEntry> SectionMap;
 
   /// Type index mappings of type server PDBs that we've loaded so far.
   std::map<GUID, CVIndexMap> TypeServerIndexMappings;
 
+  /// Type index mappings of precompiled objects type map that we've loaded so
+  /// far.
+  std::map<uint32_t, CVIndexMap> PrecompTypeIndexMappings;
+
   /// List of TypeServer PDBs which cannot be loaded.
   /// Cached to prevent repeated load attempts.
   std::map<GUID, std::string> MissingTypeServerPDBs;
 };
 
 class DebugSHandler {
   PDBLinker &Linker;
 

 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
                                            StringRef SecName) {
   // First 4 bytes are section magic.
   if (Data.size() < 4)
     fatal(SecName + " too short");
   if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
     fatal(SecName + " has an invalid magic");
   return Data.slice(4);
 }
 
 static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
   if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
     return consumeDebugMagic(Sec->getContents(), SecName);
   return {};
 }
 
 // A COFF .debug$H section is currently a clang extension.  This function checks
static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
   TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) {
     auto Hash = pdb::hashTypeRecord(Type);
     if (auto E = Hash.takeError())
       fatal("type hashing error");
     TpiBuilder.addTypeRecord(Type.RecordData, *Hash);
   });
 }
 
-static Optional<TypeServer2Record>
-maybeReadTypeServerRecord(CVTypeArray &Types) {
-  auto I = Types.begin();
-  if (I == Types.end())
-    return None;
-  const CVType &Type = *I;
-  if (Type.kind() != LF_TYPESERVER2)
-    return None;
-  TypeServer2Record TS;
-  if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type), TS))
-    fatal("error reading type server record: " + toString(std::move(EC)));
-  return std::move(TS);
+// OBJs usually start their symbol stream with a S_OBJNAME record. This record
+// also contains the signature/key of the current PCH session. The signature
+// must be same for all objects which depend on the precompiled object.
+// Recompiling the precompiled headers will generate a new PCH key and thus
+// invalidate all the dependent objects.
+static uint32_t extractPCHSignature(ObjFile *File) {
+  auto DbgIt = find_if(File->getDebugChunks(), [](auto &C) {
+    return C->getSectionName() == ".debug$S";
+  });
+  if (!DbgIt)
+    return 0;
+
+  ArrayRef<uint8_t> Contents =
+      consumeDebugMagic((*DbgIt)->getContents(), ".debug$S");
+  DebugSubsectionArray Subsections;
+  BinaryStreamReader Reader(Contents, support::little);
+  ExitOnErr(Reader.readArray(Subsections, Contents.size()));
+
+  for (const DebugSubsectionRecord &SS : Subsections) {
+    if (SS.kind() != DebugSubsectionKind::Symbols)
+      continue;
+
+    // If it's there, the S_OBJNAME record shall come first in the stream.
+    Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), 0);
+    if (!Sym) {
+      consumeError(Sym.takeError());
+      continue;
+    }
+    if (auto ObjName = SymbolDeserializer::deserializeAs<ObjNameSym>(Sym.get()))
+      return ObjName->Signature;
+  }
+  return 0;
 }
 
-Expected<const CVIndexMap&> PDBLinker::mergeDebugT(ObjFile *File,
-                                                   CVIndexMap &ObjectIndexMap) {
+Expected<const CVIndexMap &>
+PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) {
   ScopedTimer T(TypeMergingTimer);
 
+  bool IsPrecompiledHeader = false;
+
   ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
+  if (Data.empty()) {
+    // Try again, Microsoft precompiled headers use .debug$P instead of
+    // .debug$T
+    Data = getDebugSection(File, ".debug$P");
+    IsPrecompiledHeader = true;
+  }
   if (Data.empty())
-    return ObjectIndexMap;
+    return *ObjectIndexMap; // no debug info
+
+  // Precompiled headers objects need to save the index map for further
+  // reference by other objects which use the precompiled headers.
+  if (IsPrecompiledHeader) {
+    uint32_t PCHSignature = extractPCHSignature(File);
+    if (PCHSignature == 0)
+      fatal("No signature found for the precompiled headers OBJ (" +
+            File->getName() + ")");
+
+    // When a precompiled headers object comes first on the command-line, we
+    // update the mapping here. Otherwise, if an object referencing the
+    // precompiled headers object comes first, the mapping is created in
+    // aquirePrecompObj(), thus we would skip this block.
+    if (!ObjectIndexMap->IsPrecompiledTypeMap) {
+      auto R = registerPrecompiledHeaders(PCHSignature);
+      if (R.second)
+        fatal(
+            "A precompiled headers OBJ with the same signature was already "
+            "provided! (" +
+            File->getName() + ")");
+
+      ObjectIndexMap = &R.first;
+    }
+  }
 
   BinaryByteStream Stream(Data, support::little);
   CVTypeArray Types;
   BinaryStreamReader Reader(Stream);
   if (auto EC = Reader.readArray(Types, Reader.getLength()))
     fatal("Reader::readArray failed: " + toString(std::move(EC)));
 
-  // Look through type servers. If we've already seen this type server, don't
-  // merge any type information.
-  if (Optional<TypeServer2Record> TS = maybeReadTypeServerRecord(Types))
-    return maybeMergeTypeServerPDB(File, *TS);
+  auto FirstType = Types.begin();
+  if (FirstType == Types.end())
+    return *ObjectIndexMap;
+
+  if (FirstType->kind() == LF_TYPESERVER2) {
+    // Look through type servers. If we've already seen this type server,
+    // don't merge any type information.
+    return maybeMergeTypeServerPDB(File, *FirstType);
+  } else if (FirstType->kind() == LF_PRECOMP) {
+    // This object was compiled with /Yu, so process the corresponding
+    // precompiled headers object (/Yc) first. Some type indices in the current
+    // object are referencing data in the precompiled headers object, so we need
+    // both to be loaded.
+    auto E = mergeInPrecompHeaderObj(File, *FirstType, ObjectIndexMap);
+    if (!E)
+      return E.takeError();
+
+    // Drop LF_PRECOMP record from the input stream, as it needs to be replaced
+    // with the precompiled headers object type stream.
+    Types.drop_front();
+  }
 
-  // This is a /Z7 object. Fill in the temporary, caller-provided
-  // ObjectIndexMap.
+  // Fill in the temporary, caller-provided ObjectIndexMap.
   if (Config->DebugGHashes) {
     ArrayRef<GloballyHashedType> Hashes;
     std::vector<GloballyHashedType> OwnedHashes;
     if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File))
       Hashes = getHashesFromDebugH(*DebugH);
     else {
       OwnedHashes = GloballyHashedType::hashTypes(Types);
       Hashes = OwnedHashes;
     }
 
     if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
-                                         ObjectIndexMap.TPIMap, Types, Hashes))
+                                         ObjectIndexMap->TPIMap, Types, Hashes,
+                                         File->EndPrecomp))
       fatal("codeview::mergeTypeAndIdRecords failed: " +
             toString(std::move(Err)));
   } else {
-    if (auto Err = mergeTypeAndIdRecords(IDTable, TypeTable,
-                                         ObjectIndexMap.TPIMap, Types))
+    if (auto Err =
+            mergeTypeAndIdRecords(IDTable, TypeTable, ObjectIndexMap->TPIMap,
+                                  Types, File->EndPrecomp))
       fatal("codeview::mergeTypeAndIdRecords failed: " +
             toString(std::move(Err)));
   }
-  return ObjectIndexMap;
+  return *ObjectIndexMap;
 }
 
 static Expected<std::unique_ptr<pdb::NativeSession>>
 tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
   // Ensure the file exists before anything else. We want to return ENOENT,
   // "file not found", even if the path points to a removable device (in which
   // case the return message would be EAGAIN, "resource unavailable try again")
   if (!llvm::sys::fs::exists(TSPath))
tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
   // must match the GUID specified in the TypeServer2 record.
   if (ExpectedInfo->getGuid() != GuidFromObj)
     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) {
+PDBLinker::maybeMergeTypeServerPDB(ObjFile *File, const CVType &FirstType) {
+  TypeServer2Record TS;
+  if (auto EC =
+          TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType), TS))
+    fatal("error reading record: " + toString(std::move(EC)));
+
   const GUID &TSId = TS.getGuid();
   StringRef TSPath = TS.getName();
 
   // First, check if the PDB has previously failed to load.
   auto PrevErr = MissingTypeServerPDBs.find(TSId);
   if (PrevErr != MissingTypeServerPDBs.end())
     return createFileError(
         TSPath,
if (Config->DebugGHashes) {
     // PDB we have to synthesize global hashes.  To do this, we first synthesize
     // global hashes for the TPI stream, since it is independent, then we
     // synthesize hashes for the IPI stream, using the hashes for the TPI stream
     // as inputs.
     auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
     auto IpiHashes =
         GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
 
+    Optional<EndPrecompRecord> EndPrecomp;
     // Merge TPI first, because the IPI stream will reference type indices.
     if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
-                                    ExpectedTpi->typeArray(), TpiHashes))
+                                    ExpectedTpi->typeArray(), TpiHashes, EndPrecomp))
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
     if (auto Err =
             mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
                            ExpectedIpi->typeArray(), IpiHashes))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   } else {
     // Merge TPI first, because the IPI stream will reference type indices.
     if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
                                     ExpectedTpi->typeArray()))
       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 
     // Merge IPI.
     if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
                                   ExpectedIpi->typeArray()))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
   }
 
   return IndexMap;
 }
 
+Expected<const CVIndexMap &>
+PDBLinker::mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
+                                   CVIndexMap *ObjectIndexMap) {
+  PrecompRecord Precomp;
+  if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType),
+                                                Precomp))
+    fatal("error reading record: " + toString(std::move(EC)));
+
+  auto E = aquirePrecompObj(File, Precomp);
+  if (!E)
+    return createFileError(Precomp.getPrecompFilePath().str(), E.takeError());
+
+  const CVIndexMap &PrecompIndexMap = *E;
+  assert(PrecompIndexMap.IsPrecompiledTypeMap);
+
+  if (PrecompIndexMap.TPIMap.empty())
+    return PrecompIndexMap;
+
+  assert(Precomp.getStartTypeIndex() == TypeIndex::FirstNonSimpleIndex);
+  assert(Precomp.getTypesCount() <= PrecompIndexMap.TPIMap.size());
+  // Use the previously remapped index map from the precompiled headers.
+  ObjectIndexMap->TPIMap.append(PrecompIndexMap.TPIMap.begin(),
+                                PrecompIndexMap.TPIMap.begin() +
+                                    Precomp.getTypesCount());
+  return *ObjectIndexMap;
+}
+
+static bool equals_path(StringRef path1, StringRef path2) {
+#if defined(_WIN32)
+  return path1.equals_lower(path2);
+#else
+  return path1.equals(path2);
+#endif
+}
+
+// Find an OBJ provided on the command line, either by name or full path
+static Optional<std::pair<ObjFile *, std::string>>
+findObjByName(StringRef NameOrPath) {
+  SmallString<128> CurrentPath;
+
+  StringRef FileNameOnly = sys::path::filename(NameOrPath);
+
+  for (ObjFile *F : ObjFile::Instances) {
+    CurrentPath = F->getName();
+    sys::fs::make_absolute(CurrentPath);
+
+    // First compare with the full path name
+    if (equals_path(CurrentPath, NameOrPath))
+      return std::make_pair(F, CurrentPath.str().str());
+
+    StringRef CurrentFileName = sys::path::filename(CurrentPath);
+
+    // Otherwise compare based solely on the file name (link.exe behavior)
+    if (equals_path(CurrentFileName, FileNameOnly))
+      return std::make_pair(F, CurrentPath.str().str());
+  }
+  return {};
+}
+
+std::pair<CVIndexMap &, bool /*already there*/>
+PDBLinker::registerPrecompiledHeaders(uint32_t Signature) {
+  auto Insertion = PrecompTypeIndexMappings.insert({Signature, CVIndexMap()});
+  CVIndexMap &IndexMap = Insertion.first->second;
+  if (!Insertion.second)
+    return {IndexMap, true};
+  // Mark this map as a precompiled types map.
+  IndexMap.IsPrecompiledTypeMap = true;
+  return {IndexMap, false};
+}
+
+Expected<const CVIndexMap &>
+PDBLinker::aquirePrecompObj(ObjFile *File, PrecompRecord Precomp) {
+  // First, check if we already loaded the precompiled headers object with this
+  // signature. Return the type index mapping if we've already seen it.
+  auto R = registerPrecompiledHeaders(Precomp.getSignature());
+  if (R.second)
+    return R.first;
+
+  CVIndexMap &IndexMap = R.first;
+
+  SmallString<128> PrecompPath = Precomp.getPrecompFilePath();
+  sys::fs::make_absolute(PrecompPath);
+
+  // Cross-compile warning: given that Clang doesn't generate LF_PRECOMP
+  // records, we assume the OBJ comes from a Windows build of cl.exe. Thusly,
+  // the paths embedded in the OBJs are in the Windows format.
+  sys::path::native(PrecompPath, sys::path::Style::windows);
+
+  // link.exe requires that a precompiled headers object must always be provided
+  // on the command-line, even if that's not necessary.
+  auto PrecompFilePath = findObjByName(PrecompPath);
+  if (!PrecompFilePath)
+    return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
+
+  ObjFile *CurrentFile = PrecompFilePath->first;
+
+  addObjFile(CurrentFile, &IndexMap);
+
+  if (!CurrentFile->EndPrecomp)
+    fatal(PrecompFilePath->second + " is not a precompiled headers object");
+
+  if (Precomp.getSignature() != CurrentFile->EndPrecomp->getSignature())
+    return make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date);
+
+  return IndexMap;
+}
+
 static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
   if (TI.isSimple())
     return true;
   if (TI.toArrayIndex() >= TypeIndexMap.size())
     return false;
   TI = TypeIndexMap[TI.toArrayIndex()];
   return true;
 }
for (FileChecksumEntry &FC : Checksums) {
     pdbMakeAbsolute(FileName);
     ExitOnErr(Linker.Builder.getDbiBuilder().addModuleSourceFile(
         *File.ModuleDBI, FileName));
     NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
   }
   File.ModuleDBI->addDebugSubsection(std::move(NewChecksums));
 }
 
-void PDBLinker::addObjFile(ObjFile *File) {
+void PDBLinker::addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap) {
+  if (File->wasProcessedForPDB())
+    return;
   // Add a module descriptor for every object file. We need to put an absolute
   // path to the object into the PDB. If this is a plain object, we make its
   // path absolute. If it's an object in an archive, we make the archive path
   // absolute.
   bool InArchive = !File->ParentName.empty();
   SmallString<128> Path = InArchive ? File->ParentName : File->getName();
   pdbMakeAbsolute(Path);
   StringRef Name = InArchive ? File->getName() : StringRef(Path);
for (Chunk *C : Chunks) {
     break;
   }
 
   // Before we can process symbol substreams from .debug$S, we need to process
   // 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);
+  auto IndexMapResult =
+      mergeDebugT(File, ExternIndexMap ? ExternIndexMap : &ObjectIndexMap);
 
   // If the .debug$T sections fail to merge, assume there is no debug info.
   if (!IndexMapResult) {
     auto FileName = sys::path::filename(Path);
     warn("Cannot use debug info for '" + FileName + "'\n" +
          ">>> failed to load reference " +
          StringRef(toString(IndexMapResult.takeError())));
     return;

lld/trunk/test/COFF/precomp-link.test

+RUN: lld-link %S/Inputs/precomp-a.obj %S/Inputs/precomp-b.obj %S/Inputs/precomp.obj /nodefaultlib /entry:main /debug /pdb:%t.pdb /out:%t.exe /opt:ref /opt:icf
+RUN: llvm-pdbutil dump -types %t.pdb | FileCheck %s
+
+RUN: lld-link %S/Inputs/precomp.obj %S/Inputs/precomp-a.obj %S/Inputs/precomp-b.obj /nodefaultlib /entry:main /debug /pdb:%t.pdb /out:%t.exe /opt:ref /opt:icf
+RUN: llvm-pdbutil dump -types %t.pdb | FileCheck %s
+
+RUN: lld-link %S/Inputs/precomp-a.obj %S/Inputs/precomp-invalid.obj %S/Inputs/precomp.obj /nodefaultlib /entry:main /debug /pdb:%t.pdb /out:%t.exe /opt:ref /opt:icf 2>&1 | FileCheck %s -check-prefix FAILURE
+
+FAILURE: warning: Cannot use debug info for 'precomp-invalid.obj'
+FAILURE-NEXT: failed to load reference '{{.*}}precomp.obj': The signature does not match; the file(s) might be out of date.
+
+CHECK: Types (TPI Stream)
+CHECK-NOT: LF_PRECOMP
+CHECK-NOT: LF_ENDPRECOMP
+
+// precomp.h
+#pragma once
+int Function(char A);
+
+// precomp.cpp
+#include "precomp.h"
+
+// a.cpp
+#include "precomp.h"
+int main(void) {
+  Function('a');
+  return 0;
+}
+
+// b.cpp
+#include "precomp.h"
+int Function(char a) {
+  return (int)a;
+}
+
+// cl.exe precomp.cpp /Z7 /Ycprecomp.h /c
+// cl.exe a.cpp b.cpp /Z7 /Yuprecomp.h /c

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

 ///
 /// \param IdsAndTypes The collection of id records to merge in.
 ///
 /// \returns Error::success() if the operation succeeded, otherwise an
 /// appropriate error code.
 Error mergeTypeAndIdRecords(MergingTypeTableBuilder &DestIds,
                             MergingTypeTableBuilder &DestTypes,
                             SmallVectorImpl<TypeIndex> &SourceToDest,
-                            const CVTypeArray &IdsAndTypes);
+                            const CVTypeArray &IdsAndTypes,
+                            Optional<EndPrecompRecord> &EndPrecomp);
 
 Error mergeTypeAndIdRecords(GlobalTypeTableBuilder &DestIds,
                             GlobalTypeTableBuilder &DestTypes,
                             SmallVectorImpl<TypeIndex> &SourceToDest,
                             const CVTypeArray &IdsAndTypes,
-                            ArrayRef<GloballyHashedType> Hashes);
+                            ArrayRef<GloballyHashedType> Hashes,
+                            Optional<EndPrecompRecord> &EndPrecomp);
 
 Error mergeTypeRecords(GlobalTypeTableBuilder &Dest,
                        SmallVectorImpl<TypeIndex> &SourceToDest,
                        const CVTypeArray &Types,
-                       ArrayRef<GloballyHashedType> Hashes);
+                       ArrayRef<GloballyHashedType> Hashes,
+                       Optional<EndPrecompRecord> &EndPrecomp);
 
 Error mergeIdRecords(GlobalTypeTableBuilder &Dest, ArrayRef<TypeIndex> Types,
                      SmallVectorImpl<TypeIndex> &SourceToDest,
                      const CVTypeArray &Ids,
                      ArrayRef<GloballyHashedType> Hashes);
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_TYPESTREAMMERGER_H

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

 namespace llvm {
 namespace pdb {
 
 enum class pdb_error_code {
   invalid_utf8_path = 1,
   dia_sdk_not_present,
   dia_failed_loading,
   signature_out_of_date,
-  type_server_not_found,
   unspecified,
 };
-} // namespace codeview
+} // namespace pdb
 } // namespace llvm
 
 namespace std {
-    template <>
-    struct is_error_code_enum<llvm::pdb::pdb_error_code> : std::true_type {};
 } // namespace std
 
 namespace llvm {
 namespace pdb {
-    const std::error_category &PDBErrCategory();
 
-    inline std::error_code make_error_code(pdb_error_code E) {
-        return std::error_code(static_cast<int>(E), PDBErrCategory());
-    }
 
 /// Base class for errors originating when parsing raw PDB files
 class PDBError : public ErrorInfo<PDBError, StringError> {
 public:
   using ErrorInfo<PDBError, StringError>::ErrorInfo; // inherit constructors
   PDBError(const Twine &S) : ErrorInfo(S, pdb_error_code::unspecified) {}
   static char ID;
 };
 } // namespace pdb
 } // namespace llvm
 #endif

llvm/trunk/include/llvm/Support/BinaryStreamArray.h

public:
   }
 
   const Extractor &getExtractor() const { return E; }
   Extractor &getExtractor() { return E; }
 
   BinaryStreamRef getUnderlyingStream() const { return Stream; }
   void setUnderlyingStream(BinaryStreamRef S) { Stream = S; }
 
+  void drop_front() { Stream = Stream.drop_front(begin()->length()); }
+
 private:
   BinaryStreamRef Stream;
   Extractor E;
 };
 
 template <typename ValueType, typename Extractor>
 class VarStreamArrayIterator
     : public iterator_facade_base<VarStreamArrayIterator<ValueType, Extractor>,

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

std::string message(int Condition) const override {
     case cv_error_code::unknown_member_record:
       return "The member record is of an unknown type.";
     }
     llvm_unreachable("Unrecognized cv_error_code");
   }
 };
 
 static llvm::ManagedStatic<CodeViewErrorCategory> CodeViewErrCategory;
-const std::error_category &llvm::codeview::CVErrorCategory() { return *CodeViewErrCategory; }
+const std::error_category &llvm::codeview::CVErrorCategory() {
+  return *CodeViewErrCategory;
+}
 
 char CodeViewError::ID;

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

 //===-- TypeStreamMerger.cpp ------------------------------------*- 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/TypeStreamMerger.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/Support/Error.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 

 /// 0x1000.
 ///
 /// Type records are only allowed to use type indices smaller than their own, so
 /// a type stream is effectively a topologically sorted DAG. Cycles occuring in
 /// the type graph of the source program are resolved with forward declarations
 /// of composite types. This class implements the following type stream merging
 /// algorithm, which relies on this DAG structure:
 ///
 /// - Begin with a new empty stream, and a new empty hash table that maps from
 ///   type record contents to new type index.
 /// - For each new type stream, maintain a map from source type index to
 ///   destination type index.
 /// - For each record, copy it and rewrite its type indices to be valid in the
 ///   destination type stream.
 /// - If the new type record is not already present in the destination stream
 ///   hash table, append it to the destination type stream, assign it the next
 ///   type index, and update the two hash tables.
 /// - If the type record already exists in the destination stream, discard it
 ///   and update the type index map to forward the source type index to the
 ///   existing destination type index.
 ///
 /// As an additional complication, type stream merging actually produces two
 /// streams: an item (or IPI) stream and a type stream, as this is what is
 /// actually stored in the final PDB. We choose which records go where by
 /// looking at the record kind.
 class TypeStreamMerger {
 public:
   explicit TypeStreamMerger(SmallVectorImpl<TypeIndex> &SourceToDest)
       : IndexMap(SourceToDest) {
-    SourceToDest.clear();
+    // When dealing with precompiled headers objects, all data in SourceToDest
+    // belongs to the precompiled headers object, and is assumed to be already
+    // remapped to the target PDB. Any forthcoming type that will be merged in
+    // might potentially back-reference this data. We also don't want to resolve
+    // twice the types in the precompiled object.
+    CurIndex += SourceToDest.size();
   }
 
   static const TypeIndex Untranslated;
 
   // Local hashing entry points
   Error mergeTypesAndIds(MergingTypeTableBuilder &DestIds,
                          MergingTypeTableBuilder &DestTypes,
-                         const CVTypeArray &IdsAndTypes);
+                         const CVTypeArray &IdsAndTypes,
+                         Optional<EndPrecompRecord> &EP);
   Error mergeIdRecords(MergingTypeTableBuilder &Dest,
                        ArrayRef<TypeIndex> TypeSourceToDest,
                        const CVTypeArray &Ids);
   Error mergeTypeRecords(MergingTypeTableBuilder &Dest,
                          const CVTypeArray &Types);
 
   // Global hashing entry points
   Error mergeTypesAndIds(GlobalTypeTableBuilder &DestIds,
                          GlobalTypeTableBuilder &DestTypes,
                          const CVTypeArray &IdsAndTypes,
-                         ArrayRef<GloballyHashedType> Hashes);
+                         ArrayRef<GloballyHashedType> Hashes,
+                         Optional<EndPrecompRecord> &EP);
   Error mergeIdRecords(GlobalTypeTableBuilder &Dest,
                        ArrayRef<TypeIndex> TypeSourceToDest,
                        const CVTypeArray &Ids,
                        ArrayRef<GloballyHashedType> Hashes);
   Error mergeTypeRecords(GlobalTypeTableBuilder &Dest, const CVTypeArray &Types,
-                         ArrayRef<GloballyHashedType> Hashes);
+                         ArrayRef<GloballyHashedType> Hashes,
+                         Optional<EndPrecompRecord> &EP);
 
 private:
   Error doit(const CVTypeArray &Types);
 
   Error remapAllTypes(const CVTypeArray &Types);
 
   Error remapType(const CVType &Type);
 
private:
   }
 
   bool remapIndexFallback(TypeIndex &Idx, ArrayRef<TypeIndex> Map);
 
   Error errorCorruptRecord() const {
     return llvm::make_error<CodeViewError>(cv_error_code::corrupt_record);
   }
 
+  Expected<bool> shouldRemapType(const CVType &Type);
+
   Optional<Error> LastError;
 
   bool UseGlobalHashes = false;
 
   bool IsSecondPass = false;
 
   unsigned NumBadIndices = 0;
 
private:
 
   /// Map from source type index to destination type index. Indexed by source
   /// type index minus 0x1000.
   SmallVectorImpl<TypeIndex> &IndexMap;
 
   /// Temporary storage that we use to copy a record's data while re-writing
   /// its type indices.
   SmallVector<uint8_t, 256> RemapStorage;
+
+  Optional<EndPrecompRecord> EndPrecomp; 
 };
 
 } // end anonymous namespace
 
 const TypeIndex TypeStreamMerger::Untranslated(SimpleTypeKind::NotTranslated);
 
 static bool isIdRecord(TypeLeafKind K) {
   switch (K) {
Error TypeStreamMerger::mergeIdRecords(MergingTypeTableBuilder &Dest,
   TypeLookup = TypeSourceToDest;
   UseGlobalHashes = false;
 
   return doit(Ids);
 }
 
 Error TypeStreamMerger::mergeTypesAndIds(MergingTypeTableBuilder &DestIds,
                                          MergingTypeTableBuilder &DestTypes,
-                                         const CVTypeArray &IdsAndTypes) {
+                                         const CVTypeArray &IdsAndTypes,
+                                         Optional<EndPrecompRecord> &EP) {
   DestIdStream = &DestIds;
   DestTypeStream = &DestTypes;
   UseGlobalHashes = false;
-  return doit(IdsAndTypes);
+  auto Err = doit(IdsAndTypes);
+  EP = EndPrecomp;
+  return Err;
 }
 
 // Global hashing entry points
 Error TypeStreamMerger::mergeTypeRecords(GlobalTypeTableBuilder &Dest,
                                          const CVTypeArray &Types,
-                                         ArrayRef<GloballyHashedType> Hashes) {
+                                         ArrayRef<GloballyHashedType> Hashes,
+                                         Optional<EndPrecompRecord> &EP) {
   DestGlobalTypeStream = &Dest;
   UseGlobalHashes = true;
   GlobalHashes = Hashes;
-
-  return doit(Types);
+  auto Err = doit(Types);
+  EP = EndPrecomp;
+  return Err;
 }
 
 Error TypeStreamMerger::mergeIdRecords(GlobalTypeTableBuilder &Dest,
                                        ArrayRef<TypeIndex> TypeSourceToDest,
                                        const CVTypeArray &Ids,
                                        ArrayRef<GloballyHashedType> Hashes) {
   DestGlobalIdStream = &Dest;
   TypeLookup = TypeSourceToDest;
   UseGlobalHashes = true;
   GlobalHashes = Hashes;
 
   return doit(Ids);
 }
 
 Error TypeStreamMerger::mergeTypesAndIds(GlobalTypeTableBuilder &DestIds,
                                          GlobalTypeTableBuilder &DestTypes,
                                          const CVTypeArray &IdsAndTypes,
-                                         ArrayRef<GloballyHashedType> Hashes) {
+                                         ArrayRef<GloballyHashedType> Hashes,
+                                         Optional<EndPrecompRecord> &EP) {
   DestGlobalIdStream = &DestIds;
   DestGlobalTypeStream = &DestTypes;
   UseGlobalHashes = true;
   GlobalHashes = Hashes;
-  return doit(IdsAndTypes);
+  auto Err = doit(IdsAndTypes);
+  EP = EndPrecomp;
+  return Err;
 }
 
 Error TypeStreamMerger::doit(const CVTypeArray &Types) {
   if (auto EC = remapAllTypes(Types))
     return EC;
 
   // If we found bad indices but no other errors, try doing another pass and see
   // if we can resolve the indices that weren't in the map on the first pass.
Error TypeStreamMerger::remapAllTypes(const CVTypeArray &Types) {
   ArrayRef<uint8_t> Buffer;
   cantFail(Stream.readBytes(0, Stream.getLength(), Buffer));
 
   return forEachCodeViewRecord<CVType>(
       Buffer, [this](const CVType &T) { return remapType(T); });
 }
 
 Error TypeStreamMerger::remapType(const CVType &Type) {
+  auto R = shouldRemapType(Type);
+  if (!R)
+    return R.takeError();
+
+  TypeIndex DestIdx = Untranslated;
+  if (*R) {
     auto DoSerialize =
         [this, Type](MutableArrayRef<uint8_t> Storage) -> ArrayRef<uint8_t> {
       return remapIndices(Type, Storage);
     };
-
-  TypeIndex DestIdx = Untranslated;
     if (LLVM_LIKELY(UseGlobalHashes)) {
       GlobalTypeTableBuilder &Dest =
           isIdRecord(Type.kind()) ? *DestGlobalIdStream : *DestGlobalTypeStream;
       GloballyHashedType H = GlobalHashes[CurIndex.toArrayIndex()];
       DestIdx = Dest.insertRecordAs(H, Type.RecordData.size(), DoSerialize);
     } else {
       MergingTypeTableBuilder &Dest =
           isIdRecord(Type.kind()) ? *DestIdStream : *DestTypeStream;
 
       RemapStorage.resize(Type.RecordData.size());
       ArrayRef<uint8_t> Result = DoSerialize(RemapStorage);
       if (!Result.empty())
         DestIdx = Dest.insertRecordBytes(Result);
     }
+  }
   addMapping(DestIdx);
 
   ++CurIndex;
   assert((IsSecondPass || IndexMap.size() == slotForIndex(CurIndex)) &&
          "visitKnownRecord should add one index map entry");
   return Error::success();
 }
 
Error llvm::codeview::mergeIdRecords(MergingTypeTableBuilder &Dest,
                                      SmallVectorImpl<TypeIndex> &SourceToDest,
                                      const CVTypeArray &Ids) {
   TypeStreamMerger M(SourceToDest);
   return M.mergeIdRecords(Dest, TypeSourceToDest, Ids);
 }
 
 Error llvm::codeview::mergeTypeAndIdRecords(
     MergingTypeTableBuilder &DestIds, MergingTypeTableBuilder &DestTypes,
-    SmallVectorImpl<TypeIndex> &SourceToDest, const CVTypeArray &IdsAndTypes) {
+    SmallVectorImpl<TypeIndex> &SourceToDest, const CVTypeArray &IdsAndTypes,
+    Optional<EndPrecompRecord> &EndPrecomp) {
   TypeStreamMerger M(SourceToDest);
-  return M.mergeTypesAndIds(DestIds, DestTypes, IdsAndTypes);
+  return M.mergeTypesAndIds(DestIds, DestTypes, IdsAndTypes, EndPrecomp);
 }
 
 Error llvm::codeview::mergeTypeAndIdRecords(
     GlobalTypeTableBuilder &DestIds, GlobalTypeTableBuilder &DestTypes,
     SmallVectorImpl<TypeIndex> &SourceToDest, const CVTypeArray &IdsAndTypes,
-    ArrayRef<GloballyHashedType> Hashes) {
+    ArrayRef<GloballyHashedType> Hashes,
+    Optional<EndPrecompRecord> &EndPrecomp) {
   TypeStreamMerger M(SourceToDest);
-  return M.mergeTypesAndIds(DestIds, DestTypes, IdsAndTypes, Hashes);
+  return M.mergeTypesAndIds(DestIds, DestTypes, IdsAndTypes, Hashes,
+                            EndPrecomp);
 }
 
 Error llvm::codeview::mergeTypeRecords(GlobalTypeTableBuilder &Dest,
                                        SmallVectorImpl<TypeIndex> &SourceToDest,
                                        const CVTypeArray &Types,
-                                       ArrayRef<GloballyHashedType> Hashes) {
+                                       ArrayRef<GloballyHashedType> Hashes,
+                                       Optional<EndPrecompRecord> &EndPrecomp) {
   TypeStreamMerger M(SourceToDest);
-  return M.mergeTypeRecords(Dest, Types, Hashes);
+  return M.mergeTypeRecords(Dest, Types, Hashes, EndPrecomp);
 }
 
 Error llvm::codeview::mergeIdRecords(GlobalTypeTableBuilder &Dest,
                                      ArrayRef<TypeIndex> Types,
                                      SmallVectorImpl<TypeIndex> &SourceToDest,
                                      const CVTypeArray &Ids,
                                      ArrayRef<GloballyHashedType> Hashes) {
   TypeStreamMerger M(SourceToDest);
   return M.mergeIdRecords(Dest, Types, Ids, Hashes);
 }
+
+Expected<bool> TypeStreamMerger::shouldRemapType(const CVType &Type) {
+  // For object files containing precompiled types, we need to extract the
+  // signature, through EndPrecompRecord. This is done here for performance
+  // reasons, to avoid re-parsing the Types stream.
+  if (Type.kind() == LF_ENDPRECOMP) {
+    assert(!EndPrecomp);
+    EndPrecomp.emplace();
+    if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type),
+                                                  EndPrecomp.getValue()))
+      return joinErrors(std::move(EC), errorCorruptRecord());
+    return false;
+  }
+  return true;
+}

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

 // deal with the Error value directly, rather than converting to error_code.
 class PDBErrorCategory : public std::error_category {
 public:
   const char *name() const noexcept override { return "llvm.pdb"; }
   std::string message(int Condition) const override {
     switch (static_cast<pdb_error_code>(Condition)) {
     case pdb_error_code::unspecified:
       return "An unknown error has occurred.";
-    case pdb_error_code::type_server_not_found:
-        return "Type server PDB was not found.";
     case pdb_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 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.";

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

if (SectionName == ".debug$T") {
       CVTypeArray Types;
       BinaryStreamReader Reader(Data, llvm::support::little);
       if (auto EC = Reader.readArray(Types, Reader.getLength())) {
         consumeError(std::move(EC));
         W.flush();
         error(object_error::parse_failed);
       }
       SmallVector<TypeIndex, 128> SourceToDest;
-      if (auto EC = mergeTypeAndIdRecords(CVIDs, CVTypes, SourceToDest, Types))
+      Optional<EndPrecompRecord> EndPrecomp;
+      if (auto EC = mergeTypeAndIdRecords(CVIDs, CVTypes, SourceToDest, Types,
+                                          EndPrecomp))
         return error(std::move(EC));
     }
   }
 }
 
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");