Turbofan: Add MachineOperators for SIMD.

src/compiler/typer.cc

 // Copyright 2014 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/compiler/typer.h"
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/common-operator.h"
@@ skipping 79 matching lines @@
 
 #define DECLARE_CASE(x) \
   case IrOpcode::k##x:  \
     return UpdateType(node, Type##x(node));
       DECLARE_CASE(Start)
       DECLARE_CASE(IfException)
       // VALUE_OP_LIST without JS_SIMPLE_BINOP_LIST:
       COMMON_OP_LIST(DECLARE_CASE)
       SIMPLIFIED_OP_LIST(DECLARE_CASE)
       MACHINE_OP_LIST(DECLARE_CASE)
+      MACHINE_SIMD_OP_LIST(DECLARE_CASE)
       JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
       JS_OBJECT_OP_LIST(DECLARE_CASE)
       JS_CONTEXT_OP_LIST(DECLARE_CASE)
       JS_OTHER_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
 
 #define DECLARE_CASE(x) case IrOpcode::k##x:
       DECLARE_CASE(Loop)
       DECLARE_CASE(Branch)
       DECLARE_CASE(IfTrue)
@@ skipping 26 matching lines @@
       JS_SIMPLE_BINOP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
 
 #define DECLARE_CASE(x) case IrOpcode::k##x: return Type##x(node);
       DECLARE_CASE(Start)
       DECLARE_CASE(IfException)
       // VALUE_OP_LIST without JS_SIMPLE_BINOP_LIST:
       COMMON_OP_LIST(DECLARE_CASE)
       SIMPLIFIED_OP_LIST(DECLARE_CASE)
       MACHINE_OP_LIST(DECLARE_CASE)
+      MACHINE_SIMD_OP_LIST(DECLARE_CASE)
       JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
       JS_OBJECT_OP_LIST(DECLARE_CASE)
       JS_CONTEXT_OP_LIST(DECLARE_CASE)
       JS_OTHER_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
 
 #define DECLARE_CASE(x) case IrOpcode::k##x:
       DECLARE_CASE(Loop)
       DECLARE_CASE(Branch)
       DECLARE_CASE(IfTrue)
@@ skipping 2290 matching lines @@
 Type* Typer::Visitor::TypeInt32PairAdd(Node* node) { return Type::Internal(); }
 
 Type* Typer::Visitor::TypeInt32PairSub(Node* node) { return Type::Internal(); }
 
 Type* Typer::Visitor::TypeWord32PairShl(Node* node) { return Type::Internal(); }
 
 Type* Typer::Visitor::TypeWord32PairShr(Node* node) { return Type::Internal(); }
 
 Type* Typer::Visitor::TypeWord32PairSar(Node* node) { return Type::Internal(); }
 
+// SIMD type methods.

[Mircea Trofin, 2016/03/31 21:36:04]

Consider macro-ising these.

[bbudge, 2016/04/01 00:57:53]

Done.

+
+Type* Typer::Visitor::TypeCreateFloat32x4(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4ExtractLane(Node* node) {
+  return Type::Number();
+}
+
+Type* Typer::Visitor::TypeFloat32x4ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4Abs(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Neg(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Sqrt(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4RecipApprox(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4RecipSqrtApprox(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4Add(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Sub(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Mul(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Div(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4MinNum(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4MaxNum(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4NotEqual(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4Select(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Swizzle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4FromInt32x4(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4FromUint32x4(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeFloat32x4Load1(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Load2(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Load3(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Store1(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Store2(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeFloat32x4Store3(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeCreateInt32x4(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4ExtractLane(Node* node) {
+  return Type::Number();
+}
+
+Type* Typer::Visitor::TypeInt32x4ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4Neg(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Add(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Sub(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Mul(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4And(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Or(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Xor(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Not(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4ShiftLeftByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4ShiftRightByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4NotEqual(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4Select(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Swizzle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4FromFloat32x4(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt32x4Load1(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Load2(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Load3(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Store1(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Store2(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt32x4Store3(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint32x4Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint32x4Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint32x4ShiftLeftByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint32x4ShiftRightByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint32x4LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint32x4LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint32x4GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint32x4GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint32x4FromFloat32x4(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeCreateBool32x4(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4ExtractLane(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool32x4ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeBool32x4And(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4Or(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4Xor(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4Not(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4AnyTrue(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool32x4AllTrue(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool32x4Swizzle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool32x4NotEqual(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeCreateInt16x8(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8ExtractLane(Node* node) {
+  return Type::Number();
+}
+
+Type* Typer::Visitor::TypeInt16x8ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8Neg(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Add(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8AddSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8Sub(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8SubSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8Mul(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8And(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Or(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Xor(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Not(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8ShiftLeftByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8ShiftRightByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8NotEqual(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt16x8Select(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Swizzle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt16x8Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint16x8AddSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint16x8SubSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint16x8Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint16x8Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint16x8ShiftLeftByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint16x8ShiftRightByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint16x8LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint16x8LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint16x8GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint16x8GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeCreateBool16x8(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8ExtractLane(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool16x8ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeBool16x8And(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8Or(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8Xor(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8Not(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8AnyTrue(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool16x8AllTrue(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool16x8Swizzle(Node* node) { return Type::Simd(); }

[bradn, 2016/03/31 21:20:48]

I suspect these might require a separate type, but this is ok for now.

[bbudge, 2016/04/01 00:57:53]

Acknowledged.

+
+Type* Typer::Visitor::TypeBool16x8Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool16x8NotEqual(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeCreateInt8x16(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16ExtractLane(Node* node) {
+  return Type::Number();
+}
+
+Type* Typer::Visitor::TypeInt8x16ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16Neg(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Add(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16AddSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16Sub(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16SubSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16Mul(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16And(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Or(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Xor(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Not(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16ShiftLeftByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16ShiftRightByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16NotEqual(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeInt8x16Select(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Swizzle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeInt8x16Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint8x16AddSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint8x16SubSaturate(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint8x16Min(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint8x16Max(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint8x16ShiftLeftByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint8x16ShiftRightByScalar(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint8x16LessThan(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeUint8x16LessThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint8x16GreaterThan(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeUint8x16GreaterThanOrEqual(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeCreateBool8x16(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16ExtractLane(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool8x16ReplaceLane(Node* node) {
+  return Type::Simd();
+}
+
+Type* Typer::Visitor::TypeBool8x16And(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16Or(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16Xor(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16Not(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16AnyTrue(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool8x16AllTrue(Node* node) {
+  return Type::Boolean();
+}
+
+Type* Typer::Visitor::TypeBool8x16Swizzle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16Shuffle(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16Equal(Node* node) { return Type::Simd(); }
+
+Type* Typer::Visitor::TypeBool8x16NotEqual(Node* node) { return Type::Simd(); }
+
 // Heap constants.
 
 
 Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
   if (value->IsJSTypedArray()) {
     switch (JSTypedArray::cast(*value)->type()) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                          \
     return typer_->cache_.k##Type##Array;
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   if (Type::IsInteger(*value)) {
     return Type::Range(value->Number(), value->Number(), zone());
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8