Stream::StreamKind Stream::getKind(StreamType Type) {
switch (Type) {
+ case StreamType::Exception:
+ return StreamKind::Exception;
case StreamType::MemoryInfoList:
return StreamKind::MemoryInfoList;
case StreamType::MemoryList:
std::unique_ptr<Stream> Stream::create(StreamType Type) {
StreamKind Kind = getKind(Type);
switch (Kind) {
+ case StreamKind::Exception:
+ return std::make_unique<ExceptionStream>();
case StreamKind::MemoryInfoList:
return std::make_unique<MemoryInfoListStream>();
case StreamKind::MemoryList:
mapRequiredHex(IO, "Base of Image", M.Entry.BaseOfImage);
mapRequiredHex(IO, "Size of Image", M.Entry.SizeOfImage);
mapOptionalHex(IO, "Checksum", M.Entry.Checksum, 0);
- IO.mapOptional("Time Date Stamp", M.Entry.TimeDateStamp,
- support::ulittle32_t(0));
+ mapOptional(IO, "Time Date Stamp", M.Entry.TimeDateStamp, 0);
IO.mapRequired("Module Name", M.Name);
IO.mapOptional("Version Info", M.Entry.VersionInfo, VSFixedFileInfo());
IO.mapRequired("CodeView Record", M.CvRecord);
IO.mapRequired("Threads", Stream.Entries);
}
+static void streamMapping(yaml::IO &IO, MinidumpYAML::ExceptionStream &Stream) {
+ mapRequiredHex(IO, "Thread ID", Stream.MDExceptionStream.ThreadId);
+ IO.mapRequired("Exception Record", Stream.MDExceptionStream.ExceptionRecord);
+ IO.mapRequired("Thread Context", Stream.ThreadContext);
+}
+
+void yaml::MappingTraits<minidump::Exception>::mapping(
+ yaml::IO &IO, minidump::Exception &Exception) {
+ mapRequiredHex(IO, "Exception Code", Exception.ExceptionCode);
+ mapOptionalHex(IO, "Exception Flags", Exception.ExceptionFlags, 0);
+ mapOptionalHex(IO, "Exception Record", Exception.ExceptionRecord, 0);
+ mapOptionalHex(IO, "Exception Address", Exception.ExceptionAddress, 0);
+ mapOptional(IO, "Number of Parameters", Exception.NumberParameters, 0);
+
+ for (size_t Index = 0; Index < Exception.MaxParameters; ++Index) {
+ SmallString<16> Name("Parameter ");
+ Twine(Index).toVector(Name);
+ support::ulittle64_t &Field = Exception.ExceptionInformation[Index];
+
+ if (Index < Exception.NumberParameters)
+ mapRequiredHex(IO, Name.c_str(), Field);
+ else
+ mapOptionalHex(IO, Name.c_str(), Field, 0);
+ }
+}
+
void yaml::MappingTraits<std::unique_ptr<Stream>>::mapping(
yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
StreamType Type;
if (!IO.outputting())
S = MinidumpYAML::Stream::create(Type);
switch (S->Kind) {
+ case MinidumpYAML::Stream::StreamKind::Exception:
+ streamMapping(IO, llvm::cast<MinidumpYAML::ExceptionStream>(*S));
+ break;
case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
streamMapping(IO, llvm::cast<MemoryInfoListStream>(*S));
break;
switch (S->Kind) {
case MinidumpYAML::Stream::StreamKind::RawContent:
return streamValidate(cast<RawContentStream>(*S));
+ case MinidumpYAML::Stream::StreamKind::Exception:
case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
case MinidumpYAML::Stream::StreamKind::MemoryList:
case MinidumpYAML::Stream::StreamKind::ModuleList:
Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
StreamKind Kind = getKind(StreamDesc.Type);
switch (Kind) {
+ case StreamKind::Exception: {
+ Expected<const minidump::ExceptionStream &> ExpectedExceptionStream =
+ File.getExceptionStream();
+ if (!ExpectedExceptionStream)
+ return ExpectedExceptionStream.takeError();
+ Expected<ArrayRef<uint8_t>> ExpectedThreadContext =
+ File.getRawData(ExpectedExceptionStream->ThreadContext);
+ if (!ExpectedThreadContext)
+ return ExpectedThreadContext.takeError();
+ return std::make_unique<ExceptionStream>(*ExpectedExceptionStream,
+ *ExpectedThreadContext);
+ }
case StreamKind::MemoryInfoList: {
if (auto ExpectedList = File.getMemoryInfoList())
return std::make_unique<MemoryInfoListStream>(*ExpectedList);
(ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
makeArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
}
+
+// Test that we can parse a normal-looking ExceptionStream.
+TEST(MinidumpYAML, ExceptionStream) {
+ SmallString<0> Storage;
+ auto ExpectedFile = toBinary(Storage, R"(
+--- !minidump
+Streams:
+ - Type: Exception
+ Thread ID: 0x7
+ Exception Record:
+ Exception Code: 0x23
+ Exception Flags: 0x5
+ Exception Record: 0x0102030405060708
+ Exception Address: 0x0a0b0c0d0e0f1011
+ Number of Parameters: 2
+ Parameter 0: 0x22
+ Parameter 1: 0x24
+ Thread Context: 3DeadBeefDefacedABadCafe)");
+ ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+ object::MinidumpFile &File = **ExpectedFile;
+
+ ASSERT_EQ(1u, File.streams().size());
+
+ Expected<const minidump::ExceptionStream &> ExpectedStream =
+ File.getExceptionStream();
+
+ ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
+
+ const minidump::ExceptionStream &Stream = *ExpectedStream;
+ EXPECT_EQ(0x7u, Stream.ThreadId);
+ const minidump::Exception &Exception = Stream.ExceptionRecord;
+ EXPECT_EQ(0x23u, Exception.ExceptionCode);
+ EXPECT_EQ(0x5u, Exception.ExceptionFlags);
+ EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
+ EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
+ EXPECT_EQ(2u, Exception.NumberParameters);
+ EXPECT_EQ(0x22u, Exception.ExceptionInformation[0]);
+ EXPECT_EQ(0x24u, Exception.ExceptionInformation[1]);
+
+ Expected<ArrayRef<uint8_t>> ExpectedContext =
+ File.getRawData(Stream.ThreadContext);
+ ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
+ EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
+ 0xab, 0xad, 0xca, 0xfe}),
+ *ExpectedContext);
+}
+
+// Test that we can parse an exception stream with no ExceptionInformation.
+TEST(MinidumpYAML, ExceptionStream_NoParameters) {
+ SmallString<0> Storage;
+ auto ExpectedFile = toBinary(Storage, R"(
+--- !minidump
+Streams:
+ - Type: Exception
+ Thread ID: 0x7
+ Exception Record:
+ Exception Code: 0x23
+ Exception Flags: 0x5
+ Exception Record: 0x0102030405060708
+ Exception Address: 0x0a0b0c0d0e0f1011
+ Thread Context: 3DeadBeefDefacedABadCafe)");
+ ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+ object::MinidumpFile &File = **ExpectedFile;
+
+ ASSERT_EQ(1u, File.streams().size());
+
+ Expected<const minidump::ExceptionStream &> ExpectedStream =
+ File.getExceptionStream();
+
+ ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
+
+ const minidump::ExceptionStream &Stream = *ExpectedStream;
+ EXPECT_EQ(0x7u, Stream.ThreadId);
+ const minidump::Exception &Exception = Stream.ExceptionRecord;
+ EXPECT_EQ(0x23u, Exception.ExceptionCode);
+ EXPECT_EQ(0x5u, Exception.ExceptionFlags);
+ EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
+ EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
+ EXPECT_EQ(0u, Exception.NumberParameters);
+
+ Expected<ArrayRef<uint8_t>> ExpectedContext =
+ File.getRawData(Stream.ThreadContext);
+ ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
+ EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
+ 0xab, 0xad, 0xca, 0xfe}),
+ *ExpectedContext);
+}
+
+// Test that we can parse an ExceptionStream where the stated number of
+// parameters is greater than the actual size of the ExceptionInformation
+// array.
+TEST(MinidumpYAML, ExceptionStream_TooManyParameters) {
+ SmallString<0> Storage;
+ auto ExpectedFile = toBinary(Storage, R"(
+--- !minidump
+Streams:
+ - Type: Exception
+ Thread ID: 0x8
+ Exception Record:
+ Exception Code: 0
+ Number of Parameters: 16
+ Parameter 0: 0x0
+ Parameter 1: 0xff
+ Parameter 2: 0xee
+ Parameter 3: 0xdd
+ Parameter 4: 0xcc
+ Parameter 5: 0xbb
+ Parameter 6: 0xaa
+ Parameter 7: 0x99
+ Parameter 8: 0x88
+ Parameter 9: 0x77
+ Parameter 10: 0x66
+ Parameter 11: 0x55
+ Parameter 12: 0x44
+ Parameter 13: 0x33
+ Parameter 14: 0x22
+ Thread Context: 3DeadBeefDefacedABadCafe)");
+ ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+ object::MinidumpFile &File = **ExpectedFile;
+
+ ASSERT_EQ(1u, File.streams().size());
+
+ Expected<const minidump::ExceptionStream &> ExpectedStream =
+ File.getExceptionStream();
+
+ ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
+
+ const minidump::ExceptionStream &Stream = *ExpectedStream;
+ EXPECT_EQ(0x8u, Stream.ThreadId);
+ const minidump::Exception &Exception = Stream.ExceptionRecord;
+ EXPECT_EQ(0x0u, Exception.ExceptionCode);
+ EXPECT_EQ(0x0u, Exception.ExceptionFlags);
+ EXPECT_EQ(0x00u, Exception.ExceptionRecord);
+ EXPECT_EQ(0x0u, Exception.ExceptionAddress);
+ EXPECT_EQ(16u, Exception.NumberParameters);
+ EXPECT_EQ(0x0u, Exception.ExceptionInformation[0]);
+ for (int Index = 1; Index < 15; ++Index) {
+ EXPECT_EQ(0x110u - Index * 0x11, Exception.ExceptionInformation[Index]);
+ }
+
+ Expected<ArrayRef<uint8_t>> ExpectedContext =
+ File.getRawData(Stream.ThreadContext);
+ ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
+ EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
+ 0xab, 0xad, 0xca, 0xfe}),
+ *ExpectedContext);
+}
+
+// Test that we can parse an ExceptionStream where the number of
+// ExceptionInformation parameters provided is greater than the
+// specified Number of Parameters.
+TEST(MinidumpYAML, ExceptionStream_ExtraParameter) {
+ SmallString<0> Storage;
+ auto ExpectedFile = toBinary(Storage, R"(
+--- !minidump
+Streams:
+ - Type: Exception
+ Thread ID: 0x7
+ Exception Record:
+ Exception Code: 0x23
+ Exception Flags: 0x5
+ Exception Record: 0x0102030405060708
+ Exception Address: 0x0a0b0c0d0e0f1011
+ Number of Parameters: 2
+ Parameter 0: 0x99
+ Parameter 1: 0x23
+ Parameter 2: 0x42
+ Thread Context: 3DeadBeefDefacedABadCafe)");
+ ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+ object::MinidumpFile &File = **ExpectedFile;
+
+ ASSERT_EQ(1u, File.streams().size());
+
+ Expected<const minidump::ExceptionStream &> ExpectedStream =
+ File.getExceptionStream();
+
+ ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
+
+ const minidump::ExceptionStream &Stream = *ExpectedStream;
+ EXPECT_EQ(0x7u, Stream.ThreadId);
+ const minidump::Exception &Exception = Stream.ExceptionRecord;
+ EXPECT_EQ(0x23u, Exception.ExceptionCode);
+ EXPECT_EQ(0x5u, Exception.ExceptionFlags);
+ EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
+ EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
+ EXPECT_EQ(2u, Exception.NumberParameters);
+ EXPECT_EQ(0x99u, Exception.ExceptionInformation[0]);
+ EXPECT_EQ(0x23u, Exception.ExceptionInformation[1]);
+ EXPECT_EQ(0x42u, Exception.ExceptionInformation[2]);
+
+ Expected<ArrayRef<uint8_t>> ExpectedContext =
+ File.getRawData(Stream.ThreadContext);
+ ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
+ EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
+ 0xab, 0xad, 0xca, 0xfe}),
+ *ExpectedContext);
+}
projects / llvm / commitdiff