Fix debugger after inlined keyed store change....

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 5731 matching lines @@
  public:
   DeferredReferenceSetKeyedValue(Register value,
                                  Register key,
                                  Register receiver)
       : value_(value), key_(key), receiver_(receiver) {
     set_comment("[ DeferredReferenceSetKeyedValue");
   }
 
   virtual void Generate();
 
+  Label* patch_site() { return &patch_site_; }
+
  private:
   Register value_;
   Register key_;
   Register receiver_;
+  Label patch_site_;
 };
 
 
 void DeferredReferenceSetKeyedValue::Generate() {
   __ IncrementCounter(&Counters::keyed_store_inline_miss, 1);
   // Push receiver and key arguments on the stack.
   __ push(receiver_);
   __ push(key_);
   // Move value argument to eax as expected by the IC stub.
   if (!value_.is(eax)) __ mov(eax, value_);
   // Call the IC stub.
   Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
+  // The delta from the start of the map-compare instruction to the
+  // test instruction.  We use masm_-> directly here instead of the
+  // __ macro because the macro sometimes uses macro expansion to turn
+  // into something that can't return a value.  This is encountered
+  // when doing generated code coverage tests.
+  int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
+  // Here we use masm_-> instead of the __ macro because this is the

[Søren Thygesen Gjesse, 2009/06/12 11:15:29]

Maybe loose this comment as it is already in the comment above.

+  // instruction that gets patched and coverage code gets in the way.
+  masm_->test(eax, Immediate(-delta_to_patch_site));
   // Restore value (returned from store IC), key and receiver
   // registers.
   if (!value_.is(eax)) __ mov(value_, eax);
   __ pop(key_);
   __ pop(receiver_);
 }
 
 
 #undef __
 #define __ ACCESS_MASM(masm)
@@ skipping 336 matching lines @@
         // Check that the key is within bounds.  Both the key and the
         // length of the JSArray are smis.
         __ cmp(key.reg(),
                FieldOperand(receiver.reg(), JSArray::kLengthOffset));
         deferred->Branch(greater_equal);
 
         // Get the elements array from the receiver and check that it
         // is not a dictionary.
         __ mov(tmp.reg(),
                FieldOperand(receiver.reg(), JSObject::kElementsOffset));
+        // Bind the deferred code patch site to be able to locate the
+        // fixed array map comparison.  When debugging, we patch this
+        // comparison to always fail so that we will hit the IC call
+        // in the deferred code which will allow the debugger to
+        // break for fast case stores.
+        __ bind(deferred->patch_site());
         __ cmp(FieldOperand(tmp.reg(), HeapObject::kMapOffset),
-                           Immediate(Factory::hash_table_map()));
-        deferred->Branch(equal);
+               Immediate(Factory::fixed_array_map()));
+        deferred->Branch(not_equal);
 
         // Store the value.
         __ mov(Operand(tmp.reg(),
                        key.reg(),
                        times_2,
                        Array::kHeaderSize - kHeapObjectTag),
                value.reg());
         __ IncrementCounter(&Counters::keyed_store_inline, 1);
 
         deferred->BindExit();
 
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&key);
         cgen_->frame()->Push(&value);
       } else {
         Result answer = cgen_->frame()->CallKeyedStoreIC();
+        // Make sure that we do not have a test instruction after the
+        // call.  A test instruction after the call is used to
+        // indicate that we have generated an inline version of the
+        // keyed store.
+        __ nop();
         cgen_->frame()->Push(&answer);
       }
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
@@ skipping 1300 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal