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