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>
42using namespace llvm;
43using namespace llvm::object;
44
45LTOModule::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
51LTOModule::~LTOModule() {}
52
53/// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
54/// bitcode.
55bool 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
61bool 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
72bool 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
81bool 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
95std::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
108ErrorOr<std::unique_ptr<LTOModule>>
109LTOModule::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
122ErrorOr<std::unique_ptr<LTOModule>>
123LTOModule::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
128ErrorOr<std::unique_ptr<LTOModule>>
129LTOModule::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
144ErrorOr<std::unique_ptr<LTOModule>>
145LTOModule::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
153ErrorOr<std::unique_ptr<LTOModule>>
154LTOModule::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
168static ErrorOr<std::unique_ptr<Module>>
169parseBitcodeFileImpl(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
192ErrorOr<std::unique_ptr<LTOModule>>
193LTOModule::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             Triple.getArch() == llvm::Triple::aarch64_32)
225      CPU = "cyclone";
226  }
227
228  TargetMachine *target =
229      march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None);
230
231  std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
232  Ret->parseSymbols();
233  Ret->parseMetadata();
234
235  return std::move(Ret);
236}
237
238/// Create a MemoryBuffer from a memory range with an optional name.
239std::unique_ptr<MemoryBuffer>
240LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) {
241  const char *startPtr = (const char*)mem;
242  return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false);
243}
244
245/// objcClassNameFromExpression - Get string that the data pointer points to.
246bool
247LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) {
248  if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) {
249    Constant *op = ce->getOperand(0);
250    if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) {
251      Constant *cn = gvn->getInitializer();
252      if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) {
253        if (ca->isCString()) {
254          name = (".objc_class_name_" + ca->getAsCString()).str();
255          return true;
256        }
257      }
258    }
259  }
260  return false;
261}
262
263/// addObjCClass - Parse i386/ppc ObjC class data structure.
264void LTOModule::addObjCClass(const GlobalVariable *clgv) {
265  const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
266  if (!c) return;
267
268  // second slot in __OBJC,__class is pointer to superclass name
269  std::string superclassName;
270  if (objcClassNameFromExpression(c->getOperand(1), superclassName)) {
271    auto IterBool =
272        _undefines.insert(std::make_pair(superclassName, NameAndAttributes()));
273    if (IterBool.second) {
274      NameAndAttributes &info = IterBool.first->second;
275      info.name = IterBool.first->first();
276      info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
277      info.isFunction = false;
278      info.symbol = clgv;
279    }
280  }
281
282  // third slot in __OBJC,__class is pointer to class name
283  std::string className;
284  if (objcClassNameFromExpression(c->getOperand(2), className)) {
285    auto Iter = _defines.insert(className).first;
286
287    NameAndAttributes info;
288    info.name = Iter->first();
289    info.attributes = LTO_SYMBOL_PERMISSIONS_DATA |
290      LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT;
291    info.isFunction = false;
292    info.symbol = clgv;
293    _symbols.push_back(info);
294  }
295}
296
297/// addObjCCategory - Parse i386/ppc ObjC category data structure.
298void LTOModule::addObjCCategory(const GlobalVariable *clgv) {
299  const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
300  if (!c) return;
301
302  // second slot in __OBJC,__category is pointer to target class name
303  std::string targetclassName;
304  if (!objcClassNameFromExpression(c->getOperand(1), targetclassName))
305    return;
306
307  auto IterBool =
308      _undefines.insert(std::make_pair(targetclassName, NameAndAttributes()));
309
310  if (!IterBool.second)
311    return;
312
313  NameAndAttributes &info = IterBool.first->second;
314  info.name = IterBool.first->first();
315  info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
316  info.isFunction = false;
317  info.symbol = clgv;
318}
319
320/// addObjCClassRef - Parse i386/ppc ObjC class list data structure.
321void LTOModule::addObjCClassRef(const GlobalVariable *clgv) {
322  std::string targetclassName;
323  if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName))
324    return;
325
326  auto IterBool =
327      _undefines.insert(std::make_pair(targetclassName, NameAndAttributes()));
328
329  if (!IterBool.second)
330    return;
331
332  NameAndAttributes &info = IterBool.first->second;
333  info.name = IterBool.first->first();
334  info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
335  info.isFunction = false;
336  info.symbol = clgv;
337}
338
339void LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) {
340  SmallString<64> Buffer;
341  {
342    raw_svector_ostream OS(Buffer);
343    SymTab.printSymbolName(OS, Sym);
344    Buffer.c_str();
345  }
346
347  const GlobalValue *V = Sym.get<GlobalValue *>();
348  addDefinedDataSymbol(Buffer, V);
349}
350
351void LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) {
352  // Add to list of defined symbols.
353  addDefinedSymbol(Name, v, false);
354
355  if (!v->hasSection() /* || !isTargetDarwin */)
356    return;
357
358  // Special case i386/ppc ObjC data structures in magic sections:
359  // The issue is that the old ObjC object format did some strange
360  // contortions to avoid real linker symbols.  For instance, the
361  // ObjC class data structure is allocated statically in the executable
362  // that defines that class.  That data structures contains a pointer to
363  // its superclass.  But instead of just initializing that part of the
364  // struct to the address of its superclass, and letting the static and
365  // dynamic linkers do the rest, the runtime works by having that field
366  // instead point to a C-string that is the name of the superclass.
367  // At runtime the objc initialization updates that pointer and sets
368  // it to point to the actual super class.  As far as the linker
369  // knows it is just a pointer to a string.  But then someone wanted the
370  // linker to issue errors at build time if the superclass was not found.
371  // So they figured out a way in mach-o object format to use an absolute
372  // symbols (.objc_class_name_Foo = 0) and a floating reference
373  // (.reference .objc_class_name_Bar) to cause the linker into erroring when
374  // a class was missing.
375  // The following synthesizes the implicit .objc_* symbols for the linker
376  // from the ObjC data structures generated by the front end.
377
378  // special case if this data blob is an ObjC class definition
379  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(v)) {
380    StringRef Section = GV->getSection();
381    if (Section.startswith("__OBJC,__class,")) {
382      addObjCClass(GV);
383    }
384
385    // special case if this data blob is an ObjC category definition
386    else if (Section.startswith("__OBJC,__category,")) {
387      addObjCCategory(GV);
388    }
389
390    // special case if this data blob is the list of referenced classes
391    else if (Section.startswith("__OBJC,__cls_refs,")) {
392      addObjCClassRef(GV);
393    }
394  }
395}
396
397void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) {
398  SmallString<64> Buffer;
399  {
400    raw_svector_ostream OS(Buffer);
401    SymTab.printSymbolName(OS, Sym);
402    Buffer.c_str();
403  }
404
405  const Function *F = cast<Function>(Sym.get<GlobalValue *>());
406  addDefinedFunctionSymbol(Buffer, F);
407}
408
409void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) {
410  // add to list of defined symbols
411  addDefinedSymbol(Name, F, true);
412}
413
414void LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def,
415                                 bool isFunction) {
416  // set alignment part log2() can have rounding errors
417  uint32_t align = def->getAlignment();
418  uint32_t attr = align ? countTrailingZeros(align) : 0;
419
420  // set permissions part
421  if (isFunction) {
422    attr |= LTO_SYMBOL_PERMISSIONS_CODE;
423  } else {
424    const GlobalVariable *gv = dyn_cast<GlobalVariable>(def);
425    if (gv && gv->isConstant())
426      attr |= LTO_SYMBOL_PERMISSIONS_RODATA;
427    else
428      attr |= LTO_SYMBOL_PERMISSIONS_DATA;
429  }
430
431  // set definition part
432  if (def->hasWeakLinkage() || def->hasLinkOnceLinkage())
433    attr |= LTO_SYMBOL_DEFINITION_WEAK;
434  else if (def->hasCommonLinkage())
435    attr |= LTO_SYMBOL_DEFINITION_TENTATIVE;
436  else
437    attr |= LTO_SYMBOL_DEFINITION_REGULAR;
438
439  // set scope part
440  if (def->hasLocalLinkage())
441    // Ignore visibility if linkage is local.
442    attr |= LTO_SYMBOL_SCOPE_INTERNAL;
443  else if (def->hasHiddenVisibility())
444    attr |= LTO_SYMBOL_SCOPE_HIDDEN;
445  else if (def->hasProtectedVisibility())
446    attr |= LTO_SYMBOL_SCOPE_PROTECTED;
447  else if (def->canBeOmittedFromSymbolTable())
448    attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN;
449  else
450    attr |= LTO_SYMBOL_SCOPE_DEFAULT;
451
452  if (def->hasComdat())
453    attr |= LTO_SYMBOL_COMDAT;
454
455  if (isa<GlobalAlias>(def))
456    attr |= LTO_SYMBOL_ALIAS;
457
458  auto Iter = _defines.insert(Name).first;
459
460  // fill information structure
461  NameAndAttributes info;
462  StringRef NameRef = Iter->first();
463  info.name = NameRef;
464  assert(NameRef.data()[NameRef.size()] == '\0');
465  info.attributes = attr;
466  info.isFunction = isFunction;
467  info.symbol = def;
468
469  // add to table of symbols
470  _symbols.push_back(info);
471}
472
473/// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the
474/// defined list.
475void LTOModule::addAsmGlobalSymbol(StringRef name,
476                                   lto_symbol_attributes scope) {
477  auto IterBool = _defines.insert(name);
478
479  // only add new define if not already defined
480  if (!IterBool.second)
481    return;
482
483  NameAndAttributes &info = _undefines[IterBool.first->first()];
484
485  if (info.symbol == nullptr) {
486    // FIXME: This is trying to take care of module ASM like this:
487    //
488    //   module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0"
489    //
490    // but is gross and its mother dresses it funny. Have the ASM parser give us
491    // more details for this type of situation so that we're not guessing so
492    // much.
493
494    // fill information structure
495    info.name = IterBool.first->first();
496    info.attributes =
497      LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope;
498    info.isFunction = false;
499    info.symbol = nullptr;
500
501    // add to table of symbols
502    _symbols.push_back(info);
503    return;
504  }
505
506  if (info.isFunction)
507    addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol));
508  else
509    addDefinedDataSymbol(info.name, info.symbol);
510
511  _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK;
512  _symbols.back().attributes |= scope;
513}
514
515/// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the
516/// undefined list.
517void LTOModule::addAsmGlobalSymbolUndef(StringRef name) {
518  auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes()));
519
520  _asm_undefines.push_back(IterBool.first->first());
521
522  // we already have the symbol
523  if (!IterBool.second)
524    return;
525
526  uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED;
527  attr |= LTO_SYMBOL_SCOPE_DEFAULT;
528  NameAndAttributes &info = IterBool.first->second;
529  info.name = IterBool.first->first();
530  info.attributes = attr;
531  info.isFunction = false;
532  info.symbol = nullptr;
533}
534
535/// Add a symbol which isn't defined just yet to a list to be resolved later.
536void LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym,
537                                            bool isFunc) {
538  SmallString<64> name;
539  {
540    raw_svector_ostream OS(name);
541    SymTab.printSymbolName(OS, Sym);
542    name.c_str();
543  }
544
545  auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes()));
546
547  // we already have the symbol
548  if (!IterBool.second)
549    return;
550
551  NameAndAttributes &info = IterBool.first->second;
552
553  info.name = IterBool.first->first();
554
555  const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>();
556
557  if (decl->hasExternalWeakLinkage())
558    info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF;
559  else
560    info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
561
562  info.isFunction = isFunc;
563  info.symbol = decl;
564}
565
566void LTOModule::parseSymbols() {
567  for (auto Sym : SymTab.symbols()) {
568    auto *GV = Sym.dyn_cast<GlobalValue *>();
569    uint32_t Flags = SymTab.getSymbolFlags(Sym);
570    if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
571      continue;
572
573    bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined;
574
575    if (!GV) {
576      SmallString<64> Buffer;
577      {
578        raw_svector_ostream OS(Buffer);
579        SymTab.printSymbolName(OS, Sym);
580        Buffer.c_str();
581      }
582      StringRef Name(Buffer);
583
584      if (IsUndefined)
585        addAsmGlobalSymbolUndef(Name);
586      else if (Flags & object::BasicSymbolRef::SF_Global)
587        addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT);
588      else
589        addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL);
590      continue;
591    }
592
593    auto *F = dyn_cast<Function>(GV);
594    if (IsUndefined) {
595      addPotentialUndefinedSymbol(Sym, F != nullptr);
596      continue;
597    }
598
599    if (F) {
600      addDefinedFunctionSymbol(Sym);
601      continue;
602    }
603
604    if (isa<GlobalVariable>(GV)) {
605      addDefinedDataSymbol(Sym);
606      continue;
607    }
608
609    assert(isa<GlobalAlias>(GV));
610    addDefinedDataSymbol(Sym);
611  }
612
613  // make symbols for all undefines
614  for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(),
615         e = _undefines.end(); u != e; ++u) {
616    // If this symbol also has a definition, then don't make an undefine because
617    // it is a tentative definition.
618    if (_defines.count(u->getKey())) continue;
619    NameAndAttributes info = u->getValue();
620    _symbols.push_back(info);
621  }
622}
623
624/// parseMetadata - Parse metadata from the module
625void LTOModule::parseMetadata() {
626  raw_string_ostream OS(LinkerOpts);
627
628  // Linker Options
629  if (NamedMDNode *LinkerOptions =
630          getModule().getNamedMetadata("llvm.linker.options")) {
631    for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
632      MDNode *MDOptions = LinkerOptions->getOperand(i);
633      for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
634        MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
635        OS << " " << MDOption->getString();
636      }
637    }
638  }
639
640  // Globals - we only need to do this for COFF.
641  const Triple TT(_target->getTargetTriple());
642  if (!TT.isOSBinFormatCOFF())
643    return;
644  Mangler M;
645  for (const NameAndAttributes &Sym : _symbols) {
646    if (!Sym.symbol)
647      continue;
648    emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M);
649  }
650}
651
652lto::InputFile *LTOModule::createInputFile(const void *buffer,
653                                           size_t buffer_size, const char *path,
654                                           std::string &outErr) {
655  StringRef Data((const char *)buffer, buffer_size);
656  MemoryBufferRef BufferRef(Data, path);
657
658  Expected<std::unique_ptr<lto::InputFile>> ObjOrErr =
659      lto::InputFile::create(BufferRef);
660
661  if (ObjOrErr)
662    return ObjOrErr->release();
663
664  outErr = std::string(path) +
665           ": Could not read LTO input file: " + toString(ObjOrErr.takeError());
666  return nullptr;
667}
668
669size_t LTOModule::getDependentLibraryCount(lto::InputFile *input) {
670  return input->getDependentLibraries().size();
671}
672
673const char *LTOModule::getDependentLibrary(lto::InputFile *input, size_t index,
674                                           size_t *size) {
675  StringRef S = input->getDependentLibraries()[index];
676  *size = S.size();
677  return S.data();
678}
679