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

   1 // Copyright 2014 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 testFloat32x4LoadAndStore() {
  31   var f32_array = new Float32Array(12);
  32   for (var i = 0; i < 12; ++i)
  33     f32_array[i] = 1.0 + i;
  34
  35   var v1 = SIMD.float32x4.load(f32_array, 0);
  36   var v2 = SIMD.float32x4.load(f32_array, 4);
  37   var v3 = SIMD.float32x4.load(f32_array, 8);
  38
  39   assertEquals(1.0, v1.x);
  40   assertEquals(2.0, v1.y);
  41   assertEquals(3.0, v1.z);
  42   assertEquals(4.0, v1.w);
  43
  44   assertEquals(5.0, v2.x);
  45   assertEquals(6.0, v2.y);
  46   assertEquals(7.0, v2.z);
  47   assertEquals(8.0, v2.w);
  48
  49   assertEquals(9.0, v3.x);
  50   assertEquals(10.0, v3.y);
  51   assertEquals(11.0, v3.z);
  52   assertEquals(12.0, v3.w);
  53
  54   SIMD.float32x4.store(f32_array, 0, SIMD.float32x4(12.0, 11.0, 10.0, 9.0));
  55   SIMD.float32x4.store(f32_array, 4, SIMD.float32x4(8.0, 7.0, 6.0, 5.0));
  56   SIMD.float32x4.store(f32_array, 8, SIMD.float32x4(4.0, 3.0, 2.0, 1.0));
  57
  58   for (var i = 0; i < 12; ++i)
  59     assertEquals(12.0 - i, f32_array[i]);
  60 }
  61
  62 testFloat32x4LoadAndStore();
  63 testFloat32x4LoadAndStore();
  64 %OptimizeFunctionOnNextCall(testFloat32x4LoadAndStore);
  65 testFloat32x4LoadAndStore();
  66
  67 function testFloat32x4LoadXAndStoreX() {
  68   var f32_array = new Float32Array(12);
  69   for (var i = 0; i < 12; ++i)
  70     f32_array[i] = 1.0 + i;
  71
  72   for (var i = 0; i < 12; ++i) {
  73     var v = SIMD.float32x4.loadX(f32_array, i);
  74
  75     assertEquals(1.0 + i, v.x);
  76     assertEquals(0.0, v.y);
  77     assertEquals(0.0, v.z);
  78     assertEquals(0.0, v.w);
  79   }
  80
  81   for (var i = 0; i < 12; ++i) {
  82     SIMD.float32x4.storeX(f32_array, i, SIMD.float32x4(12.0 - i, 0.0, 0.0, 0.0));
  83   }
  84
  85   for (var i = 0; i < 12; ++i)
  86     assertEquals(12.0 - i, f32_array[i]);
  87 }
  88
  89 testFloat32x4LoadXAndStoreX();
  90 testFloat32x4LoadXAndStoreX();
  91 %OptimizeFunctionOnNextCall(testFloat32x4LoadXAndStoreX);
  92 testFloat32x4LoadXAndStoreX();
  93
  94 function testFloat32x4LoadXYAndStoreXY() {
  95   var f32_array = new Float32Array(12);
  96   for (var i = 0; i < 12; ++i)
  97     f32_array[i] = 1.0 + i;
  98
  99   for (var i = 0; i < 12; i += 2) {
 100     var v = SIMD.float32x4.loadXY(f32_array, i);
 101
 102     assertEquals(1.0 + i, v.x);
 103     assertEquals(2.0 + i, v.y);
 104     assertEquals(0.0, v.z);
 105     assertEquals(0.0, v.w);
 106   }
 107
 108   for (var i = 0; i < 12; i += 2) {
 109     SIMD.float32x4.storeXY(f32_array, i, SIMD.float32x4(12.0 - i, 11.0 - i, 0.0, 0.0));
 110   }
 111
 112   for (var i = 0; i < 12; ++i)
 113     assertEquals(12.0 - i, f32_array[i]);
 114 }
 115
 116 testFloat32x4LoadXYAndStoreXY();
 117 testFloat32x4LoadXYAndStoreXY();
 118 %OptimizeFunctionOnNextCall(testFloat32x4LoadXYAndStoreXY);
 119 testFloat32x4LoadXYAndStoreXY();
 120
 121 function testFloat32x4LoadXYZAndStoreXYZ() {
 122   var f32_array = new Float32Array(12);
 123   for (var i = 0; i < 12; ++i)
 124     f32_array[i] = 1.0 + i;
 125
 126   for (var i = 0; i < 12; i += 3) {
 127     var v = SIMD.float32x4.loadXYZ(f32_array, i);
 128
 129     assertEquals(1.0 + i, v.x);
 130     assertEquals(2.0 + i, v.y);
 131     assertEquals(3.0 + i, v.z);
 132     assertEquals(0.0, v.w);
 133   }
 134
 135   for (var i = 0; i < 12; i += 3) {
 136     SIMD.float32x4.storeXYZ(f32_array, i, SIMD.float32x4(12.0 - i, 11.0 - i, 10.0 - i, 0.0));
 137   }
 138
 139   for (var i = 0; i < 12; ++i)
 140     assertEquals(12.0 - i, f32_array[i]);
 141 }
 142
 143 testFloat32x4LoadXYZAndStoreXYZ();
 144 testFloat32x4LoadXYZAndStoreXYZ();
 145 %OptimizeFunctionOnNextCall(testFloat32x4LoadXYZAndStoreXYZ);
 146 testFloat32x4LoadXYZAndStoreXYZ();
 147
 148 function testFloat32x4LoadAndStoreFromInt8Array() {
 149   var f32_array = new Float32Array(12);
 150   for (var i = 0; i < 12; ++i)
 151     f32_array[i] = 1.0 + i;
 152
 153   var i8_array = new Int8Array(f32_array.buffer);
 154
 155   var v1 = SIMD.float32x4.load(i8_array, 0);
 156   var v2 = SIMD.float32x4.load(i8_array, 16);
 157   var v3 = SIMD.float32x4.load(i8_array, 32);
 158
 159   assertEquals(1.0, v1.x);
 160   assertEquals(2.0, v1.y);
 161   assertEquals(3.0, v1.z);
 162   assertEquals(4.0, v1.w);
 163
 164   assertEquals(5.0, v2.x);
 165   assertEquals(6.0, v2.y);
 166   assertEquals(7.0, v2.z);
 167   assertEquals(8.0, v2.w);
 168
 169   assertEquals(9.0, v3.x);
 170   assertEquals(10.0, v3.y);
 171   assertEquals(11.0, v3.z);
 172   assertEquals(12.0, v3.w);
 173
 174   SIMD.float32x4.store(i8_array, 0, SIMD.float32x4(12.0, 11.0, 10.0, 9.0));
 175   SIMD.float32x4.store(i8_array, 16, SIMD.float32x4(8.0, 7.0, 6.0, 5.0));
 176   SIMD.float32x4.store(i8_array, 32, SIMD.float32x4(4.0, 3.0, 2.0, 1.0));
 177
 178   for (var i = 0; i < 12; ++i)
 179     assertEquals(12.0 - i, f32_array[i]);
 180 }
 181
 182 testFloat32x4LoadAndStoreFromInt8Array();
 183 testFloat32x4LoadAndStoreFromInt8Array();
 184 %OptimizeFunctionOnNextCall(testFloat32x4LoadAndStoreFromInt8Array);
 185 testFloat32x4LoadAndStoreFromInt8Array();
 186
 187 function testFloat64x2LoadAndStore() {
 188   var f64_array = new Float64Array(6);
 189   for (var i = 0; i < 6; ++i)
 190     f64_array[i] = 1.0 + i;
 191
 192   var v1 = SIMD.float64x2.load(f64_array, 0);
 193   var v2 = SIMD.float64x2.load(f64_array, 2);
 194   var v3 = SIMD.float64x2.load(f64_array, 4);
 195
 196   assertEquals(1.0, v1.x);
 197   assertEquals(2.0, v1.y);
 198
 199   assertEquals(3.0, v2.x);
 200   assertEquals(4.0, v2.y);
 201
 202   assertEquals(5.0, v3.x);
 203   assertEquals(6.0, v3.y);
 204
 205   SIMD.float64x2.store(f64_array, 0, SIMD.float64x2(6.0, 5.0));
 206   SIMD.float64x2.store(f64_array, 2, SIMD.float64x2(4.0, 3.0));
 207   SIMD.float64x2.store(f64_array, 4, SIMD.float64x2(2.0, 1.0));
 208
 209   for (var i = 0; i < 6; ++i)
 210     assertEquals(6.0 - i, f64_array[i]);
 211 }
 212
 213 testFloat64x2LoadAndStore();
 214 testFloat64x2LoadAndStore();
 215 %OptimizeFunctionOnNextCall(testFloat64x2LoadAndStore);
 216 testFloat64x2LoadAndStore();
 217
 218 function testInt32x4LoadAndStore() {
 219   var i32_array = new Int32Array(12);
 220     for (var i = 0; i < 12; ++i)
 221     i32_array[i] = 1 + i;
 222
 223   var v1 = SIMD.int32x4.load(i32_array, 0);
 224   var v2 = SIMD.int32x4.load(i32_array, 4);
 225   var v3 = SIMD.int32x4.load(i32_array, 8);
 226
 227   assertEquals(1, v1.x);
 228   assertEquals(2, v1.y);
 229   assertEquals(3, v1.z);
 230   assertEquals(4, v1.w);
 231
 232   assertEquals(5, v2.x);
 233   assertEquals(6, v2.y);
 234   assertEquals(7, v2.z);
 235   assertEquals(8, v2.w);
 236
 237   assertEquals(9, v3.x);
 238   assertEquals(10, v3.y);
 239   assertEquals(11, v3.z);
 240   assertEquals(12, v3.w);
 241
 242   SIMD.int32x4.store(i32_array, 0, SIMD.int32x4(12, 11, 10, 9));
 243   SIMD.int32x4.store(i32_array, 4, SIMD.int32x4(8, 7, 6, 5));
 244   SIMD.int32x4.store(i32_array, 8, SIMD.int32x4(4, 3, 2, 1));
 245
 246   for (var i = 0; i < 12; ++i)
 247     assertEquals(12.0 - i, i32_array[i]);
 248 }
 249
 250 testInt32x4LoadAndStore();
 251 testInt32x4LoadAndStore();
 252 %OptimizeFunctionOnNextCall(testInt32x4LoadAndStore);
 253 testInt32x4LoadAndStore();