Home | History | Annotate | Download | only in Sema 
      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 
     25 namespace 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(nullptr) {}
     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     explicit operator bool() const { return Ptr != nullptr; }
     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 
    108 namespace 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 
    126 namespace 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     bool isUnset() const { return !Invalid && !Val; }
    162 
    163     PtrTy get() const { return Val; }
    164     template <typename T> T *getAs() { return static_cast<T*>(get()); }
    165 
    166     void set(PtrTy V) { Val = V; }
    167 
    168     const ActionResult &operator=(PtrTy RHS) {
    169       Val = RHS;
    170       Invalid = false;
    171       return *this;
    172     }
    173   };
    174 
    175   // This ActionResult partial specialization places the "invalid"
    176   // flag into the low bit of the pointer.
    177   template<typename PtrTy>
    178   class ActionResult<PtrTy, true> {
    179     // A pointer whose low bit is 1 if this result is invalid, 0
    180     // otherwise.
    181     uintptr_t PtrWithInvalid;
    182     typedef llvm::PointerLikeTypeTraits<PtrTy> PtrTraits;
    183   public:
    184     ActionResult(bool Invalid = false)
    185       : PtrWithInvalid(static_cast<uintptr_t>(Invalid)) { }
    186 
    187     ActionResult(PtrTy V) {
    188       void *VP = PtrTraits::getAsVoidPointer(V);
    189       PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
    190       assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
    191     }
    192     ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) { }
    193 
    194     // These two overloads prevent void* -> bool conversions.
    195     ActionResult(const void *);
    196     ActionResult(volatile void *);
    197 
    198     bool isInvalid() const { return PtrWithInvalid & 0x01; }
    199     bool isUsable() const { return PtrWithInvalid > 0x01; }
    200     bool isUnset() const { return PtrWithInvalid == 0; }
    201 
    202     PtrTy get() const {
    203       void *VP = reinterpret_cast<void *>(PtrWithInvalid & ~0x01);
    204       return PtrTraits::getFromVoidPointer(VP);
    205     }
    206     template <typename T> T *getAs() { return static_cast<T*>(get()); }
    207 
    208     void set(PtrTy V) {
    209       void *VP = PtrTraits::getAsVoidPointer(V);
    210       PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
    211       assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
    212     }
    213 
    214     const ActionResult &operator=(PtrTy RHS) {
    215       void *VP = PtrTraits::getAsVoidPointer(RHS);
    216       PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
    217       assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
    218       return *this;
    219     }
    220 
    221     // For types where we can fit a flag in with the pointer, provide
    222     // conversions to/from pointer type.
    223     static ActionResult getFromOpaquePointer(void *P) {
    224       ActionResult Result;
    225       Result.PtrWithInvalid = (uintptr_t)P;
    226       return Result;
    227     }
    228     void *getAsOpaquePointer() const { return (void*)PtrWithInvalid; }
    229   };
    230 
    231   /// An opaque type for threading parsed type information through the
    232   /// parser.
    233   typedef OpaquePtr<QualType> ParsedType;
    234   typedef UnionOpaquePtr<QualType> UnionParsedType;
    235 
    236   // We can re-use the low bit of expression, statement, base, and
    237   // member-initializer pointers for the "invalid" flag of
    238   // ActionResult.
    239   template<> struct IsResultPtrLowBitFree<Expr*> {
    240     static const bool value = true;
    241   };
    242   template<> struct IsResultPtrLowBitFree<Stmt*> {
    243     static const bool value = true;
    244   };
    245   template<> struct IsResultPtrLowBitFree<CXXBaseSpecifier*> {
    246     static const bool value = true;
    247   };
    248   template<> struct IsResultPtrLowBitFree<CXXCtorInitializer*> {
    249     static const bool value = true;
    250   };
    251 
    252   typedef ActionResult<Expr*> ExprResult;
    253   typedef ActionResult<Stmt*> StmtResult;
    254   typedef ActionResult<ParsedType> TypeResult;
    255   typedef ActionResult<CXXBaseSpecifier*> BaseResult;
    256   typedef ActionResult<CXXCtorInitializer*> MemInitResult;
    257 
    258   typedef ActionResult<Decl*> DeclResult;
    259   typedef OpaquePtr<TemplateName> ParsedTemplateTy;
    260 
    261   typedef MutableArrayRef<Expr*> MultiExprArg;
    262   typedef MutableArrayRef<Stmt*> MultiStmtArg;
    263   typedef MutableArrayRef<ParsedTemplateArgument> ASTTemplateArgsPtr;
    264   typedef MutableArrayRef<ParsedType> MultiTypeArg;
    265   typedef MutableArrayRef<TemplateParameterList*> MultiTemplateParamsArg;
    266 
    267   inline ExprResult ExprError() { return ExprResult(true); }
    268   inline StmtResult StmtError() { return StmtResult(true); }
    269 
    270   inline ExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); }
    271   inline StmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); }
    272 
    273   inline ExprResult ExprEmpty() { return ExprResult(false); }
    274   inline StmtResult StmtEmpty() { return StmtResult(false); }
    275 
    276   inline Expr *AssertSuccess(ExprResult R) {
    277     assert(!R.isInvalid() && "operation was asserted to never fail!");
    278     return R.get();
    279   }
    280 
    281   inline Stmt *AssertSuccess(StmtResult R) {
    282     assert(!R.isInvalid() && "operation was asserted to never fail!");
    283     return R.get();
    284   }
    285 }
    286 
    287 #endif
    288