The check for internalized strings relied on the fact that we had less

src/ia32/code-stubs-ia32.cc

Index: src/ia32/code-stubs-ia32.cc
diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc
index 0ca56984ad0497a857ba9ea3f4406902e20b52d1..a8326ee8afff60a1ab5cb4cba5d95ddcf440eaa8 100644
--- a/src/ia32/code-stubs-ia32.cc
+++ b/src/ia32/code-stubs-ia32.cc
@@ -6853,9 +6853,13 @@ void ICCompareStub::GenerateInternalizedStrings(MacroAssembler* masm) {
   __ movzx_b(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
   __ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
   STATIC_ASSERT(kInternalizedTag != 0);
-  __ and_(tmp1, tmp2);
-  __ test(tmp1, Immediate(kIsInternalizedMask));
-  __ j(zero, &miss, Label::kNear);
+  __ and_(tmp1, Immediate(kIsNotStringMask | kIsInternalizedMask));
+  __ cmpb(tmp1, kInternalizedTag | kStringTag);
+  __ j(not_equal, &miss, Label::kNear);
+
+  __ and_(tmp2, Immediate(kIsNotStringMask | kIsInternalizedMask));
+  __ cmpb(tmp2, kInternalizedTag | kStringTag);
+  __ j(not_equal, &miss, Label::kNear);
 
   // Internalized strings are compared by identity.
   Label done;
@@ -6901,17 +6905,19 @@ void ICCompareStub::GenerateUniqueNames(MacroAssembler* masm) {
   __ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
 
   Label succeed1;
-  __ test(tmp1, Immediate(kIsInternalizedMask));
-  __ j(not_zero, &succeed1);
   __ cmpb(tmp1, static_cast<uint8_t>(SYMBOL_TYPE));
-  __ j(not_equal, &miss);
+  __ j(equal, &succeed1);
+  __ and_(tmp1, Immediate(kIsNotStringMask | kIsInternalizedMask));
+  __ cmpb(tmp1, kIsInternalizedMask | kStringTag);
+  __ j(not_equal, &miss, Label::kNear);
   __ bind(&succeed1);
 
   Label succeed2;
-  __ test(tmp2, Immediate(kIsInternalizedMask));
-  __ j(not_zero, &succeed2);
   __ cmpb(tmp2, static_cast<uint8_t>(SYMBOL_TYPE));
-  __ j(not_equal, &miss);
+  __ j(equal, &succeed2);
+  __ and_(tmp2, Immediate(kIsNotStringMask | kIsInternalizedMask));
+  __ cmpb(tmp2, kIsInternalizedMask | kStringTag);
+  __ j(not_equal, &miss, Label::kNear);
   __ bind(&succeed2);
 
   // Unique names are compared by identity.
@@ -6977,7 +6983,8 @@ void ICCompareStub::GenerateStrings(MacroAssembler* masm) {
 
   // Check that both strings are internalized. If they are, we're done
   // because we already know they are not identical.  But in the case of
-  // non-equality compare, we still need to determine the order.
+  // non-equality compare, we still need to determine the order. We
+  // also know they are both strings.
   if (equality) {
     Label do_compare;
     STATIC_ASSERT(kInternalizedTag != 0);
@@ -7136,12 +7143,15 @@ void NameDictionaryLookupStub::GenerateNegativeLookup(MacroAssembler* masm,
 
     // Check if the entry name is not a unique name.
     __ mov(entity_name, FieldOperand(entity_name, HeapObject::kMapOffset));
-    __ test_b(FieldOperand(entity_name, Map::kInstanceTypeOffset),
-              kIsInternalizedMask);
-    __ j(not_zero, &good);
     __ cmpb(FieldOperand(entity_name, Map::kInstanceTypeOffset),
             static_cast<uint8_t>(SYMBOL_TYPE));
-    __ j(not_equal, miss);
+    __ j(equal, &good);
+    __ test_b(FieldOperand(entity_name, Map::kInstanceTypeOffset),
+              kIsNotStringMask);
+    __ j(not_zero, miss);
+    __ test_b(FieldOperand(entity_name, Map::kInstanceTypeOffset),
+              kIsInternalizedMask);
+    __ j(zero, miss);
     __ bind(&good);
   }
 
@@ -7276,12 +7286,15 @@ void NameDictionaryLookupStub::Generate(MacroAssembler* masm) {
       // Check if the entry name is not a unique name.
       Label cont;
       __ mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
-      __ test_b(FieldOperand(scratch, Map::kInstanceTypeOffset),
-                kIsInternalizedMask);
-      __ j(not_zero, &cont);
       __ cmpb(FieldOperand(scratch, Map::kInstanceTypeOffset),
               static_cast<uint8_t>(SYMBOL_TYPE));
-      __ j(not_equal, &maybe_in_dictionary);
+      __ j(equal, &cont);
+      __ test_b(FieldOperand(scratch, Map::kInstanceTypeOffset),
+                kIsNotStringMask);
+      __ j(not_zero, &maybe_in_dictionary);
+      __ test_b(FieldOperand(scratch, Map::kInstanceTypeOffset),
+                kIsInternalizedMask);
+      __ j(zero, &maybe_in_dictionary);
       __ bind(&cont);
     }
   }