NewGC: Merge bleeding edge up to 9009.

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, Heap::kUndefinedValueRootIndex, false, &patch);
+  CheckOddball(masm, UNDEFINED, Heap::kUndefinedValueRootIndex, false);
 
   // Boolean -> its value
-  CheckOddball(masm, BOOLEAN, Heap::kFalseValueRootIndex, false, &patch);
-  CheckOddball(masm, BOOLEAN, Heap::kTrueValueRootIndex, true, &patch);
+  CheckOddball(masm, BOOLEAN, Heap::kFalseValueRootIndex, false);
+  CheckOddball(masm, BOOLEAN, Heap::kTrueValueRootIndex, true);
 
   // 'null' -> false.
-  CheckOddball(masm, NULL_TYPE, Heap::kNullValueRootIndex, false, &patch);
+  CheckOddball(masm, NULL_TYPE, Heap::kNullValueRootIndex, false);
 
   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
+    // argument contains the correct return value already.
     if (!tos_.is(argument)) {
       __ mov(tos_, argument);
     }
     __ ret(1 * kPointerSize);
     __ bind(&not_smi);
   } else if (types_.NeedsMap()) {
     // If we need a map later and have a Smi -> patch.
     __ JumpIfSmi(argument, &patch, Label::kNear);
   }
 
   if (types_.NeedsMap()) {
     __ 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);
-    // Undetectable -> false.
-    Label not_undetectable;
-    __ j(zero, &not_undetectable, Label::kNear);
-    __ Set(tos_, Immediate(0));
-    __ ret(1 * kPointerSize);
-    __ bind(&not_undetectable);
+    if (types_.CanBeUndetectable()) {
+      __ test_b(FieldOperand(map, Map::kBitFieldOffset),
+                1 << Map::kIsUndetectable);
+      // 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));
+    // argument contains the correct return value already.
+    if (!tos_.is(argument)) {
+      __ Set(tos_, Immediate(1));
+    }
     __ ret(1 * kPointerSize);
     __ bind(&not_js_object);
-  } else if (types_.Contains(INTERNAL_OBJECT)) {
-    // We've seen a spec object for the first time -> patch.
-    __ CmpInstanceType(map, FIRST_SPEC_OBJECT_TYPE);
-    __ j(above_equal, &patch, Label::kNear);
   }
 
   if (types_.Contains(STRING)) {
     // String value -> false iff empty.
     Label not_string;
     __ CmpInstanceType(map, FIRST_NONSTRING_TYPE);
     __ j(above_equal, &not_string, Label::kNear);
     __ mov(tos_, FieldOperand(argument, String::kLengthOffset));
     __ ret(1 * kPointerSize);  // the string length is OK as the return value
     __ bind(&not_string);
-  } else if (types_.Contains(INTERNAL_OBJECT)) {
-    // We've seen a string for the first time -> patch
-    __ CmpInstanceType(map, FIRST_NONSTRING_TYPE);
-    __ j(below, &patch, Label::kNear);
   }
 
   if (types_.Contains(HEAP_NUMBER)) {
     // heap number -> false iff +0, -0, or NaN.
     Label not_heap_number, false_result;
     __ cmp(map, factory->heap_number_map());
     __ j(not_equal, &not_heap_number, Label::kNear);
     __ fldz();
     __ fld_d(FieldOperand(argument, HeapNumber::kValueOffset));
     __ FCmp();
     __ j(zero, &false_result, Label::kNear);
-    __ Set(tos_, Immediate(1));
+    // argument contains the correct return value already.
+    if (!tos_.is(argument)) {
+      __ Set(tos_, Immediate(1));
+    }
     __ ret(1 * kPointerSize);
     __ bind(&false_result);
     __ Set(tos_, Immediate(0));
     __ ret(1 * kPointerSize);
     __ bind(&not_heap_number);
-  } else if (types_.Contains(INTERNAL_OBJECT)) {
-    // We've seen a heap number for the first time -> patch
-    __ cmp(map, factory->heap_number_map());
-    __ j(equal, &patch, Label::kNear);
   }
 
-  if (types_.Contains(INTERNAL_OBJECT)) {
-    // internal objects -> true
-    __ Set(tos_, Immediate(1));
-    __ ret(1 * kPointerSize);
-  }
-
-  if (!types_.IsAll()) {
-    __ bind(&patch);
-    GenerateTypeTransition(masm);
-  }
+  __ bind(&patch);
+  GenerateTypeTransition(masm);
 }
 
 
 void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
   // We don't allow a GC during a store buffer overflow so there is no need to
   // store the registers in any particular way, but we do have to store and
   // restore them.
   __ pushad();
   if (save_doubles_ == kSaveFPRegs) {
     CpuFeatures::Scope scope(SSE2);
@@ skipping 19 matching lines @@
     __ add(Operand(esp), Immediate(kDoubleSize * XMMRegister::kNumRegisters));
   }
   __ popad();
   __ ret(0);
 }
 
 
 void ToBooleanStub::CheckOddball(MacroAssembler* masm,
                                  Type type,
                                  Heap::RootListIndex value,
-                                 bool result,
-                                 Label* patch) {
+                                 bool result) {
   const Register argument = eax;
   if (types_.Contains(type)) {
     // If we see an expected oddball, return its ToBoolean value tos_.
     Label different_value;
     __ CompareRoot(argument, value);
     __ j(not_equal, &different_value, Label::kNear);
-    __ Set(tos_, Immediate(result ? 1 : 0));
+    if (!result) {
+      // If we have to return zero, there is no way around clearing tos_.
+      __ Set(tos_, Immediate(0));
+    } else if (!tos_.is(argument)) {
+      // If we have to return non-zero, we can re-use the argument if it is the
+      // same register as the result, because we never see Smi-zero here.
+      __ Set(tos_, Immediate(1));
+    }
     __ 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.
-    __ 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.
   // Patch the caller to an appropriate specialized stub and return the
@@ skipping 6185 matching lines @@
 
   // Fall through when we need to inform the incremental marker.
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32