Ownership.h revision 18062394db459158942ab491a88b9d52a5c0ab0d
1//===--- Ownership.h - Parser ownership helpers -----------------*- 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 contains classes for managing ownership of Stmt and Expr nodes. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_SEMA_OWNERSHIP_H 15#define LLVM_CLANG_SEMA_OWNERSHIP_H 16 17#include "clang/Basic/LLVM.h" 18#include "llvm/ADT/ArrayRef.h" 19#include "llvm/ADT/PointerIntPair.h" 20 21//===----------------------------------------------------------------------===// 22// OpaquePtr 23//===----------------------------------------------------------------------===// 24 25namespace clang { 26 class CXXCtorInitializer; 27 class CXXBaseSpecifier; 28 class Decl; 29 class Expr; 30 class ParsedTemplateArgument; 31 class QualType; 32 class Stmt; 33 class TemplateName; 34 class TemplateParameterList; 35 36 /// \brief Wrapper for void* pointer. 37 /// \tparam PtrTy Either a pointer type like 'T*' or a type that behaves like 38 /// a pointer. 39 /// 40 /// This is a very simple POD type that wraps a pointer that the Parser 41 /// doesn't know about but that Sema or another client does. The PtrTy 42 /// template argument is used to make sure that "Decl" pointers are not 43 /// compatible with "Type" pointers for example. 44 template <class PtrTy> 45 class OpaquePtr { 46 void *Ptr; 47 explicit OpaquePtr(void *Ptr) : Ptr(Ptr) {} 48 49 typedef llvm::PointerLikeTypeTraits<PtrTy> Traits; 50 51 public: 52 OpaquePtr() : Ptr(0) {} 53 54 static OpaquePtr make(PtrTy P) { OpaquePtr OP; OP.set(P); return OP; } 55 56 /// \brief Returns plain pointer to the entity pointed by this wrapper. 57 /// \tparam PointeeT Type of pointed entity. 58 /// 59 /// It is identical to getPtrAs<PointeeT*>. 60 template <typename PointeeT> PointeeT* getPtrTo() const { 61 return get(); 62 } 63 64 /// \brief Returns pointer converted to the specified type. 65 /// \tparam PtrT Result pointer type. There must be implicit conversion 66 /// from PtrTy to PtrT. 67 /// 68 /// In contrast to getPtrTo, this method allows the return type to be 69 /// a smart pointer. 70 template <typename PtrT> PtrT getPtrAs() const { 71 return get(); 72 } 73 74 PtrTy get() const { 75 return Traits::getFromVoidPointer(Ptr); 76 } 77 78 void set(PtrTy P) { 79 Ptr = Traits::getAsVoidPointer(P); 80 } 81 82 LLVM_EXPLICIT operator bool() const { return Ptr != 0; } 83 84 void *getAsOpaquePtr() const { return Ptr; } 85 static OpaquePtr getFromOpaquePtr(void *P) { return OpaquePtr(P); } 86 }; 87 88 /// UnionOpaquePtr - A version of OpaquePtr suitable for membership 89 /// in a union. 90 template <class T> struct UnionOpaquePtr { 91 void *Ptr; 92 93 static UnionOpaquePtr make(OpaquePtr<T> P) { 94 UnionOpaquePtr OP = { P.getAsOpaquePtr() }; 95 return OP; 96 } 97 98 OpaquePtr<T> get() const { return OpaquePtr<T>::getFromOpaquePtr(Ptr); } 99 operator OpaquePtr<T>() const { return get(); } 100 101 UnionOpaquePtr &operator=(OpaquePtr<T> P) { 102 Ptr = P.getAsOpaquePtr(); 103 return *this; 104 } 105 }; 106} 107 108namespace llvm { 109 template <class T> 110 class PointerLikeTypeTraits<clang::OpaquePtr<T> > { 111 public: 112 static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) { 113 // FIXME: Doesn't work? return P.getAs< void >(); 114 return P.getAsOpaquePtr(); 115 } 116 static inline clang::OpaquePtr<T> getFromVoidPointer(void *P) { 117 return clang::OpaquePtr<T>::getFromOpaquePtr(P); 118 } 119 enum { NumLowBitsAvailable = 0 }; 120 }; 121 122 template <class T> 123 struct isPodLike<clang::OpaquePtr<T> > { static const bool value = true; }; 124} 125 126namespace clang { 127 // Basic 128 class DiagnosticBuilder; 129 130 // Determines whether the low bit of the result pointer for the 131 // given UID is always zero. If so, ActionResult will use that bit 132 // for it's "invalid" flag. 133 template<class Ptr> 134 struct IsResultPtrLowBitFree { 135 static const bool value = false; 136 }; 137 138 /// ActionResult - This structure is used while parsing/acting on 139 /// expressions, stmts, etc. It encapsulates both the object returned by 140 /// the action, plus a sense of whether or not it is valid. 141 /// When CompressInvalid is true, the "invalid" flag will be 142 /// stored in the low bit of the Val pointer. 143 template<class PtrTy, 144 bool CompressInvalid = IsResultPtrLowBitFree<PtrTy>::value> 145 class ActionResult { 146 PtrTy Val; 147 bool Invalid; 148 149 public: 150 ActionResult(bool Invalid = false) 151 : Val(PtrTy()), Invalid(Invalid) {} 152 ActionResult(PtrTy val) : Val(val), Invalid(false) {} 153 ActionResult(const DiagnosticBuilder &) : Val(PtrTy()), Invalid(true) {} 154 155 // These two overloads prevent void* -> bool conversions. 156 ActionResult(const void *); 157 ActionResult(volatile void *); 158 159 bool isInvalid() const { return Invalid; } 160 bool isUsable() const { return !Invalid && Val; } 161 162 PtrTy get() const { return Val; } 163 // FIXME: Replace with get. 164 PtrTy release() const { return Val; } 165 PtrTy take() const { return Val; } 166 template <typename T> T *takeAs() { return static_cast<T*>(get()); } 167 168 void set(PtrTy V) { Val = V; } 169 170 const ActionResult &operator=(PtrTy RHS) { 171 Val = RHS; 172 Invalid = false; 173 return *this; 174 } 175 }; 176 177 // This ActionResult partial specialization places the "invalid" 178 // flag into the low bit of the pointer. 179 template<typename PtrTy> 180 class ActionResult<PtrTy, true> { 181 // A pointer whose low bit is 1 if this result is invalid, 0 182 // otherwise. 183 uintptr_t PtrWithInvalid; 184 typedef llvm::PointerLikeTypeTraits<PtrTy> PtrTraits; 185 public: 186 ActionResult(bool Invalid = false) 187 : PtrWithInvalid(static_cast<uintptr_t>(Invalid)) { } 188 189 ActionResult(PtrTy V) { 190 void *VP = PtrTraits::getAsVoidPointer(V); 191 PtrWithInvalid = reinterpret_cast<uintptr_t>(VP); 192 assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer"); 193 } 194 ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) { } 195 196 // These two overloads prevent void* -> bool conversions. 197 ActionResult(const void *); 198 ActionResult(volatile void *); 199 200 bool isInvalid() const { return PtrWithInvalid & 0x01; } 201 bool isUsable() const { return PtrWithInvalid > 0x01; } 202 203 PtrTy get() const { 204 void *VP = reinterpret_cast<void *>(PtrWithInvalid & ~0x01); 205 return PtrTraits::getFromVoidPointer(VP); 206 } 207 // FIXME: Replace with get. 208 PtrTy take() const { return get(); } 209 PtrTy release() const { return get(); } 210 template <typename T> T *takeAs() { return static_cast<T*>(get()); } 211 212 void set(PtrTy V) { 213 void *VP = PtrTraits::getAsVoidPointer(V); 214 PtrWithInvalid = reinterpret_cast<uintptr_t>(VP); 215 assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer"); 216 } 217 218 const ActionResult &operator=(PtrTy RHS) { 219 void *VP = PtrTraits::getAsVoidPointer(RHS); 220 PtrWithInvalid = reinterpret_cast<uintptr_t>(VP); 221 assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer"); 222 return *this; 223 } 224 225 // For types where we can fit a flag in with the pointer, provide 226 // conversions to/from pointer type. 227 static ActionResult getFromOpaquePointer(void *P) { 228 ActionResult Result; 229 Result.PtrWithInvalid = (uintptr_t)P; 230 return Result; 231 } 232 void *getAsOpaquePointer() const { return (void*)PtrWithInvalid; } 233 }; 234 235 /// An opaque type for threading parsed type information through the 236 /// parser. 237 typedef OpaquePtr<QualType> ParsedType; 238 typedef UnionOpaquePtr<QualType> UnionParsedType; 239 240 // We can re-use the low bit of expression, statement, base, and 241 // member-initializer pointers for the "invalid" flag of 242 // ActionResult. 243 template<> struct IsResultPtrLowBitFree<Expr*> { 244 static const bool value = true; 245 }; 246 template<> struct IsResultPtrLowBitFree<Stmt*> { 247 static const bool value = true; 248 }; 249 template<> struct IsResultPtrLowBitFree<CXXBaseSpecifier*> { 250 static const bool value = true; 251 }; 252 template<> struct IsResultPtrLowBitFree<CXXCtorInitializer*> { 253 static const bool value = true; 254 }; 255 256 typedef ActionResult<Expr*> ExprResult; 257 typedef ActionResult<Stmt*> StmtResult; 258 typedef ActionResult<ParsedType> TypeResult; 259 typedef ActionResult<CXXBaseSpecifier*> BaseResult; 260 typedef ActionResult<CXXCtorInitializer*> MemInitResult; 261 262 typedef ActionResult<Decl*> DeclResult; 263 typedef OpaquePtr<TemplateName> ParsedTemplateTy; 264 265 typedef llvm::MutableArrayRef<Expr*> MultiExprArg; 266 typedef llvm::MutableArrayRef<Stmt*> MultiStmtArg; 267 typedef llvm::MutableArrayRef<ParsedTemplateArgument> ASTTemplateArgsPtr; 268 typedef llvm::MutableArrayRef<ParsedType> MultiTypeArg; 269 typedef llvm::MutableArrayRef<TemplateParameterList*> MultiTemplateParamsArg; 270 271 inline ExprResult ExprError() { return ExprResult(true); } 272 inline StmtResult StmtError() { return StmtResult(true); } 273 274 inline ExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); } 275 inline StmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); } 276 277 inline ExprResult ExprEmpty() { return ExprResult(false); } 278 inline StmtResult StmtEmpty() { return StmtResult(false); } 279 280 inline Expr *AssertSuccess(ExprResult R) { 281 assert(!R.isInvalid() && "operation was asserted to never fail!"); 282 return R.get(); 283 } 284 285 inline Stmt *AssertSuccess(StmtResult R) { 286 assert(!R.isInvalid() && "operation was asserted to never fail!"); 287 return R.get(); 288 } 289} 290 291#endif 292