Warning: That file was not part of the compilation database. It may have many parsing errors.

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
39namespace clang {
40
41class ASTConsumer;
42class ASTContext;
43class CXXBaseSpecifier;
44class CXXCtorInitializer;
45class CXXRecordDecl;
46class DeclarationName;
47class FieldDecl;
48class IdentifierInfo;
49class NamedDecl;
50class ObjCInterfaceDecl;
51class RecordDecl;
52class Selector;
53class Stmt;
54class 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.
63class 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
74public:
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
89 ~Deserializing() {
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.
145 virtual void updateOutOfDateIdentifier(IdentifierInfo &II) {}
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
155 FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name);
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.
173 class ASTSourceDescriptor {
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.
196 virtual llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID);
197
198 enum ExtKind { EK_Always, EK_Never, EK_ReplyHazy };
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
210 FindExternalLexicalDecls(const DeclContext *DC,
211 llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
212 SmallVectorImpl<Decl *> &Result);
213
214 /// Finds all declarations lexically contained within the given
215 /// DeclContext.
216 void FindExternalLexicalDecls(const DeclContext *DC,
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
311 struct MemoryBufferSizes {
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.
321 MemoryBufferSizes getMemoryBufferSizes() const {
322 MemoryBufferSizes sizes(0, 0);
323 getMemoryBufferSizes(sizes);
324 return sizes;
325 }
326
327 virtual void getMemoryBufferSizes(MemoryBufferSizes &sizes) const;
328
329protected:
330 static DeclContextLookupResult
331 SetExternalVisibleDeclsForName(const DeclContext *DC,
332 DeclarationName Name,
333 ArrayRef<NamedDecl*> Decls);
334
335 static DeclContextLookupResult
336 SetNoExternalVisibleDeclsForName(const DeclContext *DC,
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.
349template<typename T, typename OffsT, T* (ExternalASTSource::*Get)(OffsT Offset)>
350struct LazyOffsetPtr {
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
358public:
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
368 LazyOffsetPtr &operator=(T *Ptr) {
369 this->Ptr = reinterpret_cast<uint64_t>(Ptr);
370 return *this;
371 }
372
373 LazyOffsetPtr &operator=(uint64_t Offset) {
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.
414template<typename Owner, typename T, void (ExternalASTSource::*Update)(Owner)>
415struct LazyGenerationalUpdatePtr {
416 /// A cache of the value of this pointer, in the most recent generation in
417 /// which we queried it.
418 struct LazyData {
419 ExternalASTSource *ExternalSource;
420 uint32_t LastGeneration = 0;
421 T LastValue;
422
423 LazyData(ExternalASTSource *Source, T Value)
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*>;
429 ValueType Value;
430
431 LazyGenerationalUpdatePtr(ValueType V) : Value(V) {}
432
433 // Defined in ASTContext.h
434 static ValueType makeValue(const ASTContext &Ctx, T Value);
435
436public:
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 };
443 LazyGenerationalUpdatePtr(NotUpdatedTag, T Value = T())
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(); }
483 static LazyGenerationalUpdatePtr getFromOpaqueValue(void *Ptr) {
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.
492namespace llvm {
493
494template<typename Owner, typename T,
495 void (clang::ExternalASTSource::*Update)(Owner)>
496struct PointerLikeTypeTraits<
497 clang::LazyGenerationalUpdatePtr<Owner, T, Update>> {
498 using Ptr = clang::LazyGenerationalUpdatePtr<Owner, T, Update>;
499
500 static void *getAsVoidPointer(Ptr P) { return P.getOpaqueValue(); }
501 static Ptr getFromVoidPointer(void *P) { return Ptr::getFromOpaqueValue(P); }
502
503 enum {
504 NumLowBitsAvailable = PointerLikeTypeTraits<T>::NumLowBitsAvailable - 1
505 };
506};
507
508} // namespace llvm
509
510namespace 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.
518template<typename T, typename Source,
519 void (Source::*Loader)(SmallVectorImpl<T>&),
520 unsigned LoadedStorage = 2, unsigned LocalStorage = 4>
521class LazyVector {
522 SmallVector<T, LoadedStorage> Loaded;
523 SmallVector<T, LocalStorage> Local;
524
525public:
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.
597using LazyDeclStmtPtr =
598 LazyOffsetPtr<Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt>;
599
600/// A lazy pointer to a declaration.
601using LazyDeclPtr =
602 LazyOffsetPtr<Decl, uint32_t, &ExternalASTSource::GetExternalDecl>;
603
604/// A lazy pointer to a set of CXXCtorInitializers.
605using LazyCXXCtorInitializersPtr =
606 LazyOffsetPtr<CXXCtorInitializer *, uint64_t,
607 &ExternalASTSource::GetExternalCXXCtorInitializers>;
608
609/// A lazy pointer to a set of CXXBaseSpecifiers.
610using LazyCXXBaseSpecifiersPtr =
611 LazyOffsetPtr<CXXBaseSpecifier, uint64_t,
612 &ExternalASTSource::GetExternalCXXBaseSpecifiers>;
613
614} // namespace clang
615
616#endif // LLVM_CLANG_AST_EXTERNALASTSOURCE_H
617

Warning: That file was not part of the compilation database. It may have many parsing errors.