[analyzer] NFC: RetainCountChecker: Avoid dumping symbols during normal operation.

[NoQ]

Summary

The checker was trying to produce a separate ProgramPointTag for every dead symbol it cleans up, so that to potentially be able to produce a separate ExplodedNode for every symbol, and for that purpose it was dumping the symbol into a string stream.

We don't need a separate node for every symbol, because whenever the first symbol leaks, a bug is emitted, the analysis is sinked, and the checker callback immediately returns due to State variable turning into null, so we never get to see the second leaking symbol.

Then, even if we needed a separate node for every symbol, it'd be much better to print the raw pointer than pretty-print the symbol, because pointers are more unique. Additionally, we are no longer able to break normal analysis while experimenting with debug dumps, which is exactly how this behavior got noticed - we noticed a crash similar to D52756 on a buildbot that definitely doesn't dump exploded graphs.

Because D52756 has already landed, this patch doesn't change the actual behavior of the Analyzer, just prevents future bugs.

[george.karpenkov]

This should also prevent leaks.

lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

void RetainCountChecker::checkEndFunction(const ReturnStmt *RS,
   SmallVector<SymbolRef, 10> Leaked;
 
   for (RefBindingsTy::iterator I = B.begin(), E = B.end(); I != E; ++I)
     state = handleSymbolDeath(state, I->first, I->second, Leaked);
 
   processLeaks(state, Leaked, Ctx, Pred);
 }
 
-const ProgramPointTag *
-RetainCountChecker::getDeadSymbolTag(SymbolRef sym) const {
-  const CheckerProgramPointTag *&tag = DeadSymbolTags[sym];
-  if (!tag) {
-    SmallString<64> buf;
-    llvm::raw_svector_ostream out(buf);
-    out << "Dead Symbol : ";
-    sym->dumpToStream(out);
-    tag = new CheckerProgramPointTag(this, out.str());
-  }
-  return tag;
-}
-
 void RetainCountChecker::checkDeadSymbols(SymbolReaper &SymReaper,
                                           CheckerContext &C) const {
   ExplodedNode *Pred = C.getPredecessor();
 
   ProgramStateRef state = C.getState();
   RefBindingsTy B = state->get<RefBindings>();
   SmallVector<SymbolRef, 10> Leaked;
 
   // Update counts from autorelease pools
   for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
        E = SymReaper.dead_end(); I != E; ++I) {
     SymbolRef Sym = *I;
     if (const RefVal *T = B.lookup(Sym)){
       // Use the symbol as the tag.
       // FIXME: This might not be as unique as we would like.
-      const ProgramPointTag *Tag = getDeadSymbolTag(Sym);
-      state = handleAutoreleaseCounts(state, Pred, Tag, C, Sym, *T);
+      static CheckerProgramPointTag Tag(this, "DeadSymbolAutorelease");
+      state = handleAutoreleaseCounts(state, Pred, &Tag, C, Sym, *T);
       if (!state)
         return;
 
       // Fetch the new reference count from the state, and use it to handle
       // this symbol.
       state = handleSymbolDeath(state, *I, *getRefBinding(state, Sym), Leaked);
     }
   }