LTOModule.cpp revision 296417
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 15259698Sdim#include "llvm/LTO/LTOModule.h" 16259698Sdim#include "llvm/ADT/Triple.h" 17259698Sdim#include "llvm/Bitcode/ReaderWriter.h" 18280031Sdim#include "llvm/CodeGen/Analysis.h" 19259698Sdim#include "llvm/IR/Constants.h" 20280031Sdim#include "llvm/IR/DiagnosticPrinter.h" 21259698Sdim#include "llvm/IR/LLVMContext.h" 22288943Sdim#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" 29276479Sdim#include "llvm/MC/MCSection.h" 30259698Sdim#include "llvm/MC/MCSubtargetInfo.h" 31259698Sdim#include "llvm/MC/MCSymbol.h" 32259698Sdim#include "llvm/MC/MCTargetAsmParser.h" 33259698Sdim#include "llvm/MC/SubtargetFeature.h" 34280031Sdim#include "llvm/Object/IRObjectFile.h" 35280031Sdim#include "llvm/Object/ObjectFile.h" 36259698Sdim#include "llvm/Support/CommandLine.h" 37276479Sdim#include "llvm/Support/FileSystem.h" 38259698Sdim#include "llvm/Support/Host.h" 39259698Sdim#include "llvm/Support/MemoryBuffer.h" 40259698Sdim#include "llvm/Support/Path.h" 41259698Sdim#include "llvm/Support/SourceMgr.h" 42259698Sdim#include "llvm/Support/TargetRegistry.h" 43259698Sdim#include "llvm/Support/TargetSelect.h" 44276479Sdim#include "llvm/Target/TargetLowering.h" 45276479Sdim#include "llvm/Target/TargetLoweringObjectFile.h" 46259698Sdim#include "llvm/Target/TargetRegisterInfo.h" 47280031Sdim#include "llvm/Target/TargetSubtargetInfo.h" 48259698Sdim#include "llvm/Transforms/Utils/GlobalStatus.h" 49276479Sdim#include <system_error> 50259698Sdimusing namespace llvm; 51280031Sdimusing namespace llvm::object; 52259698Sdim 53276479SdimLTOModule::LTOModule(std::unique_ptr<object::IRObjectFile> Obj, 54276479Sdim llvm::TargetMachine *TM) 55276479Sdim : IRFile(std::move(Obj)), _target(TM) {} 56259698Sdim 57280031SdimLTOModule::LTOModule(std::unique_ptr<object::IRObjectFile> Obj, 58280031Sdim llvm::TargetMachine *TM, 59280031Sdim std::unique_ptr<LLVMContext> Context) 60280031Sdim : OwnedContext(std::move(Context)), IRFile(std::move(Obj)), _target(TM) {} 61280031Sdim 62280031SdimLTOModule::~LTOModule() {} 63280031Sdim 64259698Sdim/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM 65259698Sdim/// bitcode. 66280031Sdimbool LTOModule::isBitcodeFile(const void *Mem, size_t Length) { 67280031Sdim ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 68280031Sdim MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>")); 69280031Sdim return bool(BCData); 70259698Sdim} 71259698Sdim 72280031Sdimbool LTOModule::isBitcodeFile(const char *Path) { 73280031Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 74280031Sdim MemoryBuffer::getFile(Path); 75280031Sdim if (!BufferOrErr) 76259698Sdim return false; 77280031Sdim 78280031Sdim ErrorOr<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer( 79280031Sdim BufferOrErr.get()->getMemBufferRef()); 80280031Sdim return bool(BCData); 81259698Sdim} 82259698Sdim 83280031Sdimbool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer, 84280031Sdim StringRef TriplePrefix) { 85280031Sdim ErrorOr<MemoryBufferRef> BCOrErr = 86280031Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 87280031Sdim if (!BCOrErr) 88280031Sdim return false; 89280031Sdim LLVMContext Context; 90280031Sdim std::string Triple = getBitcodeTargetTriple(*BCOrErr, Context); 91280031Sdim return StringRef(Triple).startswith(TriplePrefix); 92259698Sdim} 93259698Sdim 94296417Sdimstd::string LTOModule::getProducerString(MemoryBuffer *Buffer) { 95296417Sdim ErrorOr<MemoryBufferRef> BCOrErr = 96296417Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef()); 97296417Sdim if (!BCOrErr) 98296417Sdim return ""; 99296417Sdim LLVMContext Context; 100296417Sdim return getBitcodeProducerString(*BCOrErr, Context); 101296417Sdim} 102296417Sdim 103296417SdimErrorOr<std::unique_ptr<LTOModule>> 104296417SdimLTOModule::createFromFile(LLVMContext &Context, const char *path, 105296417Sdim TargetOptions options) { 106276479Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 107276479Sdim MemoryBuffer::getFile(path); 108296417Sdim if (std::error_code EC = BufferOrErr.getError()) 109296417Sdim return EC; 110280031Sdim std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 111296417Sdim return makeLTOModule(Buffer->getMemBufferRef(), options, &Context); 112259698Sdim} 113259698Sdim 114296417SdimErrorOr<std::unique_ptr<LTOModule>> 115296417SdimLTOModule::createFromOpenFile(LLVMContext &Context, int fd, const char *path, 116296417Sdim size_t size, TargetOptions options) { 117296417Sdim return createFromOpenFileSlice(Context, fd, path, size, 0, options); 118259698Sdim} 119259698Sdim 120296417SdimErrorOr<std::unique_ptr<LTOModule>> 121296417SdimLTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, 122296417Sdim const char *path, size_t map_size, 123296417Sdim off_t offset, TargetOptions options) { 124276479Sdim ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = 125276479Sdim MemoryBuffer::getOpenFileSlice(fd, path, map_size, offset); 126296417Sdim if (std::error_code EC = BufferOrErr.getError()) 127296417Sdim return EC; 128280031Sdim std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get()); 129296417Sdim return makeLTOModule(Buffer->getMemBufferRef(), options, &Context); 130259698Sdim} 131259698Sdim 132296417SdimErrorOr<std::unique_ptr<LTOModule>> 133296417SdimLTOModule::createFromBuffer(LLVMContext &Context, const void *mem, 134296417Sdim size_t length, TargetOptions options, 135296417Sdim StringRef path) { 136296417Sdim return createInContext(mem, length, options, path, &Context); 137259698Sdim} 138259698Sdim 139296417SdimErrorOr<std::unique_ptr<LTOModule>> 140296417SdimLTOModule::createInLocalContext(const void *mem, size_t length, 141296417Sdim TargetOptions options, StringRef path) { 142296417Sdim return createInContext(mem, length, options, path, nullptr); 143280031Sdim} 144280031Sdim 145296417SdimErrorOr<std::unique_ptr<LTOModule>> 146296417SdimLTOModule::createInContext(const void *mem, size_t length, 147296417Sdim TargetOptions options, StringRef path, 148296417Sdim LLVMContext *Context) { 149280031Sdim StringRef Data((const char *)mem, length); 150280031Sdim MemoryBufferRef Buffer(Data, path); 151296417Sdim return makeLTOModule(Buffer, options, Context); 152280031Sdim} 153280031Sdim 154296417Sdimstatic ErrorOr<std::unique_ptr<Module>> 155296417SdimparseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, 156296417Sdim bool ShouldBeLazy) { 157280031Sdim 158280031Sdim // Find the buffer. 159280031Sdim ErrorOr<MemoryBufferRef> MBOrErr = 160280031Sdim IRObjectFile::findBitcodeInMemBuffer(Buffer); 161296417Sdim if (std::error_code EC = MBOrErr.getError()) 162296417Sdim return EC; 163259698Sdim 164280031Sdim if (!ShouldBeLazy) { 165280031Sdim // Parse the full file. 166296417Sdim ErrorOr<std::unique_ptr<Module>> M = parseBitcodeFile(*MBOrErr, Context); 167296417Sdim if (std::error_code EC = M.getError()) 168296417Sdim return EC; 169288943Sdim return std::move(*M); 170280031Sdim } 171280031Sdim 172280031Sdim // Parse lazily. 173280031Sdim std::unique_ptr<MemoryBuffer> LightweightBuf = 174280031Sdim MemoryBuffer::getMemBuffer(*MBOrErr, false); 175296417Sdim ErrorOr<std::unique_ptr<Module>> M = getLazyBitcodeModule( 176296417Sdim std::move(LightweightBuf), Context, true /*ShouldLazyLoadMetadata*/); 177296417Sdim if (std::error_code EC = M.getError()) 178296417Sdim return EC; 179288943Sdim return std::move(*M); 180280031Sdim} 181280031Sdim 182296417SdimErrorOr<std::unique_ptr<LTOModule>> 183296417SdimLTOModule::makeLTOModule(MemoryBufferRef Buffer, TargetOptions options, 184296417Sdim LLVMContext *Context) { 185280031Sdim std::unique_ptr<LLVMContext> OwnedContext; 186280031Sdim if (!Context) { 187280031Sdim OwnedContext = llvm::make_unique<LLVMContext>(); 188280031Sdim Context = OwnedContext.get(); 189280031Sdim } 190280031Sdim 191280031Sdim // If we own a context, we know this is being used only for symbol 192280031Sdim // extraction, not linking. Be lazy in that case. 193296417Sdim ErrorOr<std::unique_ptr<Module>> MOrErr = 194296417Sdim parseBitcodeFileImpl(Buffer, *Context, 195296417Sdim /* ShouldBeLazy */ static_cast<bool>(OwnedContext)); 196296417Sdim if (std::error_code EC = MOrErr.getError()) 197296417Sdim return EC; 198296417Sdim std::unique_ptr<Module> &M = *MOrErr; 199280031Sdim 200276479Sdim std::string TripleStr = M->getTargetTriple(); 201259698Sdim if (TripleStr.empty()) 202259698Sdim TripleStr = sys::getDefaultTargetTriple(); 203259698Sdim llvm::Triple Triple(TripleStr); 204259698Sdim 205259698Sdim // find machine architecture for this module 206296417Sdim std::string errMsg; 207259698Sdim const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg); 208259698Sdim if (!march) 209296417Sdim return std::unique_ptr<LTOModule>(nullptr); 210259698Sdim 211259698Sdim // construct LTOModule, hand over ownership of module and target 212259698Sdim SubtargetFeatures Features; 213259698Sdim Features.getDefaultSubtargetFeatures(Triple); 214259698Sdim std::string FeatureStr = Features.getString(); 215259698Sdim // Set a default CPU for Darwin triples. 216259698Sdim std::string CPU; 217259698Sdim if (Triple.isOSDarwin()) { 218259698Sdim if (Triple.getArch() == llvm::Triple::x86_64) 219259698Sdim CPU = "core2"; 220259698Sdim else if (Triple.getArch() == llvm::Triple::x86) 221259698Sdim CPU = "yonah"; 222280031Sdim else if (Triple.getArch() == llvm::Triple::aarch64) 223276479Sdim CPU = "cyclone"; 224259698Sdim } 225259698Sdim 226259698Sdim TargetMachine *target = march->createTargetMachine(TripleStr, CPU, FeatureStr, 227259698Sdim options); 228296417Sdim M->setDataLayout(target->createDataLayout()); 229259698Sdim 230276479Sdim std::unique_ptr<object::IRObjectFile> IRObj( 231280031Sdim new object::IRObjectFile(Buffer, std::move(M))); 232276479Sdim 233296417Sdim std::unique_ptr<LTOModule> Ret; 234280031Sdim if (OwnedContext) 235296417Sdim Ret.reset(new LTOModule(std::move(IRObj), target, std::move(OwnedContext))); 236280031Sdim else 237296417Sdim Ret.reset(new LTOModule(std::move(IRObj), target)); 238276479Sdim 239296417Sdim Ret->parseSymbols(); 240276479Sdim Ret->parseMetadata(); 241276479Sdim 242296417Sdim return std::move(Ret); 243259698Sdim} 244259698Sdim 245276479Sdim/// Create a MemoryBuffer from a memory range with an optional name. 246280031Sdimstd::unique_ptr<MemoryBuffer> 247280031SdimLTOModule::makeBuffer(const void *mem, size_t length, StringRef name) { 248259698Sdim const char *startPtr = (const char*)mem; 249276479Sdim return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false); 250259698Sdim} 251259698Sdim 252259698Sdim/// objcClassNameFromExpression - Get string that the data pointer points to. 253259698Sdimbool 254259698SdimLTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) { 255259698Sdim if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) { 256259698Sdim Constant *op = ce->getOperand(0); 257259698Sdim if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) { 258259698Sdim Constant *cn = gvn->getInitializer(); 259259698Sdim if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) { 260259698Sdim if (ca->isCString()) { 261288943Sdim name = (".objc_class_name_" + ca->getAsCString()).str(); 262259698Sdim return true; 263259698Sdim } 264259698Sdim } 265259698Sdim } 266259698Sdim } 267259698Sdim return false; 268259698Sdim} 269259698Sdim 270259698Sdim/// addObjCClass - Parse i386/ppc ObjC class data structure. 271259698Sdimvoid LTOModule::addObjCClass(const GlobalVariable *clgv) { 272259698Sdim const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 273259698Sdim if (!c) return; 274259698Sdim 275259698Sdim // second slot in __OBJC,__class is pointer to superclass name 276259698Sdim std::string superclassName; 277259698Sdim if (objcClassNameFromExpression(c->getOperand(1), superclassName)) { 278280031Sdim auto IterBool = 279280031Sdim _undefines.insert(std::make_pair(superclassName, NameAndAttributes())); 280280031Sdim if (IterBool.second) { 281280031Sdim NameAndAttributes &info = IterBool.first->second; 282280031Sdim info.name = IterBool.first->first().data(); 283259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 284259698Sdim info.isFunction = false; 285259698Sdim info.symbol = clgv; 286259698Sdim } 287259698Sdim } 288259698Sdim 289259698Sdim // third slot in __OBJC,__class is pointer to class name 290259698Sdim std::string className; 291259698Sdim if (objcClassNameFromExpression(c->getOperand(2), className)) { 292280031Sdim auto Iter = _defines.insert(className).first; 293259698Sdim 294259698Sdim NameAndAttributes info; 295280031Sdim info.name = Iter->first().data(); 296259698Sdim info.attributes = LTO_SYMBOL_PERMISSIONS_DATA | 297259698Sdim LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT; 298259698Sdim info.isFunction = false; 299259698Sdim info.symbol = clgv; 300259698Sdim _symbols.push_back(info); 301259698Sdim } 302259698Sdim} 303259698Sdim 304259698Sdim/// addObjCCategory - Parse i386/ppc ObjC category data structure. 305259698Sdimvoid LTOModule::addObjCCategory(const GlobalVariable *clgv) { 306259698Sdim const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer()); 307259698Sdim if (!c) return; 308259698Sdim 309259698Sdim // second slot in __OBJC,__category is pointer to target class name 310259698Sdim std::string targetclassName; 311259698Sdim if (!objcClassNameFromExpression(c->getOperand(1), targetclassName)) 312259698Sdim return; 313259698Sdim 314280031Sdim auto IterBool = 315280031Sdim _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 316259698Sdim 317280031Sdim if (!IterBool.second) 318259698Sdim return; 319259698Sdim 320280031Sdim NameAndAttributes &info = IterBool.first->second; 321280031Sdim info.name = IterBool.first->first().data(); 322259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 323259698Sdim info.isFunction = false; 324259698Sdim info.symbol = clgv; 325259698Sdim} 326259698Sdim 327259698Sdim/// addObjCClassRef - Parse i386/ppc ObjC class list data structure. 328259698Sdimvoid LTOModule::addObjCClassRef(const GlobalVariable *clgv) { 329259698Sdim std::string targetclassName; 330259698Sdim if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName)) 331259698Sdim return; 332259698Sdim 333280031Sdim auto IterBool = 334280031Sdim _undefines.insert(std::make_pair(targetclassName, NameAndAttributes())); 335280031Sdim 336280031Sdim if (!IterBool.second) 337259698Sdim return; 338259698Sdim 339280031Sdim NameAndAttributes &info = IterBool.first->second; 340280031Sdim info.name = IterBool.first->first().data(); 341259698Sdim info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED; 342259698Sdim info.isFunction = false; 343259698Sdim info.symbol = clgv; 344259698Sdim} 345259698Sdim 346276479Sdimvoid LTOModule::addDefinedDataSymbol(const object::BasicSymbolRef &Sym) { 347276479Sdim SmallString<64> Buffer; 348276479Sdim { 349276479Sdim raw_svector_ostream OS(Buffer); 350276479Sdim Sym.printName(OS); 351276479Sdim } 352276479Sdim 353276479Sdim const GlobalValue *V = IRFile->getSymbolGV(Sym.getRawDataRefImpl()); 354276479Sdim addDefinedDataSymbol(Buffer.c_str(), V); 355276479Sdim} 356276479Sdim 357276479Sdimvoid LTOModule::addDefinedDataSymbol(const char *Name, const GlobalValue *v) { 358259698Sdim // Add to list of defined symbols. 359276479Sdim addDefinedSymbol(Name, v, false); 360259698Sdim 361259698Sdim if (!v->hasSection() /* || !isTargetDarwin */) 362259698Sdim return; 363259698Sdim 364259698Sdim // Special case i386/ppc ObjC data structures in magic sections: 365259698Sdim // The issue is that the old ObjC object format did some strange 366259698Sdim // contortions to avoid real linker symbols. For instance, the 367259698Sdim // ObjC class data structure is allocated statically in the executable 368259698Sdim // that defines that class. That data structures contains a pointer to 369259698Sdim // its superclass. But instead of just initializing that part of the 370259698Sdim // struct to the address of its superclass, and letting the static and 371259698Sdim // dynamic linkers do the rest, the runtime works by having that field 372259698Sdim // instead point to a C-string that is the name of the superclass. 373259698Sdim // At runtime the objc initialization updates that pointer and sets 374259698Sdim // it to point to the actual super class. As far as the linker 375259698Sdim // knows it is just a pointer to a string. But then someone wanted the 376259698Sdim // linker to issue errors at build time if the superclass was not found. 377259698Sdim // So they figured out a way in mach-o object format to use an absolute 378259698Sdim // symbols (.objc_class_name_Foo = 0) and a floating reference 379259698Sdim // (.reference .objc_class_name_Bar) to cause the linker into erroring when 380259698Sdim // a class was missing. 381259698Sdim // The following synthesizes the implicit .objc_* symbols for the linker 382259698Sdim // from the ObjC data structures generated by the front end. 383259698Sdim 384259698Sdim // special case if this data blob is an ObjC class definition 385276479Sdim std::string Section = v->getSection(); 386276479Sdim if (Section.compare(0, 15, "__OBJC,__class,") == 0) { 387259698Sdim if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 388259698Sdim addObjCClass(gv); 389259698Sdim } 390259698Sdim } 391259698Sdim 392259698Sdim // special case if this data blob is an ObjC category definition 393276479Sdim else if (Section.compare(0, 18, "__OBJC,__category,") == 0) { 394259698Sdim if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 395259698Sdim addObjCCategory(gv); 396259698Sdim } 397259698Sdim } 398259698Sdim 399259698Sdim // special case if this data blob is the list of referenced classes 400276479Sdim else if (Section.compare(0, 18, "__OBJC,__cls_refs,") == 0) { 401259698Sdim if (const GlobalVariable *gv = dyn_cast<GlobalVariable>(v)) { 402259698Sdim addObjCClassRef(gv); 403259698Sdim } 404259698Sdim } 405259698Sdim} 406259698Sdim 407276479Sdimvoid LTOModule::addDefinedFunctionSymbol(const object::BasicSymbolRef &Sym) { 408276479Sdim SmallString<64> Buffer; 409276479Sdim { 410276479Sdim raw_svector_ostream OS(Buffer); 411276479Sdim Sym.printName(OS); 412276479Sdim } 413276479Sdim 414276479Sdim const Function *F = 415276479Sdim cast<Function>(IRFile->getSymbolGV(Sym.getRawDataRefImpl())); 416276479Sdim addDefinedFunctionSymbol(Buffer.c_str(), F); 417276479Sdim} 418276479Sdim 419276479Sdimvoid LTOModule::addDefinedFunctionSymbol(const char *Name, const Function *F) { 420259698Sdim // add to list of defined symbols 421276479Sdim addDefinedSymbol(Name, F, true); 422259698Sdim} 423259698Sdim 424276479Sdimvoid LTOModule::addDefinedSymbol(const char *Name, const GlobalValue *def, 425276479Sdim bool isFunction) { 426259698Sdim // set alignment part log2() can have rounding errors 427259698Sdim uint32_t align = def->getAlignment(); 428276479Sdim uint32_t attr = align ? countTrailingZeros(align) : 0; 429259698Sdim 430259698Sdim // set permissions part 431259698Sdim if (isFunction) { 432259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_CODE; 433259698Sdim } else { 434259698Sdim const GlobalVariable *gv = dyn_cast<GlobalVariable>(def); 435259698Sdim if (gv && gv->isConstant()) 436259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_RODATA; 437259698Sdim else 438259698Sdim attr |= LTO_SYMBOL_PERMISSIONS_DATA; 439259698Sdim } 440259698Sdim 441259698Sdim // set definition part 442276479Sdim if (def->hasWeakLinkage() || def->hasLinkOnceLinkage()) 443259698Sdim attr |= LTO_SYMBOL_DEFINITION_WEAK; 444259698Sdim else if (def->hasCommonLinkage()) 445259698Sdim attr |= LTO_SYMBOL_DEFINITION_TENTATIVE; 446259698Sdim else 447259698Sdim attr |= LTO_SYMBOL_DEFINITION_REGULAR; 448259698Sdim 449259698Sdim // set scope part 450276479Sdim if (def->hasLocalLinkage()) 451276479Sdim // Ignore visibility if linkage is local. 452276479Sdim attr |= LTO_SYMBOL_SCOPE_INTERNAL; 453276479Sdim else if (def->hasHiddenVisibility()) 454259698Sdim attr |= LTO_SYMBOL_SCOPE_HIDDEN; 455259698Sdim else if (def->hasProtectedVisibility()) 456259698Sdim attr |= LTO_SYMBOL_SCOPE_PROTECTED; 457280031Sdim else if (canBeOmittedFromSymbolTable(def)) 458259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN; 459276479Sdim else 460259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT; 461259698Sdim 462288943Sdim if (def->hasComdat()) 463288943Sdim attr |= LTO_SYMBOL_COMDAT; 464288943Sdim 465288943Sdim if (isa<GlobalAlias>(def)) 466288943Sdim attr |= LTO_SYMBOL_ALIAS; 467288943Sdim 468280031Sdim auto Iter = _defines.insert(Name).first; 469259698Sdim 470259698Sdim // fill information structure 471259698Sdim NameAndAttributes info; 472280031Sdim StringRef NameRef = Iter->first(); 473276479Sdim info.name = NameRef.data(); 474276479Sdim assert(info.name[NameRef.size()] == '\0'); 475259698Sdim info.attributes = attr; 476259698Sdim info.isFunction = isFunction; 477259698Sdim info.symbol = def; 478259698Sdim 479259698Sdim // add to table of symbols 480259698Sdim _symbols.push_back(info); 481259698Sdim} 482259698Sdim 483259698Sdim/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the 484259698Sdim/// defined list. 485259698Sdimvoid LTOModule::addAsmGlobalSymbol(const char *name, 486259698Sdim lto_symbol_attributes scope) { 487280031Sdim auto IterBool = _defines.insert(name); 488259698Sdim 489259698Sdim // only add new define if not already defined 490280031Sdim if (!IterBool.second) 491259698Sdim return; 492259698Sdim 493280031Sdim NameAndAttributes &info = _undefines[IterBool.first->first().data()]; 494259698Sdim 495276479Sdim if (info.symbol == nullptr) { 496259698Sdim // FIXME: This is trying to take care of module ASM like this: 497259698Sdim // 498259698Sdim // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0" 499259698Sdim // 500259698Sdim // but is gross and its mother dresses it funny. Have the ASM parser give us 501259698Sdim // more details for this type of situation so that we're not guessing so 502259698Sdim // much. 503259698Sdim 504259698Sdim // fill information structure 505280031Sdim info.name = IterBool.first->first().data(); 506259698Sdim info.attributes = 507259698Sdim LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope; 508259698Sdim info.isFunction = false; 509276479Sdim info.symbol = nullptr; 510259698Sdim 511259698Sdim // add to table of symbols 512259698Sdim _symbols.push_back(info); 513259698Sdim return; 514259698Sdim } 515259698Sdim 516259698Sdim if (info.isFunction) 517276479Sdim addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol)); 518259698Sdim else 519276479Sdim addDefinedDataSymbol(info.name, info.symbol); 520259698Sdim 521259698Sdim _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK; 522259698Sdim _symbols.back().attributes |= scope; 523259698Sdim} 524259698Sdim 525259698Sdim/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the 526259698Sdim/// undefined list. 527259698Sdimvoid LTOModule::addAsmGlobalSymbolUndef(const char *name) { 528280031Sdim auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes())); 529259698Sdim 530280031Sdim _asm_undefines.push_back(IterBool.first->first().data()); 531259698Sdim 532259698Sdim // we already have the symbol 533280031Sdim if (!IterBool.second) 534259698Sdim return; 535259698Sdim 536276479Sdim uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED; 537259698Sdim attr |= LTO_SYMBOL_SCOPE_DEFAULT; 538280031Sdim NameAndAttributes &info = IterBool.first->second; 539280031Sdim info.name = IterBool.first->first().data(); 540259698Sdim info.attributes = attr; 541259698Sdim info.isFunction = false; 542276479Sdim info.symbol = nullptr; 543259698Sdim} 544259698Sdim 545276479Sdim/// Add a symbol which isn't defined just yet to a list to be resolved later. 546276479Sdimvoid LTOModule::addPotentialUndefinedSymbol(const object::BasicSymbolRef &Sym, 547276479Sdim bool isFunc) { 548259698Sdim SmallString<64> name; 549276479Sdim { 550276479Sdim raw_svector_ostream OS(name); 551276479Sdim Sym.printName(OS); 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 562280031Sdim info.name = IterBool.first->first().data(); 563259698Sdim 564276479Sdim const GlobalValue *decl = IRFile->getSymbolGV(Sym.getRawDataRefImpl()); 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() { 576276479Sdim for (auto &Sym : IRFile->symbols()) { 577276479Sdim const GlobalValue *GV = IRFile->getSymbolGV(Sym.getRawDataRefImpl()); 578276479Sdim uint32_t Flags = Sym.getFlags(); 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); 588276479Sdim Sym.printName(OS); 589259698Sdim } 590276479Sdim const char *Name = Buffer.c_str(); 591259698Sdim 592276479Sdim if (IsUndefined) 593276479Sdim addAsmGlobalSymbolUndef(Name); 594276479Sdim else if (Flags & object::BasicSymbolRef::SF_Global) 595276479Sdim addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT); 596276479Sdim else 597276479Sdim addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL); 598276479Sdim continue; 599259698Sdim } 600259698Sdim 601276479Sdim auto *F = dyn_cast<Function>(GV); 602276479Sdim if (IsUndefined) { 603276479Sdim addPotentialUndefinedSymbol(Sym, F != nullptr); 604276479Sdim continue; 605259698Sdim } 606259698Sdim 607276479Sdim if (F) { 608276479Sdim addDefinedFunctionSymbol(Sym); 609276479Sdim continue; 610259698Sdim } 611259698Sdim 612276479Sdim if (isa<GlobalVariable>(GV)) { 613276479Sdim addDefinedDataSymbol(Sym); 614276479Sdim continue; 615259698Sdim } 616259698Sdim 617276479Sdim assert(isa<GlobalAlias>(GV)); 618276479Sdim addDefinedDataSymbol(Sym); 619259698Sdim } 620259698Sdim 621259698Sdim // make symbols for all undefines 622259698Sdim for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(), 623259698Sdim e = _undefines.end(); u != e; ++u) { 624259698Sdim // If this symbol also has a definition, then don't make an undefine because 625259698Sdim // it is a tentative definition. 626259698Sdim if (_defines.count(u->getKey())) continue; 627259698Sdim NameAndAttributes info = u->getValue(); 628259698Sdim _symbols.push_back(info); 629259698Sdim } 630259698Sdim} 631276479Sdim 632276479Sdim/// parseMetadata - Parse metadata from the module 633276479Sdimvoid LTOModule::parseMetadata() { 634288943Sdim raw_string_ostream OS(LinkerOpts); 635288943Sdim 636276479Sdim // Linker Options 637280031Sdim if (Metadata *Val = getModule().getModuleFlag("Linker Options")) { 638276479Sdim MDNode *LinkerOptions = cast<MDNode>(Val); 639276479Sdim for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 640276479Sdim MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i)); 641276479Sdim for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 642276479Sdim MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 643288943Sdim OS << " " << MDOption->getString(); 644276479Sdim } 645276479Sdim } 646276479Sdim } 647276479Sdim 648288943Sdim // Globals 649288943Sdim Mangler Mang; 650288943Sdim for (const NameAndAttributes &Sym : _symbols) { 651288943Sdim if (!Sym.symbol) 652288943Sdim continue; 653288943Sdim _target->getObjFileLowering()->emitLinkerFlagsForGlobal(OS, Sym.symbol, 654288943Sdim Mang); 655288943Sdim } 656288943Sdim 657276479Sdim // Add other interesting metadata here. 658276479Sdim} 659