Breakpad: Add support for parsing STACK WIN records

[labath]

Summary

The fields that aren't useful for us right now are simply ignored.

[amccarth]

LGTM.

[markmentovai]

LGTM too.

lldb/trunk/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h

 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/FormatProviders.h"
 
 namespace lldb_private {
 namespace breakpad {
 
 class Record {
 public:
-  enum Kind { Module, Info, File, Func, Line, Public, StackCFI };
+  enum Kind { Module, Info, File, Func, Line, Public, StackCFI, StackWin };
 
   /// Attempt to guess the kind of the record present in the argument without
   /// doing a full parse. The returned kind will always be correct for valid
   /// records, but the full parse can still fail in case of corrupted input.
   static llvm::Optional<Kind> classify(llvm::StringRef Line);
 
 protected:
   Record(Kind K) : TheKind(K) {}
public:
   lldb::addr_t Address;
   llvm::Optional<lldb::addr_t> Size;
   llvm::StringRef UnwindRules;
 };
 
 bool operator==(const StackCFIRecord &L, const StackCFIRecord &R);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const StackCFIRecord &R);
 
+class StackWinRecord : public Record {
+public:
+  static llvm::Optional<StackWinRecord> parse(llvm::StringRef Line);
+
+  StackWinRecord(lldb::addr_t RVA, lldb::addr_t CodeSize,
+                 lldb::addr_t ParameterSize, lldb::addr_t SavedRegisterSize,
+                 lldb::addr_t LocalSize, llvm::StringRef ProgramString)
+      : Record(StackWin), RVA(RVA), CodeSize(CodeSize),
+        ParameterSize(ParameterSize), SavedRegisterSize(SavedRegisterSize),
+        LocalSize(LocalSize), ProgramString(ProgramString) {}
+
+  enum class FrameType : uint8_t { FPO = 0, FrameData = 4 };
+  lldb::addr_t RVA;
+  lldb::addr_t CodeSize;
+  lldb::addr_t ParameterSize;
+  lldb::addr_t SavedRegisterSize;
+  lldb::addr_t LocalSize;
+  llvm::StringRef ProgramString;
+};
+
+bool operator==(const StackWinRecord &L, const StackWinRecord &R);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const StackWinRecord &R);
+
 } // namespace breakpad
 } // namespace lldb_private
 
 #endif // LLDB_PLUGINS_OBJECTFILE_BREAKPAD_BREAKPADRECORDS_H

lldb/trunk/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp

 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace lldb_private;
 using namespace lldb_private::breakpad;
 
 namespace {
-enum class Token { Unknown, Module, Info, CodeID, File, Func, Public, Stack, CFI, Init };
+enum class Token {
+  Unknown,
+  Module,
+  Info,
+  CodeID,
+  File,
+  Func,
+  Public,
+  Stack,
+  CFI,
+  Init,
+  Win,
+};
 }
 
 template<typename T>
 static T stringTo(llvm::StringRef Str);
 
 template <> Token stringTo<Token>(llvm::StringRef Str) {
   return llvm::StringSwitch<Token>(Str)
       .Case("MODULE", Token::Module)
       .Case("INFO", Token::Info)
       .Case("CODE_ID", Token::CodeID)
       .Case("FILE", Token::File)
       .Case("FUNC", Token::Func)
       .Case("PUBLIC", Token::Public)
       .Case("STACK", Token::Stack)
       .Case("CFI", Token::CFI)
       .Case("INIT", Token::Init)
+      .Case("WIN", Token::Win)
       .Default(Token::Unknown);
 }
 
 template <>
 llvm::Triple::OSType stringTo<llvm::Triple::OSType>(llvm::StringRef Str) {
   using llvm::Triple;
   return llvm::StringSwitch<Triple::OSType>(Str)
       .Case("Linux", Triple::Linux)
case Token::Func:
     return Record::Func;
   case Token::Public:
     return Record::Public;
   case Token::Stack:
     Tok = consume<Token>(Line);
     switch (Tok) {
     case Token::CFI:
       return Record::StackCFI;
+    case Token::Win:
+      return Record::StackWin;
     default:
       return llvm::None;
     }
 
   case Token::Unknown:
     // Optimistically assume that any unrecognised token means this is a line
     // record, those don't have a special keyword and start directly with a
-    // hex number. CODE_ID should never be at the start of a line, but if it
-    // is, it can be treated the same way as a garbled line record.
+    // hex number.
     return Record::Line;
 
   case Token::CodeID:
   case Token::CFI:
   case Token::Init:
+  case Token::Win:
     // These should never appear at the start of a valid record.
     return llvm::None;
   }
   llvm_unreachable("Fully covered switch above!");
 }
 
 llvm::Optional<ModuleRecord> ModuleRecord::parse(llvm::StringRef Line) {
   // MODULE Linux x86_64 E5894855C35DCCCCCCCCCCCCCCCCCCCC0 a.out
llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
   if (R.Size)
     OS << "INIT ";
   OS << llvm::formatv("{0:x-} ", R.Address);
   if (R.Size)
     OS << llvm::formatv("{0:x-} ", *R.Size);
   return OS << " " << R.UnwindRules;
 }
 
