MIPS: Enable serialization for MIPS architecture.

src/serialize.cc

 // Copyright 2012 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 743 matching lines @@
   } else if (space_number == CELL_SPACE) {                                     \
     dest_space = isolate->heap()->cell_space();                                \
   } else {                                                                     \
     ASSERT(space_number >= LO_SPACE);                                          \
     dest_space = isolate->heap()->lo_space();                                  \
   }
 
 
 static const int kUnknownOffsetFromStart = -1;
 
+#ifdef V8_TARGET_ARCH_MIPS
+#define PATCH_SITE_ADJUST(addr)                                                \
+  (addr - 3 * kPointerSize)
+#else
+#define PATCH_SITE_ADJUST(addr)                                                \
+  (addr)
+#endif
+
 
 void Deserializer::ReadChunk(Object** current,
                              Object** limit,
                              int source_space,
                              Address current_object_address) {
   Isolate* const isolate = isolate_;
   bool write_barrier_needed = (current_object_address != NULL &&
                                source_space != NEW_SPACE &&
                                source_space != CELL_SPACE &&
                                source_space != CODE_SPACE &&
@@ skipping 52 matching lines @@
             }                                                                  \
           }                                                                    \
           if (within == kFirstInstruction) {                                   \
             Code* new_code_object = reinterpret_cast<Code*>(new_object);       \
             new_object = reinterpret_cast<Object*>(                            \
                 new_code_object->instruction_start());                         \
           }                                                                    \
           if (how == kFromCode) {                                              \
             Address location_of_branch_data =                                  \
                 reinterpret_cast<Address>(current);                            \
-            Assembler::set_target_at(location_of_branch_data,                  \
+            Address patch_site = PATCH_SITE_ADJUST(location_of_branch_data);   \
+            if (patch_site != location_of_branch_data) {                       \
+              current_was_incremented = true;                                  \
+            }                                                                  \
+            Assembler::set_target_at(patch_site,                               \
                                      reinterpret_cast<Address>(new_object));   \
             if (within == kFirstInstruction) {                                 \
               location_of_branch_data += Assembler::kCallTargetSize;           \
               current = reinterpret_cast<Object**>(location_of_branch_data);   \
               current_was_incremented = true;                                  \
             }                                                                  \
           } else {                                                             \
             *current = new_object;                                             \
           }                                                                    \
         }                                                                      \
@@ skipping 113 matching lines @@
         Object* object = current[-1];
         ASSERT(!isolate->heap()->InNewSpace(object));
         for (int i = 0; i < repeats; i++) current[i] = object;
         current += repeats;
         break;
       }
 
       // Deserialize a new object and write a pointer to it to the current
       // object.
       ONE_PER_SPACE(kNewObject, kPlain, kStartOfObject)
+      // Deserialize a new object from pointer found in code and write
+      // a pointer to it to the current object. Required only for MIPS.
+#if V8_TARGET_ARCH_MIPS
+      ONE_PER_SPACE(kNewObject, kFromCode, kStartOfObject)
+#endif
       // Support for direct instruction pointers in functions
       ONE_PER_CODE_SPACE(kNewObject, kPlain, kFirstInstruction)
       // Deserialize a new code object and write a pointer to its first
       // instruction to the current code object.
       ONE_PER_SPACE(kNewObject, kFromCode, kFirstInstruction)
       // Find a recently deserialized object using its offset from the current
       // allocation point and write a pointer to it to the current object.
       ALL_SPACES(kBackref, kPlain, kStartOfObject)
       // Find a recently deserialized code object using its offset from the
+      // current allocation point and write a pointer to it to the current
+      // object. Required only for MIPS.
+      ALL_SPACES(kBackref, kFromCode, kStartOfObject)
+      // Find a recently deserialized code object using its offset from the
       // current allocation point and write a pointer to its first instruction
       // to the current code object or the instruction pointer in a function
       // object.
       ALL_SPACES(kBackref, kFromCode, kFirstInstruction)
       ALL_SPACES(kBackref, kPlain, kFirstInstruction)
       // Find an already deserialized object using its offset from the start
       // and write a pointer to it to the current object.
       ALL_SPACES(kFromStart, kPlain, kStartOfObject)
       ALL_SPACES(kFromStart, kPlain, kFirstInstruction)
       // Find an already deserialized code object using its offset from the
       // start and write a pointer to its first instruction to the current code
       // object.
       ALL_SPACES(kFromStart, kFromCode, kFirstInstruction)
+      // Find an already deserialized code object using its offset from
+      // the start and write a pointer to it to the current object.
+      // Required only for MIPS.
+      ALL_SPACES(kFromStart, kFromCode, kStartOfObject)
       // Find an object in the roots array and write a pointer to it to the
       // current object.
       CASE_STATEMENT(kRootArray, kPlain, kStartOfObject, 0)
       CASE_BODY(kRootArray, kPlain, kStartOfObject, 0, kUnknownOffsetFromStart)
       // Find an object in the partial snapshots cache and write a pointer to it
       // to the current object.
       CASE_STATEMENT(kPartialSnapshotCache, kPlain, kStartOfObject, 0)
       CASE_BODY(kPartialSnapshotCache,
                 kPlain,
                 kStartOfObject,
@@ skipping 656 matching lines @@
 int Serializer::SpaceAreaSize(int space) {
   if (space == CODE_SPACE) {
     return isolate_->memory_allocator()->CodePageAreaSize();
   } else {
     return Page::kPageSize - Page::kObjectStartOffset;
   }
 }
 
 
 } }  // namespace v8::internal