Uses slt and sltu for signed vs. unsigned comparison by the MIPS assembler.

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 VM_ASSEMBLER_MIPS_H_
 #define VM_ASSEMBLER_MIPS_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_mips.h directly; use assembler.h instead.
 #endif
@@ skipping 691 matching lines @@
     LoadImmediate(CMPRES, value);
     bne(rd, CMPRES, l);
   }
 
   void BranchNotEqual(Register rd, const Object& object, Label* l) {
     ASSERT(rd != CMPRES);
     LoadObject(CMPRES, object);
     bne(rd, CMPRES, l);
   }
 
-  void BranchGreater(Register rd, int32_t value, Label* l) {
-    if (Utils::IsInt(kImmBits, -value)) {
-      addiu(CMPRES, rd, Immediate(-value));
-      bgtz(CMPRES, l);
-    } else {
-      LoadImmediate(CMPRES, value);
-      subu(CMPRES, rd, CMPRES);
-      bgtz(CMPRES, l);
-    }
+  void BranchSignedGreater(Register rd, Register rs, Label* l) {
+    slt(CMPRES, rs, rd);  // CMPRES = rd > rs ? 1 : 0.
+    bne(CMPRES, ZR, l);
+  }
+
+  void BranchSignedGreater(Register rd, int32_t value, Label* l) {
+    LoadImmediate(CMPRES, value);
+    BranchSignedGreater(rd, CMPRES, l);
   }
 
   void BranchGreater(Register rd, Register rs, Label* l) {

[regis, 2013/04/30 00:14:50]

I suppose this is an unsigned compare?

The name is misleading if you are used to Intel terminology: 'less' and
'greater' imply signed comparison, whereas 'below' and 'above' imply unsigned
comparison.
The terms 'lower' and 'higher' ('or same') are used for unsigned comparison on
ARM.

I think we could avoid future bugs if we make this explicit
(BranchUnsignedGreater) or if we use the Intel conventions (BranchAbove).

 

[zra, 2013/04/30 00:30:07]

Done.

-    subu(CMPRES, rd, rs);
-    bgtz(CMPRES, l);
+    sltu(CMPRES, rs, rd);
+    bne(CMPRES, ZR, l);
+  }
+
+  void BranchGreater(Register rd, int32_t value, Label* l) {
+    LoadImmediate(CMPRES, value);
+    BranchGreater(rd, CMPRES, l);
+  }
+
+  void BranchSignedGreaterEqual(Register rd, Register rs, Label* l) {
+    slt(CMPRES, rd, rs);  // CMPRES = rd < rs ? 1 : 0.
+    beq(CMPRES, ZR, l);  // If CMPRES = 0, then rd >= rs.
+  }
+
+  void BranchSignedGreaterEqual(Register rd, int32_t value, Label* l) {
+    LoadImmediate(CMPRES, value);
+    BranchSignedGreaterEqual(rd, CMPRES, l);
+  }
+
+  void BranchGreaterEqual(Register rd, Register rs, Label* l) {
+    sltu(CMPRES, rd, rs);  // CMPRES = rd < rs ? 1 : 0.
+    beq(CMPRES, ZR, l);
   }
 
   void BranchGreaterEqual(Register rd, int32_t value, Label* l) {
-    if (Utils::IsInt(kImmBits, -value)) {
-      addiu(CMPRES, rd, Immediate(-value));
-      bgez(CMPRES, l);
-    } else {
-      LoadImmediate(CMPRES, value);
-      subu(CMPRES, rd, CMPRES);
-      bgez(CMPRES, l);
-    }
+    LoadImmediate(CMPRES, value);
+    BranchGreaterEqual(rd, CMPRES, l);
   }
 
-  void BranchGreaterEqual(Register rd, Register rs, Label* l) {
-    subu(CMPRES, rd, rs);
-    bgez(CMPRES, l);
+  void BranchSignedLess(Register rd, Register rs, Label* l) {
+    BranchSignedGreater(rs, rd, l);
+  }
+
+  void BranchSignedLess(Register rd, int32_t value, Label* l) {
+    LoadImmediate(CMPRES, value);
+    BranchSignedGreater(CMPRES, rd, l);
+  }
+
+  void BranchLess(Register rd, Register rs, Label* l) {
+    BranchGreater(rs, rd, l);
   }
 
   void BranchLess(Register rd, int32_t value, Label* l) {
-    if (Utils::IsInt(kImmBits, -value)) {
-      addiu(CMPRES, rd, Immediate(-value));
-      bltz(CMPRES, l);
-    } else {
-      LoadImmediate(CMPRES, value);
-      subu(CMPRES, rd, CMPRES);
-      bltz(CMPRES, l);
-    }
+    LoadImmediate(CMPRES, value);
+    BranchGreater(CMPRES, rd, l);
   }
 
-  void BranchLess(Register rd, Register rs, Label* l) {
-    subu(CMPRES, rd, rs);
-    bltz(CMPRES, l);
+  void BranchSignedLessEqual(Register rd, Register rs, Label* l) {
+    BranchSignedGreaterEqual(rs, rd, l);
+  }
+
+  void BranchSignedLessEqual(Register rd, int32_t value, Label* l) {
+    LoadImmediate(CMPRES, value);
+    BranchSignedGreaterEqual(CMPRES, rd, l);
+  }
+
+  void BranchLessEqual(Register rd, Register rs, Label* l) {
+    BranchGreaterEqual(rs, rd, l);
   }
 
   void BranchLessEqual(Register rd, int32_t value, Label* l) {
-    if (Utils::IsInt(kImmBits, -value)) {
-      addiu(CMPRES, rd, Immediate(-value));
-      blez(CMPRES, l);
-    } else {
-      LoadImmediate(CMPRES, value);
-      subu(CMPRES, rd, CMPRES);
-      blez(CMPRES, l);
-    }
-  }
-
-  void BranchLessEqual(Register rd, Register rs, Label* l) {
-    subu(CMPRES, rd, rs);
-    blez(CMPRES, l);
+    LoadImmediate(CMPRES, value);
+    BranchGreaterEqual(CMPRES, rd, l);
   }
 
   void Push(Register rt) {
     addiu(SP, SP, Immediate(-kWordSize));
     sw(rt, Address(SP));
   }
 
   void Pop(Register rt) {
     lw(rt, Address(SP));
     addiu(SP, SP, Immediate(kWordSize));
@@ skipping 205 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_MIPS_H_