[codeview] Fix YAML for LF_TYPESERVER2 by hoisting PDB_UniqueId

[rnk]

Summary

We were treating the GUIDs in TypeServer2Record as strings, and the
non-ASCII bytes in the GUID would not round-trip through YAML.

We already had the PDB_UniqueId type portably represent a Windows GUID,
but we need to hoist that up to the DebugInfo/CodeView library so that
we can use it in the TypeServer2Record as well as in PDB parsing code.

[rnk]

• rebase on type server removal

[ruiu]

lld/COFF/PDB.cpp

518

Is WindowsGuid an appropriate name for this data strucutre? This is just a GUID and not really an Windows-variant.

[rnk]

lld/COFF/PDB.cpp

518

This was an attempt to distinguish it from llvm::GlobalValue::GUID, which is a 64-bit integer, but sure, we can call it GUID.

[rnk]

• Rename WindowsGuid to GUID

[ruiu]

How about UUID, which seems to be used as a synonym to GUID? (https://en.wikipedia.org/wiki/Universally_unique_identifier)

[rnk]

In D35495#812153, @ruiu wrote:

How about UUID, which seems to be used as a synonym to GUID? (https://en.wikipedia.org/wiki/Universally_unique_identifier)

I think I prefer GUID to better match windows.h.

[ruiu]

LGTM

llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp

163–166

nit: you can use post-++ here

lld/COFF/PDB.cpp

void PDBLinker::initialize(const llvm::codeview::DebugInfo *DI) {
   // 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);
 
-  pdb::PDB_UniqueId uuid{};
+  WindowsGuid uuid{};
   if (DI)
     memcpy(&uuid, &DI->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();

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

Relocations:
         SymbolName:      main
         Type:            IMAGE_REL_AMD64_SECTION
   - Name:            '.debug$T'
     Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
     Alignment:       1
     Types:
       - Kind:            LF_TYPESERVER2
         TypeServer2:
-          Guid:            ' ?  "?kB??RX?2??' # FIXME: yaml-ize this as hex.
+          Guid:            '{01DF191B-22BF-6B42-96CE-5258B8329FE5}'
           Age:             18
           Name:            'C:\src\llvm-project\build\definitely_not_found_for_sure.pdb'
   - Name:            '.text$mn'
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
     Alignment:       16
     SectionData:     33C0C3
 symbols:
   - Name:            '.debug$S'

llvm/include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h

if (isReading())
       Value = static_cast<T>(X);
     return Error::success();
   }
 
   Error mapEncodedInteger(int64_t &Value);
   Error mapEncodedInteger(uint64_t &Value);
   Error mapEncodedInteger(APSInt &Value);
   Error mapStringZ(StringRef &Value);
-  Error mapGuid(StringRef &Guid);
+  Error mapGuid(WindowsGuid &Guid);
 
   Error mapStringZVectorZ(std::vector<StringRef> &Value);
 
   template <typename SizeType, typename T, typename ElementMapper>
   Error mapVectorN(T &Items, const ElementMapper &Mapper) {
     SizeType Size;
     if (isWriting()) {
       Size = static_cast<SizeType>(Items.size());

llvm/include/llvm/DebugInfo/CodeView/Formatters.h

 //===- Formatters.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_FORMATTERS_H
 #define LLVM_DEBUGINFO_CODEVIEW_FORMATTERS_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/WindowsGuid.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 namespace llvm {
 
 namespace codeview {
 
 namespace detail {
 
 class GuidAdapter final : public FormatAdapter<ArrayRef<uint8_t>> {
   ArrayRef<uint8_t> Guid;
 
 public:
   explicit GuidAdapter(ArrayRef<uint8_t> Guid);
   explicit GuidAdapter(StringRef Guid);
 
-  void format(raw_ostream &Stream, StringRef Style) override ;
+  void format(raw_ostream &Stream, StringRef Style) override;
 };
 
 } // end namespace detail
 
 inline detail::GuidAdapter fmt_guid(StringRef Item) {
   return detail::GuidAdapter(Item);
 }
 
static void format(const codeview::TypeIndex &V, raw_ostream &Stream,
     else {
       Stream << formatv("{0:X+4}", V.getIndex());
       if (V.isSimple())
         Stream << " (" << codeview::TypeIndex::simpleTypeName(V) << ")";
     }
   }
 };
 
+template <> struct format_provider<codeview::WindowsGuid> {
+  static void format(const codeview::WindowsGuid &V, llvm::raw_ostream &Stream,
+                     StringRef Style) {
+    Stream << V;
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_FORMATTERS_H

llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/WindowsGuid.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/Endian.h"
 #include <algorithm>
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace codeview {
public:
   std::vector<VFTableSlotKind> Slots;
 };
 
 // LF_TYPESERVER2
 class TypeServer2Record : public TypeRecord {
 public:
   TypeServer2Record() = default;
   explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}
-  TypeServer2Record(StringRef Guid, uint32_t Age, StringRef Name)
-      : TypeRecord(TypeRecordKind::TypeServer2), Guid(Guid), Age(Age),
-        Name(Name) {}
+  TypeServer2Record(StringRef GuidStr, uint32_t Age, StringRef Name)
+      : TypeRecord(TypeRecordKind::TypeServer2), Age(Age), Name(Name) {
+    assert(GuidStr.size() == 16 && "guid isn't 16 bytes");
+    ::memcpy(Guid.Guid, GuidStr.data(), 16);
+  }
 
-  StringRef getGuid() const { return Guid; }
+  const WindowsGuid &getGuid() const { return Guid; }
   uint32_t getAge() const { return Age; }
   StringRef getName() const { return Name; }
 
-  StringRef Guid;
+  WindowsGuid Guid;
   uint32_t Age;
   StringRef Name;
 };
 
 // LF_STRING_ID
 class StringIdRecord : public TypeRecord {
 public:
   StringIdRecord() = default;

llvm/include/llvm/DebugInfo/CodeView/WindowsGuid.h

+//===- WindowsGuid.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_WINDOWSGUID_H
+#define LLVM_DEBUGINFO_CODEVIEW_WINDOWSGUID_H
+
+namespace llvm {
+namespace codeview {
+
+/// This represents the 'GUID' type from windows.h.
+struct WindowsGuid {
+  uint8_t Guid[16];
+};
+
+inline bool operator==(const WindowsGuid &LHS, const WindowsGuid &RHS) {
+  return 0 == ::memcmp(LHS.Guid, RHS.Guid, sizeof(LHS.Guid));
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const WindowsGuid &Guid);
+
+} // namespace codeview
+} // namespace llvm
+
+#endif

llvm/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h

public:
   Variant getValue() const override;
   uint32_t getVirtualBaseDispIndex() const override;
   uint32_t getVirtualBaseOffset() const override;
   uint32_t getVirtualTableShapeId() const override;
   std::unique_ptr<PDBSymbolTypeBuiltin>
   getVirtualBaseTableType() const override;
   PDB_DataKind getDataKind() const override;
   PDB_SymType getSymTag() const override;
-  PDB_UniqueId getGuid() const override;
+  codeview::WindowsGuid getGuid() const override;
   int32_t getOffset() const override;
   int32_t getThisAdjust() const override;
   int32_t getVirtualBasePointerOffset() const override;
   PDB_LocType getLocationType() const override;
   PDB_Machine getMachineType() const override;
   codeview::ThunkOrdinal getThunkOrdinal() const override;
   uint64_t getLength() const override;
   uint64_t getLiveRangeLength() const override;

llvm/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h

public:
   virtual Variant getValue() const = 0;
   virtual uint32_t getVirtualBaseDispIndex() const = 0;
   virtual uint32_t getVirtualBaseOffset() const = 0;
   virtual std::unique_ptr<PDBSymbolTypeBuiltin>
   getVirtualBaseTableType() const = 0;
   virtual uint32_t getVirtualTableShapeId() const = 0;
   virtual PDB_DataKind getDataKind() const = 0;
   virtual PDB_SymType getSymTag() const = 0;
-  virtual PDB_UniqueId getGuid() const = 0;
+  virtual codeview::WindowsGuid getGuid() const = 0;
   virtual int32_t getOffset() const = 0;
   virtual int32_t getThisAdjust() const = 0;
   virtual int32_t getVirtualBasePointerOffset() const = 0;
   virtual PDB_LocType getLocationType() const = 0;
   virtual PDB_Machine getMachineType() const = 0;
   virtual codeview::ThunkOrdinal getThunkOrdinal() const = 0;
   virtual uint64_t getLength() const = 0;
   virtual uint64_t getLiveRangeLength() const = 0;

llvm/include/llvm/DebugInfo/PDB/Native/Formatters.h

 #include "llvm/Support/FormatProviders.h"
 
 #define FORMAT_CASE(Value, Name)                                               \
   case Value:                                                                  \
     Stream << Name;                                                            \
     break;
 
 namespace llvm {
-template <> struct format_provider<pdb::PDB_UniqueId> {
-  static void format(const pdb::PDB_UniqueId &V, llvm::raw_ostream &Stream,
-                     StringRef Style) {
-    codeview::fmt_guid(V.Guid).format(Stream, Style);
-  }
-};
-
 template <> struct format_provider<pdb::PdbRaw_ImplVer> {
   static void format(const pdb::PdbRaw_ImplVer &V, llvm::raw_ostream &Stream,
                      StringRef Style) {
     switch (V) {
       FORMAT_CASE(pdb::PdbRaw_ImplVer::PdbImplVC110, "VC110")
       FORMAT_CASE(pdb::PdbRaw_ImplVer::PdbImplVC140, "VC140")
       FORMAT_CASE(pdb::PdbRaw_ImplVer::PdbImplVC2, "VC2")
       FORMAT_CASE(pdb::PdbRaw_ImplVer::PdbImplVC4, "VC4")

llvm/include/llvm/DebugInfo/PDB/Native/InfoStream.h

public:
   Error reload();
 
   uint32_t getStreamSize() const;
 
   bool containsIdStream() const;
   PdbRaw_ImplVer getVersion() const;
   uint32_t getSignature() const;
   uint32_t getAge() const;
-  PDB_UniqueId getGuid() const;
+  codeview::WindowsGuid getGuid() const;
   uint32_t getNamedStreamMapByteSize() const;
 
   PdbRaw_Features getFeatures() const;
   ArrayRef<PdbRaw_FeatureSig> getFeatureSignatures() const;
 
   const NamedStreamMap &getNamedStreams() const;
 
   BinarySubstreamRef getNamedStreamsBuffer() const;
private:
 
   // The number of times the PDB has been written.  Might also be used to
   // ensure that the PDB matches the executable.
   uint32_t Age;
 
   // Due to the aforementioned limitations with `Signature`, this is a new
   // signature present on VC70 and higher PDBs which is guaranteed to be
   // universally unique.
-  PDB_UniqueId Guid;
+  codeview::WindowsGuid Guid;
 
   BinarySubstreamRef SubNamedStreams;
 
   std::vector<PdbRaw_FeatureSig> FeatureSignatures;
   PdbRaw_Features Features = PdbFeatureNone;
 
   uint32_t NamedStreamMapByteSize = 0;
 
   NamedStreamMap NamedStreams;
 };
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h

 public:
   InfoStreamBuilder(msf::MSFBuilder &Msf, NamedStreamMap &NamedStreams);
   InfoStreamBuilder(const InfoStreamBuilder &) = delete;
   InfoStreamBuilder &operator=(const InfoStreamBuilder &) = delete;
 
   void setVersion(PdbRaw_ImplVer V);
   void setSignature(uint32_t S);
   void setAge(uint32_t A);
-  void setGuid(PDB_UniqueId G);
+  void setGuid(codeview::WindowsGuid G);
   void addFeature(PdbRaw_FeatureSig Sig);
 
   uint32_t finalize();
 
   Error finalizeMsfLayout();
 
   Error commit(const msf::MSFLayout &Layout,
                WritableBinaryStreamRef Buffer) const;
 
 private:
   msf::MSFBuilder &Msf;
 
   std::vector<PdbRaw_FeatureSig> Features;
   PdbRaw_ImplVer Ver;
   uint32_t Sig;
   uint32_t Age;
-  PDB_UniqueId Guid;
+  codeview::WindowsGuid Guid;
 
   NamedStreamMap &NamedStreams;
 };
 }
 }
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/NativeExeSymbol.h

public:
 
   std::unique_ptr<NativeRawSymbol> clone() const override;
 
   std::unique_ptr<IPDBEnumSymbols>
   findChildren(PDB_SymType Type) const override;
 
   uint32_t getAge() const override;
   std::string getSymbolsFileName() const override;
-  PDB_UniqueId getGuid() const override;
+  codeview::WindowsGuid getGuid() const override;
   bool hasCTypes() const override;
   bool hasPrivateSymbols() const override;
 
 private:
   PDBFile &File;
 };
 
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/Native/NativeRawSymbol.h

public:
   Variant getValue() const override;
   uint32_t getVirtualBaseDispIndex() const override;
   uint32_t getVirtualBaseOffset() const override;
   uint32_t getVirtualTableShapeId() const override;
   std::unique_ptr<PDBSymbolTypeBuiltin>
   getVirtualBaseTableType() const override;
   PDB_DataKind getDataKind() const override;
   PDB_SymType getSymTag() const override;
-  PDB_UniqueId getGuid() const override;
+  codeview::WindowsGuid getGuid() const override;
   int32_t getOffset() const override;
   int32_t getThisAdjust() const override;
   int32_t getVirtualBasePointerOffset() const override;
   PDB_LocType getLocationType() const override;
   PDB_Machine getMachineType() const override;
   codeview::ThunkOrdinal getThunkOrdinal() const override;
   uint64_t getLength() const override;
   uint64_t getLiveRangeLength() const override;

llvm/include/llvm/DebugInfo/PDB/Native/RawTypes.h

 //===- RawTypes.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_PDB_RAW_RAWTYPES_H
 #define LLVM_DEBUGINFO_PDB_RAW_RAWTYPES_H
 
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/WindowsGuid.h"
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace pdb {
 // This struct is defined as "SO" in langapi/include/pdb.h.
 struct SectionOffset {
   support::ulittle32_t Off;
   support::ulittle16_t Isect;
struct PublicsStreamHeader {
   support::ulittle32_t NumThunks;
   support::ulittle32_t SizeOfThunk;
   support::ulittle16_t ISectThunkTable;
   char Padding[2];
   support::ulittle32_t OffThunkTable;
   support::ulittle32_t NumSections;
 };
 
-/// Defines a 128-bit unique identifier.  This maps to a GUID on Windows, but
-/// is abstracted here for the purposes of non-Windows platforms that don't have
-/// the GUID structure defined.
-struct PDB_UniqueId {
-  uint8_t Guid[16];
-};
-
-inline bool operator==(const PDB_UniqueId &LHS, const PDB_UniqueId &RHS) {
-  return 0 == ::memcmp(LHS.Guid, RHS.Guid, sizeof(LHS.Guid));
-}
-
 // The header preceeding the global TPI stream.
 // This corresponds to `HDR` in PDB/dbi/tpi.h.
 struct TpiStreamHeader {
   struct EmbeddedBuf {
     support::little32_t Off;
     support::ulittle32_t Length;
   };
 

 const uint32_t MinTpiHashBuckets = 0x1000;
 const uint32_t MaxTpiHashBuckets = 0x40000;
 
 /// The header preceeding the global PDB Stream (Stream 1)
 struct InfoStreamHeader {
   support::ulittle32_t Version;
   support::ulittle32_t Signature;
   support::ulittle32_t Age;
-  PDB_UniqueId Guid;
+  codeview::WindowsGuid Guid;
 };
 
 /// The header preceeding the /names stream.
 struct PDBStringTableHeader {
   support::ulittle32_t Signature;   // PDBStringTableSignature
   support::ulittle32_t HashVersion; // 1 or 2
   support::ulittle32_t ByteSize;    // Number of bytes of names buffer.
 };
 
 const uint32_t PDBStringTableSignature = 0xEFFEEFFE;
 
 } // namespace pdb
 } // namespace llvm
 
 #endif

llvm/include/llvm/DebugInfo/PDB/PDBExtras.h

 raw_ostream &operator<<(raw_ostream &OS, const PDB_DataKind &Data);
 raw_ostream &operator<<(raw_ostream &OS, const codeview::RegisterId &Reg);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_LocType &Loc);
 raw_ostream &operator<<(raw_ostream &OS, const codeview::ThunkOrdinal &Thunk);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_Checksum &Checksum);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_Lang &Lang);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_SymType &Tag);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_MemberAccess &Access);
-raw_ostream &operator<<(raw_ostream &OS, const PDB_UniqueId &Guid);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_UdtType &Type);
 raw_ostream &operator<<(raw_ostream &OS, const PDB_Machine &Machine);
 
 raw_ostream &operator<<(raw_ostream &OS, const Variant &Value);
 raw_ostream &operator<<(raw_ostream &OS, const VersionInfo &Version);
 raw_ostream &operator<<(raw_ostream &OS, const TagStats &Stats);
 
 } // end namespace pdb
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_PDB_PDBEXTRAS_H

