Code generation for multiply-by-constant-smi....

test/mjsunit/smi-ops.js

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 620 matching lines @@
   var shift = 2.4;
   assertEquals(5, 20.5 >> shift);
   assertEquals(5, 20.5 >> shift + 0.3);
   shift = shift + zero;
   assertEquals(5, 20.5 >> shift);
   assertEquals(5, 20.5 >> shift + 0.3);
 }
 
 testShiftNonSmis();
 
+// Test specialized code generation for shifts by a constant
+
+function testSpecializedShift(general, shift, specialized) {
+  function test(n) {
+    assertEquals(general(n, shift), specialized(n));
+  }
+  for (var i = -256; i <= 256; ++i) {
+    test(i);
+    test(i + 0.5);
+    var big = i * (1 << 24);  // ranges from -2^32 to 2^32
+    test(big);
+    test(big + 7);
+    test(big - 7);
+    test(big * 1.0000001);
+    test(big / 1.0000001);
+  }
+}
+
+function testShrConstant() {
+  function shift0(n) { return n >>> 0; }
+  function shift1(n) { return n >>> 1; }
+  function shift2(n) { return n >>> 2; }
+  function shift3(n) { return n >>> 3; }
+  function shift28(n) { return n >>> 28; }
+  function shift29(n) { return n >>> 29; }
+  function shift30(n) { return n >>> 30; }
+  function shift31(n) { return n >>> 31; }
+  function shift(n, s) { return n >>> s; }
+
+  testSpecializedShift(shift, 0, shift0);
+  testSpecializedShift(shift, 1, shift1);
+  testSpecializedShift(shift, 2, shift2);
+  testSpecializedShift(shift, 3, shift3);
+  testSpecializedShift(shift, 28, shift28);
+  testSpecializedShift(shift, 29, shift29);
+  testSpecializedShift(shift, 30, shift30);
+  testSpecializedShift(shift, 31, shift31);
+}
+
+testShrConstant();
+
+function testSarConstant() {
+  function shift0(n) { return n >> 0; }
+  function shift1(n) { return n >> 1; }
+  function shift2(n) { return n >> 2; }
+  function shift3(n) { return n >> 3; }
+  function shift28(n) { return n >> 28; }
+  function shift29(n) { return n >> 29; }
+  function shift30(n) { return n >> 30; }
+  function shift31(n) { return n >> 31; }
+  function shift(n, s) { return n >> s; }
+
+  testSpecializedShift(shift, 0, shift0);
+  testSpecializedShift(shift, 1, shift1);
+  testSpecializedShift(shift, 2, shift2);
+  testSpecializedShift(shift, 3, shift3);
+  testSpecializedShift(shift, 28, shift28);
+  testSpecializedShift(shift, 29, shift29);
+  testSpecializedShift(shift, 30, shift30);
+  testSpecializedShift(shift, 31, shift31);
+}
+
+testSarConstant();
+
+function testShlConstant() {
+  function shift0(n) { return n << 0; }
+  function shift1(n) { return n << 1; }
+  function shift2(n) { return n << 2; }
+  function shift3(n) { return n << 3; }
+  function shift28(n) { return n << 28; }
+  function shift29(n) { return n << 29; }
+  function shift30(n) { return n << 30; }
+  function shift31(n) { return n << 31; }
+  function shift(n, s) { return n << s; }
+
+  testSpecializedShift(shift, 0, shift0);
+  testSpecializedShift(shift, 1, shift1);
+  testSpecializedShift(shift, 2, shift2);
+  testSpecializedShift(shift, 3, shift3);
+  testSpecializedShift(shift, 28, shift28);
+  testSpecializedShift(shift, 29, shift29);
+  testSpecializedShift(shift, 30, shift30);
+  testSpecializedShift(shift, 31, shift31);
+}
+
+testShlConstant();
 
 // Verify that we handle the (optimized) corner case of shifting by
 // zero even for non-smis.
 function shiftByZero(n) { return n << 0; }
 
 assertEquals(3, shiftByZero(3.1415));
+assertEquals(3, shiftByZero(3.9995));
+
+// Multiplication by SMIs
+
+function MulZeroa(x) {
+  return 0 * x;
+}
+function MulZerob(x) {
+  return x * 0;
+}
+
+function testMultiplyZero(mulZero) {
+  assertEquals(0, mulZero(0));
+  assertEquals(0, mulZero(100));
+  assertEquals(0, mulZero(1000));
+  assertEquals(Infinity, 1 / mulZero(1000));
+  assertEquals(-Infinity, 1 / mulZero(-1000));
+}
+
+testMultiplyZero(MulZeroa);
+testMultiplyZero(MulZerob);
+
+function MulNeg1a(x) {
+  return -1 * x;
+}
+function MulNeg1b(x) {
+  return x * -1;
+}
+
+function testMultiplyNeg1(mulNeg1) {
+  assertEquals(1, mulNeg1(-1));
+  assertEquals(-1000, mulNeg1(1000));  // fast case
+  assertEquals(SMI_MAX + 1, mulNeg1(SMI_MIN));  // overflows
+  assertEquals(SMI_MIN + 1, mulNeg1(SMI_MAX));  // fast case
+  assertEquals(-Infinity, 1 / mulNeg1(0));  // negative zero case
+  assertEquals(Infinity, 1 / mulNeg1(mulNeg1(0)));
+
+  assertEquals(-42, mulNeg1(OBJ_42));
+}
+
+testMultiplyNeg1(MulNeg1a);
+testMultiplyNeg1(MulNeg1b);
+
+function testMulSmi() {
+  var constants = [-256, -100, -10, -3, -2, -1, 0, 1, 2, 3, 4, 5, 10, 20, 1000,
+      100000, SMI_MIN, SMI_MAX, SMI_MIN+1, SMI_MAX-1, SMI_MIN+2, SMI_MAX-3,
+      16];
+  var values = [-Infinity, 1000000, 123.4, -10000000, OBJ_42];
+  values = values.concat(constants);
+
+  for (var i = 0; i < constants.length; ++i) {
+    var x = constants[i];
+    var f1 = eval("(function(y) { return (" + x + ") * y})");
+    var f2 = eval("(function(y) { return y * (" + x + ")})");
+    for (var j = 0; j < values.length; ++j) {
+      var y = values[j];
+      var product = x * y;
+      assertEquals(product, f1(y));
+      assertEquals(product, f2(y));
+      assertEquals(1/product, 1/f1(y));
+      assertEquals(1/product, 1/f2(y));
+    }
+  }
+}
+testMulSmi();