LLVM  6.0.0svn
IRSymtab.h
Go to the documentation of this file.
1 //===- IRSymtab.h - data definitions for IR symbol tables -------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains data definitions and a reader and builder for a symbol
11 // table for LLVM IR. Its purpose is to allow linkers and other consumers of
12 // bitcode files to efficiently read the symbol table for symbol resolution
13 // purposes without needing to construct a module in memory.
14 //
15 // As with most object files the symbol table has two parts: the symbol table
16 // itself and a string table which is referenced by the symbol table.
17 //
18 // A symbol table corresponds to a single bitcode file, which may consist of
19 // multiple modules, so symbol tables may likewise contain symbols for multiple
20 // modules.
21 //
22 //===----------------------------------------------------------------------===//
23 
24 #ifndef LLVM_OBJECT_IRSYMTAB_H
25 #define LLVM_OBJECT_IRSYMTAB_H
26 
27 #include "llvm/ADT/ArrayRef.h"
28 #include "llvm/ADT/StringRef.h"
30 #include "llvm/IR/GlobalValue.h"
32 #include "llvm/Support/Endian.h"
33 #include "llvm/Support/Error.h"
34 #include <cassert>
35 #include <cstdint>
36 #include <vector>
37 
38 namespace llvm {
39 
40 struct BitcodeFileContents;
41 class StringTableBuilder;
42 
43 namespace irsymtab {
44 
45 namespace storage {
46 
47 // The data structures in this namespace define the low-level serialization
48 // format. Clients that just want to read a symbol table should use the
49 // irsymtab::Reader class.
50 
52 
53 /// A reference to a string in the string table.
54 struct Str {
56 
57  StringRef get(StringRef Strtab) const {
58  return {Strtab.data() + Offset, Size};
59  }
60 };
61 
62 /// A reference to a range of objects in the symbol table.
63 template <typename T> struct Range {
65 
66  ArrayRef<T> get(StringRef Symtab) const {
67  return {reinterpret_cast<const T *>(Symtab.data() + Offset), Size};
68  }
69 };
70 
71 /// Describes the range of a particular module's symbols within the symbol
72 /// table.
73 struct Module {
74  Word Begin, End;
75 
76  /// The index of the first Uncommon for this Module.
78 };
79 
80 /// This is equivalent to an IR comdat.
81 struct Comdat {
83 };
84 
85 /// Contains the information needed by linkers for symbol resolution, as well as
86 /// by the LTO implementation itself.
87 struct Symbol {
88  /// The mangled symbol name.
90 
91  /// The unmangled symbol name, or the empty string if this is not an IR
92  /// symbol.
94 
95  /// The index into Header::Comdats, or -1 if not a comdat member.
97 
99  enum FlagBits {
100  FB_visibility, // 2 bits
101  FB_has_uncommon = FB_visibility + 2,
113  };
114 };
115 
116 /// This data structure contains rarely used symbol fields and is optionally
117 /// referenced by a Symbol.
118 struct Uncommon {
119  Word CommonSize, CommonAlign;
120 
121  /// COFF-specific: the name of the symbol that a weak external resolves to
122  /// if not defined.
124 
125  /// Specified section name, if any.
127 };
128 
129 struct Header {
130  /// Version number of the symtab format. This number should be incremented
131  /// when the format changes, but it does not need to be incremented if a
132  /// change to LLVM would cause it to create a different symbol table.
134  enum { kCurrentVersion = 1 };
135 
136  /// The producer's version string (LLVM_VERSION_STRING " " LLVM_REVISION).
137  /// Consumers should rebuild the symbol table from IR if the producer's
138  /// version does not match the consumer's version due to potential differences
139  /// in symbol table format, symbol enumeration order and so on.
141 
146 
147  Str TargetTriple, SourceFileName;
148 
149  /// COFF-specific: linker directives.
151 };
152 
153 } // end namespace storage
154 
155 /// Fills in Symtab and StrtabBuilder with a valid symbol and string table for
156 /// Mods.
158  StringTableBuilder &StrtabBuilder, BumpPtrAllocator &Alloc);
159 
160 /// This represents a symbol that has been read from a storage::Symbol and
161 /// possibly a storage::Uncommon.
162 struct Symbol {
163  // Copied from storage::Symbol.
164  StringRef Name, IRName;
167 
168  // Copied from storage::Uncommon.
169  uint32_t CommonSize, CommonAlign;
172 
173  /// Returns the mangled symbol name.
174  StringRef getName() const { return Name; }
175 
176  /// Returns the unmangled symbol name, or the empty string if this is not an
177  /// IR symbol.
178  StringRef getIRName() const { return IRName; }
179 
180  /// Returns the index into the comdat table (see Reader::getComdatTable()), or
181  /// -1 if not a comdat member.
182  int getComdatIndex() const { return ComdatIndex; }
183 
185 
187  return GlobalValue::VisibilityTypes((Flags >> S::FB_visibility) & 3);
188  }
189 
190  bool isUndefined() const { return (Flags >> S::FB_undefined) & 1; }
191  bool isWeak() const { return (Flags >> S::FB_weak) & 1; }
192  bool isCommon() const { return (Flags >> S::FB_common) & 1; }
193  bool isIndirect() const { return (Flags >> S::FB_indirect) & 1; }
194  bool isUsed() const { return (Flags >> S::FB_used) & 1; }
195  bool isTLS() const { return (Flags >> S::FB_tls) & 1; }
196 
198  return (Flags >> S::FB_may_omit) & 1;
199  }
200 
201  bool isGlobal() const { return (Flags >> S::FB_global) & 1; }
202  bool isFormatSpecific() const { return (Flags >> S::FB_format_specific) & 1; }
203  bool isUnnamedAddr() const { return (Flags >> S::FB_unnamed_addr) & 1; }
204  bool isExecutable() const { return (Flags >> S::FB_executable) & 1; }
205 
206  uint64_t getCommonSize() const {
207  assert(isCommon());
208  return CommonSize;
209  }
210 
212  assert(isCommon());
213  return CommonAlign;
214  }
215 
216  /// COFF-specific: for weak externals, returns the name of the symbol that is
217  /// used as a fallback if the weak external remains undefined.
219  assert(isWeak() && isIndirect());
220  return COFFWeakExternFallbackName;
221  }
222 
224 };
225 
226 /// This class can be used to read a Symtab and Strtab produced by
227 /// irsymtab::build.
228 class Reader {
229  StringRef Symtab, Strtab;
230 
234  ArrayRef<storage::Uncommon> Uncommons;
235 
236  StringRef str(storage::Str S) const { return S.get(Strtab); }
237 
238  template <typename T> ArrayRef<T> range(storage::Range<T> R) const {
239  return R.get(Symtab);
240  }
241 
242  const storage::Header &header() const {
243  return *reinterpret_cast<const storage::Header *>(Symtab.data());
244  }
245 
246 public:
247  class SymbolRef;
248 
249  Reader() = default;
250  Reader(StringRef Symtab, StringRef Strtab) : Symtab(Symtab), Strtab(Strtab) {
251  Modules = range(header().Modules);
252  Comdats = range(header().Comdats);
253  Symbols = range(header().Symbols);
254  Uncommons = range(header().Uncommons);
255  }
256 
258 
259  /// Returns the symbol table for the entire bitcode file.
260  /// The symbols enumerated by this method are ephemeral, but they can be
261  /// copied into an irsymtab::Symbol object.
262  symbol_range symbols() const;
263 
264  size_t getNumModules() const { return Modules.size(); }
265 
266  /// Returns a slice of the symbol table for the I'th module in the file.
267  /// The symbols enumerated by this method are ephemeral, but they can be
268  /// copied into an irsymtab::Symbol object.
269  symbol_range module_symbols(unsigned I) const;
270 
271  StringRef getTargetTriple() const { return str(header().TargetTriple); }
272 
273  /// Returns the source file path specified at compile time.
274  StringRef getSourceFileName() const { return str(header().SourceFileName); }
275 
276  /// Returns a table with all the comdats used by this file.
277  std::vector<StringRef> getComdatTable() const {
278  std::vector<StringRef> ComdatTable;
279  ComdatTable.reserve(Comdats.size());
280  for (auto C : Comdats)
281  ComdatTable.push_back(str(C.Name));
282  return ComdatTable;
283  }
284 
285  /// COFF-specific: returns linker options specified in the input file.
286  StringRef getCOFFLinkerOpts() const { return str(header().COFFLinkerOpts); }
287 };
288 
289 /// Ephemeral symbols produced by Reader::symbols() and
290 /// Reader::module_symbols().
291 class Reader::SymbolRef : public Symbol {
292  const storage::Symbol *SymI, *SymE;
293  const storage::Uncommon *UncI;
294  const Reader *R;
295 
296  void read() {
297  if (SymI == SymE)
298  return;
299 
300  Name = R->str(SymI->Name);
301  IRName = R->str(SymI->IRName);
302  ComdatIndex = SymI->ComdatIndex;
303  Flags = SymI->Flags;
304 
305  if (Flags & (1 << storage::Symbol::FB_has_uncommon)) {
306  CommonSize = UncI->CommonSize;
307  CommonAlign = UncI->CommonAlign;
308  COFFWeakExternFallbackName = R->str(UncI->COFFWeakExternFallbackName);
309  SectionName = R->str(UncI->SectionName);
310  } else
311  // Reset this field so it can be queried unconditionally for all symbols.
312  SectionName = "";
313  }
314 
315 public:
316  SymbolRef(const storage::Symbol *SymI, const storage::Symbol *SymE,
317  const storage::Uncommon *UncI, const Reader *R)
318  : SymI(SymI), SymE(SymE), UncI(UncI), R(R) {
319  read();
320  }
321 
322  void moveNext() {
323  ++SymI;
324  if (Flags & (1 << storage::Symbol::FB_has_uncommon))
325  ++UncI;
326  read();
327  }
328 
329  bool operator==(const SymbolRef &Other) const { return SymI == Other.SymI; }
330 };
331 
333  return {SymbolRef(Symbols.begin(), Symbols.end(), Uncommons.begin(), this),
334  SymbolRef(Symbols.end(), Symbols.end(), nullptr, this)};
335 }
336 
338  const storage::Module &M = Modules[I];
339  const storage::Symbol *MBegin = Symbols.begin() + M.Begin,
340  *MEnd = Symbols.begin() + M.End;
341  return {SymbolRef(MBegin, MEnd, Uncommons.begin() + M.UncBegin, this),
342  SymbolRef(MEnd, MEnd, nullptr, this)};
343 }
344 
345 /// The contents of the irsymtab in a bitcode file. Any underlying data for the
346 /// irsymtab are owned by Symtab and Strtab.
347 struct FileContents {
350 };
351 
352 /// Reads the contents of a bitcode file, creating its irsymtab if necessary.
354 
355 } // end namespace irsymtab
356 } // end namespace llvm
357 
358 #endif // LLVM_OBJECT_IRSYMTAB_H
uint64_t CallInst * C
StringRef getIRName() const
Returns the unmangled symbol name, or the empty string if this is not an IR symbol.
Definition: IRSymtab.h:178
GlobalValue::VisibilityTypes getVisibility() const
Definition: IRSymtab.h:186
StringRef getCOFFWeakExternalFallback() const
COFF-specific: for weak externals, returns the name of the symbol that is used as a fallback if the w...
Definition: IRSymtab.h:218
bool isTLS() const
Definition: IRSymtab.h:195
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Contains the information needed by linkers for symbol resolution, as well as by the LTO implementatio...
Definition: IRSymtab.h:87
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
Reader(StringRef Symtab, StringRef Strtab)
Definition: IRSymtab.h:250
symbol_range module_symbols(unsigned I) const
Returns a slice of the symbol table for the I&#39;th module in the file.
Definition: IRSymtab.h:337
Word ComdatIndex
The index into Header::Comdats, or -1 if not a comdat member.
Definition: IRSymtab.h:96
bool isExecutable() const
Definition: IRSymtab.h:204
Str SectionName
Specified section name, if any.
Definition: IRSymtab.h:126
bool canBeOmittedFromSymbolTable() const
Definition: IRSymtab.h:197
Str IRName
The unmangled symbol name, or the empty string if this is not an IR symbol.
Definition: IRSymtab.h:93
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
A reference to a range of objects in the symbol table.
Definition: IRSymtab.h:63
bool isFormatSpecific() const
Definition: IRSymtab.h:202
size_t getNumModules() const
Definition: IRSymtab.h:264
The contents of the irsymtab in a bitcode file.
Definition: IRSymtab.h:347
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
bool isCommon() const
Definition: IRSymtab.h:192
Utility for building string tables with deduplicated suffixes.
SmallVector< char, 0 > Symtab
Definition: IRSymtab.h:348
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:63
bool isUndefined() const
Definition: IRSymtab.h:190
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
StringRef SectionName
Definition: IRSymtab.h:171
StringRef getName() const
Returns the mangled symbol name.
Definition: IRSymtab.h:174
A reference to a string in the string table.
Definition: IRSymtab.h:54
Ephemeral symbols produced by Reader::symbols() and Reader::module_symbols().
Definition: IRSymtab.h:291
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:311
Describes the range of a particular module&#39;s symbols within the symbol table.
Definition: IRSymtab.h:73
Word Version
Version number of the symtab format.
Definition: IRSymtab.h:133
uint32_t getCommonAlignment() const
Definition: IRSymtab.h:211
detail::packed_endian_specific_integral< uint32_t, little, unaligned > ulittle32_t
Definition: Endian.h:271
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:138
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
bool isIndirect() const
Definition: IRSymtab.h:193
Str COFFLinkerOpts
COFF-specific: linker directives.
Definition: IRSymtab.h:150
Str Name
The mangled symbol name.
Definition: IRSymtab.h:89
symbol_range symbols() const
Returns the symbol table for the entire bitcode file.
Definition: IRSymtab.h:332
bool isUsed() const
Definition: IRSymtab.h:194
This data structure contains rarely used symbol fields and is optionally referenced by a Symbol...
Definition: IRSymtab.h:118
ArrayRef< T > get(StringRef Symtab) const
Definition: IRSymtab.h:66
This represents a symbol that has been read from a storage::Symbol and possibly a storage::Uncommon...
Definition: IRSymtab.h:162
StringRef getSectionName() const
Definition: IRSymtab.h:223
Range< Uncommon > Uncommons
Definition: IRSymtab.h:145
int getComdatIndex() const
Returns the index into the comdat table (see Reader::getComdatTable()), or -1 if not a comdat member...
Definition: IRSymtab.h:182
bool operator==(const SymbolRef &Other) const
Definition: IRSymtab.h:329
StringRef getSourceFileName() const
Returns the source file path specified at compile time.
Definition: IRSymtab.h:274
StringRef getCOFFLinkerOpts() const
COFF-specific: returns linker options specified in the input file.
Definition: IRSymtab.h:286
std::vector< StringRef > getComdatTable() const
Returns a table with all the comdats used by this file.
Definition: IRSymtab.h:277
Expected< FileContents > readBitcode(const BitcodeFileContents &BFC)
Reads the contents of a bitcode file, creating its irsymtab if necessary.
Definition: IRSymtab.cpp:350
A range adaptor for a pair of iterators.
static bool isWeak(const MCSymbolELF &Sym)
bool isGlobal() const
Definition: IRSymtab.h:201
StringRef getTargetTriple() const
Definition: IRSymtab.h:271
Str Producer
The producer&#39;s version string (LLVM_VERSION_STRING " " LLVM_REVISION).
Definition: IRSymtab.h:140
bool isWeak() const
Definition: IRSymtab.h:191
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:66
SymbolRef(const storage::Symbol *SymI, const storage::Symbol *SymE, const storage::Uncommon *UncI, const Reader *R)
Definition: IRSymtab.h:316
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool isUnnamedAddr() const
Definition: IRSymtab.h:203
This is equivalent to an IR comdat.
Definition: IRSymtab.h:81
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
uint64_t getCommonSize() const
Definition: IRSymtab.h:206
const char SectionName[]
Definition: AMDGPUPTNote.h:24
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
StringRef COFFWeakExternFallbackName
Definition: IRSymtab.h:170
StringRef get(StringRef Strtab) const
Definition: IRSymtab.h:57
Word UncBegin
The index of the first Uncommon for this Module.
Definition: IRSymtab.h:77
This class can be used to read a Symtab and Strtab produced by irsymtab::build.
Definition: IRSymtab.h:228
Str COFFWeakExternFallbackName
COFF-specific: the name of the symbol that a weak external resolves to if not defined.
Definition: IRSymtab.h:123