clang  8.0.0svn
ExternalASTSource.h
Go to the documentation of this file.
1 //===- ExternalASTSource.h - Abstract External AST Interface ----*- 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 defines the ExternalASTSource interface, which enables
11 // construction of AST nodes from some external source.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_AST_EXTERNALASTSOURCE_H
16 #define LLVM_CLANG_AST_EXTERNALASTSOURCE_H
17 
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/DeclBase.h"
20 #include "clang/Basic/LLVM.h"
21 #include "clang/Basic/Module.h"
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/IntrusiveRefCntPtr.h"
25 #include "llvm/ADT/Optional.h"
26 #include "llvm/ADT/PointerUnion.h"
27 #include "llvm/ADT/STLExtras.h"
28 #include "llvm/ADT/SmallVector.h"
29 #include "llvm/ADT/StringRef.h"
30 #include "llvm/ADT/iterator.h"
31 #include "llvm/Support/PointerLikeTypeTraits.h"
32 #include <cassert>
33 #include <cstddef>
34 #include <cstdint>
35 #include <iterator>
36 #include <string>
37 #include <utility>
38 
39 namespace clang {
40 
41 class ASTConsumer;
42 class ASTContext;
43 class CXXBaseSpecifier;
44 class CXXCtorInitializer;
45 class CXXRecordDecl;
46 class DeclarationName;
47 class FieldDecl;
48 class IdentifierInfo;
49 class NamedDecl;
50 class ObjCInterfaceDecl;
51 class RecordDecl;
52 class Selector;
53 class Stmt;
54 class TagDecl;
55 
56 /// Abstract interface for external sources of AST nodes.
57 ///
58 /// External AST sources provide AST nodes constructed from some
59 /// external source, such as a precompiled header. External AST
60 /// sources can resolve types and declarations from abstract IDs into
61 /// actual type and declaration nodes, and read parts of declaration
62 /// contexts.
63 class ExternalASTSource : public RefCountedBase<ExternalASTSource> {
64  friend class ExternalSemaSource;
65 
66  /// Generation number for this external AST source. Must be increased
67  /// whenever we might have added new redeclarations for existing decls.
68  uint32_t CurrentGeneration = 0;
69 
70  /// Whether this AST source also provides information for
71  /// semantic analysis.
72  bool SemaSource = false;
73 
74 public:
75  ExternalASTSource() = default;
76  virtual ~ExternalASTSource();
77 
78  /// RAII class for safely pairing a StartedDeserializing call
79  /// with FinishedDeserializing.
80  class Deserializing {
81  ExternalASTSource *Source;
82 
83  public:
84  explicit Deserializing(ExternalASTSource *source) : Source(source) {
85  assert(Source);
86  Source->StartedDeserializing();
87  }
88 
90  Source->FinishedDeserializing();
91  }
92  };
93 
94  /// Get the current generation of this AST source. This number
95  /// is incremented each time the AST source lazily extends an existing
96  /// entity.
97  uint32_t getGeneration() const { return CurrentGeneration; }
98 
99  /// Resolve a declaration ID into a declaration, potentially
100  /// building a new declaration.
101  ///
102  /// This method only needs to be implemented if the AST source ever
103  /// passes back decl sets as VisibleDeclaration objects.
104  ///
105  /// The default implementation of this method is a no-op.
106  virtual Decl *GetExternalDecl(uint32_t ID);
107 
108  /// Resolve a selector ID into a selector.
109  ///
110  /// This operation only needs to be implemented if the AST source
111  /// returns non-zero for GetNumKnownSelectors().
112  ///
113  /// The default implementation of this method is a no-op.
114  virtual Selector GetExternalSelector(uint32_t ID);
115 
116  /// Returns the number of selectors known to the external AST
117  /// source.
118  ///
119  /// The default implementation of this method is a no-op.
120  virtual uint32_t GetNumExternalSelectors();
121 
122  /// Resolve the offset of a statement in the decl stream into
123  /// a statement.
124  ///
125  /// This operation is meant to be used via a LazyOffsetPtr. It only
126  /// needs to be implemented if the AST source uses methods like
127  /// FunctionDecl::setLazyBody when building decls.
128  ///
129  /// The default implementation of this method is a no-op.
130  virtual Stmt *GetExternalDeclStmt(uint64_t Offset);
131 
132  /// Resolve the offset of a set of C++ constructor initializers in
133  /// the decl stream into an array of initializers.
134  ///
135  /// The default implementation of this method is a no-op.
136  virtual CXXCtorInitializer **GetExternalCXXCtorInitializers(uint64_t Offset);
137 
138  /// Resolve the offset of a set of C++ base specifiers in the decl
139  /// stream into an array of specifiers.
140  ///
141  /// The default implementation of this method is a no-op.
142  virtual CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset);
143 
144  /// Update an out-of-date identifier.
146 
147  /// Find all declarations with the given name in the given context,
148  /// and add them to the context by calling SetExternalVisibleDeclsForName
149  /// or SetNoExternalVisibleDeclsForName.
150  /// \return \c true if any declarations might have been found, \c false if
151  /// we definitely have no declarations with tbis name.
152  ///
153  /// The default implementation of this method is a no-op returning \c false.
154  virtual bool
156 
157  /// Ensures that the table of all visible declarations inside this
158  /// context is up to date.
159  ///
160  /// The default implementation of this function is a no-op.
161  virtual void completeVisibleDeclsMap(const DeclContext *DC);
162 
163  /// Retrieve the module that corresponds to the given module ID.
164  virtual Module *getModule(unsigned ID) { return nullptr; }
165 
166  /// Determine whether D comes from a PCH which was built with a corresponding
167  /// object file.
168  virtual bool DeclIsFromPCHWithObjectFile(const Decl *D) { return false; }
169 
170  /// Abstracts clang modules and precompiled header files and holds
171  /// everything needed to generate debug info for an imported module
172  /// or PCH.
174  StringRef PCHModuleName;
175  StringRef Path;
176  StringRef ASTFile;
177  ASTFileSignature Signature;
178  const Module *ClangModule = nullptr;
179 
180  public:
181  ASTSourceDescriptor() = default;
182  ASTSourceDescriptor(StringRef Name, StringRef Path, StringRef ASTFile,
183  ASTFileSignature Signature)
184  : PCHModuleName(std::move(Name)), Path(std::move(Path)),
185  ASTFile(std::move(ASTFile)), Signature(Signature) {}
186  ASTSourceDescriptor(const Module &M);
187 
188  std::string getModuleName() const;
189  StringRef getPath() const { return Path; }
190  StringRef getASTFile() const { return ASTFile; }
191  ASTFileSignature getSignature() const { return Signature; }
192  const Module *getModuleOrNull() const { return ClangModule; }
193  };
194 
195  /// Return a descriptor for the corresponding module, if one exists.
197 
199 
200  virtual ExtKind hasExternalDefinitions(const Decl *D);
201 
202  /// Finds all declarations lexically contained within the given
203  /// DeclContext, after applying an optional filter predicate.
204  ///
205  /// \param IsKindWeWant a predicate function that returns true if the passed
206  /// declaration kind is one we are looking for.
207  ///
208  /// The default implementation of this method is a no-op.
209  virtual void
211  llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
213 
214  /// Finds all declarations lexically contained within the given
215  /// DeclContext.
217  SmallVectorImpl<Decl *> &Result) {
218  FindExternalLexicalDecls(DC, [](Decl::Kind) { return true; }, Result);
219  }
220 
221  /// Get the decls that are contained in a file in the Offset/Length
222  /// range. \p Length can be 0 to indicate a point at \p Offset instead of
223  /// a range.
224  virtual void FindFileRegionDecls(FileID File, unsigned Offset,
225  unsigned Length,
226  SmallVectorImpl<Decl *> &Decls);
227 
228  /// Gives the external AST source an opportunity to complete
229  /// the redeclaration chain for a declaration. Called each time we
230  /// need the most recent declaration of a declaration after the
231  /// generation count is incremented.
232  virtual void CompleteRedeclChain(const Decl *D);
233 
234  /// Gives the external AST source an opportunity to complete
235  /// an incomplete type.
236  virtual void CompleteType(TagDecl *Tag);
237 
238  /// Gives the external AST source an opportunity to complete an
239  /// incomplete Objective-C class.
240  ///
241  /// This routine will only be invoked if the "externally completed" bit is
242  /// set on the ObjCInterfaceDecl via the function
243  /// \c ObjCInterfaceDecl::setExternallyCompleted().
244  virtual void CompleteType(ObjCInterfaceDecl *Class);
245 
246  /// Loads comment ranges.
247  virtual void ReadComments();
248 
249  /// Notify ExternalASTSource that we started deserialization of
250  /// a decl or type so until FinishedDeserializing is called there may be
251  /// decls that are initializing. Must be paired with FinishedDeserializing.
252  ///
253  /// The default implementation of this method is a no-op.
254  virtual void StartedDeserializing();
255 
256  /// Notify ExternalASTSource that we finished the deserialization of
257  /// a decl or type. Must be paired with StartedDeserializing.
258  ///
259  /// The default implementation of this method is a no-op.
260  virtual void FinishedDeserializing();
261 
262  /// Function that will be invoked when we begin parsing a new
263  /// translation unit involving this external AST source.
264  ///
265  /// The default implementation of this method is a no-op.
266  virtual void StartTranslationUnit(ASTConsumer *Consumer);
267 
268  /// Print any statistics that have been gathered regarding
269  /// the external AST source.
270  ///
271  /// The default implementation of this method is a no-op.
272  virtual void PrintStats();
273 
274  /// Perform layout on the given record.
275  ///
276  /// This routine allows the external AST source to provide an specific
277  /// layout for a record, overriding the layout that would normally be
278  /// constructed. It is intended for clients who receive specific layout
279  /// details rather than source code (such as LLDB). The client is expected
280  /// to fill in the field offsets, base offsets, virtual base offsets, and
281  /// complete object size.
282  ///
283  /// \param Record The record whose layout is being requested.
284  ///
285  /// \param Size The final size of the record, in bits.
286  ///
287  /// \param Alignment The final alignment of the record, in bits.
288  ///
289  /// \param FieldOffsets The offset of each of the fields within the record,
290  /// expressed in bits. All of the fields must be provided with offsets.
291  ///
292  /// \param BaseOffsets The offset of each of the direct, non-virtual base
293  /// classes. If any bases are not given offsets, the bases will be laid
294  /// out according to the ABI.
295  ///
296  /// \param VirtualBaseOffsets The offset of each of the virtual base classes
297  /// (either direct or not). If any bases are not given offsets, the bases will be laid
298  /// out according to the ABI.
299  ///
300  /// \returns true if the record layout was provided, false otherwise.
301  virtual bool layoutRecordType(
302  const RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
303  llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
304  llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
305  llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets);
306 
307  //===--------------------------------------------------------------------===//
308  // Queries for performance analysis.
309  //===--------------------------------------------------------------------===//
310 
312  size_t malloc_bytes;
313  size_t mmap_bytes;
314 
315  MemoryBufferSizes(size_t malloc_bytes, size_t mmap_bytes)
316  : malloc_bytes(malloc_bytes), mmap_bytes(mmap_bytes) {}
317  };
318 
319  /// Return the amount of memory used by memory buffers, breaking down
320  /// by heap-backed versus mmap'ed memory.
322  MemoryBufferSizes sizes(0, 0);
323  getMemoryBufferSizes(sizes);
324  return sizes;
325  }
326 
327  virtual void getMemoryBufferSizes(MemoryBufferSizes &sizes) const;
328 
329 protected:
332  DeclarationName Name,
333  ArrayRef<NamedDecl*> Decls);
334 
337  DeclarationName Name);
338 
339  /// Increment the current generation.
340  uint32_t incrementGeneration(ASTContext &C);
341 };
342 
343 /// A lazy pointer to an AST node (of base type T) that resides
344 /// within an external AST source.
345 ///
346 /// The AST node is identified within the external AST source by a
347 /// 63-bit offset, and can be retrieved via an operation on the
348 /// external AST source itself.
349 template<typename T, typename OffsT, T* (ExternalASTSource::*Get)(OffsT Offset)>
351  /// Either a pointer to an AST node or the offset within the
352  /// external AST source where the AST node can be found.
353  ///
354  /// If the low bit is clear, a pointer to the AST node. If the low
355  /// bit is set, the upper 63 bits are the offset.
356  mutable uint64_t Ptr = 0;
357 
358 public:
359  LazyOffsetPtr() = default;
360  explicit LazyOffsetPtr(T *Ptr) : Ptr(reinterpret_cast<uint64_t>(Ptr)) {}
361 
362  explicit LazyOffsetPtr(uint64_t Offset) : Ptr((Offset << 1) | 0x01) {
363  assert((Offset << 1 >> 1) == Offset && "Offsets must require < 63 bits");
364  if (Offset == 0)
365  Ptr = 0;
366  }
367 
369  this->Ptr = reinterpret_cast<uint64_t>(Ptr);
370  return *this;
371  }
372 
374  assert((Offset << 1 >> 1) == Offset && "Offsets must require < 63 bits");
375  if (Offset == 0)
376  Ptr = 0;
377  else
378  Ptr = (Offset << 1) | 0x01;
379 
380  return *this;
381  }
382 
383  /// Whether this pointer is non-NULL.
384  ///
385  /// This operation does not require the AST node to be deserialized.
386  explicit operator bool() const { return Ptr != 0; }
387 
388  /// Whether this pointer is non-NULL.
389  ///
390  /// This operation does not require the AST node to be deserialized.
391  bool isValid() const { return Ptr != 0; }
392 
393  /// Whether this pointer is currently stored as an offset.
394  bool isOffset() const { return Ptr & 0x01; }
395 
396  /// Retrieve the pointer to the AST node that this lazy pointer points to.
397  ///
398  /// \param Source the external AST source.
399  ///
400  /// \returns a pointer to the AST node.
401  T* get(ExternalASTSource *Source) const {
402  if (isOffset()) {
403  assert(Source &&
404  "Cannot deserialize a lazy pointer without an AST source");
405  Ptr = reinterpret_cast<uint64_t>((Source->*Get)(Ptr >> 1));
406  }
407  return reinterpret_cast<T*>(Ptr);
408  }
409 };
410 
411 /// A lazy value (of type T) that is within an AST node of type Owner,
412 /// where the value might change in later generations of the external AST
413 /// source.
414 template<typename Owner, typename T, void (ExternalASTSource::*Update)(Owner)>
416  /// A cache of the value of this pointer, in the most recent generation in
417  /// which we queried it.
418  struct LazyData {
420  uint32_t LastGeneration = 0;
422 
424  : ExternalSource(Source), LastValue(Value) {}
425  };
426 
427  // Our value is represented as simply T if there is no external AST source.
428  using ValueType = llvm::PointerUnion<T, LazyData*>;
430 
432 
433  // Defined in ASTContext.h
434  static ValueType makeValue(const ASTContext &Ctx, T Value);
435 
436 public:
437  explicit LazyGenerationalUpdatePtr(const ASTContext &Ctx, T Value = T())
438  : Value(makeValue(Ctx, Value)) {}
439 
440  /// Create a pointer that is not potentially updated by later generations of
441  /// the external AST source.
442  enum NotUpdatedTag { NotUpdated };
444  : Value(Value) {}
445 
446  /// Forcibly set this pointer (which must be lazy) as needing updates.
447  void markIncomplete() {
448  Value.template get<LazyData *>()->LastGeneration = 0;
449  }
450 
451  /// Set the value of this pointer, in the current generation.
452  void set(T NewValue) {
453  if (auto *LazyVal = Value.template dyn_cast<LazyData *>()) {
454  LazyVal->LastValue = NewValue;
455  return;
456  }
457  Value = NewValue;
458  }
459 
460  /// Set the value of this pointer, for this and all future generations.
461  void setNotUpdated(T NewValue) { Value = NewValue; }
462 
463  /// Get the value of this pointer, updating its owner if necessary.
464  T get(Owner O) {
465  if (auto *LazyVal = Value.template dyn_cast<LazyData *>()) {
466  if (LazyVal->LastGeneration != LazyVal->ExternalSource->getGeneration()) {
467  LazyVal->LastGeneration = LazyVal->ExternalSource->getGeneration();
468  (LazyVal->ExternalSource->*Update)(O);
469  }
470  return LazyVal->LastValue;
471  }
472  return Value.template get<T>();
473  }
474 
475  /// Get the most recently computed value of this pointer without updating it.
476  T getNotUpdated() const {
477  if (auto *LazyVal = Value.template dyn_cast<LazyData *>())
478  return LazyVal->LastValue;
479  return Value.template get<T>();
480  }
481 
482  void *getOpaqueValue() { return Value.getOpaqueValue(); }
484  return LazyGenerationalUpdatePtr(ValueType::getFromOpaqueValue(Ptr));
485  }
486 };
487 
488 } // namespace clang
489 
490 /// Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be
491 /// placed into a PointerUnion.
492 namespace llvm {
493 
494 template<typename Owner, typename T,
495  void (clang::ExternalASTSource::*Update)(Owner)>
499 
500  static void *getAsVoidPointer(Ptr P) { return P.getOpaqueValue(); }
501  static Ptr getFromVoidPointer(void *P) { return Ptr::getFromOpaqueValue(P); }
502 
503  enum {
505  };
506 };
507 
508 } // namespace llvm
509 
510 namespace clang {
511 
512 /// Represents a lazily-loaded vector of data.
513 ///
514 /// The lazily-loaded vector of data contains data that is partially loaded
515 /// from an external source and partially added by local translation. The
516 /// items loaded from the external source are loaded lazily, when needed for
517 /// iteration over the complete vector.
518 template<typename T, typename Source,
519  void (Source::*Loader)(SmallVectorImpl<T>&),
520  unsigned LoadedStorage = 2, unsigned LocalStorage = 4>
521 class LazyVector {
524 
525 public:
526  /// Iteration over the elements in the vector.
527  ///
528  /// In a complete iteration, the iterator walks the range [-M, N),
529  /// where negative values are used to indicate elements
530  /// loaded from the external source while non-negative values are used to
531  /// indicate elements added via \c push_back().
532  /// However, to provide iteration in source order (for, e.g., chained
533  /// precompiled headers), dereferencing the iterator flips the negative
534  /// values (corresponding to loaded entities), so that position -M
535  /// corresponds to element 0 in the loaded entities vector, position -M+1
536  /// corresponds to element 1 in the loaded entities vector, etc. This
537  /// gives us a reasonably efficient, source-order walk.
538  ///
539  /// We define this as a wrapping iterator around an int. The
540  /// iterator_adaptor_base class forwards the iterator methods to basic integer
541  /// arithmetic.
542  class iterator
543  : public llvm::iterator_adaptor_base<
544  iterator, int, std::random_access_iterator_tag, T, int, T *, T &> {
545  friend class LazyVector;
546 
547  LazyVector *Self;
548 
549  iterator(LazyVector *Self, int Position)
550  : iterator::iterator_adaptor_base(Position), Self(Self) {}
551 
552  bool isLoaded() const { return this->I < 0; }
553 
554  public:
555  iterator() : iterator(nullptr, 0) {}
556 
557  typename iterator::reference operator*() const {
558  if (isLoaded())
559  return Self->Loaded.end()[this->I];
560  return Self->Local.begin()[this->I];
561  }
562  };
563 
564  iterator begin(Source *source, bool LocalOnly = false) {
565  if (LocalOnly)
566  return iterator(this, 0);
567 
568  if (source)
569  (source->*Loader)(Loaded);
570  return iterator(this, -(int)Loaded.size());
571  }
572 
573  iterator end() {
574  return iterator(this, Local.size());
575  }
576 
577  void push_back(const T& LocalValue) {
578  Local.push_back(LocalValue);
579  }
580 
581  void erase(iterator From, iterator To) {
582  if (From.isLoaded() && To.isLoaded()) {
583  Loaded.erase(&*From, &*To);
584  return;
585  }
586 
587  if (From.isLoaded()) {
588  Loaded.erase(&*From, Loaded.end());
589  From = begin(nullptr, true);
590  }
591 
592  Local.erase(&*From, &*To);
593  }
594 };
595 
596 /// A lazy pointer to a statement.
597 using LazyDeclStmtPtr =
599 
600 /// A lazy pointer to a declaration.
601 using LazyDeclPtr =
603 
604 /// A lazy pointer to a set of CXXCtorInitializers.
606  LazyOffsetPtr<CXXCtorInitializer *, uint64_t,
608 
609 /// A lazy pointer to a set of CXXBaseSpecifiers.
613 
614 } // namespace clang
615 
616 #endif // LLVM_CLANG_AST_EXTERNALASTSOURCE_H
Smart pointer class that efficiently represents Objective-C method names.
virtual Decl * GetExternalDecl(uint32_t ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
virtual void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl *> &Result)
Finds all declarations lexically contained within the given DeclContext, after applying an optional f...
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
Represents a lazily-loaded vector of data.
void setNotUpdated(T NewValue)
Set the value of this pointer, for this and all future generations.
LazyData(ExternalASTSource *Source, T Value)
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
Stmt - This represents one statement.
Definition: Stmt.h:66
Defines the clang::Module class, which describes a module in the source code.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
StringRef P
virtual uint32_t GetNumExternalSelectors()
Returns the number of selectors known to the external AST source.
virtual bool layoutRecordType(const RecordDecl *Record, uint64_t &Size, uint64_t &Alignment, llvm::DenseMap< const FieldDecl *, uint64_t > &FieldOffsets, llvm::DenseMap< const CXXRecordDecl *, CharUnits > &BaseOffsets, llvm::DenseMap< const CXXRecordDecl *, CharUnits > &VirtualBaseOffsets)
Perform layout on the given record.
NotUpdatedTag
Create a pointer that is not potentially updated by later generations of the external AST source...
virtual void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl *> &Decls)
Get the decls that are contained in a file in the Offset/Length range.
LazyOffsetPtr & operator=(uint64_t Offset)
virtual bool DeclIsFromPCHWithObjectFile(const Decl *D)
Determine whether D comes from a PCH which was built with a corresponding object file.
virtual void PrintStats()
Print any statistics that have been gathered regarding the external AST source.
Deserializing(ExternalASTSource *source)
virtual void CompleteRedeclChain(const Decl *D)
Gives the external AST source an opportunity to complete the redeclaration chain for a declaration...
virtual Selector GetExternalSelector(uint32_t ID)
Resolve a selector ID into a selector.
virtual void StartedDeserializing()
Notify ExternalASTSource that we started deserialization of a decl or type so until FinishedDeseriali...
iterator begin(Source *source, bool LocalOnly=false)
Represents a struct/union/class.
Definition: Decl.h:3572
void FindExternalLexicalDecls(const DeclContext *DC, SmallVectorImpl< Decl *> &Result)
Finds all declarations lexically contained within the given DeclContext.
One of these records is kept for each identifier that is lexed.
static DeclContextLookupResult SetExternalVisibleDeclsForName(const DeclContext *DC, DeclarationName Name, ArrayRef< NamedDecl *> Decls)
Definition: DeclBase.cpp:1296
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:153
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1196
void erase(iterator From, iterator To)
Definition: Format.h:2031
uint32_t incrementGeneration(ASTContext &C)
Increment the current generation.
uint32_t getGeneration() const
Get the current generation of this AST source.
T getNotUpdated() const
Get the most recently computed value of this pointer without updating it.
The signature of a module, which is a hash of the AST content.
Definition: Module.h:55
virtual CXXBaseSpecifier * GetExternalCXXBaseSpecifiers(uint64_t Offset)
Resolve the offset of a set of C++ base specifiers in the decl stream into an array of specifiers...
Describes a module or submodule.
Definition: Module.h:65
ASTSourceDescriptor(StringRef Name, StringRef Path, StringRef ASTFile, ASTFileSignature Signature)
virtual void updateOutOfDateIdentifier(IdentifierInfo &II)
Update an out-of-date identifier.
virtual bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name)
Find all declarations with the given name in the given context, and add them to the context by callin...
uint32_t Offset
Definition: CacheTokens.cpp:43
virtual void FinishedDeserializing()
Notify ExternalASTSource that we finished the deserialization of a decl or type.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
static DeclContextLookupResult SetNoExternalVisibleDeclsForName(const DeclContext *DC, DeclarationName Name)
Definition: DeclBase.cpp:1281
iterator::reference operator*() const
A cache of the value of this pointer, in the most recent generation in which we queried it...
Represents an ObjC class declaration.
Definition: DeclObjC.h:1169
virtual void completeVisibleDeclsMap(const DeclContext *DC)
Ensures that the table of all visible declarations inside this context is up to date.
#define bool
Definition: stdbool.h:31
The result type of a method or function.
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap&#39;ed memor...
An abstract interface that should be implemented by external AST sources that also provide informatio...
Abstract interface for external sources of AST nodes.
virtual Stmt * GetExternalDeclStmt(uint64_t Offset)
Resolve the offset of a statement in the decl stream into a statement.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3043
static LazyGenerationalUpdatePtr getFromOpaqueValue(void *Ptr)
void push_back(const T &LocalValue)
MemoryBufferSizes(size_t malloc_bytes, size_t mmap_bytes)
bool isValid() const
Whether this pointer is non-NULL.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Dataflow Directional Tag Classes.
virtual Module * getModule(unsigned ID)
Retrieve the module that corresponds to the given module ID.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1272
void markIncomplete()
Forcibly set this pointer (which must be lazy) as needing updates.
virtual void StartTranslationUnit(ASTConsumer *Consumer)
Function that will be invoked when we begin parsing a new translation unit involving this external AS...
virtual void ReadComments()
Loads comment ranges.
LazyOffsetPtr & operator=(T *Ptr)
A lazy pointer to an AST node (of base type T) that resides within an external AST source...
DeclarationName - The name of a declaration.
virtual CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset)
Resolve the offset of a set of C++ constructor initializers in the decl stream into an array of initi...
virtual ExtKind hasExternalDefinitions(const Decl *D)
LazyGenerationalUpdatePtr(NotUpdatedTag, T Value=T())
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2258
virtual void CompleteType(TagDecl *Tag)
Gives the external AST source an opportunity to complete an incomplete type.
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
virtual llvm::Optional< ASTSourceDescriptor > getSourceDescriptor(unsigned ID)
Return a descriptor for the corresponding module, if one exists.
LazyGenerationalUpdatePtr(const ASTContext &Ctx, T Value=T())
bool isOffset() const
Whether this pointer is currently stored as an offset.
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
Iteration over the elements in the vector.
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
llvm::PointerUnion< T, LazyData * > ValueType
A lazy value (of type T) that is within an AST node of type Owner, where the value might change in la...
LazyOffsetPtr(uint64_t Offset)