Remember to update the write barrier when storing into...

src/ia32/full-codegen-ia32.cc

 // Copyright 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 33 matching lines @@
 // formal parameter count expected by the function.
 //
 // The live registers are:
 //   o edi: the JS function object being called (ie, ourselves)
 //   o esi: our context
 //   o ebp: our caller's frame pointer
 //   o esp: stack pointer (pointing to return address)
 //
 // The function builds a JS frame.  Please see JavaScriptFrameConstants in
 // frames-ia32.h for its layout.
-void FullCodeGenerator::Generate(FunctionLiteral* fun, Mode mode) {
+void FullCodeGenerator::Generate(FunctionLiteral* fun', Mode mode) {

[Mads Ager (chromium), 2010/02/02 07:51:15]

Accidental edit?

[Lasse Reichstein, 2010/02/02 07:51:33]

Typo '.

   function_ = fun;
   SetFunctionPosition(fun);
 
   if (mode == PRIMARY) {
     __ push(ebp);  // Caller's frame pointer.
     __ mov(ebp, esp);
     __ push(esi);  // Callee's context.
     __ push(edi);  // Callee's JS Function.
 
     { Comment cmnt(masm_, "[ Allocate locals");
@@ skipping 23 matching lines @@
 
       // Copy parameters into context if necessary.
       int num_parameters = fun->scope()->num_parameters();
       for (int i = 0; i < num_parameters; i++) {
         Slot* slot = fun->scope()->parameter(i)->slot();
         if (slot != NULL && slot->type() == Slot::CONTEXT) {
           int parameter_offset = StandardFrameConstants::kCallerSPOffset +
                                      (num_parameters - 1 - i) * kPointerSize;
           // Load parameter from stack.
           __ mov(eax, Operand(ebp, parameter_offset));
-          // Store it in the context
-          __ mov(Operand(esi, Context::SlotOffset(slot->index())), eax);
+          // Store it in the context.
+          int context_offset = Context::SlotOffset(slot->index());
+          __ mov(Operand(esi, context_offset), eax);
+          // Update the write barrier. This clobbers all involved
+          // registers, so we have use a third register to avoid
+          // clobbering esi.
+          __ mov(ecx, esi);
+          __ RecordWrite(ecx, context_offset, eax, ebx);
         }
       }
     }
 
     Variable* arguments = fun->scope()->arguments()->AsVariable();
     if (arguments != NULL) {
       // Function uses arguments object.
       Comment cmnt(masm_, "[ Allocate arguments object");
       if (function_in_register) {
         __ push(edi);
       } else {
         __ push(Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
       }
       // Receiver is just before the parameters on the caller's stack.
       __ lea(edx, Operand(ebp, StandardFrameConstants::kCallerSPOffset +
-                                   fun->num_parameters() * kPointerSize));
+                          fun->num_parameters() * kPointerSize));
       __ push(edx);
       __ push(Immediate(Smi::FromInt(fun->num_parameters())));
       // Arguments to ArgumentsAccessStub:
       //   function, receiver address, parameter count.
       // The stub will rewrite receiver and parameter count if the previous
       // stack frame was an arguments adapter frame.
       ArgumentsAccessStub stub(ArgumentsAccessStub::NEW_OBJECT);
       __ CallStub(&stub);
       __ mov(ecx, eax);  // Duplicate result.
       Move(arguments->slot(), eax, ebx, edx);
@@ skipping 1759 matching lines @@
   __ add(Operand(edx), Immediate(masm_->CodeObject()));
   __ mov(Operand(esp, 0), edx);
   // And return.
   __ ret(0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal