[coff] Add command line flags /PDBAGE and /PDBGUID

[zturner]

Summary

MSVC doesn't implement these, but these should be generally useful options for people trying to support reproducible builds.

The need for these arose when I was trying to write a test for the reproducibility of the hash (D43978), because it hashes the guid and that is currently non-deterministic. So in order to write a deterministic test I need a way to specify the GUID. That said, I think people can find a use for this outside of tests as well.

[zturner]

It was suggested offline that I implement something in llvm-pdbutil that can update a GUID / age of an arbitrary PE / PDB after the fact, and remove this from the linker. So I will do that instead.

lld/COFF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_CONFIG_H
 #define LLD_COFF_CONFIG_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/CodeView/GUID.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/CachePruning.h"
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 
 namespace lld {
struct Configuration {
   bool DoICF = true;
   bool Relocatable = true;
   bool Force = false;
   bool Debug = false;
   bool DebugDwarf = false;
   bool DebugGHashes = false;
   bool ShowTiming = false;
   unsigned DebugTypes = static_cast<unsigned>(DebugType::None);
+  llvm::Optional<uint32_t> PDBAge;
+  llvm::Optional<llvm::codeview::GUID> PDBGuid;
   llvm::SmallString<128> PDBPath;
   std::vector<llvm::StringRef> Argv;
 
   // Symbols in this set are considered as live by the garbage collector.
   std::vector<Symbol *> GCRoot;
 
   std::set<StringRef> NoDefaultLibs;
   bool NoDefaultLibAll = false;

lld/COFF/Driver.cpp

if (Args.hasArg(OPT_debug, OPT_debug_dwarf, OPT_debug_ghash)) {
     if (auto *Arg = Args.getLastArg(OPT_debugtype))
       Config->DebugTypes = parseDebugType(Arg->getValue());
     else
       Config->DebugTypes = getDefaultDebugType(Args);
   }
 
   // Handle /pdb
   bool ShouldCreatePDB = Args.hasArg(OPT_debug, OPT_debug_ghash);
-  if (ShouldCreatePDB)
+  if (ShouldCreatePDB) {
     if (auto *Arg = Args.getLastArg(OPT_pdb))
       Config->PDBPath = Arg->getValue();
+    if (auto *Arg = Args.getLastArg(OPT_pdbguid)) {
+      Expected<codeview::GUID> ExpectedGuid =
+          codeview::guidFromText(Arg->getValue());
+      if (!ExpectedGuid) {
+        consumeError(ExpectedGuid.takeError());
+        error(Twine("/pdbguid: ") + Arg->getValue() + " is not a valid guid");
+      }
+      Config->PDBGuid = *ExpectedGuid;
+    }
+    if (auto *Arg = Args.getLastArg(OPT_pdbage)) {
+      Config->PDBAge.emplace();
+      StringRef(Arg->getValue()).getAsInteger(10, *Config->PDBAge);
+    }
+  }
 
   // Handle /noentry
   if (Args.hasArg(OPT_noentry)) {
     if (Args.hasArg(OPT_dll))
       Config->NoEntry = true;
     else
       error("/noentry must be specified with /dll");
   }

lld/COFF/Options.td

 def machine : P<"machine", "Specify target platform">;
 def merge   : P<"merge", "Combine sections">;
 def mllvm   : P<"mllvm", "Options to pass to LLVM">;
 def nodefaultlib : P<"nodefaultlib", "Remove a default library">;
 def opt     : P<"opt", "Control optimizations">;
 def order   : P<"order", "Put functions in order">;
 def out     : P<"out", "Path to file to write output">;
 def pdb : P<"pdb", "PDB file path">;
+def pdbage : P<"pdbage", "Specify age of PDB file">;
+def pdbguid : P<"pdbguid", "GUID used to identify PDB file">;
 def section : P<"section", "Specify section attributes">;
 def stack   : P<"stack", "Size of the stack">;
 def stub    : P<"stub", "Specify DOS stub file">;
 def subsystem : P<"subsystem", "Specify subsystem">;
 def version : P<"version", "Specify a version number in the PE header">;
 def wholearchive_file : P<"wholearchive", "Include all object files from this archive">;
 
 def disallowlib : Joined<["/", "-", "-?"], "disallowlib:">, Alias<nodefaultlib>;

lld/COFF/Writer.cpp

 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!");
 
+  // Use the previous build id from the existing binary, but override the values
+  // of guid and age if requested from the command line.
   if (PreviousBuildId.hasValue()) {
     *BuildId->BuildId = *PreviousBuildId;
-    BuildId->BuildId->PDB70.Age = BuildId->BuildId->PDB70.Age + 1;
-    return;
-  }
-
+    BuildId->BuildId->PDB70.Age += 1;
+  } else {
     BuildId->BuildId->Signature.CVSignature = OMF::Signature::PDB70;
     BuildId->BuildId->PDB70.Age = 1;
+  }
+
+  if (Config->PDBGuid.hasValue()) {
+    static_assert(sizeof(BuildId->BuildId->PDB70.Signature) ==
+                      sizeof(Config->PDBGuid->Guid),
+                  "Guid size mismatch.");
+    ::memcpy(BuildId->BuildId->PDB70.Signature, Config->PDBGuid->Guid,
+             sizeof(Config->PDBGuid->Guid));
+  } else if (!PreviousBuildId.hasValue()) {
     llvm::getRandomBytes(BuildId->BuildId->PDB70.Signature, 16);
   }
 
+  if (Config->PDBAge.hasValue())
+    BuildId->BuildId->PDB70.Age = Config->PDBAge.getValue();
+}
+
 // 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();

llvm/include/llvm/DebugInfo/CodeView/GUID.h

 //===- GUID.h ---------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_GUID_H
 #define LLVM_DEBUGINFO_CODEVIEW_GUID_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+
 #include <cstdint>
 #include <cstring>
 
 namespace llvm {
 class raw_ostream;
 
 namespace codeview {
 

 }
 
 inline bool operator!=(const GUID &LHS, const GUID &RHS) {
   return !(LHS == RHS);
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const GUID &Guid);
 
+Expected<GUID> guidFromText(StringRef S);
+std::string textFromGuid(const GUID &Guid);
+std::string textFromGuid(StringRef Guid);
+std::string textFromGuid(ArrayRef<uint8_t> Guid);
+void textFromGuid(StringRef Guid, llvm::raw_ostream &OS);
+void textFromGuid(ArrayRef<uint8_t> Guid, llvm::raw_ostream &OS);
+
 } // namespace codeview
 } // namespace llvm
 
 #endif

llvm/lib/DebugInfo/CodeView/CMakeLists.txt

add_llvm_library(LLVMDebugInfoCodeView
   DebugSubsection.cpp
   DebugSubsectionRecord.cpp
   DebugSubsectionVisitor.cpp
   DebugSymbolRVASubsection.cpp
   DebugSymbolsSubsection.cpp
   EnumTables.cpp
   Formatters.cpp
   GlobalTypeTableBuilder.cpp
+  GUID.cpp
   LazyRandomTypeCollection.cpp
   Line.cpp
   MergingTypeTableBuilder.cpp
   RecordName.cpp
   RecordSerialization.cpp
   SimpleTypeSerializer.cpp
   StringsAndChecksums.cpp
   SymbolRecordMapping.cpp

llvm/lib/DebugInfo/CodeView/Formatters.cpp

 //===- Formatters.cpp -----------------------------------------------------===//
 //
 //                     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/Formatters.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/DebugInfo/CodeView/GUID.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::codeview::detail;
 
 GuidAdapter::GuidAdapter(StringRef Guid)
     : FormatAdapter(makeArrayRef(Guid.bytes_begin(), Guid.bytes_end())) {}
 
 GuidAdapter::GuidAdapter(ArrayRef<uint8_t> Guid)
     : FormatAdapter(std::move(Guid)) {}
 
 void GuidAdapter::format(raw_ostream &Stream, StringRef Style) {
-  static const char *Lookup = "0123456789ABCDEF";
-
-  assert(Item.size() == 16 && "Expected 16-byte GUID");
-  Stream << "{";
-  for (int i = 0; i < 16;) {
-    uint8_t Byte = Item[i];
-    uint8_t HighNibble = (Byte >> 4) & 0xF;
-    uint8_t LowNibble = Byte & 0xF;
-    Stream << Lookup[HighNibble] << Lookup[LowNibble];
-    ++i;
-    if (i >= 4 && i <= 10 && i % 2 == 0)
-      Stream << "-";
-  }
-  Stream << "}";
+  textFromGuid(toStringRef(Item), Stream);
 }
 
 raw_ostream &llvm::codeview::operator<<(raw_ostream &OS, const GUID &Guid) {
   codeview::detail::GuidAdapter A(Guid.Guid);
   A.format(OS, "");
   return OS;
 }

llvm/lib/DebugInfo/CodeView/GUID.cpp

+//===- GUID.cpp -----------------------------------------------------------===//
+//
+//                     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/GUID.h"
+#include "llvm/Support/Error.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+Expected<GUID> llvm::codeview::guidFromText(StringRef GuidStr) {
+  // We recognize the following two forms of Guid specification.
+  //   {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+  //    XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+  // where X is a hex digit (in upper or lowercase).
+  if (GuidStr.size() != 36 && GuidStr.size() != 38)
+    return make_error<StringError>("Invalid Guid string!",
+                                   inconvertibleErrorCode());
+
+  if (GuidStr.size() == 38) {
+    // Strip { and } from the beginning and end.
+    if (GuidStr.front() != '{' || GuidStr.back() != '}')
+      return make_error<StringError>("Invalid Guid string!",
+                                     inconvertibleErrorCode());
+    GuidStr = GuidStr.drop_front().drop_back();
+  }
+
+  assert(GuidStr.size() == 36);
+  SmallVector<StringRef, 4> Groups;
+  GuidStr.split(Groups, '-');
+  if (Groups.size() != 5 || Groups[0].size() != 8 || Groups[1].size() != 4 ||
+      Groups[2].size() != 4 || Groups[3].size() != 4 || Groups[4].size() != 12)
+    return make_error<StringError>("Invalid Guid string!",
+                                   inconvertibleErrorCode());
+  GUID Result;
+  uint8_t *WritePtr = Result.Guid;
+  for (StringRef G : Groups) {
+    while (!G.empty()) {
+      if (!isHexDigit(G[0]) || !isHexDigit(G[1]))
+        return make_error<StringError>("Invalid Guid string!",
+                                       inconvertibleErrorCode());
+
+      *WritePtr = hexFromNibbles(G[0], G[1]);
+      G = G.drop_front(2);
+      ++WritePtr;
+    }
+  }
+  return Result;
+}
+
+std::string llvm::codeview::textFromGuid(const GUID &Guid) {
+  return textFromGuid(makeArrayRef(Guid.Guid));
+}
+
+std::string llvm::codeview::textFromGuid(StringRef Guid) {
+  return textFromGuid(arrayRefFromStringRef(Guid));
+}
+
+std::string llvm::codeview::textFromGuid(ArrayRef<uint8_t> Guid) {
+  std::string Result;
+  llvm::raw_string_ostream OS(Result);
+  textFromGuid(Guid, OS);
+  OS.flush();
+  return Result;
+}
+
+void llvm::codeview::textFromGuid(ArrayRef<uint8_t> Guid,
+                                  llvm::raw_ostream &OS) {
+  static const char *Lookup = "0123456789ABCDEF";
+
+  assert(Guid.size() == 16 && "Expected 16-byte GUID");
+  OS << "{";
+  for (int i = 0; i < 16;) {
+    uint8_t Byte = Guid[i];
+    uint8_t HighNibble = (Byte >> 4) & 0xF;
+    uint8_t LowNibble = Byte & 0xF;
+    OS << Lookup[HighNibble] << Lookup[LowNibble];
+    ++i;
+    if (i >= 4 && i <= 10 && i % 2 == 0)
+      OS << "-";
+  }
+  OS << "}";
+}
+
+void llvm::codeview::textFromGuid(StringRef Guid, llvm::raw_ostream &OS) {
+  textFromGuid(arrayRefFromStringRef(Guid), OS);
+}