Refactor embedded pointer visitors for the serializer

src/serialize.cc

 // Copyright 2011 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 1453 matching lines @@
       } else {
         serializer_->SerializeObject(current_contents, kPlain, kStartOfObject);
         bytes_processed_so_far_ += kPointerSize;
         current++;
       }
     }
   }
 }
 
 
+void Serializer::ObjectSerializer::VisitEmbeddedPointer(RelocInfo* rinfo) {
+  Object** current = rinfo->target_object_address();
+
+  if(!(*current)->IsSmi()) {

[Michael Starzinger, 2011/11/09 10:46:19]

Does the address actually ever get to be a SMI here? If yes, then I'm fine with
the check. Otherwise it should be removed.

+    OutputRawData(reinterpret_cast<Address>(rinfo->target_address_address()));

[Michael Starzinger, 2011/11/09 10:46:19]

No cast should be needed here.

+    HowToCode representation;
+    if(rinfo->IsCodedSpecially()) {

[Michael Starzinger, 2011/11/09 10:46:19]

Using the ternary operator here might make things more readable IMHO.

+      representation = kFromCode;
+    } else {
+      representation = kPlain;
+    }
+    serializer_->SerializeObject(*current, representation, kStartOfObject);
+    bytes_processed_so_far_ += rinfo->target_address_size();
+  }
+}
+
+
 void Serializer::ObjectSerializer::VisitExternalReferences(Address* start,
                                                            Address* end) {
   Address references_start = reinterpret_cast<Address>(start);
   OutputRawData(references_start);
 
   for (Address* current = start; current < end; current++) {
     sink_->Put(kExternalReference + kPlain + kStartOfObject, "ExternalRef");
     int reference_id = serializer_->EncodeExternalReference(*current);
     sink_->PutInt(reference_id, "reference id");
   }
   bytes_processed_so_far_ += static_cast<int>((end - start) * kPointerSize);
 }
 
 
+void Serializer::ObjectSerializer::VisitExternalReference(RelocInfo* rinfo) {
+  Address references_start =
+    reinterpret_cast<Address>(rinfo->target_address_address());

[Michael Starzinger, 2011/11/09 10:46:19]

No cast should be needed here.

+  OutputRawData(references_start);
+  Address* current =
+    reinterpret_cast<Address*>(rinfo->target_reference_address());

[Michael Starzinger, 2011/11/09 10:46:19]

No cast should be needed here.

+  int representation;
+  if(rinfo->IsCodedSpecially()) {

[Michael Starzinger, 2011/11/09 10:46:19]

Using the ternary operator here might make things more readable IMHO.

+    representation = kFromCode + kStartOfObject;
+  } else {
+    representation = kPlain + kStartOfObject;
+  }
+  sink_->Put(kExternalReference + representation, "ExternalRef");
+  int reference_id = serializer_->EncodeExternalReference(*current);
+  sink_->PutInt(reference_id, "reference id");
+  bytes_processed_so_far_ += rinfo->target_address_size();
+}
+
+
 void Serializer::ObjectSerializer::VisitRuntimeEntry(RelocInfo* rinfo) {
   Address target_start = rinfo->target_address_address();
   OutputRawData(target_start);
   Address target = rinfo->target_address();
   uint32_t encoding = serializer_->EncodeExternalReference(target);
   CHECK(target == NULL ? encoding == 0 : encoding != 0);
   int representation;
   // Can't use a ternary operator because of gcc.
   if (rinfo->IsCodedSpecially()) {
     representation = kStartOfObject + kFromCode;
@@ skipping 144 matching lines @@
       fullness_[space] = RoundUp(fullness_[space], Page::kPageSize);
     }
   }
   int allocation_address = fullness_[space];
   fullness_[space] = allocation_address + size;
   return allocation_address;
 }
 
 
 } }  // namespace v8::internal