Contribution of PowerPC port (continuation of 422063005) - AIX Common1

src/serialize.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 881 matching lines @@
 
   Object* write_back_obj = obj;
   UnalignedCopy(write_back, &write_back_obj);
 #ifdef DEBUG
   if (obj->IsCode()) {
     DCHECK(space_number == CODE_SPACE || space_number == LO_SPACE);
   } else {
     DCHECK(space_number != CODE_SPACE);
   }
 #endif
+#if V8_TARGET_ARCH_PPC && \
+    (ABI_USES_FUNCTION_DESCRIPTORS || V8_OOL_CONSTANT_POOL)
+  // If we're on a platform that uses function descriptors
+  // these jump tables make use of RelocInfo::INTERNAL_REFERENCE.
+  // As the V8 serialization code doesn't handle that relocation type
+  // we use this to fix up code that has function descriptors.
+  if (space_number == CODE_SPACE) {
+    Code* code = reinterpret_cast<Code*>(HeapObject::FromAddress(address));
+    for (RelocIterator it(code); !it.done(); it.next()) {
+      RelocInfo::Mode rmode = it.rinfo()->rmode();
+      if (rmode == RelocInfo::INTERNAL_REFERENCE) {

[Yang, 2015/02/06 07:08:14]

I'm quite puzzled by this. It is true that V8 currently does not use
INTERNAL_REFERENCE. This however may change soon if we decide to implement jump
tables. I'm currently looking at ways to implement serialization in a
generalized way.

I think what you are assuming here is that every INTERNAL_REFERENCE in PPC code
is a function descriptor (if I understood correctly, a pointer to self), so you
simply go through all internal references and replace them by the updated self
pointer.

This would not work for arbitrary internal references, and I think this should
be solved differently.

Furthermore, adding this piece of platform-dependent code here is bad style.

[michael_dawson, 2015/02/06 23:06:35]

We are not surprised that there are some comments on this change.  If there is a
general
solution for INTERNAL_REFERENCE type (which it sounds like you are working on)
we expect 
that our code would be subsumed by the general case and our platform specific
code would be removed.  
If there are not already plans to have a general solution we could work to
generalize what we
have or move it to the PPC specific directories but we'd need some additional 
guidance/suggestions before starting on that. 

+        Assembler::RelocateInternalReference(it.rinfo()->pc(), 0,
+                                             code->instruction_start());
+      }
+    }
+  }
+#endif
 }
 
 
 // We know the space requirements before deserialization and can
 // pre-allocate that reserved space. During deserialization, all we need
 // to do is to bump up the pointer for each space in the reserved
 // space. This is also used for fixing back references.
 // We may have to split up the pre-allocation into several chunks
 // because it would not fit onto a single page. We do not have to keep
 // track of when to move to the next chunk. An opcode will signal this.
@@ skipping 1636 matching lines @@
   return GetHeaderValue(kNumInternalizedStringsOffset);
 }
 
 Vector<const uint32_t> SerializedCodeData::CodeStubKeys() const {
   int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
   const byte* start = data_ + kHeaderSize + reservations_size;
   return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
                                 GetHeaderValue(kNumCodeStubKeysOffset));
 }
 } }  // namespace v8::internal