Turn off dump/emit routines when building minimal subzero.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction 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 Inst class, primarily the various
@@ skipping 439 matching lines @@
     : InstHighLevel(Func, Inst::FakeUse, 1, NULL) {
   assert(Src);
   addSource(Src);
 }
 
 InstFakeKill::InstFakeKill(Cfg *Func, const VarList &KilledRegs,
                            const Inst *Linked)
     : InstHighLevel(Func, Inst::FakeKill, 0, NULL), KilledRegs(KilledRegs),
       Linked(Linked) {}
 
+Type InstCall::getReturnType() const {
+  if (Dest == NULL)
+    return IceType_void;
+  return Dest->getType();
+}
+
 // ======================== Dump routines ======================== //
 
 void Inst::dumpDecorated(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (!Func->getContext()->isVerbose(IceV_Deleted) &&
       (isDeleted() || isRedundantAssign()))
     return;
   if (Func->getContext()->isVerbose(IceV_InstNumbers)) {
     char buf[30];
     InstNumberT Number = getNumber();
     if (Number == NumberDeleted)
       snprintf(buf, llvm::array_lengthof(buf), "[XXX]");
     else
       snprintf(buf, llvm::array_lengthof(buf), "[%3d]", Number);
     Str << buf;
   }
   Str << "  ";
   if (isDeleted())
     Str << "  //";
   dump(Func);
   dumpExtras(Func);
   Str << "\n";
 }
 
 void Inst::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " =~ ";
   dumpSources(Func);
 }
 
 void Inst::dumpExtras(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   bool First = true;
   // Print "LIVEEND={a,b,c}" for all source operands whose live ranges
   // are known to end at this instruction.
   if (Func->getContext()->isVerbose(IceV_Liveness)) {
     for (SizeT I = 0; I < getSrcSize(); ++I) {
       Operand *Src = getSrc(I);
       SizeT NumVars = Src->getNumVars();
       for (SizeT J = 0; J < NumVars; ++J) {
         const Variable *Var = Src->getVar(J);
         if (isLastUse(Var)) {
           if (First)
             Str << " // LIVEEND={";
           else
             Str << ",";
           Var->dump(Func);
           First = false;
         }
       }
     }
     if (!First)
       Str << "}";
   }
 }
 
 void Inst::dumpSources(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (I > 0)
       Str << ", ";
     getSrc(I)->dump(Func);
   }
 }
 
 void Inst::emitSources(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrEmit();
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (I > 0)
       Str << ", ";
     getSrc(I)->emit(Func);
   }
 }
 
 void Inst::dumpDest(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   if (getDest())
     getDest()->dump(Func);
 }
 
 void InstAlloca::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = alloca i8, i32 ";
   getSizeInBytes()->dump(Func);
   if (getAlignInBytes())
     Str << ", align " << getAlignInBytes();
 }
 
 void InstArithmetic::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = " << InstArithmeticAttributes[getOp()].DisplayString << " "
       << getDest()->getType() << " ";
   dumpSources(Func);
 }
 
 void InstAssign::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = " << getDest()->getType() << " ";
   dumpSources(Func);
 }
 
 void InstBr::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << "br ";
   if (!isUnconditional()) {
     Str << "i1 ";
     getCondition()->dump(Func);
     Str << ", label %" << getTargetTrue()->getName() << ", ";
   }
   Str << "label %" << getTargetFalse()->getName();
 }
 
