Subzero: Reduce the amount of #ifdef'd code.

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 380 matching lines @@
   }
   llvm_unreachable("Phi operand not found for specified target node");
 }
 
 // Change "a=phi(...)" to "a_phi=phi(...)" and return a new
 // instruction "a=a_phi".
 Inst *InstPhi::lower(Cfg *Func) {
   Variable *Dest = getDest();
   assert(Dest);
   Variable *NewSrc = Func->makeVariable(Dest->getType());
-  if (ALLOW_DUMP)
+  if (buildAllowsDump())
     NewSrc->setName(Func, Dest->getName(Func) + "_phi");
   this->Dest = NewSrc;
   return InstAssign::create(Func, Dest, NewSrc);
 }
 
 InstRet::InstRet(Cfg *Func, Operand *RetValue)
     : InstHighLevel(Func, Ret, RetValue ? 1 : 0, nullptr) {
   if (RetValue)
     addSource(RetValue);
 }
@@ skipping 92 matching lines @@
 
 Type InstCall::getReturnType() const {
   if (Dest == nullptr)
     return IceType_void;
   return Dest->getType();
 }
 
 // ======================== Dump routines ======================== //
 
 void Inst::dumpDecorated(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (!Func->isVerbose(IceV_Deleted) && (isDeleted() || isRedundantAssign()))
     return;
   if (Func->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)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " =~ ";
   dumpSources(Func);
 }
 
 void Inst::dumpExtras(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     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->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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     return;
   if (getDest())
     getDest()->dump(Func);
 }
 
 void InstAlloca::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = " << getDest()->getType() << " ";
   dumpSources(Func);
 }
 
 void InstBr::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     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();
 }
 
 void InstCall::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (getDest()) {
     dumpDest(Func);
     Str << " = ";
   }
   Str << "call ";
   if (getDest())
     Str << getDest()->getType();
   else
@@ skipping 12 matching lines @@
 
 const char *InstCast::getCastName(InstCast::OpKind Kind) {
   size_t Index = static_cast<size_t>(Kind);
   if (Index < InstCast::OpKind::_num)
     return InstCastAttributes[Index].DisplayString;
   llvm_unreachable("Invalid InstCast::OpKind");
   return "???";
 }
 
 void InstCast::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Str << " = " << getCastName(getCastKind()) << " " << getSrc(0)->getType()
       << " ";
   dumpSources(Func);
   Str << " to " << getDest()->getType();
 }
 
 void InstIcmp::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   dumpDest(Func);
   Type Ty = getDest()->getType();
   Str << " = load " << Ty << ", " << Ty << "* ";
   dumpSources(Func);
   Str << ", align " << typeAlignInBytes(Ty);
 }
 
 void InstStore::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = getData()->getType();
   dumpDest(Func);
   if (Dest)
     Str << " = ";
   Str << "store " << Ty << " ";
   getData()->dump(Func);
   Str << ", " << Ty << "* ";
   getAddr()->dump(Func);
   Str << ", align " << typeAlignInBytes(Ty);
   if (getRmwBeacon()) {
     Str << ", beacon ";
     getRmwBeacon()->dump(Func);
   }
 }
 
 void InstSwitch::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "unreachable";
 }
 
 void InstBundleLock::emit(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t.bundle_lock";
   switch (BundleOption) {
   case Opt_None:
     break;
   case Opt_AlignToEnd:
     Str << "\talign_to_end";
     break;
   }
 }
 
 void InstBundleLock::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "bundle_lock";
   switch (BundleOption) {
   case Opt_None:
     break;
   case Opt_AlignToEnd:
     Str << " align_to_end";
     break;
   }
 }
 
 void InstBundleUnlock::emit(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t.bundle_unlock";
 }
 
 void InstBundleUnlock::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "bundle_unlock";
 }
 
 void InstFakeDef::emit(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     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)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (Linked->isDeleted())
     Str << "// ";
   Str << "kill.pseudo scratch_regs";
 }
 
 void InstTarget::dump(const Cfg *Func) const {
-  if (!ALLOW_DUMP)
+  if (!buildAllowsDump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[TARGET] ";
   Inst::dump(Func);
 }
 
 bool checkForRedundantAssign(const Variable *Dest, const Operand *Source) {
   const auto SrcVar = llvm::dyn_cast<const Variable>(Source);
   if (!SrcVar)
     return false;
   if (Dest->hasReg() && Dest->getRegNum() == SrcVar->getRegNum()) {
     // TODO: On x86-64, instructions like "mov eax, eax" are used to
     // clear the upper 32 bits of rax.  We need to recognize and
     // preserve these.
     return true;
   }
   if (!Dest->hasReg() && !SrcVar->hasReg() &&
       Dest->getStackOffset() == SrcVar->getStackOffset())
     return true;
   return false;
 }
 
 } // end of namespace Ice