Unbreak IA32 generated code coverage.

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 5247 matching lines @@
   CodeGenerator* cgen = generator();
   Result receiver(cgen);
   enter()->Bind(&receiver);
 
   cgen->frame()->Push(&receiver);
   cgen->frame()->Push(name_);
   Result answer = cgen->frame()->CallLoadIC(RelocInfo::CODE_TARGET);
   // The call must be followed by a test eax instruction to indicate
   // that the inobject property case was inlined.
   ASSERT(answer.is_register() && answer.reg().is(eax));
-  // Store the delta to the map check instruction here in the test
-  // instruction.
-  int delta_to_patch_site = __ SizeOfCodeGeneratedSince(patch_site());
+  // Store the delta to the map check instruction here in the test instruction.
+  // Use masm_-> instead of the double underscore macro since the latter can't
+  // return a value.
+  int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   // Here we use masm_-> instead of the double underscore macro because
   // this is the instruction that gets patched and coverage code gets in
   // the way.
   masm_->test(answer.reg(), Immediate(-delta_to_patch_site));
   __ IncrementCounter(&Counters::named_load_inline_miss, 1);
   receiver = cgen->frame()->Pop();
   exit_.Jump(&receiver, &answer);
 }
 
 
@@ skipping 129 matching lines @@
         deferred->enter()->Branch(zero, &receiver, not_taken);
 
         // Preallocate the value register to ensure that there is no
         // spill emitted between the patch site label and the offset in
         // the load instruction.
         Result value = cgen_->allocator()->Allocate();
         ASSERT(value.is_valid());
         __ bind(deferred->patch_site());
         // This is the map check instruction that will be patched.
         // Initially use an invalid map to force a failure.
-        __ cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
-               Immediate(Factory::null_value()));
+        masm->cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
+                  Immediate(Factory::null_value()));
+        // This branch is always a forwards branch so it's always a fixed
+        // size which allows the assert below to succeed and patching to work.

[William Hesse, 2009/04/29 09:56:46]

Should you explain the motivation for these other uses of masm, that __ can emit
additional instructions in debug or profiling modes?

         deferred->enter()->Branch(not_equal, &receiver, not_taken);
 
         // The delta from the patch label to the load offset must be
         // statically known.
         ASSERT(masm->SizeOfCodeGeneratedSince(deferred->patch_site()) ==
                LoadIC::kOffsetToLoadInstruction);
         // The initial (invalid) offset has to be large enough to force
         // a 32-bit instruction encoding to allow patching with an
         // arbitrary offset.  Use kMaxInt (minus kHeapObjectTag).
         int offset = kMaxInt;
-        __ mov(value.reg(), FieldOperand(receiver.reg(), offset));
+        masm->mov(value.reg(), FieldOperand(receiver.reg(), offset));
 
         __ IncrementCounter(&Counters::named_load_inline, 1);
         deferred->BindExit(&receiver, &value);
         cgen_->frame()->Push(&receiver);
         cgen_->frame()->Push(&value);
       }
       break;
     }
 
     case KEYED: {
@@ skipping 1770 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal