Introduce unsigned representation types

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/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 41 matching lines @@
     int index = static_cast<int>(type);
     DCHECK(index < kNumLazyCachedTypes);
     if (cache_[index] == NULL) cache_[index] = Create(type);
     return cache_[index];
   }
 
  private:
   Type* Create(LazyCachedType type) {
     switch (type) {
       case kInt8:
-        return CreateNative(CreateRange<int8_t>(), Type::UntaggedInt8());
+        return CreateNative(CreateRange<int8_t>(), Type::UntaggedSigned8());
       case kUint8:
-        return CreateNative(CreateRange<uint8_t>(), Type::UntaggedInt8());
+        return CreateNative(CreateRange<uint8_t>(), Type::UntaggedUnsigned8());
       case kInt16:
-        return CreateNative(CreateRange<int16_t>(), Type::UntaggedInt16());
+        return CreateNative(CreateRange<int16_t>(), Type::UntaggedSigned16());
       case kUint16:
-        return CreateNative(CreateRange<uint16_t>(), Type::UntaggedInt16());
+        return CreateNative(CreateRange<uint16_t>(),
+                            Type::UntaggedUnsigned16());
       case kInt32:
-        return CreateNative(Type::Signed32(), Type::UntaggedInt32());
+        return CreateNative(Type::Signed32(), Type::UntaggedSigned32());
       case kUint32:
-        return CreateNative(Type::Unsigned32(), Type::UntaggedInt32());
+        return CreateNative(Type::Unsigned32(), Type::UntaggedUnsigned32());
       case kFloat32:
         return CreateNative(Type::Number(), Type::UntaggedFloat32());
       case kFloat64:
         return CreateNative(Type::Number(), Type::UntaggedFloat64());
       case kNumberFunc0:
         return Type::Function(Type::Number(), zone());
       case kNumberFunc1:
         return Type::Function(Type::Number(), Type::Number(), zone());
       case kNumberFunc2:
         return Type::Function(Type::Number(), Type::Number(), Type::Number(),
                               zone());
       case kImulFunc:
         return Type::Function(Type::Signed32(), Type::Integral32(),
                               Type::Integral32(), zone());
       case kClz32Func:
         return Type::Function(CreateRange(0, 32), Type::Number(), zone());
       case kArrayBufferFunc:
-        return Type::Function(Type::Buffer(zone()), Type::Unsigned32(), zone());
+        return Type::Function(Type::Object(zone()), Type::Unsigned32(), zone());
 #define NATIVE_TYPE_CASE(Type)        \
   case k##Type##Array:                \
     return CreateArray(Get(k##Type)); \
   case k##Type##ArrayFunc:            \
     return CreateArrayFunction(Get(k##Type##Array));
         NATIVE_TYPES(NATIVE_TYPE_CASE)
 #undef NATIVE_TYPE_CASE
       case kNumLazyCachedTypes:
         break;
     }
@@ skipping 490 matching lines @@
 
 Bounds Typer::Visitor::TypeParameter(Node* node) {
   return Bounds::Unbounded(zone());
 }
 
 
 Bounds Typer::Visitor::TypeInt32Constant(Node* node) {
   Factory* f = isolate()->factory();
   Handle<Object> number = f->NewNumber(OpParameter<int32_t>(node));
   return Bounds(Type::Intersect(
-      Type::Range(number, number, zone()), Type::UntaggedInt32(), zone()));
+      Type::Range(number, number, zone()), Type::UntaggedSigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeInt64Constant(Node* node) {
+  // TODO(rossberg): This actually seems to be a PointerConstant so far...
   return Bounds(Type::Internal());  // TODO(rossberg): Add int64 bitset type?
 }
 
 
 Bounds Typer::Visitor::TypeFloat32Constant(Node* node) {
   return Bounds(Type::Intersect(
       Type::Of(OpParameter<float>(node), zone()),
       Type::UntaggedFloat32(), zone()));
 }
 
@@ skipping 912 matching lines @@
       Type::Intersect(rep, Type::Representation(), zone), zone);
   */
   return type;
 }
 
 
 Bounds Typer::Visitor::TypeChangeTaggedToInt32(Node* node) {
   Bounds arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Signed32()));
   return Bounds(
-      ChangeRepresentation(arg.lower, Type::UntaggedInt32(), zone()),
-      ChangeRepresentation(arg.upper, Type::UntaggedInt32(), zone()));
+      ChangeRepresentation(arg.lower, Type::UntaggedSigned32(), zone()),
+      ChangeRepresentation(arg.upper, Type::UntaggedSigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeTaggedToUint32(Node* node) {
   Bounds arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Unsigned32()));
   return Bounds(
-      ChangeRepresentation(arg.lower, Type::UntaggedInt32(), zone()),
-      ChangeRepresentation(arg.upper, Type::UntaggedInt32(), zone()));
+      ChangeRepresentation(arg.lower, Type::UntaggedUnsigned32(), zone()),
+      ChangeRepresentation(arg.upper, Type::UntaggedUnsigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeTaggedToFloat64(Node* node) {
   Bounds arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Number()));
   return Bounds(
       ChangeRepresentation(arg.lower, Type::UntaggedFloat64(), zone()),
       ChangeRepresentation(arg.upper, Type::UntaggedFloat64(), zone()));
 }
@@ skipping 23 matching lines @@
   return Bounds(
       ChangeRepresentation(arg.lower, Type::Tagged(), zone()),
       ChangeRepresentation(arg.upper, Type::Tagged(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeBoolToBit(Node* node) {
   Bounds arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Boolean()));
   return Bounds(
-      ChangeRepresentation(arg.lower, Type::UntaggedInt1(), zone()),
-      ChangeRepresentation(arg.upper, Type::UntaggedInt1(), zone()));
+      ChangeRepresentation(arg.lower, Type::UntaggedBit(), zone()),
+      ChangeRepresentation(arg.upper, Type::UntaggedBit(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeBitToBool(Node* node) {
   Bounds arg = Operand(node, 0);
   // TODO(neis): DCHECK(arg.upper->Is(Type::Boolean()));
   return Bounds(
-      ChangeRepresentation(arg.lower, Type::TaggedPtr(), zone()),
-      ChangeRepresentation(arg.upper, Type::TaggedPtr(), zone()));
+      ChangeRepresentation(arg.lower, Type::TaggedPointer(), zone()),
+      ChangeRepresentation(arg.upper, Type::TaggedPointer(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeLoadField(Node* node) {
   return Bounds(FieldAccessOf(node->op()).type);
 }
 
 
 Bounds Typer::Visitor::TypeLoadBuffer(Node* node) {
   // TODO(bmeurer): This typing is not yet correct. Since we can still access
@@ skipping 264 matching lines @@
 
 
 Bounds Typer::Visitor::TypeChangeFloat32ToFloat64(Node* node) {
   return Bounds(Type::Intersect(
       Type::Number(), Type::UntaggedFloat64(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeFloat64ToInt32(Node* node) {
   return Bounds(Type::Intersect(
-      Type::Signed32(), Type::UntaggedInt32(), zone()));
+      Type::Signed32(), Type::UntaggedSigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeFloat64ToUint32(Node* node) {
   return Bounds(Type::Intersect(
-      Type::Unsigned32(), Type::UntaggedInt32(), zone()));
+      Type::Unsigned32(), Type::UntaggedUnsigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeInt32ToFloat64(Node* node) {
   return Bounds(Type::Intersect(
       Type::Signed32(), Type::UntaggedFloat64(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeChangeInt32ToInt64(Node* node) {
@@ skipping 13 matching lines @@
 
 
 Bounds Typer::Visitor::TypeTruncateFloat64ToFloat32(Node* node) {
   return Bounds(Type::Intersect(
       Type::Number(), Type::UntaggedFloat32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeTruncateFloat64ToInt32(Node* node) {
   return Bounds(Type::Intersect(
-      Type::Signed32(), Type::UntaggedInt32(), zone()));
+      Type::Signed32(), Type::UntaggedSigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeTruncateInt64ToInt32(Node* node) {
   return Bounds(Type::Intersect(
-      Type::Signed32(), Type::UntaggedInt32(), zone()));
+      Type::Signed32(), Type::UntaggedSigned32(), zone()));
 }
 
 
 Bounds Typer::Visitor::TypeFloat64Add(Node* node) {
   return Bounds(Type::Number());
 }
 
 
 Bounds Typer::Visitor::TypeFloat64Sub(Node* node) {
   return Bounds(Type::Number());
@@ skipping 150 matching lines @@
         // TODO(rossberg): Do we want some ClampedArray type to express this?
         break;
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8