[simd] Introduce SIMD types (as classes)

test/cctest/types-fuzz.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 21 matching lines @@
 #include "src/v8.h"
 
 namespace v8 {
 namespace internal {
 
 
 template<class Type, class TypeHandle, class Region>
 class Types {
  public:
   Types(Region* region, Isolate* isolate, v8::base::RandomNumberGenerator* rng)
-      : region_(region), rng_(rng) {
+      : region_(region), isolate_(isolate), rng_(rng) {
     #define DECLARE_TYPE(name, value) \
       name = Type::name(region);      \
       types.push_back(name);
     PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
     #undef DECLARE_TYPE
 
     SignedSmall = Type::SignedSmall(region);
     UnsignedSmall = Type::UnsignedSmall(region);
 
     object_map = isolate->factory()->NewMap(
@@ skipping 244 matching lines @@
         TypeHandle result = Fuzz(depth / 2);
         TypeHandle receiver = Fuzz(depth / 2);
         int arity = rng_->NextInt(3);
         TypeHandle type = Type::Function(result, receiver, arity, region_);
         for (int i = 0; i < type->AsFunction()->Arity(); ++i) {
           TypeHandle parameter = Fuzz(depth / 2);
           type->AsFunction()->InitParameter(i, parameter);
         }
         return type;
       }
+      case 8: {  // simd
+        static const int num_simd_types =
+            #define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) +1
+            SIMD128_TYPES(COUNT_SIMD_TYPE)
+            #undef COUNT_SIMD_TYPE
+            ;
+        TypeHandle (*simd_constructors[num_simd_types])(Isolate*, Region*) = {
+          #define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
+          &Type::Name,
+          SIMD128_TYPES(COUNT_SIMD_TYPE)
+          #undef COUNT_SIMD_TYPE
+        };
+        return simd_constructors[rng_->NextInt(num_simd_types)](
+            isolate_, region_);
+      }
       default: {  // union
         int n = rng_->NextInt(10);
         TypeHandle type = None;
         for (int i = 0; i < n; ++i) {
           TypeHandle operand = Fuzz(depth - 1);
           type = Type::Union(type, operand, region_);
         }
         return type;
       }
     }
     UNREACHABLE();
   }
 
   Region* region() { return region_; }
 
  private:
   Region* region_;
+  Isolate* isolate_;
   v8::base::RandomNumberGenerator* rng_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif