[Subzero][MIPS32] Addition of bool folding machinery and implementation of conditional branches

src/IceInstMIPS32.cpp

 //===- subzero/src/IceInstMips32.cpp - Mips32 instruction implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file
 /// \brief Implements the InstMips32 and OperandMips32 classes, primarily the
 /// constructors and the dump()/emit() methods.
 ///
 //===----------------------------------------------------------------------===//
 #include "IceAssemblerMIPS32.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceInst.h"
 #include "IceInstMIPS32.h"
 #include "IceOperand.h"
 #include "IceRegistersMIPS32.h"
 #include "IceTargetLoweringMIPS32.h"
 #include <limits>
 
 namespace Ice {
 namespace MIPS32 {
 
+const struct InstMIPS32CondAttributes_ {
+  CondMIPS32::Cond Opposite;
+  const char *EmitString;
+} InstMIPS32CondAttributes[] = {
+#define X(tag, opp, emit)                                                      \
+  { CondMIPS32::opp, emit }                                                    \
+  ,
+    ICEINSTMIPS32COND_TABLE
+#undef X
+};
+
 bool OperandMIPS32Mem::canHoldOffset(Type Ty, bool SignExt, int32_t Offset) {
   (void)SignExt;
   (void)Ty;
   if ((std::numeric_limits<int16_t>::min() <= Offset) &&
       (Offset <= std::numeric_limits<int16_t>::max()))
     return true;
   return false;
 }
 
 OperandMIPS32Mem::OperandMIPS32Mem(Cfg *Func, Type Ty, Variable *Base,
@@ skipping 67 matching lines @@
 }
 
 template <> void InstMIPS32Multu::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   emitThreeAddrLoHi(Opcode, this, Func);
 }
 
 InstMIPS32Br::InstMIPS32Br(Cfg *Func, const CfgNode *TargetTrue,
                            const CfgNode *TargetFalse,
-                           const InstMIPS32Label *Label)
+                           const InstMIPS32Label *Label, CondMIPS32::Cond Cond)
     : InstMIPS32(Func, InstMIPS32::Br, 0, nullptr), TargetTrue(TargetTrue),
-      TargetFalse(TargetFalse), Label(Label) {}
+      TargetFalse(TargetFalse), Label(Label), Predicate(Cond) {}
+
+InstMIPS32Br::InstMIPS32Br(Cfg *Func, const CfgNode *TargetTrue,
+                           const CfgNode *TargetFalse, Operand *Src0,
+                           const InstMIPS32Label *Label, CondMIPS32::Cond Cond)
+    : InstMIPS32(Func, InstMIPS32::Br, 1, nullptr), TargetTrue(TargetTrue),
+      TargetFalse(TargetFalse), Label(Label), Predicate(Cond) {
+  addSource(Src0);
+}
+
+InstMIPS32Br::InstMIPS32Br(Cfg *Func, const CfgNode *TargetTrue,
+                           const CfgNode *TargetFalse, Operand *Src0,
+                           Operand *Src1, const InstMIPS32Label *Label,
+                           CondMIPS32::Cond Cond)
+    : InstMIPS32(Func, InstMIPS32::Br, 2, nullptr), TargetTrue(TargetTrue),
+      TargetFalse(TargetFalse), Label(Label), Predicate(Cond) {
+  addSource(Src0);
+  addSource(Src1);
+}
 
 InstMIPS32Label::InstMIPS32Label(Cfg *Func, TargetMIPS32 *Target)
     : InstMIPS32(Func, InstMIPS32::Label, 0, nullptr),
       Number(Target->makeNextLabelNumber()) {
   if (BuildDefs::dump()) {
     Name = GlobalString::createWithString(
         Func->getContext(),
         ".L" + Func->getFunctionName() + "$local$__" + std::to_string(Number));
   } else {
     Name = GlobalString::createWithoutString(Func->getContext());
@@ skipping 136 matching lines @@
          "jr"
          "\t";
   RA->emit(Func);
 }
 
 void InstMIPS32Br::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t"
-         "b"
-      << "\t";
+         "b" << InstMIPS32CondAttributes[Predicate].EmitString << "\t";
   if (Label) {
     Str << Label->getLabelName();
   } else {
     if (isUnconditionalBranch()) {
       Str << getTargetFalse()->getAsmName();
     } else {
-      // TODO(reed kotler): Finish implementing conditional branch.
+      switch (Predicate) {
+      default:
+        break;
+      case CondMIPS32::EQ:
+      case CondMIPS32::NE: {
+        getSrc(0)->emit(Func);
+        Str << ", ";
+        getSrc(1)->emit(Func);
+        Str << ", ";
+        break;
+      }
+      case CondMIPS32::EQZ:
+      case CondMIPS32::NEZ:
+      case CondMIPS32::LEZ:
+      case CondMIPS32::LTZ:
+      case CondMIPS32::GEZ:
+      case CondMIPS32::GTZ: {
+        getSrc(0)->emit(Func);
+        Str << ", ";
+        break;
+      }
+      }
+      Str << getTargetFalse()->getAsmName();
     }
   }
 }
+
+void InstMIPS32Br::dump(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+  Ostream &Str = Func->getContext()->getStrDump();
+  Str << "\t"
+         "b" << InstMIPS32CondAttributes[Predicate].EmitString << "\t";
+
+  if (Label) {
+    Str << Label->getLabelName();
+  } else {
+    if (isUnconditionalBranch()) {
+      Str << getTargetFalse()->getAsmName();
+    } else {
+      dumpSources(Func);
+      Str << ", ";
+      Str << getTargetFalse()->getAsmName();
+    }
+  }
+}
 
 void InstMIPS32Call::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 1);
   if (llvm::isa<ConstantInteger32>(getCallTarget())) {
     // This shouldn't happen (typically have to copy the full 32-bits to a
     // register and do an indirect jump).
     llvm::report_fatal_error("MIPS2Call to ConstantInteger32");
@@ skipping 155 matching lines @@
   }
 
   Str << "\t";
   getDest()->emit(Func);
   Str << ", ";
   getSrc(0)->emit(Func);
 }
 
 } // end of namespace MIPS32
 } // end of namespace Ice