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