Move IncrementalRecordWrite to a stub.

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 {
+ public:
+  IncrementalMarkingRecordWriteStub(Register object,
+                                    Register value,
+                                    Register scratch,
+                                    ObjectMode object_mode,
+                                    ValueMode value_mode,
+                                    ScratchMode scratch_mode)
+      : object_(object),
+        value_(value),
+        scratch_(scratch),
+        object_mode_(object_mode),
+        value_mode_(value_mode),
+        scratch_mode_(scratch_mode) {
+  }
+
+ private:
+  void Generate(MacroAssembler* masm);
+
+  Major MajorKey() { return IncrementalMarkingRecordWrite; }
+
+  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_);
+  }
+
+  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> {};
+
+  Register object_;
+  Register value_;
+  Register scratch_;
+  ObjectMode object_mode_;
+  ValueMode value_mode_;
+  ScratchMode scratch_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
 // unchanged throughout the generated code sequence.
 void GenerateFastPixelArrayLoad(MacroAssembler* masm,
                                 Register receiver,
@@ skipping 24 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_