1 //===- MinidumpYAMLTest.cpp - Tests for Minidump<->YAML code --------------===//
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 "llvm/Object/Minidump.h"
10 #include "llvm/ObjectYAML/yaml2obj.h"
11 #include "llvm/Support/YAMLTraits.h"
12 #include "llvm/Testing/Support/Error.h"
13 #include "gtest/gtest.h"
14 
15 using namespace llvm;
16 using namespace llvm::minidump;
17 
18 static Expected<std::unique_ptr<object::MinidumpFile>>
19 toBinary(SmallVectorImpl<char> &Storage, StringRef Yaml) {
20   Storage.clear();
21   raw_svector_ostream OS(Storage);
22   yaml::Input YIn(Yaml);
23   if (!yaml::convertYAML(YIn, OS, [](const Twine &Msg) {}))
24     return createStringError(std::errc::invalid_argument,
25                              "unable to convert YAML");
26 
27   return object::MinidumpFile::create(MemoryBufferRef(OS.str(), "Binary"));
28 }
29 
30 TEST(MinidumpYAML, Basic) {
31   SmallString<0> Storage;
32   auto ExpectedFile = toBinary(Storage, R"(
33 --- !minidump
34 Streams:
35   - Type:            SystemInfo
36     Processor Arch:  ARM64
37     Platform ID:     Linux
38     CPU:
39       CPUID:           0x05060708
40   - Type:            LinuxMaps
41     Text:             |
42       400d9000-400db000 r-xp 00000000 b3:04 227        /system/bin/app_process
43       400db000-400dc000 r--p 00001000 b3:04 227        /system/bin/app_process
44 
45   - Type:            LinuxAuxv
46     Content:         DEADBEEFBAADF00D)");
47   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
48   object::MinidumpFile &File = **ExpectedFile;
49 
50   ASSERT_EQ(3u, File.streams().size());
51 
52   EXPECT_EQ(StreamType::SystemInfo, File.streams()[0].Type);
53   auto ExpectedSysInfo = File.getSystemInfo();
54   ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
55   const SystemInfo &SysInfo = *ExpectedSysInfo;
56   EXPECT_EQ(ProcessorArchitecture::ARM64, SysInfo.ProcessorArch);
57   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
58   EXPECT_EQ(0x05060708u, SysInfo.CPU.Arm.CPUID);
59 
60   EXPECT_EQ(StreamType::LinuxMaps, File.streams()[1].Type);
61   EXPECT_EQ("400d9000-400db000 r-xp 00000000 b3:04 227        "
62             "/system/bin/app_process\n"
63             "400db000-400dc000 r--p 00001000 b3:04 227        "
64             "/system/bin/app_process\n",
65             toStringRef(*File.getRawStream(StreamType::LinuxMaps)));
66 
67   EXPECT_EQ(StreamType::LinuxAuxv, File.streams()[2].Type);
68   EXPECT_EQ((ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D}),
69             File.getRawStream(StreamType::LinuxAuxv));
70 }
71 
72 TEST(MinidumpYAML, RawContent) {
73   SmallString<0> Storage;
74   auto ExpectedFile = toBinary(Storage, R"(
75 --- !minidump
76 Streams:
77   - Type:            LinuxAuxv
78     Size:            9
79     Content:         DEADBEEFBAADF00D)");
80   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
81   object::MinidumpFile &File = **ExpectedFile;
82 
83   EXPECT_EQ(
84       (ArrayRef<uint8_t>{0xDE, 0xAD, 0xBE, 0xEF, 0xBA, 0xAD, 0xF0, 0x0D, 0x00}),
85       File.getRawStream(StreamType::LinuxAuxv));
86 }
87 
88 TEST(MinidumpYAML, X86SystemInfo) {
89   SmallString<0> Storage;
90   auto ExpectedFile = toBinary(Storage, R"(
91 --- !minidump
92 Streams:
93   - Type:            SystemInfo
94     Processor Arch:  X86
95     Platform ID:     Linux
96     CPU:
97       Vendor ID:       LLVMLLVMLLVM
98       Version Info:    0x01020304
99       Feature Info:    0x05060708
100       AMD Extended Features: 0x09000102)");
101   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
102   object::MinidumpFile &File = **ExpectedFile;
103 
104   ASSERT_EQ(1u, File.streams().size());
105 
106   auto ExpectedSysInfo = File.getSystemInfo();
107   ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
108   const SystemInfo &SysInfo = *ExpectedSysInfo;
109   EXPECT_EQ(ProcessorArchitecture::X86, SysInfo.ProcessorArch);
110   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
111   EXPECT_EQ("LLVMLLVMLLVM", StringRef(SysInfo.CPU.X86.VendorID,
112                                       sizeof(SysInfo.CPU.X86.VendorID)));
113   EXPECT_EQ(0x01020304u, SysInfo.CPU.X86.VersionInfo);
114   EXPECT_EQ(0x05060708u, SysInfo.CPU.X86.FeatureInfo);
115   EXPECT_EQ(0x09000102u, SysInfo.CPU.X86.AMDExtendedFeatures);
116 }
117 
118 TEST(MinidumpYAML, OtherSystemInfo) {
119   SmallString<0> Storage;
120   auto ExpectedFile = toBinary(Storage, R"(
121 --- !minidump
122 Streams:
123   - Type:            SystemInfo
124     Processor Arch:  PPC
125     Platform ID:     Linux
126     CPU:
127       Features:        000102030405060708090a0b0c0d0e0f)");
128   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
129   object::MinidumpFile &File = **ExpectedFile;
130 
131   ASSERT_EQ(1u, File.streams().size());
132 
133   auto ExpectedSysInfo = File.getSystemInfo();
134   ASSERT_THAT_EXPECTED(ExpectedSysInfo, Succeeded());
135   const SystemInfo &SysInfo = *ExpectedSysInfo;
136   EXPECT_EQ(ProcessorArchitecture::PPC, SysInfo.ProcessorArch);
137   EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId);
138   EXPECT_EQ(
139       (ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
140       makeArrayRef(SysInfo.CPU.Other.ProcessorFeatures));
141 }
142 
143 // Test that we can parse a normal-looking ExceptionStream.
144 TEST(MinidumpYAML, ExceptionStream) {
145   SmallString<0> Storage;
146   auto ExpectedFile = toBinary(Storage, R"(
147 --- !minidump
148 Streams:
149   - Type:            Exception
150     Thread ID:  0x7
151     Exception Record:
152       Exception Code:  0x23
153       Exception Flags: 0x5
154       Exception Record: 0x0102030405060708
155       Exception Address: 0x0a0b0c0d0e0f1011
156       Number of Parameters: 2
157       Parameter 0: 0x22
158       Parameter 1: 0x24
159     Thread Context:  3DeadBeefDefacedABadCafe)");
160   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
161   object::MinidumpFile &File = **ExpectedFile;
162 
163   ASSERT_EQ(1u, File.streams().size());
164 
165   Expected<const minidump::ExceptionStream &> ExpectedStream =
166       File.getExceptionStream();
167 
168   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
169 
170   const minidump::ExceptionStream &Stream = *ExpectedStream;
171   EXPECT_EQ(0x7u, Stream.ThreadId);
172   const minidump::Exception &Exception = Stream.ExceptionRecord;
173   EXPECT_EQ(0x23u, Exception.ExceptionCode);
174   EXPECT_EQ(0x5u, Exception.ExceptionFlags);
175   EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
176   EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
177   EXPECT_EQ(2u, Exception.NumberParameters);
178   EXPECT_EQ(0x22u, Exception.ExceptionInformation[0]);
179   EXPECT_EQ(0x24u, Exception.ExceptionInformation[1]);
180 
181   Expected<ArrayRef<uint8_t>> ExpectedContext =
182       File.getRawData(Stream.ThreadContext);
183   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
184   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
185                                0xab, 0xad, 0xca, 0xfe}),
186             *ExpectedContext);
187 }
188 
189 // Test that we can parse an exception stream with no ExceptionInformation.
190 TEST(MinidumpYAML, ExceptionStream_NoParameters) {
191   SmallString<0> Storage;
192   auto ExpectedFile = toBinary(Storage, R"(
193 --- !minidump
194 Streams:
195   - Type:            Exception
196     Thread ID:  0x7
197     Exception Record:
198       Exception Code:  0x23
199       Exception Flags: 0x5
200       Exception Record: 0x0102030405060708
201       Exception Address: 0x0a0b0c0d0e0f1011
202     Thread Context:  3DeadBeefDefacedABadCafe)");
203   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
204   object::MinidumpFile &File = **ExpectedFile;
205 
206   ASSERT_EQ(1u, File.streams().size());
207 
208   Expected<const minidump::ExceptionStream &> ExpectedStream =
209       File.getExceptionStream();
210 
211   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
212 
213   const minidump::ExceptionStream &Stream = *ExpectedStream;
214   EXPECT_EQ(0x7u, Stream.ThreadId);
215   const minidump::Exception &Exception = Stream.ExceptionRecord;
216   EXPECT_EQ(0x23u, Exception.ExceptionCode);
217   EXPECT_EQ(0x5u, Exception.ExceptionFlags);
218   EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
219   EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
220   EXPECT_EQ(0u, Exception.NumberParameters);
221 
222   Expected<ArrayRef<uint8_t>> ExpectedContext =
223       File.getRawData(Stream.ThreadContext);
224   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
225   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
226                                0xab, 0xad, 0xca, 0xfe}),
227             *ExpectedContext);
228 }
229 
230 // Test that we can parse an ExceptionStream where the stated number of
231 // parameters is greater than the actual size of the ExceptionInformation
232 // array.
233 TEST(MinidumpYAML, ExceptionStream_TooManyParameters) {
234   SmallString<0> Storage;
235   auto ExpectedFile = toBinary(Storage, R"(
236 --- !minidump
237 Streams:
238   - Type:            Exception
239     Thread ID:  0x8
240     Exception Record:
241       Exception Code: 0
242       Number of Parameters: 16
243       Parameter 0: 0x0
244       Parameter 1: 0xff
245       Parameter 2: 0xee
246       Parameter 3: 0xdd
247       Parameter 4: 0xcc
248       Parameter 5: 0xbb
249       Parameter 6: 0xaa
250       Parameter 7: 0x99
251       Parameter 8: 0x88
252       Parameter 9: 0x77
253       Parameter 10: 0x66
254       Parameter 11: 0x55
255       Parameter 12: 0x44
256       Parameter 13: 0x33
257       Parameter 14: 0x22
258     Thread Context:  3DeadBeefDefacedABadCafe)");
259   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
260   object::MinidumpFile &File = **ExpectedFile;
261 
262   ASSERT_EQ(1u, File.streams().size());
263 
264   Expected<const minidump::ExceptionStream &> ExpectedStream =
265       File.getExceptionStream();
266 
267   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
268 
269   const minidump::ExceptionStream &Stream = *ExpectedStream;
270   EXPECT_EQ(0x8u, Stream.ThreadId);
271   const minidump::Exception &Exception = Stream.ExceptionRecord;
272   EXPECT_EQ(0x0u, Exception.ExceptionCode);
273   EXPECT_EQ(0x0u, Exception.ExceptionFlags);
274   EXPECT_EQ(0x00u, Exception.ExceptionRecord);
275   EXPECT_EQ(0x0u, Exception.ExceptionAddress);
276   EXPECT_EQ(16u, Exception.NumberParameters);
277   EXPECT_EQ(0x0u, Exception.ExceptionInformation[0]);
278   for (int Index = 1; Index < 15; ++Index) {
279     EXPECT_EQ(0x110u - Index * 0x11, Exception.ExceptionInformation[Index]);
280   }
281 
282   Expected<ArrayRef<uint8_t>> ExpectedContext =
283       File.getRawData(Stream.ThreadContext);
284   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
285   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
286                                0xab, 0xad, 0xca, 0xfe}),
287             *ExpectedContext);
288 }
289 
290 // Test that we can parse an ExceptionStream where the number of
291 // ExceptionInformation parameters provided is greater than the
292 // specified Number of Parameters.
293 TEST(MinidumpYAML, ExceptionStream_ExtraParameter) {
294   SmallString<0> Storage;
295   auto ExpectedFile = toBinary(Storage, R"(
296 --- !minidump
297 Streams:
298   - Type:            Exception
299     Thread ID:  0x7
300     Exception Record:
301       Exception Code:  0x23
302       Exception Flags: 0x5
303       Exception Record: 0x0102030405060708
304       Exception Address: 0x0a0b0c0d0e0f1011
305       Number of Parameters: 2
306       Parameter 0: 0x99
307       Parameter 1: 0x23
308       Parameter 2: 0x42
309     Thread Context:  3DeadBeefDefacedABadCafe)");
310   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
311   object::MinidumpFile &File = **ExpectedFile;
312 
313   ASSERT_EQ(1u, File.streams().size());
314 
315   Expected<const minidump::ExceptionStream &> ExpectedStream =
316       File.getExceptionStream();
317 
318   ASSERT_THAT_EXPECTED(ExpectedStream, Succeeded());
319 
320   const minidump::ExceptionStream &Stream = *ExpectedStream;
321   EXPECT_EQ(0x7u, Stream.ThreadId);
322   const minidump::Exception &Exception = Stream.ExceptionRecord;
323   EXPECT_EQ(0x23u, Exception.ExceptionCode);
324   EXPECT_EQ(0x5u, Exception.ExceptionFlags);
325   EXPECT_EQ(0x0102030405060708u, Exception.ExceptionRecord);
326   EXPECT_EQ(0x0a0b0c0d0e0f1011u, Exception.ExceptionAddress);
327   EXPECT_EQ(2u, Exception.NumberParameters);
328   EXPECT_EQ(0x99u, Exception.ExceptionInformation[0]);
329   EXPECT_EQ(0x23u, Exception.ExceptionInformation[1]);
330   EXPECT_EQ(0x42u, Exception.ExceptionInformation[2]);
331 
332   Expected<ArrayRef<uint8_t>> ExpectedContext =
333       File.getRawData(Stream.ThreadContext);
334   ASSERT_THAT_EXPECTED(ExpectedContext, Succeeded());
335   EXPECT_EQ((ArrayRef<uint8_t>{0x3d, 0xea, 0xdb, 0xee, 0xfd, 0xef, 0xac, 0xed,
336                                0xab, 0xad, 0xca, 0xfe}),
337             *ExpectedContext);
338 }
339