contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/PathDiagnostic.cpp

   1 //===--- PathDiagnostic.cpp - 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 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/AST/DeclCXX.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/AST/ExprCXX.h"
  20 #include "clang/AST/ParentMap.h"
  21 #include "clang/AST/StmtCXX.h"
  22 #include "clang/Basic/SourceManager.h"
  23 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
  24 #include "llvm/ADT/SmallString.h"
  25 #include "llvm/ADT/StringExtras.h"
  26 #include "llvm/Support/raw_ostream.h"
  27
  28 using namespace clang;
  29 using namespace ento;
  30
  31 bool PathDiagnosticMacroPiece::containsEvent() const {
  32   for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end();
  33        I!=E; ++I) {
  34     if (isa<PathDiagnosticEventPiece>(*I))
  35       return true;
  36     if (PathDiagnosticMacroPiece *MP = dyn_cast<PathDiagnosticMacroPiece>(*I))
  37       if (MP->containsEvent())
  38         return true;
  39   }
  40   return false;
  41 }
  42
  43 static StringRef StripTrailingDots(StringRef s) {
  44   for (StringRef::size_type i = s.size(); i != 0; --i)
  45     if (s[i - 1] != '.')
  46       return s.substr(0, i);
  47   return "";
  48 }
  49
  50 PathDiagnosticPiece::PathDiagnosticPiece(StringRef s,
  51                                          Kind k, DisplayHint hint)
  52   : str(StripTrailingDots(s)), kind(k), Hint(hint),
  53     LastInMainSourceFile(false) {}
  54
  55 PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint)
  56   : kind(k), Hint(hint), LastInMainSourceFile(false) {}
  57
  58 PathDiagnosticPiece::~PathDiagnosticPiece() {}
  59 PathDiagnosticEventPiece::~PathDiagnosticEventPiece() {}
  60 PathDiagnosticCallPiece::~PathDiagnosticCallPiece() {}
  61 PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() {}
  62 PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() {}
  63
  64
  65 void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current,
  66                            bool ShouldFlattenMacros) const {
  67   for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) {
  68     PathDiagnosticPiece *Piece = I->get();
  69
  70     switch (Piece->getKind()) {
  71     case PathDiagnosticPiece::Call: {
  72       PathDiagnosticCallPiece *Call = cast<PathDiagnosticCallPiece>(Piece);
  73       IntrusiveRefCntPtr<PathDiagnosticEventPiece> CallEnter =
  74         Call->getCallEnterEvent();
  75       if (CallEnter)
  76         Current.push_back(CallEnter);
  77       Call->path.flattenTo(Primary, Primary, ShouldFlattenMacros);
  78       IntrusiveRefCntPtr<PathDiagnosticEventPiece> callExit =
  79         Call->getCallExitEvent();
  80       if (callExit)
  81         Current.push_back(callExit);
  82       break;
  83     }
  84     case PathDiagnosticPiece::Macro: {
  85       PathDiagnosticMacroPiece *Macro = cast<PathDiagnosticMacroPiece>(Piece);
  86       if (ShouldFlattenMacros) {
  87         Macro->subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros);
  88       } else {
  89         Current.push_back(Piece);
  90         PathPieces NewPath;
  91         Macro->subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros);
  92         // FIXME: This probably shouldn't mutate the original path piece.
  93         Macro->subPieces = NewPath;
  94       }
  95       break;
  96     }
  97     case PathDiagnosticPiece::Event:
  98     case PathDiagnosticPiece::ControlFlow:
  99       Current.push_back(Piece);
 100       break;
 101     }
 102   }
 103 }
 104
 105
 106 PathDiagnostic::~PathDiagnostic() {}
 107
 108 PathDiagnostic::PathDiagnostic(StringRef CheckName, const Decl *declWithIssue,
 109                                StringRef bugtype, StringRef verboseDesc,
 110                                StringRef shortDesc, StringRef category,
 111                                PathDiagnosticLocation LocationToUnique,
 112                                const Decl *DeclToUnique)
 113   : CheckName(CheckName),
 114     DeclWithIssue(declWithIssue),
 115     BugType(StripTrailingDots(bugtype)),
 116     VerboseDesc(StripTrailingDots(verboseDesc)),
 117     ShortDesc(StripTrailingDots(shortDesc)),
 118     Category(StripTrailingDots(category)),
 119     UniqueingLoc(LocationToUnique),
 120     UniqueingDecl(DeclToUnique),
 121     path(pathImpl) {}
 122
 123 static PathDiagnosticCallPiece *
 124 getFirstStackedCallToHeaderFile(PathDiagnosticCallPiece *CP,
 125                                 const SourceManager &SMgr) {
 126   SourceLocation CallLoc = CP->callEnter.asLocation();
 127
 128   // If the call is within a macro, don't do anything (for now).
 129   if (CallLoc.isMacroID())
 130     return nullptr;
 131
 132   assert(SMgr.isInMainFile(CallLoc) &&
 133          "The call piece should be in the main file.");
 134
 135   // Check if CP represents a path through a function outside of the main file.
 136   if (!SMgr.isInMainFile(CP->callEnterWithin.asLocation()))
 137     return CP;
 138
 139   const PathPieces &Path = CP->path;
 140   if (Path.empty())
 141     return nullptr;
 142
 143   // Check if the last piece in the callee path is a call to a function outside
 144   // of the main file.
 145   if (PathDiagnosticCallPiece *CPInner =
 146       dyn_cast<PathDiagnosticCallPiece>(Path.back())) {
 147     return getFirstStackedCallToHeaderFile(CPInner, SMgr);
 148   }
 149
 150   // Otherwise, the last piece is in the main file.
 151   return nullptr;
 152 }
 153
 154 void PathDiagnostic::resetDiagnosticLocationToMainFile() {
 155   if (path.empty())
 156     return;
 157
 158   PathDiagnosticPiece *LastP = path.back().get();
 159   assert(LastP);
 160   const SourceManager &SMgr = LastP->getLocation().getManager();
 161
 162   // We only need to check if the report ends inside headers, if the last piece
 163   // is a call piece.
 164   if (PathDiagnosticCallPiece *CP = dyn_cast<PathDiagnosticCallPiece>(LastP)) {
 165     CP = getFirstStackedCallToHeaderFile(CP, SMgr);
 166     if (CP) {
 167       // Mark the piece.
 168        CP->setAsLastInMainSourceFile();
 169
 170       // Update the path diagnostic message.
 171       const NamedDecl *ND = dyn_cast<NamedDecl>(CP->getCallee());
 172       if (ND) {
 173         SmallString<200> buf;
 174         llvm::raw_svector_ostream os(buf);
 175         os << " (within a call to '" << ND->getDeclName() << "')";
 176         appendToDesc(os.str());
 177       }
 178
 179       // Reset the report containing declaration and location.
 180       DeclWithIssue = CP->getCaller();
 181       Loc = CP->getLocation();
 182
 183       return;
 184     }
 185   }
 186 }
 187
 188 void PathDiagnosticConsumer::anchor() { }
 189
 190 PathDiagnosticConsumer::~PathDiagnosticConsumer() {
 191   // Delete the contents of the FoldingSet if it isn't empty already.
 192   for (llvm::FoldingSet<PathDiagnostic>::iterator it =
 193        Diags.begin(), et = Diags.end() ; it != et ; ++it) {
 194     delete &*it;
 195   }
 196 }
 197
 198 void PathDiagnosticConsumer::HandlePathDiagnostic(
 199     std::unique_ptr<PathDiagnostic> D) {
 200   if (!D || D->path.empty())
 201     return;
 202
 203   // We need to flatten the locations (convert Stmt* to locations) because
 204   // the referenced statements may be freed by the time the diagnostics
 205   // are emitted.
 206   D->flattenLocations();
 207
 208   // If the PathDiagnosticConsumer does not support diagnostics that
 209   // cross file boundaries, prune out such diagnostics now.
 210   if (!supportsCrossFileDiagnostics()) {
 211     // Verify that the entire path is from the same FileID.
 212     FileID FID;
 213     const SourceManager &SMgr = D->path.front()->getLocation().getManager();
 214     SmallVector<const PathPieces *, 5> WorkList;
 215     WorkList.push_back(&D->path);
 216
 217     while (!WorkList.empty()) {
 218       const PathPieces &path = *WorkList.pop_back_val();
 219
 220       for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E;
 221            ++I) {
 222         const PathDiagnosticPiece *piece = I->get();
 223         FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc();
 224
 225         if (FID.isInvalid()) {
 226           FID = SMgr.getFileID(L);
 227         } else if (SMgr.getFileID(L) != FID)
 228           return; // FIXME: Emit a warning?
 229
 230         // Check the source ranges.
 231         ArrayRef<SourceRange> Ranges = piece->getRanges();
 232         for (ArrayRef<SourceRange>::iterator I = Ranges.begin(),
 233                                              E = Ranges.end(); I != E; ++I) {
 234           SourceLocation L = SMgr.getExpansionLoc(I->getBegin());
 235           if (!L.isFileID() || SMgr.getFileID(L) != FID)
 236             return; // FIXME: Emit a warning?
 237           L = SMgr.getExpansionLoc(I->getEnd());
 238           if (!L.isFileID() || SMgr.getFileID(L) != FID)
 239             return; // FIXME: Emit a warning?
 240         }
 241
 242         if (const PathDiagnosticCallPiece *call =
 243             dyn_cast<PathDiagnosticCallPiece>(piece)) {
 244           WorkList.push_back(&call->path);
 245         }
 246         else if (const PathDiagnosticMacroPiece *macro =
 247                  dyn_cast<PathDiagnosticMacroPiece>(piece)) {
 248           WorkList.push_back(&macro->subPieces);
 249         }
 250       }
 251     }
 252
 253     if (FID.isInvalid())
 254       return; // FIXME: Emit a warning?
 255   }
 256
 257   // Profile the node to see if we already have something matching it
 258   llvm::FoldingSetNodeID profile;
 259   D->Profile(profile);
 260   void *InsertPos = nullptr;
 261
 262   if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) {
 263     // Keep the PathDiagnostic with the shorter path.
 264     // Note, the enclosing routine is called in deterministic order, so the
 265     // results will be consistent between runs (no reason to break ties if the
 266     // size is the same).
 267     const unsigned orig_size = orig->full_size();
 268     const unsigned new_size = D->full_size();
 269     if (orig_size <= new_size)
 270       return;
 271
 272     assert(orig != D.get());
 273     Diags.RemoveNode(orig);
 274     delete orig;
 275   }
 276
 277   Diags.InsertNode(D.release());
 278 }
 279
 280 static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y);
 281 static Optional<bool>
 282 compareControlFlow(const PathDiagnosticControlFlowPiece &X,
 283                    const PathDiagnosticControlFlowPiece &Y) {
 284   FullSourceLoc XSL = X.getStartLocation().asLocation();
 285   FullSourceLoc YSL = Y.getStartLocation().asLocation();
 286   if (XSL != YSL)
 287     return XSL.isBeforeInTranslationUnitThan(YSL);
 288   FullSourceLoc XEL = X.getEndLocation().asLocation();
 289   FullSourceLoc YEL = Y.getEndLocation().asLocation();
 290   if (XEL != YEL)
 291     return XEL.isBeforeInTranslationUnitThan(YEL);
 292   return None;
 293 }
 294
 295 static Optional<bool> compareMacro(const PathDiagnosticMacroPiece &X,
 296                                    const PathDiagnosticMacroPiece &Y) {
 297   return comparePath(X.subPieces, Y.subPieces);
 298 }
 299
 300 static Optional<bool> compareCall(const PathDiagnosticCallPiece &X,
 301                                   const PathDiagnosticCallPiece &Y) {
 302   FullSourceLoc X_CEL = X.callEnter.asLocation();
 303   FullSourceLoc Y_CEL = Y.callEnter.asLocation();
 304   if (X_CEL != Y_CEL)
 305     return X_CEL.isBeforeInTranslationUnitThan(Y_CEL);
 306   FullSourceLoc X_CEWL = X.callEnterWithin.asLocation();
 307   FullSourceLoc Y_CEWL = Y.callEnterWithin.asLocation();
 308   if (X_CEWL != Y_CEWL)
 309     return X_CEWL.isBeforeInTranslationUnitThan(Y_CEWL);
 310   FullSourceLoc X_CRL = X.callReturn.asLocation();
 311   FullSourceLoc Y_CRL = Y.callReturn.asLocation();
 312   if (X_CRL != Y_CRL)
 313     return X_CRL.isBeforeInTranslationUnitThan(Y_CRL);
 314   return comparePath(X.path, Y.path);
 315 }
 316
 317 static Optional<bool> comparePiece(const PathDiagnosticPiece &X,
 318                                    const PathDiagnosticPiece &Y) {
 319   if (X.getKind() != Y.getKind())
 320     return X.getKind() < Y.getKind();
 321
 322   FullSourceLoc XL = X.getLocation().asLocation();
 323   FullSourceLoc YL = Y.getLocation().asLocation();
 324   if (XL != YL)
 325     return XL.isBeforeInTranslationUnitThan(YL);
 326
 327   if (X.getString() != Y.getString())
 328     return X.getString() < Y.getString();
 329
 330   if (X.getRanges().size() != Y.getRanges().size())
 331     return X.getRanges().size() < Y.getRanges().size();
 332
 333   const SourceManager &SM = XL.getManager();
 334
 335   for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) {
 336     SourceRange XR = X.getRanges()[i];
 337     SourceRange YR = Y.getRanges()[i];
 338     if (XR != YR) {
 339       if (XR.getBegin() != YR.getBegin())
 340         return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin());
 341       return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd());
 342     }
 343   }
 344
 345   switch (X.getKind()) {
 346     case clang::ento::PathDiagnosticPiece::ControlFlow:
 347       return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
 348                                 cast<PathDiagnosticControlFlowPiece>(Y));
 349     case clang::ento::PathDiagnosticPiece::Event:
 350       return None;
 351     case clang::ento::PathDiagnosticPiece::Macro:
 352       return compareMacro(cast<PathDiagnosticMacroPiece>(X),
 353                           cast<PathDiagnosticMacroPiece>(Y));
 354     case clang::ento::PathDiagnosticPiece::Call:
 355       return compareCall(cast<PathDiagnosticCallPiece>(X),
 356                          cast<PathDiagnosticCallPiece>(Y));
 357   }
 358   llvm_unreachable("all cases handled");
 359 }
 360
 361 static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) {
 362   if (X.size() != Y.size())
 363     return X.size() < Y.size();
 364
 365   PathPieces::const_iterator X_I = X.begin(), X_end = X.end();
 366   PathPieces::const_iterator Y_I = Y.begin(), Y_end = Y.end();
 367
 368   for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) {
 369     Optional<bool> b = comparePiece(**X_I, **Y_I);
 370     if (b.hasValue())
 371       return b.getValue();
 372   }
 373
 374   return None;
 375 }
 376
 377 static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
 378   FullSourceLoc XL = X.getLocation().asLocation();
 379   FullSourceLoc YL = Y.getLocation().asLocation();
 380   if (XL != YL)
 381     return XL.isBeforeInTranslationUnitThan(YL);
 382   if (X.getBugType() != Y.getBugType())
 383     return X.getBugType() < Y.getBugType();
 384   if (X.getCategory() != Y.getCategory())
 385     return X.getCategory() < Y.getCategory();
 386   if (X.getVerboseDescription() != Y.getVerboseDescription())
 387     return X.getVerboseDescription() < Y.getVerboseDescription();
 388   if (X.getShortDescription() != Y.getShortDescription())
 389     return X.getShortDescription() < Y.getShortDescription();
 390   if (X.getDeclWithIssue() != Y.getDeclWithIssue()) {
 391     const Decl *XD = X.getDeclWithIssue();
 392     if (!XD)
 393       return true;
 394     const Decl *YD = Y.getDeclWithIssue();
 395     if (!YD)
 396       return false;
 397     SourceLocation XDL = XD->getLocation();
 398     SourceLocation YDL = YD->getLocation();
 399     if (XDL != YDL) {
 400       const SourceManager &SM = XL.getManager();
 401       return SM.isBeforeInTranslationUnit(XDL, YDL);
 402     }
 403   }
 404   PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end();
 405   PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end();
 406   if (XE - XI != YE - YI)
 407     return (XE - XI) < (YE - YI);
 408   for ( ; XI != XE ; ++XI, ++YI) {
 409     if (*XI != *YI)
 410       return (*XI) < (*YI);
 411   }
 412   Optional<bool> b = comparePath(X.path, Y.path);
 413   assert(b.hasValue());
 414   return b.getValue();
 415 }
 416
 417 void PathDiagnosticConsumer::FlushDiagnostics(
 418                                      PathDiagnosticConsumer::FilesMade *Files) {
 419   if (flushed)
 420     return;
 421
 422   flushed = true;
 423
 424   std::vector<const PathDiagnostic *> BatchDiags;
 425   for (llvm::FoldingSet<PathDiagnostic>::iterator it = Diags.begin(),
 426        et = Diags.end(); it != et; ++it) {
 427     const PathDiagnostic *D = &*it;
 428     BatchDiags.push_back(D);
 429   }
 430
 431   // Sort the diagnostics so that they are always emitted in a deterministic
 432   // order.
 433   int (*Comp)(const PathDiagnostic *const *, const PathDiagnostic *const *) =
 434       [](const PathDiagnostic *const *X, const PathDiagnostic *const *Y) {
 435         assert(*X != *Y && "PathDiagnostics not uniqued!");
 436         if (compare(**X, **Y))
 437           return -1;
 438         assert(compare(**Y, **X) && "Not a total order!");
 439         return 1;
 440       };
 441   array_pod_sort(BatchDiags.begin(), BatchDiags.end(), Comp);
 442
 443   FlushDiagnosticsImpl(BatchDiags, Files);
 444
 445   // Delete the flushed diagnostics.
 446   for (std::vector<const PathDiagnostic *>::iterator it = BatchDiags.begin(),
 447        et = BatchDiags.end(); it != et; ++it) {
 448     const PathDiagnostic *D = *it;
 449     delete D;
 450   }
 451
 452   // Clear out the FoldingSet.
 453   Diags.clear();
 454 }
 455
 456 PathDiagnosticConsumer::FilesMade::~FilesMade() {
 457   for (PDFileEntry &Entry : Set)
 458     Entry.~PDFileEntry();
 459 }
 460
 461 void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD,
 462                                                       StringRef ConsumerName,
 463                                                       StringRef FileName) {
 464   llvm::FoldingSetNodeID NodeID;
 465   NodeID.Add(PD);
 466   void *InsertPos;
 467   PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
 468   if (!Entry) {
 469     Entry = Alloc.Allocate<PDFileEntry>();
 470     Entry = new (Entry) PDFileEntry(NodeID);
 471     Set.InsertNode(Entry, InsertPos);
 472   }
 473
 474   // Allocate persistent storage for the file name.
 475   char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1);
 476   memcpy(FileName_cstr, FileName.data(), FileName.size());
 477
 478   Entry->files.push_back(std::make_pair(ConsumerName,
 479                                         StringRef(FileName_cstr,
 480                                                   FileName.size())));
 481 }
 482
 483 PathDiagnosticConsumer::PDFileEntry::ConsumerFiles *
 484 PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) {
 485   llvm::FoldingSetNodeID NodeID;
 486   NodeID.Add(PD);
 487   void *InsertPos;
 488   PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos);
 489   if (!Entry)
 490     return nullptr;
 491   return &Entry->files;
 492 }
 493
 494 //===----------------------------------------------------------------------===//
 495 // PathDiagnosticLocation methods.
 496 //===----------------------------------------------------------------------===//
 497
 498 static SourceLocation getValidSourceLocation(const Stmt* S,
 499                                              LocationOrAnalysisDeclContext LAC,
 500                                              bool UseEnd = false) {
 501   SourceLocation L = UseEnd ? S->getLocEnd() : S->getLocStart();
 502   assert(!LAC.isNull() && "A valid LocationContext or AnalysisDeclContext should "
 503                           "be passed to PathDiagnosticLocation upon creation.");
 504
 505   // S might be a temporary statement that does not have a location in the
 506   // source code, so find an enclosing statement and use its location.
 507   if (!L.isValid()) {
 508
 509     AnalysisDeclContext *ADC;
 510     if (LAC.is<const LocationContext*>())
 511       ADC = LAC.get<const LocationContext*>()->getAnalysisDeclContext();
 512     else
 513       ADC = LAC.get<AnalysisDeclContext*>();
 514
 515     ParentMap &PM = ADC->getParentMap();
 516
 517     const Stmt *Parent = S;
 518     do {
 519       Parent = PM.getParent(Parent);
 520
 521       // In rare cases, we have implicit top-level expressions,
 522       // such as arguments for implicit member initializers.
 523       // In this case, fall back to the start of the body (even if we were
 524       // asked for the statement end location).
 525       if (!Parent) {
 526         const Stmt *Body = ADC->getBody();
 527         if (Body)
 528           L = Body->getLocStart();
 529         else
 530           L = ADC->getDecl()->getLocEnd();
 531         break;
 532       }
 533
 534       L = UseEnd ? Parent->getLocEnd() : Parent->getLocStart();
 535     } while (!L.isValid());
 536   }
 537
 538   return L;
 539 }
 540
 541 static PathDiagnosticLocation
 542 getLocationForCaller(const StackFrameContext *SFC,
 543                      const LocationContext *CallerCtx,
 544                      const SourceManager &SM) {
 545   const CFGBlock &Block = *SFC->getCallSiteBlock();
 546   CFGElement Source = Block[SFC->getIndex()];
 547
 548   switch (Source.getKind()) {
 549   case CFGElement::Statement:
 550     return PathDiagnosticLocation(Source.castAs<CFGStmt>().getStmt(),
 551                                   SM, CallerCtx);
 552   case CFGElement::Initializer: {
 553     const CFGInitializer &Init = Source.castAs<CFGInitializer>();
 554     return PathDiagnosticLocation(Init.getInitializer()->getInit(),
 555                                   SM, CallerCtx);
 556   }
 557   case CFGElement::AutomaticObjectDtor: {
 558     const CFGAutomaticObjDtor &Dtor = Source.castAs<CFGAutomaticObjDtor>();
 559     return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(),
 560                                              SM, CallerCtx);
 561   }
 562   case CFGElement::DeleteDtor: {
 563     const CFGDeleteDtor &Dtor = Source.castAs<CFGDeleteDtor>();
 564     return PathDiagnosticLocation(Dtor.getDeleteExpr(), SM, CallerCtx);
 565   }
 566   case CFGElement::BaseDtor:
 567   case CFGElement::MemberDtor: {
 568     const AnalysisDeclContext *CallerInfo = CallerCtx->getAnalysisDeclContext();
 569     if (const Stmt *CallerBody = CallerInfo->getBody())
 570       return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx);
 571     return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM);
 572   }
 573   case CFGElement::TemporaryDtor:
 574   case CFGElement::NewAllocator:
 575     llvm_unreachable("not yet implemented!");
 576   }
 577
 578   llvm_unreachable("Unknown CFGElement kind");
 579 }
 580
 581
 582 PathDiagnosticLocation
 583   PathDiagnosticLocation::createBegin(const Decl *D,
 584                                       const SourceManager &SM) {
 585   return PathDiagnosticLocation(D->getLocStart(), SM, SingleLocK);
 586 }
 587
 588 PathDiagnosticLocation
 589   PathDiagnosticLocation::createBegin(const Stmt *S,
 590                                       const SourceManager &SM,
 591                                       LocationOrAnalysisDeclContext LAC) {
 592   return PathDiagnosticLocation(getValidSourceLocation(S, LAC),
 593                                 SM, SingleLocK);
 594 }
 595
 596
 597 PathDiagnosticLocation
 598 PathDiagnosticLocation::createEnd(const Stmt *S,
 599                                   const SourceManager &SM,
 600                                   LocationOrAnalysisDeclContext LAC) {
 601   if (const CompoundStmt *CS = dyn_cast<CompoundStmt>(S))
 602     return createEndBrace(CS, SM);
 603   return PathDiagnosticLocation(getValidSourceLocation(S, LAC, /*End=*/true),
 604                                 SM, SingleLocK);
 605 }
 606
 607 PathDiagnosticLocation
 608   PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO,
 609                                             const SourceManager &SM) {
 610   return PathDiagnosticLocation(BO->getOperatorLoc(), SM, SingleLocK);
 611 }
 612
 613 PathDiagnosticLocation
 614   PathDiagnosticLocation::createConditionalColonLoc(
 615                                             const ConditionalOperator *CO,
 616                                             const SourceManager &SM) {
 617   return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK);
 618 }
 619
 620
 621 PathDiagnosticLocation
 622   PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME,
 623                                           const SourceManager &SM) {
 624   return PathDiagnosticLocation(ME->getMemberLoc(), SM, SingleLocK);
 625 }
 626
 627 PathDiagnosticLocation
 628   PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS,
 629                                            const SourceManager &SM) {
 630   SourceLocation L = CS->getLBracLoc();
 631   return PathDiagnosticLocation(L, SM, SingleLocK);
 632 }
 633
 634 PathDiagnosticLocation
 635   PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS,
 636                                          const SourceManager &SM) {
 637   SourceLocation L = CS->getRBracLoc();
 638   return PathDiagnosticLocation(L, SM, SingleLocK);
 639 }
 640
 641 PathDiagnosticLocation
 642   PathDiagnosticLocation::createDeclBegin(const LocationContext *LC,
 643                                           const SourceManager &SM) {
 644   // FIXME: Should handle CXXTryStmt if analyser starts supporting C++.
 645   if (const CompoundStmt *CS =
 646         dyn_cast_or_null<CompoundStmt>(LC->getDecl()->getBody()))
 647     if (!CS->body_empty()) {
 648       SourceLocation Loc = (*CS->body_begin())->getLocStart();
 649       return PathDiagnosticLocation(Loc, SM, SingleLocK);
 650     }
 651
 652   return PathDiagnosticLocation();
 653 }
 654
 655 PathDiagnosticLocation
 656   PathDiagnosticLocation::createDeclEnd(const LocationContext *LC,
 657                                         const SourceManager &SM) {
 658   SourceLocation L = LC->getDecl()->getBodyRBrace();
 659   return PathDiagnosticLocation(L, SM, SingleLocK);
 660 }
 661
 662 PathDiagnosticLocation
 663   PathDiagnosticLocation::create(const ProgramPoint& P,
 664                                  const SourceManager &SMng) {
 665
 666   const Stmt* S = nullptr;
 667   if (Optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
 668     const CFGBlock *BSrc = BE->getSrc();
 669     S = BSrc->getTerminatorCondition();
 670   } else if (Optional<StmtPoint> SP = P.getAs<StmtPoint>()) {
 671     S = SP->getStmt();
 672     if (P.getAs<PostStmtPurgeDeadSymbols>())
 673       return PathDiagnosticLocation::createEnd(S, SMng, P.getLocationContext());
 674   } else if (Optional<PostInitializer> PIP = P.getAs<PostInitializer>()) {
 675     return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(),
 676                                   SMng);
 677   } else if (Optional<PostImplicitCall> PIE = P.getAs<PostImplicitCall>()) {
 678     return PathDiagnosticLocation(PIE->getLocation(), SMng);
 679   } else if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
 680     return getLocationForCaller(CE->getCalleeContext(),
 681                                 CE->getLocationContext(),
 682                                 SMng);
 683   } else if (Optional<CallExitEnd> CEE = P.getAs<CallExitEnd>()) {
 684     return getLocationForCaller(CEE->getCalleeContext(),
 685                                 CEE->getLocationContext(),
 686                                 SMng);
 687   } else {
 688     llvm_unreachable("Unexpected ProgramPoint");
 689   }
 690
 691   return PathDiagnosticLocation(S, SMng, P.getLocationContext());
 692 }
 693
 694 const Stmt *PathDiagnosticLocation::getStmt(const ExplodedNode *N) {
 695   ProgramPoint P = N->getLocation();
 696   if (Optional<StmtPoint> SP = P.getAs<StmtPoint>())
 697     return SP->getStmt();
 698   if (Optional<BlockEdge> BE = P.getAs<BlockEdge>())
 699     return BE->getSrc()->getTerminator();
 700   if (Optional<CallEnter> CE = P.getAs<CallEnter>())
 701     return CE->getCallExpr();
 702   if (Optional<CallExitEnd> CEE = P.getAs<CallExitEnd>())
 703     return CEE->getCalleeContext()->getCallSite();
 704   if (Optional<PostInitializer> PIPP = P.getAs<PostInitializer>())
 705     return PIPP->getInitializer()->getInit();
 706
 707   return nullptr;
 708 }
 709
 710 const Stmt *PathDiagnosticLocation::getNextStmt(const ExplodedNode *N) {
 711   for (N = N->getFirstSucc(); N; N = N->getFirstSucc()) {
 712     if (const Stmt *S = getStmt(N)) {
 713       // Check if the statement is '?' or '&&'/'||'.  These are "merges",
 714       // not actual statement points.
 715       switch (S->getStmtClass()) {
 716         case Stmt::ChooseExprClass:
 717         case Stmt::BinaryConditionalOperatorClass:
 718         case Stmt::ConditionalOperatorClass:
 719           continue;
 720         case Stmt::BinaryOperatorClass: {
 721           BinaryOperatorKind Op = cast<BinaryOperator>(S)->getOpcode();
 722           if (Op == BO_LAnd || Op == BO_LOr)
 723             continue;
 724           break;
 725         }
 726         default:
 727           break;
 728       }
 729       // We found the statement, so return it.
 730       return S;
 731     }
 732   }
 733
 734   return nullptr;
 735 }
 736
 737 PathDiagnosticLocation
 738   PathDiagnosticLocation::createEndOfPath(const ExplodedNode *N,
 739                                           const SourceManager &SM) {
 740   assert(N && "Cannot create a location with a null node.");
 741   const Stmt *S = getStmt(N);
 742
 743   if (!S) {
 744     // If this is an implicit call, return the implicit call point location.
 745     if (Optional<PreImplicitCall> PIE = N->getLocationAs<PreImplicitCall>())
 746       return PathDiagnosticLocation(PIE->getLocation(), SM);
 747     S = getNextStmt(N);
 748   }
 749
 750   if (S) {
 751     ProgramPoint P = N->getLocation();
 752     const LocationContext *LC = N->getLocationContext();
 753
 754     // For member expressions, return the location of the '.' or '->'.
 755     if (const MemberExpr *ME = dyn_cast<MemberExpr>(S))
 756       return PathDiagnosticLocation::createMemberLoc(ME, SM);
 757
 758     // For binary operators, return the location of the operator.
 759     if (const BinaryOperator *B = dyn_cast<BinaryOperator>(S))
 760       return PathDiagnosticLocation::createOperatorLoc(B, SM);
 761
 762     if (P.getAs<PostStmtPurgeDeadSymbols>())
 763       return PathDiagnosticLocation::createEnd(S, SM, LC);
 764
 765     if (S->getLocStart().isValid())
 766       return PathDiagnosticLocation(S, SM, LC);
 767     return PathDiagnosticLocation(getValidSourceLocation(S, LC), SM);
 768   }
 769
 770   return createDeclEnd(N->getLocationContext(), SM);
 771 }
 772
 773 PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation(
 774                                            const PathDiagnosticLocation &PDL) {
 775   FullSourceLoc L = PDL.asLocation();
 776   return PathDiagnosticLocation(L, L.getManager(), SingleLocK);
 777 }
 778
 779 FullSourceLoc
 780   PathDiagnosticLocation::genLocation(SourceLocation L,
 781                                       LocationOrAnalysisDeclContext LAC) const {
 782   assert(isValid());
 783   // Note that we want a 'switch' here so that the compiler can warn us in
 784   // case we add more cases.
 785   switch (K) {
 786     case SingleLocK:
 787     case RangeK:
 788       break;
 789     case StmtK:
 790       // Defensive checking.
 791       if (!S)
 792         break;
 793       return FullSourceLoc(getValidSourceLocation(S, LAC),
 794                            const_cast<SourceManager&>(*SM));
 795     case DeclK:
 796       // Defensive checking.
 797       if (!D)
 798         break;
 799       return FullSourceLoc(D->getLocation(), const_cast<SourceManager&>(*SM));
 800   }
 801
 802   return FullSourceLoc(L, const_cast<SourceManager&>(*SM));
 803 }
 804
 805 PathDiagnosticRange
 806   PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const {
 807   assert(isValid());
 808   // Note that we want a 'switch' here so that the compiler can warn us in
 809   // case we add more cases.
 810   switch (K) {
 811     case SingleLocK:
 812       return PathDiagnosticRange(SourceRange(Loc,Loc), true);
 813     case RangeK:
 814       break;
 815     case StmtK: {
 816       const Stmt *S = asStmt();
 817       switch (S->getStmtClass()) {
 818         default:
 819           break;
 820         case Stmt::DeclStmtClass: {
 821           const DeclStmt *DS = cast<DeclStmt>(S);
 822           if (DS->isSingleDecl()) {
 823             // Should always be the case, but we'll be defensive.
 824             return SourceRange(DS->getLocStart(),
 825                                DS->getSingleDecl()->getLocation());
 826           }
 827           break;
 828         }
 829           // FIXME: Provide better range information for different
 830           //  terminators.
 831         case Stmt::IfStmtClass:
 832         case Stmt::WhileStmtClass:
 833         case Stmt::DoStmtClass:
 834         case Stmt::ForStmtClass:
 835         case Stmt::ChooseExprClass:
 836         case Stmt::IndirectGotoStmtClass:
 837         case Stmt::SwitchStmtClass:
 838         case Stmt::BinaryConditionalOperatorClass:
 839         case Stmt::ConditionalOperatorClass:
 840         case Stmt::ObjCForCollectionStmtClass: {
 841           SourceLocation L = getValidSourceLocation(S, LAC);
 842           return SourceRange(L, L);
 843         }
 844       }
 845       SourceRange R = S->getSourceRange();
 846       if (R.isValid())
 847         return R;
 848       break;
 849     }
 850     case DeclK:
 851       if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
 852         return MD->getSourceRange();
 853       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 854         if (Stmt *Body = FD->getBody())
 855           return Body->getSourceRange();
 856       }
 857       else {
 858         SourceLocation L = D->getLocation();
 859         return PathDiagnosticRange(SourceRange(L, L), true);
 860       }
 861   }
 862
 863   return SourceRange(Loc,Loc);
 864 }
 865
 866 void PathDiagnosticLocation::flatten() {
 867   if (K == StmtK) {
 868     K = RangeK;
 869     S = nullptr;
 870     D = nullptr;
 871   }
 872   else if (K == DeclK) {
 873     K = SingleLocK;
 874     S = nullptr;
 875     D = nullptr;
 876   }
 877 }
 878
 879 //===----------------------------------------------------------------------===//
 880 // Manipulation of PathDiagnosticCallPieces.
 881 //===----------------------------------------------------------------------===//
 882
 883 PathDiagnosticCallPiece *
 884 PathDiagnosticCallPiece::construct(const ExplodedNode *N,
 885                                    const CallExitEnd &CE,
 886                                    const SourceManager &SM) {
 887   const Decl *caller = CE.getLocationContext()->getDecl();
 888   PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(),
 889                                                     CE.getLocationContext(),
 890                                                     SM);
 891   return new PathDiagnosticCallPiece(caller, pos);
 892 }
 893
 894 PathDiagnosticCallPiece *
 895 PathDiagnosticCallPiece::construct(PathPieces &path,
 896                                    const Decl *caller) {
 897   PathDiagnosticCallPiece *C = new PathDiagnosticCallPiece(path, caller);
 898   path.clear();
 899   path.push_front(C);
 900   return C;
 901 }
 902
 903 void PathDiagnosticCallPiece::setCallee(const CallEnter &CE,
 904                                         const SourceManager &SM) {
 905   const StackFrameContext *CalleeCtx = CE.getCalleeContext();
 906   Callee = CalleeCtx->getDecl();
 907
 908   callEnterWithin = PathDiagnosticLocation::createBegin(Callee, SM);
 909   callEnter = getLocationForCaller(CalleeCtx, CE.getLocationContext(), SM);
 910 }
 911
 912 static inline void describeClass(raw_ostream &Out, const CXXRecordDecl *D,
 913                                  StringRef Prefix = StringRef()) {
 914   if (!D->getIdentifier())
 915     return;
 916   Out << Prefix << '\'' << *D << '\'';
 917 }
 918
 919 static bool describeCodeDecl(raw_ostream &Out, const Decl *D,
 920                              bool ExtendedDescription,
 921                              StringRef Prefix = StringRef()) {
 922   if (!D)
 923     return false;
 924
 925   if (isa<BlockDecl>(D)) {
 926     if (ExtendedDescription)
 927       Out << Prefix << "anonymous block";
 928     return ExtendedDescription;
 929   }
 930
 931   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
 932     Out << Prefix;
 933     if (ExtendedDescription && !MD->isUserProvided()) {
 934       if (MD->isExplicitlyDefaulted())
 935         Out << "defaulted ";
 936       else
 937         Out << "implicit ";
 938     }
 939
 940     if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(MD)) {
 941       if (CD->isDefaultConstructor())
 942         Out << "default ";
 943       else if (CD->isCopyConstructor())
 944         Out << "copy ";
 945       else if (CD->isMoveConstructor())
 946         Out << "move ";
 947
 948       Out << "constructor";
 949       describeClass(Out, MD->getParent(), " for ");
 950
 951     } else if (isa<CXXDestructorDecl>(MD)) {
 952       if (!MD->isUserProvided()) {
 953         Out << "destructor";
 954         describeClass(Out, MD->getParent(), " for ");
 955       } else {
 956         // Use ~Foo for explicitly-written destructors.
 957         Out << "'" << *MD << "'";
 958       }
 959
 960     } else if (MD->isCopyAssignmentOperator()) {
 961         Out << "copy assignment operator";
 962         describeClass(Out, MD->getParent(), " for ");
 963
 964     } else if (MD->isMoveAssignmentOperator()) {
 965         Out << "move assignment operator";
 966         describeClass(Out, MD->getParent(), " for ");
 967
 968     } else {
 969       if (MD->getParent()->getIdentifier())
 970         Out << "'" << *MD->getParent() << "::" << *MD << "'";
 971       else
 972         Out << "'" << *MD << "'";
 973     }
 974
 975     return true;
 976   }
 977
 978   Out << Prefix << '\'' << cast<NamedDecl>(*D) << '\'';
 979   return true;
 980 }
 981
 982 IntrusiveRefCntPtr<PathDiagnosticEventPiece>
 983 PathDiagnosticCallPiece::getCallEnterEvent() const {
 984   if (!Callee)
 985     return nullptr;
 986
 987   SmallString<256> buf;
 988   llvm::raw_svector_ostream Out(buf);
 989
 990   Out << "Calling ";
 991   describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true);
 992
 993   assert(callEnter.asLocation().isValid());
 994   return new PathDiagnosticEventPiece(callEnter, Out.str());
 995 }
 996
 997 IntrusiveRefCntPtr<PathDiagnosticEventPiece>
 998 PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const {
 999   if (!callEnterWithin.asLocation().isValid())
1000     return nullptr;
1001   if (Callee->isImplicit() || !Callee->hasBody())
1002     return nullptr;
1003   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee))
1004     if (MD->isDefaulted())
1005       return nullptr;
1006
1007   SmallString<256> buf;
1008   llvm::raw_svector_ostream Out(buf);
1009
1010   Out << "Entered call";
1011   describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from ");
1012
1013   return new PathDiagnosticEventPiece(callEnterWithin, Out.str());
1014 }
1015
1016 IntrusiveRefCntPtr<PathDiagnosticEventPiece>
1017 PathDiagnosticCallPiece::getCallExitEvent() const {
1018   if (NoExit)
1019     return nullptr;
1020
1021   SmallString<256> buf;
1022   llvm::raw_svector_ostream Out(buf);
1023
1024   if (!CallStackMessage.empty()) {
1025     Out << CallStackMessage;
1026   } else {
1027     bool DidDescribe = describeCodeDecl(Out, Callee,
1028                                         /*ExtendedDescription=*/false,
1029                                         "Returning from ");
1030     if (!DidDescribe)
1031       Out << "Returning to caller";
1032   }
1033
1034   assert(callReturn.asLocation().isValid());
1035   return new PathDiagnosticEventPiece(callReturn, Out.str());
1036 }
1037
1038 static void compute_path_size(const PathPieces &pieces, unsigned &size) {
1039   for (PathPieces::const_iterator it = pieces.begin(),
1040                                   et = pieces.end(); it != et; ++it) {
1041     const PathDiagnosticPiece *piece = it->get();
1042     if (const PathDiagnosticCallPiece *cp =
1043         dyn_cast<PathDiagnosticCallPiece>(piece)) {
1044       compute_path_size(cp->path, size);
1045     }
1046     else
1047       ++size;
1048   }
1049 }
1050
1051 unsigned PathDiagnostic::full_size() {
1052   unsigned size = 0;
1053   compute_path_size(path, size);
1054   return size;
1055 }
1056
1057 //===----------------------------------------------------------------------===//
1058 // FoldingSet profiling methods.
1059 //===----------------------------------------------------------------------===//
1060
1061 void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const {
1062   ID.AddInteger(Range.getBegin().getRawEncoding());
1063   ID.AddInteger(Range.getEnd().getRawEncoding());
1064   ID.AddInteger(Loc.getRawEncoding());
1065   return;
1066 }
1067
1068 void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1069   ID.AddInteger((unsigned) getKind());
1070   ID.AddString(str);
1071   // FIXME: Add profiling support for code hints.
1072   ID.AddInteger((unsigned) getDisplayHint());
1073   ArrayRef<SourceRange> Ranges = getRanges();
1074   for (ArrayRef<SourceRange>::iterator I = Ranges.begin(), E = Ranges.end();
1075                                         I != E; ++I) {
1076     ID.AddInteger(I->getBegin().getRawEncoding());
1077     ID.AddInteger(I->getEnd().getRawEncoding());
1078   }
1079 }
1080
1081 void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1082   PathDiagnosticPiece::Profile(ID);
1083   for (PathPieces::const_iterator it = path.begin(),
1084        et = path.end(); it != et; ++it) {
1085     ID.Add(**it);
1086   }
1087 }
1088
1089 void PathDiagnosticSpotPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1090   PathDiagnosticPiece::Profile(ID);
1091   ID.Add(Pos);
1092 }
1093
1094 void PathDiagnosticControlFlowPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1095   PathDiagnosticPiece::Profile(ID);
1096   for (const_iterator I = begin(), E = end(); I != E; ++I)
1097     ID.Add(*I);
1098 }
1099
1100 void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const {
1101   PathDiagnosticSpotPiece::Profile(ID);
1102   for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end();
1103        I != E; ++I)
1104     ID.Add(**I);
1105 }
1106
1107 void PathDiagnostic::Profile(llvm::FoldingSetNodeID &ID) const {
1108   ID.Add(getLocation());
1109   ID.AddString(BugType);
1110   ID.AddString(VerboseDesc);
1111   ID.AddString(Category);
1112 }
1113
1114 void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const {
1115   Profile(ID);
1116   for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I)
1117     ID.Add(**I);
1118   for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I)
1119     ID.AddString(*I);
1120 }
1121
1122 StackHintGenerator::~StackHintGenerator() {}
1123
1124 std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){
1125   ProgramPoint P = N->getLocation();
1126   CallExitEnd CExit = P.castAs<CallExitEnd>();
1127
1128   // FIXME: Use CallEvent to abstract this over all calls.
1129   const Stmt *CallSite = CExit.getCalleeContext()->getCallSite();
1130   const CallExpr *CE = dyn_cast_or_null<CallExpr>(CallSite);
1131   if (!CE)
1132     return "";
1133
1134   if (!N)
1135     return getMessageForSymbolNotFound();
1136
1137   // Check if one of the parameters are set to the interesting symbol.
1138   ProgramStateRef State = N->getState();
1139   const LocationContext *LCtx = N->getLocationContext();
1140   unsigned ArgIndex = 0;
1141   for (CallExpr::const_arg_iterator I = CE->arg_begin(),
1142                                     E = CE->arg_end(); I != E; ++I, ++ArgIndex){
1143     SVal SV = State->getSVal(*I, LCtx);
1144
1145     // Check if the variable corresponding to the symbol is passed by value.
1146     SymbolRef AS = SV.getAsLocSymbol();
1147     if (AS == Sym) {
1148       return getMessageForArg(*I, ArgIndex);
1149     }
1150
1151     // Check if the parameter is a pointer to the symbol.
1152     if (Optional<loc::MemRegionVal> Reg = SV.getAs<loc::MemRegionVal>()) {
1153       SVal PSV = State->getSVal(Reg->getRegion());
1154       SymbolRef AS = PSV.getAsLocSymbol();
1155       if (AS == Sym) {
1156         return getMessageForArg(*I, ArgIndex);
1157       }
1158     }
1159   }
1160
1161   // Check if we are returning the interesting symbol.
1162   SVal SV = State->getSVal(CE, LCtx);
1163   SymbolRef RetSym = SV.getAsLocSymbol();
1164   if (RetSym == Sym) {
1165     return getMessageForReturn(CE);
1166   }
1167
1168   return getMessageForSymbolNotFound();
1169 }
1170
1171 std::string StackHintGeneratorForSymbol::getMessageForArg(const Expr *ArgE,
1172                                                           unsigned ArgIndex) {
1173   // Printed parameters start at 1, not 0.
1174   ++ArgIndex;
1175
1176   SmallString<200> buf;
1177   llvm::raw_svector_ostream os(buf);
1178
1179   os << Msg << " via " << ArgIndex << llvm::getOrdinalSuffix(ArgIndex)
1180      << " parameter";
1181
1182   return os.str();
1183 }