llvm/include/llvm/ObjectYAML/CodeViewYAMLTypes.h

 
 std::vector<LeafRecord> fromDebugT(ArrayRef<uint8_t> DebugT);
 ArrayRef<uint8_t> toDebugT(ArrayRef<LeafRecord>, BumpPtrAllocator &Alloc);
 
 } // end namespace CodeViewYAML
 
 } // end namespace llvm
 
+LLVM_YAML_DECLARE_SCALAR_TRAITS(codeview::WindowsGuid, true)
+
 LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::LeafRecord)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::MemberRecord)
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::LeafRecord)
 LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::MemberRecord)
 
 #endif // LLVM_OBJECTYAML_CODEVIEWYAMLTYPES_H

llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp

if (auto EC = Writer->writeCString(S))
       return EC;
   } else {
     if (auto EC = Reader->readCString(Value))
       return EC;
   }
   return Error::success();
 }
 
-Error CodeViewRecordIO::mapGuid(StringRef &Guid) {
+Error CodeViewRecordIO::mapGuid(WindowsGuid &Guid) {
   constexpr uint32_t GuidSize = 16;
   if (maxFieldLength() < GuidSize)
     return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
 
   if (isWriting()) {
-    assert(Guid.size() == 16 && "Invalid Guid Size!");
-    if (auto EC = Writer->writeFixedString(Guid))
+    if (auto EC = Writer->writeBytes(Guid.Guid))
       return EC;
   } else {
-    if (auto EC = Reader->readFixedString(Guid, 16))
+    ArrayRef<uint8_t> GuidBytes;
+    if (auto EC = Reader->readBytes(GuidBytes, GuidSize))
       return EC;
+    memcpy(Guid.Guid, GuidBytes.data(), GuidSize);
   }
   return Error::success();
 }
 
 Error CodeViewRecordIO::mapStringZVectorZ(std::vector<StringRef> &Value) {
   if (isWriting()) {
     for (auto V : Value) {
       if (auto EC = mapStringZ(V))

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/DebugInfo/CodeView/WindowsGuid.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::codeview::detail;
 
for (int i = 0; i < 16;) {
     uint8_t LowNibble = Byte & 0xF;
     Stream << Lookup[HighNibble] << Lookup[LowNibble];
     ++i;
     if (i >= 4 && i <= 10 && i % 2 == 0)
       Stream << "-";
   }
   Stream << "}";
 }
+
+raw_ostream &llvm::codeview::operator<<(raw_ostream &OS,
+                                        const WindowsGuid &Guid) {
+  codeview::detail::GuidAdapter A(Guid.Guid);
+  A.format(OS, "");
+  return OS;
+}

llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

 Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
   printItemIndex("ParentScope", Func.getParentScope());
   printTypeIndex("FunctionType", Func.getFunctionType());
   W->printString("Name", Func.getName());
   return Error::success();
 }
 
 Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
-  W->printString("Guid", formatv("{0}", fmt_guid(TS.getGuid())).str());
+  W->printString("Guid", formatv("{0}", TS.getGuid()).str());
   W->printNumber("Age", TS.getAge());
   W->printString("Name", TS.getName());
   return Error::success();
 }
 
 Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
   printTypeIndex("PointeeType", Ptr.getReferentType());
   W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));

llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp

PrivateGetDIAValue(IDiaSymbol *Symbol,
   const char *SrcBytes = reinterpret_cast<const char *>(Result16.m_str);
   llvm::ArrayRef<char> SrcByteArray(SrcBytes, Result16.ByteLength());
   std::string Result8;
   if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8))
     return std::string();
   return Result8;
 }
 
-PDB_UniqueId
+codeview::WindowsGuid
 PrivateGetDIAValue(IDiaSymbol *Symbol,
                    HRESULT (__stdcall IDiaSymbol::*Method)(GUID *)) {
   GUID Result;
   if (S_OK != (Symbol->*Method)(&Result))
-    return PDB_UniqueId();
+    return codeview::WindowsGuid();
 
-  static_assert(sizeof(PDB_UniqueId) == sizeof(GUID),
-                "PDB_UniqueId is the wrong size!");
-  PDB_UniqueId IdResult;
+  static_assert(sizeof(codeview::WindowsGuid) == sizeof(GUID),
+                "WindowsGuid is the wrong size!");
+  codeview::WindowsGuid IdResult;
   ::memcpy(&IdResult, &Result, sizeof(GUID));
   return IdResult;
 }
 
 template <typename ArgType>
 void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,
                   IDiaSymbol *Symbol,
                   HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {
return PrivateGetDIAValue<DWORD, PDB_DataKind>(Symbol,
                                                  &IDiaSymbol::get_dataKind);
 }
 
 PDB_SymType DIARawSymbol::getSymTag() const {
   return PrivateGetDIAValue<DWORD, PDB_SymType>(Symbol,
                                                 &IDiaSymbol::get_symTag);
 }
 