+llvm::Optional<StackWinRecord> StackWinRecord::parse(llvm::StringRef Line) {
+  // STACK WIN type rva code_size prologue_size epilogue_size parameter_size
+  //     saved_register_size local_size max_stack_size has_program_string
+  //     program_string_OR_allocates_base_pointer
+
+  if (consume<Token>(Line) != Token::Stack)
+    return llvm::None;
+  if (consume<Token>(Line) != Token::Win)
+    return llvm::None;
+
+  llvm::StringRef Str;
+  uint8_t Type;
+  std::tie(Str, Line) = getToken(Line);
+  // Right now we only support the "FrameData" frame type.
+  if (!to_integer(Str, Type) || FrameType(Type) != FrameType::FrameData)
+    return llvm::None;
+
+  lldb::addr_t RVA;
+  std::tie(Str, Line) = getToken(Line);
+  if (!to_integer(Str, RVA, 16))
+    return llvm::None;
+
+  lldb::addr_t CodeSize;
+  std::tie(Str, Line) = getToken(Line);
+  if (!to_integer(Str, CodeSize, 16))
+    return llvm::None;
+
+  // Skip fields which we aren't using right now.
+  std::tie(Str, Line) = getToken(Line); // prologue_size
+  std::tie(Str, Line) = getToken(Line); // epilogue_size
+
+  lldb::addr_t ParameterSize;
+  std::tie(Str, Line) = getToken(Line);
+  if (!to_integer(Str, ParameterSize, 16))
+    return llvm::None;
+
+  lldb::addr_t SavedRegisterSize;
+  std::tie(Str, Line) = getToken(Line);
+  if (!to_integer(Str, SavedRegisterSize, 16))
+    return llvm::None;
+
+  lldb::addr_t LocalSize;
+  std::tie(Str, Line) = getToken(Line);
+  if (!to_integer(Str, LocalSize, 16))
+    return llvm::None;
+
+  std::tie(Str, Line) = getToken(Line); // max_stack_size
+
+  uint8_t HasProgramString;
+  std::tie(Str, Line) = getToken(Line);
+  if (!to_integer(Str, HasProgramString))
+    return llvm::None;
+  // FrameData records should always have a program string.
+  if (!HasProgramString)
+    return llvm::None;
+
+  return StackWinRecord(RVA, CodeSize, ParameterSize, SavedRegisterSize,
+                        LocalSize, Line.trim());
+}
+
+bool breakpad::operator==(const StackWinRecord &L, const StackWinRecord &R) {
+  return L.RVA == R.RVA && L.CodeSize == R.CodeSize &&
+         L.ParameterSize == R.ParameterSize &&
+         L.SavedRegisterSize == R.SavedRegisterSize &&
+         L.LocalSize == R.LocalSize && L.ProgramString == R.ProgramString;
+}
+
+llvm::raw_ostream &breakpad::operator<<(llvm::raw_ostream &OS,
+                                        const StackWinRecord &R) {
+  return OS << llvm::formatv(
+             "STACK WIN 4 {0:x-} {1:x-} ? ? {2} {3} {4} ? 1 {5}", R.RVA,
+             R.CodeSize, R.ParameterSize, R.SavedRegisterSize, R.LocalSize,
+             R.ProgramString);
+}
+
 llvm::StringRef breakpad::toString(Record::Kind K) {
   switch (K) {
   case Record::Module:
     return "MODULE";
   case Record::Info:
     return "INFO";
   case Record::File:
     return "FILE";
   case Record::Func:
     return "FUNC";
   case Record::Line:
     return "LINE";
   case Record::Public:
     return "PUBLIC";
   case Record::StackCFI:
     return "STACK CFI";
+  case Record::StackWin:
+    return "STACK WIN";
   }
   llvm_unreachable("Unknown record kind!");
 }

