Combine the incremental-marking write barrier and the remembered-set...

src/ia32/code-stubs-ia32.h

 // Copyright 2010 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 487 matching lines @@
   const char* GetName() { return "NumberToStringStub"; }
 
 #ifdef DEBUG
   void Print() {
     PrintF("NumberToStringStub\n");
   }
 #endif
 };
 
 
-class IncrementalMarkingRecordWriteStub: public CodeStub {
+class RecordWriteStub: public CodeStub {
  public:
-  IncrementalMarkingRecordWriteStub(Register object,
-                                    Register value,
-                                    Register scratch,
-                                    ObjectMode object_mode,
-                                    ValueMode value_mode,
-                                    ScratchMode scratch_mode)
+  RecordWriteStub(Register object,
+                  Register value,
+                  Register address,
+                  EmitRememberedSet emit_remembered_set,
+                  SaveFPRegsMode fp_mode)
       : object_(object),
         value_(value),
-        scratch_(scratch),
-        object_mode_(object_mode),
-        value_mode_(value_mode),
-        scratch_mode_(scratch_mode) {
+        address_(address),
+        emit_remembered_set_(emit_remembered_set),
+        save_fp_regs_mode_(fp_mode) {
   }
 
+  static const byte kTwoByteNopInstruction = 0x3c;           // Cmpb al, #imm8.
+  static const byte kSkipIncrementalPartInstruction = 0xeb;  // Jmp #imm8.
 
   static byte GetInstruction(bool enable) {
-    static const byte kNopInstruction = 0x90;
-    static const byte kRet0Instruction = 0xc3;
-    return enable ? kNopInstruction : kRet0Instruction;
+    // Can't use ternary operator here, because gcc makes an undefined
+    // reference to a static const int.
+    if (enable) {
+      return kTwoByteNopInstruction;
+    } else {
+      return kSkipIncrementalPartInstruction;
+    }
   }
 
   static void Patch(Code* stub, bool enable) {
     ASSERT(*stub->instruction_start() == GetInstruction(!enable));
     *stub->instruction_start() = GetInstruction(enable);
   }
 
  private:
   void Generate(MacroAssembler* masm);
 
-  Major MajorKey() { return IncrementalMarkingRecordWrite; }
+  Major MajorKey() { return RecordWrite; }
 
   int MinorKey() {
     return ObjectBits::encode(object_.code()) |
         ValueBits::encode(value_.code()) |
-        ScratchBits::encode(scratch_.code()) |
-        ObjectModeBits::encode(object_mode_) |
-        ValueModeBits::encode(value_mode_) |
-        ScratchModeBits::encode(scratch_mode_);
+        AddressBits::encode(address_.code()) |
+        EmitRememberedSetBits::encode(emit_remembered_set_) |
+        SaveFPRegsModeBits::encode(save_fp_regs_mode_);
   }
 
   class ObjectBits: public BitField<int, 0, 3> {};
   class ValueBits: public BitField<int, 3, 3> {};
-  class ScratchBits: public BitField<int, 6, 3> {};
-  class ObjectModeBits: public BitField<ObjectMode, 9, 1> {};
-  class ValueModeBits: public BitField<ValueMode, 10, 1> {};
-  class ScratchModeBits: public BitField<ScratchMode, 11, 1> {};
+  class AddressBits: public BitField<int, 6, 3> {};
+  class EmitRememberedSetBits: public BitField<EmitRememberedSet, 9, 1> {};
+  class SaveFPRegsModeBits: public BitField<SaveFPRegsMode, 10, 1> {};
 
   Register object_;
   Register value_;
-  Register scratch_;
-  ObjectMode object_mode_;
-  ValueMode value_mode_;
-  ScratchMode scratch_mode_;
+  Register address_;
+  EmitRememberedSet emit_remembered_set_;
+  SaveFPRegsMode save_fp_regs_mode_;
 };
 
 
 // Generate code to load an element from a pixel array. The receiver is assumed
 // to not be a smi and to have elements, the caller must guarantee this
 // precondition. If key is not a smi, then the generated code branches to
 // key_not_smi. Callers can specify NULL for key_not_smi to signal that a smi
 // check has already been performed on key so that the smi check is not
 // generated. If key is not a valid index within the bounds of the pixel array,
 // the generated code jumps to out_of_range. receiver, key and elements are
@@ skipping 27 matching lines @@
                                  Register scratch1,
                                  bool load_elements_from_receiver,
                                  Label* key_not_smi,
                                  Label* value_not_smi,
                                  Label* not_pixel_array,
                                  Label* out_of_range);
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_CODE_STUBS_IA32_H_