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) {
+

[Jim Stichnoth, 2016/04/02 01:19:52]

remove initial blank line

[sehr, 2016/04/04 15:38:51]

Done.

+  if (auto *Constant = llvm::dyn_cast<ConstantInteger32>(Source)) {

[Jim Stichnoth, 2016/04/02 01:19:52]

I would name it something like "C32", that isn't an ICE class name.

[sehr, 2016/04/04 15:38:51]

Done.

+    int32_t Value = Constant->getValue();
+    if (Value != 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 78 matching lines @@
 // becomes a problem.
 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. TODO: This uses a linear-time search,

[Jim Stichnoth, 2016/04/02 01:19:52]

TODO(owner)

Actually, maybe this TODO and the identical one above should just be removed,
because it sort of obscures other TODOs that actually need doing.  I.e., I have
no intention of improving the linear-time complexity until it actually shows up
as a problem, and if it does, it should be readily apparent via profiling.

[sehr, 2016/04/04 15:38:51]

Done.

+// which could be improved if it becomes a problem.
+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