Refactor ScriptData class for cached compile data.

src/mksnapshot.cc

 // Copyright 2006-2008 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 <errno.h>
 #include <stdio.h>
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 #include <bzlib.h>
 #endif
 #include <signal.h>
 
 #include "src/v8.h"
 
 #include "include/libplatform/libplatform.h"
 #include "src/assembler.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/flags.h"
 #include "src/list.h"
 #include "src/natives.h"
 #include "src/serialize.h"
 
 
 using namespace v8;
 
 
 class Compressor {
  public:
   virtual ~Compressor() {}
-  virtual bool Compress(i::Vector<char> input) = 0;
-  virtual i::Vector<char>* output() = 0;
+  virtual bool Compress(i::Vector<i::byte> input) = 0;
+  virtual i::Vector<i::byte>* output() = 0;
 };
 
 
 class SnapshotWriter {
  public:
   explicit SnapshotWriter(const char* snapshot_file)
       : fp_(GetFileDescriptorOrDie(snapshot_file))
       , raw_file_(NULL)
       , raw_context_file_(NULL)
       , startup_blob_file_(NULL)
@@ skipping 14 matching lines @@
   void SetRawFiles(const char* raw_file, const char* raw_context_file) {
     raw_file_ = GetFileDescriptorOrDie(raw_file);
     raw_context_file_ = GetFileDescriptorOrDie(raw_context_file);
   }
 
   void SetStartupBlobFile(const char* startup_blob_file) {
     if (startup_blob_file != NULL)
       startup_blob_file_ = GetFileDescriptorOrDie(startup_blob_file);
   }
 
-  void WriteSnapshot(const i::List<char>& snapshot_data,
+  void WriteSnapshot(const i::List<i::byte>& snapshot_data,
                      const i::Serializer& serializer,
-                     const i::List<char>& context_snapshot_data,
+                     const i::List<i::byte>& context_snapshot_data,
                      const i::Serializer& context_serializer) const {
     WriteSnapshotFile(snapshot_data, serializer,
                       context_snapshot_data, context_serializer);
     MaybeWriteStartupBlob(snapshot_data, serializer,
                           context_snapshot_data, context_serializer);
   }
 
  private:
-  void MaybeWriteStartupBlob(const i::List<char>& snapshot_data,
+  void MaybeWriteStartupBlob(const i::List<i::byte>& snapshot_data,
                              const i::Serializer& serializer,
-                             const i::List<char>& context_snapshot_data,
+                             const i::List<i::byte>& context_snapshot_data,
                              const i::Serializer& context_serializer) const {
     if (!startup_blob_file_)
       return;
 
-    i::List<char> startup_blob;
+    i::List<i::byte> startup_blob;
     i::ListSnapshotSink sink(&startup_blob);
 
     int spaces[] = {
         i::NEW_SPACE, i::OLD_POINTER_SPACE, i::OLD_DATA_SPACE, i::CODE_SPACE,
         i::MAP_SPACE, i::CELL_SPACE,  i::PROPERTY_CELL_SPACE
     };
 
-    i::byte* snapshot_bytes = reinterpret_cast<i::byte*>(snapshot_data.begin());
+    i::byte* snapshot_bytes = snapshot_data.begin();
     sink.PutBlob(snapshot_bytes, snapshot_data.length(), "snapshot");
     for (size_t i = 0; i < ARRAY_SIZE(spaces); ++i)
       sink.PutInt(serializer.CurrentAllocationAddress(spaces[i]), "spaces");
 
-    i::byte* context_bytes =
-        reinterpret_cast<i::byte*>(context_snapshot_data.begin());
+    i::byte* context_bytes = context_snapshot_data.begin();
     sink.PutBlob(context_bytes, context_snapshot_data.length(), "context");
     for (size_t i = 0; i < ARRAY_SIZE(spaces); ++i)
       sink.PutInt(context_serializer.CurrentAllocationAddress(spaces[i]),
                   "spaces");
 
     size_t written = fwrite(startup_blob.begin(), 1, startup_blob.length(),
                             startup_blob_file_);
     if (written != (size_t)startup_blob.length()) {
       i::PrintF("Writing snapshot file failed.. Aborting.\n");
       exit(1);
     }
   }
 
-  void WriteSnapshotFile(const i::List<char>& snapshot_data,
+  void WriteSnapshotFile(const i::List<i::byte>& snapshot_data,
                          const i::Serializer& serializer,
-                         const i::List<char>& context_snapshot_data,
+                         const i::List<i::byte>& context_snapshot_data,
                          const i::Serializer& context_serializer) const {
     WriteFilePrefix();
     WriteData("", snapshot_data, raw_file_);
     WriteData("context_", context_snapshot_data, raw_context_file_);
     WriteMeta("context_", context_serializer);
     WriteMeta("", serializer);
     WriteFileSuffix();
   }
 
   void WriteFilePrefix() const {
     fprintf(fp_, "// Autogenerated snapshot file. Do not edit.\n\n");
     fprintf(fp_, "#include \"src/v8.h\"\n");
     fprintf(fp_, "#include \"src/base/platform/platform.h\"\n\n");
     fprintf(fp_, "#include \"src/snapshot.h\"\n\n");
     fprintf(fp_, "namespace v8 {\n");
     fprintf(fp_, "namespace internal {\n\n");
   }
 
   void WriteFileSuffix() const {
     fprintf(fp_, "}  // namespace internal\n");
     fprintf(fp_, "}  // namespace v8\n");
   }
 
-  void WriteData(const char* prefix,
-                 const i::List<char>& source_data,
+  void WriteData(const char* prefix, const i::List<i::byte>& source_data,
                  FILE* raw_file) const {
-    const i::List <char>* data_to_be_written = NULL;
-    i::List<char> compressed_data;
+    const i::List<i::byte>* data_to_be_written = NULL;
+    i::List<i::byte> compressed_data;
     if (!compressor_) {
       data_to_be_written = &source_data;
     } else if (compressor_->Compress(source_data.ToVector())) {
       compressed_data.AddAll(*compressor_->output());
       data_to_be_written = &compressed_data;
     } else {
       i::PrintF("Compression failed. Aborting.\n");
       exit(1);
     }
 
     ASSERT(data_to_be_written);
     MaybeWriteRawFile(data_to_be_written, raw_file);
     WriteData(prefix, source_data, data_to_be_written);
   }
 
-  void MaybeWriteRawFile(const i::List<char>* data, FILE* raw_file) const {
+  void MaybeWriteRawFile(const i::List<i::byte>* data, FILE* raw_file) const {
     if (!data || !raw_file)
       return;
 
     // Sanity check, whether i::List iterators truly return pointers to an
     // internal array.
     ASSERT(data->end() - data->begin() == data->length());
 
     size_t written = fwrite(data->begin(), 1, data->length(), raw_file);
     if (written != (size_t)data->length()) {
       i::PrintF("Writing raw file failed.. Aborting.\n");
       exit(1);
     }
   }
 
-  void WriteData(const char* prefix,
-                 const i::List<char>& source_data,
-                 const i::List<char>* data_to_be_written) const {
+  void WriteData(const char* prefix, const i::List<i::byte>& source_data,
+                 const i::List<i::byte>* data_to_be_written) const {
     fprintf(fp_, "const byte Snapshot::%sdata_[] = {\n", prefix);
     WriteSnapshotData(data_to_be_written);
     fprintf(fp_, "};\n");
     fprintf(fp_, "const int Snapshot::%ssize_ = %d;\n", prefix,
             data_to_be_written->length());
 
     if (data_to_be_written == &source_data) {
       fprintf(fp_, "const byte* Snapshot::%sraw_data_ = Snapshot::%sdata_;\n",
               prefix, prefix);
       fprintf(fp_, "const int Snapshot::%sraw_size_ = Snapshot::%ssize_;\n",
@@ skipping 16 matching lines @@
     WriteSizeVar(ser, prefix, "property_cell", i::PROPERTY_CELL_SPACE);
     fprintf(fp_, "\n");
   }
 
   void WriteSizeVar(const i::Serializer& ser, const char* prefix,
                     const char* name, int space) const {
     fprintf(fp_, "const int Snapshot::%s%s_space_used_ = %d;\n",
             prefix, name, ser.CurrentAllocationAddress(space));
   }
 
-  void WriteSnapshotData(const i::List<char>* data) const {
+  void WriteSnapshotData(const i::List<i::byte>* data) const {
     for (int i = 0; i < data->length(); i++) {
       if ((i & 0x1f) == 0x1f)
         fprintf(fp_, "\n");
       if (i > 0)
         fprintf(fp_, ",");
       fprintf(fp_, "%u", static_cast<unsigned char>(data->at(i)));
     }
     fprintf(fp_, "\n");
   }
 
@@ skipping 175 matching lines @@
     }
     // If we don't do this then we end up with a stray root pointing at the
     // context even after we have disposed of the context.
     internal_isolate->heap()->CollectAllGarbage(
         i::Heap::kNoGCFlags, "mksnapshot");
     i::Object* raw_context = *v8::Utils::OpenPersistent(context);
     context.Reset();
 
     // This results in a somewhat smaller snapshot, probably because it gets
     // rid of some things that are cached between garbage collections.
-    i::List<char> snapshot_data;
+    i::List<i::byte> snapshot_data;
     i::ListSnapshotSink snapshot_sink(&snapshot_data);
     i::StartupSerializer ser(internal_isolate, &snapshot_sink);
     ser.SerializeStrongReferences();
 
-    i::List<char> context_data;
+    i::List<i::byte> context_data;
     i::ListSnapshotSink contex_sink(&context_data);
     i::PartialSerializer context_ser(internal_isolate, &ser, &contex_sink);
     context_ser.Serialize(&raw_context);
     ser.SerializeWeakReferences();
 
     {
       SnapshotWriter writer(argv[1]);
       if (i::FLAG_raw_file && i::FLAG_raw_context_file)
         writer.SetRawFiles(i::FLAG_raw_file, i::FLAG_raw_context_file);
       if (i::FLAG_startup_blob)
         writer.SetStartupBlobFile(i::FLAG_startup_blob);
   #ifdef COMPRESS_STARTUP_DATA_BZ2
       BZip2Compressor bzip2;
       writer.SetCompressor(&bzip2);
   #endif
       writer.WriteSnapshot(snapshot_data, ser, context_data, context_ser);
     }
   }
 
   isolate->Dispose();
   V8::Dispose();
   V8::ShutdownPlatform();
   delete platform;
   return 0;
 }