Implement type recording for ToBoolean on x64.

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 231 matching lines @@
   Label patch;
   Factory* factory = masm->isolate()->factory();
   const Register argument = eax;
   const Register map = edx;
 
   if (!types_.IsEmpty()) {
     __ mov(argument, Operand(esp, 1 * kPointerSize));
   }
 
   // undefined -> false
-  CheckOddball(masm, UNDEFINED, factory->undefined_value(), false, &patch);
+  CheckOddball(masm, UNDEFINED, Heap::kUndefinedValueRootIndex, false, &patch);
 
   // Boolean -> its value
-  CheckOddball(masm, BOOLEAN, factory->false_value(), false, &patch);
-  CheckOddball(masm, BOOLEAN, factory->true_value(), true, &patch);
+  CheckOddball(masm, BOOLEAN, Heap::kFalseValueRootIndex, false, &patch);
+  CheckOddball(masm, BOOLEAN, Heap::kTrueValueRootIndex, true, &patch);
 
-  // 'null' -> false.
-  CheckOddball(masm, NULL_TYPE, factory->null_value(), false, &patch);
+  // 'null' -> false.!!!

[Kevin Millikin (Chromium), 2011/08/01 13:02:05]

Don't be so surprised, it's JavaScript :)

[Sven Panne, 2011/08/01 13:13:25]

Ooops, a leftover from a previous debugging session... :-}

+  CheckOddball(masm, NULL_TYPE, Heap::kNullValueRootIndex, false, &patch);
 
   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);
@@ skipping 74 matching lines @@
 
   if (!types_.IsAll()) {
     __ bind(&patch);
     GenerateTypeTransition(masm);
   }
 }
 
 
 void ToBooleanStub::CheckOddball(MacroAssembler* masm,
                                  Type type,
-                                 Handle<Object> value,
+                                 Heap::RootListIndex value,
                                  bool result,
                                  Label* patch) {
   const Register argument = eax;
   if (types_.Contains(type)) {
     // If we see an expected oddball, return its ToBoolean value tos_.
     Label different_value;
-    __ cmp(argument, value);
+    __ CompareRoot(argument, value);
     __ j(not_equal, &different_value, Label::kNear);
     __ Set(tos_, Immediate(result ? 1 : 0));
     __ ret(1 * kPointerSize);
     __ bind(&different_value);
   } else if (types_.Contains(INTERNAL_OBJECT)) {
     // If we see an unexpected oddball and handle internal objects, we must
     // patch because the code for internal objects doesn't handle it explictly.
-    __ cmp(argument, value);
+    __ CompareRoot(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_.ToByte())));
   __ push(ecx);  // Push return address.
@@ skipping 5997 matching lines @@
   __ Drop(1);
   __ ret(2 * kPointerSize);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32