[clang][dataflow] Add (initial) debug printing for `Value` and `Environment`.

[ymandel]

Summary

Also adds uses of the new printing in analysis inner loop.

[sgatev]

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

792

Shouldn't this be OS? Same for those below.

[ymandel]

address comments

[ymandel]

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

792

Yes, good catch!

clang/include/clang/Analysis/FlowSensitive/DataflowEnvironment.h

public:
 
   /// Returns the `ControlFlowContext` registered for `F`, if any. Otherwise,
   /// returns null.
   const ControlFlowContext *getControlFlowContext(const FunctionDecl *F) {
     return DACtx->getControlFlowContext(F);
   }
 
   LLVM_DUMP_METHOD void dump() const;
+  LLVM_DUMP_METHOD void dump(raw_ostream &OS) const;
 
 private:
   /// Creates a value appropriate for `Type`, if `Type` is supported, otherwise
   /// return null.
   ///
   /// Recursively initializes storage locations and values until it sees a
   /// self-referential pointer or reference type. `Visited` is used to track
   /// which types appeared in the reference/pointer chain in order to avoid

clang/include/clang/Analysis/FlowSensitive/Value.h

 #ifndef LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_VALUE_H
 #define LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_VALUE_H
 
 #include "clang/AST/Decl.h"
 #include "clang/Analysis/FlowSensitive/StorageLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <utility>
 
 namespace clang {
 namespace dataflow {
 
 /// Base class for all values computed by abstract interpretation.
 ///
public:
 
   /// Assigns `Val` as the child value for `D`.
   void setChild(const ValueDecl &D, Value &Val) { Children[&D] = &Val; }
 
 private:
   llvm::DenseMap<const ValueDecl *, Value *> Children;
 };
 
+raw_ostream &operator<<(raw_ostream &OS, const Value &Val);
+
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOWSENSITIVE_VALUE_H

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

 void Environment::addToFlowCondition(BoolValue &Val) {
   DACtx->addFlowConditionConstraint(*FlowConditionToken, Val);
 }
 
 bool Environment::flowConditionImplies(BoolValue &Val) const {
   return DACtx->flowConditionImplies(*FlowConditionToken, Val);
 }
 
-void Environment::dump() const {
+void Environment::dump(raw_ostream &OS) const {
+  // FIXME: add printing for remaining and allow controller to decide what
+  // fields are printed.
+  llvm::dbgs() << "DeclToLoc:\n";
+  for (auto [D, L] : DeclToLoc)
+    llvm::dbgs() << "  [" << D->getName() << ", " << L << "]\n";
+
+  llvm::dbgs() << "ExprToLoc:\n";
+  for (auto [E, L] : ExprToLoc)
+    llvm::dbgs() << "  [" << E << ", " << L << "]\n";
+
+  llvm::dbgs() << "LocToVal:\n";
+  for (auto [L, V] : LocToVal) {
+    llvm::dbgs() << "  [" << L << ", " << V << ": " << *V << "]\n";
+  }
+
+  llvm::dbgs() << "FlowConditionToken:\n";
   DACtx->dumpFlowCondition(*FlowConditionToken);
 }
 
+void Environment::dump() const {
+  dump(llvm::dbgs());
+}
+
 } // namespace dataflow
 } // namespace clang

clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

 #include "clang/Analysis/FlowSensitive/DataflowWorklist.h"
 #include "clang/Analysis/FlowSensitive/Transfer.h"
 #include "clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
-#include "llvm/Support/ErrorHandling.h"
+
+#define DEBUG_TYPE "clang-dataflow"
 
 namespace clang {
 namespace dataflow {
 
 class StmtToEnvMapImpl : public StmtToEnvMap {
 public:
   StmtToEnvMapImpl(
       const ControlFlowContext &CFCtx,
runTypeErasedDataflowAnalysis(
   static constexpr uint32_t MaxAverageVisitsPerBlock = 4;
   static constexpr uint32_t AbsoluteMaxIterations = 1 << 16;
   const uint32_t RelativeMaxIterations =
       MaxAverageVisitsPerBlock * BlockStates.size();
   const uint32_t MaxIterations =
       std::min(RelativeMaxIterations, AbsoluteMaxIterations);
   uint32_t Iterations = 0;
   while (const CFGBlock *Block = Worklist.dequeue()) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "Processing Block " << Block->getBlockID() << "\n");
     if (++Iterations > MaxIterations) {
       return llvm::createStringError(std::errc::timed_out,
                                      "maximum number of iterations reached");
     }
 
     const llvm::Optional<TypeErasedDataflowAnalysisState> &OldBlockState =
         BlockStates[Block->getBlockID()];
     TypeErasedDataflowAnalysisState NewBlockState =
         transferCFGBlock(*Block, AC);
+    LLVM_DEBUG({
+      llvm::errs() << "New Env:\n";
+      NewBlockState.Env.dump();
+    });
 
     if (OldBlockState) {
+      LLVM_DEBUG({
+        llvm::errs() << "Old Env:\n";
+        OldBlockState->Env.dump();
+      });
       if (isLoopHead(*Block)) {
         LatticeJoinEffect Effect1 = Analysis.widenTypeErased(
             NewBlockState.Lattice, OldBlockState->Lattice);
         LatticeJoinEffect Effect2 =
             NewBlockState.Env.widen(OldBlockState->Env, Analysis);
         if (Effect1 == LatticeJoinEffect::Unchanged &&
             Effect2 == LatticeJoinEffect::Unchanged)
           // The state of `Block` didn't change from widening so there's no need

clang/lib/Analysis/FlowSensitive/Value.cpp

 //===-- Value.cpp -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines support functions for the `Value` type.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/FlowSensitive/Value.h"
+#include "clang/Analysis/FlowSensitive/DebugSupport.h"
 #include "llvm/Support/Casting.h"
 
 namespace clang {
 namespace dataflow {
 
 static bool areEquivalentIndirectionValues(const Value &Val1,
                                            const Value &Val2) {
   if (auto *IndVal1 = dyn_cast<ReferenceValue>(&Val1)) {
     auto *IndVal2 = cast<ReferenceValue>(&Val2);
     return &IndVal1->getReferentLoc() == &IndVal2->getReferentLoc();
   }
   if (auto *IndVal1 = dyn_cast<PointerValue>(&Val1)) {
     auto *IndVal2 = cast<PointerValue>(&Val2);
     return &IndVal1->getPointeeLoc() == &IndVal2->getPointeeLoc();
   }
   return false;
 }
 
 bool areEquivalentValues(const Value &Val1, const Value &Val2) {
   return &Val1 == &Val2 || (Val1.getKind() == Val2.getKind() &&
                             (isa<TopBoolValue>(&Val1) ||
                              areEquivalentIndirectionValues(Val1, Val2)));
 }
 
+raw_ostream &operator<<(raw_ostream &OS, const Value &Val) {
+  switch (Val.getKind()) {
+  case Value::Kind::Reference: {
+    const auto *RV = cast<ReferenceValue>(&Val);
+    return OS << "Reference(" << &RV->getReferentLoc() << ")";
+  }
+  case Value::Kind::Pointer: {
+    const auto *PV = dyn_cast<PointerValue>(&Val);
+    return OS << "Pointer(" << &PV->getPointeeLoc() << ")";
+  }
+  // FIXME: support remaining cases.
+  default:
+    return OS << debugString(Val.getKind());
+  }
+}
+
 } // namespace dataflow
 } // namespace clang