lldb/trunk/unittests/ObjectFile/Breakpad/BreakpadRecordsTest.cpp

 
 TEST(Record, classify) {
   EXPECT_EQ(Record::Module, Record::classify("MODULE"));
   EXPECT_EQ(Record::Info, Record::classify("INFO"));
   EXPECT_EQ(Record::File, Record::classify("FILE"));
   EXPECT_EQ(Record::Func, Record::classify("FUNC"));
   EXPECT_EQ(Record::Public, Record::classify("PUBLIC"));
   EXPECT_EQ(Record::StackCFI, Record::classify("STACK CFI"));
+  EXPECT_EQ(Record::StackWin, Record::classify("STACK WIN"));
 
   // Any obviously incorrect lines will be classified as such.
   EXPECT_EQ(llvm::None, Record::classify("STACK"));
   EXPECT_EQ(llvm::None, Record::classify("STACK CODE_ID"));
   EXPECT_EQ(llvm::None, Record::classify("CODE_ID"));
 
   // Any line which does not start with a known keyword will be classified as a
   // line record, as those are the only ones that start without a keyword.
TEST(StackCFIRecord, parse) {
 
   EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK CFI INIT 47"));
   EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK CFI INIT"));
   EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK CFI"));
   EXPECT_EQ(llvm::None, StackCFIRecord::parse("STACK"));
   EXPECT_EQ(llvm::None, StackCFIRecord::parse("FILE 47 foo"));
   EXPECT_EQ(llvm::None, StackCFIRecord::parse("42 47"));
 }
+
+TEST(StackWinRecord, parse) {
+  EXPECT_EQ(
+      StackWinRecord(0x47, 0x8, 3, 4, 5, llvm::StringRef("$eip $esp ^ =")),
+      StackWinRecord::parse("STACK WIN 4 47 8 1 2 3 4 5 6 1 $eip $esp ^ ="));
+
+  EXPECT_EQ(llvm::None, StackWinRecord::parse(
+                            "STACK WIN 0 47 8 1 0 0 0 0 0 1 $eip $esp ^ ="));
+  EXPECT_EQ(llvm::None,
+            StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0 0 0 0 1"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse(
+                            "STACK WIN 3 47 8 1 0 0 0 0 0 1 $eip $esp ^ ="));
+  EXPECT_EQ(llvm::None,
+            StackWinRecord::parse("STACK WIN 3 47 8 1 0 0 0 0 0 0 1"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse(
+                            "STACK WIN 4 47 8 1 0 0 0 0 1 $eip $esp ^ ="));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0 0 0"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0 0"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0 0"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0 0"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1 0"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8 1"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47 8"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4 47"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN 4"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK WIN"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse("STACK"));
+  EXPECT_EQ(llvm::None, StackWinRecord::parse(""));
+  EXPECT_EQ(llvm::None, StackCFIRecord::parse("FILE 47 foo"));
+  EXPECT_EQ(llvm::None, StackCFIRecord::parse("42 47"));
+}