1 //== CheckerContext.h - Context info for path-sensitive checkers--*- 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 defines CheckerContext that provides contextual info for 11 // path-sensitive checkers. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_SA_CORE_PATHSENSITIVE_CHECKERCONTEXT 16 #define LLVM_CLANG_SA_CORE_PATHSENSITIVE_CHECKERCONTEXT 17 18 #include "clang/Analysis/Support/SaveAndRestore.h" 19 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h" 20 21 namespace clang { 22 23 namespace ento { 24 25 class CheckerContext { 26 ExplodedNodeSet &Dst; 27 StmtNodeBuilder &B; 28 ExprEngine &Eng; 29 ExplodedNode *Pred; 30 SaveAndRestore<bool> OldSink; 31 const void *checkerTag; 32 SaveAndRestore<ProgramPoint::Kind> OldPointKind; 33 SaveOr OldHasGen; 34 const GRState *ST; 35 const Stmt *statement; 36 const unsigned size; 37 public: 38 bool *respondsToCallback; 39 public: 40 CheckerContext(ExplodedNodeSet &dst, StmtNodeBuilder &builder, 41 ExprEngine &eng, ExplodedNode *pred, 42 const void *tag, ProgramPoint::Kind K, 43 bool *respondsToCB = 0, 44 const Stmt *stmt = 0, const GRState *st = 0) 45 : Dst(dst), B(builder), Eng(eng), Pred(pred), 46 OldSink(B.BuildSinks), 47 checkerTag(tag), 48 OldPointKind(B.PointKind, K), 49 OldHasGen(B.hasGeneratedNode), 50 ST(st), statement(stmt), size(Dst.size()), 51 respondsToCallback(respondsToCB) {} 52 53 ~CheckerContext(); 54 55 ExprEngine &getEngine() { 56 return Eng; 57 } 58 59 AnalysisManager &getAnalysisManager() { 60 return Eng.getAnalysisManager(); 61 } 62 63 ConstraintManager &getConstraintManager() { 64 return Eng.getConstraintManager(); 65 } 66 67 StoreManager &getStoreManager() { 68 return Eng.getStoreManager(); 69 } 70 71 ExplodedNodeSet &getNodeSet() { return Dst; } 72 StmtNodeBuilder &getNodeBuilder() { return B; } 73 ExplodedNode *&getPredecessor() { return Pred; } 74 const GRState *getState() { return ST ? ST : B.GetState(Pred); } 75 const Stmt *getStmt() const { return statement; } 76 77 ASTContext &getASTContext() { 78 return Eng.getContext(); 79 } 80 81 BugReporter &getBugReporter() { 82 return Eng.getBugReporter(); 83 } 84 85 SourceManager &getSourceManager() { 86 return getBugReporter().getSourceManager(); 87 } 88 89 SValBuilder &getSValBuilder() { 90 return Eng.getSValBuilder(); 91 } 92 93 ExplodedNode *generateNode(bool autoTransition = true) { 94 assert(statement && "Only transitions with statements currently supported"); 95 ExplodedNode *N = generateNodeImpl(statement, getState(), false, 96 checkerTag); 97 if (N && autoTransition) 98 Dst.Add(N); 99 return N; 100 } 101 102 ExplodedNode *generateNode(const Stmt *stmt, const GRState *state, 103 bool autoTransition = true, const void *tag = 0) { 104 assert(state); 105 ExplodedNode *N = generateNodeImpl(stmt, state, false, 106 tag ? tag : checkerTag); 107 if (N && autoTransition) 108 addTransition(N); 109 return N; 110 } 111 112 ExplodedNode *generateNode(const GRState *state, ExplodedNode *pred, 113 bool autoTransition = true) { 114 assert(statement && "Only transitions with statements currently supported"); 115 ExplodedNode *N = generateNodeImpl(statement, state, pred, false); 116 if (N && autoTransition) 117 addTransition(N); 118 return N; 119 } 120 121 ExplodedNode *generateNode(const GRState *state, bool autoTransition = true, 122 const void *tag = 0) { 123 assert(statement && "Only transitions with statements currently supported"); 124 ExplodedNode *N = generateNodeImpl(statement, state, false, 125 tag ? tag : checkerTag); 126 if (N && autoTransition) 127 addTransition(N); 128 return N; 129 } 130 131 ExplodedNode *generateSink(const Stmt *stmt, const GRState *state = 0) { 132 return generateNodeImpl(stmt, state ? state : getState(), true, 133 checkerTag); 134 } 135 136 ExplodedNode *generateSink(const GRState *state = 0) { 137 assert(statement && "Only transitions with statements currently supported"); 138 return generateNodeImpl(statement, state ? state : getState(), true, 139 checkerTag); 140 } 141 142 void addTransition(ExplodedNode *node) { 143 Dst.Add(node); 144 } 145 146 void addTransition(const GRState *state, const void *tag = 0) { 147 assert(state); 148 // If the 'state' is not new, we need to check if the cached state 'ST' 149 // is new. 150 if (state != getState() || (ST && ST != B.GetState(Pred))) 151 // state is new or equals to ST. 152 generateNode(state, true, tag); 153 else 154 Dst.Add(Pred); 155 } 156 157 void EmitReport(BugReport *R) { 158 Eng.getBugReporter().EmitReport(R); 159 } 160 161 AnalysisContext *getCurrentAnalysisContext() const { 162 return Pred->getLocationContext()->getAnalysisContext(); 163 } 164 165 private: 166 ExplodedNode *generateNodeImpl(const Stmt* stmt, const GRState *state, 167 bool markAsSink, const void *tag) { 168 ExplodedNode *node = B.generateNode(stmt, state, Pred, tag); 169 if (markAsSink && node) 170 node->markAsSink(); 171 return node; 172 } 173 174 ExplodedNode *generateNodeImpl(const Stmt* stmt, const GRState *state, 175 ExplodedNode *pred, bool markAsSink) { 176 ExplodedNode *node = B.generateNode(stmt, state, pred, checkerTag); 177 if (markAsSink && node) 178 node->markAsSink(); 179 return node; 180 } 181 }; 182 183 } // end GR namespace 184 185 } // end clang namespace 186 187 #endif 188
