Better value range propagation by supporting negating ranges.

tests/compiler/dart2js/value_range2_test.dart

 // Copyright (c) 2012, 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.
 
 #import("../../../lib/compiler/implementation/ssa/ssa.dart");
 #import("../../../lib/compiler/implementation/leg.dart");
 
 Value instructionValue = new InstructionValue(new HReturn(null));
 Value lengthValue = new LengthValue(new HReturn(null));
 
@@ skipping 24 matching lines @@
 Range _0_instruction = createInstructionRange(0);
 
 checkAndRange(Range one, Range two, lower, upper) {
   if (lower is num) lower = new IntValue(lower);
   if (upper is num) upper = new IntValue(upper);
   Range range = new Range(lower, upper);
   Expect.equals(range, one & two);
 }
 
 checkSubRange(Range one, Range two, [lower, upper]) {
+
+  buildBound(one, two) {
+    // Create a bound just like the algorithm does.

[Søren Gjesse, 2012/10/08 14:00:42]

Which algorithm? (add more context to the reference).

[ngeoffray, 2012/10/08 14:16:39]

Done.

+    if (two is IntValue) {
+      if (two.isNegative()) {
+        return new AddValue(one, -two);
+      } else if (two.isZero()) {
+        return one;
+      }
+    }
+    if (one is IntValue) {
+      if (one.isNegative()) {
+        return new SubtractValue(-two, -one);
+      } else if (one.isZero()) {
+        return -two;
+      }
+    }
+    return new SubtractValue(one, two);
+  }
+
   if (lower == null) {
-    lower = new OperationValue(one.lower, two.upper, const SubtractOperation());
+    lower = buildBound(one.lower, two.upper);
   } else if (lower is num) {
     lower = new IntValue(lower);
   }
   if (upper == null) {
-    upper = new OperationValue(one.upper, two.lower, const SubtractOperation());
+    upper = buildBound(one.upper, two.lower);
   } else if (upper is num) {
     upper = new IntValue(upper);
   }
 
   Expect.equals(new Range(lower, upper), one - two);
 }
 
+checkNegateRange(Range range, [arg1, arg2]) {
+  if (arg1 is Range) {
+    Expect.equals(arg1, -range);
+  } else {
+    Value low, up;
+    if (arg1 is num) {
+      low = new IntValue(arg1);
+    } else if (arg1 == null) {
+      low = new NegateValue(range.upper);
+    } else {
+      low = arg1;
+    }
+    if (arg2 is num) {
+      up = new IntValue(arg2);
+    } else if (arg2 == null) {
+      up = new NegateValue(range.lower);
+    } else {
+      up = arg2;
+    }
+    Expect.equals(new Range(low, up), -range);
+  }
+}
+
+testNegate() {
+  checkNegateRange(instruction);
+  checkNegateRange(FF, nFF);
+  checkNegateRange(nFF, FF);
+  checkNegateRange(FA, -0xFA, -0xFA);
+  checkNegateRange(length);
+  checkNegateRange(_FA_FF, -0xFF, -0xFA);
+  checkNegateRange(_0_FF, _nFF_0);
+  checkNegateRange(_nFF_FF, _nFF_FF);
+  checkNegateRange(_nFF_0, _0_FF);
+  checkNegateRange(_0_length, -lengthValue, 0);
+  checkNegateRange(_0_instruction, -instructionValue, 0);
+}
+
 testAnd() {
   checkAndRange(
       instruction, instruction, const MinIntValue(), const MaxIntValue());
   checkAndRange(instruction, FF, 0, 0xFF);
   checkAndRange(instruction, FA, 0, 0xFA);
   checkAndRange(instruction, nFF, const MinIntValue(), const MaxIntValue());
   checkAndRange(instruction, length, 0, length.upper);
   checkAndRange(instruction, _FA_FF, 0, 0xFF);
   checkAndRange(instruction, _0_FF, 0, 0xFF);
   checkAndRange(instruction, _nFF_FF, const MinIntValue(), const MaxIntValue());
@@ skipping 233 matching lines @@
   checkSubRange(_0_instruction, _nFF_FF, -0xFF, null);
   checkSubRange(_0_instruction, _nFF_0, 0, null);
   checkSubRange(_0_instruction, _0_length, null, _0_instruction.upper);
   checkSubRange(_0_instruction, _0_instruction, null, _0_instruction.upper);
 }
 
 main() {
   HInstruction.idCounter = 0;
   testAnd();
   testSub();
+  testNegate();
 }