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