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