contrib/llvm/tools/clang/include/clang/AST/GlobalDecl.h

   1 //===--- GlobalDecl.h - Global declaration holder ---------------*- 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 // A GlobalDecl can hold either a regular variable/function or a C++ ctor/dtor
  11 // together with its type.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_AST_GLOBALDECL_H
  16 #define LLVM_CLANG_AST_GLOBALDECL_H
  17
  18 #include "clang/AST/DeclCXX.h"
  19 #include "clang/AST/DeclObjC.h"
  20 #include "clang/Basic/ABI.h"
  21
  22 namespace clang {
  23
  24 /// GlobalDecl - represents a global declaration. This can either be a
  25 /// CXXConstructorDecl and the constructor type (Base, Complete).
  26 /// a CXXDestructorDecl and the destructor type (Base, Complete) or
  27 /// a VarDecl, a FunctionDecl or a BlockDecl.
  28 class GlobalDecl {
  29   llvm::PointerIntPair<const Decl*, 2> Value;
  30
  31   void Init(const Decl *D) {
  32     assert(!isa<CXXConstructorDecl>(D) && "Use other ctor with ctor decls!");
  33     assert(!isa<CXXDestructorDecl>(D) && "Use other ctor with dtor decls!");
  34
  35     Value.setPointer(D);
  36   }
  37
  38 public:
  39   GlobalDecl() {}
  40
  41   GlobalDecl(const VarDecl *D) { Init(D);}
  42   GlobalDecl(const FunctionDecl *D) { Init(D); }
  43   GlobalDecl(const BlockDecl *D) { Init(D); }
  44   GlobalDecl(const ObjCMethodDecl *D) { Init(D); }
  45
  46   GlobalDecl(const CXXConstructorDecl *D, CXXCtorType Type)
  47   : Value(D, Type) {}
  48   GlobalDecl(const CXXDestructorDecl *D, CXXDtorType Type)
  49   : Value(D, Type) {}
  50
  51   GlobalDecl getCanonicalDecl() const {
  52     GlobalDecl CanonGD;
  53     CanonGD.Value.setPointer(Value.getPointer()->getCanonicalDecl());
  54     CanonGD.Value.setInt(Value.getInt());
  55
  56     return CanonGD;
  57   }
  58
  59   const Decl *getDecl() const { return Value.getPointer(); }
  60
  61   CXXCtorType getCtorType() const {
  62     assert(isa<CXXConstructorDecl>(getDecl()) && "Decl is not a ctor!");
  63     return static_cast<CXXCtorType>(Value.getInt());
  64   }
  65
  66   CXXDtorType getDtorType() const {
  67     assert(isa<CXXDestructorDecl>(getDecl()) && "Decl is not a dtor!");
  68     return static_cast<CXXDtorType>(Value.getInt());
  69   }
  70
  71   friend bool operator==(const GlobalDecl &LHS, const GlobalDecl &RHS) {
  72     return LHS.Value == RHS.Value;
  73   }
  74
  75   void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
  76
  77   static GlobalDecl getFromOpaquePtr(void *P) {
  78     GlobalDecl GD;
  79     GD.Value.setFromOpaqueValue(P);
  80     return GD;
  81   }
  82
  83   GlobalDecl getWithDecl(const Decl *D) {
  84     GlobalDecl Result(*this);
  85     Result.Value.setPointer(D);
  86     return Result;
  87   }
  88 };
  89
  90 } // end namespace clang
  91
  92 namespace llvm {
  93   template<class> struct DenseMapInfo;
  94
  95   template<> struct DenseMapInfo<clang::GlobalDecl> {
  96     static inline clang::GlobalDecl getEmptyKey() {
  97       return clang::GlobalDecl();
  98     }
  99
 100     static inline clang::GlobalDecl getTombstoneKey() {
 101       return clang::GlobalDecl::
 102         getFromOpaquePtr(reinterpret_cast<void*>(-1));
 103     }
 104
 105     static unsigned getHashValue(clang::GlobalDecl GD) {
 106       return DenseMapInfo<void*>::getHashValue(GD.getAsOpaquePtr());
 107     }
 108
 109     static bool isEqual(clang::GlobalDecl LHS,
 110                         clang::GlobalDecl RHS) {
 111       return LHS == RHS;
 112     }
 113
 114   };
 115
 116   // GlobalDecl isn't *technically* a POD type. However, its copy constructor,
 117   // copy assignment operator, and destructor are all trivial.
 118   template <>
 119   struct isPodLike<clang::GlobalDecl> {
 120     static const bool value = true;
 121   };
 122 } // end namespace llvm
 123
 124 #endif