Fix crash in partial snapshot test when running with no boot snapshot.

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 739 matching lines @@
     dest_space = isolate->heap()->lo_space();                                  \
   }
 
 
 static const int kUnknownOffsetFromStart = -1;
 
 
 void Deserializer::ReadChunk(Object** current,
                              Object** limit,
                              int source_space,
                              Address address) {

[Lasse Reichstein, 2011/10/24 12:06:58]

When is address passed as NULL?
Why?
I.e., please put some documentation on this function in the .h file - at least
what the parameters mean and what values they may assume.

   Isolate* const isolate = isolate_;
   while (current < limit) {
     int data = source_->Get();
     switch (data) {
 #define CASE_STATEMENT(where, how, within, space_number)                       \
       case where + how + within + space_number:                                \
       ASSERT((where & ~kPointedToMask) == 0);                                  \
       ASSERT((how & ~kHowToCodeMask) == 0);                                    \
       ASSERT((within & ~kWhereToPointMask) == 0);                              \
       ASSERT((space_number & ~kSpaceMask) == 0);
@@ skipping 27 matching lines @@
             if (source_space != CELL_SPACE &&                                  \
                 source_space != CODE_SPACE &&                                  \
                 source_space != OLD_DATA_SPACE) {                              \
               emit_write_barrier = true;                                       \
             }                                                                  \
             int cache_index = source_->GetInt();                               \
             new_object = isolate->serialize_partial_snapshot_cache()           \
                 [cache_index];                                                 \
           } else if (where == kExternalReference) {                            \
             int reference_id = source_->GetInt();                              \
             Address address = external_reference_decoder_->                    \

[Lasse Reichstein, 2011/10/24 12:06:58]

Could we call this variable something else, so it doesn't have the same name as
the function parameter.

                 Decode(reference_id);                                          \
             new_object = reinterpret_cast<Object*>(address);                   \
           } else if (where == kBackref) {                                      \
             emit_write_barrier = (space_number == NEW_SPACE &&                 \
                                   source_space != NEW_SPACE &&                 \
                                   source_space != CELL_SPACE);                 \
             new_object = GetAddressFromEnd(data & kSpaceMask);                 \
           } else {                                                             \
             ASSERT(where == kFromStart);                                       \
             if (offset_from_start == kUnknownOffsetFromStart) {                \
@@ skipping 19 matching lines @@
                                      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;                                             \
           }                                                                    \
         }                                                                      \
-        if (emit_write_barrier) {                                              \
+        if (emit_write_barrier && address != NULL) {                           \
           isolate->heap()->RecordWrite(address, static_cast<int>(              \
               reinterpret_cast<Address>(current) - address));                  \
         }                                                                      \
         if (!current_was_incremented) {                                        \
           current++;   /* Increment current if it wasn't done above. */        \
         }                                                                      \
         break;                                                                 \
       }                                                                        \
 
 // This generates a case and a body for each space.  The large object spaces are
@@ skipping 790 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