Subzero: Count lookups of each constant value in the constant pool.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the Operand class and its target-independent subclasses.
 ///
 /// The main classes are Variable, which represents an LLVM variable that is
 /// either register- or stack-allocated, and the Constant hierarchy, which
 /// represents integer, floating-point, and/or symbolic constants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceDefs.h"
 #include "IceCfg.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
 #include "llvm/Support/Format.h"
 
 #include <limits>
+#include <type_traits>
 
 namespace Ice {
 
 class Operand {
   Operand() = delete;
   Operand(const Operand &) = delete;
   Operand &operator=(const Operand &) = delete;
 
 public:
   static constexpr size_t MaxTargetKinds = 10;
@@ skipping 78 matching lines @@
   Constant() = delete;
   Constant(const Constant &) = delete;
   Constant &operator=(const Constant &) = delete;
 
 public:
   virtual void emitPoolLabel(Ostream &Str, const GlobalContext *Ctx) const {
     (void)Str;
     (void)Ctx;
     llvm::report_fatal_error("emitPoolLabel not defined for type");
   };
+  // Declare the lookup counter to take minimal space in a non-DUMP build.
+  using CounterType =
+      std::conditional<BuildDefs::dump(), uint64_t, uint8_t>::type;
   void emit(const Cfg *Func) const override { emit(Func->getTarget()); }
   virtual void emit(TargetLowering *Target) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Max;
   }
 
   /// Judge if this given immediate should be randomized or pooled By default
   /// should return false, only constant integers should truly go through this
   /// method.
   virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
     (void)Ctx;
     return false;
   }
 
-  void setShouldBePooled(bool R) { shouldBePooled = R; }
+  void setShouldBePooled(bool R) { ShouldBePooled = R; }
+  bool getShouldBePooled() const { return ShouldBePooled; }
 
-  bool getShouldBePooled() const { return shouldBePooled; }
+  // This should be thread-safe because the constant pool lock is acquired
+  // before the method is invoked.
+  void updateLookupCount() {
+    if (!BuildDefs::dump())
+      return;
+    ++LookupCount;
+  }
+  CounterType getLookupCount() const { return LookupCount; }
 
 protected:
-  Constant(OperandKind Kind, Type Ty)
-      : Operand(Kind, Ty), shouldBePooled(false) {
+  Constant(OperandKind Kind, Type Ty) : Operand(Kind, Ty) {
     Vars = nullptr;
     NumVars = 0;
   }
   /// Whether we should pool this constant. Usually Float/Double and pooled
   /// Integers should be flagged true.
-  bool shouldBePooled;
+  bool ShouldBePooled = false;
+  /// Note: If ShouldBePooled is ever removed from the base class, we will want
+  /// to completely disable LookupCount in a non-DUMP build to save space.
+  CounterType LookupCount = 0;
 };
 
 /// ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
   ConstantPrimitive() = delete;
   ConstantPrimitive(const ConstantPrimitive &) = delete;
   ConstantPrimitive &operator=(const ConstantPrimitive &) = delete;
 
 public:
@@ skipping 766 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H