Do not explicitly record undetectable objects in the ToBoolean stub.

src/ia32/code-stubs-ia32.cc

 // 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 241 matching lines @@
   CheckOddball(masm, UNDEFINED, factory->undefined_value(), false, &patch);
 
   // Boolean -> its value
   CheckOddball(masm, BOOLEAN, factory->false_value(), false, &patch);
   CheckOddball(masm, BOOLEAN, factory->true_value(), true, &patch);
 
   // 'null' -> false.
   CheckOddball(masm, NULL_TYPE, factory->null_value(), false, &patch);
 
   bool need_map =
-      types_.Contains(UNDETECTABLE) |
       types_.Contains(SPEC_OBJECT) |
       types_.Contains(STRING) |
       types_.Contains(HEAP_NUMBER) |
       types_.Contains(INTERNAL_OBJECT);
 
   if (types_.Contains(SMI)) {
     // Smis: 0 -> false, all other -> true
     Label not_smi;
     __ JumpIfNotSmi(argument, &not_smi, Label::kNear);
     // argument contains the correct return value already
     if (!tos_.is(argument)) {
       __ mov(tos_, argument);
     }
     __ ret(1 * kPointerSize);
     __ bind(&not_smi);
   } else if (need_map) {
     // If we need a map later and have a Smi -> patch.
     __ JumpIfSmi(argument, &patch, Label::kNear);
   }
 
   if (need_map) {
     __ mov(map, FieldOperand(argument, HeapObject::kMapOffset));
 
     // Everything with a map could be undetectable, so check this now.
     __ test_b(FieldOperand(map, Map::kBitFieldOffset),
               1 << Map::kIsUndetectable);
-    if (types_.Contains(UNDETECTABLE)) {
-      // Undetectable -> false.
-      Label not_undetectable;
-      __ j(zero, &not_undetectable, Label::kNear);
-      __ Set(tos_, Immediate(0));
-      __ ret(1 * kPointerSize);
-      __ bind(&not_undetectable);
-    } else {
-      // We've seen an undetectable value for the first time -> patch.
-      __ j(not_zero, &patch, Label::kNear);
-    }
+    // Undetectable -> false.
+    Label not_undetectable;
+    __ j(zero, &not_undetectable, Label::kNear);
+    __ Set(tos_, Immediate(0));
+    __ ret(1 * kPointerSize);
+    __ bind(&not_undetectable);
   }
 
   if (types_.Contains(SPEC_OBJECT)) {
     // spec object -> true.
     Label not_js_object;
     __ CmpInstanceType(map, FIRST_SPEC_OBJECT_TYPE);
     __ j(below, &not_js_object, Label::kNear);
     __ Set(tos_, Immediate(1));
     __ ret(1 * kPointerSize);
     __ bind(&not_js_object);
@@ skipping 68 matching lines @@
     // patch because the code for internal objects doesn't handle it explictly.
     __ cmp(argument, value);
     __ j(equal, patch);
   }
 }
 
 
 void ToBooleanStub::GenerateTypeTransition(MacroAssembler* masm) {
   __ pop(ecx);  // Get return address, operand is now on top of stack.
   __ push(Immediate(Smi::FromInt(tos_.code())));
-  __ push(Immediate(Smi::FromInt(types_.ToInt())));
+  __ push(Immediate(Smi::FromInt(types_.ToByte())));
   __ push(ecx);  // Push return address.
   // Patch the caller to an appropriate specialized stub and return the
   // operation result to the caller of the stub.
   __ TailCallExternalReference(
       ExternalReference(IC_Utility(IC::kToBoolean_Patch), masm->isolate()),
       3,
       1);
 }
 
 
@@ skipping 5988 matching lines @@
   __ Drop(1);
   __ ret(2 * kPointerSize);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32