SIMD.js Add the other SIMD Phase 1 types.

src/heap/heap.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 2952 matching lines @@
   ALLOCATE_MAP(instance_type, kVariableSizeSentinel, field_name)
 
     ALLOCATE_VARSIZE_MAP(FIXED_ARRAY_TYPE, fixed_cow_array)
     DCHECK(fixed_array_map() != fixed_cow_array_map());
 
     ALLOCATE_VARSIZE_MAP(FIXED_ARRAY_TYPE, scope_info)
     ALLOCATE_MAP(HEAP_NUMBER_TYPE, HeapNumber::kSize, heap_number)
     ALLOCATE_MAP(MUTABLE_HEAP_NUMBER_TYPE, HeapNumber::kSize,
                  mutable_heap_number)
     ALLOCATE_MAP(FLOAT32X4_TYPE, Float32x4::kSize, float32x4)
+    ALLOCATE_MAP(INT32X4_TYPE, Int32x4::kSize, int32x4)
+    ALLOCATE_MAP(BOOL32X4_TYPE, Bool32x4::kSize, bool32x4)
+    ALLOCATE_MAP(INT16X8_TYPE, Int16x8::kSize, int16x8)
+    ALLOCATE_MAP(BOOL16X8_TYPE, Bool16x8::kSize, bool16x8)
+    ALLOCATE_MAP(INT8X16_TYPE, Int8x16::kSize, int8x16)
+    ALLOCATE_MAP(BOOL8X16_TYPE, Bool8x16::kSize, bool8x16)
     ALLOCATE_MAP(SYMBOL_TYPE, Symbol::kSize, symbol)
     ALLOCATE_MAP(FOREIGN_TYPE, Foreign::kSize, foreign)
 
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, the_hole);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, boolean);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, uninitialized);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, arguments_marker);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, no_interceptor_result_sentinel);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, exception);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, termination_exception);
@@ skipping 120 matching lines @@
     if (!allocation.To(&result)) return allocation;
   }
 
   Map* map = mode == MUTABLE ? mutable_heap_number_map() : heap_number_map();
   HeapObject::cast(result)->set_map_no_write_barrier(map);
   HeapNumber::cast(result)->set_value(value);
   return result;
 }
 
 
