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

src/IceInstMIPS32.h

 //===- subzero/src/IceInstMIPS32.h - MIPS32 machine instrs --*- C++ -*-===    //
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the InstMIPS32 and OperandMIPS32 classes and their
 /// subclasses.
 ///
 /// This represents the machine instructions and operands used for MIPS32 code
 /// selection.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINSTMIPS32_H
 #define SUBZERO_SRC_ICEINSTMIPS32_H
 
+#include "IceConditionCodesMIPS32.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceInstMIPS32.def"
 #include "IceOperand.h"
 
 namespace Ice {
 namespace MIPS32 {
 
 class TargetMIPS32;
 
@@ skipping 301 matching lines @@
   InstMIPS32Br() = delete;
   InstMIPS32Br(const InstMIPS32Br &) = delete;
   InstMIPS32Br &operator=(const InstMIPS32Br &) = delete;
 
 public:
   /// Create an unconditional branch to a node.
   static InstMIPS32Br *create(Cfg *Func, CfgNode *Target) {
     constexpr CfgNode *NoCondTarget = nullptr;
     constexpr InstMIPS32Label *NoLabel = nullptr;
     return new (Func->allocate<InstMIPS32Br>())
-        InstMIPS32Br(Func, NoCondTarget, Target, NoLabel);
+        InstMIPS32Br(Func, NoCondTarget, Target, NoLabel, CondMIPS32::AL);
   }
+
+  static InstMIPS32Br *create(Cfg *Func, CfgNode *TargetTrue,
+                              CfgNode *TargetFalse, Operand *Src0,
+                              Operand *Src1, CondMIPS32::Cond Cond) {
+    constexpr InstMIPS32Label *NoLabel = nullptr;
+    return new (Func->allocate<InstMIPS32Br>())
+        InstMIPS32Br(Func, TargetTrue, TargetFalse, Src0, Src1, NoLabel, Cond);
+  }
+
   const CfgNode *getTargetTrue() const { return TargetTrue; }
   const CfgNode *getTargetFalse() const { return TargetFalse; }
 
-  bool isUnconditionalBranch() const override { return true; }
+  bool isUnconditionalBranch() const override {
+    return Predicate == CondMIPS32::AL;
+  }
   bool repointEdges(CfgNode *OldNode, CfgNode *NewNode) override {
     (void)OldNode;
     (void)NewNode;
     return true;
   };
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override { (void)Func; };
   void dump(const Cfg *Func) const override { (void)Func; };

[Jim Stichnoth, 2016/05/19 15:03:41]

Add a proper implementation of dump().

[sagar.thakur, 2016/05/23 18:30:26]

Done.

   static bool classof(const Inst *Instr) { return isClassof(Instr, Br); }
 
 private:
   InstMIPS32Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
-               const InstMIPS32Label *Label);
+               const InstMIPS32Label *Label, const CondMIPS32::Cond Cond);
+
+  InstMIPS32Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
+               Operand *Src0, Operand *Src1, const InstMIPS32Label *Label,
+               const CondMIPS32::Cond Cond);
 
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstMIPS32Label *Label; // Intra-block branch target
+  const CondMIPS32::Cond Predicate;
 };
 
 class InstMIPS32Call : public InstMIPS32 {
   InstMIPS32Call() = delete;
   InstMIPS32Call(const InstMIPS32Call &) = delete;
   InstMIPS32Call &operator=(const InstMIPS32Call &) = delete;
 
 public:
   static InstMIPS32Call *create(Cfg *Func, Variable *Dest,
                                 Operand *CallTarget) {
@@ skipping 154 matching lines @@
 template <> void InstMIPS32Mfhi::emit(const Cfg *Func) const;
 template <> void InstMIPS32Mtlo::emit(const Cfg *Func) const;
 template <> void InstMIPS32Mthi::emit(const Cfg *Func) const;
 template <> void InstMIPS32Mult::emit(const Cfg *Func) const;
 template <> void InstMIPS32Multu::emit(const Cfg *Func) const;
 
 } // end of namespace MIPS32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTMIPS32_H