194 lines
6.6 KiB
C++
194 lines
6.6 KiB
C++
//===--- 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
|