[analyzer] dump() dynamic type info and taint into state dumps.

[NoQ]

Summary

More dumps!

Eg.:

Dynamic types of regions:
x : class PR13569_virtual::Child

Taint dumps were already implemented, so i added them because they seemed to have been accidentally left out.

include/clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h

 /// \brief Set dynamic type information of the region; return the new state.
 inline ProgramStateRef setDynamicTypeInfo(ProgramStateRef State,
                                           const MemRegion *Reg, QualType NewTy,
                                           bool CanBeSubClassed = true) {
   return setDynamicTypeInfo(State, Reg,
                             DynamicTypeInfo(NewTy, CanBeSubClassed));
 }
 
+void printDynamicTypeInfo(ProgramStateRef State, raw_ostream &Out,
+                          const char *NL, const char *Sep);
+
 } // ento
 } // clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_DYNAMICTYPEMAP_H

lib/StaticAnalyzer/Core/DynamicTypeMap.cpp

 ProgramStateRef setDynamicTypeInfo(ProgramStateRef State, const MemRegion *Reg,
                                    DynamicTypeInfo NewTy) {
   Reg = Reg->StripCasts();
   ProgramStateRef NewState = State->set<DynamicTypeMap>(Reg, NewTy);
   assert(NewState);
   return NewState;
 }
 
+void printDynamicTypeInfo(ProgramStateRef State, raw_ostream &Out,
+                          const char *NL, const char *Sep) {
+  bool First = true;
+  for (const auto &I : State->get<DynamicTypeMap>()) {
+    if (First) {
+      Out << NL << "Dynamic types of regions:" << NL;
+      First = false;
+    }
+    const MemRegion *MR = I.first;
+    const DynamicTypeInfo &DTI = I.second;
+    Out << MR << " : ";
+    if (DTI.isValid()) {
+      Out << DTI.getType()->getPointeeType().getAsString();
+      if (DTI.canBeASubClass()) {
+        Out << " (or its subclass)";
+      }
+    } else {
+      Out << "Invalid type info";
+    }
+    Out << NL;
+  }
+}
+
 } // namespace ento
 } // namespace clang

lib/StaticAnalyzer/Core/ProgramState.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/Analysis/CFG.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/TaintManager.h"
+#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace ento;
 
 namespace clang { namespace  ento {
 /// Increments the number of times this state is referenced.
 
void ProgramState::print(raw_ostream &Out, const char *NL, const char *Sep,
   Mgr.getStoreManager().print(getStore(), Out, NL, Sep);
 
   // Print out the environment.
   Env.print(Out, NL, Sep, LC);
 
   // Print out the constraints.
   Mgr.getConstraintManager().print(this, Out, NL, Sep);
 
+  // Print out the tracked dynamic types.
+  printDynamicTypeInfo(this, Out, NL, Sep);
+
+  // Print out tainted symbols.
+  printTaint(Out, NL, Sep);
+
   // Print checker-specific data.
   Mgr.getOwningEngine()->printState(Out, this, NL, Sep, LC);
 }
 
 void ProgramState::printDOT(raw_ostream &Out, const LocationContext *LC) const {
   print(Out, "\\l", "\\|", LC);
 }
 
 LLVM_DUMP_METHOD void ProgramState::dump() const {
   print(llvm::errs());
 }
 
 void ProgramState::printTaint(raw_ostream &Out,
                               const char *NL, const char *Sep) const {
   TaintMapImpl TM = get<TaintMap>();
 
   if (!TM.isEmpty())
-    Out <<"Tainted Symbols:" << NL;
+    Out <<"Tainted symbols:" << NL;
 
   for (TaintMapImpl::iterator I = TM.begin(), E = TM.end(); I != E; ++I) {
     Out << I->first << " : " << I->second << NL;
   }
 }
 
 void ProgramState::dumpTaint() const {
   printTaint(llvm::errs());