1259698Sdim//===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===// 2259698Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6259698Sdim// 7259698Sdim//===----------------------------------------------------------------------===// 8259698Sdim// 9259698Sdim// This file implements the Link Time Optimization library. This library is 10259698Sdim// intended to be used by linker to optimize code at link time. 11259698Sdim// 12259698Sdim//===----------------------------------------------------------------------===// 13259698Sdim 14309124Sdim#include "llvm/LTO/legacy/LTOModule.h" 15259698Sdim#include "llvm/ADT/Triple.h" 16314564Sdim#include "llvm/Bitcode/BitcodeReader.h" 17327952Sdim#include "llvm/CodeGen/TargetSubtargetInfo.h" 18259698Sdim#include "llvm/IR/Constants.h" 19259698Sdim#include "llvm/IR/LLVMContext.h" 20321369Sdim#include "llvm/IR/Mangler.h" 21276479Sdim#include "llvm/IR/Metadata.h" 22259698Sdim#include "llvm/IR/Module.h" 23259698Sdim#include "llvm/MC/MCExpr.h" 24259698Sdim#include "llvm/MC/MCInst.h" 25259698Sdim#include "llvm/MC/MCParser/MCAsmParser.h" 26276479Sdim#include "llvm/MC/MCSection.h" 27259698Sdim#include "llvm/MC/MCSubtargetInfo.h" 28259698Sdim#include "llvm/MC/MCSymbol.h" 29259698Sdim#include "llvm/MC/SubtargetFeature.h" 30280031Sdim#include "llvm/Object/IRObjectFile.h" 31280031Sdim#include "llvm/Object/ObjectFile.h" 32276479Sdim#include "llvm/Support/FileSystem.h" 33259698Sdim#include "llvm/Support/Host.h" 34259698Sdim#include "llvm/Support/MemoryBuffer.h" 35259698Sdim#include "llvm/Support/Path.h" 36259698Sdim#include "llvm/Support/SourceMgr.h" 37259698Sdim#include "llvm/Support/TargetRegistry.h" 38259698Sdim#include "llvm/Support/TargetSelect.h" 39341825Sdim#include "llvm/Target/TargetLoweringObjectFile.h" 40259698Sdim#include "llvm/Transforms/Utils/GlobalStatus.h" 41276479Sdim#include <system_error> 42259698Sdimusing namespace llvm; 43280031Sdimusing namespace llvm::object; 44259698Sdim 45314564SdimLTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef, 46276479Sdim llvm::TargetMachine *TM) 47314564Sdim : Mod(std::move(M)), MBRef(MBRef), _target(TM) { 48314564Sdim SymTab.addModule(Mod.get()); 49314564Sdim} 50259698Sdim 51280031SdimLTOModule::~LTOModule() {} 52280031Sdim 53259698Sdim/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM 54259698Sdim/// bitcode. 55280031Sdimbool LTOModule::isBitcodeFile(const void *Mem, size_t Length) { 56327952Sdim Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 57280031Sdim MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>")); 58341825Sdim return !errorToBool(BCData.takeError()); 59259698Sdim} 60259698Sdim 61314564Sdimbool LTOModule::isBitcodeFile(StringRef Path) { 62280031Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 63280031Sdim MemoryBuffer::getFile(Path); 64280031Sdim if (!BufferOrErr) 65259698Sdim return false; 66280031Sdim 67327952Sdim Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 68280031Sdim BufferOrErr.get()->getMemBufferRef()); 69341825Sdim return !errorToBool(BCData.takeError()); 70259698Sdim} 71259698Sdim 72309124Sdimbool LTOModule::isThinLTO() { 73321369Sdim Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef); 74314564Sdim if (!Result) { 75344779Sdim logAllUnhandledErrors(Result.takeError(), errs()); 76314564Sdim return false; 77314564Sdim } 78321369Sdim return Result->IsThinLTO; 79309124Sdim} 80309124Sdim 81280031Sdimbool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer, 82280031Sdim StringRef TriplePrefix) { 83327952Sdim Expected<MemoryBufferRef> BCOrErr = 84280031Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 85341825Sdim if (errorToBool(BCOrErr.takeError())) 86280031Sdim return false; 87280031Sdim LLVMContext Context; 88314564Sdim ErrorOr<std::string> TripleOrErr = 89314564Sdim expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr)); 90314564Sdim if (!TripleOrErr) 91314564Sdim return false; 92314564Sdim return StringRef(*TripleOrErr).startswith(TriplePrefix); 93259698Sdim} 94259698Sdim 95296417Sdimstd::string LTOModule::getProducerString(MemoryBuffer *Buffer) { 96327952Sdim Expected<MemoryBufferRef> BCOrErr = 97296417Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 98341825Sdim if (errorToBool(BCOrErr.takeError())) 99296417Sdim return ""; 100296417Sdim LLVMContext Context; 101314564Sdim ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors( 102314564Sdim Context, getBitcodeProducerString(*BCOrErr)); 103314564Sdim if (!ProducerOrErr) 104314564Sdim return ""; 105314564Sdim return *ProducerOrErr; 106296417Sdim} 107296417Sdim 108296417SdimErrorOr<std::unique_ptr<LTOModule>> 109314564SdimLTOModule::createFromFile(LLVMContext &Context, StringRef path, 110309124Sdim const TargetOptions &options) { 111276479Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 112276479Sdim MemoryBuffer::getFile(path); 113309124Sdim if (std::error_code EC = BufferOrErr.getError()) { 114309124Sdim Context.emitError(EC.message()); 115296417Sdim return EC; 116309124Sdim } 117280031Sdim std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 118309124Sdim return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 119309124Sdim /* ShouldBeLazy*/ false); 120259698Sdim} 121259698Sdim 122296417SdimErrorOr<std::unique_ptr<LTOModule>> 123314564SdimLTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path, 124309124Sdim size_t size, const TargetOptions &options) { 125296417Sdim return createFromOpenFileSlice(Context, fd, path, size, 0, options); 126259698Sdim} 127259698Sdim 128296417SdimErrorOr<std::unique_ptr<LTOModule>> 129314564SdimLTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path, 130314564Sdim size_t map_size, off_t offset, 131314564Sdim const TargetOptions &options) { 132276479Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 133353358Sdim MemoryBuffer::getOpenFileSlice(sys::fs::convertFDToNativeFile(fd), path, 134353358Sdim map_size, offset); 135309124Sdim if (std::error_code EC = BufferOrErr.getError()) { 136309124Sdim Context.emitError(EC.message()); 137296417Sdim return EC; 138309124Sdim } 139280031Sdim std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 140309124Sdim return makeLTOModule(Buffer->getMemBufferRef(), options, Context, 141309124Sdim /* ShouldBeLazy */ false); 142259698Sdim} 143259698Sdim 144296417SdimErrorOr<std::unique_ptr<LTOModule>> 145296417SdimLTOModule::createFromBuffer(LLVMContext &Context, const void *mem, 146309124Sdim size_t length, const TargetOptions &options, 147296417Sdim StringRef path) { 148309124Sdim StringRef Data((const char *)mem, length); 149309124Sdim MemoryBufferRef Buffer(Data, path); 150309124Sdim return makeLTOModule(Buffer, options, Context, /* ShouldBeLazy */ false); 151259698Sdim} 152259698Sdim 153296417SdimErrorOr<std::unique_ptr<LTOModule>> 154309124SdimLTOModule::createInLocalContext(std::unique_ptr<LLVMContext> Context, 155309124Sdim const void *mem, size_t length, 156309124Sdim const TargetOptions &options, StringRef path) { 157280031Sdim StringRef Data((const char *)mem, length); 158280031Sdim MemoryBufferRef Buffer(Data, path); 159309124Sdim // If we own a context, we know this is being used only for symbol extraction, 160309124Sdim // not linking. Be lazy in that case. 161309124Sdim ErrorOr<std::unique_ptr<LTOModule>> Ret = 162309124Sdim makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true); 163309124Sdim if (Ret) 164309124Sdim (*Ret)->OwnedContext = std::move(Context); 165309124Sdim return Ret; 166280031Sdim} 167280031Sdim 168296417Sdimstatic ErrorOr<std::unique_ptr<Module>> 169296417SdimparseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, 170296417Sdim bool ShouldBeLazy) { 171280031Sdim // Find the buffer. 172327952Sdim Expected<MemoryBufferRef> MBOrErr = 173280031Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer); 174327952Sdim if (Error E = MBOrErr.takeError()) { 175327952Sdim std::error_code EC = errorToErrorCode(std::move(E)); 176309124Sdim Context.emitError(EC.message()); 177296417Sdim return EC; 178309124Sdim } 179259698Sdim 180280031Sdim if (!ShouldBeLazy) { 181280031Sdim // Parse the full file. 182314564Sdim return expectedToErrorOrAndEmitErrors(Context, 183314564Sdim parseBitcodeFile(*MBOrErr, Context)); 184280031Sdim } 185280031Sdim 186280031Sdim // Parse lazily. 187314564Sdim return expectedToErrorOrAndEmitErrors( 188314564Sdim Context, 189314564Sdim getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/)); 190280031Sdim} 191280031Sdim 192296417SdimErrorOr<std::unique_ptr<LTOModule>> 193309124SdimLTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options, 194309124Sdim LLVMContext &Context, bool ShouldBeLazy) { 195296417Sdim ErrorOr<std::unique_ptr<Module>> MOrErr = 196309124Sdim parseBitcodeFileImpl(Buffer, Context, ShouldBeLazy); 197296417Sdim if (std::error_code EC = MOrErr.getError()) 198296417Sdim return EC; 199296417Sdim std::unique_ptr<Module> &M = *MOrErr; 200280031Sdim 201276479Sdim std::string TripleStr = M->getTargetTriple(); 202259698Sdim if (TripleStr.empty()) 203259698Sdim TripleStr = sys::getDefaultTargetTriple(); 204259698Sdim llvm::Triple Triple(TripleStr); 205259698Sdim 206259698Sdim // find machine architecture for this module 207296417Sdim std::string errMsg; 208259698Sdim const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 209259698Sdim if (!march) 210341825Sdim return make_error_code(object::object_error::arch_not_found); 211259698Sdim 212259698Sdim // construct LTOModule, hand over ownership of module and target 213259698Sdim SubtargetFeatures Features; 214259698Sdim Features.getDefaultSubtargetFeatures(Triple); 215259698Sdim std::string FeatureStr = Features.getString(); 216259698Sdim // Set a default CPU for Darwin triples. 217259698Sdim std::string CPU; 218259698Sdim if (Triple.isOSDarwin()) { 219259698Sdim if (Triple.getArch() == llvm::Triple::x86_64) 220259698Sdim CPU = "core2"; 221259698Sdim else if (Triple.getArch() == llvm::Triple::x86) 222259698Sdim CPU = "yonah"; 223360784Sdim else if (Triple.getArch() == llvm::Triple::aarch64 || 224360784Sdim Triple.getArch() == llvm::Triple::aarch64_32) 225276479Sdim CPU = "cyclone"; 226259698Sdim } 227259698Sdim 228309124Sdim TargetMachine *target = 229309124Sdim march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None); 230259698Sdim 231314564Sdim std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target)); 232296417Sdim Ret->parseSymbols(); 233276479Sdim Ret->parseMetadata(); 234276479Sdim 235296417Sdim return std::move(Ret); 236259698Sdim} 237259698Sdim 238276479Sdim/// Create a MemoryBuffer from a memory range with an optional name. 239280031Sdimstd::unique_ptr<MemoryBuffer> 240280031SdimLTOModule::makeBuffer(const void *mem, size_t length, StringRef name) { 241259698Sdim const char *startPtr = (const char*)mem; 242276479Sdim return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false); 243259698Sdim} 244259698Sdim 245259698Sdim/// objcClassNameFromExpression - Get string that the data pointer points to. 246259698Sdimbool 247259698SdimLTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) { 248259698Sdim if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { 249259698Sdim Constant *op = ce->getOperand(0); 250259698Sdim if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { 251259698Sdim Constant *cn = gvn->getInitializer(); 252259698Sdim if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { 253259698Sdim if (ca->isCString()) { 254288943Sdim name = (".objc_class_name_" + ca->getAsCString()).str(); 255259698Sdim return true; 256259698Sdim } 257259698Sdim } 258259698Sdim } 259259698Sdim } 260259698Sdim return false; 261259698Sdim} 262259698Sdim 263259698Sdim/// addObjCClass - Parse i386/ppc ObjC class data structure. 264259698Sdimvoid LTOModule::addObjCClass(const GlobalVariable *clgv) { 265259698Sdim const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 266259698Sdim if (!c) return; 267259698Sdim 268259698Sdim // second slot in __OBJC,__class is pointer to superclass name 269259698Sdim std::string superclassName; 270259698Sdim if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { 271280031Sdim auto IterBool = 272280031Sdim _undefines.insert(std::make_pair(superclassName, NameAndAttributes())); 273280031Sdim if (IterBool.second) { 274280031Sdim NameAndAttributes &info = IterBool.first->second; 275314564Sdim info.name = IterBool.first->first(); 276259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 277259698Sdim info.isFunction = false; 278259698Sdim info.symbol = clgv; 279259698Sdim } 280259698Sdim } 281259698Sdim 282259698Sdim // third slot in __OBJC,__class is pointer to class name 283259698Sdim std::string className; 284259698Sdim if (objcClassNameFromExpression(c->getOperand(2), className)) { 285280031Sdim auto Iter = _defines.insert(className).first; 286259698Sdim 287259698Sdim NameAndAttributes info; 288314564Sdim info.name = Iter->first(); 289259698Sdim info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | 290259698Sdim LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; 291259698Sdim info.isFunction = false; 292259698Sdim info.symbol = clgv; 293259698Sdim _symbols.push_back(info); 294259698Sdim } 295259698Sdim} 296259698Sdim 297259698Sdim/// addObjCCategory - Parse i386/ppc ObjC category data structure. 298259698Sdimvoid LTOModule::addObjCCategory(const GlobalVariable *clgv) { 299259698Sdim const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 300259698Sdim if (!c) return; 301259698Sdim 302259698Sdim // second slot in __OBJC,__category is pointer to target class name 303259698Sdim std::string targetclassName; 304259698Sdim if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) 305259698Sdim return; 306259698Sdim 307280031Sdim auto IterBool = 308280031Sdim _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 309259698Sdim 310280031Sdim if (!IterBool.second) 311259698Sdim return; 312259698Sdim 313280031Sdim NameAndAttributes &info = IterBool.first->second; 314314564Sdim info.name = IterBool.first->first(); 315259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 316259698Sdim info.isFunction = false; 317259698Sdim info.symbol = clgv; 318259698Sdim} 319259698Sdim 320259698Sdim/// addObjCClassRef - Parse i386/ppc ObjC class list data structure. 321259698Sdimvoid LTOModule::addObjCClassRef(const GlobalVariable *clgv) { 322259698Sdim std::string targetclassName; 323259698Sdim if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) 324259698Sdim return; 325259698Sdim 326280031Sdim auto IterBool = 327280031Sdim _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 328280031Sdim 329280031Sdim if (!IterBool.second) 330259698Sdim return; 331259698Sdim 332280031Sdim NameAndAttributes &info = IterBool.first->second; 333314564Sdim info.name = IterBool.first->first(); 334259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 335259698Sdim info.isFunction = false; 336259698Sdim info.symbol = clgv; 337259698Sdim} 338259698Sdim 339314564Sdimvoid LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) { 340276479Sdim SmallString<64> Buffer; 341276479Sdim { 342276479Sdim raw_svector_ostream OS(Buffer); 343314564Sdim SymTab.printSymbolName(OS, Sym); 344314564Sdim Buffer.c_str(); 345276479Sdim } 346276479Sdim 347314564Sdim const GlobalValue *V = Sym.get<GlobalValue *>(); 348314564Sdim addDefinedDataSymbol(Buffer, V); 349276479Sdim} 350276479Sdim 351314564Sdimvoid LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) { 352259698Sdim // Add to list of defined symbols. 353276479Sdim addDefinedSymbol(Name, v, false); 354259698Sdim 355259698Sdim if (!v->hasSection() /* || !isTargetDarwin */) 356259698Sdim return; 357259698Sdim 358259698Sdim // Special case i386/ppc ObjC data structures in magic sections: 359259698Sdim // The issue is that the old ObjC object format did some strange 360259698Sdim // contortions to avoid real linker symbols. For instance, the 361259698Sdim // ObjC class data structure is allocated statically in the executable 362259698Sdim // that defines that class. That data structures contains a pointer to 363259698Sdim // its superclass. But instead of just initializing that part of the 364259698Sdim // struct to the address of its superclass, and letting the static and 365259698Sdim // dynamic linkers do the rest, the runtime works by having that field 366259698Sdim // instead point to a C-string that is the name of the superclass. 367259698Sdim // At runtime the objc initialization updates that pointer and sets 368259698Sdim // it to point to the actual super class. As far as the linker 369259698Sdim // knows it is just a pointer to a string. But then someone wanted the 370259698Sdim // linker to issue errors at build time if the superclass was not found. 371259698Sdim // So they figured out a way in mach-o object format to use an absolute 372259698Sdim // symbols (.objc_class_name_Foo = 0) and a floating reference 373259698Sdim // (.reference .objc_class_name_Bar) to cause the linker into erroring when 374259698Sdim // a class was missing. 375259698Sdim // The following synthesizes the implicit .objc_* symbols for the linker 376259698Sdim // from the ObjC data structures generated by the front end. 377259698Sdim 378259698Sdim // special case if this data blob is an ObjC class definition 379327952Sdim if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(v)) { 380327952Sdim StringRef Section = GV->getSection(); 381327952Sdim if (Section.startswith("__OBJC,__class,")) { 382327952Sdim addObjCClass(GV); 383259698Sdim } 384259698Sdim 385327952Sdim // special case if this data blob is an ObjC category definition 386327952Sdim else if (Section.startswith("__OBJC,__category,")) { 387327952Sdim addObjCCategory(GV); 388259698Sdim } 389259698Sdim 390327952Sdim // special case if this data blob is the list of referenced classes 391327952Sdim else if (Section.startswith("__OBJC,__cls_refs,")) { 392327952Sdim addObjCClassRef(GV); 393259698Sdim } 394259698Sdim } 395259698Sdim} 396259698Sdim 397314564Sdimvoid LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) { 398276479Sdim SmallString<64> Buffer; 399276479Sdim { 400276479Sdim raw_svector_ostream OS(Buffer); 401314564Sdim SymTab.printSymbolName(OS, Sym); 402314564Sdim Buffer.c_str(); 403276479Sdim } 404276479Sdim 405314564Sdim const Function *F = cast<Function>(Sym.get<GlobalValue *>()); 406314564Sdim addDefinedFunctionSymbol(Buffer, F); 407276479Sdim} 408276479Sdim 409314564Sdimvoid LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) { 410259698Sdim // add to list of defined symbols 411276479Sdim addDefinedSymbol(Name, F, true); 412259698Sdim} 413259698Sdim 414314564Sdimvoid LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def, 415276479Sdim bool isFunction) { 416259698Sdim // set alignment part log2() can have rounding errors 417259698Sdim uint32_t align = def->getAlignment(); 418276479Sdim uint32_t attr = align ? countTrailingZeros(align) : 0; 419259698Sdim 420259698Sdim // set permissions part 421259698Sdim if (isFunction) { 422259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_CODE; 423259698Sdim } else { 424259698Sdim const GlobalVariable *gv = dyn_cast<GlobalVariable>(def); 425259698Sdim if (gv && gv->isConstant()) 426259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_RODATA; 427259698Sdim else 428259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_DATA; 429259698Sdim } 430259698Sdim 431259698Sdim // set definition part 432276479Sdim if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) 433259698Sdim attr |= LTO_SYMBOL_DEFINITION_WEAK; 434259698Sdim else if (def->hasCommonLinkage()) 435259698Sdim attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; 436259698Sdim else 437259698Sdim attr |= LTO_SYMBOL_DEFINITION_REGULAR; 438259698Sdim 439259698Sdim // set scope part 440276479Sdim if (def->hasLocalLinkage()) 441276479Sdim // Ignore visibility if linkage is local. 442276479Sdim attr |= LTO_SYMBOL_SCOPE_INTERNAL; 443276479Sdim else if (def->hasHiddenVisibility()) 444259698Sdim attr |= LTO_SYMBOL_SCOPE_HIDDEN; 445259698Sdim else if (def->hasProtectedVisibility()) 446259698Sdim attr |= LTO_SYMBOL_SCOPE_PROTECTED; 447341825Sdim else if (def->canBeOmittedFromSymbolTable()) 448259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; 449276479Sdim else 450259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT; 451259698Sdim 452288943Sdim if (def->hasComdat()) 453288943Sdim attr |= LTO_SYMBOL_COMDAT; 454288943Sdim 455288943Sdim if (isa<GlobalAlias>(def)) 456288943Sdim attr |= LTO_SYMBOL_ALIAS; 457288943Sdim 458280031Sdim auto Iter = _defines.insert(Name).first; 459259698Sdim 460259698Sdim // fill information structure 461259698Sdim NameAndAttributes info; 462280031Sdim StringRef NameRef = Iter->first(); 463314564Sdim info.name = NameRef; 464314564Sdim assert(NameRef.data()[NameRef.size()] == '\0'); 465259698Sdim info.attributes = attr; 466259698Sdim info.isFunction = isFunction; 467259698Sdim info.symbol = def; 468259698Sdim 469259698Sdim // add to table of symbols 470259698Sdim _symbols.push_back(info); 471259698Sdim} 472259698Sdim 473259698Sdim/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the 474259698Sdim/// defined list. 475314564Sdimvoid LTOModule::addAsmGlobalSymbol(StringRef name, 476259698Sdim lto_symbol_attributes scope) { 477280031Sdim auto IterBool = _defines.insert(name); 478259698Sdim 479259698Sdim // only add new define if not already defined 480280031Sdim if (!IterBool.second) 481259698Sdim return; 482259698Sdim 483314564Sdim NameAndAttributes &info = _undefines[IterBool.first->first()]; 484259698Sdim 485276479Sdim if (info.symbol == nullptr) { 486259698Sdim // FIXME: This is trying to take care of module ASM like this: 487259698Sdim // 488259698Sdim // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" 489259698Sdim // 490259698Sdim // but is gross and its mother dresses it funny. Have the ASM parser give us 491259698Sdim // more details for this type of situation so that we're not guessing so 492259698Sdim // much. 493259698Sdim 494259698Sdim // fill information structure 495314564Sdim info.name = IterBool.first->first(); 496259698Sdim info.attributes = 497259698Sdim LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; 498259698Sdim info.isFunction = false; 499276479Sdim info.symbol = nullptr; 500259698Sdim 501259698Sdim // add to table of symbols 502259698Sdim _symbols.push_back(info); 503259698Sdim return; 504259698Sdim } 505259698Sdim 506259698Sdim if (info.isFunction) 507276479Sdim addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol)); 508259698Sdim else 509276479Sdim addDefinedDataSymbol(info.name, info.symbol); 510259698Sdim 511259698Sdim _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; 512259698Sdim _symbols.back().attributes |= scope; 513259698Sdim} 514259698Sdim 515259698Sdim/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the 516259698Sdim/// undefined list. 517314564Sdimvoid LTOModule::addAsmGlobalSymbolUndef(StringRef name) { 518280031Sdim auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 519259698Sdim 520314564Sdim _asm_undefines.push_back(IterBool.first->first()); 521259698Sdim 522259698Sdim // we already have the symbol 523280031Sdim if (!IterBool.second) 524259698Sdim return; 525259698Sdim 526276479Sdim uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED; 527259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT; 528280031Sdim NameAndAttributes &info = IterBool.first->second; 529314564Sdim info.name = IterBool.first->first(); 530259698Sdim info.attributes = attr; 531259698Sdim info.isFunction = false; 532276479Sdim info.symbol = nullptr; 533259698Sdim} 534259698Sdim 535276479Sdim/// Add a symbol which isn't defined just yet to a list to be resolved later. 536314564Sdimvoid LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym, 537276479Sdim bool isFunc) { 538259698Sdim SmallString<64> name; 539276479Sdim { 540276479Sdim raw_svector_ostream OS(name); 541314564Sdim SymTab.printSymbolName(OS, Sym); 542314564Sdim name.c_str(); 543276479Sdim } 544259698Sdim 545280031Sdim auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 546259698Sdim 547259698Sdim // we already have the symbol 548280031Sdim if (!IterBool.second) 549259698Sdim return; 550259698Sdim 551280031Sdim NameAndAttributes &info = IterBool.first->second; 552259698Sdim 553314564Sdim info.name = IterBool.first->first(); 554259698Sdim 555314564Sdim const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>(); 556276479Sdim 557259698Sdim if (decl->hasExternalWeakLinkage()) 558259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF; 559259698Sdim else 560259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 561259698Sdim 562259698Sdim info.isFunction = isFunc; 563259698Sdim info.symbol = decl; 564259698Sdim} 565259698Sdim 566296417Sdimvoid LTOModule::parseSymbols() { 567314564Sdim for (auto Sym : SymTab.symbols()) { 568314564Sdim auto *GV = Sym.dyn_cast<GlobalValue *>(); 569314564Sdim uint32_t Flags = SymTab.getSymbolFlags(Sym); 570276479Sdim if (Flags & object::BasicSymbolRef::SF_FormatSpecific) 571276479Sdim continue; 572259698Sdim 573276479Sdim bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined; 574259698Sdim 575276479Sdim if (!GV) { 576276479Sdim SmallString<64> Buffer; 577276479Sdim { 578276479Sdim raw_svector_ostream OS(Buffer); 579314564Sdim SymTab.printSymbolName(OS, Sym); 580314564Sdim Buffer.c_str(); 581259698Sdim } 582314564Sdim StringRef Name(Buffer); 583259698Sdim 584276479Sdim if (IsUndefined) 585276479Sdim addAsmGlobalSymbolUndef(Name); 586276479Sdim else if (Flags & object::BasicSymbolRef::SF_Global) 587276479Sdim addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT); 588276479Sdim else 589276479Sdim addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL); 590276479Sdim continue; 591259698Sdim } 592259698Sdim 593276479Sdim auto *F = dyn_cast<Function>(GV); 594276479Sdim if (IsUndefined) { 595276479Sdim addPotentialUndefinedSymbol(Sym, F != nullptr); 596276479Sdim continue; 597259698Sdim } 598259698Sdim 599276479Sdim if (F) { 600276479Sdim addDefinedFunctionSymbol(Sym); 601276479Sdim continue; 602259698Sdim } 603259698Sdim 604276479Sdim if (isa<GlobalVariable>(GV)) { 605276479Sdim addDefinedDataSymbol(Sym); 606276479Sdim continue; 607259698Sdim } 608259698Sdim 609276479Sdim assert(isa<GlobalAlias>(GV)); 610276479Sdim addDefinedDataSymbol(Sym); 611259698Sdim } 612259698Sdim 613259698Sdim // make symbols for all undefines 614259698Sdim for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), 615259698Sdim e = _undefines.end(); u != e; ++u) { 616259698Sdim // If this symbol also has a definition, then don't make an undefine because 617259698Sdim // it is a tentative definition. 618259698Sdim if (_defines.count(u->getKey())) continue; 619259698Sdim NameAndAttributes info = u->getValue(); 620259698Sdim _symbols.push_back(info); 621259698Sdim } 622259698Sdim} 623276479Sdim 624276479Sdim/// parseMetadata - Parse metadata from the module 625276479Sdimvoid LTOModule::parseMetadata() { 626288943Sdim raw_string_ostream OS(LinkerOpts); 627288943Sdim 628276479Sdim // Linker Options 629321369Sdim if (NamedMDNode *LinkerOptions = 630321369Sdim getModule().getNamedMetadata("llvm.linker.options")) { 631276479Sdim for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 632321369Sdim MDNode *MDOptions = LinkerOptions->getOperand(i); 633276479Sdim for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 634276479Sdim MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 635288943Sdim OS << " " << MDOption->getString(); 636276479Sdim } 637276479Sdim } 638276479Sdim } 639276479Sdim 640321369Sdim // Globals - we only need to do this for COFF. 641321369Sdim const Triple TT(_target->getTargetTriple()); 642321369Sdim if (!TT.isOSBinFormatCOFF()) 643321369Sdim return; 644321369Sdim Mangler M; 645288943Sdim for (const NameAndAttributes &Sym : _symbols) { 646288943Sdim if (!Sym.symbol) 647288943Sdim continue; 648321369Sdim emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M); 649288943Sdim } 650353358Sdim} 651288943Sdim 652353358Sdimlto::InputFile *LTOModule::createInputFile(const void *buffer, 653353358Sdim size_t buffer_size, const char *path, 654353358Sdim std::string &outErr) { 655353358Sdim StringRef Data((const char *)buffer, buffer_size); 656353358Sdim MemoryBufferRef BufferRef(Data, path); 657353358Sdim 658353358Sdim Expected<std::unique_ptr<lto::InputFile>> ObjOrErr = 659353358Sdim lto::InputFile::create(BufferRef); 660353358Sdim 661353358Sdim if (ObjOrErr) 662353358Sdim return ObjOrErr->release(); 663353358Sdim 664353358Sdim outErr = std::string(path) + 665353358Sdim ": Could not read LTO input file: " + toString(ObjOrErr.takeError()); 666353358Sdim return nullptr; 667276479Sdim} 668353358Sdim 669353358Sdimsize_t LTOModule::getDependentLibraryCount(lto::InputFile *input) { 670353358Sdim return input->getDependentLibraries().size(); 671353358Sdim} 672353358Sdim 673353358Sdimconst char *LTOModule::getDependentLibrary(lto::InputFile *input, size_t index, 674353358Sdim size_t *size) { 675353358Sdim StringRef S = input->getDependentLibraries()[index]; 676353358Sdim *size = S.size(); 677353358Sdim return S.data(); 678353358Sdim} 679