lldb/unittests/Process/minidump/MinidumpParserTest.cpp

   1 //===-- MinidumpTypesTest.cpp ---------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Plugins/Process/minidump/MinidumpParser.h"
  10 #include "Plugins/Process/minidump/MinidumpTypes.h"
  11 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_32.h"
  12 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_64.h"
  13 #include "TestingSupport/SubsystemRAII.h"
  14 #include "TestingSupport/TestUtilities.h"
  15 #include "lldb/Host/FileSystem.h"
  16 #include "lldb/Target/MemoryRegionInfo.h"
  17 #include "lldb/Utility/ArchSpec.h"
  18 #include "lldb/Utility/DataBufferHeap.h"
  19 #include "lldb/Utility/DataExtractor.h"
  20 #include "lldb/Utility/FileSpec.h"
  21 #include "llvm/ADT/ArrayRef.h"
  22 #include "llvm/ObjectYAML/yaml2obj.h"
  23 #include "llvm/Support/FileSystem.h"
  24 #include "llvm/Support/MemoryBuffer.h"
  25 #include "llvm/Support/Path.h"
  26 #include "llvm/Support/YAMLTraits.h"
  27 #include "llvm/Testing/Support/Error.h"
  28 #include "gtest/gtest.h"
  29
  30 // C includes
  31
  32 // C++ includes
  33 #include <memory>
  34 #include <optional>
  35
  36 using namespace lldb_private;
  37 using namespace minidump;
  38
  39 class MinidumpParserTest : public testing::Test {
  40 public:
  41   SubsystemRAII<FileSystem> subsystems;
  42
  43   void SetUpData(const char *minidump_filename) {
  44     std::string filename = GetInputFilePath(minidump_filename);
  45     auto BufferPtr = FileSystem::Instance().CreateDataBuffer(filename, -1, 0);
  46     ASSERT_NE(BufferPtr, nullptr);
  47     llvm::Expected<MinidumpParser> expected_parser =
  48         MinidumpParser::Create(BufferPtr);
  49     ASSERT_THAT_EXPECTED(expected_parser, llvm::Succeeded());
  50     parser = std::move(*expected_parser);
  51     ASSERT_GT(parser->GetData().size(), 0UL);
  52   }
  53
  54   llvm::Error SetUpFromYaml(llvm::StringRef yaml) {
  55     std::string data;
  56     llvm::raw_string_ostream os(data);
  57     llvm::yaml::Input YIn(yaml);
  58     if (!llvm::yaml::convertYAML(YIn, os, [](const llvm::Twine &Msg) {}))
  59       return llvm::createStringError(llvm::inconvertibleErrorCode(),
  60                                      "convertYAML() failed");
  61
  62     os.flush();
  63     auto data_buffer_sp =
  64         std::make_shared<DataBufferHeap>(data.data(), data.size());
  65     auto expected_parser = MinidumpParser::Create(std::move(data_buffer_sp));
  66     if (!expected_parser)
  67       return expected_parser.takeError();
  68     parser = std::move(*expected_parser);
  69     return llvm::Error::success();
  70   }
  71
  72   std::optional<MinidumpParser> parser;
  73 };
  74
  75 TEST_F(MinidumpParserTest, InvalidMinidump) {
  76   std::string duplicate_streams;
  77   llvm::raw_string_ostream os(duplicate_streams);
  78   llvm::yaml::Input YIn(R"(
  79 --- !minidump
  80 Streams:
  81   - Type:            LinuxAuxv
  82     Content:         DEADBEEFBAADF00D
  83   - Type:            LinuxAuxv
  84     Content:         DEADBEEFBAADF00D
  85   )");
  86
  87   ASSERT_TRUE(llvm::yaml::convertYAML(YIn, os, [](const llvm::Twine &Msg){}));
  88   os.flush();
  89   auto data_buffer_sp = std::make_shared<DataBufferHeap>(
  90       duplicate_streams.data(), duplicate_streams.size());
  91   ASSERT_THAT_EXPECTED(MinidumpParser::Create(data_buffer_sp), llvm::Failed());
  92 }
  93
  94 TEST_F(MinidumpParserTest, GetThreadsAndGetThreadContext) {
  95   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
  96 --- !minidump
  97 Streams:
  98   - Type:            ThreadList
  99     Threads:
 100       - Thread Id:       0x00003E81
 101         Stack:
 102           Start of Memory Range: 0x00007FFCEB34A000
 103           Content:         C84D04BCE97F00
 104         Context:         00000000000000
 105 ...
 106 )"),
 107                     llvm::Succeeded());
 108   llvm::ArrayRef<minidump::Thread> thread_list;
 109
 110   thread_list = parser->GetThreads();
 111   ASSERT_EQ(1UL, thread_list.size());
 112
 113   const minidump::Thread &thread = thread_list[0];
 114
 115   EXPECT_EQ(0x3e81u, thread.ThreadId);
 116
 117   llvm::ArrayRef<uint8_t> context = parser->GetThreadContext(thread);
 118   EXPECT_EQ(7u, context.size());
 119 }
 120
 121 TEST_F(MinidumpParserTest, GetArchitecture) {
 122   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 123 --- !minidump
 124 Streams:
 125   - Type:            SystemInfo
 126     Processor Arch:  AMD64
 127     Processor Level: 6
 128     Processor Revision: 16130
 129     Number of Processors: 1
 130     Platform ID:     Linux
 131     CPU:
 132       Vendor ID:       GenuineIntel
 133       Version Info:    0x00000000
 134       Feature Info:    0x00000000
 135 ...
 136 )"),
 137                     llvm::Succeeded());
 138   ASSERT_EQ(llvm::Triple::ArchType::x86_64,
 139             parser->GetArchitecture().GetMachine());
 140   ASSERT_EQ(llvm::Triple::OSType::Linux,
 141             parser->GetArchitecture().GetTriple().getOS());
 142 }
 143
 144 TEST_F(MinidumpParserTest, GetMiscInfo_no_stream) {
 145   // Test that GetMiscInfo returns nullptr when the minidump does not contain
 146   // this stream.
 147   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 148 --- !minidump
 149 Streams:
 150 ...
 151 )"),
 152                     llvm::Succeeded());
 153   EXPECT_EQ(nullptr, parser->GetMiscInfo());
 154 }
 155
 156 TEST_F(MinidumpParserTest, GetLinuxProcStatus) {
 157   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 158 --- !minidump
 159 Streams:
 160   - Type:            SystemInfo
 161     Processor Arch:  AMD64
 162     Processor Level: 6
 163     Processor Revision: 16130
 164     Number of Processors: 1
 165     Platform ID:     Linux
 166     CSD Version:     'Linux 3.13.0-91-generic'
 167     CPU:
 168       Vendor ID:       GenuineIntel
 169       Version Info:    0x00000000
 170       Feature Info:    0x00000000
 171   - Type:            LinuxProcStatus
 172     Text:             |
 173       Name:     a.out
 174       State:    t (tracing stop)
 175       Tgid:     16001
 176       Ngid:     0
 177       Pid:      16001
 178       PPid:     13243
 179       TracerPid:        16002
 180       Uid:      404696  404696  404696  404696
 181       Gid:      5762    5762    5762    5762
 182 ...
 183 )"),
 184                     llvm::Succeeded());
 185   std::optional<LinuxProcStatus> proc_status = parser->GetLinuxProcStatus();
 186   ASSERT_TRUE(proc_status.has_value());
 187   lldb::pid_t pid = proc_status->GetPid();
 188   ASSERT_EQ(16001UL, pid);
 189 }
 190
 191 TEST_F(MinidumpParserTest, GetPid) {
 192   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 193 --- !minidump
 194 Streams:
 195   - Type:            SystemInfo
 196     Processor Arch:  AMD64
 197     Processor Level: 6
 198     Processor Revision: 16130
 199     Number of Processors: 1
 200     Platform ID:     Linux
 201     CSD Version:     'Linux 3.13.0-91-generic'
 202     CPU:
 203       Vendor ID:       GenuineIntel
 204       Version Info:    0x00000000
 205       Feature Info:    0x00000000
 206   - Type:            LinuxProcStatus
 207     Text:             |
 208       Name:     a.out
 209       State:    t (tracing stop)
 210       Tgid:     16001
 211       Ngid:     0
 212       Pid:      16001
 213       PPid:     13243
 214       TracerPid:        16002
 215       Uid:      404696  404696  404696  404696
 216       Gid:      5762    5762    5762    5762
 217 ...
 218 )"),
 219                     llvm::Succeeded());
 220   std::optional<lldb::pid_t> pid = parser->GetPid();
 221   ASSERT_TRUE(pid.has_value());
 222   ASSERT_EQ(16001UL, *pid);
 223 }
 224
 225 TEST_F(MinidumpParserTest, GetFilteredModuleList) {
 226   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 227 --- !minidump
 228 Streams:
 229   - Type:            ModuleList
 230     Modules:
 231       - Base of Image:   0x0000000000400000
 232         Size of Image:   0x00001000
 233         Module Name:     '/tmp/test/linux-x86_64_not_crashed'
 234         CodeView Record: 4C4570426CCF3F60FFA7CC4B86AE8FF44DB2576A68983611
 235       - Base of Image:   0x0000000000600000
 236         Size of Image:   0x00002000
 237         Module Name:     '/tmp/test/linux-x86_64_not_crashed'
 238         CodeView Record: 4C4570426CCF3F60FFA7CC4B86AE8FF44DB2576A68983611
 239 ...
 240 )"),
 241                     llvm::Succeeded());
 242   llvm::ArrayRef<minidump::Module> modules = parser->GetModuleList();
 243   std::vector<const minidump::Module *> filtered_modules =
 244       parser->GetFilteredModuleList();
 245   EXPECT_EQ(2u, modules.size());
 246   ASSERT_EQ(1u, filtered_modules.size());
 247   const minidump::Module &M = *filtered_modules[0];
 248   EXPECT_THAT_EXPECTED(parser->GetMinidumpFile().getString(M.ModuleNameRVA),
 249                        llvm::HasValue("/tmp/test/linux-x86_64_not_crashed"));
 250 }
 251
 252 TEST_F(MinidumpParserTest, GetExceptionStream) {
 253   SetUpData("linux-x86_64.dmp");
 254   const llvm::minidump::ExceptionStream *exception_stream =
 255       parser->GetExceptionStream();
 256   ASSERT_NE(nullptr, exception_stream);
 257   ASSERT_EQ(11UL, exception_stream->ExceptionRecord.ExceptionCode);
 258 }
 259
 260 void check_mem_range_exists(MinidumpParser &parser, const uint64_t range_start,
 261                             const uint64_t range_size) {
 262   std::optional<minidump::Range> range = parser.FindMemoryRange(range_start);
 263   ASSERT_TRUE(range.has_value()) << "There is no range containing this address";
 264   EXPECT_EQ(range_start, range->start);
 265   EXPECT_EQ(range_start + range_size, range->start + range->range_ref.size());
 266 }
 267
 268 TEST_F(MinidumpParserTest, FindMemoryRange) {
 269   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 270 --- !minidump
 271 Streams:
 272   - Type:            MemoryList
 273     Memory Ranges:
 274       - Start of Memory Range: 0x00007FFCEB34A000
 275         Content:         C84D04BCE9
 276       - Start of Memory Range: 0x0000000000401D46
 277         Content:         5421
 278 ...
 279 )"),
 280                     llvm::Succeeded());
 281   EXPECT_EQ(std::nullopt, parser->FindMemoryRange(0x00));
 282   EXPECT_EQ(std::nullopt, parser->FindMemoryRange(0x2a));
 283   EXPECT_EQ((minidump::Range{0x401d46, llvm::ArrayRef<uint8_t>{0x54, 0x21}}),
 284             parser->FindMemoryRange(0x401d46));
 285   EXPECT_EQ(std::nullopt, parser->FindMemoryRange(0x401d46 + 2));
 286
 287   EXPECT_EQ(
 288       (minidump::Range{0x7ffceb34a000,
 289                        llvm::ArrayRef<uint8_t>{0xc8, 0x4d, 0x04, 0xbc, 0xe9}}),
 290       parser->FindMemoryRange(0x7ffceb34a000 + 2));
 291   EXPECT_EQ(std::nullopt, parser->FindMemoryRange(0x7ffceb34a000 + 5));
 292 }
 293
 294 TEST_F(MinidumpParserTest, GetMemory) {
 295   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 296 --- !minidump
 297 Streams:
 298   - Type:            MemoryList
 299     Memory Ranges:
 300       - Start of Memory Range: 0x00007FFCEB34A000
 301         Content:         C84D04BCE9
 302       - Start of Memory Range: 0x0000000000401D46
 303         Content:         5421
 304 ...
 305 )"),
 306                     llvm::Succeeded());
 307
 308   EXPECT_EQ((llvm::ArrayRef<uint8_t>{0x54}), parser->GetMemory(0x401d46, 1));
 309   EXPECT_EQ((llvm::ArrayRef<uint8_t>{0x54, 0x21}),
 310             parser->GetMemory(0x401d46, 4));
 311
 312   EXPECT_EQ((llvm::ArrayRef<uint8_t>{0xc8, 0x4d, 0x04, 0xbc, 0xe9}),
 313             parser->GetMemory(0x7ffceb34a000, 5));
 314   EXPECT_EQ((llvm::ArrayRef<uint8_t>{0xc8, 0x4d, 0x04}),
 315             parser->GetMemory(0x7ffceb34a000, 3));
 316
 317   EXPECT_EQ(llvm::ArrayRef<uint8_t>(), parser->GetMemory(0x500000, 512));
 318 }
 319
 320 TEST_F(MinidumpParserTest, FindMemoryRangeWithFullMemoryMinidump) {
 321   SetUpData("fizzbuzz_wow64.dmp");
 322
 323   // There are a lot of ranges in the file, just testing with some of them
 324   EXPECT_FALSE(parser->FindMemoryRange(0x00).has_value());
 325   EXPECT_FALSE(parser->FindMemoryRange(0x2a).has_value());
 326   check_mem_range_exists(*parser, 0x10000, 65536); // first range
 327   check_mem_range_exists(*parser, 0x40000, 4096);
 328   EXPECT_FALSE(parser->FindMemoryRange(0x40000 + 4096).has_value());
 329   check_mem_range_exists(*parser, 0x77c12000, 8192);
 330   check_mem_range_exists(*parser, 0x7ffe0000, 4096); // last range
 331   EXPECT_FALSE(parser->FindMemoryRange(0x7ffe0000 + 4096).has_value());
 332 }
 333
 334 constexpr auto yes = MemoryRegionInfo::eYes;
 335 constexpr auto no = MemoryRegionInfo::eNo;
 336 constexpr auto unknown = MemoryRegionInfo::eDontKnow;
 337
 338 TEST_F(MinidumpParserTest, GetMemoryRegionInfo) {
 339   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 340 --- !minidump
 341 Streams:
 342   - Type:            MemoryInfoList
 343     Memory Ranges:
 344       - Base Address:    0x0000000000000000
 345         Allocation Protect: [  ]
 346         Region Size:     0x0000000000010000
 347         State:           [ MEM_FREE ]
 348         Protect:         [ PAGE_NO_ACCESS ]
 349         Type:            [  ]
 350       - Base Address:    0x0000000000010000
 351         Allocation Protect: [ PAGE_READ_WRITE ]
 352         Region Size:     0x0000000000021000
 353         State:           [ MEM_COMMIT ]
 354         Type:            [ MEM_MAPPED ]
 355       - Base Address:    0x0000000000040000
 356         Allocation Protect: [ PAGE_EXECUTE_WRITE_COPY ]
 357         Region Size:     0x0000000000001000
 358         State:           [ MEM_COMMIT ]
 359         Protect:         [ PAGE_READ_ONLY ]
 360         Type:            [ MEM_IMAGE ]
 361       - Base Address:    0x000000007FFE0000
 362         Allocation Protect: [ PAGE_READ_ONLY ]
 363         Region Size:     0x0000000000001000
 364         State:           [ MEM_COMMIT ]
 365         Type:            [ MEM_PRIVATE ]
 366       - Base Address:    0x000000007FFE1000
 367         Allocation Base: 0x000000007FFE0000
 368         Allocation Protect: [ PAGE_READ_ONLY ]
 369         Region Size:     0x000000000000F000
 370         State:           [ MEM_RESERVE ]
 371         Protect:         [ PAGE_NO_ACCESS ]
 372         Type:            [ MEM_PRIVATE ]
 373 ...
 374 )"),
 375                     llvm::Succeeded());
 376
 377   EXPECT_THAT(
 378       parser->BuildMemoryRegions(),
 379       testing::Pair(
 380           testing::ElementsAre(
 381               MemoryRegionInfo({0x0, 0x10000}, no, no, no, unknown, no, ConstString(),
 382                                unknown, 0, unknown, unknown),
 383               MemoryRegionInfo({0x10000, 0x21000}, yes, yes, no, unknown, yes,
 384                                ConstString(), unknown, 0, unknown, unknown),
 385               MemoryRegionInfo({0x40000, 0x1000}, yes, no, no, unknown, yes,
 386                                ConstString(), unknown, 0, unknown, unknown),
 387               MemoryRegionInfo({0x7ffe0000, 0x1000}, yes, no, no, unknown, yes,
 388                                ConstString(), unknown, 0, unknown, unknown),
 389               MemoryRegionInfo({0x7ffe1000, 0xf000}, no, no, no, unknown, yes,
 390                                ConstString(), unknown, 0, unknown, unknown)),
 391           true));
 392 }
 393
 394 TEST_F(MinidumpParserTest, GetMemoryRegionInfoFromMemoryList) {
 395   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 396 --- !minidump
 397 Streams:
 398   - Type:            MemoryList
 399     Memory Ranges:
 400       - Start of Memory Range: 0x0000000000001000
 401         Content:         '31313131313131313131313131313131'
 402       - Start of Memory Range: 0x0000000000002000
 403         Content:         '3333333333333333333333333333333333333333333333333333333333333333'
 404 ...
 405 )"),
 406                     llvm::Succeeded());
 407
 408   // Test we can get memory regions from the MINIDUMP_MEMORY_LIST stream when
 409   // we don't have a MemoryInfoListStream.
 410
 411   EXPECT_THAT(
 412       parser->BuildMemoryRegions(),
 413       testing::Pair(
 414           testing::ElementsAre(
 415               MemoryRegionInfo({0x1000, 0x10}, yes, unknown, unknown, unknown, yes,
 416                                ConstString(), unknown, 0, unknown, unknown),
 417               MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown, unknown, yes,
 418                                ConstString(), unknown, 0, unknown, unknown)),
 419           false));
 420 }
 421
 422 TEST_F(MinidumpParserTest, GetMemoryRegionInfoFromMemory64List) {
 423   SetUpData("regions-memlist64.dmp");
 424
 425   // Test we can get memory regions from the MINIDUMP_MEMORY64_LIST stream when
 426   // we don't have a MemoryInfoListStream.
 427   EXPECT_THAT(
 428       parser->BuildMemoryRegions(),
 429       testing::Pair(
 430           testing::ElementsAre(
 431               MemoryRegionInfo({0x1000, 0x10}, yes, unknown, unknown, unknown, yes,
 432                                ConstString(), unknown, 0, unknown, unknown),
 433               MemoryRegionInfo({0x2000, 0x20}, yes, unknown, unknown, unknown, yes,
 434                                ConstString(), unknown, 0, unknown, unknown)),
 435           false));
 436 }
 437
 438 TEST_F(MinidumpParserTest, GetMemoryRegionInfoLinuxMaps) {
 439   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 440 --- !minidump
 441 Streams:
 442   - Type:            LinuxMaps
 443     Text:             |
 444       400d9000-400db000 r-xp 00000000 b3:04 227        /system/bin/app_process
 445       400db000-400dc000 r--p 00001000 b3:04 227        /system/bin/app_process
 446       400dc000-400dd000 rw-p 00000000 00:00 0
 447       400ec000-400ed000 r--p 00000000 00:00 0
 448       400ee000-400ef000 rw-p 00010000 b3:04 300        /system/bin/linker
 449       400fc000-400fd000 rwxp 00001000 b3:04 1096       /system/lib/liblog.so
 450
 451 ...
 452 )"),
 453                     llvm::Succeeded());
 454   // Test we can get memory regions from the linux /proc/<pid>/maps stream when
 455   // we don't have a MemoryInfoListStream.
 456   ConstString app_process("/system/bin/app_process");
 457   ConstString linker("/system/bin/linker");
 458   ConstString liblog("/system/lib/liblog.so");
 459   EXPECT_THAT(
 460       parser->BuildMemoryRegions(),
 461       testing::Pair(
 462           testing::ElementsAre(
 463               MemoryRegionInfo({0x400d9000, 0x2000}, yes, no, yes, no, yes,
 464                                app_process, unknown, 0, unknown, unknown),
 465               MemoryRegionInfo({0x400db000, 0x1000}, yes, no, no, no, yes,
 466                                app_process, unknown, 0, unknown, unknown),
 467               MemoryRegionInfo({0x400dc000, 0x1000}, yes, yes, no, no, yes,
 468                                ConstString(), unknown, 0, unknown, unknown),
 469               MemoryRegionInfo({0x400ec000, 0x1000}, yes, no, no, no, yes,
 470                                ConstString(), unknown, 0, unknown, unknown),
 471               MemoryRegionInfo({0x400ee000, 0x1000}, yes, yes, no, no, yes, linker,
 472                                unknown, 0, unknown, unknown),
 473               MemoryRegionInfo({0x400fc000, 0x1000}, yes, yes, yes, no, yes, liblog,
 474                                unknown, 0, unknown, unknown)),
 475           true));
 476 }
 477
 478 TEST_F(MinidumpParserTest, GetMemoryRegionInfoLinuxMapsError) {
 479   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 480 --- !minidump
 481 Streams:
 482   - Type:            LinuxMaps
 483     Text:             |
 484       400d9000-400db000 r?xp 00000000 b3:04 227
 485       400fc000-400fd000 rwxp 00001000 b3:04 1096
 486 ...
 487 )"),
 488                     llvm::Succeeded());
 489   // Test that when a /proc/maps region fails to parse
 490   // we handle the error and continue with the rest.
 491   EXPECT_THAT(
 492       parser->BuildMemoryRegions(),
 493       testing::Pair(testing::ElementsAre(MemoryRegionInfo(
 494                         {0x400fc000, 0x1000}, yes, yes, yes, no, yes,
 495                         ConstString(nullptr), unknown, 0, unknown, unknown)),
 496                     true));
 497 }
 498
 499 // Windows Minidump tests
 500 TEST_F(MinidumpParserTest, GetArchitectureWindows) {
 501   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 502 --- !minidump
 503 Streams:
 504   - Type:            SystemInfo
 505     Processor Arch:  X86
 506     Processor Level: 6
 507     Processor Revision: 15876
 508     Number of Processors: 32
 509     Product type:    1
 510     Major Version:   6
 511     Minor Version:   1
 512     Build Number:    7601
 513     Platform ID:     Win32NT
 514     CSD Version:     Service Pack 1
 515     Suite Mask:      0x0100
 516     CPU:
 517       Vendor ID:       GenuineIntel
 518       Version Info:    0x000306E4
 519       Feature Info:    0xBFEBFBFF
 520       AMD Extended Features: 0x771EEC80
 521 ...
 522 )"),
 523                     llvm::Succeeded());
 524   ASSERT_EQ(llvm::Triple::ArchType::x86,
 525             parser->GetArchitecture().GetMachine());
 526   ASSERT_EQ(llvm::Triple::OSType::Win32,
 527             parser->GetArchitecture().GetTriple().getOS());
 528 }
 529
 530 TEST_F(MinidumpParserTest, GetLinuxProcStatus_no_stream) {
 531   // Test that GetLinuxProcStatus returns nullptr when the minidump does not
 532   // contain this stream.
 533   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 534 --- !minidump
 535 Streams:
 536 ...
 537 )"),
 538                     llvm::Succeeded());
 539   EXPECT_EQ(std::nullopt, parser->GetLinuxProcStatus());
 540 }
 541
 542 TEST_F(MinidumpParserTest, GetMiscInfoWindows) {
 543   SetUpData("fizzbuzz_no_heap.dmp");
 544   const MinidumpMiscInfo *misc_info = parser->GetMiscInfo();
 545   ASSERT_NE(nullptr, misc_info);
 546   std::optional<lldb::pid_t> pid = misc_info->GetPid();
 547   ASSERT_TRUE(pid.has_value());
 548   ASSERT_EQ(4440UL, *pid);
 549 }
 550
 551 TEST_F(MinidumpParserTest, GetPidWindows) {
 552   SetUpData("fizzbuzz_no_heap.dmp");
 553   std::optional<lldb::pid_t> pid = parser->GetPid();
 554   ASSERT_TRUE(pid.has_value());
 555   ASSERT_EQ(4440UL, *pid);
 556 }
 557
 558 // wow64
 559 TEST_F(MinidumpParserTest, GetPidWow64) {
 560   SetUpData("fizzbuzz_wow64.dmp");
 561   std::optional<lldb::pid_t> pid = parser->GetPid();
 562   ASSERT_TRUE(pid.has_value());
 563   ASSERT_EQ(7836UL, *pid);
 564 }
 565
 566 // Register tests
 567 #define REG_VAL32(x) *(reinterpret_cast<uint32_t *>(x))
 568 #define REG_VAL64(x) *(reinterpret_cast<uint64_t *>(x))
 569
 570 TEST_F(MinidumpParserTest, GetThreadContext_x86_32) {
 571   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 572 --- !minidump
 573 Streams:
 574   - Type:            ThreadList
 575     Threads:
 576       - Thread Id:       0x00026804
 577         Stack:
 578           Start of Memory Range: 0x00000000FF9DD000
 579           Content:         68D39DFF
 580         Context:         0F0001000000000000000000000000000000000000000000000000007F03FFFF0000FFFFFFFFFFFF09DC62F72300000088E36CF72B00FFFF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000063000000000000002B0000002B000000A88204085CD59DFF008077F7A3D49DFF01000000000000003CD59DFFA082040823000000820201002CD59DFF2B0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 581 )"),
 582                     llvm::Succeeded());
 583
 584   llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads();
 585   const minidump::Thread &thread = thread_list[0];
 586   llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread));
 587   const MinidumpContext_x86_32 *context;
 588   EXPECT_TRUE(consumeObject(registers, context).Success());
 589
 590   EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)),
 591             MinidumpContext_x86_32_Flags::x86_32_Flag |
 592                 MinidumpContext_x86_32_Flags::Full |
 593                 MinidumpContext_x86_32_Flags::FloatingPoint);
 594
 595   EXPECT_EQ(0x00000000u, context->eax);
 596   EXPECT_EQ(0xf7778000u, context->ebx);
 597   EXPECT_EQ(0x00000001u, context->ecx);
 598   EXPECT_EQ(0xff9dd4a3u, context->edx);
 599   EXPECT_EQ(0x080482a8u, context->edi);
 600   EXPECT_EQ(0xff9dd55cu, context->esi);
 601   EXPECT_EQ(0xff9dd53cu, context->ebp);
 602   EXPECT_EQ(0xff9dd52cu, context->esp);
 603   EXPECT_EQ(0x080482a0u, context->eip);
 604   EXPECT_EQ(0x00010282u, context->eflags);
 605   EXPECT_EQ(0x0023u, context->cs);
 606   EXPECT_EQ(0x0000u, context->fs);
 607   EXPECT_EQ(0x0063u, context->gs);
 608   EXPECT_EQ(0x002bu, context->ss);
 609   EXPECT_EQ(0x002bu, context->ds);
 610   EXPECT_EQ(0x002bu, context->es);
 611 }
 612
 613 TEST_F(MinidumpParserTest, GetThreadContext_x86_64) {
 614   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 615 --- !minidump
 616 Streams:
 617   - Type:            ThreadList
 618     Threads:
 619       - Thread Id:       0x00003E81
 620         Stack:
 621           Start of Memory Range: 0x00007FFCEB34A000
 622           Content:         C84D04BCE97F00
 623         Context:         0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B0010000000000033000000000000000000000006020100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000010A234EBFC7F000010A234EBFC7F00000000000000000000F09C34EBFC7F0000C0A91ABCE97F00000000000000000000A0163FBCE97F00004602000000000000921C40000000000030A434EBFC7F000000000000000000000000000000000000C61D4000000000007F0300000000000000000000000000000000000000000000801F0000FFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFF00FFFFFFFFFFFFFF00FFFFFFFF25252525252525252525252525252525000000000000000000000000000000000000000000000000000000000000000000FFFF00FFFFFFFFFFFFFF00FFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 624 ...
 625 )"),
 626                     llvm::Succeeded());
 627   llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads();
 628   const minidump::Thread &thread = thread_list[0];
 629   llvm::ArrayRef<uint8_t> registers(parser->GetThreadContext(thread));
 630   const MinidumpContext_x86_64 *context;
 631   EXPECT_TRUE(consumeObject(registers, context).Success());
 632
 633   EXPECT_EQ(MinidumpContext_x86_64_Flags(uint32_t(context->context_flags)),
 634             MinidumpContext_x86_64_Flags::x86_64_Flag |
 635                 MinidumpContext_x86_64_Flags::Control |
 636                 MinidumpContext_x86_64_Flags::FloatingPoint |
 637                 MinidumpContext_x86_64_Flags::Integer);
 638   EXPECT_EQ(0x0000000000000000u, context->rax);
 639   EXPECT_EQ(0x0000000000000000u, context->rbx);
 640   EXPECT_EQ(0x0000000000000010u, context->rcx);
 641   EXPECT_EQ(0x0000000000000000u, context->rdx);
 642   EXPECT_EQ(0x00007ffceb349cf0u, context->rdi);
 643   EXPECT_EQ(0x0000000000000000u, context->rsi);
 644   EXPECT_EQ(0x00007ffceb34a210u, context->rbp);
 645   EXPECT_EQ(0x00007ffceb34a210u, context->rsp);
 646   EXPECT_EQ(0x00007fe9bc1aa9c0u, context->r8);
 647   EXPECT_EQ(0x0000000000000000u, context->r9);
 648   EXPECT_EQ(0x00007fe9bc3f16a0u, context->r10);
 649   EXPECT_EQ(0x0000000000000246u, context->r11);
 650   EXPECT_EQ(0x0000000000401c92u, context->r12);
 651   EXPECT_EQ(0x00007ffceb34a430u, context->r13);
 652   EXPECT_EQ(0x0000000000000000u, context->r14);
 653   EXPECT_EQ(0x0000000000000000u, context->r15);
 654   EXPECT_EQ(0x0000000000401dc6u, context->rip);
 655   EXPECT_EQ(0x00010206u, context->eflags);
 656   EXPECT_EQ(0x0033u, context->cs);
 657   EXPECT_EQ(0x0000u, context->ss);
 658 }
 659
 660 TEST_F(MinidumpParserTest, GetThreadContext_x86_32_wow64) {
 661   SetUpData("fizzbuzz_wow64.dmp");
 662   llvm::ArrayRef<minidump::Thread> thread_list = parser->GetThreads();
 663   const minidump::Thread &thread = thread_list[0];
 664   llvm::ArrayRef<uint8_t> registers(parser->GetThreadContextWow64(thread));
 665   const MinidumpContext_x86_32 *context;
 666   EXPECT_TRUE(consumeObject(registers, context).Success());
 667
 668   EXPECT_EQ(MinidumpContext_x86_32_Flags(uint32_t(context->context_flags)),
 669             MinidumpContext_x86_32_Flags::x86_32_Flag |
 670                 MinidumpContext_x86_32_Flags::Full |
 671                 MinidumpContext_x86_32_Flags::FloatingPoint |
 672                 MinidumpContext_x86_32_Flags::ExtendedRegisters);
 673
 674   EXPECT_EQ(0x00000000u, context->eax);
 675   EXPECT_EQ(0x0037f608u, context->ebx);
 676   EXPECT_EQ(0x00e61578u, context->ecx);
 677   EXPECT_EQ(0x00000008u, context->edx);
 678   EXPECT_EQ(0x00000000u, context->edi);
 679   EXPECT_EQ(0x00000002u, context->esi);
 680   EXPECT_EQ(0x0037f654u, context->ebp);
 681   EXPECT_EQ(0x0037f5b8u, context->esp);
 682   EXPECT_EQ(0x77ce01fdu, context->eip);
 683   EXPECT_EQ(0x00000246u, context->eflags);
 684   EXPECT_EQ(0x0023u, context->cs);
 685   EXPECT_EQ(0x0053u, context->fs);
 686   EXPECT_EQ(0x002bu, context->gs);
 687   EXPECT_EQ(0x002bu, context->ss);
 688   EXPECT_EQ(0x002bu, context->ds);
 689   EXPECT_EQ(0x002bu, context->es);
 690 }
 691
 692 TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMinAddress) {
 693   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 694 --- !minidump
 695 Streams:
 696   - Type:            ModuleList
 697     Modules:
 698       - Base of Image:   0x0000000000002000
 699         Size of Image:   0x00001000
 700         Module Name:     '/tmp/a'
 701         CodeView Record: ''
 702       - Base of Image:   0x0000000000001000
 703         Size of Image:   0x00001000
 704         Module Name:     '/tmp/a'
 705         CodeView Record: ''
 706 ...
 707 )"),
 708                     llvm::Succeeded());
 709   // If we have a module mentioned twice in the module list, the filtered
 710   // module list should contain the instance with the lowest BaseOfImage.
 711   std::vector<const minidump::Module *> filtered_modules =
 712       parser->GetFilteredModuleList();
 713   ASSERT_EQ(1u, filtered_modules.size());
 714   EXPECT_EQ(0x0000000000001000u, filtered_modules[0]->BaseOfImage);
 715 }
 716
 717 TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedFirst) {
 718   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 719 --- !minidump
 720 Streams:
 721   - Type:            ModuleList
 722     Modules:
 723       - Base of Image:   0x400d0000
 724         Size of Image:   0x00002000
 725         Module Name:     '/usr/lib/libc.so'
 726         CodeView Record: ''
 727       - Base of Image:   0x400d3000
 728         Size of Image:   0x00001000
 729         Module Name:     '/usr/lib/libc.so'
 730         CodeView Record: ''
 731   - Type:            LinuxMaps
 732     Text:             |
 733       400d0000-400d2000 r--p 00000000 b3:04 227        /usr/lib/libc.so
 734       400d2000-400d3000 rw-p 00000000 00:00 0
 735       400d3000-400d4000 r-xp 00010000 b3:04 227        /usr/lib/libc.so
 736       400d4000-400d5000 rwxp 00001000 b3:04 227        /usr/lib/libc.so
 737 ...
 738 )"),
 739                     llvm::Succeeded());
 740   // If we have a module mentioned twice in the module list, and we have full
 741   // linux maps for all of the memory regions, make sure we pick the one that
 742   // has a consecutive region with a matching path that has executable
 743   // permissions. If clients open an object file with mmap, breakpad can create
 744   // multiple mappings for a library errnoneously and the lowest address isn't
 745   // always the right address. In this case we check the consective memory
 746   // regions whose path matches starting at the base of image address and make
 747   // sure one of the regions is executable and prefer that one.
 748   //
 749   // This test will make sure that if the executable is second in the module
 750   // list, that it will become the selected module in the filtered list.
 751   std::vector<const minidump::Module *> filtered_modules =
 752       parser->GetFilteredModuleList();
 753   ASSERT_EQ(1u, filtered_modules.size());
 754   EXPECT_EQ(0x400d3000u, filtered_modules[0]->BaseOfImage);
 755 }
 756
 757 TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedSecond) {
 758   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 759 --- !minidump
 760 Streams:
 761   - Type:            ModuleList
 762     Modules:
 763       - Base of Image:   0x400d0000
 764         Size of Image:   0x00002000
 765         Module Name:     '/usr/lib/libc.so'
 766         CodeView Record: ''
 767       - Base of Image:   0x400d3000
 768         Size of Image:   0x00001000
 769         Module Name:     '/usr/lib/libc.so'
 770         CodeView Record: ''
 771   - Type:            LinuxMaps
 772     Text:             |
 773       400d0000-400d1000 r-xp 00010000 b3:04 227        /usr/lib/libc.so
 774       400d1000-400d2000 rwxp 00001000 b3:04 227        /usr/lib/libc.so
 775       400d2000-400d3000 rw-p 00000000 00:00 0
 776       400d3000-400d5000 r--p 00000000 b3:04 227        /usr/lib/libc.so
 777 ...
 778 )"),
 779                     llvm::Succeeded());
 780   // If we have a module mentioned twice in the module list, and we have full
 781   // linux maps for all of the memory regions, make sure we pick the one that
 782   // has a consecutive region with a matching path that has executable
 783   // permissions. If clients open an object file with mmap, breakpad can create
 784   // multiple mappings for a library errnoneously and the lowest address isn't
 785   // always the right address. In this case we check the consective memory
 786   // regions whose path matches starting at the base of image address and make
 787   // sure one of the regions is executable and prefer that one.
 788   //
 789   // This test will make sure that if the executable is first in the module
 790   // list, that it will remain the correctly selected module in the filtered
 791   // list.
 792   std::vector<const minidump::Module *> filtered_modules =
 793       parser->GetFilteredModuleList();
 794   ASSERT_EQ(1u, filtered_modules.size());
 795   EXPECT_EQ(0x400d0000u, filtered_modules[0]->BaseOfImage);
 796 }
 797
 798 TEST_F(MinidumpParserTest, MinidumpDuplicateModuleMappedSecondHigh) {
 799   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 800 --- !minidump
 801 Streams:
 802   - Type:            ModuleList
 803     Modules:
 804       - Base of Image:   0x400d3000
 805         Size of Image:   0x00002000
 806         Module Name:     '/usr/lib/libc.so'
 807         CodeView Record: ''
 808       - Base of Image:   0x400d0000
 809         Size of Image:   0x00001000
 810         Module Name:     '/usr/lib/libc.so'
 811         CodeView Record: ''
 812   - Type:            LinuxMaps
 813     Text:             |
 814       400d0000-400d2000 r--p 00000000 b3:04 227        /usr/lib/libc.so
 815       400d2000-400d3000 rw-p 00000000 00:00 0
 816       400d3000-400d4000 r-xp 00010000 b3:04 227        /usr/lib/libc.so
 817       400d4000-400d5000 rwxp 00001000 b3:04 227        /usr/lib/libc.so
 818 ...
 819 )"),
 820                     llvm::Succeeded());
 821   // If we have a module mentioned twice in the module list, and we have full
 822   // linux maps for all of the memory regions, make sure we pick the one that
 823   // has a consecutive region with a matching path that has executable
 824   // permissions. If clients open an object file with mmap, breakpad can create
 825   // multiple mappings for a library errnoneously and the lowest address isn't
 826   // always the right address. In this case we check the consective memory
 827   // regions whose path matches starting at the base of image address and make
 828   // sure one of the regions is executable and prefer that one.
 829   //
 830   // This test will make sure that if the executable is first in the module
 831   // list, that it will remain the correctly selected module in the filtered
 832   // list, even if the non-executable module was loaded at a lower base address.
 833   std::vector<const minidump::Module *> filtered_modules =
 834       parser->GetFilteredModuleList();
 835   ASSERT_EQ(1u, filtered_modules.size());
 836   EXPECT_EQ(0x400d3000u, filtered_modules[0]->BaseOfImage);
 837 }
 838
 839 TEST_F(MinidumpParserTest, MinidumpDuplicateModuleSeparateCode) {
 840   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 841 --- !minidump
 842 Streams:
 843   - Type:            ModuleList
 844     Modules:
 845       - Base of Image:   0x400d0000
 846         Size of Image:   0x00002000
 847         Module Name:     '/usr/lib/libc.so'
 848         CodeView Record: ''
 849       - Base of Image:   0x400d5000
 850         Size of Image:   0x00001000
 851         Module Name:     '/usr/lib/libc.so'
 852         CodeView Record: ''
 853   - Type:            LinuxMaps
 854     Text:             |
 855       400d0000-400d3000 r--p 00000000 b3:04 227        /usr/lib/libc.so
 856       400d3000-400d5000 rw-p 00000000 00:00 0
 857       400d5000-400d6000 r--p 00000000 b3:04 227        /usr/lib/libc.so
 858       400d6000-400d7000 r-xp 00010000 b3:04 227        /usr/lib/libc.so
 859       400d7000-400d8000 rwxp 00001000 b3:04 227        /usr/lib/libc.so
 860 ...
 861 )"),
 862                     llvm::Succeeded());
 863   // If we have a module mentioned twice in the module list, and we have full
 864   // linux maps for all of the memory regions, make sure we pick the one that
 865   // has a consecutive region with a matching path that has executable
 866   // permissions. If clients open an object file with mmap, breakpad can create
 867   // multiple mappings for a library errnoneously and the lowest address isn't
 868   // always the right address. In this case we check the consective memory
 869   // regions whose path matches starting at the base of image address and make
 870   // sure one of the regions is executable and prefer that one.
 871   //
 872   // This test will make sure if binaries are compiled with "-z separate-code",
 873   // where the first region for a binary won't be marked as executable, that
 874   // it gets selected by detecting the second consecutive mapping at 0x400d7000
 875   // when asked about the a module mamed "/usr/lib/libc.so" at 0x400d5000.
 876   std::vector<const minidump::Module *> filtered_modules =
 877       parser->GetFilteredModuleList();
 878   ASSERT_EQ(1u, filtered_modules.size());
 879   EXPECT_EQ(0x400d5000u, filtered_modules[0]->BaseOfImage);
 880 }
 881
 882 TEST_F(MinidumpParserTest, MinidumpModuleOrder) {
 883   ASSERT_THAT_ERROR(SetUpFromYaml(R"(
 884 --- !minidump
 885 Streams:
 886   - Type:            ModuleList
 887     Modules:
 888       - Base of Image:   0x0000000000002000
 889         Size of Image:   0x00001000
 890         Module Name:     '/tmp/a'
 891         CodeView Record: ''
 892       - Base of Image:   0x0000000000001000
 893         Size of Image:   0x00001000
 894         Module Name:     '/tmp/b'
 895         CodeView Record: ''
 896 ...
 897 )"),
 898                     llvm::Succeeded());
 899   // Test module filtering does not affect the overall module order.  Previous
 900   // versions of the MinidumpParser::GetFilteredModuleList() function would sort
 901   // all images by address and modify the order of the modules.
 902   std::vector<const minidump::Module *> filtered_modules =
 903       parser->GetFilteredModuleList();
 904   ASSERT_EQ(2u, filtered_modules.size());
 905   EXPECT_EQ(0x0000000000002000u, filtered_modules[0]->BaseOfImage);
 906   EXPECT_THAT_EXPECTED(
 907       parser->GetMinidumpFile().getString(filtered_modules[0]->ModuleNameRVA),
 908       llvm::HasValue("/tmp/a"));
 909   EXPECT_EQ(0x0000000000001000u, filtered_modules[1]->BaseOfImage);
 910   EXPECT_THAT_EXPECTED(
 911       parser->GetMinidumpFile().getString(filtered_modules[1]->ModuleNameRVA),
 912       llvm::HasValue("/tmp/b"));
 913 }