1//===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Link Time Optimization library. This library is 11// intended to be used by linker to optimize code at link time. 12// 13//===----------------------------------------------------------------------===// 14 15#include "LTOModule.h" 16#include "llvm/Constants.h" 17#include "llvm/LLVMContext.h" 18#include "llvm/Module.h" 19#include "llvm/Bitcode/ReaderWriter.h" 20#include "llvm/MC/MCExpr.h" 21#include "llvm/MC/MCInst.h" 22#include "llvm/MC/MCStreamer.h" 23#include "llvm/MC/MCSubtargetInfo.h" 24#include "llvm/MC/MCSymbol.h" 25#include "llvm/MC/MCTargetAsmParser.h" 26#include "llvm/MC/SubtargetFeature.h" 27#include "llvm/MC/MCParser/MCAsmParser.h" 28#include "llvm/Target/TargetRegisterInfo.h" 29#include "llvm/Support/CommandLine.h" 30#include "llvm/Support/Host.h" 31#include "llvm/Support/MemoryBuffer.h" 32#include "llvm/Support/Path.h" 33#include "llvm/Support/SourceMgr.h" 34#include "llvm/Support/TargetRegistry.h" 35#include "llvm/Support/TargetSelect.h" 36#include "llvm/Support/system_error.h" 37#include "llvm/ADT/OwningPtr.h" 38#include "llvm/ADT/Triple.h" 39using namespace llvm; 40 41static cl::opt<bool> 42EnableFPMAD("enable-fp-mad", 43 cl::desc("Enable less precise MAD instructions to be generated"), 44 cl::init(false)); 45 46static cl::opt<bool> 47DisableFPElim("disable-fp-elim", 48 cl::desc("Disable frame pointer elimination optimization"), 49 cl::init(false)); 50 51static cl::opt<bool> 52DisableFPElimNonLeaf("disable-non-leaf-fp-elim", 53 cl::desc("Disable frame pointer elimination optimization for non-leaf funcs"), 54 cl::init(false)); 55 56static cl::opt<bool> 57EnableUnsafeFPMath("enable-unsafe-fp-math", 58 cl::desc("Enable optimizations that may decrease FP precision"), 59 cl::init(false)); 60 61static cl::opt<bool> 62EnableNoInfsFPMath("enable-no-infs-fp-math", 63 cl::desc("Enable FP math optimizations that assume no +-Infs"), 64 cl::init(false)); 65 66static cl::opt<bool> 67EnableNoNaNsFPMath("enable-no-nans-fp-math", 68 cl::desc("Enable FP math optimizations that assume no NaNs"), 69 cl::init(false)); 70 71static cl::opt<bool> 72EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math", 73 cl::Hidden, 74 cl::desc("Force codegen to assume rounding mode can change dynamically"), 75 cl::init(false)); 76 77static cl::opt<bool> 78GenerateSoftFloatCalls("soft-float", 79 cl::desc("Generate software floating point library calls"), 80 cl::init(false)); 81 82static cl::opt<llvm::FloatABI::ABIType> 83FloatABIForCalls("float-abi", 84 cl::desc("Choose float ABI type"), 85 cl::init(FloatABI::Default), 86 cl::values( 87 clEnumValN(FloatABI::Default, "default", 88 "Target default float ABI type"), 89 clEnumValN(FloatABI::Soft, "soft", 90 "Soft float ABI (implied by -soft-float)"), 91 clEnumValN(FloatABI::Hard, "hard", 92 "Hard float ABI (uses FP registers)"), 93 clEnumValEnd)); 94 95static cl::opt<llvm::FPOpFusion::FPOpFusionMode> 96FuseFPOps("fp-contract", 97 cl::desc("Enable aggresive formation of fused FP ops"), 98 cl::init(FPOpFusion::Standard), 99 cl::values( 100 clEnumValN(FPOpFusion::Fast, "fast", 101 "Fuse FP ops whenever profitable"), 102 clEnumValN(FPOpFusion::Standard, "on", 103 "Only fuse 'blessed' FP ops."), 104 clEnumValN(FPOpFusion::Strict, "off", 105 "Only fuse FP ops when the result won't be effected."), 106 clEnumValEnd)); 107 108static cl::opt<bool> 109DontPlaceZerosInBSS("nozero-initialized-in-bss", 110 cl::desc("Don't place zero-initialized symbols into bss section"), 111 cl::init(false)); 112 113static cl::opt<bool> 114EnableGuaranteedTailCallOpt("tailcallopt", 115 cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."), 116 cl::init(false)); 117 118static cl::opt<bool> 119DisableTailCalls("disable-tail-calls", 120 cl::desc("Never emit tail calls"), 121 cl::init(false)); 122 123static cl::opt<unsigned> 124OverrideStackAlignment("stack-alignment", 125 cl::desc("Override default stack alignment"), 126 cl::init(0)); 127 128static cl::opt<bool> 129EnableRealignStack("realign-stack", 130 cl::desc("Realign stack if needed"), 131 cl::init(true)); 132 133static cl::opt<std::string> 134TrapFuncName("trap-func", cl::Hidden, 135 cl::desc("Emit a call to trap function rather than a trap instruction"), 136 cl::init("")); 137 138static cl::opt<bool> 139EnablePIE("enable-pie", 140 cl::desc("Assume the creation of a position independent executable."), 141 cl::init(false)); 142 143static cl::opt<bool> 144SegmentedStacks("segmented-stacks", 145 cl::desc("Use segmented stacks if possible."), 146 cl::init(false)); 147 148static cl::opt<bool> 149UseInitArray("use-init-array", 150 cl::desc("Use .init_array instead of .ctors."), 151 cl::init(false)); 152 153static cl::opt<unsigned> 154SSPBufferSize("stack-protector-buffer-size", cl::init(8), 155 cl::desc("Lower bound for a buffer to be considered for " 156 "stack protection")); 157 158LTOModule::LTOModule(llvm::Module *m, llvm::TargetMachine *t) 159 : _module(m), _target(t), 160 _context(*_target->getMCAsmInfo(), *_target->getRegisterInfo(), NULL), 161 _mangler(_context, *_target->getTargetData()) {} 162 163/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM 164/// bitcode. 165bool LTOModule::isBitcodeFile(const void *mem, size_t length) { 166 return llvm::sys::IdentifyFileType((const char*)mem, length) 167 == llvm::sys::Bitcode_FileType; 168} 169 170bool LTOModule::isBitcodeFile(const char *path) { 171 return llvm::sys::Path(path).isBitcodeFile(); 172} 173 174/// isBitcodeFileForTarget - Returns 'true' if the file (or memory contents) is 175/// LLVM bitcode for the specified triple. 176bool LTOModule::isBitcodeFileForTarget(const void *mem, size_t length, 177 const char *triplePrefix) { 178 MemoryBuffer *buffer = makeBuffer(mem, length); 179 if (!buffer) 180 return false; 181 return isTargetMatch(buffer, triplePrefix); 182} 183 184bool LTOModule::isBitcodeFileForTarget(const char *path, 185 const char *triplePrefix) { 186 OwningPtr<MemoryBuffer> buffer; 187 if (MemoryBuffer::getFile(path, buffer)) 188 return false; 189 return isTargetMatch(buffer.take(), triplePrefix); 190} 191 192/// isTargetMatch - Returns 'true' if the memory buffer is for the specified 193/// target triple. 194bool LTOModule::isTargetMatch(MemoryBuffer *buffer, const char *triplePrefix) { 195 std::string Triple = getBitcodeTargetTriple(buffer, getGlobalContext()); 196 delete buffer; 197 return strncmp(Triple.c_str(), triplePrefix, strlen(triplePrefix)) == 0; 198} 199 200/// makeLTOModule - Create an LTOModule. N.B. These methods take ownership of 201/// the buffer. 202LTOModule *LTOModule::makeLTOModule(const char *path, std::string &errMsg) { 203 OwningPtr<MemoryBuffer> buffer; 204 if (error_code ec = MemoryBuffer::getFile(path, buffer)) { 205 errMsg = ec.message(); 206 return NULL; 207 } 208 return makeLTOModule(buffer.take(), errMsg); 209} 210 211LTOModule *LTOModule::makeLTOModule(int fd, const char *path, 212 size_t size, std::string &errMsg) { 213 return makeLTOModule(fd, path, size, size, 0, errMsg); 214} 215 216LTOModule *LTOModule::makeLTOModule(int fd, const char *path, 217 size_t file_size, 218 size_t map_size, 219 off_t offset, 220 std::string &errMsg) { 221 OwningPtr<MemoryBuffer> buffer; 222 if (error_code ec = MemoryBuffer::getOpenFile(fd, path, buffer, file_size, 223 map_size, offset, false)) { 224 errMsg = ec.message(); 225 return NULL; 226 } 227 return makeLTOModule(buffer.take(), errMsg); 228} 229 230LTOModule *LTOModule::makeLTOModule(const void *mem, size_t length, 231 std::string &errMsg) { 232 OwningPtr<MemoryBuffer> buffer(makeBuffer(mem, length)); 233 if (!buffer) 234 return NULL; 235 return makeLTOModule(buffer.take(), errMsg); 236} 237 238void LTOModule::getTargetOptions(TargetOptions &Options) { 239 Options.LessPreciseFPMADOption = EnableFPMAD; 240 Options.NoFramePointerElim = DisableFPElim; 241 Options.NoFramePointerElimNonLeaf = DisableFPElimNonLeaf; 242 Options.AllowFPOpFusion = FuseFPOps; 243 Options.UnsafeFPMath = EnableUnsafeFPMath; 244 Options.NoInfsFPMath = EnableNoInfsFPMath; 245 Options.NoNaNsFPMath = EnableNoNaNsFPMath; 246 Options.HonorSignDependentRoundingFPMathOption = 247 EnableHonorSignDependentRoundingFPMath; 248 Options.UseSoftFloat = GenerateSoftFloatCalls; 249 if (FloatABIForCalls != FloatABI::Default) 250 Options.FloatABIType = FloatABIForCalls; 251 Options.NoZerosInBSS = DontPlaceZerosInBSS; 252 Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt; 253 Options.DisableTailCalls = DisableTailCalls; 254 Options.StackAlignmentOverride = OverrideStackAlignment; 255 Options.RealignStack = EnableRealignStack; 256 Options.TrapFuncName = TrapFuncName; 257 Options.PositionIndependentExecutable = EnablePIE; 258 Options.EnableSegmentedStacks = SegmentedStacks; 259 Options.UseInitArray = UseInitArray; 260 Options.SSPBufferSize = SSPBufferSize; 261} 262 263LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer, 264 std::string &errMsg) { 265 static bool Initialized = false; 266 if (!Initialized) { 267 InitializeAllTargets(); 268 InitializeAllTargetMCs(); 269 InitializeAllAsmParsers(); 270 Initialized = true; 271 } 272 273 // parse bitcode buffer 274 OwningPtr<Module> m(getLazyBitcodeModule(buffer, getGlobalContext(), 275 &errMsg)); 276 if (!m) { 277 delete buffer; 278 return NULL; 279 } 280 281 std::string TripleStr = m->getTargetTriple(); 282 if (TripleStr.empty()) 283 TripleStr = sys::getDefaultTargetTriple(); 284 llvm::Triple Triple(TripleStr); 285 286 // find machine architecture for this module 287 const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 288 if (!march) 289 return NULL; 290 291 // construct LTOModule, hand over ownership of module and target 292 SubtargetFeatures Features; 293 Features.getDefaultSubtargetFeatures(Triple); 294 std::string FeatureStr = Features.getString(); 295 // Set a default CPU for Darwin triples. 296 std::string CPU; 297 if (Triple.isOSDarwin()) { 298 if (Triple.getArch() == llvm::Triple::x86_64) 299 CPU = "core2"; 300 else if (Triple.getArch() == llvm::Triple::x86) 301 CPU = "yonah"; 302 } 303 TargetOptions Options; 304 getTargetOptions(Options); 305 TargetMachine *target = march->createTargetMachine(TripleStr, CPU, FeatureStr, 306 Options); 307 LTOModule *Ret = new LTOModule(m.take(), target); 308 if (Ret->parseSymbols(errMsg)) { 309 delete Ret; 310 return NULL; 311 } 312 313 return Ret; 314} 315 316/// makeBuffer - Create a MemoryBuffer from a memory range. 317MemoryBuffer *LTOModule::makeBuffer(const void *mem, size_t length) { 318 const char *startPtr = (const char*)mem; 319 return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), "", false); 320} 321 322/// objcClassNameFromExpression - Get string that the data pointer points to. 323bool LTOModule::objcClassNameFromExpression(Constant *c, std::string &name) { 324 if (ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { 325 Constant *op = ce->getOperand(0); 326 if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { 327 Constant *cn = gvn->getInitializer(); 328 if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { 329 if (ca->isCString()) { 330 name = ".objc_class_name_" + ca->getAsCString().str(); 331 return true; 332 } 333 } 334 } 335 } 336 return false; 337} 338 339/// addObjCClass - Parse i386/ppc ObjC class data structure. 340void LTOModule::addObjCClass(GlobalVariable *clgv) { 341 ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 342 if (!c) return; 343 344 // second slot in __OBJC,__class is pointer to superclass name 345 std::string superclassName; 346 if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { 347 NameAndAttributes info; 348 StringMap<NameAndAttributes>::value_type &entry = 349 _undefines.GetOrCreateValue(superclassName); 350 if (!entry.getValue().name) { 351 const char *symbolName = entry.getKey().data(); 352 info.name = symbolName; 353 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 354 info.isFunction = false; 355 info.symbol = clgv; 356 entry.setValue(info); 357 } 358 } 359 360 // third slot in __OBJC,__class is pointer to class name 361 std::string className; 362 if (objcClassNameFromExpression(c->getOperand(2), className)) { 363 StringSet::value_type &entry = _defines.GetOrCreateValue(className); 364 entry.setValue(1); 365 366 NameAndAttributes info; 367 info.name = entry.getKey().data(); 368 info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | 369 LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; 370 info.isFunction = false; 371 info.symbol = clgv; 372 _symbols.push_back(info); 373 } 374} 375 376/// addObjCCategory - Parse i386/ppc ObjC category data structure. 377void LTOModule::addObjCCategory(GlobalVariable *clgv) { 378 ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 379 if (!c) return; 380 381 // second slot in __OBJC,__category is pointer to target class name 382 std::string targetclassName; 383 if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) 384 return; 385 386 NameAndAttributes info; 387 StringMap<NameAndAttributes>::value_type &entry = 388 _undefines.GetOrCreateValue(targetclassName); 389 390 if (entry.getValue().name) 391 return; 392 393 const char *symbolName = entry.getKey().data(); 394 info.name = symbolName; 395 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 396 info.isFunction = false; 397 info.symbol = clgv; 398 entry.setValue(info); 399} 400 401/// addObjCClassRef - Parse i386/ppc ObjC class list data structure. 402void LTOModule::addObjCClassRef(GlobalVariable *clgv) { 403 std::string targetclassName; 404 if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) 405 return; 406 407 NameAndAttributes info; 408 StringMap<NameAndAttributes>::value_type &entry = 409 _undefines.GetOrCreateValue(targetclassName); 410 if (entry.getValue().name) 411 return; 412 413 const char *symbolName = entry.getKey().data(); 414 info.name = symbolName; 415 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 416 info.isFunction = false; 417 info.symbol = clgv; 418 entry.setValue(info); 419} 420 421/// addDefinedDataSymbol - Add a data symbol as defined to the list. 422void LTOModule::addDefinedDataSymbol(GlobalValue *v) { 423 // Add to list of defined symbols. 424 addDefinedSymbol(v, false); 425 426 if (!v->hasSection() /* || !isTargetDarwin */) 427 return; 428 429 // Special case i386/ppc ObjC data structures in magic sections: 430 // The issue is that the old ObjC object format did some strange 431 // contortions to avoid real linker symbols. For instance, the 432 // ObjC class data structure is allocated statically in the executable 433 // that defines that class. That data structures contains a pointer to 434 // its superclass. But instead of just initializing that part of the 435 // struct to the address of its superclass, and letting the static and 436 // dynamic linkers do the rest, the runtime works by having that field 437 // instead point to a C-string that is the name of the superclass. 438 // At runtime the objc initialization updates that pointer and sets 439 // it to point to the actual super class. As far as the linker 440 // knows it is just a pointer to a string. But then someone wanted the 441 // linker to issue errors at build time if the superclass was not found. 442 // So they figured out a way in mach-o object format to use an absolute 443 // symbols (.objc_class_name_Foo = 0) and a floating reference 444 // (.reference .objc_class_name_Bar) to cause the linker into erroring when 445 // a class was missing. 446 // The following synthesizes the implicit .objc_* symbols for the linker 447 // from the ObjC data structures generated by the front end. 448 449 // special case if this data blob is an ObjC class definition 450 if (v->getSection().compare(0, 15, "__OBJC,__class,") == 0) { 451 if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 452 addObjCClass(gv); 453 } 454 } 455 456 // special case if this data blob is an ObjC category definition 457 else if (v->getSection().compare(0, 18, "__OBJC,__category,") == 0) { 458 if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 459 addObjCCategory(gv); 460 } 461 } 462 463 // special case if this data blob is the list of referenced classes 464 else if (v->getSection().compare(0, 18, "__OBJC,__cls_refs,") == 0) { 465 if (GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 466 addObjCClassRef(gv); 467 } 468 } 469} 470 471/// addDefinedFunctionSymbol - Add a function symbol as defined to the list. 472void LTOModule::addDefinedFunctionSymbol(Function *f) { 473 // add to list of defined symbols 474 addDefinedSymbol(f, true); 475} 476 477/// addDefinedSymbol - Add a defined symbol to the list. 478void LTOModule::addDefinedSymbol(GlobalValue *def, bool isFunction) { 479 // ignore all llvm.* symbols 480 if (def->getName().startswith("llvm.")) 481 return; 482 483 // string is owned by _defines 484 SmallString<64> Buffer; 485 _mangler.getNameWithPrefix(Buffer, def, false); 486 487 // set alignment part log2() can have rounding errors 488 uint32_t align = def->getAlignment(); 489 uint32_t attr = align ? CountTrailingZeros_32(def->getAlignment()) : 0; 490 491 // set permissions part 492 if (isFunction) { 493 attr |= LTO_SYMBOL_PERMISSIONS_CODE; 494 } else { 495 GlobalVariable *gv = dyn_cast<GlobalVariable>(def); 496 if (gv && gv->isConstant()) 497 attr |= LTO_SYMBOL_PERMISSIONS_RODATA; 498 else 499 attr |= LTO_SYMBOL_PERMISSIONS_DATA; 500 } 501 502 // set definition part 503 if (def->hasWeakLinkage() || def->hasLinkOnceLinkage() || 504 def->hasLinkerPrivateWeakLinkage()) 505 attr |= LTO_SYMBOL_DEFINITION_WEAK; 506 else if (def->hasCommonLinkage()) 507 attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; 508 else 509 attr |= LTO_SYMBOL_DEFINITION_REGULAR; 510 511 // set scope part 512 if (def->hasHiddenVisibility()) 513 attr |= LTO_SYMBOL_SCOPE_HIDDEN; 514 else if (def->hasProtectedVisibility()) 515 attr |= LTO_SYMBOL_SCOPE_PROTECTED; 516 else if (def->hasExternalLinkage() || def->hasWeakLinkage() || 517 def->hasLinkOnceLinkage() || def->hasCommonLinkage() || 518 def->hasLinkerPrivateWeakLinkage()) 519 attr |= LTO_SYMBOL_SCOPE_DEFAULT; 520 else if (def->hasLinkOnceODRAutoHideLinkage()) 521 attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; 522 else 523 attr |= LTO_SYMBOL_SCOPE_INTERNAL; 524 525 StringSet::value_type &entry = _defines.GetOrCreateValue(Buffer); 526 entry.setValue(1); 527 528 // fill information structure 529 NameAndAttributes info; 530 StringRef Name = entry.getKey(); 531 info.name = Name.data(); 532 assert(info.name[Name.size()] == '\0'); 533 info.attributes = attr; 534 info.isFunction = isFunction; 535 info.symbol = def; 536 537 // add to table of symbols 538 _symbols.push_back(info); 539} 540 541/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the 542/// defined list. 543void LTOModule::addAsmGlobalSymbol(const char *name, 544 lto_symbol_attributes scope) { 545 StringSet::value_type &entry = _defines.GetOrCreateValue(name); 546 547 // only add new define if not already defined 548 if (entry.getValue()) 549 return; 550 551 entry.setValue(1); 552 553 NameAndAttributes &info = _undefines[entry.getKey().data()]; 554 555 if (info.symbol == 0) { 556 // FIXME: This is trying to take care of module ASM like this: 557 // 558 // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" 559 // 560 // but is gross and its mother dresses it funny. Have the ASM parser give us 561 // more details for this type of situation so that we're not guessing so 562 // much. 563 564 // fill information structure 565 info.name = entry.getKey().data(); 566 info.attributes = 567 LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; 568 info.isFunction = false; 569 info.symbol = 0; 570 571 // add to table of symbols 572 _symbols.push_back(info); 573 return; 574 } 575 576 if (info.isFunction) 577 addDefinedFunctionSymbol(cast<Function>(info.symbol)); 578 else 579 addDefinedDataSymbol(info.symbol); 580 581 _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; 582 _symbols.back().attributes |= scope; 583} 584 585/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the 586/// undefined list. 587void LTOModule::addAsmGlobalSymbolUndef(const char *name) { 588 StringMap<NameAndAttributes>::value_type &entry = 589 _undefines.GetOrCreateValue(name); 590 591 _asm_undefines.push_back(entry.getKey().data()); 592 593 // we already have the symbol 594 if (entry.getValue().name) 595 return; 596 597 uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED;; 598 attr |= LTO_SYMBOL_SCOPE_DEFAULT; 599 NameAndAttributes info; 600 info.name = entry.getKey().data(); 601 info.attributes = attr; 602 info.isFunction = false; 603 info.symbol = 0; 604 605 entry.setValue(info); 606} 607 608/// addPotentialUndefinedSymbol - Add a symbol which isn't defined just yet to a 609/// list to be resolved later. 610void LTOModule::addPotentialUndefinedSymbol(GlobalValue *decl, bool isFunc) { 611 // ignore all llvm.* symbols 612 if (decl->getName().startswith("llvm.")) 613 return; 614 615 // ignore all aliases 616 if (isa<GlobalAlias>(decl)) 617 return; 618 619 SmallString<64> name; 620 _mangler.getNameWithPrefix(name, decl, false); 621 622 StringMap<NameAndAttributes>::value_type &entry = 623 _undefines.GetOrCreateValue(name); 624 625 // we already have the symbol 626 if (entry.getValue().name) 627 return; 628 629 NameAndAttributes info; 630 631 info.name = entry.getKey().data(); 632 633 if (decl->hasExternalWeakLinkage()) 634 info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF; 635 else 636 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 637 638 info.isFunction = isFunc; 639 info.symbol = decl; 640 641 entry.setValue(info); 642} 643 644namespace { 645 class RecordStreamer : public MCStreamer { 646 public: 647 enum State { NeverSeen, Global, Defined, DefinedGlobal, Used }; 648 649 private: 650 StringMap<State> Symbols; 651 652 void markDefined(const MCSymbol &Symbol) { 653 State &S = Symbols[Symbol.getName()]; 654 switch (S) { 655 case DefinedGlobal: 656 case Global: 657 S = DefinedGlobal; 658 break; 659 case NeverSeen: 660 case Defined: 661 case Used: 662 S = Defined; 663 break; 664 } 665 } 666 void markGlobal(const MCSymbol &Symbol) { 667 State &S = Symbols[Symbol.getName()]; 668 switch (S) { 669 case DefinedGlobal: 670 case Defined: 671 S = DefinedGlobal; 672 break; 673 674 case NeverSeen: 675 case Global: 676 case Used: 677 S = Global; 678 break; 679 } 680 } 681 void markUsed(const MCSymbol &Symbol) { 682 State &S = Symbols[Symbol.getName()]; 683 switch (S) { 684 case DefinedGlobal: 685 case Defined: 686 case Global: 687 break; 688 689 case NeverSeen: 690 case Used: 691 S = Used; 692 break; 693 } 694 } 695 696 // FIXME: mostly copied for the obj streamer. 697 void AddValueSymbols(const MCExpr *Value) { 698 switch (Value->getKind()) { 699 case MCExpr::Target: 700 // FIXME: What should we do in here? 701 break; 702 703 case MCExpr::Constant: 704 break; 705 706 case MCExpr::Binary: { 707 const MCBinaryExpr *BE = cast<MCBinaryExpr>(Value); 708 AddValueSymbols(BE->getLHS()); 709 AddValueSymbols(BE->getRHS()); 710 break; 711 } 712 713 case MCExpr::SymbolRef: 714 markUsed(cast<MCSymbolRefExpr>(Value)->getSymbol()); 715 break; 716 717 case MCExpr::Unary: 718 AddValueSymbols(cast<MCUnaryExpr>(Value)->getSubExpr()); 719 break; 720 } 721 } 722 723 public: 724 typedef StringMap<State>::const_iterator const_iterator; 725 726 const_iterator begin() { 727 return Symbols.begin(); 728 } 729 730 const_iterator end() { 731 return Symbols.end(); 732 } 733 734 RecordStreamer(MCContext &Context) : MCStreamer(Context) {} 735 736 virtual void EmitInstruction(const MCInst &Inst) { 737 // Scan for values. 738 for (unsigned i = Inst.getNumOperands(); i--; ) 739 if (Inst.getOperand(i).isExpr()) 740 AddValueSymbols(Inst.getOperand(i).getExpr()); 741 } 742 virtual void EmitLabel(MCSymbol *Symbol) { 743 Symbol->setSection(*getCurrentSection()); 744 markDefined(*Symbol); 745 } 746 virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { 747 // FIXME: should we handle aliases? 748 markDefined(*Symbol); 749 } 750 virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) { 751 if (Attribute == MCSA_Global) 752 markGlobal(*Symbol); 753 } 754 virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 755 uint64_t Size , unsigned ByteAlignment) { 756 markDefined(*Symbol); 757 } 758 virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 759 unsigned ByteAlignment) { 760 markDefined(*Symbol); 761 } 762 763 // Noop calls. 764 virtual void ChangeSection(const MCSection *Section) {} 765 virtual void InitSections() {} 766 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {} 767 virtual void EmitThumbFunc(MCSymbol *Func) {} 768 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {} 769 virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {} 770 virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) {} 771 virtual void EmitCOFFSymbolStorageClass(int StorageClass) {} 772 virtual void EmitCOFFSymbolType(int Type) {} 773 virtual void EndCOFFSymbolDef() {} 774 virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {} 775 virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 776 unsigned ByteAlignment) {} 777 virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 778 uint64_t Size, unsigned ByteAlignment) {} 779 virtual void EmitBytes(StringRef Data, unsigned AddrSpace) {} 780 virtual void EmitValueImpl(const MCExpr *Value, unsigned Size, 781 unsigned AddrSpace) {} 782 virtual void EmitULEB128Value(const MCExpr *Value) {} 783 virtual void EmitSLEB128Value(const MCExpr *Value) {} 784 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, 785 unsigned ValueSize, 786 unsigned MaxBytesToEmit) {} 787 virtual void EmitCodeAlignment(unsigned ByteAlignment, 788 unsigned MaxBytesToEmit) {} 789 virtual bool EmitValueToOffset(const MCExpr *Offset, 790 unsigned char Value ) { return false; } 791 virtual void EmitFileDirective(StringRef Filename) {} 792 virtual void EmitDwarfAdvanceLineAddr(int64_t LineDelta, 793 const MCSymbol *LastLabel, 794 const MCSymbol *Label, 795 unsigned PointerSize) {} 796 virtual void FinishImpl() {} 797 }; 798} // end anonymous namespace 799 800/// addAsmGlobalSymbols - Add global symbols from module-level ASM to the 801/// defined or undefined lists. 802bool LTOModule::addAsmGlobalSymbols(std::string &errMsg) { 803 const std::string &inlineAsm = _module->getModuleInlineAsm(); 804 if (inlineAsm.empty()) 805 return false; 806 807 OwningPtr<RecordStreamer> Streamer(new RecordStreamer(_context)); 808 MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(inlineAsm); 809 SourceMgr SrcMgr; 810 SrcMgr.AddNewSourceBuffer(Buffer, SMLoc()); 811 OwningPtr<MCAsmParser> Parser(createMCAsmParser(SrcMgr, 812 _context, *Streamer, 813 *_target->getMCAsmInfo())); 814 const Target &T = _target->getTarget(); 815 OwningPtr<MCSubtargetInfo> 816 STI(T.createMCSubtargetInfo(_target->getTargetTriple(), 817 _target->getTargetCPU(), 818 _target->getTargetFeatureString())); 819 OwningPtr<MCTargetAsmParser> TAP(T.createMCAsmParser(*STI, *Parser.get())); 820 if (!TAP) { 821 errMsg = "target " + std::string(T.getName()) + 822 " does not define AsmParser."; 823 return true; 824 } 825 826 Parser->setTargetParser(*TAP); 827 if (Parser->Run(false)) 828 return true; 829 830 for (RecordStreamer::const_iterator i = Streamer->begin(), 831 e = Streamer->end(); i != e; ++i) { 832 StringRef Key = i->first(); 833 RecordStreamer::State Value = i->second; 834 if (Value == RecordStreamer::DefinedGlobal) 835 addAsmGlobalSymbol(Key.data(), LTO_SYMBOL_SCOPE_DEFAULT); 836 else if (Value == RecordStreamer::Defined) 837 addAsmGlobalSymbol(Key.data(), LTO_SYMBOL_SCOPE_INTERNAL); 838 else if (Value == RecordStreamer::Global || 839 Value == RecordStreamer::Used) 840 addAsmGlobalSymbolUndef(Key.data()); 841 } 842 843 return false; 844} 845 846/// isDeclaration - Return 'true' if the global value is a declaration. 847static bool isDeclaration(const GlobalValue &V) { 848 if (V.hasAvailableExternallyLinkage()) 849 return true; 850 851 if (V.isMaterializable()) 852 return false; 853 854 return V.isDeclaration(); 855} 856 857/// parseSymbols - Parse the symbols from the module and model-level ASM and add 858/// them to either the defined or undefined lists. 859bool LTOModule::parseSymbols(std::string &errMsg) { 860 // add functions 861 for (Module::iterator f = _module->begin(), e = _module->end(); f != e; ++f) { 862 if (isDeclaration(*f)) 863 addPotentialUndefinedSymbol(f, true); 864 else 865 addDefinedFunctionSymbol(f); 866 } 867 868 // add data 869 for (Module::global_iterator v = _module->global_begin(), 870 e = _module->global_end(); v != e; ++v) { 871 if (isDeclaration(*v)) 872 addPotentialUndefinedSymbol(v, false); 873 else 874 addDefinedDataSymbol(v); 875 } 876 877 // add asm globals 878 if (addAsmGlobalSymbols(errMsg)) 879 return true; 880 881 // add aliases 882 for (Module::alias_iterator a = _module->alias_begin(), 883 e = _module->alias_end(); a != e; ++a) { 884 if (isDeclaration(*a->getAliasedGlobal())) 885 // Is an alias to a declaration. 886 addPotentialUndefinedSymbol(a, false); 887 else 888 addDefinedDataSymbol(a); 889 } 890 891 // make symbols for all undefines 892 for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), 893 e = _undefines.end(); u != e; ++u) { 894 // If this symbol also has a definition, then don't make an undefine because 895 // it is a tentative definition. 896 if (_defines.count(u->getKey())) continue; 897 NameAndAttributes info = u->getValue(); 898 _symbols.push_back(info); 899 } 900 901 return false; 902} 903