Introduce code serializer/deserializer.

src/serialize.h

 // 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.
 
 #ifndef V8_SERIALIZE_H_
 #define V8_SERIALIZE_H_
 
 #include "src/hashmap.h"
 #include "src/heap-profiler.h"
 #include "src/isolate.h"
+#include "src/parser.h"

[vogelheim, 2014/07/07 15:20:01]

parser.h draws in a rather large amount of headers. If we really want to re-use
CachedData, it may make sense to move it out of parser.h.

(As you already mentioned offline, doing this later is just fine.)

[Yang, 2014/07/08 09:01:05]

Yup. Doing this later.

 #include "src/snapshot-source-sink.h"
 
 namespace v8 {
 namespace internal {
 
 // A TypeCode is used to distinguish different kinds of external reference.
 // It is a single bit to make testing for types easy.
 enum TypeCode {
   UNCLASSIFIED,        // One-of-a-kind references.
   BUILTIN,
@@ skipping 441 matching lines @@
   Isolate* isolate_;
   // Keep track of the fullness of each space in order to generate
   // relative addresses for back references.
   int fullness_[LAST_SPACE + 1];
   SnapshotByteSink* sink_;
   ExternalReferenceEncoder* external_reference_encoder_;
 
   SerializationAddressMapper address_mapper_;
   intptr_t root_index_wave_front_;
   void Pad();
+  void PadByte();
 
   friend class ObjectSerializer;
   friend class Deserializer;
 
   // We may not need the code address map for logging for every instance
   // of the serializer.  Initialize it on demand.
   void InitializeCodeAddressMap();
 
  private:
   CodeAddressMap* code_address_map_;
@@ skipping 62 matching lines @@
                                int skip);
   void SerializeWeakReferences();
   void Serialize() {
     SerializeStrongReferences();
     SerializeWeakReferences();
     Pad();
   }
 };
 
 
+class CodeSerializer : public Serializer {
+ public:
+  CodeSerializer(Isolate* isolate, SnapshotByteSink* sink)
+      : Serializer(isolate, sink) {
+    set_root_index_wave_front(Heap::kStrongRootListLength);
+    InitializeCodeAddressMap();
+  }
+
+  static ScriptData* Serialize(Handle<SharedFunctionInfo> info);
+  virtual void SerializeObject(Object* o, HowToCode how_to_code,
+                               WhereToPoint where_to_point, int skip);
+
+  static Object* Deserialize(Isolate* isolate, ScriptData* data);
+
+  // The data header consists of
+  // [0] version hash

[vogelheim, 2014/07/07 15:20:01]

nitpick: It took me a while to understand these are indices into a int-sized
array; not byte offsets. Might be useful to mention this.

[Yang, 2014/07/08 09:01:05]

Done.

+  // [1] length in bytes
+  // [2..8] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE.
+  static const int kHeaderSize = 9;
+  static const int kVersionHashOffset = 0;
+  static const int kPayloadLengthOffset = 1;
+  static const int kReservationsOffset = 2;
+};
+
+
+class DummySnapshotSink : public SnapshotByteSink {

[vogelheim, 2014/07/07 15:20:01]

If these (and the following) *Sinks are of general use, it may be useful to move
them to snapshot-source-sink.

[Yang, 2014/07/08 09:01:05]

Done.

+ public:
+  DummySnapshotSink() : length_(0) {}
+  virtual ~DummySnapshotSink() {}
+  virtual void Put(int byte, const char* description) { length_++; }
+  virtual int Position() { return length_; }
+
+ private:
+  int length_;
+};
+
+
+// Wrap a SnapshotByteSink into a DebugSnapshotSink to get debugging output.
+class DebugSnapshotSink : public SnapshotByteSink {
+ public:
+  explicit DebugSnapshotSink(SnapshotByteSink* chained) : sink_(chained) {}
+  virtual ~DebugSnapshotSink() {}
+  virtual void Put(int byte, const char* description) {
+    printf("%24s: %x\n", description, byte);

[vogelheim, 2014/07/07 15:20:01]

nitpick: This header does not include stdio.h (and I guess it shouldn't). So
here we implicitly depend on one of our other headers being sloppy with their
#includes. I guess this should at least go into a .cc, so we're not contributing
to further header pollution?

[Yang, 2014/07/08 09:01:05]

Using PrintF instead.

+    sink_->Put(byte, description);
+  }
+  virtual int Position() { return sink_->Position(); }
+
+ private:
+  SnapshotByteSink* sink_;
+};
+
+
+class ListSnapshotSink : public i::SnapshotByteSink {
+ public:
+  explicit ListSnapshotSink(i::List<char>* data) : data_(data) {}
+  virtual ~ListSnapshotSink() {}
+  virtual void Put(int byte, const char* description) { data_->Add(byte); }
+  virtual int Position() { return data_->length(); }
+
+ private:
+  i::List<char>* data_;
+};
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_