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