[hydrogen] optimize switch with string clauses

src/type-info.h

 // Copyright 2011 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 46 matching lines @@
 
   static TypeInfo Unknown() { return TypeInfo(kUnknown); }
   // We know it's a primitive type.
   static TypeInfo Primitive() { return TypeInfo(kPrimitive); }
   // We know it's a number of some sort.
   static TypeInfo Number() { return TypeInfo(kNumber); }
   // We know it's a signed 32 bit integer.
   static TypeInfo Integer32() { return TypeInfo(kInteger32); }
   // We know it's a Smi.
   static TypeInfo Smi() { return TypeInfo(kSmi); }
+  // We know it's a Symbol.
+  static TypeInfo Symbol() { return TypeInfo(kSymbol); }
   // We know it's a heap number.
   static TypeInfo Double() { return TypeInfo(kDouble); }
   // We know it's a string.
   static TypeInfo String() { return TypeInfo(kString); }
   // We know it's a non-primitive (object) type.
   static TypeInfo NonPrimitive() { return TypeInfo(kNonPrimitive); }
   // We haven't started collecting info yet.
   static TypeInfo Uninitialized() { return TypeInfo(kUninitialized); }
 
   int ToInt() {
@@ skipping 53 matching lines @@
   inline bool IsNumber() {
     ASSERT(type_ != kUninitialized);
     return ((type_ & kNumber) == kNumber);
   }
 
   inline bool IsSmi() {
     ASSERT(type_ != kUninitialized);
     return ((type_ & kSmi) == kSmi);
   }
 
+  inline bool IsSymbol() {
+    ASSERT(type_ != kUninitialized);
+    return ((type_ & kSymbol) == kSymbol);
+  }
+
+  inline bool IsNonSymbol() {
+    ASSERT(type_ != kUninitialized);
+    return ((type_ & kSymbol) == kString);
+  }
+
   inline bool IsInteger32() {
     ASSERT(type_ != kUninitialized);
     return ((type_ & kInteger32) == kInteger32);
   }
 
   inline bool IsDouble() {
     ASSERT(type_ != kUninitialized);
     return ((type_ & kDouble) == kDouble);
   }
 
@@ skipping 11 matching lines @@
     return type_ == kUninitialized;
   }
 
   const char* ToString() {
     switch (type_) {
       case kUnknown: return "Unknown";
       case kPrimitive: return "Primitive";
       case kNumber: return "Number";
       case kInteger32: return "Integer32";
       case kSmi: return "Smi";
+      case kSymbol: return "Symbol";
       case kDouble: return "Double";
       case kString: return "String";
       case kNonPrimitive: return "Object";
       case kUninitialized: return "Uninitialized";
     }
     UNREACHABLE();
     return "Unreachable code";
   }
 
  private:
   enum Type {
     kUnknown = 0,          // 0000000
     kPrimitive = 0x10,     // 0010000
     kNumber = 0x11,        // 0010001
     kInteger32 = 0x13,     // 0010011
     kSmi = 0x17,           // 0010111
     kDouble = 0x19,        // 0011001
     kString = 0x30,        // 0110000
+    kSymbol = 0x32,        // 0110010
     kNonPrimitive = 0x40,  // 1000000
     kUninitialized = 0x7f  // 1111111
   };
   explicit inline TypeInfo(Type t) : type_(t) { }
 
   Type type_;
 };
 
 
 enum StringStubFeedback {
@@ skipping 86 matching lines @@
   Handle<Context> global_context_;
   Isolate* isolate_;
   Handle<NumberDictionary> dictionary_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeFeedbackOracle);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPE_INFO_H_