470 lines
17 KiB
C++
470 lines
17 KiB
C++
//===--- Ownership.h - Parser ownership helpers -----------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains classes for managing ownership of Stmt and Expr nodes.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_SEMA_OWNERSHIP_H
|
|
#define LLVM_CLANG_SEMA_OWNERSHIP_H
|
|
|
|
#include "clang/Basic/LLVM.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/ADT/PointerIntPair.h"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// OpaquePtr
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace clang {
|
|
class Attr;
|
|
class CXXCtorInitializer;
|
|
class CXXBaseSpecifier;
|
|
class Decl;
|
|
class DeclGroupRef;
|
|
class Expr;
|
|
class NestedNameSpecifier;
|
|
class QualType;
|
|
class Sema;
|
|
class Stmt;
|
|
class TemplateName;
|
|
class TemplateParameterList;
|
|
|
|
/// OpaquePtr - This is a very simple POD type that wraps a pointer that the
|
|
/// Parser doesn't know about but that Sema or another client does. The UID
|
|
/// template argument is used to make sure that "Decl" pointers are not
|
|
/// compatible with "Type" pointers for example.
|
|
template <class PtrTy>
|
|
class OpaquePtr {
|
|
void *Ptr;
|
|
explicit OpaquePtr(void *Ptr) : Ptr(Ptr) {}
|
|
|
|
typedef llvm::PointerLikeTypeTraits<PtrTy> Traits;
|
|
|
|
public:
|
|
OpaquePtr() : Ptr(0) {}
|
|
|
|
static OpaquePtr make(PtrTy P) { OpaquePtr OP; OP.set(P); return OP; }
|
|
|
|
template <typename T> T* getAs() const {
|
|
return get();
|
|
}
|
|
|
|
template <typename T> T getAsVal() const {
|
|
return get();
|
|
}
|
|
|
|
PtrTy get() const {
|
|
return Traits::getFromVoidPointer(Ptr);
|
|
}
|
|
|
|
void set(PtrTy P) {
|
|
Ptr = Traits::getAsVoidPointer(P);
|
|
}
|
|
|
|
operator bool() const { return Ptr != 0; }
|
|
|
|
void *getAsOpaquePtr() const { return Ptr; }
|
|
static OpaquePtr getFromOpaquePtr(void *P) { return OpaquePtr(P); }
|
|
};
|
|
|
|
/// UnionOpaquePtr - A version of OpaquePtr suitable for membership
|
|
/// in a union.
|
|
template <class T> struct UnionOpaquePtr {
|
|
void *Ptr;
|
|
|
|
static UnionOpaquePtr make(OpaquePtr<T> P) {
|
|
UnionOpaquePtr OP = { P.getAsOpaquePtr() };
|
|
return OP;
|
|
}
|
|
|
|
OpaquePtr<T> get() const { return OpaquePtr<T>::getFromOpaquePtr(Ptr); }
|
|
operator OpaquePtr<T>() const { return get(); }
|
|
|
|
UnionOpaquePtr &operator=(OpaquePtr<T> P) {
|
|
Ptr = P.getAsOpaquePtr();
|
|
return *this;
|
|
}
|
|
};
|
|
}
|
|
|
|
namespace llvm {
|
|
template <class T>
|
|
class PointerLikeTypeTraits<clang::OpaquePtr<T> > {
|
|
public:
|
|
static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) {
|
|
// FIXME: Doesn't work? return P.getAs< void >();
|
|
return P.getAsOpaquePtr();
|
|
}
|
|
static inline clang::OpaquePtr<T> getFromVoidPointer(void *P) {
|
|
return clang::OpaquePtr<T>::getFromOpaquePtr(P);
|
|
}
|
|
enum { NumLowBitsAvailable = 0 };
|
|
};
|
|
|
|
template <class T>
|
|
struct isPodLike<clang::OpaquePtr<T> > { static const bool value = true; };
|
|
}
|
|
|
|
|
|
|
|
// -------------------------- About Move Emulation -------------------------- //
|
|
// The smart pointer classes in this file attempt to emulate move semantics
|
|
// as they appear in C++0x with rvalue references. Since C++03 doesn't have
|
|
// rvalue references, some tricks are needed to get similar results.
|
|
// Move semantics in C++0x have the following properties:
|
|
// 1) "Moving" means transferring the value of an object to another object,
|
|
// similar to copying, but without caring what happens to the old object.
|
|
// In particular, this means that the new object can steal the old object's
|
|
// resources instead of creating a copy.
|
|
// 2) Since moving can modify the source object, it must either be explicitly
|
|
// requested by the user, or the modifications must be unnoticeable.
|
|
// 3) As such, C++0x moving is only allowed in three contexts:
|
|
// * By explicitly using std::move() to request it.
|
|
// * From a temporary object, since that object cannot be accessed
|
|
// afterwards anyway, thus making the state unobservable.
|
|
// * On function return, since the object is not observable afterwards.
|
|
//
|
|
// To sum up: moving from a named object should only be possible with an
|
|
// explicit std::move(), or on function return. Moving from a temporary should
|
|
// be implicitly done. Moving from a const object is forbidden.
|
|
//
|
|
// The emulation is not perfect, and has the following shortcomings:
|
|
// * move() is not in namespace std.
|
|
// * move() is required on function return.
|
|
// * There are difficulties with implicit conversions.
|
|
// * Microsoft's compiler must be given the /Za switch to successfully compile.
|
|
//
|
|
// -------------------------- Implementation -------------------------------- //
|
|
// The move emulation relies on the peculiar reference binding semantics of
|
|
// C++03: as a rule, a non-const reference may not bind to a temporary object,
|
|
// except for the implicit object parameter in a member function call, which
|
|
// can refer to a temporary even when not being const.
|
|
// The moveable object has five important functions to facilitate moving:
|
|
// * A private, unimplemented constructor taking a non-const reference to its
|
|
// own class. This constructor serves a two-fold purpose.
|
|
// - It prevents the creation of a copy constructor that takes a const
|
|
// reference. Temporaries would be able to bind to the argument of such a
|
|
// constructor, and that would be bad.
|
|
// - Named objects will bind to the non-const reference, but since it's
|
|
// private, this will fail to compile. This prevents implicit moving from
|
|
// named objects.
|
|
// There's also a copy assignment operator for the same purpose.
|
|
// * An implicit, non-const conversion operator to a special mover type. This
|
|
// type represents the rvalue reference of C++0x. Being a non-const member,
|
|
// its implicit this parameter can bind to temporaries.
|
|
// * A constructor that takes an object of this mover type. This constructor
|
|
// performs the actual move operation. There is an equivalent assignment
|
|
// operator.
|
|
// There is also a free move() function that takes a non-const reference to
|
|
// an object and returns a temporary. Internally, this function uses explicit
|
|
// constructor calls to move the value from the referenced object to the return
|
|
// value.
|
|
//
|
|
// There are now three possible scenarios of use.
|
|
// * Copying from a const object. Constructor overload resolution will find the
|
|
// non-const copy constructor, and the move constructor. The first is not
|
|
// viable because the const object cannot be bound to the non-const reference.
|
|
// The second fails because the conversion to the mover object is non-const.
|
|
// Moving from a const object fails as intended.
|
|
// * Copying from a named object. Constructor overload resolution will select
|
|
// the non-const copy constructor, but fail as intended, because this
|
|
// constructor is private.
|
|
// * Copying from a temporary. Constructor overload resolution cannot select
|
|
// the non-const copy constructor, because the temporary cannot be bound to
|
|
// the non-const reference. It thus selects the move constructor. The
|
|
// temporary can be bound to the implicit this parameter of the conversion
|
|
// operator, because of the special binding rule. Construction succeeds.
|
|
// Note that the Microsoft compiler, as an extension, allows binding
|
|
// temporaries against non-const references. The compiler thus selects the
|
|
// non-const copy constructor and fails, because the constructor is private.
|
|
// Passing /Za (disable extensions) disables this behaviour.
|
|
// The free move() function is used to move from a named object.
|
|
//
|
|
// Note that when passing an object of a different type (the classes below
|
|
// have OwningResult and OwningPtr, which should be mixable), you get a problem.
|
|
// Argument passing and function return use copy initialization rules. The
|
|
// effect of this is that, when the source object is not already of the target
|
|
// type, the compiler will first seek a way to convert the source object to the
|
|
// target type, and only then attempt to copy the resulting object. This means
|
|
// that when passing an OwningResult where an OwningPtr is expected, the
|
|
// compiler will first seek a conversion from OwningResult to OwningPtr, then
|
|
// copy the OwningPtr. The resulting conversion sequence is:
|
|
// OwningResult object -> ResultMover -> OwningResult argument to
|
|
// OwningPtr(OwningResult) -> OwningPtr -> PtrMover -> final OwningPtr
|
|
// This conversion sequence is too complex to be allowed. Thus the special
|
|
// move_* functions, which help the compiler out with some explicit
|
|
// conversions.
|
|
|
|
namespace clang {
|
|
// Basic
|
|
class DiagnosticBuilder;
|
|
|
|
// Determines whether the low bit of the result pointer for the
|
|
// given UID is always zero. If so, ActionResult will use that bit
|
|
// for it's "invalid" flag.
|
|
template<class Ptr>
|
|
struct IsResultPtrLowBitFree {
|
|
static const bool value = false;
|
|
};
|
|
|
|
/// ActionResult - This structure is used while parsing/acting on
|
|
/// expressions, stmts, etc. It encapsulates both the object returned by
|
|
/// the action, plus a sense of whether or not it is valid.
|
|
/// When CompressInvalid is true, the "invalid" flag will be
|
|
/// stored in the low bit of the Val pointer.
|
|
template<class PtrTy,
|
|
bool CompressInvalid = IsResultPtrLowBitFree<PtrTy>::value>
|
|
class ActionResult {
|
|
PtrTy Val;
|
|
bool Invalid;
|
|
|
|
public:
|
|
ActionResult(bool Invalid = false)
|
|
: Val(PtrTy()), Invalid(Invalid) {}
|
|
ActionResult(PtrTy val) : Val(val), Invalid(false) {}
|
|
ActionResult(const DiagnosticBuilder &) : Val(PtrTy()), Invalid(true) {}
|
|
|
|
// These two overloads prevent void* -> bool conversions.
|
|
ActionResult(const void *);
|
|
ActionResult(volatile void *);
|
|
|
|
bool isInvalid() const { return Invalid; }
|
|
bool isUsable() const { return !Invalid && Val; }
|
|
|
|
PtrTy get() const { return Val; }
|
|
PtrTy release() const { return Val; }
|
|
PtrTy take() const { return Val; }
|
|
template <typename T> T *takeAs() { return static_cast<T*>(get()); }
|
|
|
|
void set(PtrTy V) { Val = V; }
|
|
|
|
const ActionResult &operator=(PtrTy RHS) {
|
|
Val = RHS;
|
|
Invalid = false;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
// This ActionResult partial specialization places the "invalid"
|
|
// flag into the low bit of the pointer.
|
|
template<typename PtrTy>
|
|
class ActionResult<PtrTy, true> {
|
|
// A pointer whose low bit is 1 if this result is invalid, 0
|
|
// otherwise.
|
|
uintptr_t PtrWithInvalid;
|
|
typedef llvm::PointerLikeTypeTraits<PtrTy> PtrTraits;
|
|
public:
|
|
ActionResult(bool Invalid = false)
|
|
: PtrWithInvalid(static_cast<uintptr_t>(Invalid)) { }
|
|
|
|
ActionResult(PtrTy V) {
|
|
void *VP = PtrTraits::getAsVoidPointer(V);
|
|
PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
|
|
assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
|
|
}
|
|
ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) { }
|
|
|
|
// These two overloads prevent void* -> bool conversions.
|
|
ActionResult(const void *);
|
|
ActionResult(volatile void *);
|
|
|
|
bool isInvalid() const { return PtrWithInvalid & 0x01; }
|
|
bool isUsable() const { return PtrWithInvalid > 0x01; }
|
|
|
|
PtrTy get() const {
|
|
void *VP = reinterpret_cast<void *>(PtrWithInvalid & ~0x01);
|
|
return PtrTraits::getFromVoidPointer(VP);
|
|
}
|
|
PtrTy take() const { return get(); }
|
|
PtrTy release() const { return get(); }
|
|
template <typename T> T *takeAs() { return static_cast<T*>(get()); }
|
|
|
|
void set(PtrTy V) {
|
|
void *VP = PtrTraits::getAsVoidPointer(V);
|
|
PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
|
|
assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
|
|
}
|
|
|
|
const ActionResult &operator=(PtrTy RHS) {
|
|
void *VP = PtrTraits::getAsVoidPointer(RHS);
|
|
PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
|
|
assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/// ASTMultiPtr - A moveable smart pointer to multiple AST nodes. Only owns
|
|
/// the individual pointers, not the array holding them.
|
|
template <typename PtrTy> class ASTMultiPtr;
|
|
|
|
template <class PtrTy>
|
|
class ASTMultiPtr {
|
|
PtrTy *Nodes;
|
|
unsigned Count;
|
|
|
|
public:
|
|
// Normal copying implicitly defined
|
|
ASTMultiPtr() : Nodes(0), Count(0) {}
|
|
explicit ASTMultiPtr(Sema &) : Nodes(0), Count(0) {}
|
|
ASTMultiPtr(Sema &, PtrTy *nodes, unsigned count)
|
|
: Nodes(nodes), Count(count) {}
|
|
// Fake mover in Parse/AstGuard.h needs this:
|
|
ASTMultiPtr(PtrTy *nodes, unsigned count) : Nodes(nodes), Count(count) {}
|
|
|
|
/// Access to the raw pointers.
|
|
PtrTy *get() const { return Nodes; }
|
|
|
|
/// Access to the count.
|
|
unsigned size() const { return Count; }
|
|
|
|
PtrTy *release() {
|
|
return Nodes;
|
|
}
|
|
};
|
|
|
|
class ParsedTemplateArgument;
|
|
|
|
class ASTTemplateArgsPtr {
|
|
ParsedTemplateArgument *Args;
|
|
mutable unsigned Count;
|
|
|
|
public:
|
|
ASTTemplateArgsPtr(Sema &actions, ParsedTemplateArgument *args,
|
|
unsigned count) :
|
|
Args(args), Count(count) { }
|
|
|
|
// FIXME: Lame, not-fully-type-safe emulation of 'move semantics'.
|
|
ASTTemplateArgsPtr(ASTTemplateArgsPtr &Other) :
|
|
Args(Other.Args), Count(Other.Count) {
|
|
}
|
|
|
|
// FIXME: Lame, not-fully-type-safe emulation of 'move semantics'.
|
|
ASTTemplateArgsPtr& operator=(ASTTemplateArgsPtr &Other) {
|
|
Args = Other.Args;
|
|
Count = Other.Count;
|
|
return *this;
|
|
}
|
|
|
|
ParsedTemplateArgument *getArgs() const { return Args; }
|
|
unsigned size() const { return Count; }
|
|
|
|
void reset(ParsedTemplateArgument *args, unsigned count) {
|
|
Args = args;
|
|
Count = count;
|
|
}
|
|
|
|
const ParsedTemplateArgument &operator[](unsigned Arg) const;
|
|
|
|
ParsedTemplateArgument *release() const {
|
|
return Args;
|
|
}
|
|
};
|
|
|
|
/// \brief A small vector that owns a set of AST nodes.
|
|
template <class PtrTy, unsigned N = 8>
|
|
class ASTOwningVector : public SmallVector<PtrTy, N> {
|
|
ASTOwningVector(ASTOwningVector &); // do not implement
|
|
ASTOwningVector &operator=(ASTOwningVector &); // do not implement
|
|
|
|
public:
|
|
explicit ASTOwningVector(Sema &Actions)
|
|
{ }
|
|
|
|
PtrTy *take() {
|
|
return &this->front();
|
|
}
|
|
|
|
template<typename T> T **takeAs() { return reinterpret_cast<T**>(take()); }
|
|
};
|
|
|
|
/// An opaque type for threading parsed type information through the
|
|
/// parser.
|
|
typedef OpaquePtr<QualType> ParsedType;
|
|
typedef UnionOpaquePtr<QualType> UnionParsedType;
|
|
|
|
/// A SmallVector of statements, with stack size 32 (as that is the only one
|
|
/// used.)
|
|
typedef ASTOwningVector<Stmt*, 32> StmtVector;
|
|
/// A SmallVector of expressions, with stack size 12 (the maximum used.)
|
|
typedef ASTOwningVector<Expr*, 12> ExprVector;
|
|
/// A SmallVector of types.
|
|
typedef ASTOwningVector<ParsedType, 12> TypeVector;
|
|
|
|
template <class T, unsigned N> inline
|
|
ASTMultiPtr<T> move_arg(ASTOwningVector<T, N> &vec) {
|
|
return ASTMultiPtr<T>(vec.take(), vec.size());
|
|
}
|
|
|
|
// These versions are hopefully no-ops.
|
|
template <class T, bool C>
|
|
inline ActionResult<T,C> move(ActionResult<T,C> &ptr) {
|
|
return ptr;
|
|
}
|
|
|
|
template <class T> inline
|
|
ASTMultiPtr<T>& move(ASTMultiPtr<T> &ptr) {
|
|
return ptr;
|
|
}
|
|
|
|
// We can re-use the low bit of expression, statement, base, and
|
|
// member-initializer pointers for the "invalid" flag of
|
|
// ActionResult.
|
|
template<> struct IsResultPtrLowBitFree<Expr*> {
|
|
static const bool value = true;
|
|
};
|
|
template<> struct IsResultPtrLowBitFree<Stmt*> {
|
|
static const bool value = true;
|
|
};
|
|
template<> struct IsResultPtrLowBitFree<CXXBaseSpecifier*> {
|
|
static const bool value = true;
|
|
};
|
|
template<> struct IsResultPtrLowBitFree<CXXCtorInitializer*> {
|
|
static const bool value = true;
|
|
};
|
|
|
|
typedef ActionResult<Expr*> ExprResult;
|
|
typedef ActionResult<Stmt*> StmtResult;
|
|
typedef ActionResult<ParsedType> TypeResult;
|
|
typedef ActionResult<CXXBaseSpecifier*> BaseResult;
|
|
typedef ActionResult<CXXCtorInitializer*> MemInitResult;
|
|
|
|
typedef ActionResult<Decl*> DeclResult;
|
|
typedef OpaquePtr<TemplateName> ParsedTemplateTy;
|
|
|
|
inline Expr *move(Expr *E) { return E; }
|
|
inline Stmt *move(Stmt *S) { return S; }
|
|
|
|
typedef ASTMultiPtr<Expr*> MultiExprArg;
|
|
typedef ASTMultiPtr<Stmt*> MultiStmtArg;
|
|
typedef ASTMultiPtr<ParsedType> MultiTypeArg;
|
|
typedef ASTMultiPtr<TemplateParameterList*> MultiTemplateParamsArg;
|
|
|
|
inline ExprResult ExprError() { return ExprResult(true); }
|
|
inline StmtResult StmtError() { return StmtResult(true); }
|
|
|
|
inline ExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); }
|
|
inline StmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); }
|
|
|
|
inline ExprResult ExprEmpty() { return ExprResult(false); }
|
|
inline StmtResult StmtEmpty() { return StmtResult(false); }
|
|
|
|
inline Expr *AssertSuccess(ExprResult R) {
|
|
assert(!R.isInvalid() && "operation was asserted to never fail!");
|
|
return R.get();
|
|
}
|
|
|
|
inline Stmt *AssertSuccess(StmtResult R) {
|
|
assert(!R.isInvalid() && "operation was asserted to never fail!");
|
|
return R.get();
|
|
}
|
|
}
|
|
|
|
#endif
|