Hide dbgs() stream for when built with -fmodules.

[marsupial]

Summary

Make DebugCounter::print and ump methods to be const correct.

[aprantl]

I'm slightly confused why this works as a fix for the Debug build. Isn't this patch a no-op for a debug build?

[aprantl]

That said, this patch is still obviously correct.

[marsupial]

This should be more 'obviously' correct.
Sorry, some CMake confusion here....

[marsupial]

Formatting.

[marsupial]

Remove spurious newline.

[aprantl]

LGTM, thanks!

include/llvm/Support/DebugCounter.h

#endif // NDEBUG
   }
 
   // Set a registered counter to a given value.
   static void setCounterValue(unsigned ID, const std::pair<int, int> &Val) {
     auto &Us = instance();
     Us.Counters[ID] = Val;
   }
 
-  // Dump or print the current counter set.
-  LLVM_DUMP_METHOD void dump() { print(dbgs()); }
+  // Dump or print the current counter set into llvm::dbgs().
+  LLVM_DUMP_METHOD void dump() const;
 
-  void print(raw_ostream &OS);
+  void print(raw_ostream &OS) const;
 
   // Get the counter ID for a given named counter, or return 0 if none is found.
   unsigned getCounterId(const std::string &Name) const {
     return RegisteredCounters.idFor(Name);
   }
 
   // Return the number of registered counters.
   unsigned int getNumCounters() const { return RegisteredCounters.size(); }

include/llvm/Transforms/Scalar/GVNExpression.h

public:
   }
 
   void print(raw_ostream &OS) const {
     OS << "{ ";
     printInternal(OS, true);
     OS << "}";
   }
 
-  LLVM_DUMP_METHOD void dump() const {
-    print(dbgs());
-    dbgs() << "\n";
-  }
+  LLVM_DUMP_METHOD void dump() const;
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const Expression &E) {
   E.print(OS);
   return OS;
 }
 
 class BasicExpression : public Expression {

lib/Support/DebugCounter.cpp

if (CounterPair.first.endswith("-skip")) {
     auto Res = Counters.insert({CounterID, {0, -1}});
     Res.first->second.second = CounterVal;
   } else {
     errs() << "DebugCounter Error: " << CounterPair.first
            << " does not end with -skip or -count\n";
   }
 }
 
-void DebugCounter::print(raw_ostream &OS) {
+void DebugCounter::print(raw_ostream &OS) const {
   OS << "Counters and values:\n";
   for (const auto &KV : Counters)
     OS << left_justify(RegisteredCounters[KV.first], 32) << ": {"
        << KV.second.first << "," << KV.second.second << "}\n";
 }
+
+LLVM_DUMP_METHOD void DebugCounter::dump() const {
+  print(dbgs());
+}

lib/Transforms/Scalar/GVNSink.cpp

template <typename ModelledPHI> struct DenseMapInfo {
   static unsigned getHashValue(const ModelledPHI &V) { return V.hash(); }
   static bool isEqual(const ModelledPHI &LHS, const ModelledPHI &RHS) {
     return LHS == RHS;
   }
 };
 
 typedef DenseSet<ModelledPHI, DenseMapInfo<ModelledPHI>> ModelledPHISet;
 
+LLVM_DUMP_METHOD llvm::GVNExpression::dump() const {
+  print(dbgs());
+  dbgs() << "\n";
+}
+
 //===----------------------------------------------------------------------===//
 //                             ValueTable
 //===----------------------------------------------------------------------===//
 // This is a value number table where the value number is a function of the
 // *uses* of a value, rather than its operands. Thus, if VN(A) == VN(B) we know
 // that the program would be equivalent if we replaced A with PHI(A, B).
 //===----------------------------------------------------------------------===//