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