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, Out&: OS, ErrHandler: [](const Twine &Msg) {})) |
24 | return createStringError(EC: std::errc::invalid_argument, |
25 | Fmt: "unable to convert YAML" ); |
26 | |
27 | return object::MinidumpFile::create(Source: MemoryBufferRef(OS.str(), "Binary" )); |
28 | } |
29 | |
30 | TEST(MinidumpYAML, Basic) { |
31 | SmallString<0> Storage; |
32 | auto ExpectedFile = toBinary(Storage, Yaml: 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, Yaml: 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, Yaml: 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, Yaml: 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 | ArrayRef(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, Yaml: 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(Desc: 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, Yaml: 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(Desc: 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, Yaml: 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(Desc: 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, Yaml: 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(Desc: 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 | |