LTOModule.cpp revision 321369
1259698Sdim//===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===// 2259698Sdim// 3259698Sdim// The LLVM Compiler Infrastructure 4259698Sdim// 5259698Sdim// This file is distributed under the University of Illinois Open Source 6259698Sdim// License. See LICENSE.TXT for details. 7259698Sdim// 8259698Sdim//===----------------------------------------------------------------------===// 9259698Sdim// 10259698Sdim// This file implements the Link Time Optimization library. This library is 11259698Sdim// intended to be used by linker to optimize code at link time. 12259698Sdim// 13259698Sdim//===----------------------------------------------------------------------===// 14259698Sdim 15309124Sdim#include "llvm/LTO/legacy/LTOModule.h" 16259698Sdim#include "llvm/ADT/Triple.h" 17321369Sdim#include "llvm/Analysis/ObjectUtils.h" 18314564Sdim#include "llvm/Bitcode/BitcodeReader.h" 19259698Sdim#include "llvm/IR/Constants.h" 20280031Sdim#include "llvm/IR/DiagnosticPrinter.h" 21259698Sdim#include "llvm/IR/LLVMContext.h" 22321369Sdim#include "llvm/IR/Mangler.h" 23276479Sdim#include "llvm/IR/Metadata.h" 24259698Sdim#include "llvm/IR/Module.h" 25259698Sdim#include "llvm/MC/MCExpr.h" 26259698Sdim#include "llvm/MC/MCInst.h" 27259698Sdim#include "llvm/MC/MCInstrInfo.h" 28259698Sdim#include "llvm/MC/MCParser/MCAsmParser.h" 29309124Sdim#include "llvm/MC/MCParser/MCTargetAsmParser.h" 30276479Sdim#include "llvm/MC/MCSection.h" 31259698Sdim#include "llvm/MC/MCSubtargetInfo.h" 32259698Sdim#include "llvm/MC/MCSymbol.h" 33259698Sdim#include "llvm/MC/SubtargetFeature.h" 34280031Sdim#include "llvm/Object/IRObjectFile.h" 35280031Sdim#include "llvm/Object/ObjectFile.h" 36276479Sdim#include "llvm/Support/FileSystem.h" 37259698Sdim#include "llvm/Support/Host.h" 38259698Sdim#include "llvm/Support/MemoryBuffer.h" 39259698Sdim#include "llvm/Support/Path.h" 40259698Sdim#include "llvm/Support/SourceMgr.h" 41259698Sdim#include "llvm/Support/TargetRegistry.h" 42259698Sdim#include "llvm/Support/TargetSelect.h" 43276479Sdim#include "llvm/Target/TargetLowering.h" 44276479Sdim#include "llvm/Target/TargetLoweringObjectFile.h" 45259698Sdim#include "llvm/Target/TargetRegisterInfo.h" 46280031Sdim#include "llvm/Target/TargetSubtargetInfo.h" 47259698Sdim#include "llvm/Transforms/Utils/GlobalStatus.h" 48276479Sdim#include <system_error> 49259698Sdimusing namespace llvm; 50280031Sdimusing namespace llvm::object; 51259698Sdim 52314564SdimLTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef, 53276479Sdim llvm::TargetMachine *TM) 54314564Sdim : Mod(std::move(M)), MBRef(MBRef), _target(TM) { 55314564Sdim SymTab.addModule(Mod.get()); 56314564Sdim} 57259698Sdim 58280031SdimLTOModule::~LTOModule() {} 59280031Sdim 60259698Sdim/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM 61259698Sdim/// bitcode. 62280031Sdimbool LTOModule::isBitcodeFile(const void *Mem, size_t Length) { 63280031Sdim ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 64280031Sdim MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>")); 65280031Sdim return bool(BCData); 66259698Sdim} 67259698Sdim 68314564Sdimbool LTOModule::isBitcodeFile(StringRef Path) { 69280031Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 70280031Sdim MemoryBuffer::getFile(Path); 71280031Sdim if (!BufferOrErr) 72259698Sdim return false; 73280031Sdim 74280031Sdim ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 75280031Sdim BufferOrErr.get()->getMemBufferRef()); 76280031Sdim return bool(BCData); 77259698Sdim} 78259698Sdim 79309124Sdimbool LTOModule::isThinLTO() { 80321369Sdim Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef); 81314564Sdim if (!Result) { 82314564Sdim logAllUnhandledErrors(Result.takeError(), errs(), ""); 83314564Sdim return false; 84314564Sdim } 85321369Sdim return Result->IsThinLTO; 86309124Sdim} 87309124Sdim 88280031Sdimbool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer, 89280031Sdim StringRef TriplePrefix) { 90280031Sdim ErrorOr<MemoryBufferRef> BCOrErr = 91280031Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 92280031Sdim if (!BCOrErr) 93280031Sdim return false; 94280031Sdim LLVMContext Context; 95314564Sdim ErrorOr<std::string> TripleOrErr = 96314564Sdim expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr)); 97314564Sdim if (!TripleOrErr) 98314564Sdim return false; 99314564Sdim return StringRef(*TripleOrErr).startswith(TriplePrefix); 100259698Sdim} 101259698Sdim 102296417Sdimstd::string LTOModule::getProducerString(MemoryBuffer *Buffer) { 103296417Sdim ErrorOr<MemoryBufferRef> BCOrErr = 104296417Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 105296417Sdim if (!BCOrErr) 106296417Sdim return ""; 107296417Sdim LLVMContext Context; 108314564Sdim ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors( 109314564Sdim Context, getBitcodeProducerString(*BCOrErr)); 110314564Sdim if (!ProducerOrErr) 111314564Sdim return ""; 112314564Sdim return *ProducerOrErr; 113296417Sdim} 114296417Sdim 115296417SdimErrorOr<std::unique_ptr<LTOModule>> 116314564SdimLTOModule::createFromFile(LLVMContext &Context, StringRef path, 117309124Sdim const TargetOptions &options) { 118276479Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 119276479Sdim MemoryBuffer::getFile(path); 120309124Sdim if (std::error_code EC = BufferOrErr.getError()) { 121309124Sdim Context.emitError(EC.message()); 122296417Sdim return EC; 123309124Sdim } 124280031Sdim std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 125309124Sdim return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 126309124Sdim /* ShouldBeLazy*/ false); 127259698Sdim} 128259698Sdim 129296417SdimErrorOr<std::unique_ptr<LTOModule>> 130314564SdimLTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path, 131309124Sdim size_t size, const TargetOptions &options) { 132296417Sdim return createFromOpenFileSlice(Context, fd, path, size, 0, options); 133259698Sdim} 134259698Sdim 135296417SdimErrorOr<std::unique_ptr<LTOModule>> 136314564SdimLTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path, 137314564Sdim size_t map_size, off_t offset, 138314564Sdim const TargetOptions &options) { 139276479Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 140276479Sdim MemoryBuffer::getOpenFileSlice(fd, path, map_size, offset); 141309124Sdim if (std::error_code EC = BufferOrErr.getError()) { 142309124Sdim Context.emitError(EC.message()); 143296417Sdim return EC; 144309124Sdim } 145280031Sdim std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 146309124Sdim return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 147309124Sdim /* ShouldBeLazy */ false); 148259698Sdim} 149259698Sdim 150296417SdimErrorOr<std::unique_ptr<LTOModule>> 151296417SdimLTOModule::createFromBuffer(LLVMContext &Context, const void *mem, 152309124Sdim size_t length, const TargetOptions &options, 153296417Sdim StringRef path) { 154309124Sdim StringRef Data((const char *)mem, length); 155309124Sdim MemoryBufferRef Buffer(Data, path); 156309124Sdim return makeLTOModule(Buffer, options, Context, /* ShouldBeLazy */ false); 157259698Sdim} 158259698Sdim 159296417SdimErrorOr<std::unique_ptr<LTOModule>> 160309124SdimLTOModule::createInLocalContext(std::unique_ptr<LLVMContext> Context, 161309124Sdim const void *mem, size_t length, 162309124Sdim const TargetOptions &options, StringRef path) { 163280031Sdim StringRef Data((const char *)mem, length); 164280031Sdim MemoryBufferRef Buffer(Data, path); 165309124Sdim // If we own a context, we know this is being used only for symbol extraction, 166309124Sdim // not linking. Be lazy in that case. 167309124Sdim ErrorOr<std::unique_ptr<LTOModule>> Ret = 168309124Sdim makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true); 169309124Sdim if (Ret) 170309124Sdim (*Ret)->OwnedContext = std::move(Context); 171309124Sdim return Ret; 172280031Sdim} 173280031Sdim 174296417Sdimstatic ErrorOr<std::unique_ptr<Module>> 175296417SdimparseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, 176296417Sdim bool ShouldBeLazy) { 177280031Sdim 178280031Sdim // Find the buffer. 179280031Sdim ErrorOr<MemoryBufferRef> MBOrErr = 180280031Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer); 181309124Sdim if (std::error_code EC = MBOrErr.getError()) { 182309124Sdim Context.emitError(EC.message()); 183296417Sdim return EC; 184309124Sdim } 185259698Sdim 186280031Sdim if (!ShouldBeLazy) { 187280031Sdim // Parse the full file. 188314564Sdim return expectedToErrorOrAndEmitErrors(Context, 189314564Sdim parseBitcodeFile(*MBOrErr, Context)); 190280031Sdim } 191280031Sdim 192280031Sdim // Parse lazily. 193314564Sdim return expectedToErrorOrAndEmitErrors( 194314564Sdim Context, 195314564Sdim getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/)); 196280031Sdim} 197280031Sdim 198296417SdimErrorOr<std::unique_ptr<LTOModule>> 199309124SdimLTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options, 200309124Sdim LLVMContext &Context, bool ShouldBeLazy) { 201296417Sdim ErrorOr<std::unique_ptr<Module>> MOrErr = 202309124Sdim parseBitcodeFileImpl(Buffer, Context, ShouldBeLazy); 203296417Sdim if (std::error_code EC = MOrErr.getError()) 204296417Sdim return EC; 205296417Sdim std::unique_ptr<Module> &M = *MOrErr; 206280031Sdim 207276479Sdim std::string TripleStr = M->getTargetTriple(); 208259698Sdim if (TripleStr.empty()) 209259698Sdim TripleStr = sys::getDefaultTargetTriple(); 210259698Sdim llvm::Triple Triple(TripleStr); 211259698Sdim 212259698Sdim // find machine architecture for this module 213296417Sdim std::string errMsg; 214259698Sdim const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 215259698Sdim if (!march) 216296417Sdim return std::unique_ptr<LTOModule>(nullptr); 217259698Sdim 218259698Sdim // construct LTOModule, hand over ownership of module and target 219259698Sdim SubtargetFeatures Features; 220259698Sdim Features.getDefaultSubtargetFeatures(Triple); 221259698Sdim std::string FeatureStr = Features.getString(); 222259698Sdim // Set a default CPU for Darwin triples. 223259698Sdim std::string CPU; 224259698Sdim if (Triple.isOSDarwin()) { 225259698Sdim if (Triple.getArch() == llvm::Triple::x86_64) 226259698Sdim CPU = "core2"; 227259698Sdim else if (Triple.getArch() == llvm::Triple::x86) 228259698Sdim CPU = "yonah"; 229280031Sdim else if (Triple.getArch() == llvm::Triple::aarch64) 230276479Sdim CPU = "cyclone"; 231259698Sdim } 232259698Sdim 233309124Sdim TargetMachine *target = 234309124Sdim march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None); 235259698Sdim 236314564Sdim std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target)); 237296417Sdim Ret->parseSymbols(); 238276479Sdim Ret->parseMetadata(); 239276479Sdim 240296417Sdim return std::move(Ret); 241259698Sdim} 242259698Sdim 243276479Sdim/// Create a MemoryBuffer from a memory range with an optional name. 244280031Sdimstd::unique_ptr<MemoryBuffer> 245280031SdimLTOModule::makeBuffer(const void *mem, size_t length, StringRef name) { 246259698Sdim const char *startPtr = (const char*)mem; 247276479Sdim return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false); 248259698Sdim} 249259698Sdim 250259698Sdim/// objcClassNameFromExpression - Get string that the data pointer points to. 251259698Sdimbool 252259698SdimLTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) { 253259698Sdim if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { 254259698Sdim Constant *op = ce->getOperand(0); 255259698Sdim if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { 256259698Sdim Constant *cn = gvn->getInitializer(); 257259698Sdim if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { 258259698Sdim if (ca->isCString()) { 259288943Sdim name = (".objc_class_name_" + ca->getAsCString()).str(); 260259698Sdim return true; 261259698Sdim } 262259698Sdim } 263259698Sdim } 264259698Sdim } 265259698Sdim return false; 266259698Sdim} 267259698Sdim 268259698Sdim/// addObjCClass - Parse i386/ppc ObjC class data structure. 269259698Sdimvoid LTOModule::addObjCClass(const GlobalVariable *clgv) { 270259698Sdim const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 271259698Sdim if (!c) return; 272259698Sdim 273259698Sdim // second slot in __OBJC,__class is pointer to superclass name 274259698Sdim std::string superclassName; 275259698Sdim if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { 276280031Sdim auto IterBool = 277280031Sdim _undefines.insert(std::make_pair(superclassName, NameAndAttributes())); 278280031Sdim if (IterBool.second) { 279280031Sdim NameAndAttributes &info = IterBool.first->second; 280314564Sdim info.name = IterBool.first->first(); 281259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 282259698Sdim info.isFunction = false; 283259698Sdim info.symbol = clgv; 284259698Sdim } 285259698Sdim } 286259698Sdim 287259698Sdim // third slot in __OBJC,__class is pointer to class name 288259698Sdim std::string className; 289259698Sdim if (objcClassNameFromExpression(c->getOperand(2), className)) { 290280031Sdim auto Iter = _defines.insert(className).first; 291259698Sdim 292259698Sdim NameAndAttributes info; 293314564Sdim info.name = Iter->first(); 294259698Sdim info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | 295259698Sdim LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; 296259698Sdim info.isFunction = false; 297259698Sdim info.symbol = clgv; 298259698Sdim _symbols.push_back(info); 299259698Sdim } 300259698Sdim} 301259698Sdim 302259698Sdim/// addObjCCategory - Parse i386/ppc ObjC category data structure. 303259698Sdimvoid LTOModule::addObjCCategory(const GlobalVariable *clgv) { 304259698Sdim const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 305259698Sdim if (!c) return; 306259698Sdim 307259698Sdim // second slot in __OBJC,__category is pointer to target class name 308259698Sdim std::string targetclassName; 309259698Sdim if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) 310259698Sdim return; 311259698Sdim 312280031Sdim auto IterBool = 313280031Sdim _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 314259698Sdim 315280031Sdim if (!IterBool.second) 316259698Sdim return; 317259698Sdim 318280031Sdim NameAndAttributes &info = IterBool.first->second; 319314564Sdim info.name = IterBool.first->first(); 320259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 321259698Sdim info.isFunction = false; 322259698Sdim info.symbol = clgv; 323259698Sdim} 324259698Sdim 325259698Sdim/// addObjCClassRef - Parse i386/ppc ObjC class list data structure. 326259698Sdimvoid LTOModule::addObjCClassRef(const GlobalVariable *clgv) { 327259698Sdim std::string targetclassName; 328259698Sdim if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) 329259698Sdim return; 330259698Sdim 331280031Sdim auto IterBool = 332280031Sdim _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 333280031Sdim 334280031Sdim if (!IterBool.second) 335259698Sdim return; 336259698Sdim 337280031Sdim NameAndAttributes &info = IterBool.first->second; 338314564Sdim info.name = IterBool.first->first(); 339259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 340259698Sdim info.isFunction = false; 341259698Sdim info.symbol = clgv; 342259698Sdim} 343259698Sdim 344314564Sdimvoid LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) { 345276479Sdim SmallString<64> Buffer; 346276479Sdim { 347276479Sdim raw_svector_ostream OS(Buffer); 348314564Sdim SymTab.printSymbolName(OS, Sym); 349314564Sdim Buffer.c_str(); 350276479Sdim } 351276479Sdim 352314564Sdim const GlobalValue *V = Sym.get<GlobalValue *>(); 353314564Sdim addDefinedDataSymbol(Buffer, V); 354276479Sdim} 355276479Sdim 356314564Sdimvoid LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) { 357259698Sdim // Add to list of defined symbols. 358276479Sdim addDefinedSymbol(Name, v, false); 359259698Sdim 360259698Sdim if (!v->hasSection() /* || !isTargetDarwin */) 361259698Sdim return; 362259698Sdim 363259698Sdim // Special case i386/ppc ObjC data structures in magic sections: 364259698Sdim // The issue is that the old ObjC object format did some strange 365259698Sdim // contortions to avoid real linker symbols. For instance, the 366259698Sdim // ObjC class data structure is allocated statically in the executable 367259698Sdim // that defines that class. That data structures contains a pointer to 368259698Sdim // its superclass. But instead of just initializing that part of the 369259698Sdim // struct to the address of its superclass, and letting the static and 370259698Sdim // dynamic linkers do the rest, the runtime works by having that field 371259698Sdim // instead point to a C-string that is the name of the superclass. 372259698Sdim // At runtime the objc initialization updates that pointer and sets 373259698Sdim // it to point to the actual super class. As far as the linker 374259698Sdim // knows it is just a pointer to a string. But then someone wanted the 375259698Sdim // linker to issue errors at build time if the superclass was not found. 376259698Sdim // So they figured out a way in mach-o object format to use an absolute 377259698Sdim // symbols (.objc_class_name_Foo = 0) and a floating reference 378259698Sdim // (.reference .objc_class_name_Bar) to cause the linker into erroring when 379259698Sdim // a class was missing. 380259698Sdim // The following synthesizes the implicit .objc_* symbols for the linker 381259698Sdim // from the ObjC data structures generated by the front end. 382259698Sdim 383259698Sdim // special case if this data blob is an ObjC class definition 384276479Sdim std::string Section = v->getSection(); 385276479Sdim if (Section.compare(0, 15, "__OBJC,__class,") == 0) { 386259698Sdim if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 387259698Sdim addObjCClass(gv); 388259698Sdim } 389259698Sdim } 390259698Sdim 391259698Sdim // special case if this data blob is an ObjC category definition 392276479Sdim else if (Section.compare(0, 18, "__OBJC,__category,") == 0) { 393259698Sdim if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 394259698Sdim addObjCCategory(gv); 395259698Sdim } 396259698Sdim } 397259698Sdim 398259698Sdim // special case if this data blob is the list of referenced classes 399276479Sdim else if (Section.compare(0, 18, "__OBJC,__cls_refs,") == 0) { 400259698Sdim if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 401259698Sdim addObjCClassRef(gv); 402259698Sdim } 403259698Sdim } 404259698Sdim} 405259698Sdim 406314564Sdimvoid LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) { 407276479Sdim SmallString<64> Buffer; 408276479Sdim { 409276479Sdim raw_svector_ostream OS(Buffer); 410314564Sdim SymTab.printSymbolName(OS, Sym); 411314564Sdim Buffer.c_str(); 412276479Sdim } 413276479Sdim 414314564Sdim const Function *F = cast<Function>(Sym.get<GlobalValue *>()); 415314564Sdim addDefinedFunctionSymbol(Buffer, F); 416276479Sdim} 417276479Sdim 418314564Sdimvoid LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) { 419259698Sdim // add to list of defined symbols 420276479Sdim addDefinedSymbol(Name, F, true); 421259698Sdim} 422259698Sdim 423314564Sdimvoid LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def, 424276479Sdim bool isFunction) { 425259698Sdim // set alignment part log2() can have rounding errors 426259698Sdim uint32_t align = def->getAlignment(); 427276479Sdim uint32_t attr = align ? countTrailingZeros(align) : 0; 428259698Sdim 429259698Sdim // set permissions part 430259698Sdim if (isFunction) { 431259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_CODE; 432259698Sdim } else { 433259698Sdim const GlobalVariable *gv = dyn_cast<GlobalVariable>(def); 434259698Sdim if (gv && gv->isConstant()) 435259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_RODATA; 436259698Sdim else 437259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_DATA; 438259698Sdim } 439259698Sdim 440259698Sdim // set definition part 441276479Sdim if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) 442259698Sdim attr |= LTO_SYMBOL_DEFINITION_WEAK; 443259698Sdim else if (def->hasCommonLinkage()) 444259698Sdim attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; 445259698Sdim else 446259698Sdim attr |= LTO_SYMBOL_DEFINITION_REGULAR; 447259698Sdim 448259698Sdim // set scope part 449276479Sdim if (def->hasLocalLinkage()) 450276479Sdim // Ignore visibility if linkage is local. 451276479Sdim attr |= LTO_SYMBOL_SCOPE_INTERNAL; 452276479Sdim else if (def->hasHiddenVisibility()) 453259698Sdim attr |= LTO_SYMBOL_SCOPE_HIDDEN; 454259698Sdim else if (def->hasProtectedVisibility()) 455259698Sdim attr |= LTO_SYMBOL_SCOPE_PROTECTED; 456280031Sdim else if (canBeOmittedFromSymbolTable(def)) 457259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; 458276479Sdim else 459259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT; 460259698Sdim 461288943Sdim if (def->hasComdat()) 462288943Sdim attr |= LTO_SYMBOL_COMDAT; 463288943Sdim 464288943Sdim if (isa<GlobalAlias>(def)) 465288943Sdim attr |= LTO_SYMBOL_ALIAS; 466288943Sdim 467280031Sdim auto Iter = _defines.insert(Name).first; 468259698Sdim 469259698Sdim // fill information structure 470259698Sdim NameAndAttributes info; 471280031Sdim StringRef NameRef = Iter->first(); 472314564Sdim info.name = NameRef; 473314564Sdim assert(NameRef.data()[NameRef.size()] == '\0'); 474259698Sdim info.attributes = attr; 475259698Sdim info.isFunction = isFunction; 476259698Sdim info.symbol = def; 477259698Sdim 478259698Sdim // add to table of symbols 479259698Sdim _symbols.push_back(info); 480259698Sdim} 481259698Sdim 482259698Sdim/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the 483259698Sdim/// defined list. 484314564Sdimvoid LTOModule::addAsmGlobalSymbol(StringRef name, 485259698Sdim lto_symbol_attributes scope) { 486280031Sdim auto IterBool = _defines.insert(name); 487259698Sdim 488259698Sdim // only add new define if not already defined 489280031Sdim if (!IterBool.second) 490259698Sdim return; 491259698Sdim 492314564Sdim NameAndAttributes &info = _undefines[IterBool.first->first()]; 493259698Sdim 494276479Sdim if (info.symbol == nullptr) { 495259698Sdim // FIXME: This is trying to take care of module ASM like this: 496259698Sdim // 497259698Sdim // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" 498259698Sdim // 499259698Sdim // but is gross and its mother dresses it funny. Have the ASM parser give us 500259698Sdim // more details for this type of situation so that we're not guessing so 501259698Sdim // much. 502259698Sdim 503259698Sdim // fill information structure 504314564Sdim info.name = IterBool.first->first(); 505259698Sdim info.attributes = 506259698Sdim LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; 507259698Sdim info.isFunction = false; 508276479Sdim info.symbol = nullptr; 509259698Sdim 510259698Sdim // add to table of symbols 511259698Sdim _symbols.push_back(info); 512259698Sdim return; 513259698Sdim } 514259698Sdim 515259698Sdim if (info.isFunction) 516276479Sdim addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol)); 517259698Sdim else 518276479Sdim addDefinedDataSymbol(info.name, info.symbol); 519259698Sdim 520259698Sdim _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; 521259698Sdim _symbols.back().attributes |= scope; 522259698Sdim} 523259698Sdim 524259698Sdim/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the 525259698Sdim/// undefined list. 526314564Sdimvoid LTOModule::addAsmGlobalSymbolUndef(StringRef name) { 527280031Sdim auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 528259698Sdim 529314564Sdim _asm_undefines.push_back(IterBool.first->first()); 530259698Sdim 531259698Sdim // we already have the symbol 532280031Sdim if (!IterBool.second) 533259698Sdim return; 534259698Sdim 535276479Sdim uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED; 536259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT; 537280031Sdim NameAndAttributes &info = IterBool.first->second; 538314564Sdim info.name = IterBool.first->first(); 539259698Sdim info.attributes = attr; 540259698Sdim info.isFunction = false; 541276479Sdim info.symbol = nullptr; 542259698Sdim} 543259698Sdim 544276479Sdim/// Add a symbol which isn't defined just yet to a list to be resolved later. 545314564Sdimvoid LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym, 546276479Sdim bool isFunc) { 547259698Sdim SmallString<64> name; 548276479Sdim { 549276479Sdim raw_svector_ostream OS(name); 550314564Sdim SymTab.printSymbolName(OS, Sym); 551314564Sdim name.c_str(); 552276479Sdim } 553259698Sdim 554280031Sdim auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 555259698Sdim 556259698Sdim // we already have the symbol 557280031Sdim if (!IterBool.second) 558259698Sdim return; 559259698Sdim 560280031Sdim NameAndAttributes &info = IterBool.first->second; 561259698Sdim 562314564Sdim info.name = IterBool.first->first(); 563259698Sdim 564314564Sdim const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>(); 565276479Sdim 566259698Sdim if (decl->hasExternalWeakLinkage()) 567259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF; 568259698Sdim else 569259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 570259698Sdim 571259698Sdim info.isFunction = isFunc; 572259698Sdim info.symbol = decl; 573259698Sdim} 574259698Sdim 575296417Sdimvoid LTOModule::parseSymbols() { 576314564Sdim for (auto Sym : SymTab.symbols()) { 577314564Sdim auto *GV = Sym.dyn_cast<GlobalValue *>(); 578314564Sdim uint32_t Flags = SymTab.getSymbolFlags(Sym); 579276479Sdim if (Flags & object::BasicSymbolRef::SF_FormatSpecific) 580276479Sdim continue; 581259698Sdim 582276479Sdim bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined; 583259698Sdim 584276479Sdim if (!GV) { 585276479Sdim SmallString<64> Buffer; 586276479Sdim { 587276479Sdim raw_svector_ostream OS(Buffer); 588314564Sdim SymTab.printSymbolName(OS, Sym); 589314564Sdim Buffer.c_str(); 590259698Sdim } 591314564Sdim StringRef Name(Buffer); 592259698Sdim 593276479Sdim if (IsUndefined) 594276479Sdim addAsmGlobalSymbolUndef(Name); 595276479Sdim else if (Flags & object::BasicSymbolRef::SF_Global) 596276479Sdim addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT); 597276479Sdim else 598276479Sdim addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL); 599276479Sdim continue; 600259698Sdim } 601259698Sdim 602276479Sdim auto *F = dyn_cast<Function>(GV); 603276479Sdim if (IsUndefined) { 604276479Sdim addPotentialUndefinedSymbol(Sym, F != nullptr); 605276479Sdim continue; 606259698Sdim } 607259698Sdim 608276479Sdim if (F) { 609276479Sdim addDefinedFunctionSymbol(Sym); 610276479Sdim continue; 611259698Sdim } 612259698Sdim 613276479Sdim if (isa<GlobalVariable>(GV)) { 614276479Sdim addDefinedDataSymbol(Sym); 615276479Sdim continue; 616259698Sdim } 617259698Sdim 618276479Sdim assert(isa<GlobalAlias>(GV)); 619276479Sdim addDefinedDataSymbol(Sym); 620259698Sdim } 621259698Sdim 622259698Sdim // make symbols for all undefines 623259698Sdim for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), 624259698Sdim e = _undefines.end(); u != e; ++u) { 625259698Sdim // If this symbol also has a definition, then don't make an undefine because 626259698Sdim // it is a tentative definition. 627259698Sdim if (_defines.count(u->getKey())) continue; 628259698Sdim NameAndAttributes info = u->getValue(); 629259698Sdim _symbols.push_back(info); 630259698Sdim } 631259698Sdim} 632276479Sdim 633276479Sdim/// parseMetadata - Parse metadata from the module 634276479Sdimvoid LTOModule::parseMetadata() { 635288943Sdim raw_string_ostream OS(LinkerOpts); 636288943Sdim 637276479Sdim // Linker Options 638321369Sdim if (NamedMDNode *LinkerOptions = 639321369Sdim getModule().getNamedMetadata("llvm.linker.options")) { 640276479Sdim for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 641321369Sdim MDNode *MDOptions = LinkerOptions->getOperand(i); 642276479Sdim for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 643276479Sdim MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 644288943Sdim OS << " " << MDOption->getString(); 645276479Sdim } 646276479Sdim } 647276479Sdim } 648276479Sdim 649321369Sdim // Globals - we only need to do this for COFF. 650321369Sdim const Triple TT(_target->getTargetTriple()); 651321369Sdim if (!TT.isOSBinFormatCOFF()) 652321369Sdim return; 653321369Sdim Mangler M; 654288943Sdim for (const NameAndAttributes &Sym : _symbols) { 655288943Sdim if (!Sym.symbol) 656288943Sdim continue; 657321369Sdim emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M); 658288943Sdim } 659288943Sdim 660276479Sdim // Add other interesting metadata here. 661276479Sdim} 662