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