Subzero: Print constant pool info with --szstats.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 142 matching lines @@
     ConstantList Constants;
     Constants.reserve(Pool.size());
     for (auto &I : Pool)
       Constants.push_back(I.second);
     // The sort (and its KeyCompareLess machinery) is not strictly necessary,
     // but is desirable for producing output that is deterministic across
     // unordered_map::iterator implementations.
     std::sort(Constants.begin(), Constants.end(), KeyCompareLess<ValueType>());
     return Constants;
   }
+  size_t size() const { return Pool.size(); }
 
 private:
   // Use the default hash function, and a custom key comparison function. The
   // key comparison function for floating point variables can't use the default
   // == based implementation because of special C++ semantics regarding +0.0,
   // -0.0, and NaN comparison. However, it's OK to use the default hash for
   // floating point values because KeyCompare is the final source of truth - in
   // the worst case a "false" collision must be resolved.
   using ContainerType =
       std::unordered_map<KeyType, ValueType *, std::hash<KeyType>,
@@ skipping 35 matching lines @@
   TypePool<IceType_i8, int8_t, ConstantInteger32> Integers8;
   TypePool<IceType_i16, int16_t, ConstantInteger32> Integers16;
   TypePool<IceType_i32, int32_t, ConstantInteger32> Integers32;
   TypePool<IceType_i64, int64_t, ConstantInteger64> Integers64;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable> Relocatables;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable>
       ExternRelocatables;
   UndefPool Undefs;
 };
 
-void GlobalContext::CodeStats::dump(const IceString &Name, Ostream &Str) {
+void GlobalContext::CodeStats::dump(const IceString &Name, GlobalContext *Ctx) {

[Eric Holk, 2016/03/01 19:26:39]

Optional, but I'd consider passing Ctx as a reference (&) instead of a pointer.

[John, 2016/03/01 20:02:09]

Please, do not pass non-const references to methods. :(

   if (!BuildDefs::dump())
     return;
+  OstreamLocker _(Ctx);
+  Ostream &Str = Ctx->getStrDump();
 #define X(str, tag)                                                            \
   Str << "|" << Name << "|" str "|" << Stats[CS_##tag] << "\n";
   CODESTATS_TABLE
 #undef X
   Str << "|" << Name << "|Spills+Fills|"
       << Stats[CS_NumSpills] + Stats[CS_NumFills] << "\n";
   Str << "|" << Name << "|Memory Usage|";
   if (ssize_t MemUsed = llvm::TimeRecord::getCurrentTime(false).getMemUsed())
     Str << MemUsed;
   else
     Str << "(requires '-track-memory')";
   Str << "\n";
+  Str << "|" << Name << "|CPool Sizes ";
+  {
+    auto Pool = Ctx->getConstPool();
+    Str << "|f32=" << Pool->Floats.size();
+    Str << "|f64=" << Pool->Doubles.size();
+    Str << "|i1=" << Pool->Integers1.size();
+    Str << "|i8=" << Pool->Integers8.size();
+    Str << "|i16=" << Pool->Integers16.size();
+    Str << "|i32=" << Pool->Integers32.size();
+    Str << "|i64=" << Pool->Integers64.size();
+    Str << "|Rel=" << Pool->Relocatables.size();
+    Str << "|ExtRel=" << Pool->ExternRelocatables.size();
+  }
+  Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr, const ClFlags &Flags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
       StrEmit(OsEmit), StrError(OsError), Flags(Flags), ObjectWriter(),
       OptQ(/*Sequential=*/Flags.isSequential(),
            /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()),
@@ skipping 747 matching lines @@
     emitItems();
 }
 
 EmitterWorkItem *GlobalContext::emitQueueBlockingPop() {
   return EmitQ.blockingPop();
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (!getFlags().getDumpStats())
     return;
-  OstreamLocker OL(this);
   if (Final) {
-    getStatsCumulative()->dump(Name, getStrDump());
+    getStatsCumulative()->dump(Name, this);
   } else {
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, getStrDump());
+    ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, this);
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!BuildDefs::dump())
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
@@ skipping 18 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice