DIEHashTest.cpp revision 449f036a8141b9032ff310ecbe0ab4433c5c307b 
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
17using namespace llvm;
18
19namespace {
20TEST(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 {};
30TEST(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 { };
45TEST(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 { }; }
59TEST(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; };
85TEST(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; };
114TEST(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; };
152TEST(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; };
174TEST(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; };
203TEST(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; };
236TEST(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