LTOModule.cpp revision 344779
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 "llvm/LTO/legacy/LTOModule.h" 16#include "llvm/ADT/Triple.h" 17#include "llvm/Bitcode/BitcodeReader.h" 18#include "llvm/CodeGen/TargetSubtargetInfo.h" 19#include "llvm/IR/Constants.h" 20#include "llvm/IR/LLVMContext.h" 21#include "llvm/IR/Mangler.h" 22#include "llvm/IR/Metadata.h" 23#include "llvm/IR/Module.h" 24#include "llvm/MC/MCExpr.h" 25#include "llvm/MC/MCInst.h" 26#include "llvm/MC/MCParser/MCAsmParser.h" 27#include "llvm/MC/MCSection.h" 28#include "llvm/MC/MCSubtargetInfo.h" 29#include "llvm/MC/MCSymbol.h" 30#include "llvm/MC/SubtargetFeature.h" 31#include "llvm/Object/IRObjectFile.h" 32#include "llvm/Object/ObjectFile.h" 33#include "llvm/Support/FileSystem.h" 34#include "llvm/Support/Host.h" 35#include "llvm/Support/MemoryBuffer.h" 36#include "llvm/Support/Path.h" 37#include "llvm/Support/SourceMgr.h" 38#include "llvm/Support/TargetRegistry.h" 39#include "llvm/Support/TargetSelect.h" 40#include "llvm/Target/TargetLoweringObjectFile.h" 41#include "llvm/Transforms/Utils/GlobalStatus.h" 42#include <system_error> 43using namespace llvm; 44using namespace llvm::object; 45 46LTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef, 47 llvm::TargetMachine *TM) 48 : Mod(std::move(M)), MBRef(MBRef), _target(TM) { 49 SymTab.addModule(Mod.get()); 50} 51 52LTOModule::~LTOModule() {} 53 54/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM 55/// bitcode. 56bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) { 57 Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 58 MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>")); 59 return !errorToBool(BCData.takeError()); 60} 61 62bool LTOModule::isBitcodeFile(StringRef Path) { 63 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 64 MemoryBuffer::getFile(Path); 65 if (!BufferOrErr) 66 return false; 67 68 Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 69 BufferOrErr.get()->getMemBufferRef()); 70 return !errorToBool(BCData.takeError()); 71} 72 73bool LTOModule::isThinLTO() { 74 Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef); 75 if (!Result) { 76 logAllUnhandledErrors(Result.takeError(), errs()); 77 return false; 78 } 79 return Result->IsThinLTO; 80} 81 82bool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer, 83 StringRef TriplePrefix) { 84 Expected<MemoryBufferRef> BCOrErr = 85 IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 86 if (errorToBool(BCOrErr.takeError())) 87 return false; 88 LLVMContext Context; 89 ErrorOr<std::string> TripleOrErr = 90 expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr)); 91 if (!TripleOrErr) 92 return false; 93 return StringRef(*TripleOrErr).startswith(TriplePrefix); 94} 95 96std::string LTOModule::getProducerString(MemoryBuffer *Buffer) { 97 Expected<MemoryBufferRef> BCOrErr = 98 IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 99 if (errorToBool(BCOrErr.takeError())) 100 return ""; 101 LLVMContext Context; 102 ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors( 103 Context, getBitcodeProducerString(*BCOrErr)); 104 if (!ProducerOrErr) 105 return ""; 106 return *ProducerOrErr; 107} 108 109ErrorOr<std::unique_ptr<LTOModule>> 110LTOModule::createFromFile(LLVMContext &Context, StringRef path, 111 const TargetOptions &options) { 112 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 113 MemoryBuffer::getFile(path); 114 if (std::error_code EC = BufferOrErr.getError()) { 115 Context.emitError(EC.message()); 116 return EC; 117 } 118 std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 119 return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 120 /* ShouldBeLazy*/ false); 121} 122 123ErrorOr<std::unique_ptr<LTOModule>> 124LTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path, 125 size_t size, const TargetOptions &options) { 126 return createFromOpenFileSlice(Context, fd, path, size, 0, options); 127} 128 129ErrorOr<std::unique_ptr<LTOModule>> 130LTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path, 131 size_t map_size, off_t offset, 132 const TargetOptions &options) { 133 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 134 MemoryBuffer::getOpenFileSlice(fd, path, map_size, offset); 135 if (std::error_code EC = BufferOrErr.getError()) { 136 Context.emitError(EC.message()); 137 return EC; 138 } 139 std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 140 return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 141 /* ShouldBeLazy */ false); 142} 143 144ErrorOr<std::unique_ptr<LTOModule>> 145LTOModule::createFromBuffer(LLVMContext &Context, const void *mem, 146 size_t length, const TargetOptions &options, 147 StringRef path) { 148 StringRef Data((const char *)mem, length); 149 MemoryBufferRef Buffer(Data, path); 150 return makeLTOModule(Buffer, options, Context, /* ShouldBeLazy */ false); 151} 152 153ErrorOr<std::unique_ptr<LTOModule>> 154LTOModule::createInLocalContext(std::unique_ptr<LLVMContext> Context, 155 const void *mem, size_t length, 156 const TargetOptions &options, StringRef path) { 157 StringRef Data((const char *)mem, length); 158 MemoryBufferRef Buffer(Data, path); 159 // If we own a context, we know this is being used only for symbol extraction, 160 // not linking. Be lazy in that case. 161 ErrorOr<std::unique_ptr<LTOModule>> Ret = 162 makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true); 163 if (Ret) 164 (*Ret)->OwnedContext = std::move(Context); 165 return Ret; 166} 167 168static ErrorOr<std::unique_ptr<Module>> 169parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, 170 bool ShouldBeLazy) { 171 // Find the buffer. 172 Expected<MemoryBufferRef> MBOrErr = 173 IRObjectFile::findBitcodeInMemBuffer(Buffer); 174 if (Error E = MBOrErr.takeError()) { 175 std::error_code EC = errorToErrorCode(std::move(E)); 176 Context.emitError(EC.message()); 177 return EC; 178 } 179 180 if (!ShouldBeLazy) { 181 // Parse the full file. 182 return expectedToErrorOrAndEmitErrors(Context, 183 parseBitcodeFile(*MBOrErr, Context)); 184 } 185 186 // Parse lazily. 187 return expectedToErrorOrAndEmitErrors( 188 Context, 189 getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/)); 190} 191 192ErrorOr<std::unique_ptr<LTOModule>> 193LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options, 194 LLVMContext &Context, bool ShouldBeLazy) { 195 ErrorOr<std::unique_ptr<Module>> MOrErr = 196 parseBitcodeFileImpl(Buffer, Context, ShouldBeLazy); 197 if (std::error_code EC = MOrErr.getError()) 198 return EC; 199 std::unique_ptr<Module> &M = *MOrErr; 200 201 std::string TripleStr = M->getTargetTriple(); 202 if (TripleStr.empty()) 203 TripleStr = sys::getDefaultTargetTriple(); 204 llvm::Triple Triple(TripleStr); 205 206 // find machine architecture for this module 207 std::string errMsg; 208 const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 209 if (!march) 210 return make_error_code(object::object_error::arch_not_found); 211 212 // construct LTOModule, hand over ownership of module and target 213 SubtargetFeatures Features; 214 Features.getDefaultSubtargetFeatures(Triple); 215 std::string FeatureStr = Features.getString(); 216 // Set a default CPU for Darwin triples. 217 std::string CPU; 218 if (Triple.isOSDarwin()) { 219 if (Triple.getArch() == llvm::Triple::x86_64) 220 CPU = "core2"; 221 else if (Triple.getArch() == llvm::Triple::x86) 222 CPU = "yonah"; 223 else if (Triple.getArch() == llvm::Triple::aarch64) 224 CPU = "cyclone"; 225 } 226 227 TargetMachine *target = 228 march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None); 229 230 std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target)); 231 Ret->parseSymbols(); 232 Ret->parseMetadata(); 233 234 return std::move(Ret); 235} 236 237/// Create a MemoryBuffer from a memory range with an optional name. 238std::unique_ptr<MemoryBuffer> 239LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) { 240 const char *startPtr = (const char*)mem; 241 return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false); 242} 243 244/// objcClassNameFromExpression - Get string that the data pointer points to. 245bool 246LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) { 247 if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { 248 Constant *op = ce->getOperand(0); 249 if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { 250 Constant *cn = gvn->getInitializer(); 251 if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { 252 if (ca->isCString()) { 253 name = (".objc_class_name_" + ca->getAsCString()).str(); 254 return true; 255 } 256 } 257 } 258 } 259 return false; 260} 261 262/// addObjCClass - Parse i386/ppc ObjC class data structure. 263void LTOModule::addObjCClass(const GlobalVariable *clgv) { 264 const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 265 if (!c) return; 266 267 // second slot in __OBJC,__class is pointer to superclass name 268 std::string superclassName; 269 if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { 270 auto IterBool = 271 _undefines.insert(std::make_pair(superclassName, NameAndAttributes())); 272 if (IterBool.second) { 273 NameAndAttributes &info = IterBool.first->second; 274 info.name = IterBool.first->first(); 275 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 276 info.isFunction = false; 277 info.symbol = clgv; 278 } 279 } 280 281 // third slot in __OBJC,__class is pointer to class name 282 std::string className; 283 if (objcClassNameFromExpression(c->getOperand(2), className)) { 284 auto Iter = _defines.insert(className).first; 285 286 NameAndAttributes info; 287 info.name = Iter->first(); 288 info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | 289 LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; 290 info.isFunction = false; 291 info.symbol = clgv; 292 _symbols.push_back(info); 293 } 294} 295 296/// addObjCCategory - Parse i386/ppc ObjC category data structure. 297void LTOModule::addObjCCategory(const GlobalVariable *clgv) { 298 const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 299 if (!c) return; 300 301 // second slot in __OBJC,__category is pointer to target class name 302 std::string targetclassName; 303 if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) 304 return; 305 306 auto IterBool = 307 _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 308 309 if (!IterBool.second) 310 return; 311 312 NameAndAttributes &info = IterBool.first->second; 313 info.name = IterBool.first->first(); 314 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 315 info.isFunction = false; 316 info.symbol = clgv; 317} 318 319/// addObjCClassRef - Parse i386/ppc ObjC class list data structure. 320void LTOModule::addObjCClassRef(const GlobalVariable *clgv) { 321 std::string targetclassName; 322 if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) 323 return; 324 325 auto IterBool = 326 _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 327 328 if (!IterBool.second) 329 return; 330 331 NameAndAttributes &info = IterBool.first->second; 332 info.name = IterBool.first->first(); 333 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 334 info.isFunction = false; 335 info.symbol = clgv; 336} 337 338void LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) { 339 SmallString<64> Buffer; 340 { 341 raw_svector_ostream OS(Buffer); 342 SymTab.printSymbolName(OS, Sym); 343 Buffer.c_str(); 344 } 345 346 const GlobalValue *V = Sym.get<GlobalValue *>(); 347 addDefinedDataSymbol(Buffer, V); 348} 349 350void LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) { 351 // Add to list of defined symbols. 352 addDefinedSymbol(Name, v, false); 353 354 if (!v->hasSection() /* || !isTargetDarwin */) 355 return; 356 357 // Special case i386/ppc ObjC data structures in magic sections: 358 // The issue is that the old ObjC object format did some strange 359 // contortions to avoid real linker symbols. For instance, the 360 // ObjC class data structure is allocated statically in the executable 361 // that defines that class. That data structures contains a pointer to 362 // its superclass. But instead of just initializing that part of the 363 // struct to the address of its superclass, and letting the static and 364 // dynamic linkers do the rest, the runtime works by having that field 365 // instead point to a C-string that is the name of the superclass. 366 // At runtime the objc initialization updates that pointer and sets 367 // it to point to the actual super class. As far as the linker 368 // knows it is just a pointer to a string. But then someone wanted the 369 // linker to issue errors at build time if the superclass was not found. 370 // So they figured out a way in mach-o object format to use an absolute 371 // symbols (.objc_class_name_Foo = 0) and a floating reference 372 // (.reference .objc_class_name_Bar) to cause the linker into erroring when 373 // a class was missing. 374 // The following synthesizes the implicit .objc_* symbols for the linker 375 // from the ObjC data structures generated by the front end. 376 377 // special case if this data blob is an ObjC class definition 378 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(v)) { 379 StringRef Section = GV->getSection(); 380 if (Section.startswith("__OBJC,__class,")) { 381 addObjCClass(GV); 382 } 383 384 // special case if this data blob is an ObjC category definition 385 else if (Section.startswith("__OBJC,__category,")) { 386 addObjCCategory(GV); 387 } 388 389 // special case if this data blob is the list of referenced classes 390 else if (Section.startswith("__OBJC,__cls_refs,")) { 391 addObjCClassRef(GV); 392 } 393 } 394} 395 396void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) { 397 SmallString<64> Buffer; 398 { 399 raw_svector_ostream OS(Buffer); 400 SymTab.printSymbolName(OS, Sym); 401 Buffer.c_str(); 402 } 403 404 const Function *F = cast<Function>(Sym.get<GlobalValue *>()); 405 addDefinedFunctionSymbol(Buffer, F); 406} 407 408void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) { 409 // add to list of defined symbols 410 addDefinedSymbol(Name, F, true); 411} 412 413void LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def, 414 bool isFunction) { 415 // set alignment part log2() can have rounding errors 416 uint32_t align = def->getAlignment(); 417 uint32_t attr = align ? countTrailingZeros(align) : 0; 418 419 // set permissions part 420 if (isFunction) { 421 attr |= LTO_SYMBOL_PERMISSIONS_CODE; 422 } else { 423 const GlobalVariable *gv = dyn_cast<GlobalVariable>(def); 424 if (gv && gv->isConstant()) 425 attr |= LTO_SYMBOL_PERMISSIONS_RODATA; 426 else 427 attr |= LTO_SYMBOL_PERMISSIONS_DATA; 428 } 429 430 // set definition part 431 if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) 432 attr |= LTO_SYMBOL_DEFINITION_WEAK; 433 else if (def->hasCommonLinkage()) 434 attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; 435 else 436 attr |= LTO_SYMBOL_DEFINITION_REGULAR; 437 438 // set scope part 439 if (def->hasLocalLinkage()) 440 // Ignore visibility if linkage is local. 441 attr |= LTO_SYMBOL_SCOPE_INTERNAL; 442 else if (def->hasHiddenVisibility()) 443 attr |= LTO_SYMBOL_SCOPE_HIDDEN; 444 else if (def->hasProtectedVisibility()) 445 attr |= LTO_SYMBOL_SCOPE_PROTECTED; 446 else if (def->canBeOmittedFromSymbolTable()) 447 attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; 448 else 449 attr |= LTO_SYMBOL_SCOPE_DEFAULT; 450 451 if (def->hasComdat()) 452 attr |= LTO_SYMBOL_COMDAT; 453 454 if (isa<GlobalAlias>(def)) 455 attr |= LTO_SYMBOL_ALIAS; 456 457 auto Iter = _defines.insert(Name).first; 458 459 // fill information structure 460 NameAndAttributes info; 461 StringRef NameRef = Iter->first(); 462 info.name = NameRef; 463 assert(NameRef.data()[NameRef.size()] == '\0'); 464 info.attributes = attr; 465 info.isFunction = isFunction; 466 info.symbol = def; 467 468 // add to table of symbols 469 _symbols.push_back(info); 470} 471 472/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the 473/// defined list. 474void LTOModule::addAsmGlobalSymbol(StringRef name, 475 lto_symbol_attributes scope) { 476 auto IterBool = _defines.insert(name); 477 478 // only add new define if not already defined 479 if (!IterBool.second) 480 return; 481 482 NameAndAttributes &info = _undefines[IterBool.first->first()]; 483 484 if (info.symbol == nullptr) { 485 // FIXME: This is trying to take care of module ASM like this: 486 // 487 // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" 488 // 489 // but is gross and its mother dresses it funny. Have the ASM parser give us 490 // more details for this type of situation so that we're not guessing so 491 // much. 492 493 // fill information structure 494 info.name = IterBool.first->first(); 495 info.attributes = 496 LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; 497 info.isFunction = false; 498 info.symbol = nullptr; 499 500 // add to table of symbols 501 _symbols.push_back(info); 502 return; 503 } 504 505 if (info.isFunction) 506 addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol)); 507 else 508 addDefinedDataSymbol(info.name, info.symbol); 509 510 _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; 511 _symbols.back().attributes |= scope; 512} 513 514/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the 515/// undefined list. 516void LTOModule::addAsmGlobalSymbolUndef(StringRef name) { 517 auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 518 519 _asm_undefines.push_back(IterBool.first->first()); 520 521 // we already have the symbol 522 if (!IterBool.second) 523 return; 524 525 uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED; 526 attr |= LTO_SYMBOL_SCOPE_DEFAULT; 527 NameAndAttributes &info = IterBool.first->second; 528 info.name = IterBool.first->first(); 529 info.attributes = attr; 530 info.isFunction = false; 531 info.symbol = nullptr; 532} 533 534/// Add a symbol which isn't defined just yet to a list to be resolved later. 535void LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym, 536 bool isFunc) { 537 SmallString<64> name; 538 { 539 raw_svector_ostream OS(name); 540 SymTab.printSymbolName(OS, Sym); 541 name.c_str(); 542 } 543 544 auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 545 546 // we already have the symbol 547 if (!IterBool.second) 548 return; 549 550 NameAndAttributes &info = IterBool.first->second; 551 552 info.name = IterBool.first->first(); 553 554 const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>(); 555 556 if (decl->hasExternalWeakLinkage()) 557 info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF; 558 else 559 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 560 561 info.isFunction = isFunc; 562 info.symbol = decl; 563} 564 565void LTOModule::parseSymbols() { 566 for (auto Sym : SymTab.symbols()) { 567 auto *GV = Sym.dyn_cast<GlobalValue *>(); 568 uint32_t Flags = SymTab.getSymbolFlags(Sym); 569 if (Flags & object::BasicSymbolRef::SF_FormatSpecific) 570 continue; 571 572 bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined; 573 574 if (!GV) { 575 SmallString<64> Buffer; 576 { 577 raw_svector_ostream OS(Buffer); 578 SymTab.printSymbolName(OS, Sym); 579 Buffer.c_str(); 580 } 581 StringRef Name(Buffer); 582 583 if (IsUndefined) 584 addAsmGlobalSymbolUndef(Name); 585 else if (Flags & object::BasicSymbolRef::SF_Global) 586 addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT); 587 else 588 addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL); 589 continue; 590 } 591 592 auto *F = dyn_cast<Function>(GV); 593 if (IsUndefined) { 594 addPotentialUndefinedSymbol(Sym, F != nullptr); 595 continue; 596 } 597 598 if (F) { 599 addDefinedFunctionSymbol(Sym); 600 continue; 601 } 602 603 if (isa<GlobalVariable>(GV)) { 604 addDefinedDataSymbol(Sym); 605 continue; 606 } 607 608 assert(isa<GlobalAlias>(GV)); 609 addDefinedDataSymbol(Sym); 610 } 611 612 // make symbols for all undefines 613 for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), 614 e = _undefines.end(); u != e; ++u) { 615 // If this symbol also has a definition, then don't make an undefine because 616 // it is a tentative definition. 617 if (_defines.count(u->getKey())) continue; 618 NameAndAttributes info = u->getValue(); 619 _symbols.push_back(info); 620 } 621} 622 623/// parseMetadata - Parse metadata from the module 624void LTOModule::parseMetadata() { 625 raw_string_ostream OS(LinkerOpts); 626 627 // Linker Options 628 if (NamedMDNode *LinkerOptions = 629 getModule().getNamedMetadata("llvm.linker.options")) { 630 for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 631 MDNode *MDOptions = LinkerOptions->getOperand(i); 632 for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 633 MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 634 OS << " " << MDOption->getString(); 635 } 636 } 637 } 638 639 // Globals - we only need to do this for COFF. 640 const Triple TT(_target->getTargetTriple()); 641 if (!TT.isOSBinFormatCOFF()) 642 return; 643 Mangler M; 644 for (const NameAndAttributes &Sym : _symbols) { 645 if (!Sym.symbol) 646 continue; 647 emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M); 648 } 649 650 // Add other interesting metadata here. 651} 652