StaticResolverTest.cpp revision cedee4b38f4786845183be7f5916dd520a170ae0
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