-PDB_UniqueId DIARawSymbol::getGuid() const {
+codeview::WindowsGuid DIARawSymbol::getGuid() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_guid);
 }
 
 int32_t DIARawSymbol::getOffset() const {
   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offset);
 }
 
 int32_t DIARawSymbol::getThisAdjust() const {

llvm/lib/DebugInfo/PDB/Native/InfoStream.cpp

 PdbRaw_ImplVer InfoStream::getVersion() const {
   return static_cast<PdbRaw_ImplVer>(Version);
 }
 
 uint32_t InfoStream::getSignature() const { return Signature; }
 
 uint32_t InfoStream::getAge() const { return Age; }
 
-PDB_UniqueId InfoStream::getGuid() const { return Guid; }
+WindowsGuid InfoStream::getGuid() const { return Guid; }
 
 uint32_t InfoStream::getNamedStreamMapByteSize() const {
   return NamedStreamMapByteSize;
 }
 
 PdbRaw_Features InfoStream::getFeatures() const { return Features; }
 
 ArrayRef<PdbRaw_FeatureSig> InfoStream::getFeatureSignatures() const {

llvm/lib/DebugInfo/PDB/Native/InfoStreamBuilder.cpp

: Msf(Msf), Ver(PdbRaw_ImplVer::PdbImplVC70), Sig(-1), Age(0),
       NamedStreams(NamedStreams) {}
 
 void InfoStreamBuilder::setVersion(PdbRaw_ImplVer V) { Ver = V; }
 
 void InfoStreamBuilder::setSignature(uint32_t S) { Sig = S; }
 
 void InfoStreamBuilder::setAge(uint32_t A) { Age = A; }
 
-void InfoStreamBuilder::setGuid(PDB_UniqueId G) { Guid = G; }
+void InfoStreamBuilder::setGuid(WindowsGuid G) { Guid = G; }
 
 void InfoStreamBuilder::addFeature(PdbRaw_FeatureSig Sig) {
   Features.push_back(Sig);
 }
 
 Error InfoStreamBuilder::finalizeMsfLayout() {
   uint32_t Length = sizeof(InfoStreamHeader) + NamedStreams.finalize() +
                     (Features.size() + 1) * sizeof(uint32_t);

llvm/lib/DebugInfo/PDB/Native/NativeExeSymbol.cpp

uint32_t NativeExeSymbol::getAge() const {
   consumeError(IS.takeError());
   return 0;
 }
 
 std::string NativeExeSymbol::getSymbolsFileName() const {
   return File.getFilePath();
 }
 
-PDB_UniqueId NativeExeSymbol::getGuid() const {
+codeview::WindowsGuid NativeExeSymbol::getGuid() const {
   auto IS = File.getPDBInfoStream();
   if (IS)
     return IS->getGuid();
   consumeError(IS.takeError());
-  return PDB_UniqueId{{0}};
+  return codeview::WindowsGuid{{0}};
 }
 
 bool NativeExeSymbol::hasCTypes() const {
   auto Dbi = File.getPDBDbiStream();
   if (Dbi)
     return Dbi->hasCTypes();
   consumeError(Dbi.takeError());
   return false;

llvm/lib/DebugInfo/PDB/Native/NativeRawSymbol.cpp

 PDB_DataKind NativeRawSymbol::getDataKind() const {
   return PDB_DataKind::Unknown;
 }
 
 PDB_SymType NativeRawSymbol::getSymTag() const {
   return PDB_SymType::None;
 }
 
-PDB_UniqueId NativeRawSymbol::getGuid() const {
-  return PDB_UniqueId{{0}};
+codeview::WindowsGuid NativeRawSymbol::getGuid() const {
+  return codeview::WindowsGuid{{0}};
 }
 
 int32_t NativeRawSymbol::getOffset() const {
   return 0;
 }
 
 int32_t NativeRawSymbol::getThisAdjust() const {
   return 0;

llvm/lib/DebugInfo/PDB/Native/PDBTypeServerHandler.cpp

for (auto &Path : SearchPaths) {
     // All PDB Files should have an Info stream.
     if (!ExpectedInfo)
       return ExpectedInfo.takeError();
 
     // Just because a file with a matching name was found and it was an actual
     // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
     // must match the GUID specified in the TypeServer2 record.
     ArrayRef<uint8_t> GuidBytes(ExpectedInfo->getGuid().Guid);
-    StringRef GuidStr(reinterpret_cast<const char *>(GuidBytes.begin()),
-                      GuidBytes.size());
-    if (GuidStr != TS.Guid)
+    if (GuidBytes != makeArrayRef(TS.Guid.Guid))
       continue;
 
     Session = std::move(NS);
     return handleInternal(File, Callbacks);
   }
 
   // We couldn't find a matching PDB, so let it be handled by someone else.
   return make_error<GenericError>(generic_error_code::type_server_not_found,
                                   File);
 }

llvm/lib/DebugInfo/PDB/PDBExtras.cpp

raw_ostream &llvm::pdb::operator<<(raw_ostream &OS,
   switch (Access) {
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_MemberAccess, Public, "public", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_MemberAccess, Protected, "protected", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_MemberAccess, Private, "private", OS)
   }
   return OS;
 }
 
-raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_UniqueId &Guid) {
-  codeview::detail::GuidAdapter A(Guid.Guid);
-  A.format(OS, "");
-  return OS;
-}
-
 raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_UdtType &Type) {
   switch (Type) {
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_UdtType, Class, "class", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_UdtType, Struct, "struct", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_UdtType, Interface, "interface", OS)
     CASE_OUTPUT_ENUM_CLASS_STR(PDB_UdtType, Union, "union", OS)
   }
   return OS;

llvm/lib/ObjectYAML/CodeViewYAMLTypes.cpp

template <typename T> struct MemberRecordImpl : public MemberRecordBase {
 
   mutable T Record;
 };
 
 } // end namespace detail
 } // end namespace CodeViewYAML
 } // end namespace llvm
 
