← Back to branch summary

~ubuntu-branches/ubuntu/trusty/llvm-toolchain-snapshot/trusty-201310232150

« back to all changes in this revision

Viewing changes to clang/include/clang/Analysis/Support/BlkExprDeclBitVector.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-27 15:01:57 UTC
  • mfrom: (0.10.1) (0.9.1) (0.8.1) (0.7.1) (0.6.1) (0.5.2)
  • Revision ID: package-import@ubuntu.com-20130527150157-tdkrsjpuvht7v0qx
Tags: 1:3.4~svn182733-1~exp1
http://bugs.debian.org/708677
* New snapshot release (3.4 release)
* Add a symlink of libLLVM-3.4.so.1 to usr/lib/llvm-3.4/lib/libLLVM-3.4.so
    to fix make the llvm-config-3.4 --libdir work (Closes: #708677)
  * Various packages rename to allow co installations:
    * libclang1 => libclang1-3.4
    * libclang1-dbg => libclang1-3.4-dbg
    * libclang-dev => libclang-3.4-dev
    * libclang-common-dev => libclang-common-3.4-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
clang/include/clang/Analysis/Support/BlkExprDeclBitVector.h
1
 
// BlkExprDeclBitVector.h - Dataflow types for Bitvector Analysis --*- 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 provides definition of dataflow types used by analyses such
11
 
// as LiveVariables and UninitializedValues.  The underlying dataflow values
12
 
// are implemented as bitvectors, but the definitions in this file include
13
 
// the necessary boilerplate to use with our dataflow framework.
14
 
//
15
 
//===----------------------------------------------------------------------===//
16
 
 
17
 
#ifndef LLVM_CLANG_STMTDECLBVDVAL_H
18
 
#define LLVM_CLANG_STMTDECLBVDVAL_H
19
 
 
20
 
#include "clang/AST/Decl.h" // for Decl* -> NamedDecl* conversion
21
 
#include "clang/Analysis/CFG.h"
22
 
#include "llvm/ADT/BitVector.h"
23
 
#include "llvm/ADT/DenseMap.h"
24
 
 
25
 
namespace clang {
26
 
 
27
 
  class Stmt;
28
 
  class ASTContext;
29
 
 
30
 
struct DeclBitVector_Types {
31
 
 
32
 
  class Idx {
33
 
    unsigned I;
34
 
  public:
35
 
    explicit Idx(unsigned i) : I(i) {}
36
 
    Idx() : I(~0U) {}
37
 
 
38
 
    bool isValid() const {
39
 
      return I != ~0U;
40
 
    }
41
 
    operator unsigned() const {
42
 
      assert (isValid());
43
 
      return I;
44
 
    }
45
 
  };
46
 
 
47
 
  //===--------------------------------------------------------------------===//
48
 
  // AnalysisDataTy - Whole-function meta data.
49
 
  //===--------------------------------------------------------------------===//
50
 
 
51
 
  class AnalysisDataTy {
52
 
  public:
53
 
    typedef llvm::DenseMap<const NamedDecl*, unsigned > DMapTy;
54
 
    typedef DMapTy::const_iterator decl_iterator;
55
 
 
56
 
  protected:
57
 
    DMapTy DMap;
58
 
    unsigned NDecls;
59
 
 
60
 
  public:
61
 
 
62
 
    AnalysisDataTy() : NDecls(0) {}
63
 
    virtual ~AnalysisDataTy() {}
64
 
 
65
 
    bool isTracked(const NamedDecl *SD) { return DMap.find(SD) != DMap.end(); }
66
 
 
67
 
    Idx getIdx(const NamedDecl *SD) const {
68
 
      DMapTy::const_iterator I = DMap.find(SD);
69
 
      return I == DMap.end() ? Idx() : Idx(I->second);
70
 
    }
71
 
 
72
 
    unsigned getNumDecls() const { return NDecls; }
73
 
 
74
 
    void Register(const NamedDecl *SD) {
75
 
      if (!isTracked(SD)) DMap[SD] = NDecls++;
76
 
    }
77
 
 
78
 
    decl_iterator begin_decl() const { return DMap.begin(); }
79
 
    decl_iterator end_decl() const { return DMap.end(); }
80
 
  };
81
 
 
82
 
  //===--------------------------------------------------------------------===//
83
 
  // ValTy - Dataflow value.
84
 
  //===--------------------------------------------------------------------===//
85
 
 
86
 
  class ValTy {
87
 
    llvm::BitVector DeclBV;
88
 
  public:
89
 
 
90
 
    void resetDeclValues(AnalysisDataTy& AD) {
91
 
      DeclBV.resize(AD.getNumDecls());
92
 
      DeclBV.reset();
93
 
    }
94
 
 
95
 
    void setDeclValues(AnalysisDataTy& AD) {
96
 
      DeclBV.resize(AD.getNumDecls());
97
 
      DeclBV.set();
98
 
    }
99
 
 
100
 
    void resetValues(AnalysisDataTy& AD) {
101
 
      resetDeclValues(AD);
102
 
    }
103
 
 
104
 
    bool operator==(const ValTy& RHS) const {
105
 
      assert (sizesEqual(RHS));
106
 
      return DeclBV == RHS.DeclBV;
107
 
    }
108
 
 
109
 
    void copyValues(const ValTy& RHS) { DeclBV = RHS.DeclBV; }
110
 
 
111
 
    llvm::BitVector::reference getBit(unsigned i) {
112
 
      return DeclBV[i];
113
 
    }
114
 
 
115
 
    bool getBit(unsigned i) const {
116
 
      return DeclBV[i];
117
 
    }
118
 
 
119
 
    llvm::BitVector::reference
120
 
    operator()(const NamedDecl *ND, const AnalysisDataTy& AD) {
121
 
      return getBit(AD.getIdx(ND));
122
 
    }
123
 
 
124
 
    bool operator()(const NamedDecl *ND, const AnalysisDataTy& AD) const {
125
 
      return getBit(AD.getIdx(ND));
126
 
    }
127
 
 
128
 
    llvm::BitVector::reference getDeclBit(unsigned i) { return DeclBV[i]; }
129
 
    const llvm::BitVector::reference getDeclBit(unsigned i) const {
130
 
      return const_cast<llvm::BitVector&>(DeclBV)[i];
131
 
    }
132
 
 
133
 
    ValTy& operator|=(const ValTy& RHS) {
134
 
      assert (sizesEqual(RHS));
135
 
      DeclBV |= RHS.DeclBV;
136
 
      return *this;
137
 
    }
138
 
 
139
 
    ValTy& operator&=(const ValTy& RHS) {
140
 
      assert (sizesEqual(RHS));
141
 
      DeclBV &= RHS.DeclBV;
142
 
      return *this;
143
 
    }
144
 
 
145
 
    ValTy& OrDeclBits(const ValTy& RHS) {
146
 
      return operator|=(RHS);
147
 
    }
148
 
 
149
 
    ValTy& AndDeclBits(const ValTy& RHS) {
150
 
      return operator&=(RHS);
151
 
    }
152
 
 
153
 
    bool sizesEqual(const ValTy& RHS) const {
154
 
      return DeclBV.size() == RHS.DeclBV.size();
155
 
    }
156
 
  };
157
 
 
158
 
  //===--------------------------------------------------------------------===//
159
 
  // Some useful merge operations.
160
 
  //===--------------------------------------------------------------------===//
161
 
 
162
 
  struct Union { void operator()(ValTy& Dst, ValTy& Src) { Dst |= Src; } };
163
 
  struct Intersect { void operator()(ValTy& Dst, ValTy& Src) { Dst &= Src; } };
164
 
};
165
 
 
166
 
 
167
 
struct StmtDeclBitVector_Types {
168
 
 
169
 
  //===--------------------------------------------------------------------===//
170
 
  // AnalysisDataTy - Whole-function meta data.
171
 
  //===--------------------------------------------------------------------===//
172
 
 
173
 
  class AnalysisDataTy : public DeclBitVector_Types::AnalysisDataTy {
174
 
    ASTContext *ctx;
175
 
    CFG* cfg;
176
 
  public:
177
 
    AnalysisDataTy() : ctx(0), cfg(0) {}
178
 
    virtual ~AnalysisDataTy() {}
179
 
 
180
 
    void setContext(ASTContext &c) { ctx = &c; }
181
 
    ASTContext &getContext() {
182
 
      assert(ctx && "ASTContext should not be NULL.");
183
 
      return *ctx;
184
 
    }
185
 
 
186
 
    void setCFG(CFG& c) { cfg = &c; }
187
 
    CFG& getCFG() { assert(cfg && "CFG should not be NULL."); return *cfg; }
188
 
 
189
 
    bool isTracked(const Stmt *S) { return cfg->isBlkExpr(S); }
190
 
    using DeclBitVector_Types::AnalysisDataTy::isTracked;
191
 
 
192
 
    unsigned getIdx(const Stmt *S) const {
193
 
      CFG::BlkExprNumTy I = cfg->getBlkExprNum(S);
194
 
      assert(I && "Stmtession not tracked for bitvector.");
195
 
      return I;
196
 
    }
197
 
    using DeclBitVector_Types::AnalysisDataTy::getIdx;
198
 
 
199
 
    unsigned getNumBlkExprs() const { return cfg->getNumBlkExprs(); }
200
 
  };
201
 
 
202
 
  //===--------------------------------------------------------------------===//
203
 
  // ValTy - Dataflow value.
204
 
  //===--------------------------------------------------------------------===//
205
 
 
206
 
  class ValTy : public DeclBitVector_Types::ValTy {
207
 
    llvm::BitVector BlkExprBV;
208
 
    typedef DeclBitVector_Types::ValTy ParentTy;
209
 
 
210
 
    static inline ParentTy& ParentRef(ValTy& X) {
211
 
      return static_cast<ParentTy&>(X);
212
 
    }
213
 
 
214
 
    static inline const ParentTy& ParentRef(const ValTy& X) {
215
 
      return static_cast<const ParentTy&>(X);
216
 
    }
217
 
 
218
 
  public:
219
 
 
220
 
    void resetBlkExprValues(AnalysisDataTy& AD) {
221
 
      BlkExprBV.resize(AD.getNumBlkExprs());
222
 
      BlkExprBV.reset();
223
 
    }
224
 
 
225
 
    void setBlkExprValues(AnalysisDataTy& AD) {
226
 
      BlkExprBV.resize(AD.getNumBlkExprs());
227
 
      BlkExprBV.set();
228
 
    }
229
 
 
230
 
    void resetValues(AnalysisDataTy& AD) {
231
 
      resetDeclValues(AD);
232
 
      resetBlkExprValues(AD);
233
 
    }
234
 
 
235
 
    void setValues(AnalysisDataTy& AD) {
236
 
      setDeclValues(AD);
237
 
      setBlkExprValues(AD);
238
 
    }
239
 
 
240
 
    bool operator==(const ValTy& RHS) const {
241
 
      return ParentRef(*this) == ParentRef(RHS)
242
 
          && BlkExprBV == RHS.BlkExprBV;
243
 
    }
244
 
 
245
 
    void copyValues(const ValTy& RHS) {
246
 
      ParentRef(*this).copyValues(ParentRef(RHS));
247
 
      BlkExprBV = RHS.BlkExprBV;
248
 
    }
249
 
 
250
 
    llvm::BitVector::reference
251
 
    operator()(const Stmt *S, const AnalysisDataTy& AD) {
252
 
      return BlkExprBV[AD.getIdx(S)];
253
 
    }
254
 
    const llvm::BitVector::reference
255
 
    operator()(const Stmt *S, const AnalysisDataTy& AD) const {
256
 
      return const_cast<ValTy&>(*this)(S,AD);
257
 
    }
258
 
 
259
 
    using DeclBitVector_Types::ValTy::operator();
260
 
 
261
 
 
262
 
    llvm::BitVector::reference getStmtBit(unsigned i) { return BlkExprBV[i]; }
263
 
    const llvm::BitVector::reference getStmtBit(unsigned i) const {
264
 
      return const_cast<llvm::BitVector&>(BlkExprBV)[i];
265
 
    }
266
 
 
267
 
    ValTy& OrBlkExprBits(const ValTy& RHS) {
268
 
      BlkExprBV |= RHS.BlkExprBV;
269
 
      return *this;
270
 
    }
271
 
 
272
 
    ValTy& AndBlkExprBits(const ValTy& RHS) {
273
 
      BlkExprBV &= RHS.BlkExprBV;
274
 
      return *this;
275
 
    }
276
 
 
277
 
    ValTy& operator|=(const ValTy& RHS) {
278
 
      assert (sizesEqual(RHS));
279
 
      ParentRef(*this) |= ParentRef(RHS);
280
 
      BlkExprBV |= RHS.BlkExprBV;
281
 
      return *this;
282
 
    }
283
 
 
284
 
    ValTy& operator&=(const ValTy& RHS) {
285
 
      assert (sizesEqual(RHS));
286
 
      ParentRef(*this) &= ParentRef(RHS);
287
 
      BlkExprBV &= RHS.BlkExprBV;
288
 
      return *this;
289
 
    }
290
 
 
291
 
    bool sizesEqual(const ValTy& RHS) const {
292
 
      return ParentRef(*this).sizesEqual(ParentRef(RHS))
293
 
          && BlkExprBV.size() == RHS.BlkExprBV.size();
294
 
    }
295
 
  };
296
 
 
297
 
  //===--------------------------------------------------------------------===//
298
 
  // Some useful merge operations.
299
 
  //===--------------------------------------------------------------------===//
300
 
 
301
 
  struct Union { void operator()(ValTy& Dst, ValTy& Src) { Dst |= Src; } };
302
 
  struct Intersect { void operator()(ValTy& Dst, ValTy& Src) { Dst &= Src; } };
303
 
 
304
 
};
305
 
} // end namespace clang
306
 
 
307
 
#endif