[simd.js] Single SIMD128_VALUE_TYPE for all Simd128Values.

src/code-stubs-hydrogen.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/bailout-reason.h"
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
@@ skipping 381 matching lines @@
                 Add<HConstant>(JS_FUNCTION_PROXY_TYPE);
             is_function.If<HCompareNumericAndBranch>(instance_type, js_function,
                                                      Token::EQ);
             is_function.OrIf<HCompareNumericAndBranch>(
                 instance_type, js_function_proxy, Token::EQ);
             is_function.Then();
             { Push(Add<HConstant>(factory->function_string())); }
             is_function.Else();
             {
               IfBuilder is_float32x4(this);
-              is_float32x4.If<HCompareNumericAndBranch>(
-                  instance_type, Add<HConstant>(FLOAT32X4_TYPE), Token::EQ);
+              is_float32x4.If<HCompareObjectEqAndBranch>(

[Yang, 2015/08/11 09:08:45]

Can we do an instance type check first to skip forward to the object case?

We could then bail out to the runtime implementation for the simd case (if we
don't care about performance that much).

[Benedikt Meurer, 2015/08/11 09:11:45]

As discussed offline: There's no runtime fallback (yet). I will cleanup this
CodeStub in followup CLs.

+                  map, Add<HConstant>(factory->float32x4_map()));
               is_float32x4.Then();
               { Push(Add<HConstant>(factory->float32x4_string())); }
               is_float32x4.Else();
               {
                 IfBuilder is_int32x4(this);
-                is_int32x4.If<HCompareNumericAndBranch>(
-                    instance_type, Add<HConstant>(INT32X4_TYPE), Token::EQ);
+                is_int32x4.If<HCompareObjectEqAndBranch>(
+                    map, Add<HConstant>(factory->int32x4_map()));
                 is_int32x4.Then();
                 { Push(Add<HConstant>(factory->int32x4_string())); }
                 is_int32x4.Else();
                 {
                   IfBuilder is_bool32x4(this);
-                  is_bool32x4.If<HCompareNumericAndBranch>(
-                      instance_type, Add<HConstant>(BOOL32X4_TYPE), Token::EQ);
+                  is_bool32x4.If<HCompareObjectEqAndBranch>(
+                      map, Add<HConstant>(factory->bool32x4_map()));
                   is_bool32x4.Then();
                   { Push(Add<HConstant>(factory->bool32x4_string())); }
                   is_bool32x4.Else();
                   {
                     IfBuilder is_int16x8(this);
-                    is_int16x8.If<HCompareNumericAndBranch>(
-                        instance_type, Add<HConstant>(INT16X8_TYPE), Token::EQ);
+                    is_int16x8.If<HCompareObjectEqAndBranch>(
+                        map, Add<HConstant>(factory->int16x8_map()));
                     is_int16x8.Then();
                     { Push(Add<HConstant>(factory->int16x8_string())); }
                     is_int16x8.Else();
                     {
                       IfBuilder is_bool16x8(this);
-                      is_bool16x8.If<HCompareNumericAndBranch>(
-                          instance_type, Add<HConstant>(BOOL16X8_TYPE),
-                          Token::EQ);
+                      is_bool16x8.If<HCompareObjectEqAndBranch>(
+                          map, Add<HConstant>(factory->bool16x8_map()));
                       is_bool16x8.Then();
                       { Push(Add<HConstant>(factory->bool16x8_string())); }
                       is_bool16x8.Else();
                       {
                         IfBuilder is_int8x16(this);
-                        is_int8x16.If<HCompareNumericAndBranch>(
-                            instance_type, Add<HConstant>(INT8X16_TYPE),
-                            Token::EQ);
+                        is_int8x16.If<HCompareObjectEqAndBranch>(
+                            map, Add<HConstant>(factory->int8x16_map()));
                         is_int8x16.Then();
                         { Push(Add<HConstant>(factory->int8x16_string())); }
                         is_int8x16.Else();
                         {
                           IfBuilder is_bool8x16(this);
-                          is_bool8x16.If<HCompareNumericAndBranch>(
-                              instance_type, Add<HConstant>(BOOL8X16_TYPE),
-                              Token::EQ);
+                          is_bool8x16.If<HCompareObjectEqAndBranch>(
+                              map, Add<HConstant>(factory->bool8x16_map()));
                           is_bool8x16.Then();
                           { Push(Add<HConstant>(factory->bool8x16_string())); }
                           is_bool8x16.Else();
                           {
                             // Is it an undetectable object?
                             IfBuilder is_undetectable(this);
                             is_undetectable.If<HIsUndetectableAndBranch>(
                                 object);
                             is_undetectable.Then();
                             {
@@ skipping 1815 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8