Coverage Report

Created: 2018-07-21 08:31

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/GlobalDecl.h
Line
Count
Source
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/AST/DeclOpenMP.h"
21
#include "clang/Basic/ABI.h"
22
#include "clang/Basic/LLVM.h"
23
#include "llvm/ADT/DenseMapInfo.h"
24
#include "llvm/ADT/PointerIntPair.h"
25
#include "llvm/Support/Casting.h"
26
#include "llvm/Support/type_traits.h"
27
#include <cassert>
28
29
namespace clang {
30
31
/// GlobalDecl - represents a global declaration. This can either be a
32
/// CXXConstructorDecl and the constructor type (Base, Complete).
33
/// a CXXDestructorDecl and the destructor type (Base, Complete) or
34
/// a VarDecl, a FunctionDecl or a BlockDecl.
35
class GlobalDecl {
36
  llvm::PointerIntPair<const Decl *, 2> Value;
37
38
5.85M
  void Init(const Decl *D) {
39
5.85M
    assert(!isa<CXXConstructorDecl>(D) && "Use other ctor with ctor decls!");
40
5.85M
    assert(!isa<CXXDestructorDecl>(D) && "Use other ctor with dtor decls!");
41
5.85M
42
5.85M
    Value.setPointer(D);
43
5.85M
  }
44
45
public:
46
25.6M
  GlobalDecl() = default;
47
1.33M
  GlobalDecl(const VarDecl *D) { Init(D);}
48
4.47M
  GlobalDecl(const FunctionDecl *D) { Init(D); }
49
4.21k
  GlobalDecl(const BlockDecl *D) { Init(D); }
50
36.7k
  GlobalDecl(const CapturedDecl *D) { Init(D); }
51
4.47k
  GlobalDecl(const ObjCMethodDecl *D) { Init(D); }
52
6
  GlobalDecl(const OMPDeclareReductionDecl *D) { Init(D); }
53
789k
  GlobalDecl(const CXXConstructorDecl *D, CXXCtorType Type) : Value(D, Type) {}
54
351k
  GlobalDecl(const CXXDestructorDecl *D, CXXDtorType Type) : Value(D, Type) {}
55
56
3.86M
  GlobalDecl getCanonicalDecl() const {
57
3.86M
    GlobalDecl CanonGD;
58
3.86M
    CanonGD.Value.setPointer(Value.getPointer()->getCanonicalDecl());
59
3.86M
    CanonGD.Value.setInt(Value.getInt());
60
3.86M
    
61
3.86M
    return CanonGD;
62
3.86M
  }
63
64
26.5M
  const Decl *getDecl() const { return Value.getPointer(); }
65
66
385k
  CXXCtorType getCtorType() const {
67
385k
    assert(isa<CXXConstructorDecl>(getDecl()) && "Decl is not a ctor!");
68
385k
    return static_cast<CXXCtorType>(Value.getInt());
69
385k
  }
70
71
352k
  CXXDtorType getDtorType() const {
72
352k
    assert(isa<CXXDestructorDecl>(getDecl()) && "Decl is not a dtor!");
73
352k
    return static_cast<CXXDtorType>(Value.getInt());
74
352k
  }
75
  
76
54.2M
  friend bool operator==(const GlobalDecl &LHS, const GlobalDecl &RHS) {
77
54.2M
    return LHS.Value == RHS.Value;
78
54.2M
  }
79
  
80
8.37M
  void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
81
82
8.45M
  static GlobalDecl getFromOpaquePtr(void *P) {
83
8.45M
    GlobalDecl GD;
84
8.45M
    GD.Value.setFromOpaqueValue(P);
85
8.45M
    return GD;
86
8.45M
  }
87
  
88
14.5k
  GlobalDecl getWithDecl(const Decl *D) {
89
14.5k
    GlobalDecl Result(*this);
90
14.5k
    Result.Value.setPointer(D);
91
14.5k
    return Result;
92
14.5k
  }
93
};
94
95
} // namespace clang
96
97
namespace llvm {
98
99
  template<> struct DenseMapInfo<clang::GlobalDecl> {
100
10.4M
    static inline clang::GlobalDecl getEmptyKey() {
101
10.4M
      return clang::GlobalDecl();
102
10.4M
    }
103
  
104
8.45M
    static inline clang::GlobalDecl getTombstoneKey() {
105
8.45M
      return clang::GlobalDecl::
106
8.45M
        getFromOpaquePtr(reinterpret_cast<void*>(-1));
107
8.45M
    }
108
109
8.37M
    static unsigned getHashValue(clang::GlobalDecl GD) {
110
8.37M
      return DenseMapInfo<void*>::getHashValue(GD.getAsOpaquePtr());
111
8.37M
    }
112
    
113
    static bool isEqual(clang::GlobalDecl LHS, 
114
54.2M
                        clang::GlobalDecl RHS) {
115
54.2M
      return LHS == RHS;
116
54.2M
    }
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::GlobalDecl> {
123
    static const bool value = true;
124
  };
125
126
} // namespace llvm
127
128
#endif // LLVM_CLANG_AST_GLOBALDECL_H