src/v8/test/mjsunit/smi-ops.js

   1 // Copyright 2010 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 const SMI_MAX = (1 << 29) - 1 + (1 << 29);  // Create without overflowing.
  29 const SMI_MIN = -SMI_MAX - 1;  // Create without overflowing.
  30 const ONE = 1;
  31 const ONE_HUNDRED = 100;
  32
  33 const OBJ_42 = new (function() {
  34   this.valueOf = function() { return 42; };
  35 })();
  36
  37 assertEquals(42, OBJ_42.valueOf());
  38
  39
  40 function Add1(x) {
  41   return x + 1;
  42 }
  43
  44 function Add100(x) {
  45   return x + 100;
  46 }
  47
  48 function Add1Reversed(x) {
  49   return 1 + x;
  50 }
  51
  52 function Add100Reversed(x) {
  53   return 100 + x;
  54 }
  55
  56
  57 assertEquals(1, Add1(0));  // fast case
  58 assertEquals(1, Add1Reversed(0));  // fast case
  59 assertEquals(SMI_MAX + ONE, Add1(SMI_MAX), "smimax + 1");
  60 assertEquals(SMI_MAX + ONE, Add1Reversed(SMI_MAX), "1 + smimax");
  61 assertEquals(42 + ONE, Add1(OBJ_42));  // non-smi
  62 assertEquals(42 + ONE, Add1Reversed(OBJ_42));  // non-smi
  63
  64 assertEquals(100, Add100(0));  // fast case
  65 assertEquals(100, Add100Reversed(0));  // fast case
  66 assertEquals(SMI_MAX + ONE_HUNDRED, Add100(SMI_MAX), "smimax + 100");
  67 assertEquals(SMI_MAX + ONE_HUNDRED, Add100Reversed(SMI_MAX), " 100 + smimax");
  68 assertEquals(42 + ONE_HUNDRED, Add100(OBJ_42));  // non-smi
  69 assertEquals(42 + ONE_HUNDRED, Add100Reversed(OBJ_42));  // non-smi
  70
  71
  72
  73 function Sub1(x) {
  74   return x - 1;
  75 }
  76
  77 function Sub100(x) {
  78   return x - 100;
  79 }
  80
  81 function Sub1Reversed(x) {
  82   return 1 - x;
  83 }
  84
  85 function Sub100Reversed(x) {
  86   return 100 - x;
  87 }
  88
  89
  90 assertEquals(0, Sub1(1));  // fast case
  91 assertEquals(-1, Sub1Reversed(2));  // fast case
  92 assertEquals(SMI_MIN - ONE, Sub1(SMI_MIN));  // overflow
  93 assertEquals(ONE - SMI_MIN, Sub1Reversed(SMI_MIN));  // overflow
  94 assertEquals(42 - ONE, Sub1(OBJ_42));  // non-smi
  95 assertEquals(ONE - 42, Sub1Reversed(OBJ_42));  // non-smi
  96
  97 assertEquals(0, Sub100(100));  // fast case
  98 assertEquals(1, Sub100Reversed(99));  // fast case
  99 assertEquals(SMI_MIN - ONE_HUNDRED, Sub100(SMI_MIN));  // overflow
 100 assertEquals(ONE_HUNDRED - SMI_MIN, Sub100Reversed(SMI_MIN));  // overflow
 101 assertEquals(42 - ONE_HUNDRED, Sub100(OBJ_42));  // non-smi
 102 assertEquals(ONE_HUNDRED - 42, Sub100Reversed(OBJ_42));  // non-smi
 103
 104
 105 function Shr1(x) {
 106   return x >>> 1;
 107 }
 108
 109 function Shr100(x) {
 110   return x >>> 100;
 111 }
 112
 113 function Shr1Reversed(x) {
 114   return 1 >>> x;
 115 }
 116
 117 function Shr100Reversed(x) {
 118   return 100 >>> x;
 119 }
 120
 121 function Sar1(x) {
 122   return x >> 1;
 123 }
 124
 125 function Sar100(x) {
 126   return x >> 100;
 127 }
 128
 129 function Sar1Reversed(x) {
 130   return 1 >> x;
 131 }
 132
 133 function Sar100Reversed(x) {
 134   return 100 >> x;
 135 }
 136
 137
 138 assertEquals(0, Shr1(1));
 139 assertEquals(0, Sar1(1));
 140 assertEquals(0, Shr1Reversed(2));
 141 assertEquals(0, Sar1Reversed(2));
 142 assertEquals(1610612736, Shr1(SMI_MIN));
 143 assertEquals(-536870912, Sar1(SMI_MIN));
 144 assertEquals(1, Shr1Reversed(SMI_MIN));
 145 assertEquals(1, Sar1Reversed(SMI_MIN));
 146 assertEquals(21, Shr1(OBJ_42));
 147 assertEquals(21, Sar1(OBJ_42));
 148 assertEquals(0, Shr1Reversed(OBJ_42));
 149 assertEquals(0, Sar1Reversed(OBJ_42));
 150
 151 assertEquals(6, Shr100(100), "100 >>> 100");
 152 assertEquals(6, Sar100(100), "100 >> 100");
 153 assertEquals(12, Shr100Reversed(99));
 154 assertEquals(12, Sar100Reversed(99));
 155 assertEquals(201326592, Shr100(SMI_MIN));
 156 assertEquals(-67108864, Sar100(SMI_MIN));
 157 assertEquals(100, Shr100Reversed(SMI_MIN));
 158 assertEquals(100, Sar100Reversed(SMI_MIN));
 159 assertEquals(2, Shr100(OBJ_42));
 160 assertEquals(2, Sar100(OBJ_42));
 161 assertEquals(0, Shr100Reversed(OBJ_42));
 162 assertEquals(0, Sar100Reversed(OBJ_42));
 163
 164
 165 function Xor1(x) {
 166   return x ^ 1;
 167 }
 168
 169 function Xor100(x) {
 170   return x ^ 100;
 171 }
 172
 173 function Xor1Reversed(x) {
 174   return 1 ^ x;
 175 }
 176
 177 function Xor100Reversed(x) {
 178   return 100 ^ x;
 179 }
 180
 181
 182 assertEquals(0, Xor1(1));
 183 assertEquals(3, Xor1Reversed(2));
 184 assertEquals(SMI_MIN + 1, Xor1(SMI_MIN));
 185 assertEquals(SMI_MIN + 1, Xor1Reversed(SMI_MIN));
 186 assertEquals(43, Xor1(OBJ_42));
 187 assertEquals(43, Xor1Reversed(OBJ_42));
 188
 189 assertEquals(0, Xor100(100));
 190 assertEquals(7, Xor100Reversed(99));
 191 assertEquals(-1073741724, Xor100(SMI_MIN));
 192 assertEquals(-1073741724, Xor100Reversed(SMI_MIN));
 193 assertEquals(78, Xor100(OBJ_42));
 194 assertEquals(78, Xor100Reversed(OBJ_42));
 195
 196 var x = 0x23; var y = 0x35;
 197 assertEquals(0x16, x ^ y);
 198
 199
 200 // Bitwise not.
 201 var v = 0;
 202 assertEquals(-1, ~v);
 203 v = SMI_MIN;
 204 assertEquals(0x3fffffff, ~v, "~smimin");
 205 v = SMI_MAX;
 206 assertEquals(-0x40000000, ~v, "~smimax");
 207
 208 // Overflowing ++ and --.
 209 v = SMI_MAX;
 210 v++;
 211 assertEquals(0x40000000, v, "smimax++");
 212 v = SMI_MIN;
 213 v--;
 214 assertEquals(-0x40000001, v, "smimin--");
 215
 216 // Check that comparisons of numbers separated by MIN_SMI work.
 217 assertFalse(SMI_MIN > 0);
 218 assertFalse(SMI_MIN + 1 > 1);
 219 assertFalse(SMI_MIN + 1 > 2);
 220 assertFalse(SMI_MIN + 2 > 1);
 221 assertFalse(0 < SMI_MIN);
 222 assertTrue(-1 < SMI_MAX);
 223 assertFalse(SMI_MAX < -1);
 224
 225 // Not actually Smi operations.
 226 // Check that relations on unary ops work.
 227 var v = -1.2;
 228 assertTrue(v == v);
 229 assertTrue(v === v);
 230 assertTrue(v <= v);
 231 assertTrue(v >= v);
 232 assertFalse(v < v);
 233 assertFalse(v > v);
 234 assertFalse(v != v);
 235 assertFalse(v !== v);
 236
 237 // Right hand side of unary minus is overwritable.
 238 v = 1.5
 239 assertEquals(-2.25, -(v * v));
 240
 241 // Smi input to bitop gives non-smi result where the rhs is a float that
 242 // can be overwritten.
 243 var x1 = 0x10000000;
 244 var x2 = 0x40000002;
 245 var x3 = 0x40000000;
 246 assertEquals(0x40000000, x1 << (x2 - x3), "0x10000000<<1(1)");
 247
 248 // Smi input to bitop gives non-smi result where the rhs could be overwritten
 249 // if it were a float, but it isn't.
 250 x1 = 0x10000000
 251 x2 = 4
 252 x3 = 2
 253 assertEquals(0x40000000, x1 << (x2 - x3), "0x10000000<<2(2)");
 254
 255
 256 // Test shift operators on non-smi inputs, giving smi and non-smi results.
 257 function testShiftNonSmis() {
 258   var pos_non_smi = 2000000000;
 259   var neg_non_smi = -pos_non_smi;
 260   var pos_smi = 1000000000;
 261   var neg_smi = -pos_smi;
 262
 263   // Begin block A
 264   assertEquals(pos_non_smi, (pos_non_smi) >> 0);
 265   assertEquals(pos_non_smi, (pos_non_smi) >>> 0);
 266   assertEquals(pos_non_smi, (pos_non_smi) << 0);
 267   assertEquals(neg_non_smi, (neg_non_smi) >> 0);
 268   assertEquals(neg_non_smi + 0x100000000, (neg_non_smi) >>> 0);
 269   assertEquals(neg_non_smi, (neg_non_smi) << 0);
 270   assertEquals(pos_smi, (pos_smi) >> 0, "possmi >> 0");
 271   assertEquals(pos_smi, (pos_smi) >>> 0, "possmi >>>0");
 272   assertEquals(pos_smi, (pos_smi) << 0, "possmi << 0");
 273   assertEquals(neg_smi, (neg_smi) >> 0, "negsmi >> 0");
 274   assertEquals(neg_smi + 0x100000000, (neg_smi) >>> 0, "negsmi >>> 0");
 275   assertEquals(neg_smi, (neg_smi) << 0), "negsmi << 0";
 276
 277   assertEquals(pos_non_smi / 2, (pos_non_smi) >> 1);
 278   assertEquals(pos_non_smi / 2, (pos_non_smi) >>> 1);
 279   assertEquals(-0x1194D800, (pos_non_smi) << 1);
 280   assertEquals(pos_non_smi / 8, (pos_non_smi) >> 3);
 281   assertEquals(pos_non_smi / 8, (pos_non_smi) >>> 3);
 282   assertEquals(-0x46536000, (pos_non_smi) << 3);
 283   assertEquals(0x73594000, (pos_non_smi) << 4);
 284   assertEquals(pos_non_smi, (pos_non_smi + 0.5) >> 0);
 285   assertEquals(pos_non_smi, (pos_non_smi + 0.5) >>> 0);
 286   assertEquals(pos_non_smi, (pos_non_smi + 0.5) << 0);
 287   assertEquals(pos_non_smi / 2, (pos_non_smi + 0.5) >> 1);
 288   assertEquals(pos_non_smi / 2, (pos_non_smi + 0.5) >>> 1);
 289   assertEquals(-0x1194D800, (pos_non_smi + 0.5) << 1);
 290   assertEquals(pos_non_smi / 8, (pos_non_smi + 0.5) >> 3);
 291   assertEquals(pos_non_smi / 8, (pos_non_smi + 0.5) >>> 3);
 292   assertEquals(-0x46536000, (pos_non_smi + 0.5) << 3);
 293   assertEquals(0x73594000, (pos_non_smi + 0.5) << 4);
 294
 295   assertEquals(neg_non_smi / 2, (neg_non_smi) >> 1, "negnonsmi >> 1");
 296
 297   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_non_smi) >>> 1,
 298                "negnonsmi >>> 1");
 299   assertEquals(0x1194D800, (neg_non_smi) << 1);
 300   assertEquals(neg_non_smi / 8, (neg_non_smi) >> 3);
 301   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_non_smi) >>> 3);
 302   assertEquals(0x46536000, (neg_non_smi) << 3);
 303   assertEquals(-0x73594000, (neg_non_smi) << 4);
 304   assertEquals(neg_non_smi, (neg_non_smi - 0.5) >> 0);
 305   assertEquals(neg_non_smi + 0x100000000, (neg_non_smi - 0.5) >>> 0,
 306                "negnonsmi.5 >>> 0");
 307   assertEquals(neg_non_smi, (neg_non_smi - 0.5) << 0);
 308   assertEquals(neg_non_smi / 2, (neg_non_smi - 0.5) >> 1);
 309   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_non_smi - 0.5) >>> 1,
 310                "negnonsmi.5 >>> 1");
 311   assertEquals(0x1194D800, (neg_non_smi - 0.5) << 1);
 312   assertEquals(neg_non_smi / 8, (neg_non_smi - 0.5) >> 3);
 313   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_non_smi - 0.5) >>> 3);
 314   assertEquals(0x46536000, (neg_non_smi - 0.5) << 3);
 315   assertEquals(-0x73594000, (neg_non_smi - 0.5) << 4);
 316
 317   assertEquals(pos_smi / 2, (pos_smi) >> 1);
 318   assertEquals(pos_smi / 2, (pos_smi) >>> 1);
 319   assertEquals(pos_non_smi, (pos_smi) << 1);
 320   assertEquals(pos_smi / 8, (pos_smi) >> 3);
 321   assertEquals(pos_smi / 8, (pos_smi) >>> 3);
 322   assertEquals(-0x2329b000, (pos_smi) << 3);
 323   assertEquals(0x73594000, (pos_smi) << 5);
 324   assertEquals(pos_smi, (pos_smi + 0.5) >> 0, "possmi.5 >> 0");
 325   assertEquals(pos_smi, (pos_smi + 0.5) >>> 0, "possmi.5 >>> 0");
 326   assertEquals(pos_smi, (pos_smi + 0.5) << 0, "possmi.5 << 0");
 327   assertEquals(pos_smi / 2, (pos_smi + 0.5) >> 1);
 328   assertEquals(pos_smi / 2, (pos_smi + 0.5) >>> 1);
 329   assertEquals(pos_non_smi, (pos_smi + 0.5) << 1);
 330   assertEquals(pos_smi / 8, (pos_smi + 0.5) >> 3);
 331   assertEquals(pos_smi / 8, (pos_smi + 0.5) >>> 3);
 332   assertEquals(-0x2329b000, (pos_smi + 0.5) << 3);
 333   assertEquals(0x73594000, (pos_smi + 0.5) << 5);
 334
 335   assertEquals(neg_smi / 2, (neg_smi) >> 1);
 336   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_smi) >>> 1);
 337   assertEquals(neg_non_smi, (neg_smi) << 1);
 338   assertEquals(neg_smi / 8, (neg_smi) >> 3);
 339   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_smi) >>> 3);
 340   assertEquals(0x46536000, (neg_smi) << 4);
 341   assertEquals(-0x73594000, (neg_smi) << 5);
 342   assertEquals(neg_smi, (neg_smi - 0.5) >> 0, "negsmi.5 >> 0");
 343   assertEquals(neg_smi + 0x100000000, (neg_smi - 0.5) >>> 0, "negsmi.5 >>> 0");
 344   assertEquals(neg_smi, (neg_smi - 0.5) << 0, "negsmi.5 << 0");
 345   assertEquals(neg_smi / 2, (neg_smi - 0.5) >> 1);
 346   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_smi - 0.5) >>> 1);
 347   assertEquals(neg_non_smi, (neg_smi - 0.5) << 1);
 348   assertEquals(neg_smi / 8, (neg_smi - 0.5) >> 3);
 349   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_smi - 0.5) >>> 3);
 350   assertEquals(0x46536000, (neg_smi - 0.5) << 4);
 351   assertEquals(-0x73594000, (neg_smi - 0.5) << 5);
 352   // End block A
 353
 354   // Repeat block A with 2^32 added to positive numbers and
 355   // 2^32 subtracted from negative numbers.
 356   // Begin block A repeat 1
 357   var two_32 = 0x100000000;
 358   var neg_32 = -two_32;
 359   assertEquals(pos_non_smi, (two_32 + pos_non_smi) >> 0);
 360   assertEquals(pos_non_smi, (two_32 + pos_non_smi) >>> 0);
 361   assertEquals(pos_non_smi, (two_32 + pos_non_smi) << 0);
 362   assertEquals(neg_non_smi, (neg_32 + neg_non_smi) >> 0);
 363   assertEquals(neg_non_smi + 0x100000000, (neg_32 + neg_non_smi) >>> 0);
 364   assertEquals(neg_non_smi, (neg_32 + neg_non_smi) << 0);
 365   assertEquals(pos_smi, (two_32 + pos_smi) >> 0, "2^32+possmi >> 0");
 366   assertEquals(pos_smi, (two_32 + pos_smi) >>> 0, "2^32+possmi >>> 0");
 367   assertEquals(pos_smi, (two_32 + pos_smi) << 0, "2^32+possmi << 0");
 368   assertEquals(neg_smi, (neg_32 + neg_smi) >> 0, "2^32+negsmi >> 0");
 369   assertEquals(neg_smi + 0x100000000, (neg_32 + neg_smi) >>> 0);
 370   assertEquals(neg_smi, (neg_32 + neg_smi) << 0, "2^32+negsmi << 0");
 371
 372   assertEquals(pos_non_smi / 2, (two_32 + pos_non_smi) >> 1);
 373   assertEquals(pos_non_smi / 2, (two_32 + pos_non_smi) >>> 1);
 374   assertEquals(-0x1194D800, (two_32 + pos_non_smi) << 1);
 375   assertEquals(pos_non_smi / 8, (two_32 + pos_non_smi) >> 3);
 376   assertEquals(pos_non_smi / 8, (two_32 + pos_non_smi) >>> 3);
 377   assertEquals(-0x46536000, (two_32 + pos_non_smi) << 3);
 378   assertEquals(0x73594000, (two_32 + pos_non_smi) << 4);
 379   assertEquals(pos_non_smi, (two_32 + pos_non_smi + 0.5) >> 0);
 380   assertEquals(pos_non_smi, (two_32 + pos_non_smi + 0.5) >>> 0);
 381   assertEquals(pos_non_smi, (two_32 + pos_non_smi + 0.5) << 0);
 382   assertEquals(pos_non_smi / 2, (two_32 + pos_non_smi + 0.5) >> 1);
 383   assertEquals(pos_non_smi / 2, (two_32 + pos_non_smi + 0.5) >>> 1);
 384   assertEquals(-0x1194D800, (two_32 + pos_non_smi + 0.5) << 1);
 385   assertEquals(pos_non_smi / 8, (two_32 + pos_non_smi + 0.5) >> 3);
 386   assertEquals(pos_non_smi / 8, (two_32 + pos_non_smi + 0.5) >>> 3);
 387   assertEquals(-0x46536000, (two_32 + pos_non_smi + 0.5) << 3);
 388   assertEquals(0x73594000, (two_32 + pos_non_smi + 0.5) << 4);
 389
 390   assertEquals(neg_non_smi / 2, (neg_32 + neg_non_smi) >> 1);
 391   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_32 + neg_non_smi) >>> 1);
 392   assertEquals(0x1194D800, (neg_32 + neg_non_smi) << 1);
 393   assertEquals(neg_non_smi / 8, (neg_32 + neg_non_smi) >> 3);
 394   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_32 + neg_non_smi) >>> 3);
 395   assertEquals(0x46536000, (neg_32 + neg_non_smi) << 3);
 396   assertEquals(-0x73594000, (neg_32 + neg_non_smi) << 4);
 397   assertEquals(neg_non_smi, (neg_32 + neg_non_smi - 0.5) >> 0);
 398   assertEquals(neg_non_smi + 0x100000000, (neg_32 + neg_non_smi - 0.5) >>> 0);
 399   assertEquals(neg_non_smi, (neg_32 + neg_non_smi - 0.5) << 0);
 400   assertEquals(neg_non_smi / 2, (neg_32 + neg_non_smi - 0.5) >> 1);
 401   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_32 + neg_non_smi - 0.5)
 402                >>> 1);
 403   assertEquals(0x1194D800, (neg_32 + neg_non_smi - 0.5) << 1);
 404   assertEquals(neg_non_smi / 8, (neg_32 + neg_non_smi - 0.5) >> 3);
 405   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_32 + neg_non_smi - 0.5)
 406                >>> 3);
 407   assertEquals(0x46536000, (neg_32 + neg_non_smi - 0.5) << 3);
 408   assertEquals(-0x73594000, (neg_32 + neg_non_smi - 0.5) << 4);
 409
 410   assertEquals(pos_smi / 2, (two_32 + pos_smi) >> 1);
 411   assertEquals(pos_smi / 2, (two_32 + pos_smi) >>> 1);
 412   assertEquals(pos_non_smi, (two_32 + pos_smi) << 1);
 413   assertEquals(pos_smi / 8, (two_32 + pos_smi) >> 3);
 414   assertEquals(pos_smi / 8, (two_32 + pos_smi) >>> 3);
 415   assertEquals(-0x2329b000, (two_32 + pos_smi) << 3);
 416   assertEquals(0x73594000, (two_32 + pos_smi) << 5);
 417   assertEquals(pos_smi, (two_32 + pos_smi + 0.5) >> 0);
 418   assertEquals(pos_smi, (two_32 + pos_smi + 0.5) >>> 0);
 419   assertEquals(pos_smi, (two_32 + pos_smi + 0.5) << 0);
 420   assertEquals(pos_smi / 2, (two_32 + pos_smi + 0.5) >> 1);
 421   assertEquals(pos_smi / 2, (two_32 + pos_smi + 0.5) >>> 1);
 422   assertEquals(pos_non_smi, (two_32 + pos_smi + 0.5) << 1);
 423   assertEquals(pos_smi / 8, (two_32 + pos_smi + 0.5) >> 3);
 424   assertEquals(pos_smi / 8, (two_32 + pos_smi + 0.5) >>> 3);
 425   assertEquals(-0x2329b000, (two_32 + pos_smi + 0.5) << 3);
 426   assertEquals(0x73594000, (two_32 + pos_smi + 0.5) << 5);
 427
 428   assertEquals(neg_smi / 2, (neg_32 + neg_smi) >> 1);
 429   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_32 + neg_smi) >>> 1);
 430   assertEquals(neg_non_smi, (neg_32 + neg_smi) << 1);
 431   assertEquals(neg_smi / 8, (neg_32 + neg_smi) >> 3);
 432   assertEquals((neg_smi + 0x100000000) / 8, (neg_32 + neg_smi) >>> 3);
 433   assertEquals(0x46536000, (neg_32 + neg_smi) << 4);
 434   assertEquals(-0x73594000, (neg_32 + neg_smi) << 5);
 435   assertEquals(neg_smi, (neg_32 + neg_smi - 0.5) >> 0, "-2^32+negsmi.5 >> 0");
 436   assertEquals(neg_smi + 0x100000000, (neg_32 + neg_smi - 0.5) >>> 0);
 437   assertEquals(neg_smi, (neg_32 + neg_smi - 0.5) << 0, "-2^32+negsmi.5 << 0");
 438   assertEquals(neg_smi / 2, (neg_32 + neg_smi - 0.5) >> 1);
 439   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_32 + neg_smi - 0.5) >>> 1);
 440   assertEquals(neg_non_smi, (neg_32 + neg_smi - 0.5) << 1);
 441   assertEquals(neg_smi / 8, (neg_32 + neg_smi - 0.5) >> 3);
 442   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_32 + neg_smi - 0.5) >>> 3);
 443   assertEquals(0x46536000, (neg_32 + neg_smi - 0.5) << 4);
 444   assertEquals(-0x73594000, (neg_32 + neg_smi - 0.5) << 5);
 445   // End block A repeat 1
 446   // Repeat block A with shift amounts in variables intialized with
 447   // a constant.
 448   var zero = 0;
 449   var one = 1;
 450   var three = 3;
 451   var four = 4;
 452   var five = 5;
 453   // Begin block A repeat 2
 454   assertEquals(pos_non_smi, (pos_non_smi) >> zero);
 455   assertEquals(pos_non_smi, (pos_non_smi) >>> zero);
 456   assertEquals(pos_non_smi, (pos_non_smi) << zero);
 457   assertEquals(neg_non_smi, (neg_non_smi) >> zero);
 458   assertEquals(neg_non_smi + 0x100000000, (neg_non_smi) >>> zero);
 459   assertEquals(neg_non_smi, (neg_non_smi) << zero);
 460   assertEquals(pos_smi, (pos_smi) >> zero);
 461   assertEquals(pos_smi, (pos_smi) >>> zero);
 462   assertEquals(pos_smi, (pos_smi) << zero);
 463   assertEquals(neg_smi, (neg_smi) >> zero, "negsmi >> zero");
 464   assertEquals(neg_smi + 0x100000000, (neg_smi) >>> zero);
 465   assertEquals(neg_smi, (neg_smi) << zero, "negsmi << zero");
 466
 467   assertEquals(pos_non_smi / 2, (pos_non_smi) >> one);
 468   assertEquals(pos_non_smi / 2, (pos_non_smi) >>> one);
 469   assertEquals(-0x1194D800, (pos_non_smi) << one);
 470   assertEquals(pos_non_smi / 8, (pos_non_smi) >> three);
 471   assertEquals(pos_non_smi / 8, (pos_non_smi) >>> three);
 472   assertEquals(-0x46536000, (pos_non_smi) << three);
 473   assertEquals(0x73594000, (pos_non_smi) << four);
 474   assertEquals(pos_non_smi, (pos_non_smi + 0.5) >> zero);
 475   assertEquals(pos_non_smi, (pos_non_smi + 0.5) >>> zero);
 476   assertEquals(pos_non_smi, (pos_non_smi + 0.5) << zero);
 477   assertEquals(pos_non_smi / 2, (pos_non_smi + 0.5) >> one);
 478   assertEquals(pos_non_smi / 2, (pos_non_smi + 0.5) >>> one);
 479   assertEquals(-0x1194D800, (pos_non_smi + 0.5) << one);
 480   assertEquals(pos_non_smi / 8, (pos_non_smi + 0.5) >> three);
 481   assertEquals(pos_non_smi / 8, (pos_non_smi + 0.5) >>> three);
 482   assertEquals(-0x46536000, (pos_non_smi + 0.5) << three);
 483   assertEquals(0x73594000, (pos_non_smi + 0.5) << four);
 484
 485   assertEquals(neg_non_smi / 2, (neg_non_smi) >> one);
 486   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_non_smi) >>> one);
 487   assertEquals(0x1194D800, (neg_non_smi) << one);
 488   assertEquals(neg_non_smi / 8, (neg_non_smi) >> three);
 489   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_non_smi) >>> three);
 490   assertEquals(0x46536000, (neg_non_smi) << three);
 491   assertEquals(-0x73594000, (neg_non_smi) << four);
 492   assertEquals(neg_non_smi, (neg_non_smi - 0.5) >> zero);
 493   assertEquals(neg_non_smi + 0x100000000, (neg_non_smi - 0.5) >>> zero);
 494   assertEquals(neg_non_smi, (neg_non_smi - 0.5) << zero);
 495   assertEquals(neg_non_smi / 2, (neg_non_smi - 0.5) >> one);
 496   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_non_smi - 0.5) >>> one);
 497   assertEquals(0x1194D800, (neg_non_smi - 0.5) << one);
 498   assertEquals(neg_non_smi / 8, (neg_non_smi - 0.5) >> three);
 499   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_non_smi - 0.5)
 500       >>> three);
 501   assertEquals(0x46536000, (neg_non_smi - 0.5) << three);
 502   assertEquals(-0x73594000, (neg_non_smi - 0.5) << four);
 503
 504   assertEquals(pos_smi / 2, (pos_smi) >> one);
 505   assertEquals(pos_smi / 2, (pos_smi) >>> one);
 506   assertEquals(pos_non_smi, (pos_smi) << one);
 507   assertEquals(pos_smi / 8, (pos_smi) >> three);
 508   assertEquals(pos_smi / 8, (pos_smi) >>> three);
 509   assertEquals(-0x2329b000, (pos_smi) << three);
 510   assertEquals(0x73594000, (pos_smi) << five);
 511   assertEquals(pos_smi, (pos_smi + 0.5) >> zero);
 512   assertEquals(pos_smi, (pos_smi + 0.5) >>> zero);
 513   assertEquals(pos_smi, (pos_smi + 0.5) << zero);
 514   assertEquals(pos_smi / 2, (pos_smi + 0.5) >> one);
 515   assertEquals(pos_smi / 2, (pos_smi + 0.5) >>> one);
 516   assertEquals(pos_non_smi, (pos_smi + 0.5) << one);
 517   assertEquals(pos_smi / 8, (pos_smi + 0.5) >> three);
 518   assertEquals(pos_smi / 8, (pos_smi + 0.5) >>> three);
 519   assertEquals(-0x2329b000, (pos_smi + 0.5) << three);
 520   assertEquals(0x73594000, (pos_smi + 0.5) << five);
 521
 522   assertEquals(neg_smi / 2, (neg_smi) >> one);
 523   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_smi) >>> one);
 524   assertEquals(neg_non_smi, (neg_smi) << one);
 525   assertEquals(neg_smi / 8, (neg_smi) >> three);
 526   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_smi) >>> three);
 527   assertEquals(0x46536000, (neg_smi) << four);
 528   assertEquals(-0x73594000, (neg_smi) << five);
 529   assertEquals(neg_smi, (neg_smi - 0.5) >> zero);
 530   assertEquals(neg_smi + 0x100000000, (neg_smi - 0.5) >>> zero);
 531   assertEquals(neg_smi, (neg_smi - 0.5) << zero);
 532   assertEquals(neg_smi / 2, (neg_smi - 0.5) >> one);
 533   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_smi - 0.5) >>> one);
 534   assertEquals(neg_non_smi, (neg_smi - 0.5) << one);
 535   assertEquals(neg_smi / 8, (neg_smi - 0.5) >> three);
 536   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_smi - 0.5) >>> three);
 537   assertEquals(0x46536000, (neg_smi - 0.5) << four);
 538   assertEquals(-0x73594000, (neg_smi - 0.5) << five);
 539   // End block A repeat 2
 540
 541   // Repeat previous block, with computed values in the shift variables.
 542   five = 0;
 543   while (five < 5 ) ++five;
 544   four = five - one;
 545   three = four - one;
 546   one = four - three;
 547   zero = one - one;
 548
 549   // Begin block A repeat 3
 550   assertEquals(pos_non_smi, (pos_non_smi) >> zero);
 551   assertEquals(pos_non_smi, (pos_non_smi) >>> zero);
 552   assertEquals(pos_non_smi, (pos_non_smi) << zero);
 553   assertEquals(neg_non_smi, (neg_non_smi) >> zero);
 554   assertEquals(neg_non_smi + 0x100000000, (neg_non_smi) >>> zero);
 555   assertEquals(neg_non_smi, (neg_non_smi) << zero);
 556   assertEquals(pos_smi, (pos_smi) >> zero);
 557   assertEquals(pos_smi, (pos_smi) >>> zero);
 558   assertEquals(pos_smi, (pos_smi) << zero);
 559   assertEquals(neg_smi, (neg_smi) >> zero, "negsmi >> zero(2)");
 560   assertEquals(neg_smi + 0x100000000, (neg_smi) >>> zero);
 561   assertEquals(neg_smi, (neg_smi) << zero, "negsmi << zero(2)");
 562
 563   assertEquals(pos_non_smi / 2, (pos_non_smi) >> one);
 564   assertEquals(pos_non_smi / 2, (pos_non_smi) >>> one);
 565   assertEquals(-0x1194D800, (pos_non_smi) << one);
 566   assertEquals(pos_non_smi / 8, (pos_non_smi) >> three);
 567   assertEquals(pos_non_smi / 8, (pos_non_smi) >>> three);
 568   assertEquals(-0x46536000, (pos_non_smi) << three);
 569   assertEquals(0x73594000, (pos_non_smi) << four);
 570   assertEquals(pos_non_smi, (pos_non_smi + 0.5) >> zero);
 571   assertEquals(pos_non_smi, (pos_non_smi + 0.5) >>> zero);
 572   assertEquals(pos_non_smi, (pos_non_smi + 0.5) << zero);
 573   assertEquals(pos_non_smi / 2, (pos_non_smi + 0.5) >> one);
 574   assertEquals(pos_non_smi / 2, (pos_non_smi + 0.5) >>> one);
 575   assertEquals(-0x1194D800, (pos_non_smi + 0.5) << one);
 576   assertEquals(pos_non_smi / 8, (pos_non_smi + 0.5) >> three);
 577   assertEquals(pos_non_smi / 8, (pos_non_smi + 0.5) >>> three);
 578   assertEquals(-0x46536000, (pos_non_smi + 0.5) << three);
 579   assertEquals(0x73594000, (pos_non_smi + 0.5) << four);
 580
 581   assertEquals(neg_non_smi / 2, (neg_non_smi) >> one);
 582   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_non_smi) >>> one);
 583   assertEquals(0x1194D800, (neg_non_smi) << one);
 584   assertEquals(neg_non_smi / 8, (neg_non_smi) >> three);
 585   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_non_smi) >>> three);
 586   assertEquals(0x46536000, (neg_non_smi) << three);
 587   assertEquals(-0x73594000, (neg_non_smi) << four);
 588   assertEquals(neg_non_smi, (neg_non_smi - 0.5) >> zero);
 589   assertEquals(neg_non_smi + 0x100000000, (neg_non_smi - 0.5) >>> zero);
 590   assertEquals(neg_non_smi, (neg_non_smi - 0.5) << zero);
 591   assertEquals(neg_non_smi / 2, (neg_non_smi - 0.5) >> one);
 592   assertEquals(neg_non_smi / 2 + 0x100000000 / 2, (neg_non_smi - 0.5) >>> one);
 593   assertEquals(0x1194D800, (neg_non_smi - 0.5) << one);
 594   assertEquals(neg_non_smi / 8, (neg_non_smi - 0.5) >> three);
 595   assertEquals(neg_non_smi / 8 + 0x100000000 / 8, (neg_non_smi - 0.5)
 596       >>> three);
 597   assertEquals(0x46536000, (neg_non_smi - 0.5) << three);
 598   assertEquals(-0x73594000, (neg_non_smi - 0.5) << four);
 599
 600   assertEquals(pos_smi / 2, (pos_smi) >> one);
 601   assertEquals(pos_smi / 2, (pos_smi) >>> one);
 602   assertEquals(pos_non_smi, (pos_smi) << one);
 603   assertEquals(pos_smi / 8, (pos_smi) >> three);
 604   assertEquals(pos_smi / 8, (pos_smi) >>> three);
 605   assertEquals(-0x2329b000, (pos_smi) << three);
 606   assertEquals(0x73594000, (pos_smi) << five);
 607   assertEquals(pos_smi, (pos_smi + 0.5) >> zero);
 608   assertEquals(pos_smi, (pos_smi + 0.5) >>> zero);
 609   assertEquals(pos_smi, (pos_smi + 0.5) << zero);
 610   assertEquals(pos_smi / 2, (pos_smi + 0.5) >> one);
 611   assertEquals(pos_smi / 2, (pos_smi + 0.5) >>> one);
 612   assertEquals(pos_non_smi, (pos_smi + 0.5) << one);
 613   assertEquals(pos_smi / 8, (pos_smi + 0.5) >> three);
 614   assertEquals(pos_smi / 8, (pos_smi + 0.5) >>> three);
 615   assertEquals(-0x2329b000, (pos_smi + 0.5) << three);
 616   assertEquals(0x73594000, (pos_smi + 0.5) << five);
 617
 618   assertEquals(neg_smi / 2, (neg_smi) >> one);
 619   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_smi) >>> one);
 620   assertEquals(neg_non_smi, (neg_smi) << one);
 621   assertEquals(neg_smi / 8, (neg_smi) >> three);
 622   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_smi) >>> three);
 623   assertEquals(0x46536000, (neg_smi) << four);
 624   assertEquals(-0x73594000, (neg_smi) << five);
 625   assertEquals(neg_smi, (neg_smi - 0.5) >> zero, "negsmi.5 >> zero");
 626   assertEquals(neg_smi + 0x100000000, (neg_smi - 0.5) >>> zero);
 627   assertEquals(neg_smi, (neg_smi - 0.5) << zero, "negsmi.5 << zero");
 628   assertEquals(neg_smi / 2, (neg_smi - 0.5) >> one);
 629   assertEquals(neg_smi / 2 + 0x100000000 / 2, (neg_smi - 0.5) >>> one);
 630   assertEquals(neg_non_smi, (neg_smi - 0.5) << one);
 631   assertEquals(neg_smi / 8, (neg_smi - 0.5) >> three);
 632   assertEquals(neg_smi / 8 + 0x100000000 / 8, (neg_smi - 0.5) >>> three);
 633   assertEquals(0x46536000, (neg_smi - 0.5) << four);
 634   assertEquals(-0x73594000, (neg_smi - 0.5) << five);
 635   // End block A repeat 3
 636
 637   // Test non-integer shift value
 638   assertEquals(5, 20.5 >> 2.4);
 639   assertEquals(5, 20.5 >> 2.7);
 640   var shift = 2.4;
 641   assertEquals(5, 20.5 >> shift);
 642   assertEquals(5, 20.5 >> shift + 0.3);
 643   shift = shift + zero;
 644   assertEquals(5, 20.5 >> shift);
 645   assertEquals(5, 20.5 >> shift + 0.3);
 646 }
 647
 648 testShiftNonSmis();
 649
 650 function intConversion() {
 651   function foo(x) {
 652     assertEquals(x, (x * 1.0000000001) | 0, "foo more " + x);
 653     assertEquals(x, x | 0, "foo " + x);
 654     if (x > 0) {
 655       assertEquals(x - 1, (x * 0.9999999999) | 0, "foo less " + x);
 656     } else {
 657       assertEquals(x + 1, (x * 0.9999999999) | 0, "foo less " + x);
 658     }
 659   }
 660   for (var i = 1; i < 0x80000000; i *= 2) {
 661     foo(i);
 662     foo(-i);
 663   }
 664   for (var i = 1; i < 1/0; i *= 2) {
 665     assertEquals(i | 0, (i * 1.0000000000000001) | 0, "b" + i);
 666     assertEquals(-i | 0, (i * -1.0000000000000001) | 0, "c" + i);
 667   }
 668   for (var i = 0.5; i > 0; i /= 2) {
 669     assertEquals(0, i | 0, "d" + i);
 670     assertEquals(0, -i | 0, "e" + i);
 671   }
 672 }
 673
 674 intConversion();
 675
 676 // Verify that we handle the (optimized) corner case of shifting by
 677 // zero even for non-smis.
 678 function shiftByZero(n) { return n << 0; }
 679
 680 assertEquals(3, shiftByZero(3.1415));
 681
 682 // Verify that the static type information of x >>> 32 is computed correctly.
 683 function LogicalShiftRightByMultipleOf32(x) {
 684   x = x >>> 32;
 685   return x + x;
 686 }
 687
 688 assertEquals(4589934592, LogicalShiftRightByMultipleOf32(-2000000000));
 689 assertEquals(4589934592, LogicalShiftRightByMultipleOf32(-2000000000));
 690
 691 // Verify that the shift amount is reduced modulo 32, not modulo 64.
 692 function LeftShiftThreeBy(x) {return 3 << x;}
 693 assertEquals(24, LeftShiftThreeBy(3));
 694 assertEquals(24, LeftShiftThreeBy(35));
 695 assertEquals(24, LeftShiftThreeBy(67));
 696 assertEquals(24, LeftShiftThreeBy(-29));
 697
 698 // Regression test for a bug in the ARM code generator.  For some register
 699 // allocations we got the Smi overflow case wrong.
 700 function f(x, y) { return y +  ( 1 << (x & 31)); }
 701 assertEquals(-2147483647, f(31, 1));
 702
 703 // Regression test for correct handling of overflow in smi comparison.
 704 assertTrue(-0x40000000 < 42);