[simd.js] Add SIMD load functions for Phase 1.

src/harmony-simd.js

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 301 matching lines @@
 function Float32x4SwizzleJS(a, c0, c1, c2, c3) {
   return %Float32x4Swizzle(a, c0, c1, c2, c3);
 }
 
 
 function Float32x4ShuffleJS(a, b, c0, c1, c2, c3) {
   return %Float32x4Shuffle(a, b, c0, c1, c2, c3);
 }
 
 
+function Float32x4LoadJS(tarray, index) {
+  return %Float32x4Load(tarray, index);
+}
+
+
+function Float32x4Load1JS(tarray, index) {
+  return %Float32x4Load1(tarray, index);
+}
+
+
+function Float32x4Load2JS(tarray, index) {
+  return %Float32x4Load2(tarray, index);
+}
+
+
+function Float32x4Load3JS(tarray, index) {
+  return %Float32x4Load3(tarray, index);
+}

[bbudge, 2015/08/20 18:23:34]

You should be able to use the V8 macro system on these to reduce duplication.
There are examples in this file, above.

[gdeepti, 2015/08/20 22:09:24]

Done.

+
+
 function Int32x4Constructor(c0, c1, c2, c3) {
   if (%_IsConstructCall()) throw MakeTypeError(kNotConstructor, "Int32x4");
   return %CreateInt32x4(TO_NUMBER_INLINE(c0), TO_NUMBER_INLINE(c1),
                         TO_NUMBER_INLINE(c2), TO_NUMBER_INLINE(c3));
 }
 
 
 function Int32x4Splat(s) {
   return %CreateInt32x4(s, s, s, s);
 }
 
 
 function Int32x4SwizzleJS(a, c0, c1, c2, c3) {
   return %Int32x4Swizzle(a, c0, c1, c2, c3);
 }
 
 
 function Int32x4ShuffleJS(a, b, c0, c1, c2, c3) {
   return %Int32x4Shuffle(a, b, c0, c1, c2, c3);
 }
 
 
+function Int32x4LoadJS(tarray, index) {
+  return %Int32x4Load(tarray, index);
+}
+
+
+function Int32x4Load1JS(tarray, index) {
+  return %Int32x4Load1(tarray, index);
+}
+
+
+function Int32x4Load2JS(tarray, index) {
+  return %Int32x4Load2(tarray, index);
+}
+
+
+function Int32x4Load3JS(tarray, index) {
+  return %Int32x4Load3(tarray, index);
+}
+
+
 function Bool32x4Constructor(c0, c1, c2, c3) {
   if (%_IsConstructCall()) throw MakeTypeError(kNotConstructor, "Bool32x4");
   return %CreateBool32x4(c0, c1, c2, c3);
 }
 
 
 function Bool32x4Splat(s) {
   return %CreateBool32x4(s, s, s, s);
 }
 
@@ skipping 24 matching lines @@
 function Int16x8SwizzleJS(a, c0, c1, c2, c3, c4, c5, c6, c7) {
   return %Int16x8Swizzle(a, c0, c1, c2, c3, c4, c5, c6, c7);
 }
 
 
 function Int16x8ShuffleJS(a, b, c0, c1, c2, c3, c4, c5, c6, c7) {
   return %Int16x8Shuffle(a, b, c0, c1, c2, c3, c4, c5, c6, c7);
 }
 
 
+function Int16x8LoadJS(tarray, index) {
+  return %Int16x8Load(tarray, index);
+}
+
+
+function Int16x8Load1JS(tarray, index) {
+  return %Int16x8Load1(tarray, index);
+}
+
+
+function Int16x8Load2JS(tarray, index) {
+  return %Int16x8Load2(tarray, index);
+}
+
+
+function Int16x8Load3JS(tarray, index) {
+  return %Int16x8Load3(tarray, index);
+}
+
+
 function Bool16x8Constructor(c0, c1, c2, c3, c4, c5, c6, c7) {
   if (%_IsConstructCall()) throw MakeTypeError(kNotConstructor, "Bool16x8");
   return %CreateBool16x8(c0, c1, c2, c3, c4, c5, c6, c7);
 }
 
 
 function Bool16x8Splat(s) {
   return %CreateBool16x8(s, s, s, s, s, s, s, s);
 }
 
@@ skipping 34 matching lines @@
 }
 
 
 function Int8x16ShuffleJS(a, b, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10,
                           c11, c12, c13, c14, c15) {
   return %Int8x16Shuffle(a, b, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10,
                          c11, c12, c13, c14, c15);
 }
 
 
