StaticResolverTest.cpp revision 22add6ff3426df1a85089fe6a6e1597ee3b6f300 
1//===- implTest.cpp -------------------------------------------------------===//
2//
3//                     The MCLinker Project
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9#include "StaticResolverTest.h"
10#include <mcld/Support/TargetSelect.h>
11#include <mcld/LD/StaticResolver.h>
12#include <mcld/LD/ResolveInfo.h>
13#include <mcld/LinkerConfig.h>
14
15#include <mcld/Support/FileSystem.h>
16
17using namespace mcld;
18using namespace mcldtest;
19
20//===----------------------------------------------------------------------===//
21// StaticResolverTest
22//===----------------------------------------------------------------------===//
23// Constructor can do set-up work for all test here.
24StaticResolverTest::StaticResolverTest()
25  : m_pResolver(NULL), m_pConfig(NULL) {
26  // create testee. modify it if need
27  m_pResolver = new StaticResolver();
28
29  mcld::InitializeAllDiagnostics();
30
31  m_pConfig = new LinkerConfig("arm-none-linux-gnueabi");
32}
33
34// Destructor can do clean-up work that doesn't throw exceptions here.
35StaticResolverTest::~StaticResolverTest()
36{
37  delete m_pResolver;
38  delete m_pConfig;
39}
40
41// SetUp() will be called immediately before each test.
42void StaticResolverTest::SetUp()
43{
44}
45
46// TearDown() will be called immediately after each test.
47void StaticResolverTest::TearDown()
48{
49}
50
51//==========================================================================//
52// Testcases
53//
54TEST_F( StaticResolverTest, MDEF ) {
55  ResolveInfo* old_sym = ResolveInfo::Create("abc");
56  ResolveInfo* new_sym = ResolveInfo::Create("abc");
57  new_sym->setDesc(ResolveInfo::Define);
58  old_sym->setDesc(ResolveInfo::Define);
59  ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
60  ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
61  ASSERT_TRUE( mcld::ResolveInfo::define_flag == new_sym->info());
62  ASSERT_TRUE( mcld::ResolveInfo::define_flag == old_sym->info());
63  bool override = true;
64  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
65  ASSERT_TRUE(result);
66  ASSERT_FALSE( override );
67}
68
69TEST_F( StaticResolverTest, DynDefAfterDynUndef ) {
70  ResolveInfo* old_sym = ResolveInfo::Create("abc");
71  ResolveInfo* new_sym = ResolveInfo::Create("abc");
72
73  new_sym->setBinding(ResolveInfo::Global);
74  old_sym->setBinding(ResolveInfo::Global);
75  new_sym->setDesc(ResolveInfo::Undefined);
76  old_sym->setDesc(ResolveInfo::Define);
77  new_sym->setSource(true);
78  old_sym->setSource(true);
79
80  new_sym->setSize(0);
81
82  old_sym->setSize(1);
83
84  ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
85  ASSERT_TRUE( mcld::ResolveInfo::Global == old_sym->binding());
86  ASSERT_TRUE( mcld::ResolveInfo::Undefined == new_sym->desc());
87  ASSERT_TRUE( mcld::ResolveInfo::Define    == old_sym->desc());
88
89  bool override = false;
90  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
91  ASSERT_TRUE(result);
92  ASSERT_FALSE( override );
93  ASSERT_TRUE(1 == old_sym->size());
94}
95
96TEST_F( StaticResolverTest, DynDefAfterDynDef ) {
97  ResolveInfo* old_sym = ResolveInfo::Create("abc");
98  ResolveInfo* new_sym = ResolveInfo::Create("abc");
99
100  new_sym->setBinding(ResolveInfo::Global);
101  old_sym->setBinding(ResolveInfo::Global);
102  new_sym->setDesc(ResolveInfo::Define);
103  old_sym->setDesc(ResolveInfo::Define);
104  new_sym->setSource(true);
105  old_sym->setSource(true);
106
107  new_sym->setSize(0);
108
109  old_sym->setSize(1);
110
111  ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
112  ASSERT_TRUE( mcld::ResolveInfo::Global == old_sym->binding());
113  ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
114  ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
115
116  bool override = false;
117  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
118  ASSERT_TRUE(result);
119  ASSERT_FALSE( override );
120  ASSERT_TRUE(1 == old_sym->size());
121}
122
123TEST_F( StaticResolverTest, DynUndefAfterDynUndef ) {
124  ResolveInfo* old_sym = ResolveInfo::Create("abc");
125  ResolveInfo* new_sym = ResolveInfo::Create("abc");
126
127  new_sym->setBinding(ResolveInfo::Global);
128  old_sym->setBinding(ResolveInfo::Global);
129  new_sym->setDesc(ResolveInfo::Undefined);
130  old_sym->setDesc(ResolveInfo::Undefined);
131  new_sym->setSource(true);
132  old_sym->setSource(true);
133
134  new_sym->setSize(0);
135
136  old_sym->setSize(1);
137
138  ASSERT_TRUE( mcld::ResolveInfo::Global    == new_sym->binding());
139  ASSERT_TRUE( mcld::ResolveInfo::Global    == old_sym->binding());
140  ASSERT_TRUE( mcld::ResolveInfo::Undefined == new_sym->desc());
141  ASSERT_TRUE( mcld::ResolveInfo::Undefined ==  old_sym->desc());
142
143  bool override = false;
144  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
145  ASSERT_TRUE(result);
146  ASSERT_FALSE( override );
147  ASSERT_TRUE(1 == old_sym->size());
148}
149
150TEST_F( StaticResolverTest, OverrideWeakByGlobal )
151{
152  ResolveInfo* old_sym = ResolveInfo::Create("abc");
153  ResolveInfo* new_sym = ResolveInfo::Create("abc");
154
155  new_sym->setBinding(ResolveInfo::Global);
156  old_sym->setBinding(ResolveInfo::Weak);
157  new_sym->setSize(0);
158  old_sym->setSize(1);
159
160  ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
161  ASSERT_TRUE( mcld::ResolveInfo::Weak == old_sym->binding());
162
163  ASSERT_TRUE( mcld::ResolveInfo::global_flag == new_sym->info());
164  ASSERT_TRUE( mcld::ResolveInfo::weak_flag == old_sym->info());
165  bool override = false;
166  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
167  ASSERT_TRUE(result);
168  ASSERT_TRUE( override );
169  ASSERT_TRUE(0 == old_sym->size());
170}
171
172TEST_F( StaticResolverTest, DynWeakAfterDynDef ) {
173  ResolveInfo* old_sym = ResolveInfo::Create("abc");
174  ResolveInfo* new_sym = ResolveInfo::Create("abc");
175
176  old_sym->setBinding(ResolveInfo::Weak);
177  new_sym->setBinding(ResolveInfo::Global);
178
179  new_sym->setSource(true);
180  old_sym->setSource(true);
181
182  old_sym->setDesc(ResolveInfo::Define);
183  new_sym->setDesc(ResolveInfo::Define);
184
185  new_sym->setSize(0);
186
187  old_sym->setSize(1);
188
189  ASSERT_TRUE( mcld::ResolveInfo::Weak   == old_sym->binding());
190  ASSERT_TRUE( mcld::ResolveInfo::Global == new_sym->binding());
191  ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
192  ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
193
194  bool override = false;
195  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
196  ASSERT_TRUE(result);
197  ASSERT_FALSE( override );
198  ASSERT_TRUE(1 == old_sym->size());
199}
200
201TEST_F( StaticResolverTest, MarkByBiggerCommon )
202{
203  ResolveInfo* old_sym = ResolveInfo::Create("abc");
204  ResolveInfo* new_sym = ResolveInfo::Create("abc");
205
206  new_sym->setDesc(ResolveInfo::Common);
207  old_sym->setDesc(ResolveInfo::Common);
208  new_sym->setSize(999);
209  old_sym->setSize(0);
210
211  ASSERT_TRUE( mcld::ResolveInfo::Common == new_sym->desc());
212  ASSERT_TRUE( mcld::ResolveInfo::Common == old_sym->desc());
213
214  ASSERT_TRUE( mcld::ResolveInfo::common_flag == new_sym->info());
215  ASSERT_TRUE( mcld::ResolveInfo::common_flag == old_sym->info());
216  bool override = true;
217  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
218  ASSERT_TRUE(result);
219  ASSERT_FALSE( override );
220  ASSERT_TRUE(999 == old_sym->size());
221}
222
223TEST_F( StaticResolverTest, OverrideByBiggerCommon )
224{
225  ResolveInfo* old_sym = ResolveInfo::Create("abc");
226  ResolveInfo* new_sym = ResolveInfo::Create("abc");
227
228  new_sym->setDesc(ResolveInfo::Common);
229  old_sym->setDesc(ResolveInfo::Common);
230  old_sym->setBinding(ResolveInfo::Weak);
231  new_sym->setSize(999);
232  old_sym->setSize(0);
233
234  ASSERT_TRUE( ResolveInfo::Common == new_sym->desc());
235  ASSERT_TRUE( ResolveInfo::Common == old_sym->desc());
236  ASSERT_TRUE( ResolveInfo::Weak == old_sym->binding());
237
238  ASSERT_TRUE( ResolveInfo::common_flag == new_sym->info());
239  ASSERT_TRUE( (ResolveInfo::weak_flag | ResolveInfo::common_flag) == old_sym->info());
240
241  bool override = false;
242  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
243  ASSERT_TRUE(result);
244  ASSERT_TRUE( override );
245  ASSERT_TRUE(999 == old_sym->size());
246}
247
248TEST_F( StaticResolverTest, OverrideCommonByDefine)
249{
250  ResolveInfo* old_sym = ResolveInfo::Create("abc");
251  ResolveInfo* new_sym = ResolveInfo::Create("abc");
252
253  old_sym->setDesc(ResolveInfo::Common);
254  old_sym->setSize(0);
255
256  new_sym->setDesc(ResolveInfo::Define);
257  new_sym->setSize(999);
258
259  ASSERT_TRUE( ResolveInfo::Define == new_sym->desc());
260  ASSERT_TRUE( ResolveInfo::Common == old_sym->desc());
261
262  ASSERT_TRUE( ResolveInfo::define_flag == new_sym->info());
263  ASSERT_TRUE( ResolveInfo::common_flag == old_sym->info());
264
265  bool override = false;
266  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
267  ASSERT_TRUE(result);
268  ASSERT_TRUE( override );
269  ASSERT_TRUE(999 == old_sym->size());
270}
271
272TEST_F( StaticResolverTest, SetUpDesc)
273{
274  ResolveInfo* sym = ResolveInfo::Create("abc");
275
276  sym->setIsSymbol(true);
277
278//  ASSERT_FALSE( sym->isSymbol() );
279  ASSERT_TRUE( sym->isSymbol() );
280  ASSERT_TRUE( sym->isGlobal() );
281  ASSERT_FALSE( sym->isWeak() );
282  ASSERT_FALSE( sym->isLocal() );
283  ASSERT_FALSE( sym->isDefine() );
284  ASSERT_TRUE( sym->isUndef() );
285  ASSERT_FALSE( sym->isDyn() );
286  ASSERT_FALSE( sym->isCommon() );
287  ASSERT_FALSE( sym->isIndirect() );
288  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
289  ASSERT_TRUE( 0 == sym->desc() );
290  ASSERT_TRUE( 0 == sym->binding() );
291  ASSERT_TRUE( 0 == sym->other() );
292
293  sym->setIsSymbol(false);
294  ASSERT_FALSE( sym->isSymbol() );
295//  ASSERT_TRUE( sym->isSymbol() );
296  ASSERT_TRUE( sym->isGlobal() );
297  ASSERT_FALSE( sym->isWeak() );
298  ASSERT_FALSE( sym->isLocal() );
299  ASSERT_FALSE( sym->isDefine() );
300  ASSERT_TRUE( sym->isUndef() );
301  ASSERT_FALSE( sym->isDyn() );
302  ASSERT_FALSE( sym->isCommon() );
303  ASSERT_FALSE( sym->isIndirect() );
304  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
305  ASSERT_TRUE( 0 == sym->desc() );
306  ASSERT_TRUE( 0 == sym->binding() );
307  ASSERT_TRUE( 0 == sym->other() );
308
309  sym->setDesc(ResolveInfo::Define);
310  ASSERT_FALSE( sym->isSymbol() );
311//  ASSERT_TRUE( sym->isSymbol() );
312  ASSERT_TRUE( sym->isGlobal() );
313  ASSERT_FALSE( sym->isWeak() );
314  ASSERT_FALSE( sym->isLocal() );
315  ASSERT_TRUE( sym->isDefine() );
316  ASSERT_FALSE( sym->isUndef() );
317  ASSERT_FALSE( sym->isDyn() );
318  ASSERT_FALSE( sym->isCommon() );
319  ASSERT_FALSE( sym->isIndirect() );
320  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
321  ASSERT_TRUE( ResolveInfo::Define == sym->desc() );
322  ASSERT_TRUE( 0 == sym->binding() );
323  ASSERT_TRUE( 0 == sym->other() );
324
325  sym->setDesc(ResolveInfo::Common);
326  ASSERT_FALSE( sym->isSymbol() );
327//  ASSERT_TRUE( sym->isSymbol() );
328  ASSERT_TRUE( sym->isGlobal() );
329  ASSERT_FALSE( sym->isWeak() );
330  ASSERT_FALSE( sym->isLocal() );
331  ASSERT_FALSE( sym->isDyn() );
332  ASSERT_FALSE( sym->isDefine() );
333  ASSERT_FALSE( sym->isUndef() );
334  ASSERT_TRUE( sym->isCommon() );
335  ASSERT_FALSE( sym->isIndirect() );
336  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
337  ASSERT_TRUE( ResolveInfo::Common == sym->desc() );
338  ASSERT_TRUE( 0 == sym->binding() );
339  ASSERT_TRUE( 0 == sym->other() );
340
341  sym->setDesc(ResolveInfo::Indirect);
342  ASSERT_FALSE( sym->isSymbol() );
343  ASSERT_TRUE( sym->isGlobal() );
344  ASSERT_FALSE( sym->isWeak() );
345  ASSERT_FALSE( sym->isLocal() );
346  ASSERT_FALSE( sym->isDyn() );
347  ASSERT_FALSE( sym->isDefine() );
348  ASSERT_FALSE( sym->isUndef() );
349  ASSERT_FALSE( sym->isCommon() );
350  ASSERT_TRUE( sym->isIndirect() );
351  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
352  ASSERT_TRUE( ResolveInfo::Indirect == sym->desc() );
353  ASSERT_TRUE( 0 == sym->binding() );
354  ASSERT_TRUE( 0 == sym->other() );
355
356  sym->setDesc(ResolveInfo::Undefined);
357  ASSERT_FALSE( sym->isSymbol() );
358  ASSERT_TRUE( sym->isGlobal() );
359  ASSERT_FALSE( sym->isWeak() );
360  ASSERT_FALSE( sym->isLocal() );
361  ASSERT_FALSE( sym->isDyn() );
362  ASSERT_TRUE( sym->isUndef() );
363  ASSERT_FALSE( sym->isDefine() );
364  ASSERT_FALSE( sym->isCommon() );
365  ASSERT_FALSE( sym->isIndirect() );
366  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
367  ASSERT_TRUE( 0 == sym->desc() );
368  ASSERT_TRUE( 0 == sym->binding() );
369  ASSERT_TRUE( 0 == sym->other() );
370}
371
372TEST_F( StaticResolverTest, SetUpBinding)
373{
374  ResolveInfo* sym = ResolveInfo::Create("abc");
375
376  sym->setIsSymbol(true);
377
378//  ASSERT_FALSE( sym->isSymbol() );
379  ASSERT_TRUE( sym->isSymbol() );
380  ASSERT_TRUE( sym->isGlobal() );
381  ASSERT_FALSE( sym->isWeak() );
382  ASSERT_FALSE( sym->isLocal() );
383  ASSERT_FALSE( sym->isDefine() );
384  ASSERT_TRUE( sym->isUndef() );
385  ASSERT_FALSE( sym->isDyn() );
386  ASSERT_FALSE( sym->isCommon() );
387  ASSERT_FALSE( sym->isIndirect() );
388  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
389  ASSERT_TRUE( 0 == sym->desc() );
390  ASSERT_TRUE( 0 == sym->binding() );
391  ASSERT_TRUE( 0 == sym->other() );
392
393  sym->setBinding(ResolveInfo::Global);
394  ASSERT_TRUE( sym->isSymbol() );
395  ASSERT_TRUE( sym->isGlobal() );
396  ASSERT_FALSE( sym->isWeak() );
397  ASSERT_FALSE( sym->isLocal() );
398  ASSERT_FALSE( sym->isDefine() );
399  ASSERT_TRUE( sym->isUndef() );
400  ASSERT_FALSE( sym->isDyn() );
401  ASSERT_FALSE( sym->isCommon() );
402  ASSERT_FALSE( sym->isIndirect() );
403  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
404  ASSERT_TRUE( 0 == sym->desc() );
405  ASSERT_TRUE( ResolveInfo::Global == sym->binding() );
406  ASSERT_TRUE( 0 == sym->other() );
407
408  sym->setBinding(ResolveInfo::Weak);
409  ASSERT_TRUE( sym->isSymbol() );
410  ASSERT_FALSE( sym->isGlobal() );
411  ASSERT_TRUE( sym->isWeak() );
412  ASSERT_FALSE( sym->isLocal() );
413  ASSERT_FALSE( sym->isDyn() );
414  ASSERT_FALSE( sym->isDefine() );
415  ASSERT_TRUE( sym->isUndef() );
416  ASSERT_FALSE( sym->isCommon() );
417  ASSERT_FALSE( sym->isIndirect() );
418  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
419  ASSERT_TRUE( 0 == sym->desc() );
420  ASSERT_TRUE( ResolveInfo::Weak == sym->binding() );
421  ASSERT_TRUE( 0 == sym->other() );
422
423  sym->setBinding(ResolveInfo::Local);
424  ASSERT_TRUE( sym->isSymbol() );
425  ASSERT_FALSE( sym->isGlobal() );
426  ASSERT_FALSE( sym->isWeak() );
427  ASSERT_TRUE( sym->isLocal() );
428  ASSERT_FALSE( sym->isDyn() );
429  ASSERT_FALSE( sym->isDefine() );
430  ASSERT_TRUE( sym->isUndef() );
431  ASSERT_FALSE( sym->isCommon() );
432  ASSERT_FALSE( sym->isIndirect() );
433  ASSERT_TRUE( ResolveInfo::NoType == sym->type());
434  ASSERT_TRUE( 0 == sym->desc() );
435  ASSERT_TRUE( ResolveInfo::Local == sym->binding() );
436  ASSERT_TRUE( 0 == sym->other() );
437}
438
439