+void ScalarTraits<WindowsGuid>::output(const WindowsGuid &G, void *,
+                                       llvm::raw_ostream &OS) {
+  OS << G;
+}
+
+StringRef ScalarTraits<WindowsGuid>::input(StringRef Scalar, void *Ctx,
+                                           WindowsGuid &S) {
+  if (Scalar.size() != 38)
+    return "GUID strings are 38 characters long";
+  if (Scalar[0] != '{' || Scalar[37] != '}')
+    return "GUID is not enclosed in {}";
+  if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
+      Scalar[24] != '-')
+    return "GUID sections are not properly delineated with dashes";
+
+  uint8_t *OutBuffer = S.Guid;
+  for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
+    if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
+      ++Iter;
+      continue;
+    }
+    uint8_t Value = (llvm::hexDigitValue(*Iter) << 4);
+    ++Iter;
+    Value |= llvm::hexDigitValue(*Iter);
+    ++Iter;
+    *OutBuffer++ = Value;
+  }
+
+  return "";
+}
+
 void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
                                      raw_ostream &OS) {
   OS << S.getIndex();
 }
 
 StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,
                                          TypeIndex &S) {
   uint32_t I;

llvm/test/ObjectYAML/CodeView/guid.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            '.debug$T'
+    Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+    Alignment:       1
+    Types:
+      - Kind:            LF_TYPESERVER2
+        TypeServer2:
+          Guid:            '{01DF191B-22BF-6B42-96CE-5258B8329FE5}'
+          Age:             24
+          Name:            'C:\src\llvm-project\build\vc140.pdb'
+symbols:
+  - Name:            '.debug$T'
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          64
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+...
+
+# CHECK: --- !COFF
+# CHECK: header:
+# CHECK:   Machine:         IMAGE_FILE_MACHINE_AMD64
+# CHECK:   Characteristics: [  ]
+# CHECK: sections:
+# CHECK:   - Name:            '.debug$T'
+# CHECK:     Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
+# CHECK:     Alignment:       1
+# CHECK:     Types:
+# CHECK:       - Kind:            LF_TYPESERVER2
+# CHECK:         TypeServer2:
+# CHECK:           Guid:            '{01DF191B-22BF-6B42-96CE-5258B8329FE5}'
+# CHECK:           Age:             24
+# CHECK:           Name:            'C:\src\llvm-project\build\vc140.pdb'
+# CHECK: symbols:
+# CHECK:   - Name:            '.debug$T'
+# CHECK:     Value:           0
+# CHECK:     SectionNumber:   1
+# CHECK:     SimpleType:      IMAGE_SYM_TYPE_NULL
+# CHECK:     ComplexType:     IMAGE_SYM_DTYPE_NULL
+# CHECK:     StorageClass:    IMAGE_SYM_CLASS_STATIC
+# CHECK:     SectionDefinition:
+# CHECK:       Length:          64
+# CHECK:       NumberOfRelocations: 0
+# CHECK:       NumberOfLinenumbers: 0
+# CHECK:       CheckSum:        0
+# CHECK:       Number:          0
+# CHECK: ...

llvm/tools/llvm-pdbutil/MinimalTypeDumper.cpp

Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
                                                FuncIdRecord &Func) {
   P.formatLine("name = {0}, type = {1}, parent scope = {2}", Func.Name,
                Func.FunctionType, Func.ParentScope);
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
                                                TypeServer2Record &TS) {
-  P.formatLine("name = {0}, age = {1}, guid = {2}", TS.Name, TS.Age,
-               fmt_guid(TS.Guid));
+  P.formatLine("name = {0}, age = {1}, guid = {2}", TS.Name, TS.Age, TS.Guid);
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
                                                PointerRecord &Ptr) {
   P.formatLine("referent = {0}, {1}", Ptr.ReferentType,
                formatPointerAttrs(Ptr));
   return Error::success();

llvm/tools/llvm-pdbutil/PdbYaml.h

struct NamedStreamMapping {
   StringRef StreamName;
   uint32_t StreamNumber;
 };
 
 struct PdbInfoStream {
   PdbRaw_ImplVer Version = PdbImplVC70;
   uint32_t Signature = 0;
   uint32_t Age = 1;
-  PDB_UniqueId Guid;
+  codeview::WindowsGuid Guid;
   std::vector<PdbRaw_FeatureSig> Features;
   std::vector<NamedStreamMapping> NamedStreams;
 };
 
 struct PdbModiStream {
   uint32_t Signature;
   std::vector<CodeViewYAML::SymbolRecord> Symbols;
 };

llvm/tools/llvm-pdbutil/PdbYaml.cpp

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::NamedStreamMapping)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbDbiModuleInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamBlockList)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::pdb::PdbRaw_FeatureSig)
 
 namespace llvm {
 namespace yaml {
 
-template <> struct ScalarTraits<llvm::pdb::PDB_UniqueId> {
-  static void output(const llvm::pdb::PDB_UniqueId &S, void *,
-                     llvm::raw_ostream &OS) {
-    OS << S;
-  }
-
-  static StringRef input(StringRef Scalar, void *Ctx,
-                         llvm::pdb::PDB_UniqueId &S) {
-    if (Scalar.size() != 38)
-      return "GUID strings are 38 characters long";
-    if (Scalar[0] != '{' || Scalar[37] != '}')
-      return "GUID is not enclosed in {}";
-    if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
-        Scalar[24] != '-')
-      return "GUID sections are not properly delineated with dashes";
-
-    uint8_t *OutBuffer = S.Guid;
-    for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
-      if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
-        ++Iter;
-        continue;
-      }
-      uint8_t Value = (llvm::hexDigitValue(*Iter) << 4);
-      ++Iter;
-      Value |= llvm::hexDigitValue(*Iter);
-      ++Iter;
-      *OutBuffer++ = Value;
-    }
-
-    return "";
-  }
-
-  static bool mustQuote(StringRef Scalar) { return needsQuotes(Scalar); }
-};
-
 template <> struct ScalarEnumerationTraits<llvm::pdb::PDB_Machine> {
   static void enumeration(IO &io, llvm::pdb::PDB_Machine &Value) {
     io.enumCase(Value, "Invalid", PDB_Machine::Invalid);
     io.enumCase(Value, "Am33", PDB_Machine::Am33);
     io.enumCase(Value, "Amd64", PDB_Machine::Amd64);
     io.enumCase(Value, "Arm", PDB_Machine::Arm);
     io.enumCase(Value, "ArmNT", PDB_Machine::ArmNT);
     io.enumCase(Value, "Ebc", PDB_Machine::Ebc);

llvm/unittests/DebugInfo/PDB/TypeServerHandlerTest.cpp

 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 namespace {
 
 constexpr uint8_t Guid[] = {0x2a, 0x2c, 0x1c, 0x2a, 0xcb, 0x9e, 0x48, 0x18,
                             0x82, 0x82, 0x7a, 0x87, 0xc3, 0xfe, 0x16, 0xe8};
-StringRef GuidStr(reinterpret_cast<const char *>(Guid),
-                  llvm::array_lengthof(Guid));
+ArrayRef<uint8_t> GuidBytes(Guid, llvm::array_lengthof(Guid));
 
 constexpr const char *Name = "Test Name";
 constexpr int Age = 1;
 
 class MockTypeServerHandler : public TypeServerHandler {
 public:
   explicit MockTypeServerHandler(bool HandleAlways)
       : HandleAlways(HandleAlways) {}
 
   Expected<bool> handle(TypeServer2Record &TS,
                         TypeVisitorCallbacks &Callbacks) override {
-    if (TS.Age != Age || TS.Guid != GuidStr || TS.Name != Name)
+    if (TS.Age != Age || makeArrayRef(TS.Guid.Guid) != GuidBytes ||
+        TS.Name != Name)
       return make_error<CodeViewError>(cv_error_code::corrupt_record,
                                        "Invalid TypeServer record!");
 
     if (Handled && !HandleAlways)
       return false;
 
     Handled = true;
     return true;
public:
   State S = State::Ready;
 };
 
 class TypeServerHandlerTest : public testing::Test {
 public:
   void SetUp() override {
     TypeServer2Record R(TypeRecordKind::TypeServer2);
     R.Age = Age;
-    R.Guid = GuidStr;
+    memcpy(R.Guid.Guid, Guid, sizeof(R.Guid.Guid));
     R.Name = Name;
 
     TypeTableBuilder Builder(Allocator);
     Builder.writeKnownType(R);
     TypeServerRecord.RecordData = Builder.records().front();
     TypeServerRecord.Type = TypeLeafKind::LF_TYPESERVER2;
   }