xref: /llvm-project/llvm/unittests/CodeGen/DIEHashTest.cpp (revision 65cc969f5038d82c65c7f8cbaee30c8481971e38) 
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/Dwarf.h"
13 #include "llvm/Support/Debug.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