Make snapshots reproducible.

src/objects.h

 // 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 5178 matching lines @@
 
   // Find |length| handlers and put them into |code_list|. Returns false if not
   // enough handlers can be found.
   bool FindHandlers(CodeHandleList* code_list, int length = -1);
 
   // Find the first name in an IC stub.
   Name* FindFirstName();
 
   void ReplaceNthCell(int n, Cell* replace_with);
 
+  // Slightly ugly, used in ObjectSerializer only.

[Erik Corry, 2013/11/04 12:41:14]

Rather than insulting your own code it would be more helpful to spend a few
words explaining why it's needed.

[Sven Panne, 2013/11/04 13:03:19]

Well, that would just be yet another general v8 comment: What we are lacking
here again is a clear distinction between raw data structure manipulation and
some semantics layered upon that. I just want the "raw stuff" here.

Furthermore, from a more conceptual POV this doesn't really belong into the Code
class at all, it just lives here because we suffer from the common OOP problem
of the "tyranny of the hierarchy". Duplicating READ_FIELD/WRITE_FIELD in the
serializer would have been worse.

I am not sure how to put that into a non-insulting but enlightening comment...
:-)

[Erik Corry, 2013/11/04 13:20:02]

Let me suggest:

"The entire code object including its header is copied verbatim to the snapshot
so that it can be written in one, fast, memcpy during deserialization.  The
deserializer will overwrite some pointers, rather like a runtime linker, but the
random allocation addresses used in the mksnapshot process would still be
present in the unlinked snapshot data, which would make snapshot production
non-reproducible.  This method wipes out the to-be-overwritten header data for
reproducible snapshots."

+  inline void WipeOutHeader();
+
   class ExtraICStateStrictMode: public BitField<StrictModeFlag, 0, 1> {};
   class ExtraICStateKeyedAccessStoreMode:
       public BitField<KeyedAccessStoreMode, 1, 4> {};  // NOLINT
 
   static inline StrictModeFlag GetStrictMode(ExtraICState extra_ic_state) {
     return ExtraICStateStrictMode::decode(extra_ic_state);
   }
 
   static inline KeyedAccessStoreMode GetKeyedAccessStoreMode(
       ExtraICState extra_ic_state) {
@@ skipping 5231 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_