LLVM  4.0.0
LTO.h
Go to the documentation of this file.
1 //===-LTO.h - LLVM Link Time Optimizer ------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file declares functions and classes used to support LTO. It is intended
11 // to be used both by LTO classes as well as by clients (gold-plugin) that
12 // don't utilize the LTO code generator interfaces.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_LTO_LTO_H
17 #define LLVM_LTO_LTO_H
18 
19 #include "llvm/ADT/MapVector.h"
20 #include "llvm/ADT/StringMap.h"
21 #include "llvm/ADT/StringSet.h"
22 #include "llvm/CodeGen/Analysis.h"
23 #include "llvm/IR/DiagnosticInfo.h"
25 #include "llvm/LTO/Config.h"
26 #include "llvm/Linker/IRMover.h"
28 #include "llvm/Support/thread.h"
31 
32 namespace llvm {
33 
34 class BitcodeModule;
35 class Error;
36 class LLVMContext;
37 class MemoryBufferRef;
38 class Module;
39 class Target;
40 class raw_pwrite_stream;
41 
42 /// Resolve Weak and LinkOnce values in the \p Index. Linkage changes recorded
43 /// in the index and the ThinLTO backends must apply the changes to the Module
44 /// via thinLTOResolveWeakForLinkerModule.
45 ///
46 /// This is done for correctness (if value exported, ensure we always
47 /// emit a copy), and compile-time optimization (allow drop of duplicates).
49  ModuleSummaryIndex &Index,
50  function_ref<bool(GlobalValue::GUID, const GlobalValueSummary *)>
51  isPrevailing,
52  function_ref<void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)>
53  recordNewLinkage);
54 
55 /// Update the linkages in the given \p Index to mark exported values
56 /// as external and non-exported values as internal. The ThinLTO backends
57 /// must apply the changes to the Module via thinLTOInternalizeModule.
59  ModuleSummaryIndex &Index,
60  function_ref<bool(StringRef, GlobalValue::GUID)> isExported);
61 
62 namespace lto {
63 
64 /// Given the original \p Path to an output file, replace any path
65 /// prefix matching \p OldPrefix with \p NewPrefix. Also, create the
66 /// resulting directory if it does not yet exist.
67 std::string getThinLTOOutputFile(const std::string &Path,
68  const std::string &OldPrefix,
69  const std::string &NewPrefix);
70 
71 class LTO;
72 struct SymbolResolution;
73 class ThinBackendProc;
74 
75 /// An input file. This is a wrapper for ModuleSymbolTable that exposes only the
76 /// information that an LTO client should need in order to do symbol resolution.
77 class InputFile {
78  // FIXME: Remove LTO class friendship once we have bitcode symbol tables.
79  friend LTO;
80  InputFile() = default;
81 
82  // FIXME: Remove the LLVMContext once we have bitcode symbol tables.
83  LLVMContext Ctx;
84  struct InputModule;
85  std::vector<InputModule> Mods;
86  ModuleSymbolTable SymTab;
87 
88  std::vector<StringRef> Comdats;
90 
91 public:
92  ~InputFile();
93 
94  /// Create an InputFile.
96 
97  class symbol_iterator;
98 
99  /// This is a wrapper for ArrayRef<ModuleSymbolTable::Symbol>::iterator that
100  /// exposes only the information that an LTO client should need in order to do
101  /// symbol resolution.
102  ///
103  /// This object is ephemeral; it is only valid as long as an iterator obtained
104  /// from symbols() refers to it.
105  class Symbol {
106  friend symbol_iterator;
107  friend LTO;
108 
110  const ModuleSymbolTable &SymTab;
111  const InputFile *File;
112  uint32_t Flags;
113  SmallString<64> Name;
114 
115  bool shouldSkip() {
116  return !(Flags & object::BasicSymbolRef::SF_Global) ||
118  }
119 
120  void skip() {
122  while (I != E) {
123  Flags = SymTab.getSymbolFlags(*I);
124  if (!shouldSkip())
125  break;
126  ++I;
127  }
128  if (I == E)
129  return;
130 
131  Name.clear();
132  {
133  raw_svector_ostream OS(Name);
134  SymTab.printSymbolName(OS, *I);
135  }
136  }
137 
138  bool isGV() const { return I->is<GlobalValue *>(); }
139  GlobalValue *getGV() const { return I->get<GlobalValue *>(); }
140 
141  public:
143  const ModuleSymbolTable &SymTab, const InputFile *File)
144  : I(I), SymTab(SymTab), File(File) {
145  skip();
146  }
147 
148  /// Returns the mangled name of the global.
149  StringRef getName() const { return Name; }
150 
151  uint32_t getFlags() const { return Flags; }
153  if (isGV())
154  return getGV()->getVisibility();
156  }
158  return isGV() && llvm::canBeOmittedFromSymbolTable(getGV());
159  }
160  bool isTLS() const {
161  // FIXME: Expose a thread-local flag for module asm symbols.
162  return isGV() && getGV()->isThreadLocal();
163  }
164 
165  // Returns the index of the comdat this symbol is in or -1 if the symbol
166  // is not in a comdat.
167  // FIXME: We have to return Expected<int> because aliases point to an
168  // arbitrary ConstantExpr and that might not actually be a constant. That
169  // means we might not be able to find what an alias is aliased to and
170  // so find its comdat.
172 
173  uint64_t getCommonSize() const {
175  if (!isGV())
176  return 0;
177  return getGV()->getParent()->getDataLayout().getTypeAllocSize(
178  getGV()->getType()->getElementType());
179  }
180  unsigned getCommonAlignment() const {
182  if (!isGV())
183  return 0;
184  return getGV()->getAlignment();
185  }
186  };
187 
189  Symbol Sym;
190 
191  public:
193  const ModuleSymbolTable &SymTab, const InputFile *File)
194  : Sym(I, SymTab, File) {}
195 
197  ++Sym.I;
198  Sym.skip();
199  return *this;
200  }
201 
203  symbol_iterator I = *this;
204  ++*this;
205  return I;
206  }
207 
208  const Symbol &operator*() const { return Sym; }
209  const Symbol *operator->() const { return &Sym; }
210 
211  bool operator!=(const symbol_iterator &Other) const {
212  return Sym.I != Other.Sym.I;
213  }
214  };
215 
216  /// A range over the symbols in this InputFile.
218  return llvm::make_range(
219  symbol_iterator(SymTab.symbols().begin(), SymTab, this),
220  symbol_iterator(SymTab.symbols().end(), SymTab, this));
221  }
222 
223  /// Returns the path to the InputFile.
224  StringRef getName() const;
225 
226  /// Returns the source file path specified at compile time.
228 
229  // Returns a table with all the comdats used by this file.
230  ArrayRef<StringRef> getComdatTable() const { return Comdats; }
231 
232 private:
233  iterator_range<symbol_iterator> module_symbols(InputModule &IM);
234 };
235 
236 /// This class wraps an output stream for a native object. Most clients should
237 /// just be able to return an instance of this base class from the stream
238 /// callback, but if a client needs to perform some action after the stream is
239 /// written to, that can be done by deriving from this class and overriding the
240 /// destructor.
242 public:
243  NativeObjectStream(std::unique_ptr<raw_pwrite_stream> OS) : OS(std::move(OS)) {}
244  std::unique_ptr<raw_pwrite_stream> OS;
245  virtual ~NativeObjectStream() = default;
246 };
247 
248 /// This type defines the callback to add a native object that is generated on
249 /// the fly.
250 ///
251 /// Stream callbacks must be thread safe.
252 typedef std::function<std::unique_ptr<NativeObjectStream>(unsigned Task)>
254 
255 /// This is the type of a native object cache. To request an item from the
256 /// cache, pass a unique string as the Key. For hits, the cached file will be
257 /// added to the link and this function will return AddStreamFn(). For misses,
258 /// the cache will return a stream callback which must be called at most once to
259 /// produce content for the stream. The native object stream produced by the
260 /// stream callback will add the file to the link after the stream is written
261 /// to.
262 ///
263 /// Clients generally look like this:
264 ///
265 /// if (AddStreamFn AddStream = Cache(Task, Key))
266 /// ProduceContent(AddStream);
267 typedef std::function<AddStreamFn(unsigned Task, StringRef Key)>
269 
270 /// A ThinBackend defines what happens after the thin-link phase during ThinLTO.
271 /// The details of this type definition aren't important; clients can only
272 /// create a ThinBackend using one of the create*ThinBackend() functions below.
273 typedef std::function<std::unique_ptr<ThinBackendProc>(
274  Config &C, ModuleSummaryIndex &CombinedIndex,
275  StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
276  AddStreamFn AddStream, NativeObjectCache Cache)>
278 
279 /// This ThinBackend runs the individual backend jobs in-process.
280 ThinBackend createInProcessThinBackend(unsigned ParallelismLevel);
281 
282 /// This ThinBackend writes individual module indexes to files, instead of
283 /// running the individual backend jobs. This backend is for distributed builds
284 /// where separate processes will invoke the real backends.
285 ///
286 /// To find the path to write the index to, the backend checks if the path has a
287 /// prefix of OldPrefix; if so, it replaces that prefix with NewPrefix. It then
288 /// appends ".thinlto.bc" and writes the index to that path. If
289 /// ShouldEmitImportsFiles is true it also writes a list of imported files to a
290 /// similar path with ".imports" appended instead.
291 ThinBackend createWriteIndexesThinBackend(std::string OldPrefix,
292  std::string NewPrefix,
293  bool ShouldEmitImportsFiles,
294  std::string LinkedObjectsFile);
295 
296 /// This class implements a resolution-based interface to LLVM's LTO
297 /// functionality. It supports regular LTO, parallel LTO code generation and
298 /// ThinLTO. You can use it from a linker in the following way:
299 /// - Set hooks and code generation options (see lto::Config struct defined in
300 /// Config.h), and use the lto::Config object to create an lto::LTO object.
301 /// - Create lto::InputFile objects using lto::InputFile::create(), then use
302 /// the symbols() function to enumerate its symbols and compute a resolution
303 /// for each symbol (see SymbolResolution below).
304 /// - After the linker has visited each input file (and each regular object
305 /// file) and computed a resolution for each symbol, take each lto::InputFile
306 /// and pass it and an array of symbol resolutions to the add() function.
307 /// - Call the getMaxTasks() function to get an upper bound on the number of
308 /// native object files that LTO may add to the link.
309 /// - Call the run() function. This function will use the supplied AddStream
310 /// and Cache functions to add up to getMaxTasks() native object files to
311 /// the link.
312 class LTO {
313  friend InputFile;
314 
315 public:
316  /// Create an LTO object. A default constructed LTO object has a reasonable
317  /// production configuration, but you can customize it by passing arguments to
318  /// this constructor.
319  /// FIXME: We do currently require the DiagHandler field to be set in Conf.
320  /// Until that is fixed, a Config argument is required.
321  LTO(Config Conf, ThinBackend Backend = nullptr,
322  unsigned ParallelCodeGenParallelismLevel = 1);
323  ~LTO();
324 
325  /// Add an input file to the LTO link, using the provided symbol resolutions.
326  /// The symbol resolutions must appear in the enumeration order given by
327  /// InputFile::symbols().
328  Error add(std::unique_ptr<InputFile> Obj, ArrayRef<SymbolResolution> Res);
329 
330  /// Returns an upper bound on the number of tasks that the client may expect.
331  /// This may only be called after all IR object files have been added. For a
332  /// full description of tasks see LTOBackend.h.
333  unsigned getMaxTasks() const;
334 
335  /// Runs the LTO pipeline. This function calls the supplied AddStream
336  /// function to add native object files to the link.
337  ///
338  /// The Cache parameter is optional. If supplied, it will be used to cache
339  /// native object files and add them to the link.
340  ///
341  /// The client will receive at most one callback (via either AddStream or
342  /// Cache) for each task identifier.
343  Error run(AddStreamFn AddStream, NativeObjectCache Cache = nullptr);
344 
345 private:
346  Config Conf;
347 
348  struct RegularLTOState {
349  RegularLTOState(unsigned ParallelCodeGenParallelismLevel, Config &Conf);
351  uint64_t Size = 0;
352  unsigned Align = 0;
353  /// Record if at least one instance of the common was marked as prevailing
354  bool Prevailing = false;
355  };
356  std::map<std::string, CommonResolution> Commons;
357 
358  unsigned ParallelCodeGenParallelismLevel;
359  LTOLLVMContext Ctx;
360  bool HasModule = false;
361  std::unique_ptr<Module> CombinedModule;
362  std::unique_ptr<IRMover> Mover;
363  } RegularLTO;
364 
365  struct ThinLTOState {
366  ThinLTOState(ThinBackend Backend);
367 
368  ThinBackend Backend;
369  ModuleSummaryIndex CombinedIndex;
371  DenseMap<GlobalValue::GUID, StringRef> PrevailingModuleForGUID;
372  } ThinLTO;
373 
374  // The global resolution for a particular (mangled) symbol name. This is in
375  // particular necessary to track whether each symbol can be internalized.
376  // Because any input file may introduce a new cross-partition reference, we
377  // cannot make any final internalization decisions until all input files have
378  // been added and the client has called run(). During run() we apply
379  // internalization decisions either directly to the module (for regular LTO)
380  // or to the combined index (for ThinLTO).
381  struct GlobalResolution {
382  /// The unmangled name of the global.
383  std::string IRName;
384 
385  /// Keep track if the symbol is visible outside of ThinLTO (i.e. in
386  /// either a regular object or the regular LTO partition).
387  bool VisibleOutsideThinLTO = false;
388 
389  bool UnnamedAddr = true;
390 
391  /// This field keeps track of the partition number of this global. The
392  /// regular LTO object is partition 0, while each ThinLTO object has its own
393  /// partition number from 1 onwards.
394  ///
395  /// Any global that is defined or used by more than one partition, or that
396  /// is referenced externally, may not be internalized.
397  ///
398  /// Partitions generally have a one-to-one correspondence with tasks, except
399  /// that we use partition 0 for all parallel LTO code generation partitions.
400  /// Any partitioning of the combined LTO object is done internally by the
401  /// LTO backend.
402  unsigned Partition = Unknown;
403 
404  /// Special partition numbers.
405  enum : unsigned {
406  /// A partition number has not yet been assigned to this global.
407  Unknown = -1u,
408 
409  /// This global is either used by more than one partition or has an
410  /// external reference, and therefore cannot be internalized.
411  External = -2u,
412 
413  /// The RegularLTO partition
414  RegularLTO = 0,
415  };
416  };
417 
418  // Global mapping from mangled symbol names to resolutions.
419  StringMap<GlobalResolution> GlobalResolutions;
420 
421  void addSymbolToGlobalRes(SmallPtrSet<GlobalValue *, 8> &Used,
422  const InputFile::Symbol &Sym, SymbolResolution Res,
423  unsigned Partition);
424 
425  // These functions take a range of symbol resolutions [ResI, ResE) and consume
426  // the resolutions used by a single input module by incrementing ResI. After
427  // these functions return, [ResI, ResE) will refer to the resolution range for
428  // the remaining modules in the InputFile.
429  Error addModule(InputFile &Input, InputFile::InputModule &IM,
430  const SymbolResolution *&ResI, const SymbolResolution *ResE);
431  Error addRegularLTO(BitcodeModule BM, const SymbolResolution *&ResI,
432  const SymbolResolution *ResE);
433  Error addThinLTO(BitcodeModule BM, Module &M,
434  iterator_range<InputFile::symbol_iterator> Syms,
435  const SymbolResolution *&ResI, const SymbolResolution *ResE);
436 
437  Error runRegularLTO(AddStreamFn AddStream);
438  Error runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
439  bool HasRegularLTO);
440 
441  mutable bool CalledGetMaxTasks = false;
442 };
443 
444 /// The resolution for a symbol. The linker must provide a SymbolResolution for
445 /// each global symbol based on its internal resolution of that symbol.
449  }
450  /// The linker has chosen this definition of the symbol.
451  unsigned Prevailing : 1;
452 
453  /// The definition of this symbol is unpreemptable at runtime and is known to
454  /// be in this linkage unit.
456 
457  /// The definition of this symbol is visible outside of the LTO unit.
458  unsigned VisibleToRegularObj : 1;
459 };
460 
461 } // namespace lto
462 } // namespace llvm
463 
464 #endif
NativeObjectStream(std::unique_ptr< raw_pwrite_stream > OS)
Definition: LTO.h:243
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:219
unsigned Prevailing
The linker has chosen this definition of the symbol.
Definition: LTO.h:451
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:465
bool Prevailing
Record if at least one instance of the common was marked as prevailing.
Definition: LTO.h:354
This is a wrapper for ArrayRef<ModuleSymbolTable::Symbol>::iterator that exposes only the information...
Definition: LTO.h:105
bool canBeOmittedFromSymbolTable(const GlobalValue *GV)
GlobalValue::VisibilityTypes getVisibility() const
Definition: LTO.h:152
iterator_range< symbol_iterator > symbols()
A range over the symbols in this InputFile.
Definition: LTO.h:217
bool operator!=(const symbol_iterator &Other) const
Definition: LTO.h:211
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:490
The resolution for a symbol.
Definition: LTO.h:446
This class implements a map that also provides access to all stored values in a deterministic order...
Definition: MapVector.h:32
static Expected< std::unique_ptr< InputFile > > create(MemoryBufferRef Object)
Create an InputFile.
Definition: LTO.cpp:234
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:905
symbol_iterator(ArrayRef< ModuleSymbolTable::Symbol >::iterator I, const ModuleSymbolTable &SymTab, const InputFile *File)
Definition: LTO.h:192
std::unique_ptr< raw_pwrite_stream > OS
Definition: LTO.h:244
std::function< std::unique_ptr< NativeObjectStream >unsigned Task)> AddStreamFn
This type defines the callback to add a native object that is generated on the fly.
Definition: LTO.h:253
Tagged union holding either a T or a Error.
Expected< int > getComdatIndex() const
Definition: LTO.cpp:278
virtual ~NativeObjectStream()=default
unsigned getCommonAlignment() const
Definition: LTO.h:180
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:63
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
An input file.
Definition: LTO.h:77
This class implements a resolution-based interface to LLVM's LTO functionality.
Definition: LTO.h:312
Class to hold module path string table and global value map, and encapsulate methods for operating on...
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
Error add(std::unique_ptr< InputFile > Obj, ArrayRef< SymbolResolution > Res)
Add an input file to the LTO link, using the provided symbol resolutions.
Definition: LTO.cpp:378
StringRef getSourceFileName() const
Returns the source file path specified at compile time.
Definition: LTO.cpp:297
std::function< AddStreamFn(unsigned Task, StringRef Key)> NativeObjectCache
This is the type of a native object cache.
Definition: LTO.h:268
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
This class wraps an output stream for a native object.
Definition: LTO.h:241
ThinBackend createWriteIndexesThinBackend(std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles, std::string LinkedObjectsFile)
This ThinBackend writes individual module indexes to files, instead of running the individual backend...
Definition: LTO.cpp:822
bool isTLS() const
Definition: LTO.h:160
LTO configuration.
Definition: Config.h:35
const Symbol * operator->() const
Definition: LTO.h:209
StringRef getName() const
Returns the path to the InputFile.
Definition: LTO.cpp:293
StringRef getName() const
Returns the mangled name of the global.
Definition: LTO.h:149
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:232
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
std::function< std::unique_ptr< ThinBackendProc > Config &C, ModuleSummaryIndex &CombinedIndex, StringMap< GVSummaryMapTy > &ModuleToDefinedGVSummaries, AddStreamFn AddStream, NativeObjectCache Cache)> ThinBackend
A ThinBackend defines what happens after the thin-link phase during ThinLTO.
Definition: LTO.h:277
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:408
bool canBeOmittedFromSymbolTable() const
Definition: LTO.h:157
unsigned getMaxTasks() const
Returns an upper bound on the number of tasks that the client may expect.
Definition: LTO.cpp:530
static const char * Target
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
A range adaptor for a pair of iterators.
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
uint32_t getSymbolFlags(Symbol S) const
ThinBackend createInProcessThinBackend(unsigned ParallelismLevel)
This ThinBackend runs the individual backend jobs in-process.
Definition: LTO.cpp:732
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
LTO(Config Conf, ThinBackend Backend=nullptr, unsigned ParallelCodeGenParallelismLevel=1)
Create an LTO object.
Definition: LTO.cpp:319
void thinLTOResolveWeakForLinkerInIndex(ModuleSummaryIndex &Index, function_ref< bool(GlobalValue::GUID, const GlobalValueSummary *)> isPrevailing, function_ref< void(StringRef, GlobalValue::GUID, GlobalValue::LinkageTypes)> recordNewLinkage)
Resolve Weak and LinkOnce values in the Index.
Definition: LTO.cpp:182
ArrayRef< StringRef > getComdatTable() const
Definition: LTO.h:230
#define I(x, y, z)
Definition: MD5.cpp:54
ArrayRef< Symbol > symbols() const
Error run(AddStreamFn AddStream, NativeObjectCache Cache=nullptr)
Runs the LTO pipeline.
Definition: LTO.cpp:535
unsigned VisibleToRegularObj
The definition of this symbol is visible outside of the LTO unit.
Definition: LTO.h:458
void printSymbolName(raw_ostream &OS, Symbol S) const
uint32_t getFlags() const
Definition: LTO.h:151
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
unsigned getAlignment() const
Definition: Globals.cpp:72
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const Symbol & operator*() const
Definition: LTO.h:208
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
symbol_iterator & operator++()
Definition: LTO.h:196
Lightweight error class with error context and mandatory checking.
A derived class of LLVMContext that initializes itself according to a given Config object...
Definition: Config.h:164
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
uint64_t getCommonSize() const
Definition: LTO.h:173
unsigned FinalDefinitionInLinkageUnit
The definition of this symbol is unpreemptable at runtime and is known to be in this linkage unit...
Definition: LTO.h:455
Symbol(ArrayRef< ModuleSymbolTable::Symbol >::iterator I, const ModuleSymbolTable &SymTab, const InputFile *File)
Definition: LTO.h:142
std::string getThinLTOOutputFile(const std::string &Path, const std::string &OldPrefix, const std::string &NewPrefix)
Given the original Path to an output file, replace any path prefix matching OldPrefix with NewPrefix...
Definition: LTO.cpp:745
void thinLTOInternalizeAndPromoteInIndex(ModuleSummaryIndex &Index, function_ref< bool(StringRef, GlobalValue::GUID)> isExported)
Update the linkages in the given Index to mark exported values as external and non-exported values as...
Definition: LTO.cpp:216
symbol_iterator operator++(int)
Definition: LTO.h:202