-Type InstCall::getReturnType() const {
-  if (Dest == NULL)
-    return IceType_void;
-  return Dest->getType();
-}
-
 void InstCall::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (getDest()) {
     dumpDest(Func);
     Str << " = ";
   }
   Str << "call ";
   if (getDest())
     Str << getDest()->getType();
   else
     Str << "void";
   Str << " ";
   getCallTarget()->dump(Func);
   Str << "(";
   for (SizeT I = 0; I < getNumArgs(); ++I) {
     if (I > 0)
       Str << ", ";
     Str << getArg(I)->getType() << " ";
     getArg(I)->dump(Func);
   }
   Str << ")";
 }
 
 void InstCast::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = " << InstCastAttributes[getCastKind()].DisplayString << " "
       << getSrc(0)->getType() << " ";
   dumpSources(Func);
   Str << " to " << getDest()->getType();
 }
 
 void InstIcmp::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = icmp " << InstIcmpAttributes[getCondition()].DisplayString << " "
       << getSrc(0)->getType() << " ";
   dumpSources(Func);
 }
 
 void InstExtractElement::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = extractelement ";
   Str << getSrc(0)->getType() << " ";
   getSrc(0)->dump(Func);
   Str << ", ";
   Str << getSrc(1)->getType() << " ";
   getSrc(1)->dump(Func);
 }
 
 void InstInsertElement::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = insertelement ";
   Str << getSrc(0)->getType() << " ";
   getSrc(0)->dump(Func);
   Str << ", ";
   Str << getSrc(1)->getType() << " ";
   getSrc(1)->dump(Func);
   Str << ", ";
   Str << getSrc(2)->getType() << " ";
   getSrc(2)->dump(Func);
 }
 
 void InstFcmp::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = fcmp " << InstFcmpAttributes[getCondition()].DisplayString << " "
       << getSrc(0)->getType() << " ";
   dumpSources(Func);
 }
 
 void InstLoad::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Type Ty = getDest()->getType();
   Str << " = load " << Ty << "* ";
   dumpSources(Func);
   Str << ", align " << typeAlignInBytes(Ty);
 }
 
 void InstStore::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = getData()->getType();
   Str << "store " << Ty << " ";
   getData()->dump(Func);
   Str << ", " << Ty << "* ";
   getAddr()->dump(Func);
   Str << ", align " << typeAlignInBytes(Ty);
 }
 
 void InstSwitch::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = getComparison()->getType();
   Str << "switch " << Ty << " ";
   getSrc(0)->dump(Func);
   Str << ", label %" << getLabelDefault()->getName() << " [\n";
   for (SizeT I = 0; I < getNumCases(); ++I) {
     Str << "    " << Ty << " " << static_cast<int64_t>(getValue(I))
         << ", label %" << getLabel(I)->getName() << "\n";
   }
   Str << "  ]";
 }
 
 void InstPhi::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = phi " << getDest()->getType() << " ";
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (I > 0)
       Str << ", ";
     Str << "[ ";
     getSrc(I)->dump(Func);
     Str << ", %" << Labels[I]->getName() << " ]";
   }
 }
 
 void InstRet::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = hasRetValue() ? getRetValue()->getType() : IceType_void;
   Str << "ret " << Ty;
   if (hasRetValue()) {
     Str << " ";
     dumpSources(Func);
   }
 }
 
 void InstSelect::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Operand *Condition = getCondition();
   Operand *TrueOp = getTrueOperand();
   Operand *FalseOp = getFalseOperand();
   Str << " = select " << Condition->getType() << " ";
   Condition->dump(Func);
   Str << ", " << TrueOp->getType() << " ";
   TrueOp->dump(Func);
   Str << ", " << FalseOp->getType() << " ";
   FalseOp->dump(Func);
 }
 
 void InstUnreachable::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "unreachable";
 }
 
 void InstFakeDef::emit(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   // Go ahead and "emit" these for now, since they are relatively
   // rare.
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t# ";
   getDest()->emit(Func);
   Str << " = def.pseudo ";
   emitSources(Func);
 }
 
 void InstFakeDef::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = def.pseudo ";
   dumpSources(Func);
 }
 
 void InstFakeUse::emit(const Cfg *Func) const { (void)Func; }
 
 void InstFakeUse::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "use.pseudo ";
   dumpSources(Func);
 }
 
 void InstFakeKill::emit(const Cfg *Func) const { (void)Func; }
 
 void InstFakeKill::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (Linked->isDeleted())
     Str << "// ";
   Str << "kill.pseudo ";
   bool First = true;
   for (Variable *Var : KilledRegs) {
     if (!First)
       Str << ", ";
     First = false;
     Var->dump(Func);
   }
 }
 
 void InstTarget::dump(const Cfg *Func) const {
+  if (!ALLOW_DUMP)
+    return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[TARGET] ";
   Inst::dump(Func);
 }
 
 } // end of namespace Ice