Environment* env = Environment::GetCurrent(args);

Local<Integer> result =

Integer::NewFromUnsigned(env->isolate(),

ScriptCompiler::CachedDataVersionTag());

args.GetReturnValue().Set(result);

Environment* env = Environment::GetCurrent(args);

HeapStatistics s;

env->isolate()->GetHeapStatistics(&s);

double* const buffer = env->heap_statistics_buffer();

#define V(index, name, _) buffer[index] = static_cast<double>(s.name());

HEAP_STATISTICS_PROPERTIES(V)

#undef V

Environment* env = Environment::GetCurrent(args);

HeapSpaceStatistics s;

Isolate* const isolate = env->isolate();

double* buffer = env->heap_space_statistics_buffer();

for (size_t i = 0; i < number_of_heap_spaces; i++) {

isolate->GetHeapSpaceStatistics(&s, i);

size_t const property_offset = i * kHeapSpaceStatisticsPropertiesCount;

#define V(index, name, _) buffer[property_offset + index] = \

static_cast<double>(s.name());

HEAP_SPACE_STATISTICS_PROPERTIES(V)

#undef V

}

Environment* env = Environment::GetCurrent(args);

if (args.Length() < 1)

return env->ThrowTypeError("v8 flag is required");

if (!args[0]->IsString())

return env->ThrowTypeError("v8 flag must be a string");

String::Utf8Value flags(args[0]);

V8::SetFlagsFromString(*flags, flags.length());

Local<Value> unused,

Local<Context> context) {

Environment* env = Environment::GetCurrent(context);

env->SetMethod(target, "cachedDataVersionTag", CachedDataVersionTag);

env->SetMethod(target,

"updateHeapStatisticsArrayBuffer",

UpdateHeapStatisticsArrayBuffer);

env->set_heap_statistics_buffer(new double[kHeapStatisticsPropertiesCount]);

const size_t heap_statistics_buffer_byte_length =

sizeof(*env->heap_statistics_buffer()) * kHeapStatisticsPropertiesCount;

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(),

"heapStatisticsArrayBuffer"),

ArrayBuffer::New(env->isolate(),

env->heap_statistics_buffer(),

heap_statistics_buffer_byte_length));

#define V(i, _, name) \

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), #name), \

Uint32::NewFromUnsigned(env->isolate(), i));

HEAP_STATISTICS_PROPERTIES(V)

#undef V

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(),

"kHeapSpaceStatisticsPropertiesCount"),

Uint32::NewFromUnsigned(env->isolate(),

kHeapSpaceStatisticsPropertiesCount));

number_of_heap_spaces = env->isolate()->NumberOfHeapSpaces();

// Heap space names are extracted once and exposed to JavaScript to

// avoid excessive creation of heap space name Strings.

HeapSpaceStatistics s;

const Local<Array> heap_spaces = Array::New(env->isolate(),

number_of_heap_spaces);

for (size_t i = 0; i < number_of_heap_spaces; i++) {

env->isolate()->GetHeapSpaceStatistics(&s, i);

Local<String> heap_space_name = String::NewFromUtf8(env->isolate(),

s.space_name(),

NewStringType::kNormal)

.ToLocalChecked();

heap_spaces->Set(i, heap_space_name);

}

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kHeapSpaces"),

heap_spaces);

env->SetMethod(target,

"updateHeapSpaceStatisticsArrayBuffer",

UpdateHeapSpaceStatisticsBuffer);

env->set_heap_space_statistics_buffer(

new double[kHeapSpaceStatisticsPropertiesCount * number_of_heap_spaces]);

const size_t heap_space_statistics_buffer_byte_length =

sizeof(*env->heap_space_statistics_buffer()) *

kHeapSpaceStatisticsPropertiesCount *

number_of_heap_spaces;

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(),

"heapSpaceStatisticsArrayBuffer"),

ArrayBuffer::New(env->isolate(),

env->heap_space_statistics_buffer(),

heap_space_statistics_buffer_byte_length));

#define V(i, _, name) \

target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), #name), \

Uint32::NewFromUnsigned(env->isolate(), i));

HEAP_SPACE_STATISTICS_PROPERTIES(V)

#undef V

env->SetMethod(target, "setFlagsFromString", SetFlagsFromString);