+function Int8x16LoadJS(tarray, index) {
+  return %Int8x16Load(tarray, index);
+}
+
+
+function Int8x16Load1JS(tarray, index) {
+  return %Int8x16Load1(tarray, index);
+}
+
+
+function Int8x16Load2JS(tarray, index) {
+  return %Int8x16Load2(tarray, index);
+}
+
+
+function Int8x16Load3JS(tarray, index) {
+  return %Int8x16Load3(tarray, index);
+}
+
+
 function Bool8x16Constructor(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11,
                              c12, c13, c14, c15) {
   if (%_IsConstructCall()) throw MakeTypeError(kNotConstructor, "Bool8x16");
   return %CreateBool8x16(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12,
                          c13, c14, c15);
 }
 
 
 function Bool8x16Splat(s) {
   return %CreateBool8x16(s, s, s, s, s, s, s, s, s, s, s, s, s, s, s, s);
@@ skipping 58 matching lines @@
   'greaterThanOrEqual', Float32x4GreaterThanOrEqualJS,
   'equal', Float32x4EqualJS,
   'notEqual', Float32x4NotEqualJS,
   'select', Float32x4SelectJS,
   'swizzle', Float32x4SwizzleJS,
   'shuffle', Float32x4ShuffleJS,
   'fromInt32x4', Float32x4FromInt32x4JS,
   'fromInt32x4Bits', Float32x4FromInt32x4BitsJS,
   'fromInt16x8Bits', Float32x4FromInt16x8BitsJS,
   'fromInt8x16Bits', Float32x4FromInt8x16BitsJS,
+  'load', Float32x4LoadJS,
+  'load1', Float32x4Load1JS,
+  'load2', Float32x4Load2JS,
+  'load3', Float32x4Load3JS,
 ]);
 
 utils.InstallFunctions(GlobalInt32x4, DONT_ENUM, [
   'splat', Int32x4Splat,
   'check', Int32x4CheckJS,
   'extractLane', Int32x4ExtractLaneJS,
   'replaceLane', Int32x4ReplaceLaneJS,
   'neg', Int32x4NegJS,
   'add', Int32x4AddJS,
   'sub', Int32x4SubJS,
@@ skipping 13 matching lines @@
   'greaterThanOrEqual', Int32x4GreaterThanOrEqualJS,
   'equal', Int32x4EqualJS,
   'notEqual', Int32x4NotEqualJS,
   'select', Int32x4SelectJS,
   'swizzle', Int32x4SwizzleJS,
   'shuffle', Int32x4ShuffleJS,
   'fromFloat32x4', Int32x4FromFloat32x4JS,
   'fromFloat32x4Bits', Int32x4FromFloat32x4BitsJS,
   'fromInt16x8Bits', Int32x4FromInt16x8BitsJS,
   'fromInt8x16Bits', Int32x4FromInt8x16BitsJS,
+  'load', Int32x4LoadJS,
+  'load1', Int32x4Load1JS,
+  'load2', Int32x4Load2JS,
+  'load3', Int32x4Load3JS,
 ]);
 
 utils.InstallFunctions(GlobalBool32x4, DONT_ENUM, [
   'splat', Bool32x4Splat,
   'check', Bool32x4CheckJS,
   'extractLane', Bool32x4ExtractLaneJS,
   'replaceLane', Bool32x4ReplaceLaneJS,
   'and', Bool32x4AndJS,
   'or', Bool32x4OrJS,
   'xor', Bool32x4XorJS,
@@ skipping 30 matching lines @@
   'greaterThan', Int16x8GreaterThanJS,
   'greaterThanOrEqual', Int16x8GreaterThanOrEqualJS,
   'equal', Int16x8EqualJS,
   'notEqual', Int16x8NotEqualJS,
   'select', Int16x8SelectJS,
   'swizzle', Int16x8SwizzleJS,
   'shuffle', Int16x8ShuffleJS,
   'fromFloat32x4Bits', Int16x8FromFloat32x4BitsJS,
   'fromInt32x4Bits', Int16x8FromInt32x4BitsJS,
   'fromInt8x16Bits', Int16x8FromInt8x16BitsJS,
+  'load', Int16x8LoadJS,
+  'load1', Int16x8Load1JS,
+  'load2', Int16x8Load2JS,
+  'load3', Int16x8Load3JS,
 ]);
 
 utils.InstallFunctions(GlobalBool16x8, DONT_ENUM, [
   'splat', Bool16x8Splat,
   'check', Bool16x8CheckJS,
   'extractLane', Bool16x8ExtractLaneJS,
   'replaceLane', Bool16x8ReplaceLaneJS,
   'and', Bool16x8AndJS,
   'or', Bool16x8OrJS,
   'xor', Bool16x8XorJS,
@@ skipping 30 matching lines @@
   'greaterThan', Int8x16GreaterThanJS,
   'greaterThanOrEqual', Int8x16GreaterThanOrEqualJS,
   'equal', Int8x16EqualJS,
   'notEqual', Int8x16NotEqualJS,
   'select', Int8x16SelectJS,
   'swizzle', Int8x16SwizzleJS,
   'shuffle', Int8x16ShuffleJS,
   'fromFloat32x4Bits', Int8x16FromFloat32x4BitsJS,
   'fromInt32x4Bits', Int8x16FromInt32x4BitsJS,
   'fromInt16x8Bits', Int8x16FromInt16x8BitsJS,
+  'load', Int8x16LoadJS,
+  'load1', Int8x16Load1JS,
+  'load2', Int8x16Load2JS,
+  'load3', Int8x16Load3JS,
 ]);
 
 utils.InstallFunctions(GlobalBool8x16, DONT_ENUM, [
   'splat', Bool8x16Splat,
   'check', Bool8x16CheckJS,
   'extractLane', Bool8x16ExtractLaneJS,
   'replaceLane', Bool8x16ReplaceLaneJS,
   'and', Bool8x16AndJS,
   'or', Bool8x16OrJS,
   'xor', Bool8x16XorJS,
@@ skipping 10 matching lines @@
   to.Float32x4ToString = Float32x4ToString;
   to.Int32x4ToString = Int32x4ToString;
   to.Bool32x4ToString = Bool32x4ToString;
   to.Int16x8ToString = Int16x8ToString;
   to.Bool16x8ToString = Bool16x8ToString;
   to.Int8x16ToString = Int8x16ToString;
   to.Bool8x16ToString = Bool8x16ToString;
 });
 
 })