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

src/runtime/runtime-simd.cc

 // 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.
 
 #include "src/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/base/macros.h"
 #include "src/conversions.h"
 #include "src/factory.h"
@@ skipping 570 matching lines @@
     return *result;                                           \
   }
 
 #define SIMD_MAX_FUNCTION(type, lane_type, lane_count)        \
   RUNTIME_FUNCTION(Runtime_##type##Max) {                     \
     HandleScope scope(isolate);                               \
     SIMD_BINARY_OP(type, lane_type, lane_count, Max, result); \
     return *result;                                           \
   }
 
+
 SIMD_NUMERIC_TYPES(SIMD_NEG_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_ADD_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_SUB_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_MUL_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_MIN_FUNCTION)
 SIMD_NUMERIC_TYPES(SIMD_MAX_FUNCTION)
 
 //-------------------------------------------------------------------
 
 // Relational functions.
@@ skipping 209 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(Runtime_Int8x16UnsignedExtractLane) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(Int8x16, a, 0);
   CONVERT_SIMD_LANE_ARG_CHECKED(lane, 1, 16);
   return *isolate->factory()->NewNumber(bit_cast<uint8_t>(a->get_lane(lane)));
 }
+
+
+//-------------------------------------------------------------------
+
+// Load functions.
+#define SIMD_MEMORY_OP_TYPES(FUNCTION) \
+  FUNCTION(Float32x4, float, 4)        \
+  FUNCTION(Int32x4, int32_t, 4)        \
+  FUNCTION(Int16x8, int16_t, 8)        \
+  FUNCTION(Int8x16, int8_t, 16)

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

You'll have to partition these, since only the 4-lane types have LoadN / StoreN.

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

Done.

+
+
+// Common Load Functions
+#define SIMD_LOAD(type, lane_type, lane_count, count, result)             \
+  static const int kLaneCount = lane_count;                               \
+  lane_type lanes[kLaneCount] = {0};                                      \
+  Handle<type> result;                                                    \
+  DCHECK(args.length() == 2);                                             \
+  CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, tarray_obj, 0);                \
+  CONVERT_INT32_ARG_CHECKED(index, 1)                                     \
+  Handle<JSTypedArray> tarray(JSTypedArray::cast(*tarray_obj));           \
+  size_t bpe = tarray->element_size();                                    \
+  uint32_t bytes = count * sizeof(lane_type);                             \
+  size_t byte_length = NumberToSize(isolate, tarray->byte_length());      \
+                                                                          \
+  if (index < 0 || (index * bpe + bytes) > byte_length) {                 \
+    THROW_NEW_ERROR_RETURN_FAILURE(                                       \
+        isolate, NewTypeError(MessageTemplate::kInvalidTypedArrayIndex)); \
+  }                                                                       \
+  size_t tarray_offset = NumberToSize(isolate, tarray->byte_offset());    \
+  uint8_t* tarray_base =                                                  \
+      static_cast<uint8_t*>(tarray->GetBuffer()->backing_store()) +       \
+      tarray_offset;                                                      \
+  memcpy(lanes, tarray_base + (index)*bpe, bytes);                        \
+  result = isolate->factory()->New##type(lanes);
+
+
+#define SIMD_LOAD_FUNCTION(type, lane_type, lane_count)         \
+  RUNTIME_FUNCTION(Runtime_##type##Load) {                      \
+    HandleScope scope(isolate);                                 \
+    SIMD_LOAD(type, lane_type, lane_count, lane_count, result); \
+    return *result;                                             \
+  }
+
+
+#define SIMD_LOAD1_FUNCTION(type, lane_type, lane_count) \
+  RUNTIME_FUNCTION(Runtime_##type##Load1) {              \
+    HandleScope scope(isolate);                          \
+    SIMD_LOAD(type, lane_type, lane_count, 1, result);   \
+    return *result;                                      \
+  }
+
+
+#define SIMD_LOAD2_FUNCTION(type, lane_type, lane_count) \
+  RUNTIME_FUNCTION(Runtime_##type##Load2) {              \
+    HandleScope scope(isolate);                          \
+    SIMD_LOAD(type, lane_type, lane_count, 2, result);   \
+    return *result;                                      \
+  }
+
+
+#define SIMD_LOAD3_FUNCTION(type, lane_type, lane_count) \
+  RUNTIME_FUNCTION(Runtime_##type##Load3) {              \
+    HandleScope scope(isolate);                          \
+    SIMD_LOAD(type, lane_type, lane_count, 3, result);   \
+    return *result;                                      \
+  }
+
+
+SIMD_MEMORY_OP_TYPES(SIMD_LOAD_FUNCTION)
+SIMD_MEMORY_OP_TYPES(SIMD_LOAD1_FUNCTION)
+SIMD_MEMORY_OP_TYPES(SIMD_LOAD2_FUNCTION)
+SIMD_MEMORY_OP_TYPES(SIMD_LOAD3_FUNCTION)
+
+//-------------------------------------------------------------------
+
 }  // namespace internal
 }  // namespace v8