unittests/CodeGen/DIEHashTest.cpp

   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 "gtest/gtest.h"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20 TEST(DIEHashTest, Data1) {
  21   DIEHash Hash;
  22   DIE Die(dwarf::DW_TAG_base_type);
  23   DIEInteger Size(4);
  24   Die.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Size);
  25   uint64_t MD5Res = Hash.computeTypeSignature(Die);
  26   ASSERT_EQ(0x1AFE116E83701108ULL, MD5Res);
  27 }
  28
  29 // struct {};
  30 TEST(DIEHashTest, TrivialType) {
  31   DIE Unnamed(dwarf::DW_TAG_structure_type);
  32   DIEInteger One(1);
  33   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
  34
  35   // Line and file number are ignored.
  36   Unnamed.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
  37   Unnamed.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
  38   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
  39
  40   // The exact same hash GCC produces for this DIE.
  41   ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res);
  42 }
  43
  44 // struct foo { };
  45 TEST(DIEHashTest, NamedType) {
  46   DIE Foo(dwarf::DW_TAG_structure_type);
  47   DIEInteger One(1);
  48   DIEString FooStr(&One, "foo");
  49   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
  50   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
  51
  52   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
  53
  54   // The exact same hash GCC produces for this DIE.
  55   ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res);
  56 }
  57
  58 // namespace space { struct foo { }; }
  59 TEST(DIEHashTest, NamespacedType) {
  60   DIE CU(dwarf::DW_TAG_compile_unit);
  61
  62   DIE *Space = new DIE(dwarf::DW_TAG_namespace);
  63   DIEInteger One(1);
  64   DIEString SpaceStr(&One, "space");
  65   Space->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &SpaceStr);
  66   // DW_AT_declaration is ignored.
  67   Space->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
  68   // sibling?
  69
  70   DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
  71   DIEString FooStr(&One, "foo");
  72   Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
  73   Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
  74
  75   Space->addChild(Foo);
  76   CU.addChild(Space);
  77
  78   uint64_t MD5Res = DIEHash().computeTypeSignature(*Foo);
  79
  80   // The exact same hash GCC produces for this DIE.
  81   ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res);
  82 }
  83
  84 // struct { int member; };
  85 TEST(DIEHashTest, TypeWithMember) {
  86   DIE Unnamed(dwarf::DW_TAG_structure_type);
  87   DIEInteger Four(4);
  88   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
  89
  90   DIE *Member = new DIE(dwarf::DW_TAG_member);
  91   DIEString MemberStr(&Four, "member");
  92   Member->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemberStr);
  93   DIEInteger Zero(0);
  94   Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
  95
  96   Unnamed.addChild(Member);
  97
  98   DIE Int(dwarf::DW_TAG_base_type);
  99   DIEString IntStr(&Four, "int");
 100   Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
 101   Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
 102   DIEInteger Five(5);
 103   Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
 104
 105   DIEEntry IntRef(&Int);
 106   Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
 107
 108   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 109
 110   ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
 111 }
 112
 113 // struct foo { int mem1, mem2; };
 114 TEST(DIEHashTest, ReusedType) {
 115   DIE Unnamed(dwarf::DW_TAG_structure_type);
 116   DIEInteger Eight(8);
 117   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 118
 119   DIE *Mem1 = new DIE(dwarf::DW_TAG_member);
 120   DIEInteger Four(4);
 121   DIEString Mem1Str(&Four, "mem1");
 122   Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
 123   DIEInteger Zero(0);
 124   Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 125
 126   Unnamed.addChild(Mem1);
 127
 128   DIE *Mem2 = new DIE(dwarf::DW_TAG_member);
 129   DIEString Mem2Str(&Four, "mem2");
 130   Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str);
 131   Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Four);
 132
 133   Unnamed.addChild(Mem2);
 134
 135   DIE Int(dwarf::DW_TAG_base_type);
 136   DIEString IntStr(&Four, "int");
 137   Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
 138   Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
 139   DIEInteger Five(5);
 140   Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
 141
 142   DIEEntry IntRef(&Int);
 143   Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
 144   Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
 145
 146   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 147
 148   ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
 149 }
 150
 151 // struct foo { static foo f; };
 152 TEST(DIEHashTest, RecursiveType) {
 153   DIE Foo(dwarf::DW_TAG_structure_type);
 154   DIEInteger One(1);
 155   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 156   DIEString FooStr(&One, "foo");
 157   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 158
 159   DIE *Mem = new DIE(dwarf::DW_TAG_member);
 160   DIEString MemStr(&One, "mem");
 161   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 162   DIEEntry FooRef(&Foo);
 163   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
 164   // DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
 165
 166   Foo.addChild(Mem);
 167
 168   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 169
 170   ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res);
 171 }
 172
 173 // struct foo { foo *mem; };
 174 TEST(DIEHashTest, Pointer) {
 175   DIE Foo(dwarf::DW_TAG_structure_type);
 176   DIEInteger Eight(8);
 177   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 178   DIEString FooStr(&Eight, "foo");
 179   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 180
 181   DIE *Mem = new DIE(dwarf::DW_TAG_member);
 182   DIEString MemStr(&Eight, "mem");
 183   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 184   DIEInteger Zero(0);
 185   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 186
 187   DIE FooPtr(dwarf::DW_TAG_pointer_type);
 188   FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 189   DIEEntry FooRef(&Foo);
 190   FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
 191
 192   DIEEntry FooPtrRef(&FooPtr);
 193   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
 194
 195   Foo.addChild(Mem);
 196
 197   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 198
 199   ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res);
 200 }
 201
 202 // struct foo { foo &mem; };
 203 TEST(DIEHashTest, Reference) {
 204   DIE Foo(dwarf::DW_TAG_structure_type);
 205   DIEInteger Eight(8);
 206   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 207   DIEString FooStr(&Eight, "foo");
 208   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 209
 210   DIE *Mem = new DIE(dwarf::DW_TAG_member);
 211   DIEString MemStr(&Eight, "mem");
 212   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 213   DIEInteger Zero(0);
 214   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 215
 216   DIE FooRef(dwarf::DW_TAG_reference_type);
 217   FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 218   DIEEntry FooEntry(&Foo);
 219   FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
 220
 221   DIE FooRefConst(dwarf::DW_TAG_const_type);
 222   DIEEntry FooRefRef(&FooRef);
 223   FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
 224
 225   DIEEntry FooRefConstRef(&FooRefConst);
 226   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
 227
 228   Foo.addChild(Mem);
 229
 230   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 231
 232   ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res);
 233 }
 234
 235 // struct foo { foo &&mem; };
 236 TEST(DIEHashTest, RValueReference) {
 237   DIE Foo(dwarf::DW_TAG_structure_type);
 238   DIEInteger Eight(8);
 239   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 240   DIEString FooStr(&Eight, "foo");
 241   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 242
 243   DIE *Mem = new DIE(dwarf::DW_TAG_member);
 244   DIEString MemStr(&Eight, "mem");
 245   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 246   DIEInteger Zero(0);
 247   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 248
 249   DIE FooRef(dwarf::DW_TAG_rvalue_reference_type);
 250   FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 251   DIEEntry FooEntry(&Foo);
 252   FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
 253
 254   DIE FooRefConst(dwarf::DW_TAG_const_type);
 255   DIEEntry FooRefRef(&FooRef);
 256   FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
 257
 258   DIEEntry FooRefConstRef(&FooRefConst);
 259   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
 260
 261   Foo.addChild(Mem);
 262
 263   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 264
 265   ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res);
 266 }
 267
 268 // struct foo { foo foo::*mem; };
 269 TEST(DIEHashTest, PtrToMember) {
 270   DIE Foo(dwarf::DW_TAG_structure_type);
 271   DIEInteger Eight(8);
 272   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 273   DIEString FooStr(&Eight, "foo");
 274   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 275
 276   DIE *Mem = new DIE(dwarf::DW_TAG_member);
 277   DIEString MemStr(&Eight, "mem");
 278   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 279   DIEInteger Zero(0);
 280   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 281
 282   DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
 283   DIEEntry FooEntry(&Foo);
 284   PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
 285   PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, &FooEntry);
 286
 287   DIEEntry PtrToFooMemRef(&PtrToFooMem);
 288   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 289
 290   Foo.addChild(Mem);
 291
 292   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 293
 294   ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res);
 295 }
 296
 297 // Check that the hash for a pointer-to-member matches regardless of whether the
 298 // pointed-to type is a declaration or a definition.
 299 //
 300 //   struct bar; // { };
 301 //   struct foo { bar foo::*mem; };
 302 TEST(DIEHashTest, PtrToMemberDeclDefMatch) {
 303   DIEInteger Zero(0);
 304   DIEInteger One(1);
 305   DIEInteger Eight(8);
 306   DIEString FooStr(&Eight, "foo");
 307   DIEString BarStr(&Eight, "bar");
 308   DIEString MemStr(&Eight, "mem");
 309   uint64_t MD5ResDecl;
 310   {
 311     DIE Bar(dwarf::DW_TAG_structure_type);
 312     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
 313     Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
 314
 315     DIE Foo(dwarf::DW_TAG_structure_type);
 316     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 317     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 318
 319     DIE *Mem = new DIE(dwarf::DW_TAG_member);
 320     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 321     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
 322                   &Zero);
 323
 324     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
 325     DIEEntry BarEntry(&Bar);
 326     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
 327     DIEEntry FooEntry(&Foo);
 328     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 329                          &FooEntry);
 330
 331     DIEEntry PtrToFooMemRef(&PtrToFooMem);
 332     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 333
 334     Foo.addChild(Mem);
 335
 336     MD5ResDecl = DIEHash().computeTypeSignature(Foo);
 337   }
 338   uint64_t MD5ResDef;
 339   {
 340     DIE Bar(dwarf::DW_TAG_structure_type);
 341     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
 342     Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 343
 344     DIE Foo(dwarf::DW_TAG_structure_type);
 345     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 346     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 347
 348     DIE *Mem = new DIE(dwarf::DW_TAG_member);
 349     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 350     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
 351                   &Zero);
 352
 353     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
 354     DIEEntry BarEntry(&Bar);
 355     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
 356     DIEEntry FooEntry(&Foo);
 357     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 358                          &FooEntry);
 359
 360     DIEEntry PtrToFooMemRef(&PtrToFooMem);
 361     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 362
 363     Foo.addChild(Mem);
 364
 365     MD5ResDef = DIEHash().computeTypeSignature(Foo);
 366   }
 367   ASSERT_EQ(MD5ResDef, MD5ResDecl);
 368 }
 369
 370 // Check that the hash for a pointer-to-member matches regardless of whether the
 371 // pointed-to type is a declaration or a definition.
 372 //
 373 //   struct bar; // { };
 374 //   struct foo { bar bar::*mem; };
 375 TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) {
 376   DIEInteger Zero(0);
 377   DIEInteger One(1);
 378   DIEInteger Eight(8);
 379   DIEString FooStr(&Eight, "foo");
 380   DIEString BarStr(&Eight, "bar");
 381   DIEString MemStr(&Eight, "mem");
 382   uint64_t MD5ResDecl;
 383   {
 384     DIE Bar(dwarf::DW_TAG_structure_type);
 385     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
 386     Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
 387
 388     DIE Foo(dwarf::DW_TAG_structure_type);
 389     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 390     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 391
 392     DIE *Mem = new DIE(dwarf::DW_TAG_member);
 393     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 394     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
 395                   &Zero);
 396
 397     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
 398     DIEEntry BarEntry(&Bar);
 399     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
 400     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 401                          &BarEntry);
 402
 403     DIEEntry PtrToFooMemRef(&PtrToFooMem);
 404     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 405
 406     Foo.addChild(Mem);
 407
 408     MD5ResDecl = DIEHash().computeTypeSignature(Foo);
 409   }
 410   uint64_t MD5ResDef;
 411   {
 412     DIE Bar(dwarf::DW_TAG_structure_type);
 413     Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
 414     Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 415
 416     DIE Foo(dwarf::DW_TAG_structure_type);
 417     Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 418     Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 419
 420     DIE *Mem = new DIE(dwarf::DW_TAG_member);
 421     Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 422     Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
 423                   &Zero);
 424
 425     DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
 426     DIEEntry BarEntry(&Bar);
 427     PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
 428     PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 429                          &BarEntry);
 430
 431     DIEEntry PtrToFooMemRef(&PtrToFooMem);
 432     Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
 433
 434     Foo.addChild(Mem);
 435
 436     MD5ResDef = DIEHash().computeTypeSignature(Foo);
 437   }
 438   // FIXME: This seems to be a bug in the DWARF type hashing specification that
 439   // only uses the brief name hashing for types referenced via DW_AT_type. In
 440   // this case the type is referenced via DW_AT_containing_type and full hashing
 441   // causes a hash to differ when the containing type is a declaration in one TU
 442   // and a definition in another.
 443   ASSERT_NE(MD5ResDef, MD5ResDecl);
 444 }
 445
 446 // struct { } a;
 447 // struct foo { decltype(a) mem; };
 448 TEST(DIEHashTest, RefUnnamedType) {
 449   DIEInteger Zero(0);
 450   DIEInteger One(1);
 451   DIEInteger Eight(8);
 452   DIEString FooStr(&Zero, "foo");
 453   DIEString MemStr(&Zero, "mem");
 454
 455   DIE Unnamed(dwarf::DW_TAG_structure_type);
 456   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 457
 458   DIE Foo(dwarf::DW_TAG_structure_type);
 459   Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 460   Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 461
 462   DIE *Mem = new DIE(dwarf::DW_TAG_member);
 463   Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
 464   Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
 465
 466   DIE UnnamedPtr(dwarf::DW_TAG_pointer_type);
 467   UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
 468   DIEEntry UnnamedRef(&Unnamed);
 469   UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef);
 470
 471   DIEEntry UnnamedPtrRef(&UnnamedPtr);
 472   Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
 473
 474   Foo.addChild(Mem);
 475
 476   uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
 477
 478   ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
 479 }
 480
 481 // struct { struct bar { }; };
 482 TEST(DIEHashTest, NestedType) {
 483   DIE Unnamed(dwarf::DW_TAG_structure_type);
 484   DIEInteger One(1);
 485   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 486
 487   DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
 488   DIEString FooStr(&One, "foo");
 489   Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
 490   Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 491
 492   Unnamed.addChild(Foo);
 493
 494   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 495
 496   // The exact same hash GCC produces for this DIE.
 497   ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res);
 498 }
 499
 500 // struct { static void func(); };
 501 TEST(DIEHashTest, MemberFunc) {
 502   DIE Unnamed(dwarf::DW_TAG_structure_type);
 503   DIEInteger One(1);
 504   Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
 505
 506   DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
 507   DIEString FuncStr(&One, "func");
 508   Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
 509
 510   Unnamed.addChild(Func);
 511
 512   uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
 513
 514   // The exact same hash GCC produces for this DIE.
 515   ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res);
 516 }
 517 }