-AllocationResult Heap::AllocateFloat32x4(float w, float x, float y, float z,
+AllocationResult Heap::AllocateFloat32x4(float lanes[4],

[rossberg, 2015/07/29 14:37:55]

Macrofication might help here, too.

[bbudge, 2015/07/30 13:46:58]

Definitely. Done.

                                          PretenureFlag pretenure) {
   // Statically ensure that it is safe to allocate SIMD values in paged
   // spaces.
   int size = Float32x4::kSize;
   STATIC_ASSERT(Float32x4::kSize <= Page::kMaxRegularHeapObjectSize);
 
   AllocationSpace space = SelectSpace(size, pretenure);
 
   HeapObject* result;
   {
     AllocationResult allocation =
         AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
     if (!allocation.To(&result)) return allocation;
   }
 
   result->set_map_no_write_barrier(float32x4_map());
-  Float32x4* float32x4 = Float32x4::cast(result);
-  float32x4->set_lane(0, w);
-  float32x4->set_lane(1, x);
-  float32x4->set_lane(2, y);
-  float32x4->set_lane(3, z);
+  Float32x4* instance = Float32x4::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
   return result;
 }
 
+
+AllocationResult Heap::AllocateInt32x4(int32_t lanes[4],
+                                       PretenureFlag pretenure) {
+  // Statically ensure that it is safe to allocate SIMD values in paged
+  // spaces.
+  int size = Int32x4::kSize;
+  STATIC_ASSERT(Int32x4::kSize <= Page::kMaxRegularHeapObjectSize);
+
+  AllocationSpace space = SelectSpace(size, pretenure);
+
+  HeapObject* result;
+  {
+    AllocationResult allocation =
+        AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(int32x4_map());
+  Int32x4* instance = Int32x4::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
+  return result;
+}
+
+
+AllocationResult Heap::AllocateBool32x4(bool lanes[4],
+                                        PretenureFlag pretenure) {
+  // Statically ensure that it is safe to allocate SIMD values in paged
+  // spaces.
+  int size = Bool32x4::kSize;
+  STATIC_ASSERT(Bool32x4::kSize <= Page::kMaxRegularHeapObjectSize);
+
+  AllocationSpace space = SelectSpace(size, pretenure);
+
+  HeapObject* result;
+  {
+    AllocationResult allocation =
+        AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(bool32x4_map());
+  Bool32x4* instance = Bool32x4::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
+  return result;
+}
+
+
+AllocationResult Heap::AllocateInt16x8(int16_t lanes[8],
+                                       PretenureFlag pretenure) {
+  // Statically ensure that it is safe to allocate SIMD values in paged
+  // spaces.
+  int size = Int16x8::kSize;
+  STATIC_ASSERT(Int16x8::kSize <= Page::kMaxRegularHeapObjectSize);
+
+  AllocationSpace space = SelectSpace(size, pretenure);
+
+  HeapObject* result;
+  {
+    AllocationResult allocation =
+        AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(int16x8_map());
+  Int16x8* instance = Int16x8::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
+  instance->set_lane(4, lanes[4]);
+  instance->set_lane(5, lanes[5]);
+  instance->set_lane(6, lanes[6]);
+  instance->set_lane(7, lanes[7]);
+  return result;
+}
+
+
+AllocationResult Heap::AllocateBool16x8(bool lanes[8],
+                                        PretenureFlag pretenure) {
+  // Statically ensure that it is safe to allocate SIMD values in paged
+  // spaces.
+  int size = Bool16x8::kSize;
+  STATIC_ASSERT(Bool16x8::kSize <= Page::kMaxRegularHeapObjectSize);
+
+  AllocationSpace space = SelectSpace(size, pretenure);
+
+  HeapObject* result;
+  {
+    AllocationResult allocation =
+        AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(bool16x8_map());
+  Bool16x8* instance = Bool16x8::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
+  instance->set_lane(4, lanes[4]);
+  instance->set_lane(5, lanes[5]);
+  instance->set_lane(6, lanes[6]);
+  instance->set_lane(7, lanes[7]);
+  return result;
+}
+
+
+AllocationResult Heap::AllocateInt8x16(int8_t lanes[16],
+                                       PretenureFlag pretenure) {
+  // Statically ensure that it is safe to allocate SIMD values in paged
+  // spaces.
+  int size = Int8x16::kSize;
+  STATIC_ASSERT(Int8x16::kSize <= Page::kMaxRegularHeapObjectSize);
+
+  AllocationSpace space = SelectSpace(size, pretenure);
+
+  HeapObject* result;
+  {
+    AllocationResult allocation =
+        AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(int8x16_map());
+  Int8x16* instance = Int8x16::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
+  instance->set_lane(4, lanes[4]);
+  instance->set_lane(5, lanes[5]);
+  instance->set_lane(6, lanes[6]);
+  instance->set_lane(7, lanes[7]);
+  instance->set_lane(8, lanes[8]);
+  instance->set_lane(9, lanes[9]);
+  instance->set_lane(10, lanes[10]);
+  instance->set_lane(11, lanes[11]);
+  instance->set_lane(12, lanes[12]);
+  instance->set_lane(13, lanes[13]);
+  instance->set_lane(14, lanes[14]);
+  instance->set_lane(15, lanes[15]);
+  return result;
+}
+
+
+AllocationResult Heap::AllocateBool8x16(bool lanes[16],
+                                        PretenureFlag pretenure) {
+  // Statically ensure that it is safe to allocate SIMD values in paged
+  // spaces.
+  int size = Bool8x16::kSize;
+  STATIC_ASSERT(Bool8x16::kSize <= Page::kMaxRegularHeapObjectSize);
+
+  AllocationSpace space = SelectSpace(size, pretenure);
+
+  HeapObject* result;
+  {
+    AllocationResult allocation =
+        AllocateRaw(size, space, OLD_SPACE, kSimd128Unaligned);
+    if (!allocation.To(&result)) return allocation;
+  }
+
+  result->set_map_no_write_barrier(bool8x16_map());
+  Bool8x16* instance = Bool8x16::cast(result);
+  instance->set_lane(0, lanes[0]);
+  instance->set_lane(1, lanes[1]);
+  instance->set_lane(2, lanes[2]);
+  instance->set_lane(3, lanes[3]);
+  instance->set_lane(4, lanes[4]);
+  instance->set_lane(5, lanes[5]);
+  instance->set_lane(6, lanes[6]);
+  instance->set_lane(7, lanes[7]);
+  instance->set_lane(8, lanes[8]);
+  instance->set_lane(9, lanes[9]);
+  instance->set_lane(10, lanes[10]);
+  instance->set_lane(11, lanes[11]);
+  instance->set_lane(12, lanes[12]);
+  instance->set_lane(13, lanes[13]);
+  instance->set_lane(14, lanes[14]);
+  instance->set_lane(15, lanes[15]);
+  return result;
+}
+
 
 AllocationResult Heap::AllocateCell(Object* value) {
   int size = Cell::kSize;
   STATIC_ASSERT(Cell::kSize <= Page::kMaxRegularHeapObjectSize);
 
   HeapObject* result;
   {
     AllocationResult allocation = AllocateRaw(size, OLD_SPACE, OLD_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
@@ skipping 3775 matching lines @@
     *object_type = "CODE_TYPE";                                                \
     *object_sub_type = "CODE_AGE/" #name;                                      \
     return true;
     CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
 #undef COMPARE_AND_RETURN_NAME
   }
   return false;
 }
 }  // namespace internal
 }  // namespace v8