Replace constant conditional branches by unconditional branches

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 286 matching lines @@
 
 bool InstAssign::isVarAssign() const { return llvm::isa<Variable>(getSrc(0)); }
 
 // If TargetTrue==TargetFalse, we turn it into an unconditional branch. This
 // ensures that, along with the 'switch' instruction semantics, there is at
 // most one edge from one node to another.
 InstBr::InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue_,
                CfgNode *TargetFalse_)
     : InstHighLevel(Func, Inst::Br, 1, nullptr), TargetFalse(TargetFalse_),
       TargetTrue(TargetTrue_) {
-  if (TargetTrue == TargetFalse) {
+  if (auto *Constant = llvm::dyn_cast<ConstantInteger32>(Source)) {
+    int32_t C32 = Constant->getValue();
+    if (C32 != 0) {
+      TargetFalse = TargetTrue;
+    }
+    TargetTrue = nullptr; // turn into unconditional version
+  } else if (TargetTrue == TargetFalse) {
     TargetTrue = nullptr; // turn into unconditional version
   } else {
     addSource(Source);
   }
 }
 
 InstBr::InstBr(Cfg *Func, CfgNode *Target)
     : InstHighLevel(Func, Inst::Br, 0, nullptr), TargetFalse(Target),
       TargetTrue(nullptr) {}
 
@@ skipping 67 matching lines @@
 // TODO: A Switch instruction (and maybe others) can add duplicate edges. We
 // may want to de-dup Phis and validate consistency (i.e., the source operands
 // are the same for duplicate edges), though it seems the current lowering code
 // is OK with this situation.
 void InstPhi::addArgument(Operand *Source, CfgNode *Label) {
   Labels[getSrcSize()] = Label;
   addSource(Source);
 }
 
 // Find the source operand corresponding to the incoming edge for the given
-// node. TODO: This uses a linear-time search, which could be improved if it
-// becomes a problem.
+// node.
 Operand *InstPhi::getOperandForTarget(CfgNode *Target) const {
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (Labels[I] == Target)
       return getSrc(I);
   }
   llvm_unreachable("Phi target not found");
   return nullptr;
 }
 
+// Replace the source operand corresponding to the incoming edge for the given
+// node by a zero of the appropriate type.
+void InstPhi::clearOperandForTarget(CfgNode *Target) {
+  for (SizeT I = 0; I < getSrcSize(); ++I) {
+    if (getLabel(I) == Target) {
+      Type Ty = Dest->getType();
+      Srcs[I] = Target->getCfg()->getContext()->getConstantZero(Ty);
+      return;
+    }
+  }
+  llvm_unreachable("Phi target not found");
+}
+
 // Updates liveness for a particular operand based on the given predecessor
 // edge. Doesn't mark the operand as live if the Phi instruction is dead or
 // deleted.
 void InstPhi::livenessPhiOperand(LivenessBV &Live, CfgNode *Target,
                                  Liveness *Liveness) {
   if (isDeleted() || Dead)
     return;
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (Labels[I] == Target) {
       if (auto *Var = llvm::dyn_cast<Variable>(getSrc(I))) {
@@ skipping 599 matching lines @@
     // 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