Home | History | Annotate | Download | only in LTO 
      1 //===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the Link Time Optimization library. This library is
     11 // intended to be used by linker to optimize code at link time.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "llvm/LTO/legacy/LTOModule.h"
     16 #include "llvm/ADT/Triple.h"
     17 #include "llvm/Bitcode/BitcodeReader.h"
     18 #include "llvm/CodeGen/TargetSubtargetInfo.h"
     19 #include "llvm/IR/Constants.h"
     20 #include "llvm/IR/LLVMContext.h"
     21 #include "llvm/IR/Mangler.h"
     22 #include "llvm/IR/Metadata.h"
     23 #include "llvm/IR/Module.h"
     24 #include "llvm/MC/MCExpr.h"
     25 #include "llvm/MC/MCInst.h"
     26 #include "llvm/MC/MCParser/MCAsmParser.h"
     27 #include "llvm/MC/MCSection.h"
     28 #include "llvm/MC/MCSubtargetInfo.h"
     29 #include "llvm/MC/MCSymbol.h"
     30 #include "llvm/MC/SubtargetFeature.h"
     31 #include "llvm/Object/IRObjectFile.h"
     32 #include "llvm/Object/ObjectFile.h"
     33 #include "llvm/Support/FileSystem.h"
     34 #include "llvm/Support/Host.h"
     35 #include "llvm/Support/MemoryBuffer.h"
     36 #include "llvm/Support/Path.h"
     37 #include "llvm/Support/SourceMgr.h"
     38 #include "llvm/Support/TargetRegistry.h"
     39 #include "llvm/Support/TargetSelect.h"
     40 #include "llvm/Target/TargetLoweringObjectFile.h"
     41 #include "llvm/Transforms/Utils/GlobalStatus.h"
     42 #include <system_error>
     43 using namespace llvm;
     44 using namespace llvm::object;
     45 
     46 LTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef,
     47                      llvm::TargetMachine *TM)
     48     : Mod(std::move(M)), MBRef(MBRef), _target(TM) {
     49   SymTab.addModule(Mod.get());
     50 }
     51 
     52 LTOModule::~LTOModule() {}
     53 
     54 /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
     55 /// bitcode.
     56 bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) {
     57   Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
     58       MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>"));
     59   return !errorToBool(BCData.takeError());
     60 }
     61 
     62 bool LTOModule::isBitcodeFile(StringRef Path) {
     63   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
     64       MemoryBuffer::getFile(Path);
     65   if (!BufferOrErr)
     66     return false;
     67 
     68   Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
     69       BufferOrErr.get()->getMemBufferRef());
     70   return !errorToBool(BCData.takeError());
     71 }
     72 
     73 bool LTOModule::isThinLTO() {
     74   Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef);
     75   if (!Result) {
     76     logAllUnhandledErrors(Result.takeError(), errs(), "");
     77     return false;
     78   }
     79   return Result->IsThinLTO;
     80 }
     81 
     82 bool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer,
     83                                    StringRef TriplePrefix) {
     84   Expected<MemoryBufferRef> BCOrErr =
     85       IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
     86   if (errorToBool(BCOrErr.takeError()))
     87     return false;
     88   LLVMContext Context;
     89   ErrorOr<std::string> TripleOrErr =
     90       expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr));
     91   if (!TripleOrErr)
     92     return false;
     93   return StringRef(*TripleOrErr).startswith(TriplePrefix);
     94 }
     95 
     96 std::string LTOModule::getProducerString(MemoryBuffer *Buffer) {
     97   Expected<MemoryBufferRef> BCOrErr =
     98       IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
     99   if (errorToBool(BCOrErr.takeError()))
    100     return "";
    101   LLVMContext Context;
    102   ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors(
    103       Context, getBitcodeProducerString(*BCOrErr));
    104   if (!ProducerOrErr)
    105     return "";
    106   return *ProducerOrErr;
    107 }
    108 
    109 ErrorOr<std::unique_ptr<LTOModule>>
    110 LTOModule::createFromFile(LLVMContext &Context, StringRef path,
    111                           const TargetOptions &options) {
    112   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
    113       MemoryBuffer::getFile(path);
    114   if (std::error_code EC = BufferOrErr.getError()) {
    115     Context.emitError(EC.message());
    116     return EC;
    117   }
    118   std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
    119   return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
    120                        /* ShouldBeLazy*/ false);
    121 }
    122 
    123 ErrorOr<std::unique_ptr<LTOModule>>
    124 LTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path,
    125                               size_t size, const TargetOptions &options) {
    126   return createFromOpenFileSlice(Context, fd, path, size, 0, options);
    127 }
    128 
    129 ErrorOr<std::unique_ptr<LTOModule>>
    130 LTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path,
    131                                    size_t map_size, off_t offset,
    132                                    const TargetOptions &options) {
    133   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
    134       MemoryBuffer::getOpenFileSlice(fd, path, 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   // Add other interesting metadata here.
    651 }
    652