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