#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/platform.h"
#include "src/serialize.h"
-#include "src/list.h"
using namespace v8;
class Compressor {
public:
virtual ~Compressor() {}
- virtual bool Compress(i::Vector<char> input) = 0;
- virtual i::Vector<char>* output() = 0;
-};
-
-
-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_;
+ virtual bool Compress(i::Vector<i::byte> input) = 0;
+ virtual i::Vector<i::byte>* output() = 0;
};
: fp_(GetFileDescriptorOrDie(snapshot_file))
, raw_file_(NULL)
, raw_context_file_(NULL)
- , compressor_(NULL)
- , omit_(false) {
+ , startup_blob_file_(NULL)
+ , compressor_(NULL) {
}
~SnapshotWriter() {
fclose(fp_);
if (raw_file_) fclose(raw_file_);
if (raw_context_file_) fclose(raw_context_file_);
+ if (startup_blob_file_) fclose(startup_blob_file_);
}
void SetCompressor(Compressor* compressor) {
compressor_ = compressor;
}
- void SetOmit(bool omit) {
- omit_ = omit;
- }
-
void SetRawFiles(const char* raw_file, const char* raw_context_file) {
raw_file_ = GetFileDescriptorOrDie(raw_file);
raw_context_file_ = GetFileDescriptorOrDie(raw_context_file);
}
- void WriteSnapshot(const i::List<char>& snapshot_data,
+ void SetStartupBlobFile(const char* startup_blob_file) {
+ if (startup_blob_file != NULL)
+ startup_blob_file_ = GetFileDescriptorOrDie(startup_blob_file);
+ }
+
+ 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<i::byte>& snapshot_data,
+ const i::Serializer& serializer,
+ const i::List<i::byte>& context_snapshot_data,
+ const i::Serializer& context_serializer) const {
+ if (!startup_blob_file_)
+ return;
+
+ 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 = 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 = 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<i::byte>& snapshot_data,
+ const i::Serializer& serializer,
+ 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_);
WriteFileSuffix();
}
- private:
void WriteFilePrefix() const {
fprintf(fp_, "// Autogenerated snapshot file. Do not edit.\n\n");
fprintf(fp_, "#include \"src/v8.h\"\n");
- fprintf(fp_, "#include \"src/platform.h\"\n\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");
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())) {
exit(1);
}
- ASSERT(data_to_be_written);
+ DCHECK(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());
+ DCHECK(data->end() - data->begin() == data->length());
size_t written = fwrite(data->begin(), 1, data->length(), raw_file);
if (written != (size_t)data->length()) {
}
}
- 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);
- if (!omit_)
- WriteSnapshotData(data_to_be_written);
+ 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 && !omit_) {
+ 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",
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");
}
FILE* GetFileDescriptorOrDie(const char* filename) {
- FILE* fp = i::OS::FOpen(filename, "wb");
+ FILE* fp = base::OS::FOpen(filename, "wb");
if (fp == NULL) {
i::PrintF("Unable to open file \"%s\" for writing.\n", filename);
exit(1);
FILE* fp_;
FILE* raw_file_;
FILE* raw_context_file_;
+ FILE* startup_blob_file_;
Compressor* compressor_;
- bool omit_;
};
int* raw_data_size,
const char* compressed_data,
int compressed_data_size) {
- ASSERT_EQ(StartupData::kBZip2,
+ DCHECK_EQ(StartupData::kBZip2,
V8::GetCompressedStartupDataAlgorithm());
unsigned int decompressed_size = *raw_data_size;
int result =
int main(int argc, char** argv) {
V8::InitializeICU();
- i::Isolate::SetCrashIfDefaultIsolateInitialized();
+ v8::Platform* platform = v8::platform::CreateDefaultPlatform();
+ v8::V8::InitializePlatform(platform);
i::CpuFeatures::Probe(true);
// By default, log code create information in the snapshot.
HandleScope scope(isolate);
v8::Context::Scope cscope(v8::Local<v8::Context>::New(isolate, context));
const char* name = i::FLAG_extra_code;
- FILE* file = i::OS::FOpen(name, "rb");
+ FILE* file = base::OS::FOpen(name, "rb");
if (file == NULL) {
fprintf(stderr, "Failed to open '%s': errno %d\n", name, errno);
exit(1);
// 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;
- ListSnapshotSink snapshot_sink(&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;
- ListSnapshotSink contex_sink(&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]);
- writer.SetOmit(i::FLAG_omit);
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);
isolate->Dispose();
V8::Dispose();
+ V8::ShutdownPlatform();
+ delete platform;
return 0;
}
projects / platform / framework / web / crosswalk.git / blobdiff