1 //===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "../lib/CodeGen/AsmPrinter/DIE.h" 11 #include "../lib/CodeGen/AsmPrinter/DIEHash.h" 12 #include "llvm/Support/Debug.h" 13 #include "llvm/Support/Dwarf.h" 14 #include "llvm/Support/Format.h" 15 #include "llvm/ADT/STLExtras.h" 16 #include "gtest/gtest.h" 17 18 using namespace llvm; 19 20 namespace { 21 TEST(DIEHashTest, Data1) { 22 DIEHash Hash; 23 DIE Die(dwarf::DW_TAG_base_type); 24 DIEInteger Size(4); 25 Die.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Size); 26 uint64_t MD5Res = Hash.computeTypeSignature(Die); 27 ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res); 28 } 29 30 // struct {}; 31 TEST(DIEHashTest, TrivialType) { 32 DIE Unnamed(dwarf::DW_TAG_structure_type); 33 DIEInteger One(1); 34 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 35 36 // Line and file number are ignored. 37 Unnamed.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 38 Unnamed.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One); 39 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); 40 41 // The exact same hash GCC produces for this DIE. 42 ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res); 43 } 44 45 // struct foo { }; 46 TEST(DIEHashTest, NamedType) { 47 DIE Foo(dwarf::DW_TAG_structure_type); 48 DIEInteger One(1); 49 DIEString FooStr(&One, "foo"); 50 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 51 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 52 53 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 54 55 // The exact same hash GCC produces for this DIE. 56 ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res); 57 } 58 59 // namespace space { struct foo { }; } 60 TEST(DIEHashTest, NamespacedType) { 61 DIE CU(dwarf::DW_TAG_compile_unit); 62 63 auto Space = make_unique<DIE>(dwarf::DW_TAG_namespace); 64 DIEInteger One(1); 65 DIEString SpaceStr(&One, "space"); 66 Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &SpaceStr); 67 // DW_AT_declaration is ignored. 68 Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One); 69 // sibling? 70 71 auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type); 72 DIEString FooStr(&One, "foo"); 73 Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 74 Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 75 76 DIE &N = *Foo; 77 Space->addChild(std::move(Foo)); 78 CU.addChild(std::move(Space)); 79 80 uint64_t MD5Res = DIEHash().computeTypeSignature(N); 81 82 // The exact same hash GCC produces for this DIE. 83 ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res); 84 } 85 86 // struct { int member; }; 87 TEST(DIEHashTest, TypeWithMember) { 88 DIE Unnamed(dwarf::DW_TAG_structure_type); 89 DIEInteger Four(4); 90 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four); 91 92 DIE Int(dwarf::DW_TAG_base_type); 93 DIEString IntStr(&Four, "int"); 94 Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr); 95 Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four); 96 DIEInteger Five(5); 97 Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five); 98 99 DIEEntry IntRef(Int); 100 101 auto Member = make_unique<DIE>(dwarf::DW_TAG_member); 102 DIEString MemberStr(&Four, "member"); 103 Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemberStr); 104 DIEInteger Zero(0); 105 Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 106 &Zero); 107 Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef); 108 109 Unnamed.addChild(std::move(Member)); 110 111 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); 112 113 ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res); 114 } 115 116 // struct foo { int mem1, mem2; }; 117 TEST(DIEHashTest, ReusedType) { 118 DIE Unnamed(dwarf::DW_TAG_structure_type); 119 DIEInteger Eight(8); 120 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 121 122 DIEInteger Four(4); 123 DIE Int(dwarf::DW_TAG_base_type); 124 DIEString IntStr(&Four, "int"); 125 Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr); 126 Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four); 127 DIEInteger Five(5); 128 Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five); 129 130 DIEEntry IntRef(Int); 131 132 auto Mem1 = make_unique<DIE>(dwarf::DW_TAG_member); 133 DIEString Mem1Str(&Four, "mem1"); 134 Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str); 135 DIEInteger Zero(0); 136 Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 137 &Zero); 138 Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef); 139 140 Unnamed.addChild(std::move(Mem1)); 141 142 auto Mem2 = make_unique<DIE>(dwarf::DW_TAG_member); 143 DIEString Mem2Str(&Four, "mem2"); 144 Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str); 145 Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 146 &Four); 147 Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef); 148 149 Unnamed.addChild(std::move(Mem2)); 150 151 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); 152 153 ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res); 154 } 155 156 // struct foo { static foo f; }; 157 TEST(DIEHashTest, RecursiveType) { 158 DIE Foo(dwarf::DW_TAG_structure_type); 159 DIEInteger One(1); 160 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 161 DIEString FooStr(&One, "foo"); 162 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 163 164 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 165 DIEString MemStr(&One, "mem"); 166 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 167 DIEEntry FooRef(Foo); 168 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef); 169 // DW_AT_external and DW_AT_declaration are ignored anyway, so skip them. 170 171 Foo.addChild(std::move(Mem)); 172 173 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 174 175 ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res); 176 } 177 178 // struct foo { foo *mem; }; 179 TEST(DIEHashTest, Pointer) { 180 DIE Foo(dwarf::DW_TAG_structure_type); 181 DIEInteger Eight(8); 182 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 183 DIEString FooStr(&Eight, "foo"); 184 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 185 186 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 187 DIEString MemStr(&Eight, "mem"); 188 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 189 DIEInteger Zero(0); 190 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero); 191 192 DIE FooPtr(dwarf::DW_TAG_pointer_type); 193 FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 194 DIEEntry FooRef(Foo); 195 FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef); 196 197 DIEEntry FooPtrRef(FooPtr); 198 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef); 199 200 Foo.addChild(std::move(Mem)); 201 202 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 203 204 ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res); 205 } 206 207 // struct foo { foo &mem; }; 208 TEST(DIEHashTest, Reference) { 209 DIE Foo(dwarf::DW_TAG_structure_type); 210 DIEInteger Eight(8); 211 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 212 DIEString FooStr(&Eight, "foo"); 213 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 214 215 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 216 DIEString MemStr(&Eight, "mem"); 217 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 218 DIEInteger Zero(0); 219 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero); 220 221 DIE FooRef(dwarf::DW_TAG_reference_type); 222 FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 223 DIEEntry FooEntry(Foo); 224 FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry); 225 226 DIE FooRefConst(dwarf::DW_TAG_const_type); 227 DIEEntry FooRefRef(FooRef); 228 FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef); 229 230 DIEEntry FooRefConstRef(FooRefConst); 231 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef); 232 233 Foo.addChild(std::move(Mem)); 234 235 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 236 237 ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res); 238 } 239 240 // struct foo { foo &&mem; }; 241 TEST(DIEHashTest, RValueReference) { 242 DIE Foo(dwarf::DW_TAG_structure_type); 243 DIEInteger Eight(8); 244 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 245 DIEString FooStr(&Eight, "foo"); 246 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 247 248 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 249 DIEString MemStr(&Eight, "mem"); 250 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 251 DIEInteger Zero(0); 252 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero); 253 254 DIE FooRef(dwarf::DW_TAG_rvalue_reference_type); 255 FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 256 DIEEntry FooEntry(Foo); 257 FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry); 258 259 DIE FooRefConst(dwarf::DW_TAG_const_type); 260 DIEEntry FooRefRef(FooRef); 261 FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef); 262 263 DIEEntry FooRefConstRef(FooRefConst); 264 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef); 265 266 Foo.addChild(std::move(Mem)); 267 268 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 269 270 ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res); 271 } 272 273 // struct foo { foo foo::*mem; }; 274 TEST(DIEHashTest, PtrToMember) { 275 DIE Foo(dwarf::DW_TAG_structure_type); 276 DIEInteger Eight(8); 277 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 278 DIEString FooStr(&Eight, "foo"); 279 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 280 281 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 282 DIEString MemStr(&Eight, "mem"); 283 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 284 DIEInteger Zero(0); 285 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero); 286 287 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); 288 DIEEntry FooEntry(Foo); 289 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry); 290 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 291 &FooEntry); 292 293 DIEEntry PtrToFooMemRef(PtrToFooMem); 294 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef); 295 296 Foo.addChild(std::move(Mem)); 297 298 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 299 300 ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res); 301 } 302 303 // Check that the hash for a pointer-to-member matches regardless of whether the 304 // pointed-to type is a declaration or a definition. 305 // 306 // struct bar; // { }; 307 // struct foo { bar foo::*mem; }; 308 TEST(DIEHashTest, PtrToMemberDeclDefMatch) { 309 DIEInteger Zero(0); 310 DIEInteger One(1); 311 DIEInteger Eight(8); 312 DIEString FooStr(&Eight, "foo"); 313 DIEString BarStr(&Eight, "bar"); 314 DIEString MemStr(&Eight, "mem"); 315 uint64_t MD5ResDecl; 316 { 317 DIE Bar(dwarf::DW_TAG_structure_type); 318 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr); 319 Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One); 320 321 DIE Foo(dwarf::DW_TAG_structure_type); 322 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 323 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 324 325 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 326 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 327 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 328 &Zero); 329 330 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); 331 DIEEntry BarEntry(Bar); 332 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry); 333 DIEEntry FooEntry(Foo); 334 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 335 &FooEntry); 336 337 DIEEntry PtrToFooMemRef(PtrToFooMem); 338 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef); 339 340 Foo.addChild(std::move(Mem)); 341 342 MD5ResDecl = DIEHash().computeTypeSignature(Foo); 343 } 344 uint64_t MD5ResDef; 345 { 346 DIE Bar(dwarf::DW_TAG_structure_type); 347 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr); 348 Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 349 350 DIE Foo(dwarf::DW_TAG_structure_type); 351 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 352 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 353 354 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 355 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 356 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 357 &Zero); 358 359 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); 360 DIEEntry BarEntry(Bar); 361 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry); 362 DIEEntry FooEntry(Foo); 363 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 364 &FooEntry); 365 366 DIEEntry PtrToFooMemRef(PtrToFooMem); 367 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef); 368 369 Foo.addChild(std::move(Mem)); 370 371 MD5ResDef = DIEHash().computeTypeSignature(Foo); 372 } 373 ASSERT_EQ(MD5ResDef, MD5ResDecl); 374 } 375 376 // Check that the hash for a pointer-to-member matches regardless of whether the 377 // pointed-to type is a declaration or a definition. 378 // 379 // struct bar; // { }; 380 // struct foo { bar bar::*mem; }; 381 TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) { 382 DIEInteger Zero(0); 383 DIEInteger One(1); 384 DIEInteger Eight(8); 385 DIEString FooStr(&Eight, "foo"); 386 DIEString BarStr(&Eight, "bar"); 387 DIEString MemStr(&Eight, "mem"); 388 uint64_t MD5ResDecl; 389 { 390 DIE Bar(dwarf::DW_TAG_structure_type); 391 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr); 392 Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One); 393 394 DIE Foo(dwarf::DW_TAG_structure_type); 395 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 396 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 397 398 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 399 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 400 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 401 &Zero); 402 403 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); 404 DIEEntry BarEntry(Bar); 405 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry); 406 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 407 &BarEntry); 408 409 DIEEntry PtrToFooMemRef(PtrToFooMem); 410 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef); 411 412 Foo.addChild(std::move(Mem)); 413 414 MD5ResDecl = DIEHash().computeTypeSignature(Foo); 415 } 416 uint64_t MD5ResDef; 417 { 418 DIE Bar(dwarf::DW_TAG_structure_type); 419 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr); 420 Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 421 422 DIE Foo(dwarf::DW_TAG_structure_type); 423 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 424 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 425 426 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 427 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 428 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, 429 &Zero); 430 431 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type); 432 DIEEntry BarEntry(Bar); 433 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry); 434 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 435 &BarEntry); 436 437 DIEEntry PtrToFooMemRef(PtrToFooMem); 438 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef); 439 440 Foo.addChild(std::move(Mem)); 441 442 MD5ResDef = DIEHash().computeTypeSignature(Foo); 443 } 444 // FIXME: This seems to be a bug in the DWARF type hashing specification that 445 // only uses the brief name hashing for types referenced via DW_AT_type. In 446 // this case the type is referenced via DW_AT_containing_type and full hashing 447 // causes a hash to differ when the containing type is a declaration in one TU 448 // and a definition in another. 449 ASSERT_NE(MD5ResDef, MD5ResDecl); 450 } 451 452 // struct { } a; 453 // struct foo { decltype(a) mem; }; 454 TEST(DIEHashTest, RefUnnamedType) { 455 DIEInteger Zero(0); 456 DIEInteger One(1); 457 DIEInteger Eight(8); 458 DIEString FooStr(&Zero, "foo"); 459 DIEString MemStr(&Zero, "mem"); 460 461 DIE Unnamed(dwarf::DW_TAG_structure_type); 462 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 463 464 DIE Foo(dwarf::DW_TAG_structure_type); 465 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 466 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 467 468 auto Mem = make_unique<DIE>(dwarf::DW_TAG_member); 469 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr); 470 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero); 471 472 DIE UnnamedPtr(dwarf::DW_TAG_pointer_type); 473 UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight); 474 DIEEntry UnnamedRef(Unnamed); 475 UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef); 476 477 DIEEntry UnnamedPtrRef(UnnamedPtr); 478 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef); 479 480 Foo.addChild(std::move(Mem)); 481 482 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo); 483 484 ASSERT_EQ(0x954e026f01c02529ULL, MD5Res); 485 } 486 487 // struct { struct foo { }; }; 488 TEST(DIEHashTest, NestedType) { 489 DIE Unnamed(dwarf::DW_TAG_structure_type); 490 DIEInteger One(1); 491 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 492 493 auto Foo = make_unique<DIE>(dwarf::DW_TAG_structure_type); 494 DIEString FooStr(&One, "foo"); 495 Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr); 496 Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 497 498 Unnamed.addChild(std::move(Foo)); 499 500 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); 501 502 // The exact same hash GCC produces for this DIE. 503 ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res); 504 } 505 506 // struct { static void func(); }; 507 TEST(DIEHashTest, MemberFunc) { 508 DIE Unnamed(dwarf::DW_TAG_structure_type); 509 DIEInteger One(1); 510 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 511 512 auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram); 513 DIEString FuncStr(&One, "func"); 514 Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr); 515 516 Unnamed.addChild(std::move(Func)); 517 518 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed); 519 520 // The exact same hash GCC produces for this DIE. 521 ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res); 522 } 523 524 // struct A { 525 // static void func(); 526 // }; 527 TEST(DIEHashTest, MemberFuncFlag) { 528 DIE A(dwarf::DW_TAG_structure_type); 529 DIEInteger One(1); 530 DIEString AStr(&One, "A"); 531 A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr); 532 A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 533 A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 534 A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One); 535 536 auto Func = make_unique<DIE>(dwarf::DW_TAG_subprogram); 537 DIEString FuncStr(&One, "func"); 538 DIEString FuncLinkage(&One, "_ZN1A4funcEv"); 539 DIEInteger Two(2); 540 Func->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One); 541 Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr); 542 Func->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 543 Func->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two); 544 Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, &FuncLinkage); 545 Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One); 546 547 A.addChild(std::move(Func)); 548 549 uint64_t MD5Res = DIEHash().computeTypeSignature(A); 550 551 // The exact same hash GCC produces for this DIE. 552 ASSERT_EQ(0x8f78211ddce3df10ULL, MD5Res); 553 } 554 555 // Derived from: 556 // struct A { 557 // const static int PI = -3; 558 // }; 559 // A a; 560 TEST(DIEHashTest, MemberSdata) { 561 DIE A(dwarf::DW_TAG_structure_type); 562 DIEInteger One(1); 563 DIEString AStr(&One, "A"); 564 A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr); 565 A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 566 A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 567 A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One); 568 569 DIEInteger Four(4); 570 DIEInteger Five(5); 571 DIEString FStr(&One, "int"); 572 DIE IntTyDIE(dwarf::DW_TAG_base_type); 573 IntTyDIE.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four); 574 IntTyDIE.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five); 575 IntTyDIE.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr); 576 577 DIEEntry IntTy(IntTyDIE); 578 auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type); 579 PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntTy); 580 581 DIEEntry PITy(*PITyDIE); 582 auto PI = make_unique<DIE>(dwarf::DW_TAG_member); 583 DIEString PIStr(&One, "PI"); 584 DIEInteger Two(2); 585 DIEInteger NegThree(-3); 586 PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr); 587 PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 588 PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two); 589 PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy); 590 PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One); 591 PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One); 592 PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, &NegThree); 593 594 A.addChild(std::move(PI)); 595 596 uint64_t MD5Res = DIEHash().computeTypeSignature(A); 597 ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res); 598 } 599 600 // Derived from: 601 // struct A { 602 // const static float PI = 3.14; 603 // }; 604 // A a; 605 TEST(DIEHashTest, MemberBlock) { 606 DIE A(dwarf::DW_TAG_structure_type); 607 DIEInteger One(1); 608 DIEString AStr(&One, "A"); 609 A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr); 610 A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One); 611 A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 612 A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One); 613 614 DIEInteger Four(4); 615 DIEString FStr(&One, "float"); 616 auto FloatTyDIE = make_unique<DIE>(dwarf::DW_TAG_base_type); 617 FloatTyDIE->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four); 618 FloatTyDIE->addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Four); 619 FloatTyDIE->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr); 620 621 DIEEntry FloatTy(*FloatTyDIE); 622 auto PITyDIE = make_unique<DIE>(dwarf::DW_TAG_const_type); 623 PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FloatTy); 624 625 DIEEntry PITy(*PITyDIE); 626 auto PI = make_unique<DIE>(dwarf::DW_TAG_member); 627 DIEString PIStr(&One, "PI"); 628 DIEInteger Two(2); 629 PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr); 630 PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One); 631 PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two); 632 PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy); 633 PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One); 634 PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One); 635 636 DIEBlock PIBlock; 637 DIEInteger Blk1(0xc3); 638 DIEInteger Blk2(0xf5); 639 DIEInteger Blk3(0x48); 640 DIEInteger Blk4(0x40); 641 642 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk1); 643 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk2); 644 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk3); 645 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk4); 646 647 PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock); 648 649 A.addChild(std::move(PI)); 650 651 uint64_t MD5Res = DIEHash().computeTypeSignature(A); 652 ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res); 653 } 654 } 655
