PathDiagnostic.h revision 3183075ff18449594090aacb1793d66f58a95429
1//===--- PathDiagnostic.h - Path-Specific Diagnostic Handling ---*- 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 the PathDiagnostic-related interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_PATH_DIAGNOSTIC_H 15#define LLVM_CLANG_PATH_DIAGNOSTIC_H 16 17#include "clang/Basic/SourceLocation.h" 18#include "clang/Analysis/ProgramPoint.h" 19#include "llvm/ADT/FoldingSet.h" 20#include "llvm/ADT/IntrusiveRefCntPtr.h" 21#include "llvm/ADT/PointerUnion.h" 22#include "llvm/ADT/Optional.h" 23#include <deque> 24#include <iterator> 25#include <string> 26#include <vector> 27 28namespace clang { 29 30class AnalysisDeclContext; 31class BinaryOperator; 32class CompoundStmt; 33class Decl; 34class LocationContext; 35class MemberExpr; 36class ParentMap; 37class ProgramPoint; 38class SourceManager; 39class Stmt; 40 41namespace ento { 42 43class ExplodedNode; 44 45//===----------------------------------------------------------------------===// 46// High-level interface for handlers of path-sensitive diagnostics. 47//===----------------------------------------------------------------------===// 48 49class PathDiagnostic; 50 51class PathDiagnosticConsumer { 52 virtual void anchor(); 53public: 54 PathDiagnosticConsumer() : flushed(false) {} 55 virtual ~PathDiagnosticConsumer(); 56 57 void FlushDiagnostics(SmallVectorImpl<std::string> *FilesMade); 58 59 virtual void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags, 60 SmallVectorImpl<std::string> *FilesMade) 61 = 0; 62 63 virtual StringRef getName() const = 0; 64 65 void HandlePathDiagnostic(PathDiagnostic *D); 66 67 enum PathGenerationScheme { Minimal, Extensive }; 68 virtual PathGenerationScheme getGenerationScheme() const { return Minimal; } 69 virtual bool supportsLogicalOpControlFlow() const { return false; } 70 virtual bool supportsAllBlockEdges() const { return false; } 71 virtual bool useVerboseDescription() const { return true; } 72 73 /// Return true if the PathDiagnosticConsumer supports individual 74 /// PathDiagnostics that span multiple files. 75 virtual bool supportsCrossFileDiagnostics() const { return false; } 76 77protected: 78 bool flushed; 79 llvm::FoldingSet<PathDiagnostic> Diags; 80}; 81 82//===----------------------------------------------------------------------===// 83// Path-sensitive diagnostics. 84//===----------------------------------------------------------------------===// 85 86class PathDiagnosticRange : public SourceRange { 87public: 88 bool isPoint; 89 90 PathDiagnosticRange(const SourceRange &R, bool isP = false) 91 : SourceRange(R), isPoint(isP) {} 92 93 PathDiagnosticRange() : isPoint(false) {} 94}; 95 96typedef llvm::PointerUnion<const LocationContext*, AnalysisDeclContext*> 97 LocationOrAnalysisDeclContext; 98 99class PathDiagnosticLocation { 100private: 101 enum Kind { RangeK, SingleLocK, StmtK, DeclK } K; 102 const Stmt *S; 103 const Decl *D; 104 const SourceManager *SM; 105 FullSourceLoc Loc; 106 PathDiagnosticRange Range; 107 108 PathDiagnosticLocation(SourceLocation L, const SourceManager &sm, 109 Kind kind) 110 : K(kind), S(0), D(0), SM(&sm), 111 Loc(genLocation(L)), Range(genRange()) { 112 assert(Loc.isValid()); 113 assert(Range.isValid()); 114 } 115 116 FullSourceLoc 117 genLocation(SourceLocation L = SourceLocation(), 118 LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext*)0) const; 119 120 PathDiagnosticRange 121 genRange(LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext*)0) const; 122 123public: 124 /// Create an invalid location. 125 PathDiagnosticLocation() 126 : K(SingleLocK), S(0), D(0), SM(0) {} 127 128 /// Create a location corresponding to the given statement. 129 PathDiagnosticLocation(const Stmt *s, 130 const SourceManager &sm, 131 LocationOrAnalysisDeclContext lac) 132 : K(StmtK), S(s), D(0), SM(&sm), 133 Loc(genLocation(SourceLocation(), lac)), 134 Range(genRange(lac)) { 135 assert(S); 136 assert(Loc.isValid()); 137 assert(Range.isValid()); 138 } 139 140 /// Create a location corresponding to the given declaration. 141 PathDiagnosticLocation(const Decl *d, const SourceManager &sm) 142 : K(DeclK), S(0), D(d), SM(&sm), 143 Loc(genLocation()), Range(genRange()) { 144 assert(D); 145 assert(Loc.isValid()); 146 assert(Range.isValid()); 147 } 148 149 /// Create a location corresponding to the given declaration. 150 static PathDiagnosticLocation create(const Decl *D, 151 const SourceManager &SM) { 152 return PathDiagnosticLocation(D, SM); 153 } 154 155 /// Create a location for the beginning of the declaration. 156 static PathDiagnosticLocation createBegin(const Decl *D, 157 const SourceManager &SM); 158 159 /// Create a location for the beginning of the statement. 160 static PathDiagnosticLocation createBegin(const Stmt *S, 161 const SourceManager &SM, 162 const LocationOrAnalysisDeclContext LAC); 163 164 /// Create the location for the operator of the binary expression. 165 /// Assumes the statement has a valid location. 166 static PathDiagnosticLocation createOperatorLoc(const BinaryOperator *BO, 167 const SourceManager &SM); 168 169 /// For member expressions, return the location of the '.' or '->'. 170 /// Assumes the statement has a valid location. 171 static PathDiagnosticLocation createMemberLoc(const MemberExpr *ME, 172 const SourceManager &SM); 173 174 /// Create a location for the beginning of the compound statement. 175 /// Assumes the statement has a valid location. 176 static PathDiagnosticLocation createBeginBrace(const CompoundStmt *CS, 177 const SourceManager &SM); 178 179 /// Create a location for the end of the compound statement. 180 /// Assumes the statement has a valid location. 181 static PathDiagnosticLocation createEndBrace(const CompoundStmt *CS, 182 const SourceManager &SM); 183 184 /// Create a location for the beginning of the enclosing declaration body. 185 /// Defaults to the beginning of the first statement in the declaration body. 186 static PathDiagnosticLocation createDeclBegin(const LocationContext *LC, 187 const SourceManager &SM); 188 189 /// Constructs a location for the end of the enclosing declaration body. 190 /// Defaults to the end of brace. 191 static PathDiagnosticLocation createDeclEnd(const LocationContext *LC, 192 const SourceManager &SM); 193 194 /// Create a location corresponding to the given valid ExplodedNode. 195 static PathDiagnosticLocation create(const ProgramPoint& P, 196 const SourceManager &SMng); 197 198 /// Create a location corresponding to the next valid ExplodedNode as end 199 /// of path location. 200 static PathDiagnosticLocation createEndOfPath(const ExplodedNode* N, 201 const SourceManager &SM); 202 203 /// Convert the given location into a single kind location. 204 static PathDiagnosticLocation createSingleLocation( 205 const PathDiagnosticLocation &PDL); 206 207 bool operator==(const PathDiagnosticLocation &X) const { 208 return K == X.K && Loc == X.Loc && Range == X.Range; 209 } 210 211 bool operator!=(const PathDiagnosticLocation &X) const { 212 return !(*this == X); 213 } 214 215 bool isValid() const { 216 return SM != 0; 217 } 218 219 FullSourceLoc asLocation() const { 220 return Loc; 221 } 222 223 PathDiagnosticRange asRange() const { 224 return Range; 225 } 226 227 const Stmt *asStmt() const { assert(isValid()); return S; } 228 const Decl *asDecl() const { assert(isValid()); return D; } 229 230 bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; } 231 232 void invalidate() { 233 *this = PathDiagnosticLocation(); 234 } 235 236 void flatten(); 237 238 const SourceManager& getManager() const { assert(isValid()); return *SM; } 239 240 void Profile(llvm::FoldingSetNodeID &ID) const; 241}; 242 243class PathDiagnosticLocationPair { 244private: 245 PathDiagnosticLocation Start, End; 246public: 247 PathDiagnosticLocationPair(const PathDiagnosticLocation &start, 248 const PathDiagnosticLocation &end) 249 : Start(start), End(end) {} 250 251 const PathDiagnosticLocation &getStart() const { return Start; } 252 const PathDiagnosticLocation &getEnd() const { return End; } 253 254 void flatten() { 255 Start.flatten(); 256 End.flatten(); 257 } 258 259 void Profile(llvm::FoldingSetNodeID &ID) const { 260 Start.Profile(ID); 261 End.Profile(ID); 262 } 263}; 264 265//===----------------------------------------------------------------------===// 266// Path "pieces" for path-sensitive diagnostics. 267//===----------------------------------------------------------------------===// 268 269class PathDiagnosticPiece : public RefCountedBaseVPTR { 270public: 271 enum Kind { ControlFlow, Event, Macro, Call }; 272 enum DisplayHint { Above, Below }; 273 274private: 275 const std::string str; 276 const Kind kind; 277 const DisplayHint Hint; 278 std::vector<SourceRange> ranges; 279 280 // Do not implement: 281 PathDiagnosticPiece(); 282 PathDiagnosticPiece(const PathDiagnosticPiece &P); 283 PathDiagnosticPiece& operator=(const PathDiagnosticPiece &P); 284 285protected: 286 PathDiagnosticPiece(StringRef s, Kind k, DisplayHint hint = Below); 287 288 PathDiagnosticPiece(Kind k, DisplayHint hint = Below); 289 290public: 291 virtual ~PathDiagnosticPiece(); 292 293 const std::string& getString() const { return str; } 294 295 /// getDisplayHint - Return a hint indicating where the diagnostic should 296 /// be displayed by the PathDiagnosticConsumer. 297 DisplayHint getDisplayHint() const { return Hint; } 298 299 virtual PathDiagnosticLocation getLocation() const = 0; 300 virtual void flattenLocations() = 0; 301 302 Kind getKind() const { return kind; } 303 304 void addRange(SourceRange R) { 305 if (!R.isValid()) 306 return; 307 ranges.push_back(R); 308 } 309 310 void addRange(SourceLocation B, SourceLocation E) { 311 if (!B.isValid() || !E.isValid()) 312 return; 313 ranges.push_back(SourceRange(B,E)); 314 } 315 316 typedef const SourceRange* range_iterator; 317 318 range_iterator ranges_begin() const { 319 return ranges.empty() ? NULL : &ranges[0]; 320 } 321 322 range_iterator ranges_end() const { 323 return ranges_begin() + ranges.size(); 324 } 325 326 static inline bool classof(const PathDiagnosticPiece *P) { 327 return true; 328 } 329 330 virtual void Profile(llvm::FoldingSetNodeID &ID) const; 331}; 332 333 334class PathPieces : 335 public std::deque<IntrusiveRefCntPtr<PathDiagnosticPiece> > { 336public: 337 ~PathPieces(); 338}; 339 340class PathDiagnosticSpotPiece : public PathDiagnosticPiece { 341private: 342 PathDiagnosticLocation Pos; 343public: 344 PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos, 345 StringRef s, 346 PathDiagnosticPiece::Kind k, 347 bool addPosRange = true) 348 : PathDiagnosticPiece(s, k), Pos(pos) { 349 assert(Pos.isValid() && Pos.asLocation().isValid() && 350 "PathDiagnosticSpotPiece's must have a valid location."); 351 if (addPosRange && Pos.hasRange()) addRange(Pos.asRange()); 352 } 353 354 PathDiagnosticLocation getLocation() const { return Pos; } 355 virtual void flattenLocations() { Pos.flatten(); } 356 357 virtual void Profile(llvm::FoldingSetNodeID &ID) const; 358}; 359 360class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece { 361 llvm::Optional<bool> IsPrunable; 362public: 363 PathDiagnosticEventPiece(const PathDiagnosticLocation &pos, 364 StringRef s, bool addPosRange = true) 365 : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {} 366 367 ~PathDiagnosticEventPiece(); 368 369 /// Mark the diagnostic piece as being potentially prunable. This 370 /// flag may have been previously set, at which point it will not 371 /// be reset unless one specifies to do so. 372 void setPrunable(bool isPrunable, bool override = false) { 373 if (IsPrunable.hasValue() && !override) 374 return; 375 IsPrunable = isPrunable; 376 } 377 378 /// Return true if the diagnostic piece is prunable. 379 bool isPrunable() const { 380 return IsPrunable.hasValue() ? IsPrunable.getValue() : false; 381 } 382 383 static inline bool classof(const PathDiagnosticPiece *P) { 384 return P->getKind() == Event; 385 } 386}; 387 388class PathDiagnosticCallPiece : public PathDiagnosticPiece { 389 PathDiagnosticCallPiece(const Decl *callerD, 390 const PathDiagnosticLocation &callReturnPos) 391 : PathDiagnosticPiece(Call), Caller(callerD), Callee(0), 392 NoExit(false), callReturn(callReturnPos) {} 393 394 PathDiagnosticCallPiece(PathPieces &oldPath, const Decl *caller) 395 : PathDiagnosticPiece(Call), Caller(caller), Callee(0), 396 NoExit(true), path(oldPath) {} 397 398 const Decl *Caller; 399 const Decl *Callee; 400 401 // Flag signifying that this diagnostic has only call enter and no matching 402 // call exit. 403 bool NoExit; 404 405public: 406 PathDiagnosticLocation callEnter; 407 PathDiagnosticLocation callEnterWithin; 408 PathDiagnosticLocation callReturn; 409 PathPieces path; 410 411 virtual ~PathDiagnosticCallPiece(); 412 413 const Decl *getCaller() const { return Caller; } 414 415 const Decl *getCallee() const { return Callee; } 416 void setCallee(const CallEnter &CE, const SourceManager &SM); 417 418 virtual PathDiagnosticLocation getLocation() const { 419 return callEnter; 420 } 421 422 IntrusiveRefCntPtr<PathDiagnosticEventPiece> getCallEnterEvent() const; 423 IntrusiveRefCntPtr<PathDiagnosticEventPiece> 424 getCallEnterWithinCallerEvent() const; 425 IntrusiveRefCntPtr<PathDiagnosticEventPiece> getCallExitEvent() const; 426 427 virtual void flattenLocations() { 428 callEnter.flatten(); 429 callReturn.flatten(); 430 for (PathPieces::iterator I = path.begin(), 431 E = path.end(); I != E; ++I) (*I)->flattenLocations(); 432 } 433 434 static PathDiagnosticCallPiece *construct(const ExplodedNode *N, 435 const CallExit &CE, 436 const SourceManager &SM); 437 438 static PathDiagnosticCallPiece *construct(PathPieces &pieces, 439 const Decl *caller); 440 441 virtual void Profile(llvm::FoldingSetNodeID &ID) const; 442 443 static inline bool classof(const PathDiagnosticPiece *P) { 444 return P->getKind() == Call; 445 } 446}; 447 448class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece { 449 std::vector<PathDiagnosticLocationPair> LPairs; 450public: 451 PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos, 452 const PathDiagnosticLocation &endPos, 453 StringRef s) 454 : PathDiagnosticPiece(s, ControlFlow) { 455 LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos)); 456 } 457 458 PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos, 459 const PathDiagnosticLocation &endPos) 460 : PathDiagnosticPiece(ControlFlow) { 461 LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos)); 462 } 463 464 ~PathDiagnosticControlFlowPiece(); 465 466 PathDiagnosticLocation getStartLocation() const { 467 assert(!LPairs.empty() && 468 "PathDiagnosticControlFlowPiece needs at least one location."); 469 return LPairs[0].getStart(); 470 } 471 472 PathDiagnosticLocation getEndLocation() const { 473 assert(!LPairs.empty() && 474 "PathDiagnosticControlFlowPiece needs at least one location."); 475 return LPairs[0].getEnd(); 476 } 477 478 void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); } 479 480 virtual PathDiagnosticLocation getLocation() const { 481 return getStartLocation(); 482 } 483 484 typedef std::vector<PathDiagnosticLocationPair>::iterator iterator; 485 iterator begin() { return LPairs.begin(); } 486 iterator end() { return LPairs.end(); } 487 488 virtual void flattenLocations() { 489 for (iterator I=begin(), E=end(); I!=E; ++I) I->flatten(); 490 } 491 492 typedef std::vector<PathDiagnosticLocationPair>::const_iterator 493 const_iterator; 494 const_iterator begin() const { return LPairs.begin(); } 495 const_iterator end() const { return LPairs.end(); } 496 497 static inline bool classof(const PathDiagnosticPiece *P) { 498 return P->getKind() == ControlFlow; 499 } 500 501 virtual void Profile(llvm::FoldingSetNodeID &ID) const; 502}; 503 504class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece { 505public: 506 PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos) 507 : PathDiagnosticSpotPiece(pos, "", Macro) {} 508 509 ~PathDiagnosticMacroPiece(); 510 511 PathPieces subPieces; 512 513 bool containsEvent() const; 514 515 virtual void flattenLocations() { 516 PathDiagnosticSpotPiece::flattenLocations(); 517 for (PathPieces::iterator I = subPieces.begin(), 518 E = subPieces.end(); I != E; ++I) (*I)->flattenLocations(); 519 } 520 521 static inline bool classof(const PathDiagnosticPiece *P) { 522 return P->getKind() == Macro; 523 } 524 525 virtual void Profile(llvm::FoldingSetNodeID &ID) const; 526}; 527 528/// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive 529/// diagnostic. It represents an ordered-collection of PathDiagnosticPieces, 530/// each which represent the pieces of the path. 531class PathDiagnostic : public llvm::FoldingSetNode { 532 std::string BugType; 533 std::string Desc; 534 std::string Category; 535 std::deque<std::string> OtherDesc; 536 PathPieces pathImpl; 537 llvm::SmallVector<PathPieces *, 3> pathStack; 538public: 539 const PathPieces &path; 540 541 /// Return the path currently used by builders for constructing the 542 /// PathDiagnostic. 543 PathPieces &getActivePath() { 544 if (pathStack.empty()) 545 return pathImpl; 546 return *pathStack.back(); 547 } 548 549 /// Return a mutable version of 'path'. 550 PathPieces &getMutablePieces() { 551 return pathImpl; 552 } 553 554 /// Return the unrolled size of the path. 555 unsigned full_size(); 556 557 void pushActivePath(PathPieces *p) { pathStack.push_back(p); } 558 void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); } 559 560 PathDiagnostic(); 561 PathDiagnostic(StringRef bugtype, StringRef desc, 562 StringRef category); 563 564 ~PathDiagnostic(); 565 566 StringRef getDescription() const { return Desc; } 567 StringRef getBugType() const { return BugType; } 568 StringRef getCategory() const { return Category; } 569 570 571 typedef std::deque<std::string>::const_iterator meta_iterator; 572 meta_iterator meta_begin() const { return OtherDesc.begin(); } 573 meta_iterator meta_end() const { return OtherDesc.end(); } 574 void addMeta(StringRef s) { OtherDesc.push_back(s); } 575 576 PathDiagnosticLocation getLocation() const; 577 578 void flattenLocations() { 579 for (PathPieces::iterator I = pathImpl.begin(), E = pathImpl.end(); 580 I != E; ++I) (*I)->flattenLocations(); 581 } 582 583 void Profile(llvm::FoldingSetNodeID &ID) const; 584 585 void FullProfile(llvm::FoldingSetNodeID &ID) const; 586}; 587 588} // end GR namespace 589 590} //end clang namespace 591 592#endif 593