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