| //===--- ExternalASTSource.h - Abstract External AST Interface --*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines the ExternalASTSource interface, which enables |
| // construction of AST nodes from some external source.x |
| // |
| //===----------------------------------------------------------------------===// |
| #ifndef LLVM_CLANG_AST_EXTERNAL_AST_SOURCE_H |
| #define LLVM_CLANG_AST_EXTERNAL_AST_SOURCE_H |
| |
| #include "clang/AST/DeclarationName.h" |
| #include "clang/AST/Type.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include <cassert> |
| #include <vector> |
| namespace clang { |
| |
| class ASTConsumer; |
| class Decl; |
| class DeclContext; |
| class ExternalSemaSource; // layering violation required for downcasting |
| class Stmt; |
| |
| /// \brief The deserialized representation of a set of declarations |
| /// with the same name that are visible in a given context. |
| struct VisibleDeclaration { |
| /// \brief The name of the declarations. |
| DeclarationName Name; |
| |
| /// \brief The ID numbers of all of the declarations with this name. |
| /// |
| /// These declarations have not necessarily been de-serialized. |
| llvm::SmallVector<unsigned, 4> Declarations; |
| }; |
| |
| /// \brief Abstract interface for external sources of AST nodes. |
| /// |
| /// External AST sources provide AST nodes constructed from some |
| /// external source, such as a precompiled header. External AST |
| /// sources can resolve types and declarations from abstract IDs into |
| /// actual type and declaration nodes, and read parts of declaration |
| /// contexts. |
| class ExternalASTSource { |
| /// \brief Whether this AST source also provides information for |
| /// semantic analysis. |
| bool SemaSource; |
| |
| friend class ExternalSemaSource; |
| |
| public: |
| ExternalASTSource() : SemaSource(false) { } |
| |
| virtual ~ExternalASTSource(); |
| |
| /// \brief Reads the source ranges that correspond to comments from |
| /// an external AST source. |
| /// |
| /// \param Comments the contents of this vector will be |
| /// replaced with the sorted set of source ranges corresponding to |
| /// comments in the source code. |
| virtual void ReadComments(std::vector<SourceRange> &Comments) = 0; |
| |
| /// \brief Resolve a type ID into a type, potentially building a new |
| /// type. |
| virtual QualType GetType(uint32_t ID) = 0; |
| |
| /// \brief Resolve a declaration ID into a declaration, potentially |
| /// building a new declaration. |
| virtual Decl *GetDecl(uint32_t ID) = 0; |
| |
| /// \brief Resolve the offset of a statement in the decl stream into a |
| /// statement. |
| /// |
| /// This operation will read a new statement from the external |
| /// source each time it is called, and is meant to be used via a |
| /// LazyOffsetPtr. |
| virtual Stmt *GetDeclStmt(uint64_t Offset) = 0; |
| |
| /// \brief Read all of the declarations lexically stored in a |
| /// declaration context. |
| /// |
| /// \param DC The declaration context whose declarations will be |
| /// read. |
| /// |
| /// \param Decls Vector that will contain the declarations loaded |
| /// from the external source. The caller is responsible for merging |
| /// these declarations with any declarations already stored in the |
| /// declaration context. |
| /// |
| /// \returns true if there was an error while reading the |
| /// declarations for this declaration context. |
| virtual bool ReadDeclsLexicallyInContext(DeclContext *DC, |
| llvm::SmallVectorImpl<uint32_t> &Decls) = 0; |
| |
| /// \brief Read all of the declarations visible from a declaration |
| /// context. |
| /// |
| /// \param DC The declaration context whose visible declarations |
| /// will be read. |
| /// |
| /// \param Decls A vector of visible declaration structures, |
| /// providing the mapping from each name visible in the declaration |
| /// context to the declaration IDs of declarations with that name. |
| /// |
| /// \returns true if there was an error while reading the |
| /// declarations for this declaration context. |
| virtual bool ReadDeclsVisibleInContext(DeclContext *DC, |
| llvm::SmallVectorImpl<VisibleDeclaration> & Decls) = 0; |
| |
| /// \brief Function that will be invoked when we begin parsing a new |
| /// translation unit involving this external AST source. |
| virtual void StartTranslationUnit(ASTConsumer *Consumer) { } |
| |
| /// \brief Print any statistics that have been gathered regarding |
| /// the external AST source. |
| virtual void PrintStats(); |
| }; |
| |
| /// \brief A lazy pointer to an AST node (of base type T) that resides |
| /// within an external AST source. |
| /// |
| /// The AST node is identified within the external AST source by a |
| /// 63-bit offset, and can be retrieved via an operation on the |
| /// external AST source itself. |
| template<typename T, T* (ExternalASTSource::*Get)(uint64_t Offset)> |
| struct LazyOffsetPtr { |
| /// \brief Either a pointer to an AST node or the offset within the |
| /// external AST source where the AST node can be found. |
| /// |
| /// If the low bit is clear, a pointer to the AST node. If the low |
| /// bit is set, the upper 63 bits are the offset. |
| mutable uint64_t Ptr; |
| |
| public: |
| LazyOffsetPtr() : Ptr(0) { } |
| |
| explicit LazyOffsetPtr(T *Ptr) : Ptr(reinterpret_cast<uint64_t>(Ptr)) { } |
| explicit LazyOffsetPtr(uint64_t Offset) : Ptr((Offset << 1) | 0x01) { |
| assert((Offset << 1 >> 1) == Offset && "Offsets must require < 63 bits"); |
| if (Offset == 0) |
| Ptr = 0; |
| } |
| |
| LazyOffsetPtr &operator=(T *Ptr) { |
| this->Ptr = reinterpret_cast<uint64_t>(Ptr); |
| return *this; |
| } |
| |
| LazyOffsetPtr &operator=(uint64_t Offset) { |
| assert((Offset << 1 >> 1) == Offset && "Offsets must require < 63 bits"); |
| if (Offset == 0) |
| Ptr = 0; |
| else |
| Ptr = (Offset << 1) | 0x01; |
| |
| return *this; |
| } |
| |
| /// \brief Whether this pointer is non-NULL. |
| /// |
| /// This operation does not require the AST node to be deserialized. |
| operator bool() const { return Ptr != 0; } |
| |
| /// \brief Whether this pointer is currently stored as an offset. |
| bool isOffset() const { return Ptr & 0x01; } |
| |
| /// \brief Retrieve the pointer to the AST node that this lazy pointer |
| /// |
| /// \param Source the external AST source. |
| /// |
| /// \returns a pointer to the AST node. |
| T* get(ExternalASTSource *Source) const { |
| if (isOffset()) { |
| assert(Source && |
| "Cannot deserialize a lazy pointer without an AST source"); |
| Ptr = reinterpret_cast<uint64_t>((Source->*Get)(Ptr >> 1)); |
| } |
| return reinterpret_cast<T*>(Ptr); |
| } |
| }; |
| |
| /// \brief A lazy pointer to a statement. |
| typedef LazyOffsetPtr<Stmt, &ExternalASTSource::GetDeclStmt> LazyDeclStmtPtr; |
| |
| } // end namespace clang |
| |
| #endif // LLVM_CLANG_AST_EXTERNAL_AST_SOURCE_H |