LLVM  16.0.0git
IRSymtab.cpp
Go to the documentation of this file.
1 //===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//
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 #include "llvm/Object/IRSymtab.h"
10 #include "llvm/ADT/ArrayRef.h"
11 #include "llvm/ADT/DenseMap.h"
12 #include "llvm/ADT/SmallPtrSet.h"
13 #include "llvm/ADT/SmallString.h"
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/ADT/Triple.h"
18 #include "llvm/Config/llvm-config.h"
19 #include "llvm/IR/Comdat.h"
20 #include "llvm/IR/DataLayout.h"
21 #include "llvm/IR/GlobalAlias.h"
22 #include "llvm/IR/GlobalObject.h"
23 #include "llvm/IR/Mangler.h"
24 #include "llvm/IR/Metadata.h"
25 #include "llvm/IR/Module.h"
29 #include "llvm/Support/Allocator.h"
30 #include "llvm/Support/Casting.h"
32 #include "llvm/Support/Error.h"
34 #include "llvm/Support/VCSRevision.h"
36 #include <cassert>
37 #include <string>
38 #include <utility>
39 #include <vector>
40 
41 using namespace llvm;
42 using namespace irsymtab;
43 
45  "disable-bitcode-version-upgrade", cl::init(false), cl::Hidden,
46  cl::desc("Disable automatic bitcode upgrade for version mismatch"));
47 
48 static const char *PreservedSymbols[] = {
49 #define HANDLE_LIBCALL(code, name) name,
50 #include "llvm/IR/RuntimeLibcalls.def"
51 #undef HANDLE_LIBCALL
52  // There are global variables, so put it here instead of in
53  // RuntimeLibcalls.def.
54  // TODO: Are there similar such variables?
55  "__ssp_canary_word",
56  "__stack_chk_guard",
57 };
58 
59 namespace {
60 
61 const char *getExpectedProducerName() {
62  static char DefaultName[] = LLVM_VERSION_STRING
63 #ifdef LLVM_REVISION
64  " " LLVM_REVISION
65 #endif
66  ;
67  // Allows for testing of the irsymtab writer and upgrade mechanism. This
68  // environment variable should not be set by users.
69  if (char *OverrideName = getenv("LLVM_OVERRIDE_PRODUCER"))
70  return OverrideName;
71  return DefaultName;
72 }
73 
74 const char *kExpectedProducerName = getExpectedProducerName();
75 
76 /// Stores the temporary state that is required to build an IR symbol table.
77 struct Builder {
78  SmallVector<char, 0> &Symtab;
79  StringTableBuilder &StrtabBuilder;
80  StringSaver Saver;
81 
82  // This ctor initializes a StringSaver using the passed in BumpPtrAllocator.
83  // The StringTableBuilder does not create a copy of any strings added to it,
84  // so this provides somewhere to store any strings that we create.
85  Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,
86  BumpPtrAllocator &Alloc)
87  : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc) {}
88 
90  Mangler Mang;
91  Triple TT;
92 
93  std::vector<storage::Comdat> Comdats;
94  std::vector<storage::Module> Mods;
95  std::vector<storage::Symbol> Syms;
96  std::vector<storage::Uncommon> Uncommons;
97 
98  std::string COFFLinkerOpts;
99  raw_string_ostream COFFLinkerOptsOS{COFFLinkerOpts};
100 
101  std::vector<storage::Str> DependentLibraries;
102 
103  void setStr(storage::Str &S, StringRef Value) {
104  S.Offset = StrtabBuilder.add(Value);
105  S.Size = Value.size();
106  }
107 
108  template <typename T>
109  void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
110  R.Offset = Symtab.size();
111  R.Size = Objs.size();
112  Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
113  reinterpret_cast<const char *>(Objs.data() + Objs.size()));
114  }
115 
116  Expected<int> getComdatIndex(const Comdat *C, const Module *M);
117 
118  Error addModule(Module *M);
119  Error addSymbol(const ModuleSymbolTable &Msymtab,
120  const SmallPtrSet<GlobalValue *, 4> &Used,
122 
124 };
125 
126 Error Builder::addModule(Module *M) {
127  if (M->getDataLayoutStr().empty())
128  return make_error<StringError>("input module has no datalayout",
130 
131  // Symbols in the llvm.used list will get the FB_Used bit and will not be
132  // internalized. We do this for llvm.compiler.used as well:
133  //
134  // IR symbol table tracks module-level asm symbol references but not inline
135  // asm. A symbol only referenced by inline asm is not in the IR symbol table,
136  // so we may not know that the definition (in another translation unit) is
137  // referenced. That definition may have __attribute__((used)) (which lowers to
138  // llvm.compiler.used on ELF targets) to communicate to the compiler that it
139  // may be used by inline asm. The usage is perfectly fine, so we treat
140  // llvm.compiler.used conservatively as llvm.used to work around our own
141  // limitation.
143  collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/false);
144  collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/true);
145  SmallPtrSet<GlobalValue *, 4> Used(UsedV.begin(), UsedV.end());
146 
147  ModuleSymbolTable Msymtab;
148  Msymtab.addModule(M);
149 
151  Mod.Begin = Syms.size();
152  Mod.End = Syms.size() + Msymtab.symbols().size();
153  Mod.UncBegin = Uncommons.size();
154  Mods.push_back(Mod);
155 
156  if (TT.isOSBinFormatCOFF()) {
157  if (auto E = M->materializeMetadata())
158  return E;
159  if (NamedMDNode *LinkerOptions =
160  M->getNamedMetadata("llvm.linker.options")) {
161  for (MDNode *MDOptions : LinkerOptions->operands())
162  for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())
163  COFFLinkerOptsOS << " " << cast<MDString>(MDOption)->getString();
164  }
165  }
166 
167  if (TT.isOSBinFormatELF()) {
168  if (auto E = M->materializeMetadata())
169  return E;
170  if (NamedMDNode *N = M->getNamedMetadata("llvm.dependent-libraries")) {
171  for (MDNode *MDOptions : N->operands()) {
172  const auto OperandStr =
173  cast<MDString>(cast<MDNode>(MDOptions)->getOperand(0))->getString();
174  storage::Str Specifier;
175  setStr(Specifier, OperandStr);
176  DependentLibraries.emplace_back(Specifier);
177  }
178  }
179  }
180 
181  for (ModuleSymbolTable::Symbol Msym : Msymtab.symbols())
182  if (Error Err = addSymbol(Msymtab, Used, Msym))
183  return Err;
184 
185  return Error::success();
186 }
187 
188 Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
189  auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));
190  if (P.second) {
191  std::string Name;
192  if (TT.isOSBinFormatCOFF()) {
193  const GlobalValue *GV = M->getNamedValue(C->getName());
194  if (!GV)
195  return make_error<StringError>("Could not find leader",
197  // Internal leaders do not affect symbol resolution, therefore they do not
198  // appear in the symbol table.
199  if (GV->hasLocalLinkage()) {
200  P.first->second = -1;
201  return -1;
202  }
203  llvm::raw_string_ostream OS(Name);
204  Mang.getNameWithPrefix(OS, GV, false);
205  } else {
206  Name = std::string(C->getName());
207  }
208 
210  setStr(Comdat.Name, Saver.save(Name));
211  Comdat.SelectionKind = C->getSelectionKind();
212  Comdats.push_back(Comdat);
213  }
214 
215  return P.first->second;
216 }
217 
219  const SmallPtrSet<GlobalValue *, 4> &Used,
221  Syms.emplace_back();
222  storage::Symbol &Sym = Syms.back();
223  Sym = {};
224 
225  storage::Uncommon *Unc = nullptr;
226  auto Uncommon = [&]() -> storage::Uncommon & {
227  if (Unc)
228  return *Unc;
230  Uncommons.emplace_back();
231  Unc = &Uncommons.back();
232  *Unc = {};
233  setStr(Unc->COFFWeakExternFallbackName, "");
234  setStr(Unc->SectionName, "");
235  return *Unc;
236  };
237 
239  {
240  raw_svector_ostream OS(Name);
241  Msymtab.printSymbolName(OS, Msym);
242  }
243  setStr(Sym.Name, Saver.save(Name.str()));
244 
245  auto Flags = Msymtab.getSymbolFlags(Msym);
249  Sym.Flags |= 1 << storage::Symbol::FB_weak;
251  Sym.Flags |= 1 << storage::Symbol::FB_common;
255  Sym.Flags |= 1 << storage::Symbol::FB_global;
260 
261  Sym.ComdatIndex = -1;
262  auto *GV = Msym.dyn_cast<GlobalValue *>();
263  if (!GV) {
264  // Undefined module asm symbols act as GC roots and are implicitly used.
266  Sym.Flags |= 1 << storage::Symbol::FB_used;
267  setStr(Sym.IRName, "");
268  return Error::success();
269  }
270 
271  setStr(Sym.IRName, GV->getName());
272 
273  bool IsPreservedSymbol = llvm::is_contained(PreservedSymbols, GV->getName());
274 
275  if (Used.count(GV) || IsPreservedSymbol)
276  Sym.Flags |= 1 << storage::Symbol::FB_used;
277  if (GV->isThreadLocal())
278  Sym.Flags |= 1 << storage::Symbol::FB_tls;
279  if (GV->hasGlobalUnnamedAddr())
281  if (GV->canBeOmittedFromSymbolTable())
283  Sym.Flags |= unsigned(GV->getVisibility()) << storage::Symbol::FB_visibility;
284 
285  if (Flags & object::BasicSymbolRef::SF_Common) {
286  auto *GVar = dyn_cast<GlobalVariable>(GV);
287  if (!GVar)
288  return make_error<StringError>("Only variables can have common linkage!",
290  Uncommon().CommonSize =
292  Uncommon().CommonAlign = GVar->getAlignment();
293  }
294 
295  const GlobalObject *GO = GV->getAliaseeObject();
296  if (!GO) {
297  if (isa<GlobalIFunc>(GV))
298  GO = cast<GlobalIFunc>(GV)->getResolverFunction();
299  if (!GO)
300  return make_error<StringError>("Unable to determine comdat of alias!",
302  }
303  if (const Comdat *C = GO->getComdat()) {
304  Expected<int> ComdatIndexOrErr = getComdatIndex(C, GV->getParent());
305  if (!ComdatIndexOrErr)
306  return ComdatIndexOrErr.takeError();
307  Sym.ComdatIndex = *ComdatIndexOrErr;
308  }
309 
310  if (TT.isOSBinFormatCOFF()) {
311  emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);
312 
313  if ((Flags & object::BasicSymbolRef::SF_Weak) &&
315  auto *Fallback = dyn_cast<GlobalValue>(
316  cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts());
317  if (!Fallback)
318  return make_error<StringError>("Invalid weak external",
320  std::string FallbackName;
321  raw_string_ostream OS(FallbackName);
322  Msymtab.printSymbolName(OS, Fallback);
323  OS.flush();
324  setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
325  }
326  }
327 
328  if (!GO->getSection().empty())
329  setStr(Uncommon().SectionName, Saver.save(GO->getSection()));
330 
331  return Error::success();
332 }
333 
335  storage::Header Hdr;
336 
337  assert(!IRMods.empty());
339  setStr(Hdr.Producer, kExpectedProducerName);
340  setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
341  setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
342  TT = Triple(IRMods[0]->getTargetTriple());
343 
344  for (auto *M : IRMods)
345  if (Error Err = addModule(M))
346  return Err;
347 
348  COFFLinkerOptsOS.flush();
349  setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));
350 
351  // We are about to fill in the header's range fields, so reserve space for it
352  // and copy it in afterwards.
353  Symtab.resize(sizeof(storage::Header));
354  writeRange(Hdr.Modules, Mods);
355  writeRange(Hdr.Comdats, Comdats);
356  writeRange(Hdr.Symbols, Syms);
357  writeRange(Hdr.Uncommons, Uncommons);
358  writeRange(Hdr.DependentLibraries, DependentLibraries);
359  *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
360  return Error::success();
361 }
362 
363 } // end anonymous namespace
364 
366  StringTableBuilder &StrtabBuilder,
367  BumpPtrAllocator &Alloc) {
368  return Builder(Symtab, StrtabBuilder, Alloc).build(Mods);
369 }
370 
371 // Upgrade a vector of bitcode modules created by an old version of LLVM by
372 // creating an irsymtab for them in the current format.
375 
376  LLVMContext Ctx;
377  std::vector<Module *> Mods;
378  std::vector<std::unique_ptr<Module>> OwnedMods;
379  for (auto BM : BMs) {
381  BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,
382  /*IsImporting*/ false);
383  if (!MOrErr)
384  return MOrErr.takeError();
385 
386  Mods.push_back(MOrErr->get());
387  OwnedMods.push_back(std::move(*MOrErr));
388  }
389 
391  BumpPtrAllocator Alloc;
392  if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))
393  return std::move(E);
394 
395  StrtabBuilder.finalizeInOrder();
396  FC.Strtab.resize(StrtabBuilder.getSize());
397  StrtabBuilder.write((uint8_t *)FC.Strtab.data());
398 
399  FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
400  {FC.Strtab.data(), FC.Strtab.size()}};
401  return std::move(FC);
402 }
403 
405  if (BFC.Mods.empty())
406  return make_error<StringError>("Bitcode file does not contain any modules",
408 
410  if (BFC.StrtabForSymtab.empty() ||
411  BFC.Symtab.size() < sizeof(storage::Header))
412  return upgrade(BFC.Mods);
413 
414  // We cannot use the regular reader to read the version and producer,
415  // because it will expect the header to be in the current format. The only
416  // thing we can rely on is that the version and producer will be present as
417  // the first struct elements.
418  auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());
419  unsigned Version = Hdr->Version;
420  StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);
422  Producer != kExpectedProducerName)
423  return upgrade(BFC.Mods);
424  }
425 
427  FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
428  {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
429 
430  // Finally, make sure that the number of modules in the symbol table matches
431  // the number of modules in the bitcode file. If they differ, it may mean that
432  // the bitcode file was created by binary concatenation, so we need to create
433  // a new symbol table from scratch.
434  if (FC.TheReader.getNumModules() != BFC.Mods.size())
435  return upgrade(std::move(BFC.Mods));
436 
437  return std::move(FC);
438 }
llvm::irsymtab::storage::Symbol::FB_has_uncommon
@ FB_has_uncommon
Definition: IRSymtab.h:105
llvm::irsymtab::storage::Header::Symbols
Range< Symbol > Symbols
Definition: IRSymtab.h:149
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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
Comdat.h
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1588
llvm::ARM::PredBlockMask::TT
@ TT
llvm::irsymtab::storage::Header::Modules
Range< Module > Modules
Definition: IRSymtab.h:147
Metadata.h
llvm::irsymtab::storage::Str::get
StringRef get(StringRef Strtab) const
Definition: IRSymtab.h:58
llvm::object::BasicSymbolRef::SF_Indirect
@ SF_Indirect
Definition: SymbolicFile.h:115
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::object::BasicSymbolRef::SF_Common
@ SF_Common
Definition: SymbolicFile.h:114
llvm::irsymtab::FileContents
The contents of the irsymtab in a bitcode file.
Definition: IRSymtab.h:369
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:629
llvm::GlobalObject::getSection
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:111
llvm::SmallVector< char, 0 >
llvm::irsymtab::storage::Comdat
This is equivalent to an IR comdat.
Definition: IRSymtab.h:82
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::irsymtab::storage::Symbol::FB_used
@ FB_used
Definition: IRSymtab.h:110
llvm::StringTableBuilder::finalizeInOrder
void finalizeInOrder()
Finalize the string table without reording it.
Definition: StringTableBuilder.cpp:133
upgrade
static Expected< FileContents > upgrade(ArrayRef< BitcodeModule > BMs)
Definition: IRSymtab.cpp:373
Allocator.h
R600_InstFlag::FC
@ FC
Definition: R600Defines.h:32
Error.h
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:140
DenseMap.h
llvm::BitcodeFileContents::Symtab
StringRef Symtab
Definition: BitcodeReader.h:129
llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Used
@ Used
Module.h
llvm::irsymtab::storage::Header::DependentLibraries
Range< Str > DependentLibraries
Dependent Library Specifiers.
Definition: IRSymtab.h:158
llvm::irsymtab::storage::Header::Version
Word Version
Version number of the symtab format.
Definition: IRSymtab.h:138
GlobalObject.h
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::object::BasicSymbolRef::SF_Weak
@ SF_Weak
Definition: SymbolicFile.h:112
SymbolicFile.h
llvm::Mangler
Definition: Mangler.h:27
llvm::irsymtab::storage::Symbol::FB_undefined
@ FB_undefined
Definition: IRSymtab.h:106
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:159
llvm::object::BasicSymbolRef::SF_Executable
@ SF_Executable
Definition: SymbolicFile.h:122
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:265
llvm::collectUsedGlobalVariables
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition: Module.cpp:801
CommandLine.h
llvm::irsymtab::storage::Header::Producer
Str Producer
The producer's version string (LLVM_VERSION_STRING " " LLVM_REVISION).
Definition: IRSymtab.h:145
StringTableBuilder.h
SmallString.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::irsymtab::storage::Symbol::Flags
Word Flags
Definition: IRSymtab.h:102
llvm::Comdat::SelectionKind
SelectionKind
Definition: Comdat.h:35
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::GlobalObject
Definition: GlobalObject.h:27
llvm::MDNode::operands
ArrayRef< MDOperand > operands() const
Definition: Metadata.h:1290
llvm::GlobalObject::getComdat
const Comdat * getComdat() const
Definition: GlobalObject.h:122
llvm::Mangler::getNameWithPrefix
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition: Mangler.cpp:119
llvm::StringTableBuilder::getSize
size_t getSize() const
Definition: StringTableBuilder.h:82
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:642
llvm::StringRef::data
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
llvm::irsymtab::storage::Header::TargetTriple
Str TargetTriple
Definition: IRSymtab.h:152
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:1056
SmallPtrSet.h
llvm::ModuleSymbolTable::printSymbolName
void printSymbolName(raw_ostream &OS, Symbol S) const
Definition: ModuleSymbolTable.cpp:176
llvm::GlobalValue::hasGlobalUnnamedAddr
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:209
llvm::ModuleSymbolTable::symbols
ArrayRef< Symbol > symbols() const
Definition: ModuleSymbolTable.h:46
llvm::Comdat
Definition: Comdat.h:33
llvm::irsymtab::storage::Header
Definition: IRSymtab.h:134
llvm::BitcodeFileContents
Definition: BitcodeReader.h:127
llvm::StringTableBuilder::RAW
@ RAW
Definition: StringTableBuilder.h:32
llvm::ModuleSymbolTable::addModule
void addModule(Module *M)
Definition: ModuleSymbolTable.cpp:54
llvm::SmallString< 64 >
llvm::irsymtab::storage::Header::Comdats
Range< Comdat > Comdats
Definition: IRSymtab.h:148
llvm::irsymtab::readBitcode
Expected< FileContents > readBitcode(const BitcodeFileContents &BFC)
Reads the contents of a bitcode file, creating its irsymtab if necessary.
Definition: IRSymtab.cpp:404
StringSaver.h
llvm::irsymtab::storage::Header::SourceFileName
Str SourceFileName
Definition: IRSymtab.h:152
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
DisableBitcodeVersionUpgrade
cl::opt< bool > DisableBitcodeVersionUpgrade("disable-bitcode-version-upgrade", cl::init(false), cl::Hidden, cl::desc("Disable automatic bitcode upgrade for version mismatch"))
llvm::cl::opt< bool >
llvm::irsymtab::storage::Symbol::FB_visibility
@ FB_visibility
Definition: IRSymtab.h:104
IRSymtab.h
llvm::irsymtab::storage::Header::kCurrentVersion
@ kCurrentVersion
Definition: IRSymtab.h:139
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::object::BasicSymbolRef::SF_FormatSpecific
@ SF_FormatSpecific
Definition: SymbolicFile.h:117
llvm::irsymtab::storage::Symbol::FB_common
@ FB_common
Definition: IRSymtab.h:108
llvm::GlobalValue::getVisibility
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:242
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:650
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:63
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:162
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::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
llvm::DenseMap
Definition: DenseMap.h:714
llvm::irsymtab::storage::Symbol::IRName
Str IRName
The unmangled symbol name, or the empty string if this is not an IR symbol.
Definition: IRSymtab.h:97
llvm::object::BasicSymbolRef::SF_Undefined
@ SF_Undefined
Definition: SymbolicFile.h:110
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:447
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1843
ArrayRef.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
PreservedSymbols
static const char * PreservedSymbols[]
Definition: IRSymtab.cpp:48
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:521
llvm::GlobalValue::isThreadLocal
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:257
llvm::irsymtab::storage::Uncommon
This data structure contains rarely used symbol fields and is optionally referenced by a Symbol.
Definition: IRSymtab.h:122
llvm::irsymtab::storage::Uncommon::SectionName
Str SectionName
Specified section name, if any.
Definition: IRSymtab.h:130
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::StringTableBuilder::write
void write(raw_ostream &OS) const
Definition: StringTableBuilder.cpp:60
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::BitcodeFileContents::Mods
std::vector< BitcodeModule > Mods
Definition: BitcodeReader.h:128
llvm::StringSaver
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
Mangler.h
Triple.h
ModuleSymbolTable.h
llvm::GlobalValue::canBeOmittedFromSymbolTable
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:390
Fallback
@ Fallback
Definition: WholeProgramDevirt.cpp:180
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
DataLayout.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:566
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
llvm::GlobalValue::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:365
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:207
llvm::PointerUnion
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:112
llvm::irsymtab::storage::Module
Describes the range of a particular module's symbols within the symbol table.
Definition: IRSymtab.h:74
llvm::irsymtab::storage::Str
A reference to a string in the string table.
Definition: IRSymtab.h:55
llvm::ModuleSymbolTable::getSymbolFlags
uint32_t getSymbolFlags(Symbol S) const
Definition: ModuleSymbolTable.cpp:189
llvm::StringRef::size
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
llvm::irsymtab::storage::Range
A reference to a range of objects in the symbol table.
Definition: IRSymtab.h:64
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::irsymtab::storage::Uncommon::COFFWeakExternFallbackName
Str COFFWeakExternFallbackName
COFF-specific: the name of the symbol that a weak external resolves to if not defined.
Definition: IRSymtab.h:127
llvm::inconvertibleErrorCode
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:79
llvm::irsymtab::storage::Symbol::FB_weak
@ FB_weak
Definition: IRSymtab.h:107
llvm::SectionName
Definition: DWARFSection.h:21
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
Casting.h
llvm::irsymtab::storage::Symbol::FB_may_omit
@ FB_may_omit
Definition: IRSymtab.h:112
llvm::StringTableBuilder::add
size_t add(CachedHashStringRef S)
Add a string to the builder.
Definition: StringTableBuilder.cpp:201
llvm::StringTableBuilder
Utility for building string tables with deduplicated suffixes.
Definition: StringTableBuilder.h:23
llvm::irsymtab::storage::Header::COFFLinkerOpts
Str COFFLinkerOpts
COFF-specific: linker directives.
Definition: IRSymtab.h:155
GlobalAlias.h
llvm::irsymtab::storage::Symbol::FB_indirect
@ FB_indirect
Definition: IRSymtab.h:109
llvm::BitcodeFileContents::StrtabForSymtab
StringRef StrtabForSymtab
Definition: BitcodeReader.h:129
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:596
llvm::ModuleSymbolTable
Definition: ModuleSymbolTable.h:33
llvm::irsymtab::storage::Symbol::FB_global
@ FB_global
Definition: IRSymtab.h:113
SmallVector.h
llvm::emitLinkerFlagsForGlobalCOFF
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:211
llvm::irsymtab::storage::Symbol::ComdatIndex
Word ComdatIndex
The index into Header::Comdats, or -1 if not a comdat member.
Definition: IRSymtab.h:100
llvm::irsymtab::storage::Symbol::FB_tls
@ FB_tls
Definition: IRSymtab.h:111
N
#define N
llvm::object::BasicSymbolRef::SF_Global
@ SF_Global
Definition: SymbolicFile.h:111
llvm::StringSaver::save
StringRef save(const char *S)
Definition: StringSaver.h:30
addSymbol
static void addSymbol(Object &Obj, const NewSymbolInfo &SymInfo, uint8_t DefaultVisibility)
Definition: ELFObjcopy.cpp:531
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:659
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:399
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:290
llvm::omp::RTLDependInfoFields::Flags
@ Flags
llvm::cl::desc
Definition: CommandLine.h:413
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
BitcodeReader.h
raw_ostream.h
llvm::irsymtab::storage::Symbol::Name
Str Name
The mangled symbol name.
Definition: IRSymtab.h:93
llvm::irsymtab::storage::Header::Uncommons
Range< Uncommon > Uncommons
Definition: IRSymtab.h:150
llvm::irsymtab::storage::Symbol::FB_executable
@ FB_executable
Definition: IRSymtab.h:116
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::irsymtab::storage::Symbol
Contains the information needed by linkers for symbol resolution, as well as by the LTO implementatio...
Definition: IRSymtab.h:91
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:773
llvm::irsymtab::storage::Symbol::FB_unnamed_addr
@ FB_unnamed_addr
Definition: IRSymtab.h:115
llvm::irsymtab::storage::Symbol::FB_format_specific
@ FB_format_specific
Definition: IRSymtab.h:114
llvm::irsymtab::build
Error build(ArrayRef< Module * > Mods, SmallVector< char, 0 > &Symtab, StringTableBuilder &StrtabBuilder, BumpPtrAllocator &Alloc)
Fills in Symtab and StrtabBuilder with a valid symbol and string table for Mods.
Definition: IRSymtab.cpp:365
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:809
llvm::DataLayout::getTypeAllocSize
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:506
llvm::Module::size
size_t size() const
Definition: Module.h:633