LLVM  13.0.0git
LTOModule.cpp
Go to the documentation of this file.
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 
15 #include "llvm/ADT/Triple.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"
26 #include "llvm/MC/MCSection.h"
28 #include "llvm/MC/MCSymbol.h"
31 #include "llvm/Object/MachO.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  assert(_target && "target machine is null");
50  SymTab.addModule(Mod.get());
51 }
52 
54 
55 /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
56 /// bitcode.
57 bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) {
58  Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
59  MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>"));
60  return !errorToBool(BCData.takeError());
61 }
62 
66  if (!BufferOrErr)
67  return false;
68 
69  Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
70  BufferOrErr.get()->getMemBufferRef());
71  return !errorToBool(BCData.takeError());
72 }
73 
76  if (!Result) {
77  logAllUnhandledErrors(Result.takeError(), errs());
78  return false;
79  }
80  return Result->IsThinLTO;
81 }
82 
84  StringRef TriplePrefix) {
86  IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
87  if (errorToBool(BCOrErr.takeError()))
88  return false;
90  ErrorOr<std::string> TripleOrErr =
92  if (!TripleOrErr)
93  return false;
94  return StringRef(*TripleOrErr).startswith(TriplePrefix);
95 }
96 
99  IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
100  if (errorToBool(BCOrErr.takeError()))
101  return "";
104  Context, getBitcodeProducerString(*BCOrErr));
105  if (!ProducerOrErr)
106  return "";
107  return *ProducerOrErr;
108 }
109 
112  const TargetOptions &options) {
114  MemoryBuffer::getFile(path);
115  if (std::error_code EC = BufferOrErr.getError()) {
116  Context.emitError(EC.message());
117  return EC;
118  }
119  std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
120  return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
121  /* ShouldBeLazy*/ false);
122 }
123 
126  size_t size, const TargetOptions &options) {
127  return createFromOpenFileSlice(Context, fd, path, size, 0, options);
128 }
129 
132  size_t map_size, off_t offset,
133  const TargetOptions &options) {
136  map_size, offset);
137  if (std::error_code EC = BufferOrErr.getError()) {
138  Context.emitError(EC.message());
139  return EC;
140  }
141  std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
142  return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
143  /* ShouldBeLazy */ false);
144 }
145 
148  size_t length, const TargetOptions &options,
149  StringRef path) {
150  StringRef Data((const char *)mem, length);
151  MemoryBufferRef Buffer(Data, path);
152  return makeLTOModule(Buffer, options, Context, /* ShouldBeLazy */ false);
153 }
154 
156 LTOModule::createInLocalContext(std::unique_ptr<LLVMContext> Context,
157  const void *mem, size_t length,
158  const TargetOptions &options, StringRef path) {
159  StringRef Data((const char *)mem, length);
160  MemoryBufferRef Buffer(Data, path);
161  // If we own a context, we know this is being used only for symbol extraction,
162  // not linking. Be lazy in that case.
164  makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true);
165  if (Ret)
166  (*Ret)->OwnedContext = std::move(Context);
167  return Ret;
168 }
169 
172  bool ShouldBeLazy) {
173  // Find the buffer.
174  Expected<MemoryBufferRef> MBOrErr =
175  IRObjectFile::findBitcodeInMemBuffer(Buffer);
176  if (Error E = MBOrErr.takeError()) {
177  std::error_code EC = errorToErrorCode(std::move(E));
178  Context.emitError(EC.message());
179  return EC;
180  }
181 
182  if (!ShouldBeLazy) {
183  // Parse the full file.
185  parseBitcodeFile(*MBOrErr, Context));
186  }
187 
188  // Parse lazily.
190  Context,
191  getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/));
192 }
193 
195 LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
196  LLVMContext &Context, bool ShouldBeLazy) {
198  parseBitcodeFileImpl(Buffer, Context, ShouldBeLazy);
199  if (std::error_code EC = MOrErr.getError())
200  return EC;
201  std::unique_ptr<Module> &M = *MOrErr;
202 
203  std::string TripleStr = M->getTargetTriple();
204  if (TripleStr.empty())
205  TripleStr = sys::getDefaultTargetTriple();
206  llvm::Triple Triple(TripleStr);
207 
208  // find machine architecture for this module
209  std::string errMsg;
210  const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg);
211  if (!march)
213 
214  // construct LTOModule, hand over ownership of module and target
215  SubtargetFeatures Features;
217  std::string FeatureStr = Features.getString();
218  // Set a default CPU for Darwin triples.
219  std::string CPU;
220  if (Triple.isOSDarwin()) {
222  CPU = "core2";
223  else if (Triple.getArch() == llvm::Triple::x86)
224  CPU = "yonah";
225  else if (Triple.isArm64e())
226  CPU = "apple-a12";
227  else if (Triple.getArch() == llvm::Triple::aarch64 ||
229  CPU = "cyclone";
230  }
231 
232  TargetMachine *target =
233  march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None);
234 
235  std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
236  Ret->parseSymbols();
237  Ret->parseMetadata();
238 
239  return std::move(Ret);
240 }
241 
242 /// Create a MemoryBuffer from a memory range with an optional name.
243 std::unique_ptr<MemoryBuffer>
244 LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) {
245  const char *startPtr = (const char*)mem;
246  return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false);
247 }
248 
249 /// objcClassNameFromExpression - Get string that the data pointer points to.
250 bool
251 LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) {
252  if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) {
253  Constant *op = ce->getOperand(0);
254  if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) {
255  Constant *cn = gvn->getInitializer();
256  if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) {
257  if (ca->isCString()) {
258  name = (".objc_class_name_" + ca->getAsCString()).str();
259  return true;
260  }
261  }
262  }
263  }
264  return false;
265 }
266 
267 /// addObjCClass - Parse i386/ppc ObjC class data structure.
268 void LTOModule::addObjCClass(const GlobalVariable *clgv) {
269  const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
270  if (!c) return;
271 
272  // second slot in __OBJC,__class is pointer to superclass name
273  std::string superclassName;
274  if (objcClassNameFromExpression(c->getOperand(1), superclassName)) {
275  auto IterBool =
276  _undefines.insert(std::make_pair(superclassName, NameAndAttributes()));
277  if (IterBool.second) {
278  NameAndAttributes &info = IterBool.first->second;
279  info.name = IterBool.first->first();
281  info.isFunction = false;
282  info.symbol = clgv;
283  }
284  }
285 
286  // third slot in __OBJC,__class is pointer to class name
287  std::string className;
288  if (objcClassNameFromExpression(c->getOperand(2), className)) {
289  auto Iter = _defines.insert(className).first;
290 
291  NameAndAttributes info;
292  info.name = Iter->first();
293  info.attributes = LTO_SYMBOL_PERMISSIONS_DATA |
295  info.isFunction = false;
296  info.symbol = clgv;
297  _symbols.push_back(info);
298  }
299 }
300 
301 /// addObjCCategory - Parse i386/ppc ObjC category data structure.
302 void LTOModule::addObjCCategory(const GlobalVariable *clgv) {
303  const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
304  if (!c) return;
305 
306  // second slot in __OBJC,__category is pointer to target class name
307  std::string targetclassName;
308  if (!objcClassNameFromExpression(c->getOperand(1), targetclassName))
309  return;
310 
311  auto IterBool =
312  _undefines.insert(std::make_pair(targetclassName, NameAndAttributes()));
313 
314  if (!IterBool.second)
315  return;
316 
317  NameAndAttributes &info = IterBool.first->second;
318  info.name = IterBool.first->first();
320  info.isFunction = false;
321  info.symbol = clgv;
322 }
323 
324 /// addObjCClassRef - Parse i386/ppc ObjC class list data structure.
325 void LTOModule::addObjCClassRef(const GlobalVariable *clgv) {
326  std::string targetclassName;
327  if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName))
328  return;
329 
330  auto IterBool =
331  _undefines.insert(std::make_pair(targetclassName, NameAndAttributes()));
332 
333  if (!IterBool.second)
334  return;
335 
336  NameAndAttributes &info = IterBool.first->second;
337  info.name = IterBool.first->first();
339  info.isFunction = false;
340  info.symbol = clgv;
341 }
342 
343 void LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) {
344  SmallString<64> Buffer;
345  {
346  raw_svector_ostream OS(Buffer);
347  SymTab.printSymbolName(OS, Sym);
348  Buffer.c_str();
349  }
350 
351  const GlobalValue *V = Sym.get<GlobalValue *>();
352  addDefinedDataSymbol(Buffer, V);
353 }
354 
355 void LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) {
356  // Add to list of defined symbols.
357  addDefinedSymbol(Name, v, false);
358 
359  if (!v->hasSection() /* || !isTargetDarwin */)
360  return;
361 
362  // Special case i386/ppc ObjC data structures in magic sections:
363  // The issue is that the old ObjC object format did some strange
364  // contortions to avoid real linker symbols. For instance, the
365  // ObjC class data structure is allocated statically in the executable
366  // that defines that class. That data structures contains a pointer to
367  // its superclass. But instead of just initializing that part of the
368  // struct to the address of its superclass, and letting the static and
369  // dynamic linkers do the rest, the runtime works by having that field
370  // instead point to a C-string that is the name of the superclass.
371  // At runtime the objc initialization updates that pointer and sets
372  // it to point to the actual super class. As far as the linker
373  // knows it is just a pointer to a string. But then someone wanted the
374  // linker to issue errors at build time if the superclass was not found.
375  // So they figured out a way in mach-o object format to use an absolute
376  // symbols (.objc_class_name_Foo = 0) and a floating reference
377  // (.reference .objc_class_name_Bar) to cause the linker into erroring when
378  // a class was missing.
379  // The following synthesizes the implicit .objc_* symbols for the linker
380  // from the ObjC data structures generated by the front end.
381 
382  // special case if this data blob is an ObjC class definition
383  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(v)) {
384  StringRef Section = GV->getSection();
385  if (Section.startswith("__OBJC,__class,")) {
386  addObjCClass(GV);
387  }
388 
389  // special case if this data blob is an ObjC category definition
390  else if (Section.startswith("__OBJC,__category,")) {
391  addObjCCategory(GV);
392  }
393 
394  // special case if this data blob is the list of referenced classes
395  else if (Section.startswith("__OBJC,__cls_refs,")) {
396  addObjCClassRef(GV);
397  }
398  }
399 }
400 
401 void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) {
402  SmallString<64> Buffer;
403  {
404  raw_svector_ostream OS(Buffer);
405  SymTab.printSymbolName(OS, Sym);
406  Buffer.c_str();
407  }
408 
409  const Function *F = cast<Function>(Sym.get<GlobalValue *>());
410  addDefinedFunctionSymbol(Buffer, F);
411 }
412 
413 void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) {
414  // add to list of defined symbols
415  addDefinedSymbol(Name, F, true);
416 }
417 
418 void LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def,
419  bool isFunction) {
420  const GlobalObject *go = dyn_cast<GlobalObject>(def);
421  uint32_t attr = go ? Log2(go->getAlign().valueOrOne()) : 0;
422 
423  // set permissions part
424  if (isFunction) {
426  } else {
427  const GlobalVariable *gv = dyn_cast<GlobalVariable>(def);
428  if (gv && gv->isConstant())
430  else
432  }
433 
434  // set definition part
435  if (def->hasWeakLinkage() || def->hasLinkOnceLinkage())
437  else if (def->hasCommonLinkage())
439  else
441 
442  // set scope part
443  if (def->hasLocalLinkage())
444  // Ignore visibility if linkage is local.
446  else if (def->hasHiddenVisibility())
447  attr |= LTO_SYMBOL_SCOPE_HIDDEN;
448  else if (def->hasProtectedVisibility())
450  else if (def->canBeOmittedFromSymbolTable())
452  else
453  attr |= LTO_SYMBOL_SCOPE_DEFAULT;
454 
455  if (def->hasComdat())
456  attr |= LTO_SYMBOL_COMDAT;
457 
458  if (isa<GlobalAlias>(def))
459  attr |= LTO_SYMBOL_ALIAS;
460 
461  auto Iter = _defines.insert(Name).first;
462 
463  // fill information structure
464  NameAndAttributes info;
465  StringRef NameRef = Iter->first();
466  info.name = NameRef;
467  assert(NameRef.data()[NameRef.size()] == '\0');
468  info.attributes = attr;
469  info.isFunction = isFunction;
470  info.symbol = def;
471 
472  // add to table of symbols
473  _symbols.push_back(info);
474 }
475 
476 /// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the
477 /// defined list.
478 void LTOModule::addAsmGlobalSymbol(StringRef name,
479  lto_symbol_attributes scope) {
480  auto IterBool = _defines.insert(name);
481 
482  // only add new define if not already defined
483  if (!IterBool.second)
484  return;
485 
486  NameAndAttributes &info = _undefines[IterBool.first->first()];
487 
488  if (info.symbol == nullptr) {
489  // FIXME: This is trying to take care of module ASM like this:
490  //
491  // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0"
492  //
493  // but is gross and its mother dresses it funny. Have the ASM parser give us
494  // more details for this type of situation so that we're not guessing so
495  // much.
496 
497  // fill information structure
498  info.name = IterBool.first->first();
499  info.attributes =
501  info.isFunction = false;
502  info.symbol = nullptr;
503 
504  // add to table of symbols
505  _symbols.push_back(info);
506  return;
507  }
508 
509  if (info.isFunction)
510  addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol));
511  else
512  addDefinedDataSymbol(info.name, info.symbol);
513 
514  _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK;
515  _symbols.back().attributes |= scope;
516 }
517 
518 /// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the
519 /// undefined list.
520 void LTOModule::addAsmGlobalSymbolUndef(StringRef name) {
521  auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes()));
522 
523  _asm_undefines.push_back(IterBool.first->first());
524 
525  // we already have the symbol
526  if (!IterBool.second)
527  return;
528 
530  attr |= LTO_SYMBOL_SCOPE_DEFAULT;
531  NameAndAttributes &info = IterBool.first->second;
532  info.name = IterBool.first->first();
533  info.attributes = attr;
534  info.isFunction = false;
535  info.symbol = nullptr;
536 }
537 
538 /// Add a symbol which isn't defined just yet to a list to be resolved later.
539 void LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym,
540  bool isFunc) {
542  {
544  SymTab.printSymbolName(OS, Sym);
545  name.c_str();
546  }
547 
548  auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes()));
549 
550  // we already have the symbol
551  if (!IterBool.second)
552  return;
553 
554  NameAndAttributes &info = IterBool.first->second;
555 
556  info.name = IterBool.first->first();
557 
558  const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>();
559 
560  if (decl->hasExternalWeakLinkage())
562  else
564 
565  info.isFunction = isFunc;
566  info.symbol = decl;
567 }
568 
569 void LTOModule::parseSymbols() {
570  for (auto Sym : SymTab.symbols()) {
571  auto *GV = Sym.dyn_cast<GlobalValue *>();
572  uint32_t Flags = SymTab.getSymbolFlags(Sym);
574  continue;
575 
576  bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined;
577 
578  if (!GV) {
579  SmallString<64> Buffer;
580  {
581  raw_svector_ostream OS(Buffer);
582  SymTab.printSymbolName(OS, Sym);
583  Buffer.c_str();
584  }
585  StringRef Name(Buffer);
586 
587  if (IsUndefined)
588  addAsmGlobalSymbolUndef(Name);
589  else if (Flags & object::BasicSymbolRef::SF_Global)
590  addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT);
591  else
592  addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL);
593  continue;
594  }
595 
596  auto *F = dyn_cast<Function>(GV);
597  if (IsUndefined) {
598  addPotentialUndefinedSymbol(Sym, F != nullptr);
599  continue;
600  }
601 
602  if (F) {
603  addDefinedFunctionSymbol(Sym);
604  continue;
605  }
606 
607  if (isa<GlobalVariable>(GV)) {
608  addDefinedDataSymbol(Sym);
609  continue;
610  }
611 
612  assert(isa<GlobalAlias>(GV));
613  addDefinedDataSymbol(Sym);
614  }
615 
616  // make symbols for all undefines
617  for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(),
618  e = _undefines.end(); u != e; ++u) {
619  // If this symbol also has a definition, then don't make an undefine because
620  // it is a tentative definition.
621  if (_defines.count(u->getKey())) continue;
622  NameAndAttributes info = u->getValue();
623  _symbols.push_back(info);
624  }
625 }
626 
627 /// parseMetadata - Parse metadata from the module
628 void LTOModule::parseMetadata() {
629  raw_string_ostream OS(LinkerOpts);
630 
631  // Linker Options
632  if (NamedMDNode *LinkerOptions =
633  getModule().getNamedMetadata("llvm.linker.options")) {
634  for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
635  MDNode *MDOptions = LinkerOptions->getOperand(i);
636  for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
637  MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
638  OS << " " << MDOption->getString();
639  }
640  }
641  }
642 
643  // Globals - we only need to do this for COFF.
644  const Triple TT(_target->getTargetTriple());
645  if (!TT.isOSBinFormatCOFF())
646  return;
647  Mangler M;
648  for (const NameAndAttributes &Sym : _symbols) {
649  if (!Sym.symbol)
650  continue;
651  emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M);
652  }
653 }
654 
656  size_t buffer_size, const char *path,
657  std::string &outErr) {
658  StringRef Data((const char *)buffer, buffer_size);
659  MemoryBufferRef BufferRef(Data, path);
660 
662  lto::InputFile::create(BufferRef);
663 
664  if (ObjOrErr)
665  return ObjOrErr->release();
666 
667  outErr = std::string(path) +
668  ": Could not read LTO input file: " + toString(ObjOrErr.takeError());
669  return nullptr;
670 }
671 
673  return input->getDependentLibraries().size();
674 }
675 
677  size_t *size) {
678  StringRef S = input->getDependentLibraries()[index];
679  *size = S.size();
680  return S.data();
681 }
682 
684  return MachO::getCPUType(Triple(Mod->getTargetTriple()));
685 }
686 
688  return MachO::getCPUSubType(Triple(Mod->getTargetTriple()));
689 }
i
i
Definition: README.txt:29
MemoryBuffer.h
llvm::expectedToErrorOrAndEmitErrors
ErrorOr< T > expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected< T > Val)
Definition: BitcodeReader.h:44
LTO_SYMBOL_SCOPE_DEFAULT
@ LTO_SYMBOL_SCOPE_DEFAULT
Definition: lto.h:70
llvm::StringRef::startswith
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:286
LTO_SYMBOL_SCOPE_PROTECTED
@ LTO_SYMBOL_SCOPE_PROTECTED
Definition: lto.h:69
llvm::LTOModule::createInLocalContext
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:156
llvm
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1386
llvm::ARM::PredBlockMask::TT
@ TT
llvm::GlobalValue::hasCommonLinkage
bool hasCommonLinkage() const
Definition: GlobalValue.h:449
LTO_SYMBOL_DEFINITION_TENTATIVE
@ LTO_SYMBOL_DEFINITION_TENTATIVE
Definition: lto.h:62
FileSystem.h
Metadata.h
llvm::TargetOptions
Definition: TargetOptions.h:113
llvm::GlobalValue::hasProtectedVisibility
bool hasProtectedVisibility() const
Definition: GlobalValue.h:232
llvm::Function
Definition: Function.h:61
llvm::Triple::x86
@ x86
Definition: Triple.h:83
llvm::getBitcodeProducerString
Expected< std::string > getBitcodeProducerString(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the producer string information.
Definition: BitcodeReader.cpp:7085
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:614
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:125
llvm::MemoryBuffer::getOpenFileSlice
static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFileSlice(sys::fs::file_t 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.
Definition: MemoryBuffer.cpp:510
llvm::GlobalValue::hasWeakLinkage
bool hasWeakLinkage() const
Definition: GlobalValue.h:439
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:991
op
#define op(i)
Host.h
llvm::GlobalObject::getAlign
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:80
Path.h
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::LTOModule::createFromFile
static ErrorOr< std::unique_ptr< LTOModule > > createFromFile(LLVMContext &Context, StringRef path, const TargetOptions &options)
Create an LTOModule.
Definition: LTOModule.cpp:111
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
llvm::StringMap::end
iterator end()
Definition: StringMap.h:205
llvm::GlobalValue::hasHiddenVisibility
bool hasHiddenVisibility() const
Definition: GlobalValue.h:231
Module.h
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:84
llvm::MaybeAlign::valueOrOne
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
Definition: Alignment.h:134
llvm::GlobalValue::hasSection
bool hasSection() const
Definition: GlobalValue.h:267
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::LTOModule::createFromOpenFileSlice
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:131
llvm::StringSet::insert
std::pair< typename Base::iterator, bool > insert(StringRef key)
Definition: StringSet.h:33
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::Mangler
Definition: Mangler.h:27
llvm::Triple::aarch64_32
@ aarch64_32
Definition: Triple.h:54
llvm::TargetRegistry::lookupTarget
static const Target * lookupTarget(const std::string &Triple, std::string &Error)
lookupTarget - Lookup a target based on a target triple.
Definition: TargetRegistry.cpp:62
MCAsmParser.h
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
llvm::PointerUnion::get
T get() const
Returns the value of the specified pointer type.
Definition: PointerUnion.h:187
llvm::LTOModule::isThinLTO
bool isThinLTO()
Returns 'true' if the Module is produced for ThinLTO.
Definition: LTOModule.cpp:74
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::GlobalValue::hasExternalWeakLinkage
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:446
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:50
llvm::MachO::getCPUType
Expected< uint32_t > getCPUType(const Triple &T)
Definition: MachO.cpp:77
F
#define F(x, y, z)
Definition: MD5.cpp:56
LTO_SYMBOL_ALIAS
@ LTO_SYMBOL_ALIAS
Definition: lto.h:73
MachO.h
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1108
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:78
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:246
llvm::object
Definition: ObjectFileTransformer.h:18
llvm::MemoryBuffer::getMemBuffer
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
Definition: MemoryBuffer.cpp:113
SubtargetFeature.h
LTO_SYMBOL_DEFINITION_WEAKUNDEF
@ LTO_SYMBOL_DEFINITION_WEAKUNDEF
Definition: lto.h:65
llvm::LTOModule::getDependentLibraryCount
static size_t getDependentLibraryCount(lto::InputFile *input)
Definition: LTOModule.cpp:672
Constants.h
LTO_SYMBOL_PERMISSIONS_RODATA
@ LTO_SYMBOL_PERMISSIONS_RODATA
Definition: lto.h:59
llvm::LTOModule::isBitcodeFile
static bool isBitcodeFile(const void *mem, size_t length)
Returns 'true' if the file or memory contents is LLVM bitcode.
Definition: LTOModule.cpp:57
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::Triple::isOSDarwin
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (macOS, iOS, tvOS or watchOS).
Definition: Triple.h:484
llvm::Log2
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition: Alignment.h:207
llvm::StringMap::insert
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:276
llvm::GlobalObject
Definition: GlobalObject.h:28
llvm::LTOModule::makeBuffer
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:244
MCSymbol.h
llvm::SubtargetFeatures
Manages the enabling and disabling of subtarget specific features.
Definition: SubtargetFeature.h:183
MCInst.h
llvm::ErrorOr::getError
std::error_code getError() const
Definition: ErrorOr.h:153
MCSubtargetInfo.h
LTOModule.h
llvm::lto::InputFile::create
static Expected< std::unique_ptr< InputFile > > create(MemoryBufferRef Object)
Create an InputFile.
Definition: LTO.cpp:471
llvm::LTOModule::createInputFile
static lto::InputFile * createInputFile(const void *buffer, size_t buffer_size, const char *path, std::string &out_error)
Definition: LTOModule.cpp:655
llvm::ModuleSymbolTable::printSymbolName
void printSymbolName(raw_ostream &OS, Symbol S) const
Definition: ModuleSymbolTable.cpp:178
LTO_SYMBOL_DEFINITION_UNDEFINED
@ LTO_SYMBOL_DEFINITION_UNDEFINED
Definition: lto.h:64
llvm::MachO::getCPUSubType
Expected< uint32_t > getCPUSubType(const Triple &T)
Definition: MachO.cpp:95
input
The initial backend is deliberately restricted to z10 We should add support for later architectures at some point If an asm ties an i32 r result to an i64 input
Definition: README.txt:10
llvm::ModuleSymbolTable::symbols
ArrayRef< Symbol > symbols() const
Definition: ModuleSymbolTable.h:46
llvm::Triple::getArch
ArchType getArch() const
getArch - Get the parsed architecture type of this triple.
Definition: Triple.h:307
llvm::SubtargetFeatures::getDefaultSubtargetFeatures
void getDefaultSubtargetFeatures(const Triple &Triple)
Adds the default features for the specified target triple.
Definition: SubtargetFeature.cpp:70
c
the resulting code requires compare and branches when and if the revised code is with conditional branches instead of More there is a byte word extend before each where there should be only and the condition codes are not remembered when the same two values are compared twice More LSR enhancements i8 and i32 load store addressing modes are identical int int c
Definition: README.txt:418
llvm::None
const NoneType None
Definition: None.h:23
LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN
@ LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN
Definition: lto.h:71
SourceMgr.h
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::SmallString< 64 >
LTO_SYMBOL_COMDAT
@ LTO_SYMBOL_COMDAT
Definition: lto.h:72
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1102
llvm::SubtargetFeatures::getString
std::string getString() const
Returns features as a string.
Definition: SubtargetFeature.cpp:54
llvm::LLVMContext::emitError
void emitError(unsigned LocCookie, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
Definition: LLVMContext.cpp:251
llvm::SmallString::c_str
const char * c_str()
Definition: SmallString.h:262
IRObjectFile.h
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalVariable::getInitializer
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Definition: GlobalVariable.h:136
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::object::BasicSymbolRef::SF_FormatSpecific
@ SF_FormatSpecific
Definition: SymbolicFile.h:115
parseBitcodeFileImpl
static ErrorOr< std::unique_ptr< Module > > parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context, bool ShouldBeLazy)
Definition: LTOModule.cpp:171
llvm::LTOModule::isBitcodeForTarget
static bool isBitcodeForTarget(MemoryBuffer *memBuffer, StringRef triplePrefix)
Returns 'true' if the memory buffer is LLVM bitcode for the specified triple.
Definition: LTOModule.cpp:83
index
splat index
Definition: README_ALTIVEC.txt:181
LTO_SYMBOL_SCOPE_MASK
@ LTO_SYMBOL_SCOPE_MASK
Definition: lto.h:66
llvm::parseBitcodeFile
Expected< std::unique_ptr< Module > > parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context, DataLayoutCallbackTy DataLayoutCallback=[](StringRef) { return None;})
Read the specified bitcode file, returning the module.
Definition: BitcodeReader.cpp:7060
llvm::ConstantDataArray
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition: Constants.h:677
GlobalStatus.h
llvm::PointerUnion::dyn_cast
T dyn_cast() const
Returns the current pointer if it is of the specified pointer type, otherwise returns null.
Definition: PointerUnion.h:194
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::MemoryBuffer::getMemBufferRef
MemoryBufferRef getMemBufferRef() const
Definition: MemoryBuffer.cpp:540
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::GlobalValue::hasComdat
bool hasComdat() const
Definition: GlobalValue.h:222
llvm::LTOModule::getDependentLibrary
static const char * getDependentLibrary(lto::InputFile *input, size_t index, size_t *size)
Definition: LTOModule.cpp:676
llvm::object::BasicSymbolRef::SF_Undefined
@ SF_Undefined
Definition: SymbolicFile.h:108
llvm::LTOModule::getMachOCPUSubType
Expected< uint32_t > getMachOCPUSubType() const
Definition: LTOModule.cpp:687
llvm::StringMap::begin
iterator begin()
Definition: StringMap.h:204
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1540
LTO_SYMBOL_DEFINITION_WEAK
@ LTO_SYMBOL_DEFINITION_WEAK
Definition: lto.h:63
ObjectFile.h
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:445
llvm::codeview::CompileSym2Flags::EC
@ EC
LTO_SYMBOL_DEFINITION_REGULAR
@ LTO_SYMBOL_DEFINITION_REGULAR
Definition: lto.h:61
llvm::errorToBool
bool errorToBool(Error Err)
Helper for converting an Error to a bool.
Definition: Error.h:1029
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::ConstantStruct
Definition: Constants.h:439
info
lazy value info
Definition: LazyValueInfo.cpp:59
llvm::LTOModule::getProducerString
static std::string getProducerString(MemoryBuffer *Buffer)
Returns a string representing the producer identification stored in the bitcode, or "" if the bitcode...
Definition: LTOModule.cpp:97
MCSection.h
Mangler.h
Triple.h
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1463
llvm::GlobalValue::canBeOmittedFromSymbolTable
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:311
llvm::sys::getDefaultTargetTriple
std::string getDefaultTargetTriple()
getDefaultTargetTriple() - Return the default target triple the compiler has been configured to produ...
llvm::LTOModule::getModule
const Module & getModule() const
Definition: LTOModule.h:115
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
TargetLoweringObjectFile.h
llvm::getBitcodeTargetTriple
Expected< std::string > getBitcodeTargetTriple(MemoryBufferRef Buffer)
Read the header of the specified bitcode buffer and extract just the triple information.
Definition: BitcodeReader.cpp:7069
uint32_t
TargetSubtargetInfo.h
llvm::LTOModule::createFromBuffer
static ErrorOr< std::unique_ptr< LTOModule > > createFromBuffer(LLVMContext &Context, const void *mem, size_t length, const TargetOptions &options, StringRef path="")
Definition: LTOModule.cpp:147
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
LTO_SYMBOL_SCOPE_INTERNAL
@ LTO_SYMBOL_SCOPE_INTERNAL
Definition: lto.h:67
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:149
llvm::ModuleSymbolTable::getSymbolFlags
uint32_t getSymbolFlags(Symbol S) const
Definition: ModuleSymbolTable.cpp:191
llvm::make_error_code
std::error_code make_error_code(BitcodeError E)
Definition: BitcodeReader.h:270
llvm::logAllUnhandledErrors
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition: Error.cpp:61
llvm::sys::fs::convertFDToNativeFile
file_t convertFDToNativeFile(int FD)
Converts from a Posix file descriptor number to a native file handle.
Definition: FileSystem.h:989
name
static const char * name
Definition: SVEIntrinsicOpts.cpp:84
llvm::ConstantExpr
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:931
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
LTO_SYMBOL_SCOPE_HIDDEN
@ LTO_SYMBOL_SCOPE_HIDDEN
Definition: lto.h:68
llvm::LTOModule::~LTOModule
~LTOModule()
Definition: LTOModule.cpp:53
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
options
The object format emitted by the WebAssembly backed is documented see the home and packaging for producing WebAssembly applications that can run in browsers and other environments wasi sdk provides a more minimal C C SDK based on llvm and a libc based on for producing WebAssemmbly applictions that use the WASI ABI Rust provides WebAssembly support integrated into Cargo There are two main options
Definition: README.txt:24
llvm::Triple::isArm64e
bool isArm64e() const
Tests whether the target is the Apple "arm64e" AArch64 subarch.
Definition: Triple.h:803
llvm::LTOModule::createFromOpenFile
static ErrorOr< std::unique_ptr< LTOModule > > createFromOpenFile(LLVMContext &Context, int fd, StringRef path, size_t size, const TargetOptions &options)
Definition: LTOModule.cpp:125
llvm::StringMap::count
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:246
lto_symbol_attributes
lto_symbol_attributes
Definition: lto.h:54
LTO_SYMBOL_PERMISSIONS_DATA
@ LTO_SYMBOL_PERMISSIONS_DATA
Definition: lto.h:58
llvm::errorToErrorCode
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition: Error.cpp:93
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
llvm::emitLinkerFlagsForGlobalCOFF
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:206
llvm::ErrorOr::get
reference get()
Definition: ErrorOr.h:150
llvm::GlobalVariable::isConstant
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
Definition: GlobalVariable.h:153
llvm::object::object_error::arch_not_found
@ arch_not_found
llvm::object::BasicSymbolRef::SF_Global
@ SF_Global
Definition: SymbolicFile.h:109
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:647
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
llvm::GlobalValue::hasLinkOnceLinkage
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:435
LTO_SYMBOL_PERMISSIONS_CODE
@ LTO_SYMBOL_PERMISSIONS_CODE
Definition: lto.h:57
TargetSelect.h
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::LTOModule::getMachOCPUType
Expected< uint32_t > getMachOCPUType() const
Definition: LTOModule.cpp:683
llvm::getBitcodeLTOInfo
Expected< BitcodeLTOInfo > getBitcodeLTOInfo(MemoryBufferRef Buffer)
Returns LTO information for the specified bitcode file.
Definition: BitcodeReader.cpp:7112
LLVMContext.h
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
BitcodeReader.h
llvm::MDString::getString
StringRef getString() const
Definition: Metadata.cpp:477
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::getLazyBitcodeModule
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...
Definition: BitcodeReader.cpp:7032
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
TargetRegistry.h
MCExpr.h
llvm::LTOModule
C++ class which implements the opaque lto_module_t type.
Definition: LTOModule.h:38
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:52
llvm::lto::InputFile
An input file.
Definition: LTO.h:104
llvm::Target::createTargetMachine
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.
Definition: TargetRegistry.h:420