SIMD.js Add the other SIMD Phase 1 types.

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 387 matching lines @@
             { 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.Then();
               { Push(Add<HConstant>(factory->float32x4_string())); }
               is_float32x4.Else();
               {
-                // Is it an undetectable object?
-                IfBuilder is_undetectable(this);
-                is_undetectable.If<HIsUndetectableAndBranch>(object);
-                is_undetectable.Then();
+                IfBuilder is_int32x4(this);
+                is_int32x4.If<HCompareNumericAndBranch>(
+                    instance_type, Add<HConstant>(INT32X4_TYPE), Token::EQ);
+                is_int32x4.Then();
+                { Push(Add<HConstant>(factory->int32x4_string())); }
+                is_int32x4.Else();
                 {
-                  // typeof an undetectable object is 'undefined'.
-                  Push(undefined_string);
-                }
-                is_undetectable.Else();
-                {
-                  // For any kind of object not handled above, the spec rule for
-                  // host objects gives that it is okay to return "object".
-                  Push(object_string);
+                  IfBuilder is_bool32x4(this);
+                  is_bool32x4.If<HCompareNumericAndBranch>(
+                      instance_type, Add<HConstant>(BOOL32X4_TYPE), Token::EQ);
+                  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.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.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.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.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();
+                            {
+                              // typeof an undetectable object is 'undefined'.
+                              Push(undefined_string);
+                            }
+                            is_undetectable.Else();
+                            {
+                              // For any kind of object not handled above, the
+                              // spec rule for host objects gives that it is
+                              // okay to return "object".
+                              Push(object_string);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
                 }
               }
             }
             is_function.End();
           }
           is_symbol.End();
         }
         is_oddball.End();
       }
       is_string.End();
@@ skipping 1780 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8