1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
//== SymbolManager.h - Management of Symbolic Values ------------*- C++ -*--==//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines SymbolManager, a class that manages symbolic values
// created for use by GRExprEngine and related classes.
//
//===----------------------------------------------------------------------===//
#include "clang/Analysis/PathSensitive/SymbolManager.h"
using namespace clang;
SymbolID SymbolManager::getSymbol(VarDecl* D) {
assert (isa<ParmVarDecl>(D) || D->hasGlobalStorage());
llvm::FoldingSetNodeID profile;
ParmVarDecl* PD = dyn_cast<ParmVarDecl>(D);
if (PD)
SymbolDataParmVar::Profile(profile, PD);
else
SymbolDataGlobalVar::Profile(profile, D);
void* InsertPos;
SymbolData* SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
if (SD)
return SD->getSymbol();
if (PD) {
SD = (SymbolData*) BPAlloc.Allocate<SymbolDataParmVar>();
new (SD) SymbolDataParmVar(SymbolCounter, PD);
}
else {
SD = (SymbolData*) BPAlloc.Allocate<SymbolDataGlobalVar>();
new (SD) SymbolDataGlobalVar(SymbolCounter, D);
}
DataSet.InsertNode(SD, InsertPos);
DataMap[SymbolCounter] = SD;
return SymbolCounter++;
}
SymbolID SymbolManager::getContentsOfSymbol(SymbolID sym) {
llvm::FoldingSetNodeID profile;
SymbolDataContentsOf::Profile(profile, sym);
void* InsertPos;
SymbolData* SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
if (SD)
return SD->getSymbol();
SD = (SymbolData*) BPAlloc.Allocate<SymbolDataContentsOf>();
new (SD) SymbolDataContentsOf(SymbolCounter, sym);
DataSet.InsertNode(SD, InsertPos);
DataMap[SymbolCounter] = SD;
return SymbolCounter++;
}
SymbolID SymbolManager::getConjuredSymbol(Expr* E, unsigned Count) {
llvm::FoldingSetNodeID profile;
SymbolConjured::Profile(profile, E, Count);
void* InsertPos;
SymbolData* SD = DataSet.FindNodeOrInsertPos(profile, InsertPos);
if (SD)
return SD->getSymbol();
SD = (SymbolData*) BPAlloc.Allocate<SymbolConjured>();
new (SD) SymbolConjured(SymbolCounter, E, Count);
DataSet.InsertNode(SD, InsertPos);
DataMap[SymbolCounter] = SD;
return SymbolCounter++;
}
const SymbolData& SymbolManager::getSymbolData(SymbolID Sym) const {
DataMapTy::const_iterator I = DataMap.find(Sym);
assert (I != DataMap.end());
return *I->second;
}
QualType SymbolData::getType(const SymbolManager& SymMgr) const {
switch (getKind()) {
default:
assert (false && "getType() not implemented for this symbol.");
case ParmKind:
return cast<SymbolDataParmVar>(this)->getDecl()->getType();
case GlobalKind:
return cast<SymbolDataGlobalVar>(this)->getDecl()->getType();
case ContentsOfKind: {
SymbolID x = cast<SymbolDataContentsOf>(this)->getContainerSymbol();
QualType T = SymMgr.getSymbolData(x).getType(SymMgr);
return T->getAsPointerType()->getPointeeType();
}
case ConjuredKind:
return cast<SymbolConjured>(this)->getExpr()->getType();
}
}
SymbolManager::~SymbolManager() {}
|
