1 //===- llvm/unittest/DebugInfo/DWARFFormValueTest.cpp ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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"
20 TEST(DIEHashTest, Data1) {
22 DIE Die(dwarf::DW_TAG_base_type);
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);
30 TEST(DIEHashTest, TrivialType) {
31 DIE Unnamed(dwarf::DW_TAG_structure_type);
33 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
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);
40 // The exact same hash GCC produces for this DIE.
41 ASSERT_EQ(0x715305ce6cfd9ad1ULL, MD5Res);
45 TEST(DIEHashTest, NamedType) {
46 DIE Foo(dwarf::DW_TAG_structure_type);
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);
52 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
54 // The exact same hash GCC produces for this DIE.
55 ASSERT_EQ(0xd566dbd2ca5265ffULL, MD5Res);
58 // namespace space { struct foo { }; }
59 TEST(DIEHashTest, NamespacedType) {
60 DIE CU(dwarf::DW_TAG_compile_unit);
62 DIE *Space = new DIE(dwarf::DW_TAG_namespace);
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);
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);
78 uint64_t MD5Res = DIEHash().computeTypeSignature(*Foo);
80 // The exact same hash GCC produces for this DIE.
81 ASSERT_EQ(0x7b80381fd17f1e33ULL, MD5Res);
84 // struct { int member; };
85 TEST(DIEHashTest, TypeWithMember) {
86 DIE Unnamed(dwarf::DW_TAG_structure_type);
88 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
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);
94 Member->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
96 Unnamed.addChild(Member);
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);
103 Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
105 DIEEntry IntRef(&Int);
106 Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
108 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
110 ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
113 // struct foo { int mem1, mem2; };
114 TEST(DIEHashTest, ReusedType) {
115 DIE Unnamed(dwarf::DW_TAG_structure_type);
117 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
119 DIE *Mem1 = new DIE(dwarf::DW_TAG_member);
121 DIEString Mem1Str(&Four, "mem1");
122 Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
124 Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
126 Unnamed.addChild(Mem1);
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);
133 Unnamed.addChild(Mem2);
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);
140 Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
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);
146 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
148 ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
151 // struct foo { static foo f; };
152 TEST(DIEHashTest, RecursiveType) {
153 DIE Foo(dwarf::DW_TAG_structure_type);
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);
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.
168 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
170 ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res);
173 // struct foo { foo *mem; };
174 TEST(DIEHashTest, Pointer) {
175 DIE Foo(dwarf::DW_TAG_structure_type);
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);
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);
185 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
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);
192 DIEEntry FooPtrRef(&FooPtr);
193 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
197 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
199 ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res);
202 // struct foo { foo &mem; };
203 TEST(DIEHashTest, Reference) {
204 DIE Foo(dwarf::DW_TAG_structure_type);
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);
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);
214 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
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);
221 DIE FooRefConst(dwarf::DW_TAG_const_type);
222 DIEEntry FooRefRef(&FooRef);
223 FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
225 DIEEntry FooRefConstRef(&FooRefConst);
226 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
230 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
232 ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res);
235 // struct foo { foo &&mem; };
236 TEST(DIEHashTest, RValueReference) {
237 DIE Foo(dwarf::DW_TAG_structure_type);
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);
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);
247 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
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);
254 DIE FooRefConst(dwarf::DW_TAG_const_type);
255 DIEEntry FooRefRef(&FooRef);
256 FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
258 DIEEntry FooRefConstRef(&FooRefConst);
259 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
263 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
265 ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res);
268 // struct foo { foo foo::*mem; };
269 TEST(DIEHashTest, PtrToMember) {
270 DIE Foo(dwarf::DW_TAG_structure_type);
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);
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);
280 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
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);
287 DIEEntry PtrToFooMemRef(&PtrToFooMem);
288 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
292 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
294 ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res);
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.
300 // struct bar; // { };
301 // struct foo { bar foo::*mem; };
302 TEST(DIEHashTest, PtrToMemberDeclDefMatch) {
306 DIEString FooStr(&Eight, "foo");
307 DIEString BarStr(&Eight, "bar");
308 DIEString MemStr(&Eight, "mem");
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);
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);
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,
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,
331 DIEEntry PtrToFooMemRef(&PtrToFooMem);
332 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
336 MD5ResDecl = DIEHash().computeTypeSignature(Foo);
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);
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);
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,
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,
360 DIEEntry PtrToFooMemRef(&PtrToFooMem);
361 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
365 MD5ResDef = DIEHash().computeTypeSignature(Foo);
367 ASSERT_EQ(MD5ResDef, MD5ResDecl);
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.
373 // struct bar; // { };
374 // struct foo { bar bar::*mem; };
375 TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) {
379 DIEString FooStr(&Eight, "foo");
380 DIEString BarStr(&Eight, "bar");
381 DIEString MemStr(&Eight, "mem");
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);
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);
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,
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,
403 DIEEntry PtrToFooMemRef(&PtrToFooMem);
404 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
408 MD5ResDecl = DIEHash().computeTypeSignature(Foo);
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);
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);
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,
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,
431 DIEEntry PtrToFooMemRef(&PtrToFooMem);
432 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
436 MD5ResDef = DIEHash().computeTypeSignature(Foo);
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);
447 // struct foo { decltype(a) mem; };
448 TEST(DIEHashTest, RefUnnamedType) {
452 DIEString FooStr(&Zero, "foo");
453 DIEString MemStr(&Zero, "mem");
455 DIE Unnamed(dwarf::DW_TAG_structure_type);
456 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
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);
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);
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);
471 DIEEntry UnnamedPtrRef(&UnnamedPtr);
472 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
476 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
478 ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
481 // struct { struct bar { }; };
482 TEST(DIEHashTest, NestedType) {
483 DIE Unnamed(dwarf::DW_TAG_structure_type);
485 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
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);
492 Unnamed.addChild(Foo);
494 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
496 // The exact same hash GCC produces for this DIE.
497 ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res);
500 // struct { static void func(); };
501 TEST(DIEHashTest, MemberFunc) {
502 DIE Unnamed(dwarf::DW_TAG_structure_type);
504 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
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);
510 Unnamed.addChild(Func);
512 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
514 // The exact same hash GCC produces for this DIE.
515 ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res);