[llvm-pdbutil] Don't crash when printing unknown CodeView type records

[aganea]

Summary

It seems Microsoft has added some new, undocumented, debug type records with the (latest?) VS 2019 16.8 release. For example:

>cat a.cpp
namespace NS {
  struct Foo {
    explicit Foo(int x) : X(x) {}
    int X;
  };
}

int main(int argc, char **argv) {
  NS::Foo f(argc);
  return 0;
}

>cl /c /Z7 /GS- a.cpp
Microsoft (R) C/C++ Optimizing Compiler Version 19.28.29335 for x86
Copyright (C) Microsoft Corporation.  All rights reserved.

a.cpp

>cvdump.exe a.obj | grep "UNRECOGNIZED"
0x1004 : Length = 46, Leaf = 0x1609 UNRECOGNIZED TYPE
0x1009 : Length = 46, Leaf = 0x1609 UNRECOGNIZED TYPE

Before this patch, llvm-pdbutil dump a.obj used to crash. Now it displays "UNKOWN RECORD":

>llvm-pdbutil dump -all a.obj | grep -C2 "0x1609"
                Record Kind | Count  Size
    --------------------------------------
    UNKNOWN RECORD (0x1609) |     1    48
    --------------------------------------
              Total (S_UDT) |     1    16
--
0x1003 | LF_FUNC_ID [size = 20]
         name = main, type = 0x1002, parent scope = <no type>
0x1004 | UNKNOWN RECORD (0x1609) [size = 48]
0x1005 | LF_POINTER [size = 12]
         referent = 0x1004, mode = pointer, opts = const, kind = ptr64
--
           type = 0x1007, vftable offset = -1, attrs = public
         - LF_MEMBER [name = `X`, Type = 0x0074 (int), offset = 0, attrs = public]
0x1009 | UNKNOWN RECORD (0x1609) [size = 48]
0x100A | LF_STRING_ID [size = 48] ID: <no type>, String: F:\aganea\llvm-project\__test\a.cpp
0x100B | LF_UDT_SRC_LINE [size = 16]

There's also a crash in obj2yaml as well, I can send another review for that.

@gratianlup Do you think if it would be possible to to upgrade the list of records in https://github.com/microsoft/microsoft-pdb ? Thanks in advance!

[rnk]

lgtm

It seems like Harbormaster / Jenkins didn't like the new test, so double check that it passes before landing.

llvm/test/tools/llvm-pdbutil/unknown-records.test

+; REQUIRES: diasdk
+; RUN: llvm-pdbutil dump -all %p/Inputs/unknown-record.obj | FileCheck %s
+; CHECK: UNKNOWN RECORD (0x1609)

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

static bool isValidNamespaceIdentifier(StringRef S) {
 
   return llvm::all_of(S, [](char C) { return std::isalnum(C); });
 }
 
 namespace {
 constexpr uint32_t kNoneUdtKind = 0;
 constexpr uint32_t kSimpleUdtKind = 1;
 constexpr uint32_t kUnknownUdtKind = 2;
-const StringRef NoneLabel("<none type>");
-const StringRef SimpleLabel("<simple type>");
-const StringRef UnknownLabel("<unknown type>");
-
 } // namespace
 
-static StringRef getUdtStatLabel(uint32_t Kind) {
+static std::string getUdtStatLabel(uint32_t Kind) {
   if (Kind == kNoneUdtKind)
-    return NoneLabel;
+    return "<none type>";
 
   if (Kind == kSimpleUdtKind)
-    return SimpleLabel;
+    return "<simple type>";
 
   if (Kind == kUnknownUdtKind)
-    return UnknownLabel;
+    return "<unknown type>";
 
   return formatTypeLeafKind(static_cast<TypeLeafKind>(Kind));
 }
 
 static uint32_t getLongestTypeLeafName(const StatCollection &Stats) {
   size_t L = 0;
   for (const auto &Stat : Stats.Individual) {
-    StringRef Label = getUdtStatLabel(Stat.first);
+    std::string Label = getUdtStatLabel(Stat.first);
     L = std::max(L, Label.size());
   }
   return static_cast<uint32_t>(L);
 }
 
 Error DumpOutputStyle::dumpUdtStats() {
   printHeader(P, "S_UDT Record Stats");
 
Error DumpOutputStyle::dumpUdtStats() {
 
   P.formatLine("{0} | {1}  {2}",
                fmt_align("Record Kind", AlignStyle::Right, FieldWidth),
                fmt_align(CountHeader, AlignStyle::Right, CD),
                fmt_align(SizeHeader, AlignStyle::Right, SD));
 
   P.formatLine("{0}", fmt_repeat('-', TableWidth));
   for (const auto &Stat : UdtTargetStats.getStatsSortedBySize()) {
-    StringRef Label = getUdtStatLabel(Stat.first);
+    std::string Label = getUdtStatLabel(Stat.first);
     P.formatLine("{0} | {1:N}  {2:N}",
                  fmt_align(Label, AlignStyle::Right, FieldWidth),
                  fmt_align(Stat.second.Count, AlignStyle::Right, CD),
                  fmt_align(Stat.second.Size, AlignStyle::Right, SD));
   }
   P.formatLine("{0}", fmt_repeat('-', TableWidth));
   P.formatLine("{0} | {1:N}  {2:N}",
                fmt_align("Total (S_UDT)", AlignStyle::Right, FieldWidth),

llvm/tools/llvm-pdbutil/FormatUtil.h

std::string typesetItemList(ArrayRef<std::string> Opts, uint32_t IndentLevel,
                             uint32_t GroupSize, StringRef Sep);
 
 std::string typesetStringList(uint32_t IndentLevel,
                               ArrayRef<StringRef> Strings);
 
 std::string formatChunkKind(codeview::DebugSubsectionKind Kind,
                             bool Friendly = true);
 std::string formatSymbolKind(codeview::SymbolKind K);
-StringRef formatTypeLeafKind(codeview::TypeLeafKind K);
+std::string formatTypeLeafKind(codeview::TypeLeafKind K);
 
 /// Returns the number of digits in the given integer.
 inline int NumDigits(uint64_t N) {
   if (N < 10ULL)
     return 1;
   if (N < 100ULL)
     return 2;
   if (N < 1000ULL)

llvm/tools/llvm-pdbutil/FormatUtil.cpp

#define SYMBOL_RECORD(EnumName, value, name)                                   \
   case EnumName:                                                               \
     return #EnumName;
 #define CV_SYMBOL(EnumName, value) SYMBOL_RECORD(EnumName, value, EnumName)
 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
   }
   return formatUnknownEnum(K);
 }
 
-StringRef llvm::pdb::formatTypeLeafKind(TypeLeafKind K) {
+std::string llvm::pdb::formatTypeLeafKind(TypeLeafKind K) {
   switch (K) {
 #define TYPE_RECORD(EnumName, value, name)                                     \
   case EnumName:                                                               \
     return #EnumName;
 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
   default:
-    llvm_unreachable("Unknown type leaf kind!");
+    return formatv("UNKNOWN RECORD ({0:X})",
+                   static_cast<std::underlying_type_t<TypeLeafKind>>(K))
+        .str();
   }
-  return "";
 }
 
 std::string llvm::pdb::formatSegmentOffset(uint16_t Segment, uint32_t Offset) {
   return std::string(formatv("{0:4}:{1:4}", Segment, Offset));
 }
 
 #define PUSH_CHARACTERISTIC_FLAG(Enum, TheOpt, Value, Style, Descriptive)      \
   PUSH_FLAG(Enum, TheOpt, Value,                                               \