LLVM  13.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"
17 #include "llvm/Config/llvm-config.h"
18 #include "llvm/IR/Comdat.h"
19 #include "llvm/IR/DataLayout.h"
20 #include "llvm/IR/GlobalAlias.h"
21 #include "llvm/IR/GlobalObject.h"
22 #include "llvm/IR/Mangler.h"
23 #include "llvm/IR/Metadata.h"
24 #include "llvm/IR/Module.h"
30 #include "llvm/Support/Allocator.h"
31 #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 
44 static const char *LibcallRoutineNames[] = {
45 #define HANDLE_LIBCALL(code, name) name,
46 #include "llvm/IR/RuntimeLibcalls.def"
47 #undef HANDLE_LIBCALL
48 };
49 
50 namespace {
51 
52 const char *getExpectedProducerName() {
53  static char DefaultName[] = LLVM_VERSION_STRING
54 #ifdef LLVM_REVISION
55  " " LLVM_REVISION
56 #endif
57  ;
58  // Allows for testing of the irsymtab writer and upgrade mechanism. This
59  // environment variable should not be set by users.
60  if (char *OverrideName = getenv("LLVM_OVERRIDE_PRODUCER"))
61  return OverrideName;
62  return DefaultName;
63 }
64 
65 const char *kExpectedProducerName = getExpectedProducerName();
66 
67 /// Stores the temporary state that is required to build an IR symbol table.
68 struct Builder {
69  SmallVector<char, 0> &Symtab;
70  StringTableBuilder &StrtabBuilder;
71  StringSaver Saver;
72 
73  // This ctor initializes a StringSaver using the passed in BumpPtrAllocator.
74  // The StringTableBuilder does not create a copy of any strings added to it,
75  // so this provides somewhere to store any strings that we create.
76  Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,
77  BumpPtrAllocator &Alloc)
78  : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc) {}
79 
81  Mangler Mang;
82  Triple TT;
83 
84  std::vector<storage::Comdat> Comdats;
85  std::vector<storage::Module> Mods;
86  std::vector<storage::Symbol> Syms;
87  std::vector<storage::Uncommon> Uncommons;
88 
89  std::string COFFLinkerOpts;
90  raw_string_ostream COFFLinkerOptsOS{COFFLinkerOpts};
91 
92  std::vector<storage::Str> DependentLibraries;
93 
94  void setStr(storage::Str &S, StringRef Value) {
95  S.Offset = StrtabBuilder.add(Value);
96  S.Size = Value.size();
97  }
98 
99  template <typename T>
100  void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
101  R.Offset = Symtab.size();
102  R.Size = Objs.size();
103  Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
104  reinterpret_cast<const char *>(Objs.data() + Objs.size()));
105  }
106 
107  Expected<int> getComdatIndex(const Comdat *C, const Module *M);
108 
109  Error addModule(Module *M);
110  Error addSymbol(const ModuleSymbolTable &Msymtab,
111  const SmallPtrSet<GlobalValue *, 4> &Used,
113 
115 };
116 
117 Error Builder::addModule(Module *M) {
118  if (M->getDataLayoutStr().empty())
119  return make_error<StringError>("input module has no datalayout",
121 
122  // Symbols in the llvm.used list will get the FB_Used bit and will not be
123  // internalized. We do this for llvm.compiler.used as well:
124  //
125  // IR symbol table tracks module-level asm symbol references but not inline
126  // asm. A symbol only referenced by inline asm is not in the IR symbol table,
127  // so we may not know that the definition (in another translation unit) is
128  // referenced. That definition may have __attribute__((used)) (which lowers to
129  // llvm.compiler.used on ELF targets) to communicate to the compiler that it
130  // may be used by inline asm. The usage is perfectly fine, so we treat
131  // llvm.compiler.used conservatively as llvm.used to work around our own
132  // limitation.
134  collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/false);
135  collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/true);
136  SmallPtrSet<GlobalValue *, 4> Used(UsedV.begin(), UsedV.end());
137 
138  ModuleSymbolTable Msymtab;
139  Msymtab.addModule(M);
140 
142  Mod.Begin = Syms.size();
143  Mod.End = Syms.size() + Msymtab.symbols().size();
144  Mod.UncBegin = Uncommons.size();
145  Mods.push_back(Mod);
146 
147  if (TT.isOSBinFormatCOFF()) {
148  if (auto E = M->materializeMetadata())
149  return E;
150  if (NamedMDNode *LinkerOptions =
151  M->getNamedMetadata("llvm.linker.options")) {
152  for (MDNode *MDOptions : LinkerOptions->operands())
153  for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())
154  COFFLinkerOptsOS << " " << cast<MDString>(MDOption)->getString();
155  }
156  }
157 
158  if (TT.isOSBinFormatELF()) {
159  if (auto E = M->materializeMetadata())
160  return E;
161  if (NamedMDNode *N = M->getNamedMetadata("llvm.dependent-libraries")) {
162  for (MDNode *MDOptions : N->operands()) {
163  const auto OperandStr =
164  cast<MDString>(cast<MDNode>(MDOptions)->getOperand(0))->getString();
165  storage::Str Specifier;
166  setStr(Specifier, OperandStr);
167  DependentLibraries.emplace_back(Specifier);
168  }
169  }
170  }
171 
172  for (ModuleSymbolTable::Symbol Msym : Msymtab.symbols())
173  if (Error Err = addSymbol(Msymtab, Used, Msym))
174  return Err;
175 
176  return Error::success();
177 }
178 
179 Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
180  auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));
181  if (P.second) {
182  std::string Name;
183  if (TT.isOSBinFormatCOFF()) {
184  const GlobalValue *GV = M->getNamedValue(C->getName());
185  if (!GV)
186  return make_error<StringError>("Could not find leader",
188  // Internal leaders do not affect symbol resolution, therefore they do not
189  // appear in the symbol table.
190  if (GV->hasLocalLinkage()) {
191  P.first->second = -1;
192  return -1;
193  }
195  Mang.getNameWithPrefix(OS, GV, false);
196  } else {
197  Name = std::string(C->getName());
198  }
199 
201  setStr(Comdat.Name, Saver.save(Name));
202  Comdats.push_back(Comdat);
203  }
204 
205  return P.first->second;
206 }
207 
208 Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
209  const SmallPtrSet<GlobalValue *, 4> &Used,
211  Syms.emplace_back();
212  storage::Symbol &Sym = Syms.back();
213  Sym = {};
214 
215  storage::Uncommon *Unc = nullptr;
216  auto Uncommon = [&]() -> storage::Uncommon & {
217  if (Unc)
218  return *Unc;
220  Uncommons.emplace_back();
221  Unc = &Uncommons.back();
222  *Unc = {};
223  setStr(Unc->COFFWeakExternFallbackName, "");
224  setStr(Unc->SectionName, "");
225  return *Unc;
226  };
227 
229  {
231  Msymtab.printSymbolName(OS, Msym);
232  }
233  setStr(Sym.Name, Saver.save(StringRef(Name)));
234 
235  auto Flags = Msymtab.getSymbolFlags(Msym);
239  Sym.Flags |= 1 << storage::Symbol::FB_weak;
241  Sym.Flags |= 1 << storage::Symbol::FB_common;
245  Sym.Flags |= 1 << storage::Symbol::FB_global;
250 
251  Sym.ComdatIndex = -1;
252  auto *GV = Msym.dyn_cast<GlobalValue *>();
253  if (!GV) {
254  // Undefined module asm symbols act as GC roots and are implicitly used.
256  Sym.Flags |= 1 << storage::Symbol::FB_used;
257  setStr(Sym.IRName, "");
258  return Error::success();
259  }
260 
261  setStr(Sym.IRName, GV->getName());
262 
263  bool IsBuiltinFunc = llvm::is_contained(LibcallRoutineNames, GV->getName());
264 
265  if (Used.count(GV) || IsBuiltinFunc)
266  Sym.Flags |= 1 << storage::Symbol::FB_used;
267  if (GV->isThreadLocal())
268  Sym.Flags |= 1 << storage::Symbol::FB_tls;
269  if (GV->hasGlobalUnnamedAddr())
271  if (GV->canBeOmittedFromSymbolTable())
273  Sym.Flags |= unsigned(GV->getVisibility()) << storage::Symbol::FB_visibility;
274 
275  if (Flags & object::BasicSymbolRef::SF_Common) {
276  auto *GVar = dyn_cast<GlobalVariable>(GV);
277  if (!GVar)
278  return make_error<StringError>("Only variables can have common linkage!",
280  Uncommon().CommonSize = GV->getParent()->getDataLayout().getTypeAllocSize(
281  GV->getType()->getElementType());
282  Uncommon().CommonAlign = GVar->getAlignment();
283  }
284 
285  const GlobalObject *Base = GV->getBaseObject();
286  if (!Base)
287  return make_error<StringError>("Unable to determine comdat of alias!",
289  if (const Comdat *C = Base->getComdat()) {
290  Expected<int> ComdatIndexOrErr = getComdatIndex(C, GV->getParent());
291  if (!ComdatIndexOrErr)
292  return ComdatIndexOrErr.takeError();
293  Sym.ComdatIndex = *ComdatIndexOrErr;
294  }
295 
296  if (TT.isOSBinFormatCOFF()) {
297  emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);
298 
299  if ((Flags & object::BasicSymbolRef::SF_Weak) &&
301  auto *Fallback = dyn_cast<GlobalValue>(
302  cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts());
303  if (!Fallback)
304  return make_error<StringError>("Invalid weak external",
306  std::string FallbackName;
307  raw_string_ostream OS(FallbackName);
308  Msymtab.printSymbolName(OS, Fallback);
309  OS.flush();
310  setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
311  }
312  }
313 
314  if (!Base->getSection().empty())
315  setStr(Uncommon().SectionName, Saver.save(Base->getSection()));
316 
317  return Error::success();
318 }
319 
321  storage::Header Hdr;
322 
323  assert(!IRMods.empty());
325  setStr(Hdr.Producer, kExpectedProducerName);
326  setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
327  setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
328  TT = Triple(IRMods[0]->getTargetTriple());
329 
330  for (auto *M : IRMods)
331  if (Error Err = addModule(M))
332  return Err;
333 
334  COFFLinkerOptsOS.flush();
335  setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));
336 
337  // We are about to fill in the header's range fields, so reserve space for it
338  // and copy it in afterwards.
339  Symtab.resize(sizeof(storage::Header));
340  writeRange(Hdr.Modules, Mods);
341  writeRange(Hdr.Comdats, Comdats);
342  writeRange(Hdr.Symbols, Syms);
343  writeRange(Hdr.Uncommons, Uncommons);
344  writeRange(Hdr.DependentLibraries, DependentLibraries);
345  *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
346  return Error::success();
347 }
348 
349 } // end anonymous namespace
350 
352  StringTableBuilder &StrtabBuilder,
353  BumpPtrAllocator &Alloc) {
354  return Builder(Symtab, StrtabBuilder, Alloc).build(Mods);
355 }
356 
357 // Upgrade a vector of bitcode modules created by an old version of LLVM by
358 // creating an irsymtab for them in the current format.
361 
362  LLVMContext Ctx;
363  std::vector<Module *> Mods;
364  std::vector<std::unique_ptr<Module>> OwnedMods;
365  for (auto BM : BMs) {
367  BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,
368  /*IsImporting*/ false);
369  if (!MOrErr)
370  return MOrErr.takeError();
371 
372  Mods.push_back(MOrErr->get());
373  OwnedMods.push_back(std::move(*MOrErr));
374  }
375 
377  BumpPtrAllocator Alloc;
378  if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))
379  return std::move(E);
380 
381  StrtabBuilder.finalizeInOrder();
382  FC.Strtab.resize(StrtabBuilder.getSize());
383  StrtabBuilder.write((uint8_t *)FC.Strtab.data());
384 
385  FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
386  {FC.Strtab.data(), FC.Strtab.size()}};
387  return std::move(FC);
388 }
389 
391  if (BFC.Mods.empty())
392  return make_error<StringError>("Bitcode file does not contain any modules",
394 
395  if (BFC.StrtabForSymtab.empty() ||
396  BFC.Symtab.size() < sizeof(storage::Header))
397  return upgrade(BFC.Mods);
398 
399  // We cannot use the regular reader to read the version and producer, because
400  // it will expect the header to be in the current format. The only thing we
401  // can rely on is that the version and producer will be present as the first
402  // struct elements.
403  auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());
404  unsigned Version = Hdr->Version;
405  StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);
407  Producer != kExpectedProducerName)
408  return upgrade(BFC.Mods);
409 
411  FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
412  {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
413 
414  // Finally, make sure that the number of modules in the symbol table matches
415  // the number of modules in the bitcode file. If they differ, it may mean that
416  // the bitcode file was created by binary concatenation, so we need to create
417  // a new symbol table from scratch.
418  if (FC.TheReader.getNumModules() != BFC.Mods.size())
419  return upgrade(std::move(BFC.Mods));
420 
421  return std::move(FC);
422 }
llvm::irsymtab::storage::Symbol::FB_has_uncommon
@ FB_has_uncommon
Definition: IRSymtab.h:101
llvm::irsymtab::storage::Header::Symbols
Range< Symbol > Symbols
Definition: IRSymtab.h:145
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::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
Comdat.h
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1386
llvm::ARM::PredBlockMask::TT
@ TT
llvm::irsymtab::storage::Header::Modules
Range< Module > Modules
Definition: IRSymtab.h:143
Metadata.h
llvm::irsymtab::storage::Str::get
StringRef get(StringRef Strtab) const
Definition: IRSymtab.h:57
llvm::object::BasicSymbolRef::SF_Indirect
@ SF_Indirect
Definition: SymbolicFile.h:113
llvm::PointerType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:675
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:112
llvm::irsymtab::FileContents
The contents of the irsymtab in a bitcode file.
Definition: IRSymtab.h:363
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:614
llvm::SmallVector< char, 0 >
llvm::irsymtab::storage::Comdat
This is equivalent to an IR comdat.
Definition: IRSymtab.h:81
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::irsymtab::storage::Symbol::FB_used
@ FB_used
Definition: IRSymtab.h:106
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:359
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:45
DenseMap.h
llvm::BitcodeFileContents::Symtab
StringRef Symtab
Definition: BitcodeReader.h:125
Module.h
llvm::irsymtab::storage::Header::DependentLibraries
Range< Str > DependentLibraries
Dependent Library Specifiers.
Definition: IRSymtab.h:154
llvm::irsymtab::storage::Header::Version
Word Version
Version number of the symtab format.
Definition: IRSymtab.h:134
GlobalObject.h
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:449
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::object::BasicSymbolRef::SF_Weak
@ SF_Weak
Definition: SymbolicFile.h:110
SymbolicFile.h
llvm::Mangler
Definition: Mangler.h:27
llvm::irsymtab::storage::Symbol::FB_undefined
@ FB_undefined
Definition: IRSymtab.h:102
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::object::BasicSymbolRef::SF_Executable
@ SF_Executable
Definition: SymbolicFile.h:120
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:180
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:763
llvm::MDNode::operands
op_range operands() const
Definition: Metadata.h:1100
llvm::irsymtab::storage::Header::Producer
Str Producer
The producer's version string (LLVM_VERSION_STRING " " LLVM_REVISION).
Definition: IRSymtab.h:141
StringTableBuilder.h
SmallString.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::irsymtab::storage::Symbol::Flags
Word Flags
Definition: IRSymtab.h:98
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::GlobalObject
Definition: GlobalObject.h:28
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:114
llvm::StringTableBuilder::getSize
size_t getSize() const
Definition: StringTableBuilder.h:82
llvm::SmallVectorImpl::resize
void resize(size_type N)
Definition: SmallVector.h:605
llvm::irsymtab::storage::Header::TargetTriple
Str TargetTriple
Definition: IRSymtab.h:148
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
SmallPtrSet.h
llvm::ModuleSymbolTable::printSymbolName
void printSymbolName(raw_ostream &OS, Symbol S) const
Definition: ModuleSymbolTable.cpp:178
llvm::GlobalValue::hasGlobalUnnamedAddr
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:196
llvm::ModuleSymbolTable::symbols
ArrayRef< Symbol > symbols() const
Definition: ModuleSymbolTable.h:46
llvm::Comdat
Definition: Comdat.h:31
llvm::irsymtab::storage::Header
Definition: IRSymtab.h:130
llvm::BitcodeFileContents
Definition: BitcodeReader.h:123
llvm::StringTableBuilder::RAW
@ RAW
Definition: StringTableBuilder.h:32
llvm::ModuleSymbolTable::addModule
void addModule(Module *M)
Definition: ModuleSymbolTable.cpp:57
llvm::SmallString< 64 >
llvm::irsymtab::storage::Header::Comdats
Range< Comdat > Comdats
Definition: IRSymtab.h:144
llvm::irsymtab::readBitcode
Expected< FileContents > readBitcode(const BitcodeFileContents &BFC)
Reads the contents of a bitcode file, creating its irsymtab if necessary.
Definition: IRSymtab.cpp:390
StringSaver.h
llvm::irsymtab::storage::Header::SourceFileName
Str SourceFileName
Definition: IRSymtab.h:148
IRObjectFile.h
llvm::irsymtab::storage::Symbol::FB_visibility
@ FB_visibility
Definition: IRSymtab.h:100
IRSymtab.h
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::object::BasicSymbolRef::SF_FormatSpecific
@ SF_FormatSpecific
Definition: SymbolicFile.h:115
llvm::irsymtab::storage::Symbol::FB_common
@ FB_common
Definition: IRSymtab.h:104
llvm::irsymtab::storage::Header::kCurrentVersion
@ kCurrentVersion
Definition: IRSymtab.h:135
llvm::GlobalValue::getVisibility
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:229
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:67
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::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
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:93
llvm::object::BasicSymbolRef::SF_Undefined
@ SF_Undefined
Definition: SymbolicFile.h:108
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:1547
ArrayRef.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:445
llvm::GlobalValue::isThreadLocal
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:244
llvm::irsymtab::storage::Uncommon
This data structure contains rarely used symbol fields and is optionally referenced by a Symbol.
Definition: IRSymtab.h:118
llvm::irsymtab::storage::Uncommon::SectionName
Str SectionName
Specified section name, if any.
Definition: IRSymtab.h:126
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::StringTableBuilder::write
void write(raw_ostream &OS) const
Definition: StringTableBuilder.cpp:60
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:382
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::BitcodeFileContents::Mods
std::vector< BitcodeModule > Mods
Definition: BitcodeReader.h:124
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:311
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:58
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:537
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::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:294
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:149
llvm::irsymtab::storage::Module
Describes the range of a particular module's symbols within the symbol table.
Definition: IRSymtab.h:73
llvm::irsymtab::storage::Str
A reference to a string in the string table.
Definition: IRSymtab.h:54
llvm::ModuleSymbolTable::getSymbolFlags
uint32_t getSymbolFlags(Symbol S) const
Definition: ModuleSymbolTable.cpp:191
llvm::irsymtab::storage::Range
A reference to a range of objects in the symbol table.
Definition: IRSymtab.h:63
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
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:123
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:77
llvm::irsymtab::storage::Symbol::FB_weak
@ FB_weak
Definition: IRSymtab.h:103
llvm::SectionName
Definition: DWARFSection.h:21
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
Casting.h
llvm::irsymtab::storage::Symbol::FB_may_omit
@ FB_may_omit
Definition: IRSymtab.h:108
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::GlobalValue::getBaseObject
const GlobalObject * getBaseObject() const
Definition: Globals.cpp:283
llvm::irsymtab::storage::Header::COFFLinkerOpts
Str COFFLinkerOpts
COFF-specific: linker directives.
Definition: IRSymtab.h:151
GlobalAlias.h
llvm::irsymtab::storage::Symbol::FB_indirect
@ FB_indirect
Definition: IRSymtab.h:105
llvm::BitcodeFileContents::StrtabForSymtab
StringRef StrtabForSymtab
Definition: BitcodeReader.h:125
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
llvm::ModuleSymbolTable
Definition: ModuleSymbolTable.h:33
llvm::irsymtab::storage::Symbol::FB_global
@ FB_global
Definition: IRSymtab.h:109
SmallVector.h
llvm::emitLinkerFlagsForGlobalCOFF
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:206
llvm::irsymtab::storage::Symbol::ComdatIndex
Word ComdatIndex
The index into Header::Comdats, or -1 if not a comdat member.
Definition: IRSymtab.h:96
llvm::irsymtab::storage::Symbol::FB_tls
@ FB_tls
Definition: IRSymtab.h:107
N
#define N
llvm::object::BasicSymbolRef::SF_Global
@ SF_Global
Definition: SymbolicFile.h:109
llvm::StringSaver::save
StringRef save(const char *S)
Definition: StringSaver.h:28
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::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:271
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:397
LibcallRoutineNames
static const char * LibcallRoutineNames[]
Definition: IRSymtab.cpp:44
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:89
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157
llvm::irsymtab::storage::Header::Uncommons
Range< Uncommon > Uncommons
Definition: IRSymtab.h:146
llvm::irsymtab::storage::Symbol::FB_executable
@ FB_executable
Definition: IRSymtab.h:112
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::irsymtab::storage::Symbol
Contains the information needed by linkers for symbol resolution, as well as by the LTO implementatio...
Definition: IRSymtab.h:87
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:744
llvm::irsymtab::storage::Symbol::FB_unnamed_addr
@ FB_unnamed_addr
Definition: IRSymtab.h:111
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::irsymtab::storage::Symbol::FB_format_specific
@ FB_format_specific
Definition: IRSymtab.h:110
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:351
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:772
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:498
llvm::Module::size
size_t size() const
Definition: Module.h:627