1 //===- llvm/unittest/DebugInfo/DWARFFormValueTest.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 "llvm/DebugInfo/DWARF/DWARFFormValue.h"
10 #include "llvm/ADT/ArrayRef.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/BinaryFormat/Dwarf.h"
13 #include "llvm/Support/FormatVariadic.h"
14 #include "llvm/Support/Host.h"
15 #include "llvm/Support/LEB128.h"
16 #include "gtest/gtest.h"
17 #include <climits>
18 using namespace llvm;
19 using namespace dwarf;
20
21 namespace {
22
isFormClass(dwarf::Form Form,DWARFFormValue::FormClass FC)23 bool isFormClass(dwarf::Form Form, DWARFFormValue::FormClass FC) {
24 return DWARFFormValue(Form).isFormClass(FC);
25 }
26
TEST(DWARFFormValue,FormClass)27 TEST(DWARFFormValue, FormClass) {
28 EXPECT_TRUE(isFormClass(DW_FORM_addr, DWARFFormValue::FC_Address));
29 EXPECT_FALSE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Address));
30 EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_Constant));
31 EXPECT_TRUE(isFormClass(DW_FORM_data8, DWARFFormValue::FC_SectionOffset));
32 EXPECT_TRUE(
33 isFormClass(DW_FORM_sec_offset, DWARFFormValue::FC_SectionOffset));
34 EXPECT_TRUE(isFormClass(DW_FORM_GNU_str_index, DWARFFormValue::FC_String));
35 EXPECT_TRUE(isFormClass(DW_FORM_GNU_addr_index, DWARFFormValue::FC_Address));
36 EXPECT_FALSE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Address));
37 EXPECT_TRUE(isFormClass(DW_FORM_ref_addr, DWARFFormValue::FC_Reference));
38 EXPECT_TRUE(isFormClass(DW_FORM_ref_sig8, DWARFFormValue::FC_Reference));
39 }
40
41 template<typename RawTypeT>
createDataXFormValue(dwarf::Form Form,RawTypeT Value)42 DWARFFormValue createDataXFormValue(dwarf::Form Form, RawTypeT Value) {
43 char Raw[sizeof(RawTypeT)];
44 memcpy(Raw, &Value, sizeof(RawTypeT));
45 uint64_t Offset = 0;
46 DWARFFormValue Result(Form);
47 DWARFDataExtractor Data(StringRef(Raw, sizeof(RawTypeT)),
48 sys::IsLittleEndianHost, sizeof(void *));
49 Result.extractValue(Data, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32});
50 return Result;
51 }
52
createULEBFormValue(uint64_t Value)53 DWARFFormValue createULEBFormValue(uint64_t Value) {
54 SmallString<10> RawData;
55 raw_svector_ostream OS(RawData);
56 encodeULEB128(Value, OS);
57 uint64_t Offset = 0;
58 DWARFFormValue Result(DW_FORM_udata);
59 DWARFDataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void *));
60 Result.extractValue(Data, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32});
61 return Result;
62 }
63
createSLEBFormValue(int64_t Value)64 DWARFFormValue createSLEBFormValue(int64_t Value) {
65 SmallString<10> RawData;
66 raw_svector_ostream OS(RawData);
67 encodeSLEB128(Value, OS);
68 uint64_t Offset = 0;
69 DWARFFormValue Result(DW_FORM_sdata);
70 DWARFDataExtractor Data(OS.str(), sys::IsLittleEndianHost, sizeof(void *));
71 Result.extractValue(Data, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32});
72 return Result;
73 }
74
TEST(DWARFFormValue,SignedConstantForms)75 TEST(DWARFFormValue, SignedConstantForms) {
76 // Check that we correctly sign extend fixed size forms.
77 auto Sign1 = createDataXFormValue<uint8_t>(DW_FORM_data1, -123);
78 auto Sign2 = createDataXFormValue<uint16_t>(DW_FORM_data2, -12345);
79 auto Sign4 = createDataXFormValue<uint32_t>(DW_FORM_data4, -123456789);
80 auto Sign8 = createDataXFormValue<uint64_t>(DW_FORM_data8, -1);
81 EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123);
82 EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345);
83 EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789);
84 EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1);
85
86 // Check that we can handle big positive values, but that we return
87 // an error just over the limit.
88 auto UMax = createULEBFormValue(LLONG_MAX);
89 auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1);
90 EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX);
91 EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false);
92
93 // Sanity check some other forms.
94 auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120);
95 auto Data2 = createDataXFormValue<uint16_t>(DW_FORM_data2, 32000);
96 auto Data4 = createDataXFormValue<uint32_t>(DW_FORM_data4, 2000000000);
97 auto Data8 = createDataXFormValue<uint64_t>(DW_FORM_data8, 0x1234567812345678LL);
98 auto LEBMin = createSLEBFormValue(LLONG_MIN);
99 auto LEBMax = createSLEBFormValue(LLONG_MAX);
100 auto LEB1 = createSLEBFormValue(-42);
101 auto LEB2 = createSLEBFormValue(42);
102 EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120);
103 EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000);
104 EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000);
105 EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL);
106 EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN);
107 EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX);
108 EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42);
109 EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42);
110
111 // Data16 is a little tricky.
112 char Cksum[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
113 DWARFFormValue Data16(DW_FORM_data16);
114 DWARFDataExtractor DE16(StringRef(Cksum, 16), sys::IsLittleEndianHost,
115 sizeof(void *));
116 uint64_t Offset = 0;
117 Data16.extractValue(DE16, &Offset, {0, 0, dwarf::DwarfFormat::DWARF32});
118 SmallString<32> Str;
119 raw_svector_ostream Res(Str);
120 Data16.dump(Res, DIDumpOptions());
121 EXPECT_EQ(memcmp(Str.data(), "000102030405060708090a0b0c0d0e0f", 32), 0);
122 }
123
124 using ParamType = std::tuple<Form, uint16_t, uint8_t, DwarfFormat,
125 ArrayRef<uint8_t>, uint64_t, bool>;
126
127 struct FormSkipValueFixtureBase : public testing::TestWithParam<ParamType> {
SetUp__anond066f06f0111::FormSkipValueFixtureBase128 void SetUp() override {
129 std::tie(Fm, Version, AddrSize, Dwarf, InitialData, ExpectedSkipped,
130 ExpectedResult) = GetParam();
131 }
132
doSkipValueTest__anond066f06f0111::FormSkipValueFixtureBase133 void doSkipValueTest() {
134 SCOPED_TRACE("Inputs: Form = " + std::to_string(Fm) +
135 ", Version = " + std::to_string(Version) +
136 ", AddrSize = " + std::to_string(uint32_t(AddrSize)) +
137 ", DwarfFormat = " + std::to_string(Dwarf));
138 std::vector<uint8_t> Buf(InitialData.data(),
139 InitialData.data() + InitialData.size());
140 // The data extractor only adjusts the offset to the end of the buffer when
141 // attempting to read past the end, so the buffer must be bigger than the
142 // expected amount to be skipped to identify cases where more data than
143 // expected is skipped.
144 Buf.resize(ExpectedSkipped + 1);
145 DWARFDataExtractor Data(Buf, sys::IsLittleEndianHost, AddrSize);
146 uint64_t Offset = 0;
147 EXPECT_EQ(DWARFFormValue::skipValue(Fm, Data, &Offset,
148 {Version, AddrSize, Dwarf}),
149 ExpectedResult);
150 EXPECT_EQ(Offset, ExpectedSkipped);
151 }
152
153 Form Fm;
154 uint16_t Version;
155 uint8_t AddrSize;
156 DwarfFormat Dwarf;
157 ArrayRef<uint8_t> InitialData;
158 uint64_t ExpectedSkipped;
159 bool ExpectedResult;
160 };
161
toBytes(const T & Input)162 template <typename T> static ArrayRef<uint8_t> toBytes(const T &Input) {
163 return ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&Input),
164 sizeof(Input));
165 }
166
167 const uint8_t LEBData[] = {0x80, 0x1};
168 ArrayRef<uint8_t> SampleLEB(LEBData, sizeof(LEBData));
169 const uint8_t SampleLength8 = 0x80;
170 const uint16_t SampleLength16 = 0x80;
171 const uint32_t SampleLength = 0x80;
172 ArrayRef<uint8_t> SampleU8 = toBytes(SampleLength8);
173 ArrayRef<uint8_t> SampleU16 = toBytes(SampleLength16);
174 ArrayRef<uint8_t> SampleU32 = toBytes(SampleLength);
175 const uint8_t StringData[] = "abcdef";
176 ArrayRef<uint8_t> SampleString(StringData, sizeof(StringData));
177 const uint8_t IndirectData8[] = {DW_FORM_data8};
178 const uint8_t IndirectData16[] = {DW_FORM_data16};
179 const uint8_t IndirectAddr[] = {DW_FORM_addr};
180 const uint8_t IndirectIndirectData1[] = {DW_FORM_indirect, DW_FORM_data1};
181 const uint8_t IndirectIndirectEnd[] = {DW_FORM_indirect};
182
183 // Gtest's paramterised tests only allow a maximum of 50 cases, so split the
184 // test into multiple identical parts to share the cases.
185 struct FormSkipValueFixture1 : FormSkipValueFixtureBase {};
186 struct FormSkipValueFixture2 : FormSkipValueFixtureBase {};
TEST_P(FormSkipValueFixture1,skipValuePart1)187 TEST_P(FormSkipValueFixture1, skipValuePart1) { doSkipValueTest(); }
TEST_P(FormSkipValueFixture2,skipValuePart2)188 TEST_P(FormSkipValueFixture2, skipValuePart2) { doSkipValueTest(); }
189
190 INSTANTIATE_TEST_SUITE_P(
191 SkipValueTestParams1, FormSkipValueFixture1,
192 testing::Values(
193 // Form, Version, AddrSize, DwarfFormat, InitialData, ExpectedSize,
194 // ExpectedResult.
195 ParamType(DW_FORM_exprloc, 0, 0, DWARF32, SampleLEB,
196 SampleLength + SampleLEB.size(), true),
197 ParamType(DW_FORM_block, 0, 0, DWARF32, SampleLEB,
198 SampleLength + SampleLEB.size(), true),
199 ParamType(DW_FORM_block1, 0, 0, DWARF32, SampleU8, SampleLength8 + 1,
200 true),
201 ParamType(DW_FORM_block2, 0, 0, DWARF32, SampleU16, SampleLength16 + 2,
202 true),
203 ParamType(DW_FORM_block4, 0, 0, DWARF32, SampleU32, SampleLength + 4,
204 true),
205 ParamType(DW_FORM_string, 0, 0, DWARF32, SampleString,
206 SampleString.size(), true),
207 ParamType(DW_FORM_addr, 0, 42, DWARF32, SampleU32, 0, false),
208 ParamType(DW_FORM_addr, 4, 0, DWARF32, SampleU32, 0, false),
209 ParamType(DW_FORM_addr, 4, 42, DWARF32, SampleU32, 42, true),
210 ParamType(DW_FORM_ref_addr, 0, 1, DWARF32, SampleU32, 0, false),
211 ParamType(DW_FORM_ref_addr, 1, 0, DWARF32, SampleU32, 0, false),
212 ParamType(DW_FORM_ref_addr, 1, 1, DWARF32, SampleU32, 4, true),
213 ParamType(DW_FORM_ref_addr, 1, 1, DWARF64, SampleU32, 8, true),
214 ParamType(DW_FORM_ref_addr, 2, 42, DWARF32, SampleU32, 42, true),
215 ParamType(DW_FORM_ref_addr, 2, 42, DWARF64, SampleU32, 42, true),
216 ParamType(DW_FORM_ref_addr, 3, 3, DWARF32, SampleU32, 4, true),
217 ParamType(DW_FORM_ref_addr, 3, 3, DWARF64, SampleU32, 8, true),
218 ParamType(DW_FORM_flag_present, 4, 4, DWARF32, SampleU32, 0, true),
219 ParamType(DW_FORM_data1, 0, 0, DWARF32, SampleU32, 1, true),
220 ParamType(DW_FORM_data2, 0, 0, DWARF32, SampleU32, 2, true),
221 ParamType(DW_FORM_data4, 0, 0, DWARF32, SampleU32, 4, true),
222 ParamType(DW_FORM_data8, 0, 0, DWARF32, SampleU32, 8, true),
223 ParamType(DW_FORM_data16, 0, 0, DWARF32, SampleU32, 16, true),
224 ParamType(DW_FORM_flag, 0, 0, DWARF32, SampleU32, 1, true),
225 ParamType(DW_FORM_ref1, 0, 0, DWARF32, SampleU32, 1, true),
226 ParamType(DW_FORM_ref2, 0, 0, DWARF32, SampleU32, 2, true),
227 ParamType(DW_FORM_ref4, 0, 0, DWARF32, SampleU32, 4, true),
228 ParamType(DW_FORM_ref8, 0, 0, DWARF32, SampleU32, 8, true),
229 ParamType(DW_FORM_ref_sig8, 0, 0, DWARF32, SampleU32, 8, true),
230 ParamType(DW_FORM_ref_sup4, 0, 0, DWARF32, SampleU32, 4, true),
231 ParamType(DW_FORM_ref_sup8, 0, 0, DWARF32, SampleU32, 8, true),
232 ParamType(DW_FORM_strx1, 0, 0, DWARF32, SampleU32, 1, true),
233 ParamType(DW_FORM_strx2, 0, 0, DWARF32, SampleU32, 2, true),
234 ParamType(DW_FORM_strx4, 0, 0, DWARF32, SampleU32, 4, true),
235 ParamType(DW_FORM_addrx1, 0, 0, DWARF32, SampleU32, 1, true),
236 ParamType(DW_FORM_addrx2, 0, 0, DWARF32, SampleU32, 2, true),
237 ParamType(DW_FORM_addrx4, 0, 0, DWARF32, SampleU32, 4, true),
238 ParamType(DW_FORM_sec_offset, 0, 1, DWARF32, SampleU32, 0, false),
239 ParamType(DW_FORM_sec_offset, 1, 0, DWARF32, SampleU32, 0, false),
240 ParamType(DW_FORM_sec_offset, 1, 1, DWARF32, SampleU32, 4, true),
241 ParamType(DW_FORM_sec_offset, 1, 1, DWARF64, SampleU32, 8, true),
242 ParamType(DW_FORM_strp, 0, 1, DWARF32, SampleU32, 0, false),
243 ParamType(DW_FORM_strp, 1, 0, DWARF32, SampleU32, 0, false),
244 ParamType(DW_FORM_strp, 1, 1, DWARF32, SampleU32, 4, true),
245 ParamType(DW_FORM_strp, 1, 1, DWARF64, SampleU32, 8, true),
246 ParamType(DW_FORM_strp_sup, 0, 1, DWARF32, SampleU32, 0, false),
247 ParamType(DW_FORM_strp_sup, 1, 0, DWARF32, SampleU32, 0, false),
248 ParamType(DW_FORM_strp_sup, 1, 1, DWARF32, SampleU32, 4, true),
249 ParamType(DW_FORM_strp_sup, 1, 1, DWARF64, SampleU32, 8, true)));
250
251 INSTANTIATE_TEST_SUITE_P(
252 SkipValueTestParams2, FormSkipValueFixture2,
253 testing::Values(
254 ParamType(DW_FORM_line_strp, 0, 1, DWARF32, SampleU32, 0, false),
255 ParamType(DW_FORM_line_strp, 1, 0, DWARF32, SampleU32, 0, false),
256 ParamType(DW_FORM_line_strp, 1, 1, DWARF32, SampleU32, 4, true),
257 ParamType(DW_FORM_line_strp, 1, 1, DWARF64, SampleU32, 8, true),
258 ParamType(DW_FORM_GNU_ref_alt, 0, 1, DWARF32, SampleU32, 0, false),
259 ParamType(DW_FORM_GNU_ref_alt, 1, 0, DWARF32, SampleU32, 0, false),
260 ParamType(DW_FORM_GNU_ref_alt, 1, 1, DWARF32, SampleU32, 4, true),
261 ParamType(DW_FORM_GNU_ref_alt, 1, 1, DWARF64, SampleU32, 8, true),
262 ParamType(DW_FORM_GNU_strp_alt, 0, 1, DWARF32, SampleU32, 0, false),
263 ParamType(DW_FORM_GNU_strp_alt, 1, 0, DWARF32, SampleU32, 0, false),
264 ParamType(DW_FORM_GNU_strp_alt, 1, 1, DWARF32, SampleU32, 4, true),
265 ParamType(DW_FORM_GNU_strp_alt, 1, 1, DWARF64, SampleU32, 8, true),
266 ParamType(DW_FORM_sdata, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
267 true),
268 ParamType(DW_FORM_udata, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
269 true),
270 ParamType(DW_FORM_ref_udata, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
271 true),
272 ParamType(DW_FORM_strx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
273 true),
274 ParamType(DW_FORM_addrx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
275 true),
276 ParamType(DW_FORM_loclistx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
277 true),
278 ParamType(DW_FORM_rnglistx, 0, 0, DWARF32, SampleLEB, SampleLEB.size(),
279 true),
280 ParamType(DW_FORM_GNU_addr_index, 0, 0, DWARF32, SampleLEB,
281 SampleLEB.size(), true),
282 ParamType(DW_FORM_GNU_str_index, 0, 0, DWARF32, SampleLEB,
283 SampleLEB.size(), true),
284 ParamType(DW_FORM_indirect, 0, 0, DWARF32,
285 ArrayRef<uint8_t>(IndirectData8, sizeof(IndirectData8)), 9,
286 true),
287 ParamType(DW_FORM_indirect, 0, 0, DWARF32,
288 ArrayRef<uint8_t>(IndirectData16, sizeof(IndirectData16)), 17,
289 true),
290 ParamType(DW_FORM_indirect, 4, 0, DWARF32,
291 ArrayRef<uint8_t>(IndirectAddr, sizeof(IndirectAddr)), 1,
292 false),
293 ParamType(DW_FORM_indirect, 4, 4, DWARF32,
294 ArrayRef<uint8_t>(IndirectAddr, sizeof(IndirectAddr)), 5,
295 true),
296 ParamType(DW_FORM_indirect, 4, 4, DWARF32,
297 ArrayRef<uint8_t>(IndirectIndirectData1,
298 sizeof(IndirectIndirectData1)),
299 3, true),
300 ParamType(DW_FORM_indirect, 4, 4, DWARF32,
301 ArrayRef<uint8_t>(IndirectIndirectEnd,
302 sizeof(IndirectIndirectEnd)),
303 2, false),
304 ParamType(/*Unknown=*/Form(0xff), 4, 4, DWARF32, SampleU32, 0, false)));
305
306 using ErrorParams = std::tuple<Form, std::vector<uint8_t>>;
307 struct ExtractValueErrorFixture : public testing::TestWithParam<ErrorParams> {
SetUp__anond066f06f0111::ExtractValueErrorFixture308 void SetUp() override { std::tie(Fm, InitialData) = GetParam(); }
309
310 Form Fm;
311 ArrayRef<uint8_t> InitialData;
312 };
313
TEST_P(ExtractValueErrorFixture,Test)314 TEST_P(ExtractValueErrorFixture, Test) {
315 SCOPED_TRACE(formatv("Fm = {0}, InitialData = {1}", Fm,
316 make_range(InitialData.begin(), InitialData.end()))
317 .str());
318
319 DWARFDataExtractor Data(InitialData, sys::IsLittleEndianHost, 4);
320 DWARFFormValue Form(Fm);
321 uint64_t Offset = 0;
322 EXPECT_FALSE(Form.extractValue(Data, &Offset, {0, 0, DWARF32}));
323 }
324
325 INSTANTIATE_TEST_SUITE_P(
326 ExtractValueErrorParams, ExtractValueErrorFixture,
327 testing::Values(
328 ErrorParams{DW_FORM_ref_addr, {}}, ErrorParams{DW_FORM_block, {}},
329 ErrorParams{DW_FORM_block, {1}}, ErrorParams{DW_FORM_block, {2, 0}},
330 ErrorParams{DW_FORM_block1, {}}, ErrorParams{DW_FORM_block2, {}},
331 ErrorParams{DW_FORM_block4, {}}, ErrorParams{DW_FORM_data1, {}},
332 ErrorParams{DW_FORM_data2, {}}, ErrorParams{DW_FORM_strx3, {}},
333 ErrorParams{DW_FORM_data4, {}}, ErrorParams{DW_FORM_data8, {}},
334 ErrorParams{DW_FORM_data16, {}}, ErrorParams{DW_FORM_sdata, {}},
335 ErrorParams{DW_FORM_udata, {}}, ErrorParams{DW_FORM_string, {}},
336 ErrorParams{DW_FORM_indirect, {}},
337 ErrorParams{DW_FORM_indirect, {DW_FORM_data1}},
338 ErrorParams{DW_FORM_strp_sup, {}}, ErrorParams{DW_FORM_ref_sig8, {}}));
339
340 using DumpValueParams =
341 std::tuple<Form, ArrayRef<uint8_t>, DwarfFormat, StringRef>;
342 struct DumpValueFixture : public testing::TestWithParam<DumpValueParams> {
SetUp__anond066f06f0111::DumpValueFixture343 void SetUp() override {
344 std::tie(Fm, InitialData, Format, ExpectedResult) = GetParam();
345 }
346
347 Form Fm;
348 ArrayRef<uint8_t> InitialData;
349 DwarfFormat Format;
350 StringRef ExpectedResult;
351 };
352
TEST_P(DumpValueFixture,Test)353 TEST_P(DumpValueFixture, Test) {
354 SCOPED_TRACE(formatv("Fm = {0}, InitialData = [{1}], Format = {2}", Fm,
355 toHex(InitialData),
356 Format == DWARF64 ? "DWARF64" : "DWARF32"));
357 DWARFDataExtractor Data(InitialData, sys::IsLittleEndianHost, 8);
358 DWARFFormValue Form(Fm);
359 uint64_t Offset = 0;
360 Form.extractValue(Data, &Offset, {0, 0, Format});
361
362 std::string Output;
363 raw_string_ostream OS(Output);
364
365 DIDumpOptions Opts;
366 Opts.Verbose = true;
367 Opts.ShowAddresses = true;
368
369 Form.dump(OS, Opts);
370 OS.flush();
371
372 EXPECT_EQ(Output, ExpectedResult);
373 }
374
375 const uint32_t DumpTestSample32Val = 0x112233;
376 ArrayRef<uint8_t> DumpTestSample32 = toBytes(DumpTestSample32Val);
377 const uint64_t DumpTestSample64Val = 0x11223344556677;
378 ArrayRef<uint8_t> DumpTestSample64 = toBytes(DumpTestSample64Val);
379
380 INSTANTIATE_TEST_SUITE_P(
381 DumpValueParams, DumpValueFixture,
382 testing::Values(DumpValueParams{DW_FORM_strp, DumpTestSample32, DWARF32,
383 " .debug_str[0x00112233] = "},
384 DumpValueParams{DW_FORM_strp, DumpTestSample64, DWARF64,
385 " .debug_str[0x0011223344556677] = "},
386 DumpValueParams{DW_FORM_line_strp, DumpTestSample32,
387 DWARF32, " .debug_line_str[0x00112233] = "},
388 DumpValueParams{DW_FORM_line_strp, DumpTestSample64,
389 DWARF64,
390 " .debug_line_str[0x0011223344556677] = "},
391 DumpValueParams{DW_FORM_sec_offset, DumpTestSample32,
392 DWARF32, "0x00112233"},
393 DumpValueParams{DW_FORM_sec_offset, DumpTestSample64,
394 DWARF64, "0x0011223344556677"}));
395
396 } // end anonymous namespace
397