OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity
llvm-project/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp

339 lines
12 KiB
C++
Raw Blame History

//===- MinidumpYAMLTest.cpp - Tests for Minidump<->YAML code --------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/Object/Minidump.h"
#include "llvm/ObjectYAML/yaml2obj.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"
using namespace llvm;
using namespace llvm::minidump;
static Expected<std::unique_ptr<object::MinidumpFile>>
toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
Storage.clear();
raw_svector_ostream OS(Storage);
yaml::Input YIn(Yaml);
if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
return createStringError(std::errc::invalid_argument,
"unable to convert YAML");
return object::MinidumpFile::create(MemoryBufferRef(OS.str(), "Binary"));
}
TEST(MinidumpYAML, Basic) {
SmallString<0> Storage;
auto ExpectedFile = toBinary(Storage, R"(
--- !minidump
Streams:
- Type: SystemInfo
Processor Arch: ARM64
Platform ID: Linux
CPU:
CPUID: 0x05060708
- Type: LinuxMaps
Text: |
400d9000-400db000 r-xp 00000000 b3:04 227 /system/bin/app_process
400db000-400dc000 r--p 00001000 b3:04 227 /system/bin/app_process
- Type: LinuxAuxv
Content: DEADBEEFBAADF00D)");
ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
object::MinidumpFile &File = **ExpectedFile;
ASSERT_EQ(3u, File.streams().size());
EXPECT_EQ(StreamType::SystemInfo, File.streams()[0].Type);
auto ExpectedSysInfo = File.getSystemInfo();
ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
const SystemInfo &SysInfo = *ExpectedSysInfo;
EXPECT_EQ(ProcessorArchitecture::ARM64, SysInfo.ProcessorArch);
EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
EXPECT_EQ(0x05060708u, SysInfo.CPU.Arm.CPUID);
EXPECT_EQ(StreamType::LinuxMaps, File.streams()[1].Type);
EXPECT_EQ("400d9000-400db000 r-xp 00000000 b3:04 227 "
"/system/bin/app_process\n"
"400db000-400dc000 r--p 00001000 b3:04 227 "
"/system/bin/app_process\n",
toStringRef(*File.getRawStream(StreamType::LinuxMaps)));
EXPECT_EQ(StreamType::LinuxAuxv, File.streams()[2].Type);
EXPECT_EQ((ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D}),
File.getRawStream(StreamType::LinuxAuxv));
}
TEST(MinidumpYAML, RawContent) {
SmallString<0> Storage;
auto ExpectedFile = toBinary(Storage, R"(
--- !minidump
Streams:
- Type: LinuxAuxv
Size: 9
Content: DEADBEEFBAADF00D)");
ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
object::MinidumpFile &File = **ExpectedFile;
EXPECT_EQ(
(ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D, 0x00}),
File.getRawStream(StreamType::LinuxAuxv));
}
TEST(MinidumpYAML, X86SystemInfo) {
SmallString<0> Storage;
auto ExpectedFile = toBinary(Storage, R"(
--- !minidump
Streams:
- Type: SystemInfo
Processor Arch: X86
Platform ID: Linux
CPU:
Vendor ID: LLVMLLVMLLVM
Version Info: 0x01020304
Feature Info: 0x05060708
AMD Extended Features: 0x09000102)");
ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
object::MinidumpFile &File = **ExpectedFile;
ASSERT_EQ(1u, File.streams().size());
auto ExpectedSysInfo = File.getSystemInfo();
ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
const SystemInfo &SysInfo = *ExpectedSysInfo;
EXPECT_EQ(ProcessorArchitecture::X86, SysInfo.ProcessorArch);
EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
EXPECT_EQ("LLVMLLVMLLVM", StringRef(SysInfo.CPU.X86.VendorID,
sizeof(SysInfo.CPU.X86.VendorID)));
EXPECT_EQ(0x01020304u, SysInfo.CPU.X86.VersionInfo);
EXPECT_EQ(0x05060708u, SysInfo.CPU.X86.FeatureInfo);
EXPECT_EQ(0x09000102u, SysInfo.CPU.X86.AMDExtendedFeatures);
}
TEST(MinidumpYAML, OtherSystemInfo) {
SmallString<0> Storage;
auto ExpectedFile = toBinary(Storage, R"(
--- !minidump
Streams:
- Type: SystemInfo
Processor Arch: PPC
Platform ID: Linux
CPU:
Features: 000102030405060708090a0b0c0d0e0f)");
ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
object::MinidumpFile &File = **ExpectedFile;
ASSERT_EQ(1u, File.streams().size());
auto ExpectedSysInfo = File.getSystemInfo();
ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
const SystemInfo &SysInfo = *ExpectedSysInfo;
EXPECT_EQ(ProcessorArchitecture::PPC, SysInfo.ProcessorArch);
EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
EXPECT_EQ(
(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);
}
Reference in New Issue View Git Blame Copy Permalink