src/v8/test/mjsunit/simd/int32x4.js

   1 // Copyright 2011 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 // Flags: --simd_object  --allow-natives-syntax
  29
  30 function testConstructor() {
  31   var u4 = SIMD.int32x4(1, 2, 3, 4);
  32   assertEquals(1, u4.x);
  33   assertEquals(2, u4.y);
  34   assertEquals(3, u4.z);
  35   assertEquals(4, u4.w);
  36 }
  37
  38 testConstructor();
  39
  40 function test1ArgumentConstructor() {
  41   var u4 = SIMD.int32x4(1, 2, 3, 4);
  42   var u4_new = SIMD.int32x4(u4);
  43   assertEquals(u4_new.x, u4.x);
  44   assertEquals(u4_new.y, u4.y);
  45   assertEquals(u4_new.z, u4.z);
  46   assertEquals(u4_new.w, u4.w);
  47 }
  48
  49 test1ArgumentConstructor();
  50 test1ArgumentConstructor();
  51 %OptimizeFunctionOnNextCall(test1ArgumentConstructor);
  52 test1ArgumentConstructor();
  53
  54 function testZeroConstructor() {
  55   var u4 = SIMD.int32x4.zero();
  56   assertEquals(0, u4.x);
  57   assertEquals(0, u4.y);
  58   assertEquals(0, u4.z);
  59   assertEquals(0, u4.w);
  60 }
  61
  62 testZeroConstructor();
  63 testZeroConstructor();
  64 %OptimizeFunctionOnNextCall(testZeroConstructor);
  65 testZeroConstructor();
  66
  67 function testBoolConstructor() {
  68   var u4 = SIMD.int32x4.bool(true, false, true, false);
  69   assertEquals(-1, u4.x);
  70   assertEquals(0, u4.y);
  71   assertEquals(-1, u4.z);
  72   assertEquals(0, u4.w);
  73 }
  74
  75 testBoolConstructor();
  76 testBoolConstructor();
  77 %OptimizeFunctionOnNextCall(testBoolConstructor);
  78 testBoolConstructor();
  79
  80 function testSplatConstructor() {
  81   var u4 = SIMD.int32x4.splat(4);
  82   assertEquals(4, u4.x);
  83   assertEquals(4, u4.y);
  84   assertEquals(4, u4.z);
  85   assertEquals(4, u4.w);
  86 }
  87
  88 testSplatConstructor();
  89 testSplatConstructor();
  90 %OptimizeFunctionOnNextCall(testSplatConstructor);
  91 testSplatConstructor();
  92
  93 function testTypeof() {
  94   var u4 = SIMD.int32x4(1, 2, 3, 4);
  95   assertEquals(typeof(u4), "object");
  96
  97   var new_u4 = new SIMD.int32x4(1, 2, 3, 4);
  98   assertEquals(typeof(new_u4), "object");
  99   assertEquals(typeof(new_u4.valueOf()), "object");
 100   assertEquals(Object.prototype.toString.call(new_u4), "[object Object]");
 101 }
 102
 103 testTypeof();
 104
 105 function testSignMaskGetter() {
 106   var a = SIMD.int32x4(0x80000000 - 0xFFFFFFFF - 1, 0x7000000, -1, 0x0);
 107   assertEquals(0x5, a.signMask);
 108   var b = SIMD.int32x4(0x0, 0x0, 0x0, 0x0);
 109   assertEquals(0x0, b.signMask);
 110   var c = SIMD.int32x4(-1, -1, -1, -1);
 111   assertEquals(0xf, c.signMask);
 112 }
 113
 114 testSignMaskGetter();
 115 testSignMaskGetter();
 116 %OptimizeFunctionOnNextCall(testSignMaskGetter);
 117 testSignMaskGetter();
 118
 119
 120 function testSIMDAnd() {
 121   var m = SIMD.int32x4(0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1,
 122                   0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1);
 123   var n = SIMD.int32x4(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 124   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, m.x);
 125   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, m.y);
 126   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, m.z);
 127   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, m.w);
 128   assertEquals(0x55555555, n.x);
 129   assertEquals(0x55555555, n.y);
 130   assertEquals(0x55555555, n.z);
 131   assertEquals(0x55555555, n.w);
 132   assertEquals(true, n.flagX);
 133   assertEquals(true, n.flagY);
 134   assertEquals(true, n.flagZ);
 135   assertEquals(true, n.flagW);
 136   o = SIMD.int32x4.and(m,n); // and
 137   assertEquals(0x0, o.x);
 138   assertEquals(0x0, o.y);
 139   assertEquals(0x0, o.z);
 140   assertEquals(0x0, o.w);
 141   assertEquals(false, o.flagX);
 142   assertEquals(false, o.flagY);
 143   assertEquals(false, o.flagZ);
 144   assertEquals(false, o.flagW);
 145 }
 146
 147 testSIMDAnd();
 148 testSIMDAnd();
 149 %OptimizeFunctionOnNextCall(testSIMDAnd);
 150 testSIMDAnd();
 151
 152 function testSIMDOr() {
 153   var m = SIMD.int32x4(0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1,
 154                   0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1);
 155   var n = SIMD.int32x4(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 156   var o = SIMD.int32x4.or(m,n); // or
 157   assertEquals(-1, o.x);
 158   assertEquals(-1, o.y);
 159   assertEquals(-1, o.z);
 160   assertEquals(-1, o.w);
 161   assertEquals(true, o.flagX);
 162   assertEquals(true, o.flagY);
 163   assertEquals(true, o.flagZ);
 164   assertEquals(true, o.flagW);
 165 }
 166
 167 testSIMDOr();
 168 testSIMDOr();
 169 %OptimizeFunctionOnNextCall(testSIMDOr);
 170 testSIMDOr();
 171
 172 function testSIMDInt32x4Or() {
 173   var m = SIMD.int32x4(0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1,
 174                   0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1);
 175   var n = SIMD.int32x4(0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1,
 176                   0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1);
 177   var o = SIMD.int32x4.xor(m,n); // xor
 178   assertEquals(0x0, o.x);
 179   assertEquals(0x0, o.y);
 180   assertEquals(0x0, o.z);
 181   assertEquals(0x0, o.w);
 182   assertEquals(false, o.flagX);
 183   assertEquals(false, o.flagY);
 184   assertEquals(false, o.flagZ);
 185   assertEquals(false, o.flagW);
 186 }
 187
 188 testSIMDInt32x4Or();
 189 testSIMDInt32x4Or();
 190 %OptimizeFunctionOnNextCall(testSIMDInt32x4Or);
 191 testSIMDInt32x4Or();
 192
 193 function testSIMDNot() {
 194   var m = SIMD.int32x4(0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1,
 195                   0xAAAAAAAA - 0xFFFFFFFF - 1, 0xAAAAAAAA - 0xFFFFFFFF - 1);
 196   var n = SIMD.int32x4(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 197   m = SIMD.int32x4.not(m);
 198   n = SIMD.int32x4.not(n);
 199   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, n.x);
 200   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, n.y);
 201   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, n.z);
 202   assertEquals(0xAAAAAAAA - 0xFFFFFFFF - 1, n.w);
 203   assertEquals(0x55555555, m.x);
 204   assertEquals(0x55555555, m.y);
 205   assertEquals(0x55555555, m.z);
 206   assertEquals(0x55555555, m.w);
 207 }
 208
 209 testSIMDNot();
 210 testSIMDNot();
 211 %OptimizeFunctionOnNextCall(testSIMDNot);
 212 testSIMDNot();
 213
 214 function testSIMDNegu32() {
 215   var m = SIMD.int32x4(-1, 1, -1, 1);
 216   m = SIMD.int32x4.neg(m);
 217   assertEquals(1, m.x);
 218   assertEquals(-1, m.y);
 219   assertEquals(1, m.z);
 220   assertEquals(-1, m.w);
 221 }
 222
 223 testSIMDNegu32();
 224 testSIMDNegu32();
 225 %OptimizeFunctionOnNextCall(testSIMDNegu32);
 226 testSIMDNegu32();
 227
 228 function testSIMDSelect() {
 229   var m = SIMD.int32x4.bool(true, true, false, false);
 230   var t = SIMD.int32x4(1, 2, 3, 4);
 231   var f = SIMD.int32x4(5, 6, 7, 8);
 232   var s = SIMD.int32x4.select(m, t, f);
 233   assertEquals(1, s.x);
 234   assertEquals(2, s.y);
 235   assertEquals(7, s.z);
 236   assertEquals(8, s.w);
 237 }
 238
 239 testSIMDSelect();
 240 testSIMDSelect();
 241 %OptimizeFunctionOnNextCall(testSIMDSelect);
 242 testSIMDSelect();
 243
 244
 245 function testSIMDWithXu32() {
 246     var a = SIMD.int32x4(1, 2, 3, 4);
 247     var c = SIMD.int32x4.withX(a, 20);
 248     assertEquals(20, c.x);
 249     assertEquals(2, c.y);
 250     assertEquals(3, c.z);
 251     assertEquals(4, c.w);
 252 }
 253
 254 testSIMDWithXu32();
 255 testSIMDWithXu32();
 256 %OptimizeFunctionOnNextCall(testSIMDWithXu32);
 257 testSIMDWithXu32();
 258
 259 function testSIMDWithYu32() {
 260     var a = SIMD.int32x4(1, 2, 3, 4);
 261     var c = SIMD.int32x4.withY(a, 20);
 262     assertEquals(1, c.x);
 263     assertEquals(20, c.y);
 264     assertEquals(3, c.z);
 265     assertEquals(4, c.w);
 266 }
 267
 268 testSIMDWithYu32();
 269 testSIMDWithYu32();
 270 %OptimizeFunctionOnNextCall(testSIMDWithYu32);
 271 testSIMDWithYu32();
 272
 273 function testSIMDWithZu32() {
 274     var a = SIMD.int32x4(1, 2, 3, 4);
 275     var c = SIMD.int32x4.withZ(a, 20);
 276     assertEquals(1, c.x);
 277     assertEquals(2, c.y);
 278     assertEquals(20, c.z);
 279     assertEquals(4, c.w);
 280 }
 281
 282 testSIMDWithZu32();
 283 testSIMDWithZu32();
 284 %OptimizeFunctionOnNextCall(testSIMDWithZu32);
 285 testSIMDWithZu32();
 286
 287 function testSIMDWithWu32() {
 288     var a = SIMD.int32x4(1, 2, 3, 4);
 289     var c = SIMD.int32x4.withW(a, 20);
 290     assertEquals(1, c.x);
 291     assertEquals(2, c.y);
 292     assertEquals(3, c.z);
 293     assertEquals(20, c.w);
 294 }
 295
 296 testSIMDWithWu32();
 297 testSIMDWithWu32();
 298 %OptimizeFunctionOnNextCall(testSIMDWithWu32);
 299 testSIMDWithWu32();
 300
 301 function testSIMDWithFlagX() {
 302     var a = SIMD.int32x4.bool(true, false, true, false);
 303
 304     // boolean
 305     var c = SIMD.int32x4.withFlagX(a, true);
 306     assertEquals(true, c.flagX);
 307     assertEquals(false, c.flagY);
 308     assertEquals(true, c.flagZ);
 309     assertEquals(false, c.flagW);
 310     c = SIMD.int32x4.withFlagX(a, false);
 311     assertEquals(false, c.flagX);
 312     assertEquals(false, c.flagY);
 313     assertEquals(true, c.flagZ);
 314     assertEquals(false, c.flagW);
 315     assertEquals(0x0, c.x);
 316     assertEquals(0x0, c.y);
 317     assertEquals(-1, c.z);
 318     assertEquals(0x0, c.w);
 319
 320     // smi
 321     c = SIMD.int32x4.withFlagX(a, 2);
 322     assertEquals(true, c.flagX);
 323     assertEquals(false, c.flagY);
 324     assertEquals(true, c.flagZ);
 325     assertEquals(false, c.flagW);
 326     assertEquals(-1, c.x);
 327     assertEquals(0x0, c.y);
 328     assertEquals(-1, c.z);
 329     assertEquals(0x0, c.w);
 330     c = SIMD.int32x4.withFlagX(a, 0);
 331     assertEquals(false, c.flagX);
 332     assertEquals(false, c.flagY);
 333     assertEquals(true, c.flagZ);
 334     assertEquals(false, c.flagW);
 335     assertEquals(0x0, c.x);
 336     assertEquals(0x0, c.y);
 337     assertEquals(-1, c.z);
 338     assertEquals(0x0, c.w);
 339
 340     // string
 341     c = SIMD.int32x4.withFlagX(a, 'true');
 342     assertEquals(true, c.flagX);
 343     assertEquals(false, c.flagY);
 344     assertEquals(true, c.flagZ);
 345     assertEquals(false, c.flagW);
 346     assertEquals(-1, c.x);
 347     assertEquals(0x0, c.y);
 348     assertEquals(-1, c.z);
 349     assertEquals(0x0, c.w);
 350     c = SIMD.int32x4.withFlagX(a, '');
 351     assertEquals(false, c.flagX);
 352     assertEquals(false, c.flagY);
 353     assertEquals(true, c.flagZ);
 354     assertEquals(false, c.flagW);
 355     assertEquals(0x0, c.x);
 356     assertEquals(0x0, c.y);
 357     assertEquals(-1, c.z);
 358     assertEquals(0x0, c.w);
 359
 360     // heap number
 361     c = SIMD.int32x4.withFlagX(a, 3.14);
 362     assertEquals(true, c.flagX);
 363     assertEquals(false, c.flagY);
 364     assertEquals(true, c.flagZ);
 365     assertEquals(false, c.flagW);
 366     assertEquals(-1, c.x);
 367     assertEquals(0x0, c.y);
 368     assertEquals(-1, c.z);
 369     assertEquals(0x0, c.w);
 370     c = SIMD.int32x4.withFlagX(a, 0.0);
 371     assertEquals(false, c.flagX);
 372     assertEquals(false, c.flagY);
 373     assertEquals(true, c.flagZ);
 374     assertEquals(false, c.flagW);
 375     assertEquals(0x0, c.x);
 376     assertEquals(0x0, c.y);
 377     assertEquals(-1, c.z);
 378     assertEquals(0x0, c.w);
 379
 380     // JS Array
 381     var array = [1];
 382     c = SIMD.int32x4.withFlagX(a, array);
 383     assertEquals(true, c.flagX);
 384     assertEquals(false, c.flagY);
 385     assertEquals(true, c.flagZ);
 386     assertEquals(false, c.flagW);
 387     assertEquals(-1, c.x);
 388     assertEquals(0x0, c.y);
 389     assertEquals(-1, c.z);
 390     assertEquals(0x0, c.w);
 391
 392     c = SIMD.int32x4.withFlagX(a, undefined);
 393     assertEquals(false, c.flagX);
 394     assertEquals(false, c.flagY);
 395     assertEquals(true, c.flagZ);
 396     assertEquals(false, c.flagW);
 397     assertEquals(0x0, c.x);
 398     assertEquals(0x0, c.y);
 399     assertEquals(-1, c.z);
 400     assertEquals(0x0, c.w);
 401 }
 402
 403 testSIMDWithFlagX();
 404 testSIMDWithFlagX();
 405 %OptimizeFunctionOnNextCall(testSIMDWithFlagX);
 406 testSIMDWithFlagX();
 407
 408 function testSIMDWithFlagY() {
 409     var a = SIMD.int32x4.bool(true, false, true, false);
 410     var c = SIMD.int32x4.withFlagY(a, true);
 411     assertEquals(true, c.flagX);
 412     assertEquals(true, c.flagY);
 413     assertEquals(true, c.flagZ);
 414     assertEquals(false, c.flagW);
 415     c = SIMD.int32x4.withFlagY(a, false);
 416     assertEquals(true, c.flagX);
 417     assertEquals(false, c.flagY);
 418     assertEquals(true, c.flagZ);
 419     assertEquals(false, c.flagW);
 420     assertEquals(-1, c.x);
 421     assertEquals(0x0, c.y);
 422     assertEquals(-1, c.z);
 423     assertEquals(0x0, c.w);
 424 }
 425
 426 testSIMDWithFlagY();
 427 testSIMDWithFlagY();
 428 %OptimizeFunctionOnNextCall(testSIMDWithFlagY);
 429 testSIMDWithFlagY();
 430
 431 function testSIMDWithFlagZ() {
 432     var a = SIMD.int32x4.bool(true, false, true, false);
 433     var c = SIMD.int32x4.withFlagZ(a, true);
 434     assertEquals(true, c.flagX);
 435     assertEquals(false, c.flagY);
 436     assertEquals(true, c.flagZ);
 437     assertEquals(false, c.flagW);
 438     c = SIMD.int32x4.withFlagZ(a, false);
 439     assertEquals(true, c.flagX);
 440     assertEquals(false, c.flagY);
 441     assertEquals(false, c.flagZ);
 442     assertEquals(false, c.flagW);
 443     assertEquals(-1, c.x);
 444     assertEquals(0x0, c.y);
 445     assertEquals(0x0, c.z);
 446     assertEquals(0x0, c.w);
 447 }
 448
 449 testSIMDWithFlagZ();
 450 testSIMDWithFlagZ();
 451 %OptimizeFunctionOnNextCall(testSIMDWithFlagZ);
 452 testSIMDWithFlagZ();
 453
 454 function testSIMDWithFlagW() {
 455     var a = SIMD.int32x4.bool(true, false, true, false);
 456     var c = SIMD.int32x4.withFlagW(a, true);
 457     assertEquals(true, c.flagX);
 458     assertEquals(false, c.flagY);
 459     assertEquals(true, c.flagZ);
 460     assertEquals(true, c.flagW);
 461     c = SIMD.int32x4.withFlagW(a, false);
 462     assertEquals(true, c.flagX);
 463     assertEquals(false, c.flagY);
 464     assertEquals(true, c.flagZ);
 465     assertEquals(false, c.flagW);
 466     assertEquals(-1, c.x);
 467     assertEquals(0x0, c.y);
 468     assertEquals(-1, c.z);
 469     assertEquals(0x0, c.w);
 470 }
 471
 472 testSIMDWithFlagW();
 473 testSIMDWithFlagW();
 474 %OptimizeFunctionOnNextCall(testSIMDWithFlagW);
 475 testSIMDWithFlagW();
 476
 477 function testSIMDAddu32() {
 478   var a = SIMD.int32x4(-1, -1, 0x7fffffff, 0x0);
 479   var b = SIMD.int32x4(0x1, -1, 0x1, -1);
 480   var c = SIMD.int32x4.add(a, b);
 481   assertEquals(0x0, c.x);
 482   assertEquals(-2, c.y);
 483   assertEquals(0x80000000 - 0xFFFFFFFF - 1, c.z);
 484   assertEquals(-1, c.w);
 485 }
 486
 487 testSIMDAddu32();
 488 testSIMDAddu32();
 489 %OptimizeFunctionOnNextCall(testSIMDAddu32);
 490 testSIMDAddu32();
 491
 492 function testSIMDSubu32() {
 493   var a = SIMD.int32x4(-1, -1, 0x80000000 - 0xFFFFFFFF - 1, 0x0);
 494   var b = SIMD.int32x4(0x1, -1, 0x1, -1);
 495   var c = SIMD.int32x4.sub(a, b);
 496   assertEquals(-2, c.x);
 497   assertEquals(0x0, c.y);
 498   assertEquals(0x7FFFFFFF, c.z);
 499   assertEquals(0x1, c.w);
 500 }
 501
 502 testSIMDSubu32();
 503 testSIMDSubu32();
 504 %OptimizeFunctionOnNextCall(testSIMDSubu32);
 505 testSIMDSubu32();
 506
 507 function testSIMDMulu32() {
 508   var a = SIMD.int32x4(-1, -1, 0x80000000 - 0xFFFFFFFF - 1, 0x0);
 509   var b = SIMD.int32x4(0x1, -1, 0x80000000 - 0xFFFFFFFF - 1, -1);
 510   var c = SIMD.int32x4.mul(a, b);
 511   assertEquals(-1, c.x);
 512   assertEquals(0x1, c.y);
 513   assertEquals(0x0, c.z);
 514   assertEquals(0x0, c.w);
 515 }
 516
 517 testSIMDMulu32();
 518 testSIMDMulu32();
 519 %OptimizeFunctionOnNextCall(testSIMDMulu32);
 520 testSIMDMulu32();
 521
 522 function testSIMDShuffleu32() {
 523   var m = SIMD.int32x4(1, 2, 3, 4);
 524   var xxxx = SIMD.int32x4.shuffle(m, SIMD.XXXX);
 525   assertEquals(1, xxxx.x);
 526   assertEquals(1, xxxx.y);
 527   assertEquals(1, xxxx.z);
 528   assertEquals(1, xxxx.w);
 529   var yyyy = SIMD.int32x4.shuffle(m, SIMD.YYYY);
 530   assertEquals(2, yyyy.x);
 531   assertEquals(2, yyyy.y);
 532   assertEquals(2, yyyy.z);
 533   assertEquals(2, yyyy.w);
 534   var zzzz = SIMD.int32x4.shuffle(m, SIMD.ZZZZ);
 535   assertEquals(3, zzzz.x);
 536   assertEquals(3, zzzz.y);
 537   assertEquals(3, zzzz.z);
 538   assertEquals(3, zzzz.w);
 539   var wwww = SIMD.int32x4.shuffle(m, SIMD.WWWW);
 540   assertEquals(4, wwww.x);
 541   assertEquals(4, wwww.y);
 542   assertEquals(4, wwww.z);
 543   assertEquals(4, wwww.w);
 544   var wzyx = SIMD.int32x4.shuffle(m, SIMD.WZYX);
 545   assertEquals(4, wzyx.x);
 546   assertEquals(3, wzyx.y);
 547   assertEquals(2, wzyx.z);
 548   assertEquals(1, wzyx.w);
 549   var wwzz = SIMD.int32x4.shuffle(m, SIMD.WWZZ);
 550   assertEquals(4, wwzz.x);
 551   assertEquals(4, wwzz.y);
 552   assertEquals(3, wwzz.z);
 553   assertEquals(3, wwzz.w);
 554   var xxyy = SIMD.int32x4.shuffle(m, SIMD.XXYY);
 555   assertEquals(1, xxyy.x);
 556   assertEquals(1, xxyy.y);
 557   assertEquals(2, xxyy.z);
 558   assertEquals(2, xxyy.w);
 559   var yyww = SIMD.int32x4.shuffle(m, SIMD.YYWW);
 560   assertEquals(2, yyww.x);
 561   assertEquals(2, yyww.y);
 562   assertEquals(4, yyww.z);
 563   assertEquals(4, yyww.w);
 564 }
 565
 566 testSIMDShuffleu32();
 567 testSIMDShuffleu32();
 568 %OptimizeFunctionOnNextCall(testSIMDShuffleu32);
 569 testSIMDShuffleu32();
 570
 571 function testSIMDComparisons() {
 572   var m = SIMD.int32x4(1, 2, 100, 1);
 573   var n = SIMD.int32x4(2, 2, 1, 100);
 574   var cmp;
 575   cmp = SIMD.int32x4.lessThan(m, n);
 576   assertEquals(-1, cmp.x);
 577   assertEquals(0x0, cmp.y);
 578   assertEquals(0x0, cmp.z);
 579   assertEquals(-1, cmp.w);
 580
 581   cmp = SIMD.int32x4.equal(m, n);
 582   assertEquals(0x0, cmp.x);
 583   assertEquals(-1, cmp.y);
 584   assertEquals(0x0, cmp.z);
 585   assertEquals(0x0, cmp.w);
 586
 587   cmp = SIMD.int32x4.greaterThan(m, n);
 588   assertEquals(0x0, cmp.x);
 589   assertEquals(0x0, cmp.y);
 590   assertEquals(-1, cmp.z);
 591   assertEquals(0x0, cmp.w);
 592 }
 593
 594 testSIMDComparisons();
 595 testSIMDComparisons();
 596 %OptimizeFunctionOnNextCall(testSIMDComparisons);
 597 testSIMDComparisons();
 598
 599 function testSIMDShift() {
 600   var m = SIMD.int32x4(1, 2, 100, 0);
 601
 602   var a = SIMD.int32x4.shiftLeft(m, 2);
 603   assertEquals(4, a.x);
 604   assertEquals(8, a.y);
 605   assertEquals(400, a.z);
 606   assertEquals(0, a.w);
 607
 608   var b = SIMD.int32x4.shiftRight(a, 2);
 609   assertEquals(1, b.x);
 610   assertEquals(2, b.y);
 611   assertEquals(100, b.z);
 612   assertEquals(0, b.w);
 613
 614   var n = SIMD.int32x4(-8, 2, 1, 100);
 615
 616   var c = SIMD.int32x4.shiftRightArithmetic(n, 2);
 617   assertEquals(-2, c.x);
 618   assertEquals(0, c.y);
 619   assertEquals(0, c.z);
 620   assertEquals(25, c.w);
 621 }
 622
 623 testSIMDShift();
 624 testSIMDShift();
 625 %OptimizeFunctionOnNextCall(testSIMDShift);
 626 testSIMDShift();
 627
 628 function testInt32x4ArrayBasic() {
 629   var a = new Int32x4Array(1);
 630   assertEquals(1, a.length);
 631   assertEquals(16, a.byteLength);
 632   assertEquals(16, a.BYTES_PER_ELEMENT);
 633   assertEquals(16, Int32x4Array.BYTES_PER_ELEMENT);
 634   assertEquals(0, a.byteOffset);
 635   assertTrue(undefined != a.buffer);
 636   var b = new Int32x4Array(4);
 637   assertEquals(4, b.length);
 638   assertEquals(64, b.byteLength);
 639   assertEquals(16, b.BYTES_PER_ELEMENT);
 640   assertEquals(16, Int32x4Array.BYTES_PER_ELEMENT);
 641   assertEquals(0, b.byteOffset);
 642   assertTrue(undefined != b.buffer);
 643 }
 644
 645 testInt32x4ArrayBasic();
 646
 647 function testInt32x4ArrayGetAndSet() {
 648   var a = new Int32x4Array(4);
 649   a[0] = SIMD.int32x4(1, 2, 3, 4);
 650   a[1] = SIMD.int32x4(5, 6, 7, 8);
 651   a[2] = SIMD.int32x4(9, 10, 11, 12);
 652   a[3] = SIMD.int32x4(13, 14, 15, 16);
 653   assertEquals(a[0].x, 1);
 654   assertEquals(a[0].y, 2);
 655   assertEquals(a[0].z, 3);
 656   assertEquals(a[0].w, 4);
 657
 658   assertEquals(a[1].x, 5);
 659   assertEquals(a[1].y, 6);
 660   assertEquals(a[1].z, 7);
 661   assertEquals(a[1].w, 8);
 662
 663   assertEquals(a[2].x, 9);
 664   assertEquals(a[2].y, 10);
 665   assertEquals(a[2].z, 11);
 666   assertEquals(a[2].w, 12);
 667
 668   assertEquals(a[3].x, 13);
 669   assertEquals(a[3].y, 14);
 670   assertEquals(a[3].z, 15);
 671   assertEquals(a[3].w, 16);
 672
 673   var b = new Int32x4Array(4);
 674   b.setAt(0,SIMD.int32x4(1, 2, 3, 4));
 675   b.setAt(1,SIMD.int32x4(5, 6, 7, 8));
 676   b.setAt(2,SIMD.int32x4(9, 10, 11, 12));
 677   b.setAt(3,SIMD.int32x4(13, 14, 15, 16));
 678
 679   assertEquals(b.getAt(0).x, 1);
 680   assertEquals(b.getAt(0).y, 2);
 681   assertEquals(b.getAt(0).z, 3);
 682   assertEquals(b.getAt(0).w, 4);
 683
 684   assertEquals(b.getAt(1).x, 5);
 685   assertEquals(b.getAt(1).y, 6);
 686   assertEquals(b.getAt(1).z, 7);
 687   assertEquals(b.getAt(1).w, 8);
 688
 689   assertEquals(b.getAt(2).x, 9);
 690   assertEquals(b.getAt(2).y, 10);
 691   assertEquals(b.getAt(2).z, 11);
 692   assertEquals(b.getAt(2).w, 12);
 693
 694   assertEquals(b.getAt(3).x, 13);
 695   assertEquals(b.getAt(3).y, 14);
 696   assertEquals(b.getAt(3).z, 15);
 697   assertEquals(b.getAt(3).w, 16);
 698 }
 699
 700 testInt32x4ArrayGetAndSet();
 701
 702 function testInt32x4ArraySwap() {
 703   var a = new Int32x4Array(4);
 704   a[0] = SIMD.int32x4(1, 2, 3, 4);
 705   a[1] = SIMD.int32x4(5, 6, 7, 8);
 706   a[2] = SIMD.int32x4(9, 10, 11, 12);
 707   a[3] = SIMD.int32x4(13, 14, 15, 16);
 708
 709   // Swap element 0 and element 3
 710   var t = a[0];
 711   a[0] = a[3];
 712   a[3] = t;
 713
 714   assertEquals(a[3].x, 1);
 715   assertEquals(a[3].y, 2);
 716   assertEquals(a[3].z, 3);
 717   assertEquals(a[3].w, 4);
 718
 719   assertEquals(a[1].x, 5);
 720   assertEquals(a[1].y, 6);
 721   assertEquals(a[1].z, 7);
 722   assertEquals(a[1].w, 8);
 723
 724   assertEquals(a[2].x, 9);
 725   assertEquals(a[2].y, 10);
 726   assertEquals(a[2].z, 11);
 727   assertEquals(a[2].w, 12);
 728
 729   assertEquals(a[0].x, 13);
 730   assertEquals(a[0].y, 14);
 731   assertEquals(a[0].z, 15);
 732   assertEquals(a[0].w, 16);
 733 }
 734
 735 testInt32x4ArraySwap();
 736 testInt32x4ArraySwap();
 737 %OptimizeFunctionOnNextCall(testInt32x4ArraySwap);
 738 testInt32x4ArraySwap();
 739
 740 function testInt32x4ArrayCopy() {
 741   var a = new Int32x4Array(4);
 742   a[0] = SIMD.int32x4(1, 2, 3, 4);
 743   a[1] = SIMD.int32x4(5, 6, 7, 8);
 744   a[2] = SIMD.int32x4(9, 10, 11, 12);
 745   a[3] = SIMD.int32x4(13, 14, 15, 16);
 746   var b = new Int32x4Array(a);
 747   assertEquals(a[0].x, b[0].x);
 748   assertEquals(a[0].y, b[0].y);
 749   assertEquals(a[0].z, b[0].z);
 750   assertEquals(a[0].w, b[0].w);
 751
 752   assertEquals(a[1].x, b[1].x);
 753   assertEquals(a[1].y, b[1].y);
 754   assertEquals(a[1].z, b[1].z);
 755   assertEquals(a[1].w, b[1].w);
 756
 757   assertEquals(a[2].x, b[2].x);
 758   assertEquals(a[2].y, b[2].y);
 759   assertEquals(a[2].z, b[2].z);
 760   assertEquals(a[2].w, b[2].w);
 761
 762   assertEquals(a[3].x, b[3].x);
 763   assertEquals(a[3].y, b[3].y);
 764   assertEquals(a[3].z, b[3].z);
 765   assertEquals(a[3].w, b[3].w);
 766
 767   a[2] = SIMD.int32x4(17, 18, 19, 20);
 768
 769   assertEquals(a[2].x, 17);
 770   assertEquals(a[2].y, 18);
 771   assertEquals(a[2].z, 19);
 772   assertEquals(a[2].w, 20);
 773
 774   assertTrue(a[2].x != b[2].x);
 775   assertTrue(a[2].y != b[2].y);
 776   assertTrue(a[2].z != b[2].z);
 777   assertTrue(a[2].w != b[2].w);
 778 }
 779
 780 testInt32x4ArrayCopy();
 781
 782 function testInt32x4ArrayViewBasic() {
 783   var a = new Uint32Array(8);
 784   // view with no offset.
 785   var b = new Int32x4Array(a.buffer, 0);
 786   // view with offset.
 787   var c = new Int32x4Array(a.buffer, 16);
 788   // view with no offset but shorter than original list.
 789   var d = new Int32x4Array(a.buffer, 0, 1);
 790   assertEquals(a.length, 8);
 791   assertEquals(b.length, 2);
 792   assertEquals(c.length, 1);
 793   assertEquals(d.length, 1);
 794   assertEquals(a.byteLength, 32);
 795   assertEquals(b.byteLength, 32);
 796   assertEquals(c.byteLength, 16);
 797   assertEquals(d.byteLength, 16)
 798   assertEquals(a.byteOffset, 0);
 799   assertEquals(b.byteOffset, 0);
 800   assertEquals(c.byteOffset, 16);
 801   assertEquals(d.byteOffset, 0);
 802 }
 803
 804 testInt32x4ArrayViewBasic();
 805
 806 function testInt32x4ArrayViewValues() {
 807   var a = new Uint32Array(8);
 808   var b = new Int32x4Array(a.buffer, 0);
 809   var c = new Int32x4Array(a.buffer, 16);
 810   var d = new Int32x4Array(a.buffer, 0, 1);
 811   var start = 100;
 812   for (var i = 0; i < b.length; i++) {
 813     assertEquals(0, b[i].x);
 814     assertEquals(0, b[i].y);
 815     assertEquals(0, b[i].z);
 816     assertEquals(0, b[i].w);
 817   }
 818   for (var i = 0; i < c.length; i++) {
 819     assertEquals(0, c[i].x);
 820     assertEquals(0, c[i].y);
 821     assertEquals(0, c[i].z);
 822     assertEquals(0, c[i].w);
 823   }
 824   for (var i = 0; i < d.length; i++) {
 825     assertEquals(0, d[i].x);
 826     assertEquals(0, d[i].y);
 827     assertEquals(0, d[i].z);
 828     assertEquals(0, d[i].w);
 829   }
 830   for (var i = 0; i < a.length; i++) {
 831     a[i] = i+start;
 832   }
 833   for (var i = 0; i < b.length; i++) {
 834     assertTrue(0 != b[i].x);
 835     assertTrue(0 != b[i].y);
 836     assertTrue(0 != b[i].z);
 837     assertTrue(0 != b[i].w);
 838   }
 839   for (var i = 0; i < c.length; i++) {
 840     assertTrue(0 != c[i].x);
 841     assertTrue(0 != c[i].y);
 842     assertTrue(0 != c[i].z);
 843     assertTrue(0 != c[i].w);
 844   }
 845   for (var i = 0; i < d.length; i++) {
 846     assertTrue(0 != d[i].x);
 847     assertTrue(0 != d[i].y);
 848     assertTrue(0 != d[i].z);
 849     assertTrue(0 != d[i].w);
 850   }
 851   assertEquals(start+0, b[0].x);
 852   assertEquals(start+1, b[0].y);
 853   assertEquals(start+2, b[0].z);
 854   assertEquals(start+3, b[0].w);
 855   assertEquals(start+4, b[1].x);
 856   assertEquals(start+5, b[1].y);
 857   assertEquals(start+6, b[1].z);
 858   assertEquals(start+7, b[1].w);
 859
 860   assertEquals(start+4, c[0].x);
 861   assertEquals(start+5, c[0].y);
 862   assertEquals(start+6, c[0].z);
 863   assertEquals(start+7, c[0].w);
 864
 865   assertEquals(start+0, d[0].x);
 866   assertEquals(start+1, d[0].y);
 867   assertEquals(start+2, d[0].z);
 868   assertEquals(start+3, d[0].w);
 869 }
 870
 871 testInt32x4ArrayViewValues();
 872
 873 function testViewOnInt32x4Array() {
 874   var a = new Int32x4Array(4);
 875   a[0] = SIMD.int32x4(1, 2, 3, 4);
 876   a[1] = SIMD.int32x4(5, 6, 7, 8);
 877   a[2] = SIMD.int32x4(9, 10, 11, 12);
 878   a[3] = SIMD.int32x4(13, 14, 15, 16);
 879   assertEquals(a[0].x, 1);
 880   assertEquals(a[0].y, 2);
 881   assertEquals(a[0].z, 3);
 882   assertEquals(a[0].w, 4);
 883
 884   assertEquals(a[1].x, 5);
 885   assertEquals(a[1].y, 6);
 886   assertEquals(a[1].z, 7);
 887   assertEquals(a[1].w, 8);
 888
 889   assertEquals(a[2].x, 9);
 890   assertEquals(a[2].y, 10);
 891   assertEquals(a[2].z, 11);
 892   assertEquals(a[2].w, 12);
 893
 894   assertEquals(a[3].x, 13);
 895   assertEquals(a[3].y, 14);
 896   assertEquals(a[3].z, 15);
 897   assertEquals(a[3].w, 16);
 898
 899   // Create view on a.
 900   var b = new Uint32Array(a.buffer);
 901   assertEquals(b.length, 16);
 902   assertEquals(b.byteLength, 64);
 903   b[2] = 99.0;
 904   b[6] = 1.0;
 905
 906   // Observe changes in "a"
 907   assertEquals(a[0].x, 1);
 908   assertEquals(a[0].y, 2);
 909   assertEquals(a[0].z, 99);
 910   assertEquals(a[0].w, 4);
 911
 912   assertEquals(a[1].x, 5);
 913   assertEquals(a[1].y, 6);
 914   assertEquals(a[1].z, 1);
 915   assertEquals(a[1].w, 8);
 916
 917   assertEquals(a[2].x, 9);
 918   assertEquals(a[2].y, 10);
 919   assertEquals(a[2].z, 11);
 920   assertEquals(a[2].w, 12);
 921
 922   assertEquals(a[3].x, 13);
 923   assertEquals(a[3].y, 14);
 924   assertEquals(a[3].z, 15);
 925   assertEquals(a[3].w, 16);
 926 }
 927
 928 testViewOnInt32x4Array();
 929
 930 function testArrayOfInt32x4() {
 931   var a = [];
 932   var a4 = new Int32x4Array(2);
 933   for (var i = 0; i < a4.length; i++) {
 934     a[i] = SIMD.int32x4(i, i + 1, i + 2, i + 3);
 935     a4[i] = SIMD.int32x4(i, i + 1, i + 2, i + 3);
 936   }
 937
 938   for (var i = 0; i < a4.length; i++) {
 939     assertEquals(a[i].x, a4[i].x);
 940     assertEquals(a[i].y, a4[i].y);
 941     assertEquals(a[i].z, a4[i].z);
 942     assertEquals(a[i].w, a4[i].w);
 943   }
 944 }
 945
 946 testArrayOfInt32x4();