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/Debug.h"
13 #include "llvm/Support/Dwarf.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,
97 Unnamed.addChild(Member);
99 DIE Int(dwarf::DW_TAG_base_type);
100 DIEString IntStr(&Four, "int");
101 Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
102 Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
104 Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
106 DIEEntry IntRef(Int);
107 Member->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
109 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
111 ASSERT_EQ(0x5646aa436b7e07c6ULL, MD5Res);
114 // struct foo { int mem1, mem2; };
115 TEST(DIEHashTest, ReusedType) {
116 DIE Unnamed(dwarf::DW_TAG_structure_type);
118 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
120 DIE *Mem1 = new DIE(dwarf::DW_TAG_member);
122 DIEString Mem1Str(&Four, "mem1");
123 Mem1->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem1Str);
125 Mem1->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
128 Unnamed.addChild(Mem1);
130 DIE *Mem2 = new DIE(dwarf::DW_TAG_member);
131 DIEString Mem2Str(&Four, "mem2");
132 Mem2->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &Mem2Str);
133 Mem2->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
136 Unnamed.addChild(Mem2);
138 DIE Int(dwarf::DW_TAG_base_type);
139 DIEString IntStr(&Four, "int");
140 Int.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &IntStr);
141 Int.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
143 Int.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
145 DIEEntry IntRef(Int);
146 Mem1->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
147 Mem2->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntRef);
149 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
151 ASSERT_EQ(0x3a7dc3ed7b76b2f8ULL, MD5Res);
154 // struct foo { static foo f; };
155 TEST(DIEHashTest, RecursiveType) {
156 DIE Foo(dwarf::DW_TAG_structure_type);
158 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
159 DIEString FooStr(&One, "foo");
160 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
162 DIE *Mem = new DIE(dwarf::DW_TAG_member);
163 DIEString MemStr(&One, "mem");
164 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
165 DIEEntry FooRef(Foo);
166 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
167 // DW_AT_external and DW_AT_declaration are ignored anyway, so skip them.
171 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
173 ASSERT_EQ(0x73d8b25aef227b06ULL, MD5Res);
176 // struct foo { foo *mem; };
177 TEST(DIEHashTest, Pointer) {
178 DIE Foo(dwarf::DW_TAG_structure_type);
180 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
181 DIEString FooStr(&Eight, "foo");
182 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
184 DIE *Mem = new DIE(dwarf::DW_TAG_member);
185 DIEString MemStr(&Eight, "mem");
186 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
188 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
190 DIE FooPtr(dwarf::DW_TAG_pointer_type);
191 FooPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
192 DIEEntry FooRef(Foo);
193 FooPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRef);
195 DIEEntry FooPtrRef(FooPtr);
196 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooPtrRef);
200 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
202 ASSERT_EQ(0x74ea73862e8708d2ULL, MD5Res);
205 // struct foo { foo &mem; };
206 TEST(DIEHashTest, Reference) {
207 DIE Foo(dwarf::DW_TAG_structure_type);
209 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
210 DIEString FooStr(&Eight, "foo");
211 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
213 DIE *Mem = new DIE(dwarf::DW_TAG_member);
214 DIEString MemStr(&Eight, "mem");
215 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
217 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
219 DIE FooRef(dwarf::DW_TAG_reference_type);
220 FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
221 DIEEntry FooEntry(Foo);
222 FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
224 DIE FooRefConst(dwarf::DW_TAG_const_type);
225 DIEEntry FooRefRef(FooRef);
226 FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
228 DIEEntry FooRefConstRef(FooRefConst);
229 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
233 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
235 ASSERT_EQ(0xa0b15f467ad4525bULL, MD5Res);
238 // struct foo { foo &&mem; };
239 TEST(DIEHashTest, RValueReference) {
240 DIE Foo(dwarf::DW_TAG_structure_type);
242 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
243 DIEString FooStr(&Eight, "foo");
244 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
246 DIE *Mem = new DIE(dwarf::DW_TAG_member);
247 DIEString MemStr(&Eight, "mem");
248 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
250 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
252 DIE FooRef(dwarf::DW_TAG_rvalue_reference_type);
253 FooRef.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
254 DIEEntry FooEntry(Foo);
255 FooRef.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
257 DIE FooRefConst(dwarf::DW_TAG_const_type);
258 DIEEntry FooRefRef(FooRef);
259 FooRefConst.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefRef);
261 DIEEntry FooRefConstRef(FooRefConst);
262 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooRefConstRef);
266 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
268 ASSERT_EQ(0xad211c8c3b31e57ULL, MD5Res);
271 // struct foo { foo foo::*mem; };
272 TEST(DIEHashTest, PtrToMember) {
273 DIE Foo(dwarf::DW_TAG_structure_type);
275 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
276 DIEString FooStr(&Eight, "foo");
277 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
279 DIE *Mem = new DIE(dwarf::DW_TAG_member);
280 DIEString MemStr(&Eight, "mem");
281 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
283 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
285 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
286 DIEEntry FooEntry(Foo);
287 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FooEntry);
288 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
291 DIEEntry PtrToFooMemRef(PtrToFooMem);
292 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
296 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
298 ASSERT_EQ(0x852e0c9ff7c04ebULL, MD5Res);
301 // Check that the hash for a pointer-to-member matches regardless of whether the
302 // pointed-to type is a declaration or a definition.
304 // struct bar; // { };
305 // struct foo { bar foo::*mem; };
306 TEST(DIEHashTest, PtrToMemberDeclDefMatch) {
310 DIEString FooStr(&Eight, "foo");
311 DIEString BarStr(&Eight, "bar");
312 DIEString MemStr(&Eight, "mem");
315 DIE Bar(dwarf::DW_TAG_structure_type);
316 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
317 Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
319 DIE Foo(dwarf::DW_TAG_structure_type);
320 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
321 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
323 DIE *Mem = new DIE(dwarf::DW_TAG_member);
324 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
325 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
328 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
329 DIEEntry BarEntry(Bar);
330 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
331 DIEEntry FooEntry(Foo);
332 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
335 DIEEntry PtrToFooMemRef(PtrToFooMem);
336 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
340 MD5ResDecl = DIEHash().computeTypeSignature(Foo);
344 DIE Bar(dwarf::DW_TAG_structure_type);
345 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
346 Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
348 DIE Foo(dwarf::DW_TAG_structure_type);
349 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
350 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
352 DIE *Mem = new DIE(dwarf::DW_TAG_member);
353 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
354 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
357 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
358 DIEEntry BarEntry(Bar);
359 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
360 DIEEntry FooEntry(Foo);
361 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
364 DIEEntry PtrToFooMemRef(PtrToFooMem);
365 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
369 MD5ResDef = DIEHash().computeTypeSignature(Foo);
371 ASSERT_EQ(MD5ResDef, MD5ResDecl);
374 // Check that the hash for a pointer-to-member matches regardless of whether the
375 // pointed-to type is a declaration or a definition.
377 // struct bar; // { };
378 // struct foo { bar bar::*mem; };
379 TEST(DIEHashTest, PtrToMemberDeclDefMisMatch) {
383 DIEString FooStr(&Eight, "foo");
384 DIEString BarStr(&Eight, "bar");
385 DIEString MemStr(&Eight, "mem");
388 DIE Bar(dwarf::DW_TAG_structure_type);
389 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
390 Bar.addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
392 DIE Foo(dwarf::DW_TAG_structure_type);
393 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
394 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
396 DIE *Mem = new DIE(dwarf::DW_TAG_member);
397 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
398 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
401 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
402 DIEEntry BarEntry(Bar);
403 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
404 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
407 DIEEntry PtrToFooMemRef(PtrToFooMem);
408 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
412 MD5ResDecl = DIEHash().computeTypeSignature(Foo);
416 DIE Bar(dwarf::DW_TAG_structure_type);
417 Bar.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &BarStr);
418 Bar.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
420 DIE Foo(dwarf::DW_TAG_structure_type);
421 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
422 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
424 DIE *Mem = new DIE(dwarf::DW_TAG_member);
425 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
426 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1,
429 DIE PtrToFooMem(dwarf::DW_TAG_ptr_to_member_type);
430 DIEEntry BarEntry(Bar);
431 PtrToFooMem.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &BarEntry);
432 PtrToFooMem.addValue(dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
435 DIEEntry PtrToFooMemRef(PtrToFooMem);
436 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PtrToFooMemRef);
440 MD5ResDef = DIEHash().computeTypeSignature(Foo);
442 // FIXME: This seems to be a bug in the DWARF type hashing specification that
443 // only uses the brief name hashing for types referenced via DW_AT_type. In
444 // this case the type is referenced via DW_AT_containing_type and full hashing
445 // causes a hash to differ when the containing type is a declaration in one TU
446 // and a definition in another.
447 ASSERT_NE(MD5ResDef, MD5ResDecl);
451 // struct foo { decltype(a) mem; };
452 TEST(DIEHashTest, RefUnnamedType) {
456 DIEString FooStr(&Zero, "foo");
457 DIEString MemStr(&Zero, "mem");
459 DIE Unnamed(dwarf::DW_TAG_structure_type);
460 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
462 DIE Foo(dwarf::DW_TAG_structure_type);
463 Foo.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
464 Foo.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
466 DIE *Mem = new DIE(dwarf::DW_TAG_member);
467 Mem->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &MemStr);
468 Mem->addValue(dwarf::DW_AT_data_member_location, dwarf::DW_FORM_data1, &Zero);
470 DIE UnnamedPtr(dwarf::DW_TAG_pointer_type);
471 UnnamedPtr.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Eight);
472 DIEEntry UnnamedRef(Unnamed);
473 UnnamedPtr.addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedRef);
475 DIEEntry UnnamedPtrRef(UnnamedPtr);
476 Mem->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &UnnamedPtrRef);
480 uint64_t MD5Res = DIEHash().computeTypeSignature(Foo);
482 ASSERT_EQ(0x954e026f01c02529ULL, MD5Res);
485 // struct { struct foo { }; };
486 TEST(DIEHashTest, NestedType) {
487 DIE Unnamed(dwarf::DW_TAG_structure_type);
489 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
491 DIE *Foo = new DIE(dwarf::DW_TAG_structure_type);
492 DIEString FooStr(&One, "foo");
493 Foo->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FooStr);
494 Foo->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
496 Unnamed.addChild(Foo);
498 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
500 // The exact same hash GCC produces for this DIE.
501 ASSERT_EQ(0xde8a3b7b43807f4aULL, MD5Res);
504 // struct { static void func(); };
505 TEST(DIEHashTest, MemberFunc) {
506 DIE Unnamed(dwarf::DW_TAG_structure_type);
508 Unnamed.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
510 DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
511 DIEString FuncStr(&One, "func");
512 Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
514 Unnamed.addChild(Func);
516 uint64_t MD5Res = DIEHash().computeTypeSignature(Unnamed);
518 // The exact same hash GCC produces for this DIE.
519 ASSERT_EQ(0xd36a1b6dfb604ba0ULL, MD5Res);
523 // static void func();
525 TEST(DIEHashTest, MemberFuncFlag) {
526 DIE A(dwarf::DW_TAG_structure_type);
528 DIEString AStr(&One, "A");
529 A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
530 A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
531 A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
532 A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
534 DIE *Func = new DIE(dwarf::DW_TAG_subprogram);
535 DIEString FuncStr(&One, "func");
536 DIEString FuncLinkage(&One, "_ZN1A4funcEv");
538 Func->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
539 Func->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FuncStr);
540 Func->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
541 Func->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
542 Func->addValue(dwarf::DW_AT_linkage_name, dwarf::DW_FORM_strp, &FuncLinkage);
543 Func->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
547 uint64_t MD5Res = DIEHash().computeTypeSignature(A);
549 // The exact same hash GCC produces for this DIE.
550 ASSERT_EQ(0x8f78211ddce3df10ULL, MD5Res);
555 // const static int PI = -3;
558 TEST(DIEHashTest, MemberSdata) {
559 DIE A(dwarf::DW_TAG_structure_type);
561 DIEString AStr(&One, "A");
562 A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
563 A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
564 A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
565 A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
569 DIEString FStr(&One, "int");
570 DIE IntTyDIE(dwarf::DW_TAG_base_type);
571 IntTyDIE.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
572 IntTyDIE.addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Five);
573 IntTyDIE.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
575 DIEEntry IntTy(IntTyDIE);
576 DIE *PITyDIE = new DIE(dwarf::DW_TAG_const_type);
577 PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &IntTy);
579 DIEEntry PITy(*PITyDIE);
580 DIE *PI = new DIE(dwarf::DW_TAG_member);
581 DIEString PIStr(&One, "PI");
583 DIEInteger NegThree(-3);
584 PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
585 PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
586 PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
587 PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy);
588 PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
589 PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
590 PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, &NegThree);
594 uint64_t MD5Res = DIEHash().computeTypeSignature(A);
595 ASSERT_EQ(0x9a216000dd3788a7ULL, MD5Res);
600 // const static float PI = 3.14;
603 TEST(DIEHashTest, MemberBlock) {
604 DIE A(dwarf::DW_TAG_structure_type);
606 DIEString AStr(&One, "A");
607 A.addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &AStr);
608 A.addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &One);
609 A.addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
610 A.addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &One);
613 DIEString FStr(&One, "float");
614 DIE *FloatTyDIE = new DIE(dwarf::DW_TAG_base_type);
615 FloatTyDIE->addValue(dwarf::DW_AT_byte_size, dwarf::DW_FORM_data1, &Four);
616 FloatTyDIE->addValue(dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, &Four);
617 FloatTyDIE->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &FStr);
619 DIEEntry FloatTy(*FloatTyDIE);
620 DIE *PITyDIE = new DIE(dwarf::DW_TAG_const_type);
621 PITyDIE->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &FloatTy);
623 DIEEntry PITy(*PITyDIE);
624 DIE *PI = new DIE(dwarf::DW_TAG_member);
625 DIEString PIStr(&One, "PI");
627 PI->addValue(dwarf::DW_AT_name, dwarf::DW_FORM_strp, &PIStr);
628 PI->addValue(dwarf::DW_AT_decl_file, dwarf::DW_FORM_data1, &One);
629 PI->addValue(dwarf::DW_AT_decl_line, dwarf::DW_FORM_data1, &Two);
630 PI->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, &PITy);
631 PI->addValue(dwarf::DW_AT_external, dwarf::DW_FORM_flag_present, &One);
632 PI->addValue(dwarf::DW_AT_declaration, dwarf::DW_FORM_flag_present, &One);
635 DIEInteger Blk1(0xc3);
636 DIEInteger Blk2(0xf5);
637 DIEInteger Blk3(0x48);
638 DIEInteger Blk4(0x40);
640 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk1);
641 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk2);
642 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk3);
643 PIBlock.addValue((dwarf::Attribute)0, dwarf::DW_FORM_data1, &Blk4);
645 PI->addValue(dwarf::DW_AT_const_value, dwarf::DW_FORM_block1, &PIBlock);
649 uint64_t MD5Res = DIEHash().computeTypeSignature(A);
650 ASSERT_EQ(0x493af53ad3d3f651ULL, MD5Res);