Add primitive type and string type to the number info....

src/number-info.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_NUMBER_INFO_H_
 #define V8_NUMBER_INFO_H_
 
 namespace v8 {
 namespace internal {
 
 //        Unknown
 //           |
-//         Number
-//         /    |
-//  HeapNumber Integer32
-//        |      |
-//        |     Smi
-//        |     /
-//      Uninitialized.
+//      PrimitiveType
+//           |   \--------|
+//         Number      String
+//         /    |         |
+//  HeapNumber Integer32  |
+//        |      |       /
+//        |     Smi     /
+//        |     /      /
+//        Uninitialized.
 
 class NumberInfo {
  public:
   NumberInfo() { }
 
   static inline NumberInfo Unknown();
+  // We know it's a primitive type.
+  static inline NumberInfo Primitive();
   // We know it's a number of some sort.
   static inline NumberInfo Number();
   // We know it's signed or unsigned 32 bit integer.
   static inline NumberInfo Integer32();
   // We know it's a Smi.
   static inline NumberInfo Smi();
   // We know it's a heap number.
   static inline NumberInfo HeapNumber();
+  // We know it's a string.
+  static inline NumberInfo String();
   // We haven't started collecting info yet.
   static inline NumberInfo Uninitialized();
 
   // Return compact representation.  Very sensitive to enum values below!
+  // Compacting drops information about primtive types and strings types.
+  // We use the compact representation when we only care about number types.
   int ThreeBitRepresentation() {
     ASSERT(type_ != kUninitializedType);
-    int answer = type_ > 6 ? type_ -2 : type_;
+    int answer = type_ & 0xf;
+    answer = answer > 6 ? answer - 2 : answer;
     ASSERT(answer >= 0);
     ASSERT(answer <= 7);
     return answer;
   }
 
   // Decode compact representation.  Very sensitive to enum values below!
   static NumberInfo ExpandedRepresentation(int three_bit_representation) {
     Type t = static_cast<Type>(three_bit_representation >= 6 ?
                                three_bit_representation + 2 :
                                three_bit_representation);
+    t = (t == kUnknownType) ? t : static_cast<Type>(t | kPrimitiveType);
     ASSERT(t == kUnknownType ||
            t == kNumberType ||
            t == kInteger32Type ||
            t == kSmiType ||
            t == kHeapNumberType);
     return NumberInfo(t);
   }
 
   int ToInt() {
     return type_;
   }
 
   static NumberInfo FromInt(int bit_representation) {
     Type t = static_cast<Type>(bit_representation);
     ASSERT(t == kUnknownType ||
+           t == kPrimitiveType ||
            t == kNumberType ||
            t == kInteger32Type ||
            t == kSmiType ||
-           t == kHeapNumberType);
+           t == kHeapNumberType ||
+           t == kStringType);
     return NumberInfo(t);
   }
 
   // Return the weakest (least precise) common type.
   static NumberInfo Combine(NumberInfo a, NumberInfo b) {
     return NumberInfo(static_cast<Type>(a.type_ & b.type_));
   }
 
   inline bool IsUnknown() {
     return type_ == kUnknownType;
@@ skipping 19 matching lines @@
     return ((type_ & kHeapNumberType) == kHeapNumberType);
   }
 
   inline bool IsUninitialized() {
     return type_ == kUninitializedType;
   }
 
   const char* ToString() {
     switch (type_) {
       case kUnknownType: return "UnknownType";
+      case kPrimitiveType: return "PrimitiveType";
       case kNumberType: return "NumberType";
+      case kInteger32Type: return "Integer32Type";
       case kSmiType: return "SmiType";
       case kHeapNumberType: return "HeapNumberType";
-      case kInteger32Type: return "Integer32Type";
+      case kStringType: return "StringType";
       case kUninitializedType:
         UNREACHABLE();
         return "UninitializedType";
     }
     UNREACHABLE();
     return "Unreachable code";
   }
 
  private:
+  // We use 6 bits to represent the types.
   enum Type {
-    kUnknownType = 0,
-    kNumberType = 1,
-    kInteger32Type = 3,
-    kSmiType = 7,
-    kHeapNumberType = 9,
-    kUninitializedType = 15
+    kUnknownType = 0,          // 000000
+    kPrimitiveType = 0x10,     // 010000
+    kNumberType = 0x11,        // 010001
+    kInteger32Type = 0x13,     // 010011
+    kSmiType = 0x17,           // 010111
+    kHeapNumberType = 0x19,    // 011001
+    kStringType = 0x30,        // 110000
+    kUninitializedType = 0x3f  // 111111
   };
   explicit inline NumberInfo(Type t) : type_(t) { }
 
   Type type_;
 };
 
 
 NumberInfo NumberInfo::Unknown() {
   return NumberInfo(kUnknownType);
 }
 
 
+NumberInfo NumberInfo::Primitive() {
+  return NumberInfo(kPrimitiveType);
+}
+
+
 NumberInfo NumberInfo::Number() {
   return NumberInfo(kNumberType);
 }
 
 
 NumberInfo NumberInfo::Integer32() {
   return NumberInfo(kInteger32Type);
 }
 
 
 NumberInfo NumberInfo::Smi() {
   return NumberInfo(kSmiType);
 }
 
 
 NumberInfo NumberInfo::HeapNumber() {
   return NumberInfo(kHeapNumberType);
 }
 
 
+NumberInfo NumberInfo::String() {
+  return NumberInfo(kStringType);
+}
+
+
 NumberInfo NumberInfo::Uninitialized() {
   return NumberInfo(kUninitializedType);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_NUMBER_INFO_H_