Steps towards unification of number bitset and range types.

test/cctest/compiler/test-js-typed-lowering.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/graph-inl.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/opcodes.h"
@@ skipping 148 matching lines @@
     CHECK_EQ(IrOpcode::kHeapConstant, result->opcode());
     Handle<Object> value = OpParameter<Unique<Object> >(result).handle();
     CHECK_EQ(*expected, *value);
   }
 };
 
 static Type* kStringTypes[] = {Type::InternalizedString(), Type::OtherString(),
                                Type::String()};
 
 
-static Type* kInt32Types[] = {
-    Type::UnsignedSmall(),       Type::NegativeSigned32(),
-    Type::NonNegativeSigned32(), Type::SignedSmall(),
-    Type::Signed32(),            Type::Unsigned32(),
-    Type::Integral32()};
+static Type* kInt32Types[] = {Type::Unsigned30(), Type::Negative32(),

[rossberg, 2015/01/15 15:15:12]

Why can't you use the Small types any longer?

[Jarin, 2015/01/16 16:28:39]

Done.

+                              Type::Unsigned31(), Type::Signed31(),
+                              Type::Signed32(),   Type::Unsigned32(),
+                              Type::Integral32()};
 
 
 static Type* kNumberTypes[] = {
-    Type::UnsignedSmall(),       Type::NegativeSigned32(),
-    Type::NonNegativeSigned32(), Type::SignedSmall(),
-    Type::Signed32(),            Type::Unsigned32(),
-    Type::Integral32(),          Type::MinusZero(),
-    Type::NaN(),                 Type::OrderedNumber(),
-    Type::PlainNumber(),         Type::Number()};
+    Type::Unsigned30(),    Type::Negative32(),  Type::Unsigned31(),
+    Type::Signed31(),      Type::Signed32(),    Type::Unsigned32(),
+    Type::Integral32(),    Type::MinusZero(),   Type::NaN(),
+    Type::OrderedNumber(), Type::PlainNumber(), Type::Number()};
 
 
 static Type* kJSTypes[] = {Type::Undefined(), Type::Null(),   Type::Boolean(),
                            Type::Number(),    Type::String(), Type::Object()};
 
 
 static Type* I32Type(bool is_signed) {
   return is_signed ? Type::Signed32() : Type::Unsigned32();
 }
 
@@ skipping 106 matching lines @@
   void set(int idx, const Operator* op, bool s) {
     ops[idx] = op;
     signedness[idx] = s;
   }
 };
 
 
 TEST(Int32BitwiseShifts) {
   JSBitwiseShiftTypedLoweringTester R;
 
-  Type* types[] = {Type::SignedSmall(),      Type::UnsignedSmall(),
-                   Type::NegativeSigned32(), Type::NonNegativeSigned32(),
-                   Type::Unsigned32(),       Type::Signed32(),
-                   Type::MinusZero(),        Type::NaN(),
-                   Type::Undefined(),        Type::Null(),
-                   Type::Boolean(),          Type::Number(),
-                   Type::PlainNumber(),      Type::String()};
+  Type* types[] = {Type::Signed31(),    Type::Unsigned30(), Type::Negative32(),
+                   Type::Unsigned31(),  Type::Unsigned32(), Type::Signed32(),
+                   Type::MinusZero(),   Type::NaN(),        Type::Undefined(),
+                   Type::Null(),        Type::Boolean(),    Type::Number(),
+                   Type::PlainNumber(), Type::String()};
 
   for (size_t i = 0; i < arraysize(types); ++i) {
     Node* p0 = R.Parameter(types[i], 0);
 
     for (size_t j = 0; j < arraysize(types); ++j) {
       Node* p1 = R.Parameter(types[j], 1);
 
       for (int k = 0; k < R.kNumberOps; k += 2) {
         Node* add = R.Binop(R.ops[k], p0, p1);
         Node* r = R.reduce(add);
@@ skipping 39 matching lines @@
     ops[idx] = op;
     signedness[idx] = s;
   }
 };
 
 
 TEST(Int32BitwiseBinops) {
   JSBitwiseTypedLoweringTester R;
 
   Type* types[] = {
-      Type::SignedSmall(),   Type::UnsignedSmall(), Type::Unsigned32(),
-      Type::Signed32(),      Type::MinusZero(),     Type::NaN(),
-      Type::OrderedNumber(), Type::PlainNumber(),   Type::Undefined(),
-      Type::Null(),          Type::Boolean(),       Type::Number(),
+      Type::Signed31(),      Type::Unsigned30(),  Type::Unsigned32(),
+      Type::Signed32(),      Type::MinusZero(),   Type::NaN(),
+      Type::OrderedNumber(), Type::PlainNumber(), Type::Undefined(),
+      Type::Null(),          Type::Boolean(),     Type::Number(),
       Type::String()};
 
   for (size_t i = 0; i < arraysize(types); ++i) {
     Node* p0 = R.Parameter(types[i], 0);
 
     for (size_t j = 0; j < arraysize(types); ++j) {
       Node* p1 = R.Parameter(types[j], 1);
 
       for (int k = 0; k < R.kNumberOps; k += 2) {
         Node* add = R.Binop(R.ops[k], p0, p1);
@@ skipping 471 matching lines @@
       Node* r = n->InputAt(0);
       R->CheckPureBinop(expected, r);
     }
   }
 }
 
 
 TEST(EqualityForNumbers) {
   JSTypedLoweringTester R;
 
-  Type* simple_number_types[] = {Type::UnsignedSmall(), Type::SignedSmall(),
+  Type* simple_number_types[] = {Type::Unsigned30(), Type::Signed31(),
                                  Type::Signed32(), Type::Unsigned32(),
                                  Type::Number()};
 
 
   for (size_t i = 0; i < arraysize(simple_number_types); ++i) {
     Node* p0 = R.Parameter(simple_number_types[i], 0);
 
     for (size_t j = 0; j < arraysize(simple_number_types); ++j) {
       Node* p1 = R.Parameter(simple_number_types[j], 1);
 
@@ skipping 376 matching lines @@
           CHECK_EQ(p1, r->InputAt(0));
           CHECK_EQ(p0, r->InputAt(1));
         } else {
           CHECK_EQ(p0, r->InputAt(0));
           CHECK_EQ(p1, r->InputAt(1));
         }
       }
     }
   }
 }