Reduce copying, redundancy & repetition for codegen of comparison instructions

runtime/vm/assembler_mips.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_ASSEMBLER_MIPS_H_
 #define RUNTIME_VM_ASSEMBLER_MIPS_H_
 
 #ifndef RUNTIME_VM_ASSEMBLER_H_
 #error Do not include assembler_mips.h directly; use assembler.h instead.
 #endif
@@ skipping 144 matching lines @@
     kImmPos = kRelOpPos + kRelOpSize,
     kImmSize = 16,
   };
 
   class LeftBits : public BitField<uword, Register, kLeftPos, kLeftSize> {};
   class RightBits : public BitField<uword, Register, kRightPos, kRightSize> {};
   class RelOpBits
       : public BitField<uword, RelationOperator, kRelOpPos, kRelOpSize> {};
   class ImmBits : public BitField<uword, uint16_t, kImmPos, kImmSize> {};
 
-  Register left() const { return LeftBits::decode(bits_); }
-  Register right() const { return RightBits::decode(bits_); }
+  Register left() const {
+    ASSERT(IsValid());
+    return LeftBits::decode(bits_);
+  }
+
+  Register right() const {
+    ASSERT(IsValid());
+    return RightBits::decode(bits_);
+  }
   RelationOperator rel_op() const { return RelOpBits::decode(bits_); }
-  int16_t imm() const { return static_cast<int16_t>(ImmBits::decode(bits_)); }
+  int16_t imm() const {
+    ASSERT(IsValid());
+    return static_cast<int16_t>(ImmBits::decode(bits_));
+  }
 
   static bool IsValidImm(int32_t value) {
     // We want both value and value + 1 to fit in an int16_t.
     return (-0x08000 <= value) && (value < 0x7fff);
   }
 
   void set_rel_op(RelationOperator value) {
     ASSERT(IsValidRelOp(value));
     bits_ = RelOpBits::update(value, bits_);
   }
 
+  bool IsValid() const { return rel_op() != INVALID_RELATION; }
+
   // Uninitialized condition.
-  Condition() : ValueObject(), bits_(0) {}
+  Condition() : ValueObject(), bits_(RelOpBits::update(INVALID_RELATION, 0)) {}
 
   // Copy constructor.
   Condition(const Condition& other) : ValueObject(), bits_(other.bits_) {}
 
   // Copy assignment operator.
   Condition& operator=(const Condition& other) {
     bits_ = other.bits_;
     return *this;
   }
 
   Condition(Register left,
             Register right,
             RelationOperator rel_op,
             int16_t imm = 0) {
     // At most one constant, ZR or immediate.
     ASSERT(!(((left == ZR) || (left == IMM)) &&
              ((right == ZR) || (right == IMM))));
     // Non-zero immediate value is only allowed for IMM.
     ASSERT((imm != 0) == ((left == IMM) || (right == IMM)));
     set_left(left);
     set_right(right);
-    set_rel_op(rel_op);
+    if (rel_op == INVALID_RELATION) {
+      SetToInvalidState();
+    } else {
+      set_rel_op(rel_op);
+    }
     set_imm(imm);
   }
 
  private:
+  void SetToInvalidState() {
+    bits_ = RelOpBits::update(INVALID_RELATION, bits_);
+  }
+
   static bool IsValidRelOp(RelationOperator value) {
     return (AL <= value) && (value <= ULE);
   }
 
   static bool IsValidRegister(Register value) {
     return (ZR <= value) && (value <= IMM) && (value != AT);
   }
 
   void set_left(Register value) {
     ASSERT(IsValidRegister(value));
@@ skipping 1475 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ASSEMBLER_MIPS_H_