Subzero: Refactor Operand::dump().

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Operand class and its target-independent
@@ skipping 183 matching lines @@
   V.StackOffset = StackOffset;
   return V;
 }
 
 // ======================== dump routines ======================== //
 
 void Variable::emit(const Cfg *Func) const {
   Func->getTarget()->emitVariable(this, Func);
 }
 
-void Variable::dump(const Cfg *Func) const {
-  Ostream &Str = Func->getContext()->getStrDump();
+void Variable::dump(const Cfg *Func, Ostream &Str) const {
+  if (Func == NULL) {
+    Str << "%" << getName();
+    return;
+  }
   const CfgNode *CurrentNode = Func->getCurrentNode();
   (void)CurrentNode; // used only in assert()
   assert(CurrentNode == NULL || DefNode == NULL || DefNode == CurrentNode);
   if (Func->getContext()->isVerbose(IceV_RegOrigins) ||
       (!hasReg() && !Func->getTarget()->hasComputedFrame()))
     Str << "%" << getName();
   if (hasReg()) {
     if (Func->getContext()->isVerbose(IceV_RegOrigins))
       Str << ":";
     Str << Func->getTarget()->getRegName(RegNum, getType());
@@ skipping 18 matching lines @@
     Str << Name;
   else
     Str << Ctx->mangleName(Name);
   if (Offset) {
     if (Offset > 0)
       Str << "+";
     Str << Offset;
   }
 }
 
-void ConstantRelocatable::dump(GlobalContext *Ctx) const {
-  Ostream &Str = Ctx->getStrDump();
+void ConstantRelocatable::dump(const Cfg *, Ostream &Str) const {
   Str << "@" << Name;
   if (Offset)
     Str << "+" << Offset;
 }
 
 void LiveRange::dump(Ostream &Str) const {
   Str << "(weight=" << Weight << ") ";
   for (RangeType::const_iterator I = Range.begin(), E = Range.end(); I != E;
        ++I) {
     if (I != Range.begin())
       Str << ", ";
     Str << "[" << (*I).first << ":" << (*I).second << ")";
   }
 }
 
 Ostream &operator<<(Ostream &Str, const LiveRange &L) {
   L.dump(Str);
   return Str;
 }
 
 Ostream &operator<<(Ostream &Str, const RegWeight &W) {
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
 } // end of namespace Ice