Refactor HCheckInstanceType to allow mask/tag tests.

src/hydrogen-instructions.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 1739 matching lines @@
     return target_.is_identical_to(b->target());
   }
 
  private:
   Handle<JSFunction> target_;
 };
 
 
 class HCheckInstanceType: public HUnaryOperation {
  public:
-  // Check that the instance type is in the range [first, last] where
-  // both first and last are included.
-  HCheckInstanceType(HValue* value, InstanceType first, InstanceType last)
-      : HUnaryOperation(value), first_(first), last_(last) {
-    ASSERT(first <= last);
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    if ((FIRST_STRING_TYPE < first && last <= LAST_STRING_TYPE) ||
-        (FIRST_STRING_TYPE <= first && last < LAST_STRING_TYPE)) {
-      // A particular string instance type can change because of GC or
-      // externalization, but the value still remains a string.
-      SetFlag(kDependsOnMaps);
-    }
+  static HCheckInstanceType* NewIsJSObjectOrJSFunction(HValue* value);
+  static HCheckInstanceType* NewIsJSArray(HValue* value) {
+    return new HCheckInstanceType(value, JS_ARRAY_TYPE, JS_ARRAY_TYPE, 0, 0);
+  }
+  static HCheckInstanceType* NewIsString(HValue* value) {
+    return new HCheckInstanceType(value,
+                                  FIRST_TYPE, FIRST_TYPE,
+                                  kIsNotStringMask, kStringTag);
+  }
+  static HCheckInstanceType* NewIsSymbol(HValue* value) {
+    return new HCheckInstanceType(value,
+                                  FIRST_TYPE, FIRST_TYPE,
+                                  kIsSymbolMask, kSymbolTag);
   }
 
   virtual bool IsCheckInstruction() const { return true; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
 #ifdef DEBUG
   virtual void Verify();
 #endif
 
   virtual HValue* Canonicalize() {
     if (!value()->type().IsUninitialized() &&
         value()->type().IsString() &&
-        first() == FIRST_STRING_TYPE &&
-        last() == LAST_STRING_TYPE) {
+        !is_range() &&
+        mask() == kIsNotStringMask &&
+        tag() == kStringTag) {
       return NULL;
     }
     return this;
   }
 
-  static HCheckInstanceType* NewIsJSObjectOrJSFunction(HValue* value);
+  bool is_range() const { return mask_ == 0; }
 
-  InstanceType first() const { return first_; }
-  InstanceType last() const { return last_; }
+  InstanceType first() const {
+    ASSERT(is_range());
+    return first_;
+  }
+
+  InstanceType last() {
+    ASSERT(is_range());
+    return last_;
+  }
+
+  uint8_t mask() const {
+    ASSERT(!is_range());
+    return mask_;
+  }
+
+  uint8_t tag() const {
+    ASSERT(!is_range());
+    return tag_;
+  }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType)
 
  protected:
   // TODO(ager): It could be nice to allow the ommision of instance
   // type checks if we have already performed an instance type check
   // with a larger range.
   virtual bool DataEquals(HValue* other) {
     HCheckInstanceType* b = HCheckInstanceType::cast(other);
-    return (first_ == b->first()) && (last_ == b->last());
+    return first_ == b->first_ && last_ == b->last_ &&
+        mask_ == b->mask_ && tag_ == b->tag_;
   }
 
  private:
+  // Check that the instance type is in the range [first, last] where

[Mads Ager (chromium), 2011/05/09 16:57:51]

Comment needs updating.

+  // both first and last are included.
+  HCheckInstanceType(HValue* value,
+                     InstanceType first, InstanceType last,
+                     uint8_t mask, uint8_t tag)
+      : HUnaryOperation(value),
+        first_(first), last_(last),
+        mask_(mask), tag_(tag) {
+    ASSERT(first <= last);
+    set_representation(Representation::Tagged());
+    SetFlag(kUseGVN);
+    if (is_range() && first_ < FIRST_NONSTRING_TYPE) {
+      // A particular string instance type can change because of GC or
+      // externalization, but the value still remains a string.
+      SetFlag(kDependsOnMaps);
+    }
+  }
+
   InstanceType first_;
   InstanceType last_;
+  uint8_t mask_;

[Mads Ager (chromium), 2011/05/09 16:57:51]

I don't like this much. Create two types of instructions instead of having two
unused fields per instance?

+  uint8_t tag_;
 };
 
 
 class HCheckNonSmi: public HUnaryOperation {
  public:
   explicit HCheckNonSmi(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
   }
 
@@ skipping 2004 matching lines @@
 
   DECLARE_CONCRETE_INSTRUCTION(In)
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_