Subzero: Refactor Operand::dump().

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
@@ skipping 33 matching lines @@
   // Every Operand keeps an array of the Variables referenced in
   // the operand.  This is so that the liveness operations can get
   // quick access to the variables of interest, without having to dig
   // so far into the operand.
   SizeT getNumVars() const { return NumVars; }
   Variable *getVar(SizeT I) const {
     assert(I < getNumVars());
     return Vars[I];
   }
   virtual void emit(const Cfg *Func) const = 0;
-  virtual void dump(const Cfg *Func) const = 0;
+  // The dump(Func,Str) implementation must be sure to handle the
+  // situation where Func==NULL.
+  virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
+  void dump(const Cfg *Func) const {
+    assert(Func);
+    dump(Func, Func->getContext()->getStrDump());
+  }
+  void dump(Ostream &Str) const { dump(NULL, Str); }
 
   // Query whether this object was allocated in isolation, or added to
   // some higher-level pool.  This determines whether a containing
   // object's destructor should delete this object.  Generally,
   // constants are pooled globally, variables are pooled per-CFG, and
   // target-specific operands are not pooled.
   virtual bool isPooled() const { return false; }
 
   virtual ~Operand() {}
 
@@ skipping 10 matching lines @@
 private:
   Operand(const Operand &) LLVM_DELETED_FUNCTION;
   Operand &operator=(const Operand &) LLVM_DELETED_FUNCTION;
 };
 
 // Constant is the abstract base class for constants.  All
 // constants are allocated from a global arena and are pooled.
 class Constant : public Operand {
 public:
   uint32_t getPoolEntryID() const { return PoolEntryID; }
+  using Operand::dump;
   virtual void emit(const Cfg *Func) const { emit(Func->getContext()); }
-  virtual void dump(const Cfg *Func) const { dump(Func->getContext()); }
   virtual void emit(GlobalContext *Ctx) const = 0;
-  virtual void dump(GlobalContext *Ctx) const = 0;
+  virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Num;
   }
 
 protected:
   Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
       : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
     Vars = NULL;
@@ skipping 18 matching lines @@
                                    uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantPrimitive>())
         ConstantPrimitive(Ty, Value, PoolEntryID);
   }
   T getValue() const { return Value; }
   using Constant::emit;
   // The target needs to implement this for each ConstantPrimitive
   // specialization.
   virtual void emit(GlobalContext *Ctx) const;
   using Constant::dump;
-  virtual void dump(GlobalContext *Ctx) const {
-    Ostream &Str = Ctx->getStrDump();
-    Str << getValue();
-  }
+  virtual void dump(const Cfg *, Ostream &Str) const { Str << getValue(); }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
 private:
   ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ConstantPrimitive(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
   ConstantPrimitive &operator=(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
   virtual ~ConstantPrimitive() {}
   const T Value;
 };
 
 typedef ConstantPrimitive<uint64_t, Operand::kConstInteger> ConstantInteger;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
-template <> inline void ConstantInteger::dump(GlobalContext *Ctx) const {
-  Ostream &Str = Ctx->getStrDump();
+template <> inline void ConstantInteger::dump(const Cfg *, Ostream &Str) const {
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int64_t>(getValue());
 }
 
 // RelocatableTuple bundles the parameters that are used to
 // construct an ConstantRelocatable.  It is done this way so that
 // ConstantRelocatable can fit into the global constant pool
 // template mechanism.
@@ skipping 25 matching lines @@
     return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
         Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID);
   }
   int64_t getOffset() const { return Offset; }
   IceString getName() const { return Name; }
   void setSuppressMangling(bool Value) { SuppressMangling = Value; }
   bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
   using Constant::dump;
   virtual void emit(GlobalContext *Ctx) const;
-  virtual void dump(GlobalContext *Ctx) const;
+  virtual void dump(const Cfg *Func, Ostream &Str) const;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
   ConstantRelocatable(Type Ty, int64_t Offset, const IceString &Name,
                       bool SuppressMangling, uint32_t PoolEntryID)
       : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
@@ skipping 11 matching lines @@
 // legal to lower ConstantUndef to any value, backends should try to
 // make code generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
 public:
   static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
                                uint32_t PoolEntryID) {
     return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
   }
 
   using Constant::emit;
+  using Constant::dump;
   // The target needs to implement this.
   virtual void emit(GlobalContext *Ctx) const;
-
-  using Constant::dump;
-  virtual void dump(GlobalContext *Ctx) const {
-    Ostream &Str = Ctx->getStrEmit();
-    Str << "undef";
-  }
+  virtual void dump(const Cfg *, Ostream &Str) const { Str << "undef"; }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
 
 private:
   ConstantUndef(Type Ty, uint32_t PoolEntryID)
       : Constant(kConstUndef, Ty, PoolEntryID) {}
   ConstantUndef(const ConstantUndef &) LLVM_DELETED_FUNCTION;
   ConstantUndef &operator=(const ConstantUndef &) LLVM_DELETED_FUNCTION;
@@ skipping 162 matching lines @@
     HiVar = Hi;
   }
   // Creates a temporary copy of the variable with a different type.
   // Used primarily for syntactic correctness of textual assembly
   // emission.  Note that only basic information is copied, in
   // particular not DefInst, IsArgument, Weight, RegisterPreference,
   // AllowRegisterOverlap, LoVar, HiVar, VarsReal.
   Variable asType(Type Ty);
 
   virtual void emit(const Cfg *Func) const;
-  virtual void dump(const Cfg *Func) const;
+  using Operand::dump;
+  virtual void dump(const Cfg *Func, Ostream &Str) const;
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kVariable;
   }
 
   // The destructor is public because of the asType() method.
   virtual ~Variable() {}
 
 private:
   Variable(Type Ty, const CfgNode *Node, SizeT Index, const IceString &Name)
@@ skipping 55 matching lines @@
   Variable *LoVar;
   Variable *HiVar;
   // VarsReal (and Operand::Vars) are set up such that Vars[0] ==
   // this.
   Variable *VarsReal[1];
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H