[LLD COFF / PDB] Incrementally update the BuildId when writing a PDB.

[zturner]

Summary

Previously, our algorithm to compute a build id involved hashing the executable and storing that as the GUID in the CV Debug Record chunk, and setting the age to 1.

This breaks down in one very obvious case: a user adds some newlines to a file, rebuilds, but changes nothing else. This causes new line information and new file checksums to get written to the PDB, meaning that the debug info is different, but the generated code would be the same, so we would write the same build over again with an age of 1.

Anyone using a symbol cache would have a problem now, because the debugger would open the executable, look at the age and guid, find a matching PDB in the symbol cache and then load it. It would never copy the new PDB to the symbol cache.

There are various other scenarios where this can arise as well, but this one is both the easiest to describe and is what people will run into the most often.

PE files are ultimately matched against PDBs using 3 pieces of information:

1. A 128-bit GUID. When an executable is being written for the first time, a new GUID is generated, otherwise the existing GUID is re-used.
2. When an executable is being written for the first time, the Age is set to 1, otherwise the age is incremented.
3. Every time an executable is written, the time stamp field is updated.

Then, the debugger goes through these steps when looking for a PDB:

1. Is there a PDB with a matching GUID? If not, there's no debug info, otherwise go to step 2.
2. Does the PDB have a matching age? If not, warn the user that the debug info might be stale, otherwise go to step 3.
3. Does the PDB have a matching timestamp? If not, warn the user that the debug info might be stale, otherwise we're good to go.

This patch implements the first two of these fields. We're still not writing a timestamp, but this is at least better than before. Unfortunately, this hurts reproducibility, but if we want PDBs to work correctly, we don't have much of a choice but to do this. We can still get reproducibility through additional flags, or via a tool that runs as a post-processing step to strip out un-reproducible pieces.

[ruiu]

I think it is more straightforward if you change Writer::writeBuildId to compute a hash using not only an executable but also a pdb file. If you do that, every time debug info is different, you'll get a different build id, which I think solves the issue.

That way, we can still maintain build reproducibility. I don't want to use a random value as a build id.

[zturner]

In D36758#842342, @ruiu wrote:

I think it is more straightforward if you change Writer::writeBuildId to compute a hash using not only an executable but also a pdb file. If you do that, every time debug info is different, you'll get a different build id, which I think solves the issue.

That way, we can still maintain build reproducibility. I don't want to use a random value as a build id.

I actually think that would be rather difficult. First we would have to emit the entire executable and PDB, then we would have to hash them, then we would have to modify them and write them again.

Even if we did do it that way, there is another problem. Now every time the debug info changes, a new PDB is generated, which means you get a new entry in your symbol cache / symbol server. Over time, your symbol server will grow indefinitely in size because stale entries aren't overwritten, they are copied to a new location (it computes the folder to store the symbol file in based on the GUID).

I realize this is not what any of us wants, but if we want to be compatible with MS symbol servers, I believe this is the way it has to be done.

[rnk]

In D36758#842342, @ruiu wrote:

I think it is more straightforward if you change Writer::writeBuildId to compute a hash using not only an executable but also a pdb file. If you do that, every time debug info is different, you'll get a different build id, which I think solves the issue.

That way, we can still maintain build reproducibility. I don't want to use a random value as a build id.

PDB files are too big. I don't want to MD5 4GB of data just to avoid a random number.

My suggestion for people that want determinstic builds is that we ask them to pass a flag like /PDBGUID:XXXXXX-XXX-XX. Then it's completely out of our hands.

[rnk]

In D36758#842357, @zturner wrote:

In D36758#842342, @ruiu wrote:

I think it is more straightforward if you change Writer::writeBuildId to compute a hash using not only an executable but also a pdb file. If you do that, every time debug info is different, you'll get a different build id, which I think solves the issue.

That way, we can still maintain build reproducibility. I don't want to use a random value as a build id.

I actually think that would be rather difficult. First we would have to emit the entire executable and PDB, then we would have to hash them, then we would have to modify them and write them again.

Even if we did do it that way, there is another problem. Now every time the debug info changes, a new PDB is generated, which means you get a new entry in your symbol cache / symbol server. Over time, your symbol server will grow indefinitely in size because stale entries aren't overwritten, they are copied to a new location (it computes the folder to store the symbol file in based on the GUID).

I realize this is not what any of us wants, but if we want to be compatible with MS symbol servers, I believe this is the way it has to be done.

This is also true. We have to try to reuse the PDB GUID if we can. This means our output is not a pure function of the input objects, unless you consider the output image as an additional input. Once we accept that this will be the default operating model, adding a random number isn't that big of a deal. We can always offer an escape hatch.

[ruiu]

lld/COFF/PDB.cpp

827 ↗

(On Diff #111208)

I believe you can remove {}.

831 ↗

(On Diff #111208)

If Age is assigned only once, I'd remove that variable and use BuildId.PDB70.Age directly instead.

834 ↗

(On Diff #111208)

Does this mean both Uuid and uuid are visible in this function? That is a bit confusing.

lld/COFF/Writer.cpp

786 ↗

(On Diff #111208)

Looks like this function does not depend on Writer class. Can you make this a static non-member function that returns a const codeview::DebugInfo * (or a nullptr if no previous build id is available)?

Also I think this function needs comment as to why we want to keep existing build id if available.

[zturner]

lld/COFF/Writer.cpp

786 ↗

(On Diff #111208)

It would have to return an Optional<codeview::DebugInfo>. It can't return by pointer because after the function returns the file will be closed and the memory the pointer points to will be detroyed.

But yea I can do that.

[zturner]

Updated from feedback.

[compnerd]

Nice! Im looking forward to this! It was one of the bits that I hadn't gotten around to implementing just yet, so thanks for taking it on.

lld/COFF/PDB.cpp

827 ↗

(On Diff #111208)

Where is this used?

831 ↗

(On Diff #111208)

+1 on the inline the variable use.

lld/COFF/Writer.cpp

318 ↗

(On Diff #111208)

I think that this is not particularly correct. In the CV case, no PDB is supposed to be generated, and we should be creating a COFF group entry instead. I realize that its unlikely that we will support the /Z7 mode, but, the comment is slightly misleading.

792 ↗

(On Diff #111208)

Can you change this to ExpectedOutput? It could be a dll.

799 ↗

(On Diff #111208)

When would this be false? I thought that link is never used as a resource compiler, and you use resgen for that.

809 ↗

(On Diff #111208)

Is the bitsex enough? Shouldn't we check the machine and the bitsex?

820 ↗

(On Diff #111208)

I think that this deserves a comment. The only reason we need this is because we don't support the other versions rather than it is not the one that we want. I think that we should be checking that the existing CVSignature matches the one that we are going to write out this time (which ATM, just happens to be this constant).

[zturner]

lld/COFF/Writer.cpp

799 ↗

(On Diff #111208)

If the output file exists on disk but is just a random text file, for example.

809 ↗

(On Diff #111208)

Ahh yes, I suppose you could be writing an intel x86-64 binary and the existing binary on disk is arm64 or something. We shouldn't re-use the build id in that case either.

[zturner]

Fixes suggested by compnerd@

[ruiu]

LGTM

lld/COFF/Writer.cpp

270 ↗

(On Diff #111252)

remove llvm::

[thakis]

lld/trunk/COFF/Writer.cpp

237

Could this talk about build determinism a bit? rnk mentioned that upthread.

Is there a list of all sources of build indeterminism in lld? Deterministic builds is one of the motivations for the whole clang-cl thing, so it'd be good if we had a list of things needed to get there :-)

[ruiu]

Until this patch, lld behavior was deterministic. It generated the same output as long as your input files and command line options are the same.

[zturner]

We can definitely make a list. There are quite a few in PDB that we will need to work out. However, we're kind of at the mercy of the ecosystem we're trying to support. determinism was one goal, but making sure developers can debug their code (and making sure we can debug crashes generated in the wild) was another goal. And those two goals conflict with each other in some ways.

I don't dispute the utility of reproducible builds, but at least right now, debug info is what's blocking us. As far as I can tell there is no way to have both at the same time unless you have a post-processing step that strips out the non-deterministic portions of the debug info. Which seems like something we'll have to look into when we get to that bridge, but at least immediately, it's not what's blocking us.

The line number case described earlier is one example. People need to be able to continue to debug their code if they add a blank line (PDB needs to change even though EXE doesn't).

And to work with symbol and source server, EXEs need to re-use the same GUID. We can still get determinism by adding flags such as /PDBGUID:{...} and /PDBAGE:n, but the default-out-of-the-box experience really needs to err on the side of actually working IMO.

lld/trunk/COFF/PDB.h

 namespace lld {
 namespace coff {
 class OutputSection;
 class SymbolTable;
 
 void createPDB(SymbolTable *Symtab,
                llvm::ArrayRef<OutputSection *> OutputSections,
                llvm::ArrayRef<uint8_t> SectionTable,
-               const llvm::codeview::DebugInfo *DI);
+               const llvm::codeview::DebugInfo &BuildId);
 }
 }
 
 #endif

lld/trunk/COFF/PDB.cpp

 
 class PDBLinker {
 public:
   PDBLinker(SymbolTable *Symtab)
       : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
         IDTable(Alloc) {}
 
   /// Emit the basic PDB structure: initial streams, headers, etc.
-  void initialize(const llvm::codeview::DebugInfo *DI);
+  void initialize(const llvm::codeview::DebugInfo &BuildId);
 
   /// 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);
 
   /// Produce a mapping from the type and item indices used in the object
static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       Sym, Allocator, CodeViewContainer::Pdb));
 }
 
 // Creates a PDB file.
 void coff::createPDB(SymbolTable *Symtab,
                      ArrayRef<OutputSection *> OutputSections,
                      ArrayRef<uint8_t> SectionTable,
-                     const llvm::codeview::DebugInfo *DI) {
+                     const llvm::codeview::DebugInfo &BuildId) {
   PDBLinker PDB(Symtab);
-  PDB.initialize(DI);
+  PDB.initialize(BuildId);
   PDB.addObjectsToPDB();
   PDB.addSections(OutputSections, SectionTable);
   PDB.commit();
 }
 
-void PDBLinker::initialize(const llvm::codeview::DebugInfo *DI) {
+void PDBLinker::initialize(const llvm::codeview::DebugInfo &BuildId) {
   ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
 
   // Create streams in MSF for predefined streams, namely
   // PDB, TPI, DBI and IPI.
   for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 
   // Add an Info stream.
   auto &InfoBuilder = Builder.getInfoBuilder();
-  InfoBuilder.setAge(DI ? DI->PDB70.Age : 0);
+  InfoBuilder.setAge(BuildId.PDB70.Age);
 
-  GUID uuid{};
-  if (DI)
-    memcpy(&uuid, &DI->PDB70.Signature, sizeof(uuid));
+  GUID uuid;
+  memcpy(&uuid, &BuildId.PDB70.Signature, sizeof(uuid));
   InfoBuilder.setGuid(uuid);
   InfoBuilder.setSignature(time(nullptr));
   InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
 
   // Add an empty DBI stream.
   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
+  DbiBuilder.setAge(BuildId.PDB70.Age);
   DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
   ExitOnErr(DbiBuilder.addDbgStream(pdb::DbgHeaderType::NewFPO, {}));
 }
 
 void PDBLinker::addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
                                   OutputSection *OS, Chunk *C) {
   pdb::SectionContrib SC;
   memset(&SC, 0, sizeof(SC));

lld/trunk/COFF/Writer.cpp

 #include "MapFile.h"
 #include "Memory.h"
 #include "PDB.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdio>
public:
 
   size_t getSize() const override {
     return sizeof(codeview::DebugInfo) + PDBAbsPath.size() + 1;
   }
 
   void writeTo(uint8_t *B) const override {
     // Save off the DebugInfo entry to backfill the file signature (build id)
     // in Writer::writeBuildId
-    DI = reinterpret_cast<codeview::DebugInfo *>(B + OutputSectionOff);
-
-    DI->Signature.CVSignature = OMF::Signature::PDB70;
+    BuildId = reinterpret_cast<codeview::DebugInfo *>(B + OutputSectionOff);
 
     // variable sized field (PDB Path)
-    auto *P = reinterpret_cast<char *>(B + OutputSectionOff + sizeof(*DI));
+    char *P = reinterpret_cast<char *>(B + OutputSectionOff + sizeof(*BuildId));
     if (!PDBAbsPath.empty())
       memcpy(P, PDBAbsPath.data(), PDBAbsPath.size());
     P[PDBAbsPath.size()] = '\0';
   }
 
   SmallString<128> PDBAbsPath;
-  mutable codeview::DebugInfo *DI = nullptr;
+  mutable codeview::DebugInfo *BuildId = nullptr;
 };
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
   Writer(SymbolTable *T) : Symtab(T) {}
   void run();
 
 private:
   void createSections();
   void createMiscChunks();
   void createImportTables();
   void createExportTable();
   void assignAddresses();
   void removeEmptySections();
   void createSymbolAndStringTable();
   void openFile(StringRef OutputPath);
   template <typename PEHeaderTy> void writeHeader();
   void fixSafeSEHSymbols();
   void setSectionPermissions();
   void writeSections();
-  void sortExceptionTable();
   void writeBuildId();
+  void sortExceptionTable();
 
   llvm::Optional<coff_symbol16> createSymbol(Defined *D);
   size_t addEntryToStringTable(StringRef Str);
 
   OutputSection *findSection(StringRef Name);
   OutputSection *createSection(StringRef Name);
   void addBaserels(OutputSection *Dest);
   void addBaserelBlocks(OutputSection *Dest, std::vector<Baserel> &V);
private:
   IdataContents Idata;
   DelayLoadContents DelayIdata;
   EdataContents Edata;
   SEHTableChunk *SEHTable = nullptr;
 
   Chunk *DebugDirectory = nullptr;
   std::vector<Chunk *> DebugRecords;
   CVDebugRecordChunk *BuildId = nullptr;
+  Optional<codeview::DebugInfo> PreviousBuildId;
   ArrayRef<uint8_t> SectionTable;
 
   uint64_t FileSize;
   uint32_t PointerToSymbolTable = 0;
   uint64_t SizeOfImage;
   uint64_t SizeOfHeaders;
 };
 } // anonymous namespace
if (StringTableOff) {
     strncpy(Hdr->Name, Name.data(),
             std::min(Name.size(), (size_t)COFF::NameSize));
   }
 }
 
 } // namespace coff
 } // namespace lld
 
+// PDBs are matched against executables using a build id which consists of three
+// components:
+//   1. A 16-bit GUID
+//   2. An age
+//   3. A time stamp.
+//
+// Debuggers and symbol servers match executables against debug info by checking
+// each of these components of the EXE/DLL against the corresponding value in
+// the PDB and failing a match if any of the components differ.  In the case of
+// symbol servers, symbols are cached in a folder that is a function of the
+// GUID.  As a result, in order to avoid symbol cache pollution where every
+// incremental build copies a new PDB to the symbol cache, we must try to re-use
+// the existing GUID if one exists, but bump the age.  This way the match will
+// fail, so the symbol cache knows to use the new PDB, but the GUID matches, so
+// it overwrites the existing item in the symbol cache rather than making a new
+// one.
+static Optional<codeview::DebugInfo> loadExistingBuildId(StringRef Path) {
+  // We don't need to incrementally update a previous build id if we're not
+  // writing codeview debug info.
+  if (!Config->Debug)
+    return None;
+
+  auto ExpectedBinary = llvm::object::createBinary(Path);
+  if (!ExpectedBinary) {
+    consumeError(ExpectedBinary.takeError());
+    return None;
+  }
+
+  auto Binary = std::move(*ExpectedBinary);
+  if (!Binary.getBinary()->isCOFF())
+    return None;
+
+  std::error_code EC;
+  COFFObjectFile File(Binary.getBinary()->getMemoryBufferRef(), EC);
+  if (EC)
+    return None;
+
+  // If the machine of the binary we're outputting doesn't match the machine
+  // of the existing binary, don't try to re-use the build id.
+  if (File.is64() != Config->is64() || File.getMachine() != Config->Machine)
+    return None;
+
+  for (const auto &DebugDir : File.debug_directories()) {
+    if (DebugDir.Type != IMAGE_DEBUG_TYPE_CODEVIEW)
+      continue;
+
+    const codeview::DebugInfo *ExistingDI = nullptr;
+    StringRef PDBFileName;
+    if (auto EC = File.getDebugPDBInfo(ExistingDI, PDBFileName))
+      return None;
+    // We only support writing PDBs in v70 format.  So if this is not a build
+    // id that we recognize / support, ignore it.
+    if (ExistingDI->Signature.CVSignature != OMF::Signature::PDB70)
+      return None;
+    return *ExistingDI;
+  }
+  return None;
+}
+
 // The main function of the writer.
 void Writer::run() {
   createSections();
   createMiscChunks();
   createImportTables();
   createExportTable();
   if (Config->Relocatable)
     createSection(".reloc");
   assignAddresses();
   removeEmptySections();
   setSectionPermissions();
   createSymbolAndStringTable();
+
+  // We must do this before opening the output file, as it depends on being able
+  // to read the contents of the existing output file.
+  PreviousBuildId = loadExistingBuildId(Config->OutputFile);
   openFile(Config->OutputFile);
   if (Config->is64()) {
     writeHeader<pe32plus_header>();
   } else {
     writeHeader<pe32_header>();
   }
   fixSafeSEHSymbols();
   writeSections();
   sortExceptionTable();
   writeBuildId();
 
   if (!Config->PDBPath.empty() && Config->Debug) {
-    const llvm::codeview::DebugInfo *DI = nullptr;
-    if (Config->DebugTypes & static_cast<unsigned>(coff::DebugType::CV))
-      DI = BuildId->DI;
-    createPDB(Symtab, OutputSections, SectionTable, DI);
+
+    assert(BuildId);
+    createPDB(Symtab, OutputSections, SectionTable, *BuildId->BuildId);
   }
 
   writeMapFile(OutputSections);
 
   if (auto EC = Buffer->commit())
     fatal(EC, "failed to write the output file");
 }
 
if (!Symtab->LocalImportChunks.empty()) {
     for (Chunk *C : Symtab->LocalImportChunks)
       RData->addChunk(C);
   }
 
   // Create Debug Information Chunks
   if (Config->Debug) {
     DebugDirectory = make<DebugDirectoryChunk>(DebugRecords);
 
-    // TODO(compnerd) create a coffgrp entry if DebugType::CV is not enabled
-    if (Config->DebugTypes & static_cast<unsigned>(coff::DebugType::CV)) {
-      auto *Chunk = make<CVDebugRecordChunk>();
-
-      BuildId = Chunk;
-      DebugRecords.push_back(Chunk);
-    }
+    // Make a CVDebugRecordChunk even when /DEBUG:CV is not specified.  We
+    // output a PDB no matter what, and this chunk provides the only means of
+    // allowing a debugger to match a PDB and an executable.  So we need it even
+    // if we're ultimately not going to write CodeView data to the PDB.
+    auto *CVChunk = make<CVDebugRecordChunk>();
+    BuildId = CVChunk;
+    DebugRecords.push_back(CVChunk);
 
     RData->addChunk(DebugDirectory);
     for (Chunk *C : DebugRecords)
       RData->addChunk(C);
   }
 
   // Create SEH table. x86-only.
   if (Config->Machine != I386)
for (OutputSection *Sec : OutputSections) {
     // ADD instructions).
     if (Sec->getPermissions() & IMAGE_SCN_CNT_CODE)
       memset(SecBuf, 0xCC, Sec->getRawSize());
     for_each(parallel::par, Sec->getChunks().begin(), Sec->getChunks().end(),
              [&](Chunk *C) { C->writeTo(SecBuf); });
   }
 }
 
+void Writer::writeBuildId() {
+  // If we're not writing a build id (e.g. because /debug is not specified),
+  // then just return;
+  if (!Config->Debug)
+    return;
+
+  assert(BuildId && "BuildId is not set!");
+
+  if (PreviousBuildId.hasValue()) {
+    *BuildId->BuildId = *PreviousBuildId;
+    BuildId->BuildId->PDB70.Age = BuildId->BuildId->PDB70.Age + 1;
+    return;
+  }
+
+  BuildId->BuildId->Signature.CVSignature = OMF::Signature::PDB70;
+  BuildId->BuildId->PDB70.Age = 1;
+  llvm::getRandomBytes(BuildId->BuildId->PDB70.Signature, 16);
+}
+
 // Sort .pdata section contents according to PE/COFF spec 5.5.
 void Writer::sortExceptionTable() {
   OutputSection *Sec = findSection(".pdata");
   if (!Sec)
     return;
   // We assume .pdata contains function table entries only.
   uint8_t *Begin = Buffer->getBufferStart() + Sec->getFileOff();
   uint8_t *End = Begin + Sec->getVirtualSize();
   if (Config->Machine == AMD64) {
     struct Entry { ulittle32_t Begin, End, Unwind; };
     sort(parallel::par, (Entry *)Begin, (Entry *)End,
          [](const Entry &A, const Entry &B) { return A.Begin < B.Begin; });
     return;
   }
   if (Config->Machine == ARMNT) {
     struct Entry { ulittle32_t Begin, Unwind; };
     sort(parallel::par, (Entry *)Begin, (Entry *)End,
          [](const Entry &A, const Entry &B) { return A.Begin < B.Begin; });
     return;
   }
   errs() << "warning: don't know how to handle .pdata.\n";
 }
 
-// Backfill the CVSignature in a PDB70 Debug Record.  This backfilling allows us
-// to get reproducible builds.
-void Writer::writeBuildId() {
-  // There is nothing to backfill if BuildId was not setup.
-  if (BuildId == nullptr)
-    return;
-
-  assert(BuildId->DI->Signature.CVSignature == OMF::Signature::PDB70 &&
-         "only PDB 7.0 is supported");
-  assert(sizeof(BuildId->DI->PDB70.Signature) == 16 &&
-         "signature size mismatch");
-
-  // Compute an MD5 hash.
-  ArrayRef<uint8_t> Buf(Buffer->getBufferStart(), Buffer->getBufferEnd());
-  memcpy(BuildId->DI->PDB70.Signature, MD5::hash(Buf).data(), 16);
-
-  // TODO(compnerd) track the Age
-  BuildId->DI->PDB70.Age = 1;
-}
-
 OutputSection *Writer::findSection(StringRef Name) {
   for (OutputSection *Sec : OutputSections)
     if (Sec->getName() == Name)
       return Sec;
   return nullptr;
 }
 
 uint32_t Writer::getSizeOfInitializedData() {

lld/trunk/test/COFF/pdb-diff.test

 This test verifies that we produce PDBs compatible with MSVC in various ways.
 We check in a cl-generated object file, PDB, and original source which serve
 as the "baseline" for us to measure against.  Then we link the same object
 file with LLD and compare the two PDBs.  Since the baseline object file and
 PDB are already checked in, we just run LLD on the object file.
 
-RUN: lld-link /debug /pdb:%T/pdb-diff-lld.pdb /nodefaultlib /entry:main %S/Inputs/pdb-diff.obj
-RUN: llvm-pdbutil diff -result -values=false -left-bin-root=%S -right-bin-root=D:/src/llvm-mono/lld/test/COFF/ %T/pdb-diff-lld.pdb %S/Inputs/pdb-diff-cl.pdb | FileCheck %s
+RUN: rm -f %T/pdb-diff-lld.pdb %T/pdb-diff-lld.exe
+RUN: lld-link /debug /pdb:%T/pdb-diff-lld.pdb /out:%T/pdb-diff-lld.exe /nodefaultlib \
+RUN:   /entry:main %S/Inputs/pdb-diff.obj
+RUN: llvm-pdbutil diff -result -values=false -left-bin-root=%S -right-bin-root=D:/src/llvm-mono/lld/test/COFF/ \
+RUN:   %T/pdb-diff-lld.pdb %S/Inputs/pdb-diff-cl.pdb | FileCheck %s
 
 CHECK:        ----------------------
 CHECK-NEXT:   |  MSF Super Block   |
 CHECK-NEXT:   |----------------+---|
 CHECK-NEXT:   |           File |   |
 CHECK-NEXT:   |----------------+---|
 CHECK-NEXT:   |     Block Size | I |
 CHECK-NEXT:   |----------------+---|

lld/trunk/test/COFF/pdb-none.test

 # RUN: yaml2obj < %p/Inputs/pdb1.yaml > %t1.obj
 # RUN: yaml2obj < %p/Inputs/pdb2.yaml > %t2.obj
+# RUN: rm -f %t.pdb %t.dll
 # RUN: lld-link /debug /debugtype:pdata /pdb:%t.pdb /dll /out:%t.dll /entry:main /nodefaultlib \
 # RUN:   %t1.obj %t2.obj
 
 # RUN: llvm-pdbutil pdb2yaml -pdb-stream %t.pdb | FileCheck %s
 
 # CHECK:      PdbStream:
-# CHECK-NEXT:   Age:             0
+# CHECK-NEXT:   Age:             1
 # CHECK-NEXT:   Guid:
 # CHECK-NEXT:   Signature:
 # CHECK-NEXT:   Features:        [ VC140 ]
 # CHECK-NEXT:   Version:         VC70
 

lld/trunk/test/COFF/pdb-source-lines.test

 ==> pdb_lines_2.c <==
 void bar(void) {
 }
 
 $ cl -c -Z7 pdb_lines*.c
 
 RUN: yaml2obj %S/Inputs/pdb_lines_1.yaml -o %t.pdb_lines_1.obj
 RUN: yaml2obj %S/Inputs/pdb_lines_2.yaml -o %t.pdb_lines_2.obj
+RUN: rm -f %t.exe %t.pdb
 RUN: lld-link -debug -entry:main -nodefaultlib -out:%t.exe -pdb:%t.pdb %t.pdb_lines_1.obj %t.pdb_lines_2.obj
 RUN: llvm-pdbutil pdb2yaml -modules -module-files -subsections=lines,fc %t.pdb | FileCheck %s
 
-CHECK-LABEL: DbiStream:       
+CHECK-LABEL: DbiStream:
 CHECK-NEXT:   VerHeader:       V70
 CHECK-NEXT:   Age:             1
 CHECK-NEXT:   BuildNumber:     0
 CHECK-NEXT:   PdbDllVersion:   0
 CHECK-NEXT:   PdbDllRbld:      0
 CHECK-NEXT:   Flags:           0
 CHECK-NEXT:   MachineType:     x86
-CHECK-NEXT:   Modules:         
+CHECK-NEXT:   Modules:
 
 CHECK-LABEL:    - Module:          {{.*}}pdb_lines_1.obj
 CHECK-NEXT:       ObjFile:         {{.*}}pdb_lines_1.obj
-CHECK-NEXT:       SourceFiles:     
+CHECK-NEXT:       SourceFiles:
 CHECK-NEXT:         - '{{.*}}pdb_lines_1.c'
 CHECK-NEXT:         - '{{.*}}foo.h'
-CHECK-NEXT:       Subsections:     
+CHECK-NEXT:       Subsections:
 CHECK-NEXT:         - !Lines
 CHECK-NEXT:           CodeSize:        19
 CHECK-NEXT:           Flags:           [  ]
 CHECK-NEXT:           RelocOffset:     0
 CHECK-NEXT:           RelocSegment:    2
-CHECK-NEXT:           Blocks:          
+CHECK-NEXT:           Blocks:
 CHECK-NEXT:             - FileName:        '{{.*}}pdb_lines_1.c'
-CHECK-NEXT:               Lines:           
+CHECK-NEXT:               Lines:
 CHECK-NEXT:                 - Offset:          0
 CHECK-NEXT:                   LineStart:       2
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
 CHECK-NEXT:                 - Offset:          4
 CHECK-NEXT:                   LineStart:       3
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
 CHECK-NEXT:                 - Offset:          9
 CHECK-NEXT:                   LineStart:       4
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
 CHECK-NEXT:                 - Offset:          14
 CHECK-NEXT:                   LineStart:       5
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
-CHECK-NEXT:               Columns:         
+CHECK-NEXT:               Columns:
 CHECK-NEXT:         - !FileChecksums
-CHECK-NEXT:           Checksums:       
+CHECK-NEXT:           Checksums:
 CHECK-NEXT:             - FileName:        '{{.*}}pdb_lines_1.c'
 CHECK-NEXT:               Kind:            MD5
 CHECK-NEXT:               Checksum:        4EB19DCD86C3BA2238A255C718572E7B
 CHECK-NEXT:             - FileName:        '{{.*}}foo.h'
 CHECK-NEXT:               Kind:            MD5
 CHECK-NEXT:               Checksum:        061EB73ABB642532857A4F1D9CBAC323
 CHECK-NEXT:         - !Lines
 CHECK-NEXT:           CodeSize:        14
 CHECK-NEXT:           Flags:           [  ]
 CHECK-NEXT:           RelocOffset:     32
 CHECK-NEXT:           RelocSegment:    2
-CHECK-NEXT:           Blocks:          
+CHECK-NEXT:           Blocks:
 CHECK-NEXT:             - FileName:        '{{.*}}foo.h'
-CHECK-NEXT:               Lines:           
+CHECK-NEXT:               Lines:
 CHECK-NEXT:                 - Offset:          0
 CHECK-NEXT:                   LineStart:       2
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
 CHECK-NEXT:                 - Offset:          4
 CHECK-NEXT:                   LineStart:       3
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
 CHECK-NEXT:                 - Offset:          9
 CHECK-NEXT:                   LineStart:       4
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
-CHECK-NEXT:               Columns:         
+CHECK-NEXT:               Columns:
 
 CHECK-LABEL:    - Module:          {{.*}}pdb_lines_2.obj
 CHECK-NEXT:       ObjFile:         {{.*}}pdb_lines_2.obj
-CHECK-NEXT:       SourceFiles:     
+CHECK-NEXT:       SourceFiles:
 CHECK-NEXT:         - '{{.*}}pdb_lines_2.c'
-CHECK-NEXT:       Subsections:     
+CHECK-NEXT:       Subsections:
 CHECK-NEXT:         - !Lines
 CHECK-NEXT:           CodeSize:        1
 CHECK-NEXT:           Flags:           [  ]
 CHECK-NEXT:           RelocOffset:     48
 CHECK-NEXT:           RelocSegment:    2
-CHECK-NEXT:           Blocks:          
+CHECK-NEXT:           Blocks:
 CHECK-NEXT:             - FileName:        '{{.*}}pdb_lines_2.c'
-CHECK-NEXT:               Lines:           
+CHECK-NEXT:               Lines:
 CHECK-NEXT:                 - Offset:          0
 CHECK-NEXT:                   LineStart:       1
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
 CHECK-NEXT:                 - Offset:          0
 CHECK-NEXT:                   LineStart:       2
 CHECK-NEXT:                   IsStatement:     true
 CHECK-NEXT:                   EndDelta:        0
-CHECK-NEXT:               Columns:         
+CHECK-NEXT:               Columns:
 CHECK-NEXT:         - !FileChecksums
-CHECK-NEXT:           Checksums:       
+CHECK-NEXT:           Checksums:
 CHECK-NEXT:             - FileName:        '{{.*}}pdb_lines_2.c'
 CHECK-NEXT:               Kind:            MD5
 CHECK-NEXT:               Checksum:        DF91CB3A2B8D917486574BB50CAC4CC7
 CHECK-NEXT:     - Module:          '* Linker *'
 CHECK-NEXT:       ObjFile:         ''

lld/trunk/test/COFF/pdb.test

 # RUN: yaml2obj < %p/Inputs/pdb1.yaml > %t1.obj
 # RUN: yaml2obj < %p/Inputs/pdb2.yaml > %t2.obj
+# RUN: rm -f %t.dll %t.pdb
 # RUN: lld-link /debug /pdb:%t.pdb /dll /out:%t.dll /entry:main /nodefaultlib \
 # RUN:   %t1.obj %t2.obj
 
 # RUN: llvm-pdbutil pdb2yaml -stream-metadata -stream-directory -pdb-stream \
 # RUN:   -dbi-stream -ipi-stream -tpi-stream %t.pdb | FileCheck %s
 
 # RUN: llvm-pdbutil dump -modules -section-map -section-contribs -section-headers \
 # RUN:   -publics -public-extras -types -ids -type-extras -id-extras %t.pdb \

lld/trunk/test/COFF/rsds.test

 # RUN: yaml2obj %s > %t.obj
 
+# RUN: rm -f %t.dll %t.pdb
 # RUN: lld-link /debug /dll /out:%t.dll /entry:DllMain %t.obj
-# RUN: llvm-readobj -coff-debug-directory %t.dll | FileCheck %s
+# RUN: llvm-readobj -coff-debug-directory %t.dll > %t.1.txt
+# RUN: lld-link /debug /dll /out:%t.dll /entry:DllMain %t.obj
+# RUN: llvm-readobj -coff-debug-directory %t.dll > %t.2.txt
+# RUN: cat %t.1.txt %t.2.txt | FileCheck %s
 
+# RUN: rm -f %t.dll %t.pdb
+# RUN: lld-link /debug /pdb:%t.pdb /dll /out:%t.dll /entry:DllMain %t.obj
+# RUN: llvm-readobj -coff-debug-directory %t.dll > %t.3.txt
 # RUN: lld-link /debug /pdb:%t.pdb /dll /out:%t.dll /entry:DllMain %t.obj
-# RUN: llvm-readobj -coff-debug-directory %t.dll | FileCheck %s
+# RUN: llvm-readobj -coff-debug-directory %t.dll > %t.4.txt
+# RUN: cat %t.3.txt %t.4.txt | FileCheck %s
 
+# CHECK: File: [[FILE:.*]].dll
 # CHECK: DebugDirectory [
 # CHECK:   DebugEntry {
 # CHECK:     Characteristics: 0x0
 # CHECK:     TimeDateStamp: 1970-01-01 00:00:00 (0x0)
 # CHECK:     MajorVersion: 0x0
 # CHECK:     MinorVersion: 0x0
 # CHECK:     Type: CodeView (0x2)
 # CHECK:     SizeOfData: 0x{{[^0]}}
 # CHECK:     AddressOfRawData: 0x{{[^0]}}
 # CHECK:     PointerToRawData: 0x{{[^0]}}
 # CHECK:     PDBInfo {
 # CHECK:       PDBSignature: 0x53445352
-# CHECK:       PDBGUID:
+# CHECK:       PDBGUID: [[GUID:\(([A-Za-z0-9]{2} ?){16}\)]]
 # CHECK:       PDBAge: 1
 # CHECK:       PDBFileName: {{.*}}.pdb
 # CHECK:     }
 # CHECK:   }
 # CHECK: ]
+# CHECK: File: [[FILE]].dll
+# CHECK: DebugDirectory [
+# CHECK:   DebugEntry {
+# CHECK:     Characteristics: 0x0
+# CHECK:     TimeDateStamp: 1970-01-01 00:00:00 (0x0)
+# CHECK:     MajorVersion: 0x0
+# CHECK:     MinorVersion: 0x0
+# CHECK:     Type: CodeView (0x2)
+# CHECK:     SizeOfData: 0x{{[^0]}}
+# CHECK:     AddressOfRawData: 0x{{[^0]}}
+# CHECK:     PointerToRawData: 0x{{[^0]}}
+# CHECK:     PDBInfo {
+# CHECK:       PDBSignature: 0x53445352
+# CHECK:       PDBGUID: [[GUID]]
+# CHECK:       PDBAge: 2
+# CHECK:       PDBFileName: {{.*}}.pdb
+# CHECK:     }
+# CHECK:   }
+# CHECK: ]
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_I386
   Characteristics: [  ]
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]