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