Compress sources of JS libraries in addition to the snapshot.

src/api.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 20 matching lines @@
 
 #include "arguments.h"
 #include "bootstrapper.h"
 #include "compiler.h"
 #include "debug.h"
 #include "deoptimizer.h"
 #include "execution.h"
 #include "global-handles.h"
 #include "heap-profiler.h"
 #include "messages.h"
+#include "natives.h"
 #include "parser.h"
 #include "platform.h"
 #include "profile-generator-inl.h"
 #include "runtime-profiler.h"
 #include "serialize.h"
 #include "snapshot.h"
 #include "v8threads.h"
 #include "version.h"
 #include "vm-state-inl.h"
 
@@ skipping 265 matching lines @@
   return StartupData::kBZip2;
 #else
   return StartupData::kUncompressed;
 #endif
 }
 
 
 enum CompressedStartupDataItems {
   kSnapshot = 0,
   kSnapshotContext,
-  kCompressedStartupDataCount
+  kSnapshotDataCount
 };
 
 int V8::GetCompressedStartupDataCount() {
 #ifdef COMPRESS_STARTUP_DATA_BZ2
-  return kCompressedStartupDataCount;
+  return kSnapshotDataCount +
+      i::Natives::GetBuiltinsCount() +
+      i::ExperimentalNatives::GetBuiltinsCount();
 #else
   return 0;
 #endif
 }
 
 
 void V8::GetCompressedStartupData(StartupData* compressed_data) {
 #ifdef COMPRESS_STARTUP_DATA_BZ2
   compressed_data[kSnapshot].data =
       reinterpret_cast<const char*>(i::Snapshot::data());
   compressed_data[kSnapshot].compressed_size = i::Snapshot::size();
   compressed_data[kSnapshot].raw_size = i::Snapshot::raw_size();
 
   compressed_data[kSnapshotContext].data =
       reinterpret_cast<const char*>(i::Snapshot::context_data());
   compressed_data[kSnapshotContext].compressed_size =
       i::Snapshot::context_size();
   compressed_data[kSnapshotContext].raw_size = i::Snapshot::context_raw_size();
+
+  for (int i = 0, idx = kSnapshotDataCount;

[Vitaly Repeshko, 2011/06/06 10:08:23]

It may be easier to read to maintain a separate offset variable (updated before
the loops) and replace usages of idx with offset + i.

[mnaganov (inactive), 2011/06/06 13:40:18]

Done.

+       i < i::Natives::GetBuiltinsCount();

[Vitaly Repeshko, 2011/06/06 10:08:23]

I hope no compiler will have trouble with 'i' both as a variable and a namespace
name.

[mnaganov (inactive), 2011/06/06 13:40:18]

Bots will tell ;)

+       ++i, ++idx) {
+    i::Vector<const i::byte> source = i::Natives::GetScriptSource(i);
+    compressed_data[idx].data =
+        reinterpret_cast<const char*>(source.start());
+    compressed_data[idx].compressed_size = source.length();
+    compressed_data[idx].raw_size = i::Natives::GetRawScriptSize(i);    
+  }
+
+  for (int i = 0, idx = kSnapshotDataCount + i::Natives::GetBuiltinsCount();
+       i < i::ExperimentalNatives::GetBuiltinsCount();
+       ++i, ++idx) {
+    i::Vector<const i::byte> source =
+        i::ExperimentalNatives::GetScriptSource(i);
+    compressed_data[idx].data =
+        reinterpret_cast<const char*>(source.start());
+    compressed_data[idx].compressed_size = source.length();
+    compressed_data[idx].raw_size =
+        i::ExperimentalNatives::GetRawScriptSize(i);    
+  }
 #endif
 }
 
 
 void V8::SetDecompressedStartupData(StartupData* decompressed_data) {
 #ifdef COMPRESS_STARTUP_DATA_BZ2
   ASSERT_EQ(i::Snapshot::raw_size(), decompressed_data[kSnapshot].raw_size);
   i::Snapshot::set_raw_data(
       reinterpret_cast<const i::byte*>(decompressed_data[kSnapshot].data));
 
   ASSERT_EQ(i::Snapshot::context_raw_size(),
             decompressed_data[kSnapshotContext].raw_size);
   i::Snapshot::set_context_raw_data(
       reinterpret_cast<const i::byte*>(
           decompressed_data[kSnapshotContext].data));
+
+  for (int i = 0, idx = kSnapshotDataCount;

[Vitaly Repeshko, 2011/06/06 10:08:23]

Same here.

+       i < i::Natives::GetBuiltinsCount();
+       ++i, ++idx) {
+    ASSERT_EQ(i::Natives::GetRawScriptSize(i),
+              decompressed_data[idx].raw_size);
+    i::Vector<const char> source(decompressed_data[idx].data,
+                                 decompressed_data[idx].raw_size);
+    i::Natives::SetRawScriptSource(i, source);
+  }
+
+  for (int i = 0, idx = kSnapshotDataCount + i::Natives::GetBuiltinsCount();
+       i < i::ExperimentalNatives::GetBuiltinsCount();
+       ++i, ++idx) {
+    ASSERT_EQ(i::ExperimentalNatives::GetRawScriptSize(i),
+              decompressed_data[idx].raw_size);
+    i::Vector<const char> source(decompressed_data[idx].data,
+                                 decompressed_data[idx].raw_size);
+    i::ExperimentalNatives::SetRawScriptSource(i, source);
+  }
 #endif
 }
 
 
 void V8::SetFatalErrorHandler(FatalErrorCallback that) {
   i::Isolate* isolate = EnterIsolateIfNeeded();
   isolate->set_exception_behavior(that);
 }
 
 
@@ skipping 5469 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* scope_implementer =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   scope_implementer->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal