lib/LTO/LTOModule.cpp

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