[WIP] TrapHandler 2014/11/27.

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/bootstrapper.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/node-properties.h"
@@ skipping 51 matching lines @@
   singleton_one = Type::Range(one, one, zone);
   zero_or_one = Type::Union(singleton_zero, singleton_one, zone);
   zeroish = Type::Union(singleton_zero, nan_or_minuszero, zone);
   signed32ish = Type::Union(signed32, truncating_to_zero, zone);
   unsigned32ish = Type::Union(unsigned32, truncating_to_zero, zone);
   falsish = Type::Union(Type::Undetectable(),
       Type::Union(zeroish, undefined_or_null, zone), zone);
   integer = Type::Range(minusinfinity, infinity, zone);
   weakint = Type::Union(integer, nan_or_minuszero, zone);
 
+  signed8_ = Type::Range(f->NewNumber(-0x7F), f->NewNumber(0x7F - 1), zone);
+  unsigned8_ = Type::Range(zero, f->NewNumber(0xFF - 1), zone);
+  signed16_ =
+      Type::Range(f->NewNumber(-0x7FFF), f->NewNumber(0x7FFF - 1), zone);
+  unsigned16_ = Type::Range(zero, f->NewNumber(0xFFFF - 1), zone);
+
   number_fun0_ = Type::Function(number, zone);
   number_fun1_ = Type::Function(number, number, zone);
   number_fun2_ = Type::Function(number, number, number, zone);
   weakint_fun1_ = Type::Function(weakint, number, zone);
   imul_fun_ = Type::Function(signed32, integral32, integral32, zone);
   clz32_fun_ = Type::Function(
       Type::Range(zero, f->NewNumber(32), zone), number, zone);
   random_fun_ = Type::Function(Type::Union(
       Type::UnsignedSmall(), Type::OtherNumber(), zone), zone);
 
-  Type* int8 = Type::Intersect(
-      Type::Range(f->NewNumber(-0x7F), f->NewNumber(0x7F-1), zone),
-      Type::UntaggedInt8(), zone);
-  Type* int16 = Type::Intersect(
-      Type::Range(f->NewNumber(-0x7FFF), f->NewNumber(0x7FFF-1), zone),
-      Type::UntaggedInt16(), zone);
-  Type* uint8 = Type::Intersect(
-      Type::Range(zero, f->NewNumber(0xFF-1), zone),
-      Type::UntaggedInt8(), zone);
-  Type* uint16 = Type::Intersect(
-      Type::Range(zero, f->NewNumber(0xFFFF-1), zone),
-      Type::UntaggedInt16(), zone);
-
-#define NATIVE_TYPE(sem, rep) \
-    Type::Intersect(Type::sem(), Type::rep(), zone)
-  Type* int32 = NATIVE_TYPE(Signed32, UntaggedInt32);
-  Type* uint32 = NATIVE_TYPE(Unsigned32, UntaggedInt32);
-  Type* float32 = NATIVE_TYPE(Number, UntaggedFloat32);
-  Type* float64 = NATIVE_TYPE(Number, UntaggedFloat64);
+#define NATIVE_TYPE(sem, rep) Type::Intersect(sem, rep, zone)
+  Type* int8 = NATIVE_TYPE(signed8_, Type::UntaggedInt8());
+  Type* uint8 = NATIVE_TYPE(unsigned8_, Type::UntaggedInt8());
+  Type* int16 = NATIVE_TYPE(signed16_, Type::UntaggedInt16());
+  Type* uint16 = NATIVE_TYPE(unsigned16_, Type::UntaggedInt16());
+  Type* int32 = NATIVE_TYPE(Type::Signed32(), Type::UntaggedInt32());
+  Type* uint32 = NATIVE_TYPE(Type::Unsigned32(), Type::UntaggedInt32());
+  Type* float32 = NATIVE_TYPE(Type::Number(), Type::UntaggedFloat32());
+  Type* float64 = NATIVE_TYPE(Type::Number(), Type::UntaggedFloat64());
 #undef NATIVE_TYPE
 
   Type* buffer = Type::Buffer(zone);
   Type* int8_array = Type::Array(int8, zone);
   Type* int16_array = Type::Array(int16, zone);
   Type* int32_array = Type::Array(int32, zone);
   Type* uint8_array = Type::Array(uint8, zone);
   Type* uint16_array = Type::Array(uint16, zone);
   Type* uint32_array = Type::Array(uint32, zone);
   Type* float32_array = Type::Array(float32, zone);
@@ skipping 1429 matching lines @@
 Bounds Typer::Visitor::TypeObjectIsSmi(Node* node) {
   return Bounds(Type::Boolean());
 }
 
 
 Bounds Typer::Visitor::TypeObjectIsNonNegativeSmi(Node* node) {
   return Bounds(Type::Boolean());
 }
 
 
+Bounds Typer::Visitor::TypeLoadBuffer(Node* node) {
+  switch (BufferAccessOf(node->op()).external_array_type()) {
+    case kExternalInt8Array:
+      return Bounds(typer_->signed8_);
+    case kExternalUint8Array:
+    case kExternalUint8ClampedArray:
+      return Bounds(typer_->unsigned8_);
+    case kExternalInt16Array:
+      return Bounds(typer_->signed16_);
+    case kExternalUint16Array:
+      return Bounds(typer_->unsigned16_);
+    case kExternalInt32Array:
+      return Bounds(Type::Signed32());
+    case kExternalUint32Array:
+      return Bounds(Type::Unsigned32());
+    case kExternalFloat32Array:
+      return Bounds(Type::Number());
+    case kExternalFloat64Array:
+      return Bounds(Type::Number());
+  }
+  UNREACHABLE();
+  return Bounds();
+}
+
+
+Bounds Typer::Visitor::TypeStoreBuffer(Node* node) {
+  UNREACHABLE();
+  return Bounds();
+}
+
+
+Bounds Typer::Visitor::TypeBoundsCheck(Node* node) {
+  return Bounds(Type::Unsigned32());
+}
+
+
 // Machine operators.
 
 Bounds Typer::Visitor::TypeLoad(Node* node) {
   return Bounds::Unbounded(zone());
 }
 
 
 Bounds Typer::Visitor::TypeStore(Node* node) {
   UNREACHABLE();
   return Bounds();
@@ skipping 413 matching lines @@
         return typer_->float64_array_fun_;
       }
     }
   }
   return Type::Constant(value, zone());
 }
 
 }
 }
 }  // namespace v8::internal::compiler