LLVM  8.0.0svn
LTOModule.cpp
Go to the documentation of this file.
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 
16 #include "llvm/ADT/Triple.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"
27 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCSymbol.h"
32 #include "llvm/Object/ObjectFile.h"
34 #include "llvm/Support/Host.h"
36 #include "llvm/Support/Path.h"
37 #include "llvm/Support/SourceMgr.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,
48  : Mod(std::move(M)), MBRef(MBRef), _target(TM) {
49  SymTab.addModule(Mod.get());
50 }
51 
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 
65  if (!BufferOrErr)
66  return false;
67 
68  Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
69  BufferOrErr.get()->getMemBufferRef());
70  return !errorToBool(BCData.takeError());
71 }
72 
75  if (!Result) {
77  return false;
78  }
79  return Result->IsThinLTO;
80 }
81 
83  StringRef TriplePrefix) {
85  IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
86  if (errorToBool(BCOrErr.takeError()))
87  return false;
88  LLVMContext Context;
89  ErrorOr<std::string> TripleOrErr =
91  if (!TripleOrErr)
92  return false;
93  return StringRef(*TripleOrErr).startswith(TriplePrefix);
94 }
95 
98  IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
99  if (errorToBool(BCOrErr.takeError()))
100  return "";
101  LLVMContext Context;
103  Context, getBitcodeProducerString(*BCOrErr));
104  if (!ProducerOrErr)
105  return "";
106  return *ProducerOrErr;
107 }
108 
111  const TargetOptions &options) {
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 
125  size_t size, const TargetOptions &options) {
126  return createFromOpenFileSlice(Context, fd, path, size, 0, options);
127 }
128 
131  size_t map_size, off_t offset,
132  const TargetOptions &options) {
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 
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 
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.
162  makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true);
163  if (Ret)
164  (*Ret)->OwnedContext = std::move(Context);
165  return Ret;
166 }
167 
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.
188  Context,
189  getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/));
190 }
191 
193 LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
194  LLVMContext &Context, bool ShouldBeLazy) {
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)
211 
212  // construct LTOModule, hand over ownership of module and target
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) {
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 |
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) {
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) {
422  } else {
423  const GlobalVariable *gv = dyn_cast<GlobalVariable>(def);
424  if (gv && gv->isConstant())
426  else
428  }
429 
430  // set definition part
431  if (def->hasWeakLinkage() || def->hasLinkOnceLinkage())
433  else if (def->hasCommonLinkage())
435  else
437 
438  // set scope part
439  if (def->hasLocalLinkage())
440  // Ignore visibility if linkage is local.
442  else if (def->hasHiddenVisibility())
443  attr |= LTO_SYMBOL_SCOPE_HIDDEN;
444  else if (def->hasProtectedVisibility())
446  else if (def->canBeOmittedFromSymbolTable())
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 =
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 
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) {
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);
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 }
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X, iOS, or watchOS).
Definition: Triple.h:475
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFileSlice(int FD, const Twine &Filename, uint64_t MapSize, int64_t Offset, bool IsVolatile=false)
Given an already-open file descriptor, map some slice of it into a MemoryBuffer.
Represents either an error or a value T.
Definition: ErrorOr.h:57
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool hasLocalLinkage() const
Definition: GlobalValue.h:436
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
This class represents lattice values for constants.
Definition: AllocatorList.h:24
void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
Expected< std::unique_ptr< Module > > getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldLazyLoadMetadata=false, bool IsImporting=false)
Read the header of the specified bitcode buffer and prepare for lazy deserialization of function bodi...
TargetMachine * createTargetMachine(StringRef TT, StringRef CPU, StringRef Features, const TargetOptions &Options, Optional< Reloc::Model > RM, Optional< CodeModel::Model > CM=None, CodeGenOpt::Level OL=CodeGenOpt::Default, bool JIT=false) const
createTargetMachine - Create a target specific machine implementation for the specified Triple...
static ErrorOr< std::unique_ptr< LTOModule > > createFromFile(LLVMContext &Context, StringRef path, const TargetOptions &options)
Create an LTOModule.
Definition: LTOModule.cpp:110
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
std::string getDefaultTargetTriple()
getDefaultTargetTriple() - Return the default target triple the compiler has been configured to produ...
This file contains the declarations for metadata subclasses.
std::string getString() const
Returns features as a string.
const FeatureBitset Features
bool isThinLTO()
Returns &#39;true&#39; if the Module is produced for ThinLTO.
Definition: LTOModule.cpp:73
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:510
static ErrorOr< std::unique_ptr< LTOModule > > createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path, size_t map_size, off_t offset, const TargetOptions &options)
Definition: LTOModule.cpp:130
Metadata node.
Definition: Metadata.h:864
F(f)
static std::string getProducerString(MemoryBuffer *Buffer)
Returns a string representing the producer identification stored in the bitcode, or "" if the bitcode...
Definition: LTOModule.cpp:96
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1069
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:437
Error takeError()
Take ownership of the stored error.
Definition: Error.h:553
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
#define op(i)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:289
bool hasSection() const
Definition: GlobalValue.h:270
A tuple of MDNodes.
Definition: Metadata.h:1326
amdgpu Simplify well known AMD library false Value Value const Twine & Name
Definition: BitVector.h:938
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
std::error_code make_error_code(BitcodeError E)
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
bool hasCommonLinkage() const
Definition: GlobalValue.h:440
void emitError(unsigned LocCookie, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
static ErrorOr< std::unique_ptr< LTOModule > > createFromOpenFile(LLVMContext &Context, int fd, StringRef path, size_t size, const TargetOptions &options)
Definition: LTOModule.cpp:124
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:889
static ErrorOr< std::unique_ptr< Module > > parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldBeLazy)
Definition: LTOModule.cpp:169
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:290
unsigned getAlignment() const
Definition: Globals.cpp:97
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:426
static bool isBitcodeForTarget(MemoryBuffer *memBuffer, StringRef triplePrefix)
Returns &#39;true&#39; if the memory buffer is LLVM bitcode for the specified triple.
Definition: LTOModule.cpp:82
Value * getOperand(unsigned i) const
Definition: User.h:170
StringRef getString() const
Definition: Metadata.cpp:464
Expected< std::string > getBitcodeProducerString(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the producer string information...
bool hasProtectedVisibility() const
Definition: GlobalValue.h:236
std::size_t countTrailingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0&#39;s from the least significant bit to the most stopping at the first 1...
Definition: MathExtras.h:120
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
Definition: Constants.h:690
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:991
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::error_code getError() const
Definition: ErrorOr.h:160
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:185
Expected< std::string > getBitcodeTargetTriple(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the triple information.
lazy value info
C++ class which implements the opaque lto_module_t type.
Definition: LTOModule.h:38
T dyn_cast() const
Returns the current pointer if it is of the specified pointer type, otherwises returns null...
Definition: PointerUnion.h:142
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition: Error.cpp:61
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool hasWeakLinkage() const
Definition: GlobalValue.h:430
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1161
bool hasComdat() const
Definition: GlobalValue.h:226
Module.h This file contains the declarations for the Module class.
MemoryBufferRef getMemBufferRef() const
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:42
The access may modify the value stored in memory.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:220
Target - Wrapper for Target specific information.
Manages the enabling and disabling of subtarget specific features.
bool hasHiddenVisibility() const
Definition: GlobalValue.h:235
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context)
Read the specified bitcode file, returning the module.
Expected< BitcodeLTOInfo > getBitcodeLTOInfo(MemoryBufferRef Buffer)
Returns LTO information for the specified bitcode file.
ErrorOr< T > expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected< T > Val)
Definition: BitcodeReader.h:42
iterator begin()
Definition: StringMap.h:315
lto_symbol_attributes
Definition: lto.h:52
const char * c_str()
Definition: SmallString.h:270
static std::unique_ptr< MemoryBuffer > makeBuffer(const void *mem, size_t length, StringRef name="")
Create a MemoryBuffer from a memory range with an optional name.
Definition: LTOModule.cpp:239
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
static bool isBitcodeFile(const void *mem, size_t length)
Returns &#39;true&#39; if the file or memory contents is LLVM bitcode.
Definition: LTOModule.cpp:56
T get() const
Returns the value of the specified pointer type.
Definition: PointerUnion.h:135
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:483
static const char * name
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:59
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:604
static ErrorOr< std::unique_ptr< LTOModule > > createInLocalContext(std::unique_ptr< LLVMContext > Context, const void *mem, size_t length, const TargetOptions &options, StringRef path)
Definition: LTOModule.cpp:154
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1075
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition: Error.cpp:93
reference get()
Definition: ErrorOr.h:157
A discriminated union of two pointer types, with the discriminator in the low bit of the pointer...
Definition: PointerUnion.h:87
static ErrorOr< std::unique_ptr< LTOModule > > createFromBuffer(LLVMContext &Context, const void *mem, size_t length, const TargetOptions &options, StringRef path="")
Definition: LTOModule.cpp:145