Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/test/cctest/test-heap-profiler.cc b/test/cctest/test-heap-profiler.cc
index 94a5be4..a2fd09e 100644
--- a/test/cctest/test-heap-profiler.cc
+++ b/test/cctest/test-heap-profiler.cc
@@ -32,12 +32,11 @@
#include "src/v8.h"
#include "include/v8-profiler.h"
-#include "src/allocation-tracker.h"
-#include "src/debug.h"
+#include "src/debug/debug.h"
#include "src/hashmap.h"
-#include "src/heap-profiler.h"
-#include "src/snapshot.h"
-#include "src/utils-inl.h"
+#include "src/profiler/allocation-tracker.h"
+#include "src/profiler/heap-profiler.h"
+#include "src/profiler/heap-snapshot-generator-inl.h"
#include "test/cctest/cctest.h"
using i::AllocationTraceNode;
@@ -75,10 +74,9 @@
for (int i = 0; i < children.length(); ++i) {
if (children[i]->type() == i::HeapGraphEdge::kShortcut) continue;
i::HeapEntry* child = children[i]->to();
- i::HashMap::Entry* entry = visited.Lookup(
+ i::HashMap::Entry* entry = visited.LookupOrInsert(
reinterpret_cast<void*>(child),
- static_cast<uint32_t>(reinterpret_cast<uintptr_t>(child)),
- true);
+ static_cast<uint32_t>(reinterpret_cast<uintptr_t>(child)));
if (entry->value)
continue;
entry->value = reinterpret_cast<void*>(1);
@@ -147,10 +145,9 @@
i::HashMap visited(AddressesMatch);
i::List<i::HeapGraphEdge>& edges = heap_snapshot->edges();
for (int i = 0; i < edges.length(); ++i) {
- i::HashMap::Entry* entry = visited.Lookup(
+ i::HashMap::Entry* entry = visited.LookupOrInsert(
reinterpret_cast<void*>(edges[i].to()),
- static_cast<uint32_t>(reinterpret_cast<uintptr_t>(edges[i].to())),
- true);
+ static_cast<uint32_t>(reinterpret_cast<uintptr_t>(edges[i].to())));
uint32_t ref_count = static_cast<uint32_t>(
reinterpret_cast<uintptr_t>(entry->value));
entry->value = reinterpret_cast<void*>(ref_count + 1);
@@ -160,8 +157,7 @@
for (int i = 0; i < entries.length(); ++i) {
i::HashMap::Entry* entry = visited.Lookup(
reinterpret_cast<void*>(&entries[i]),
- static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&entries[i])),
- false);
+ static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&entries[i])));
if (!entry && entries[i].id() != 1) {
entries[i].Print("entry with no retainer", "", depth, 0);
++unretained_entries_count;
@@ -183,20 +179,17 @@
"var a2 = new A2();\n"
"var b2_1 = new B2(a2), b2_2 = new B2(a2);\n"
"var c2 = new C2(a2);");
- const v8::HeapSnapshot* snapshot_env2 =
- heap_profiler->TakeHeapSnapshot(v8_str("env2"));
+ const v8::HeapSnapshot* snapshot_env2 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot_env2));
const v8::HeapGraphNode* global_env2 = GetGlobalObject(snapshot_env2);
// Verify, that JS global object of env2 has '..2' properties.
const v8::HeapGraphNode* a2_node =
GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "a2");
- CHECK_NE(NULL, a2_node);
- CHECK_NE(
- NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1"));
- CHECK_NE(
- NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2"));
- CHECK_NE(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2"));
+ CHECK(a2_node);
+ CHECK(GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1"));
+ CHECK(GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2"));
+ CHECK(GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2"));
NamedEntriesDetector det;
det.CheckAllReachables(const_cast<i::HeapEntry*>(
@@ -219,19 +212,18 @@
"x = new X(new X(), new X());\n"
"dummy = new X();\n"
"(function() { x.a.a = x.b; })();");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("sizes"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* x =
GetProperty(global, v8::HeapGraphEdge::kProperty, "x");
- CHECK_NE(NULL, x);
+ CHECK(x);
const v8::HeapGraphNode* x1 =
GetProperty(x, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, x1);
+ CHECK(x1);
const v8::HeapGraphNode* x2 =
GetProperty(x, v8::HeapGraphEdge::kProperty, "b");
- CHECK_NE(NULL, x2);
+ CHECK(x2);
// Test sizes.
CHECK_NE(0, static_cast<int>(x->GetShallowSize()));
@@ -248,20 +240,18 @@
"function myFunction(a, b) { this.a = a; this.b = b; }\n"
"function AAAAA() {}\n"
"boundFunction = myFunction.bind(new AAAAA(), 20, new Number(12)); \n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("sizes"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* f =
GetProperty(global, v8::HeapGraphEdge::kProperty, "boundFunction");
CHECK(f);
- CHECK_EQ(v8::String::NewFromUtf8(env->GetIsolate(), "native_bind"),
- f->GetName());
+ CHECK(v8_str("native_bind")->Equals(env.local(), f->GetName()).FromJust());
const v8::HeapGraphNode* bindings =
GetProperty(f, v8::HeapGraphEdge::kInternal, "bindings");
- CHECK_NE(NULL, bindings);
+ CHECK(bindings);
CHECK_EQ(v8::HeapGraphNode::kArray, bindings->GetType());
- CHECK_EQ(4, bindings->GetChildrenCount());
+ CHECK_EQ(1, bindings->GetChildrenCount());
const v8::HeapGraphNode* bound_this = GetProperty(
f, v8::HeapGraphEdge::kShortcut, "bound_this");
@@ -288,8 +278,7 @@
CompileRun(
"function A() { }\n"
"a = new A;");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("children"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
for (int i = 0, count = global->GetChildrenCount(); i < count; ++i) {
@@ -298,7 +287,7 @@
}
const v8::HeapGraphNode* a =
GetProperty(global, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, a);
+ CHECK(a);
for (int i = 0, count = a->GetChildrenCount(); i < count; ++i) {
const v8::HeapGraphEdge* prop = a->GetChild(i);
CHECK_EQ(a, prop->GetFromNode());
@@ -316,42 +305,41 @@
"function compiled(x) { return x + 1; }\n"
"var anonymous = (function() { return function() { return 0; } })();\n"
"compiled(1)");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("code"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* compiled =
GetProperty(global, v8::HeapGraphEdge::kProperty, "compiled");
- CHECK_NE(NULL, compiled);
+ CHECK(compiled);
CHECK_EQ(v8::HeapGraphNode::kClosure, compiled->GetType());
const v8::HeapGraphNode* lazy =
GetProperty(global, v8::HeapGraphEdge::kProperty, "lazy");
- CHECK_NE(NULL, lazy);
+ CHECK(lazy);
CHECK_EQ(v8::HeapGraphNode::kClosure, lazy->GetType());
const v8::HeapGraphNode* anonymous =
GetProperty(global, v8::HeapGraphEdge::kProperty, "anonymous");
- CHECK_NE(NULL, anonymous);
+ CHECK(anonymous);
CHECK_EQ(v8::HeapGraphNode::kClosure, anonymous->GetType());
v8::String::Utf8Value anonymous_name(anonymous->GetName());
- CHECK_EQ("", *anonymous_name);
+ CHECK_EQ(0, strcmp("", *anonymous_name));
// Find references to code.
const v8::HeapGraphNode* compiled_code =
GetProperty(compiled, v8::HeapGraphEdge::kInternal, "shared");
- CHECK_NE(NULL, compiled_code);
+ CHECK(compiled_code);
const v8::HeapGraphNode* lazy_code =
GetProperty(lazy, v8::HeapGraphEdge::kInternal, "shared");
- CHECK_NE(NULL, lazy_code);
+ CHECK(lazy_code);
// Check that there's no strong next_code_link. There might be a weak one
// but might be not, so we can't check that fact.
const v8::HeapGraphNode* code =
GetProperty(compiled_code, v8::HeapGraphEdge::kInternal, "code");
- CHECK_NE(NULL, code);
+ CHECK(code);
const v8::HeapGraphNode* next_code_link =
GetProperty(code, v8::HeapGraphEdge::kInternal, "code");
- CHECK_EQ(NULL, next_code_link);
+ CHECK(!next_code_link);
// Verify that non-compiled code doesn't contain references to "x"
// literal, while compiled code does. The scope info is stored in FixedArray
@@ -389,14 +377,13 @@
CompileRun(
"a = 1; // a is Smi\n"
"b = 2.5; // b is HeapNumber");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("numbers"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_EQ(NULL, GetProperty(global, v8::HeapGraphEdge::kProperty, "a"));
+ CHECK(!GetProperty(global, v8::HeapGraphEdge::kProperty, "a"));
const v8::HeapGraphNode* b =
GetProperty(global, v8::HeapGraphEdge::kProperty, "b");
- CHECK_NE(NULL, b);
+ CHECK(b);
CHECK_EQ(v8::HeapGraphNode::kHeapNumber, b->GetType());
}
@@ -409,18 +396,21 @@
"parent_string = \"123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789."
+ "123456789.123456789.123456789.123456789.123456789."
+ "123456789.123456789.123456789.123456789.123456789."
+ "123456789.123456789.123456789.123456789.123456789."
+ "123456789.123456789.123456789.123456789.123456789."
"123456789.123456789.123456789.123456789.123456789.\";"
"child_string = parent_string.slice(100);");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("strings"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* parent_string =
GetProperty(global, v8::HeapGraphEdge::kProperty, "parent_string");
- CHECK_NE(NULL, parent_string);
+ CHECK(parent_string);
const v8::HeapGraphNode* child_string =
GetProperty(global, v8::HeapGraphEdge::kProperty, "child_string");
- CHECK_NE(NULL, child_string);
+ CHECK(child_string);
CHECK_EQ(v8::HeapGraphNode::kSlicedString, child_string->GetType());
const v8::HeapGraphNode* parent =
GetProperty(child_string, v8::HeapGraphEdge::kInternal, "parent");
@@ -436,8 +426,8 @@
v8::ObjectTemplate::New(isolate);
global_template->SetInternalFieldCount(1);
LocalContext env(NULL, global_template);
- v8::Handle<v8::Object> global_proxy = env->Global();
- v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
+ v8::Local<v8::Object> global_proxy = env->Global();
+ v8::Local<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
CHECK_EQ(1, global->InternalFieldCount());
i::Factory* factory = CcTest::i_isolate()->factory();
@@ -449,14 +439,13 @@
global->SetInternalField(0, v8::ToApiHandle<v8::String>(cons_string));
v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("cons_strings"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
const v8::HeapGraphNode* string_node =
GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0");
- CHECK_NE(NULL, string_node);
+ CHECK(string_node);
CHECK_EQ(v8::HeapGraphNode::kConsString, string_node->GetType());
const v8::HeapGraphNode* first_node =
@@ -477,19 +466,49 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("a = Symbol('mySymbol');\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("Symbol"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* a =
GetProperty(global, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, a);
+ CHECK(a);
CHECK_EQ(a->GetType(), v8::HeapGraphNode::kSymbol);
- CHECK_EQ(v8_str("symbol"), a->GetName());
+ CHECK(v8_str("symbol")->Equals(env.local(), a->GetName()).FromJust());
const v8::HeapGraphNode* name =
GetProperty(a, v8::HeapGraphEdge::kInternal, "name");
- CHECK_NE(NULL, name);
- CHECK_EQ(v8_str("mySymbol"), name->GetName());
+ CHECK(name);
+ CHECK(v8_str("mySymbol")->Equals(env.local(), name->GetName()).FromJust());
+}
+
+
+void CheckSimdSnapshot(const char* program, const char* var_name) {
+ i::FLAG_harmony_simd = true;
+ LocalContext env;
+ v8::HandleScope scope(env->GetIsolate());
+ v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+
+ CompileRun(program);
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
+ CHECK(ValidateSnapshot(snapshot));
+ const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
+ const v8::HeapGraphNode* var =
+ GetProperty(global, v8::HeapGraphEdge::kProperty, var_name);
+ CHECK(var);
+ CHECK_EQ(var->GetType(), v8::HeapGraphNode::kSimdValue);
+}
+
+
+TEST(HeapSnapshotSimd) {
+ CheckSimdSnapshot("a = SIMD.Float32x4();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Int32x4();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Uint32x4();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Bool32x4();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Int16x8();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Uint16x8();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Bool16x8();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Int8x16();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Uint8x16();\n", "a");
+ CheckSimdSnapshot("a = SIMD.Bool8x16();\n", "a");
}
@@ -502,25 +521,24 @@
"k = {}; v = {}; s = 'str';\n"
"ws = new WeakSet(); ws.add(k); ws.add(v); ws[s] = s;\n"
"wm = new WeakMap(); wm.set(k, v); wm[s] = s;\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("WeakCollections"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* k =
GetProperty(global, v8::HeapGraphEdge::kProperty, "k");
- CHECK_NE(NULL, k);
+ CHECK(k);
const v8::HeapGraphNode* v =
GetProperty(global, v8::HeapGraphEdge::kProperty, "v");
- CHECK_NE(NULL, v);
+ CHECK(v);
const v8::HeapGraphNode* s =
GetProperty(global, v8::HeapGraphEdge::kProperty, "s");
- CHECK_NE(NULL, s);
+ CHECK(s);
const v8::HeapGraphNode* ws =
GetProperty(global, v8::HeapGraphEdge::kProperty, "ws");
- CHECK_NE(NULL, ws);
+ CHECK(ws);
CHECK_EQ(v8::HeapGraphNode::kObject, ws->GetType());
- CHECK_EQ(v8_str("WeakSet"), ws->GetName());
+ CHECK(v8_str("WeakSet")->Equals(env.local(), ws->GetName()).FromJust());
const v8::HeapGraphNode* ws_table =
GetProperty(ws, v8::HeapGraphEdge::kInternal, "table");
@@ -537,14 +555,14 @@
CHECK_EQ(1, weak_entries);
const v8::HeapGraphNode* ws_s =
GetProperty(ws, v8::HeapGraphEdge::kProperty, "str");
- CHECK_NE(NULL, ws_s);
- CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(ws_s->GetId()));
+ CHECK(ws_s);
+ CHECK_EQ(s->GetId(), ws_s->GetId());
const v8::HeapGraphNode* wm =
GetProperty(global, v8::HeapGraphEdge::kProperty, "wm");
- CHECK_NE(NULL, wm);
+ CHECK(wm);
CHECK_EQ(v8::HeapGraphNode::kObject, wm->GetType());
- CHECK_EQ(v8_str("WeakMap"), wm->GetName());
+ CHECK(v8_str("WeakMap")->Equals(env.local(), wm->GetName()).FromJust());
const v8::HeapGraphNode* wm_table =
GetProperty(wm, v8::HeapGraphEdge::kInternal, "table");
@@ -562,8 +580,8 @@
CHECK_EQ(2, weak_entries);
const v8::HeapGraphNode* wm_s =
GetProperty(wm, v8::HeapGraphEdge::kProperty, "str");
- CHECK_NE(NULL, wm_s);
- CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(wm_s->GetId()));
+ CHECK(wm_s);
+ CHECK_EQ(s->GetId(), wm_s->GetId());
}
@@ -576,25 +594,24 @@
"k = {}; v = {}; s = 'str';\n"
"set = new Set(); set.add(k); set.add(v); set[s] = s;\n"
"map = new Map(); map.set(k, v); map[s] = s;\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("Collections"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* k =
GetProperty(global, v8::HeapGraphEdge::kProperty, "k");
- CHECK_NE(NULL, k);
+ CHECK(k);
const v8::HeapGraphNode* v =
GetProperty(global, v8::HeapGraphEdge::kProperty, "v");
- CHECK_NE(NULL, v);
+ CHECK(v);
const v8::HeapGraphNode* s =
GetProperty(global, v8::HeapGraphEdge::kProperty, "s");
- CHECK_NE(NULL, s);
+ CHECK(s);
const v8::HeapGraphNode* set =
GetProperty(global, v8::HeapGraphEdge::kProperty, "set");
- CHECK_NE(NULL, set);
+ CHECK(set);
CHECK_EQ(v8::HeapGraphNode::kObject, set->GetType());
- CHECK_EQ(v8_str("Set"), set->GetName());
+ CHECK(v8_str("Set")->Equals(env.local(), set->GetName()).FromJust());
const v8::HeapGraphNode* set_table =
GetProperty(set, v8::HeapGraphEdge::kInternal, "table");
@@ -611,14 +628,14 @@
CHECK_EQ(2, entries);
const v8::HeapGraphNode* set_s =
GetProperty(set, v8::HeapGraphEdge::kProperty, "str");
- CHECK_NE(NULL, set_s);
- CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(set_s->GetId()));
+ CHECK(set_s);
+ CHECK_EQ(s->GetId(), set_s->GetId());
const v8::HeapGraphNode* map =
GetProperty(global, v8::HeapGraphEdge::kProperty, "map");
- CHECK_NE(NULL, map);
+ CHECK(map);
CHECK_EQ(v8::HeapGraphNode::kObject, map->GetType());
- CHECK_EQ(v8_str("Map"), map->GetName());
+ CHECK(v8_str("Map")->Equals(env.local(), map->GetName()).FromJust());
const v8::HeapGraphNode* map_table =
GetProperty(map, v8::HeapGraphEdge::kInternal, "table");
@@ -635,8 +652,8 @@
CHECK_EQ(2, entries);
const v8::HeapGraphNode* map_s =
GetProperty(map, v8::HeapGraphEdge::kProperty, "str");
- CHECK_NE(NULL, map_s);
- CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(map_s->GetId()));
+ CHECK(map_s);
+ CHECK_EQ(s->GetId(), map_s->GetId());
}
@@ -647,32 +664,23 @@
v8::ObjectTemplate::New(isolate);
global_template->SetInternalFieldCount(2);
LocalContext env(NULL, global_template);
- v8::Handle<v8::Object> global_proxy = env->Global();
- v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
+ v8::Local<v8::Object> global_proxy = env->Global();
+ v8::Local<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
CHECK_EQ(2, global->InternalFieldCount());
v8::Local<v8::Object> obj = v8::Object::New(isolate);
global->SetInternalField(0, v8_num(17));
global->SetInternalField(1, obj);
v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("internals"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
// The first reference will not present, because it's a Smi.
- CHECK_EQ(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0"));
+ CHECK(!GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0"));
// The second reference is to an object.
- CHECK_NE(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "1"));
+ CHECK(GetProperty(global_node, v8::HeapGraphEdge::kInternal, "1"));
}
-// Trying to introduce a check helper for uint32_t causes many
-// overloading ambiguities, so it seems easier just to cast
-// them to a signed type.
-#define CHECK_EQ_SNAPSHOT_OBJECT_ID(a, b) \
- CHECK_EQ(static_cast<int32_t>(a), static_cast<int32_t>(b))
-#define CHECK_NE_SNAPSHOT_OBJECT_ID(a, b) \
- CHECK((a) != (b)) // NOLINT
-
TEST(HeapSnapshotAddressReuse) {
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
@@ -683,24 +691,22 @@
"var a = [];\n"
"for (var i = 0; i < 10000; ++i)\n"
" a[i] = new A();\n");
- const v8::HeapSnapshot* snapshot1 =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot1"));
+ const v8::HeapSnapshot* snapshot1 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot1));
v8::SnapshotObjectId maxId1 = snapshot1->GetMaxSnapshotJSObjectId();
CompileRun(
"for (var i = 0; i < 10000; ++i)\n"
" a[i] = new A();\n");
- CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+ CcTest::heap()->CollectAllGarbage();
- const v8::HeapSnapshot* snapshot2 =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot2"));
+ const v8::HeapSnapshot* snapshot2 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot2));
const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2);
const v8::HeapGraphNode* array_node =
GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, array_node);
+ CHECK(array_node);
int wrong_count = 0;
for (int i = 0, count = array_node->GetChildrenCount(); i < count; ++i) {
const v8::HeapGraphEdge* prop = array_node->GetChild(i);
@@ -727,40 +733,38 @@
"var a = new Array();\n"
"for (var i = 0; i < 10; ++i)\n"
" a.push(new AnObject());\n");
- const v8::HeapSnapshot* snapshot1 =
- heap_profiler->TakeHeapSnapshot(v8_str("s1"));
+ const v8::HeapSnapshot* snapshot1 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot1));
CompileRun(
"for (var i = 0; i < 1; ++i)\n"
" a.shift();\n");
- CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+ CcTest::heap()->CollectAllGarbage();
- const v8::HeapSnapshot* snapshot2 =
- heap_profiler->TakeHeapSnapshot(v8_str("s2"));
+ const v8::HeapSnapshot* snapshot2 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot2));
const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1);
const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2);
- CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId());
+ CHECK_NE(0u, global1->GetId());
+ CHECK_EQ(global1->GetId(), global2->GetId());
const v8::HeapGraphNode* a1 =
GetProperty(global1, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, a1);
+ CHECK(a1);
const v8::HeapGraphNode* k1 =
GetProperty(a1, v8::HeapGraphEdge::kInternal, "elements");
- CHECK_NE(NULL, k1);
+ CHECK(k1);
const v8::HeapGraphNode* a2 =
GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, a2);
+ CHECK(a2);
const v8::HeapGraphNode* k2 =
GetProperty(a2, v8::HeapGraphEdge::kInternal, "elements");
- CHECK_NE(NULL, k2);
+ CHECK(k2);
- CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(k1->GetId(), k2->GetId());
+ CHECK_EQ(a1->GetId(), a2->GetId());
+ CHECK_EQ(k1->GetId(), k2->GetId());
}
@@ -774,58 +778,54 @@
"function B(x) { this.x = x; }\n"
"var a = new A();\n"
"var b = new B(a);");
- v8::Local<v8::String> s1_str = v8_str("s1");
- v8::Local<v8::String> s2_str = v8_str("s2");
- const v8::HeapSnapshot* snapshot1 =
- heap_profiler->TakeHeapSnapshot(s1_str);
+ const v8::HeapSnapshot* snapshot1 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot1));
- CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+ CcTest::heap()->CollectAllGarbage();
- const v8::HeapSnapshot* snapshot2 =
- heap_profiler->TakeHeapSnapshot(s2_str);
+ const v8::HeapSnapshot* snapshot2 = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot2));
- CHECK_GT(snapshot1->GetMaxSnapshotJSObjectId(), 7000);
+ CHECK_GT(snapshot1->GetMaxSnapshotJSObjectId(), 7000u);
CHECK(snapshot1->GetMaxSnapshotJSObjectId() <=
snapshot2->GetMaxSnapshotJSObjectId());
const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1);
const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2);
- CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId());
+ CHECK_NE(0u, global1->GetId());
+ CHECK_EQ(global1->GetId(), global2->GetId());
const v8::HeapGraphNode* A1 =
GetProperty(global1, v8::HeapGraphEdge::kProperty, "A");
- CHECK_NE(NULL, A1);
+ CHECK(A1);
const v8::HeapGraphNode* A2 =
GetProperty(global2, v8::HeapGraphEdge::kProperty, "A");
- CHECK_NE(NULL, A2);
- CHECK_NE_SNAPSHOT_OBJECT_ID(0, A1->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(A1->GetId(), A2->GetId());
+ CHECK(A2);
+ CHECK_NE(0u, A1->GetId());
+ CHECK_EQ(A1->GetId(), A2->GetId());
const v8::HeapGraphNode* B1 =
GetProperty(global1, v8::HeapGraphEdge::kProperty, "B");
- CHECK_NE(NULL, B1);
+ CHECK(B1);
const v8::HeapGraphNode* B2 =
GetProperty(global2, v8::HeapGraphEdge::kProperty, "B");
- CHECK_NE(NULL, B2);
- CHECK_NE_SNAPSHOT_OBJECT_ID(0, B1->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(B1->GetId(), B2->GetId());
+ CHECK(B2);
+ CHECK_NE(0u, B1->GetId());
+ CHECK_EQ(B1->GetId(), B2->GetId());
const v8::HeapGraphNode* a1 =
GetProperty(global1, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, a1);
+ CHECK(a1);
const v8::HeapGraphNode* a2 =
GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");
- CHECK_NE(NULL, a2);
- CHECK_NE_SNAPSHOT_OBJECT_ID(0, a1->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId());
+ CHECK(a2);
+ CHECK_NE(0u, a1->GetId());
+ CHECK_EQ(a1->GetId(), a2->GetId());
const v8::HeapGraphNode* b1 =
GetProperty(global1, v8::HeapGraphEdge::kProperty, "b");
- CHECK_NE(NULL, b1);
+ CHECK(b1);
const v8::HeapGraphNode* b2 =
GetProperty(global2, v8::HeapGraphEdge::kProperty, "b");
- CHECK_NE(NULL, b2);
- CHECK_NE_SNAPSHOT_OBJECT_ID(0, b1->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(b1->GetId(), b2->GetId());
+ CHECK(b2);
+ CHECK_NE(0u, b1->GetId());
+ CHECK_EQ(b1->GetId(), b2->GetId());
}
@@ -833,8 +833,7 @@
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("s"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* root1 = snapshot->GetRoot();
const_cast<i::HeapSnapshot*>(reinterpret_cast<const i::HeapSnapshot*>(
@@ -862,7 +861,7 @@
return kContinue;
}
virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int chars_written) {
- DCHECK(false);
+ CHECK(false);
return kAbort;
}
void WriteTo(i::Vector<char> dest) { buffer_.WriteTo(dest); }
@@ -902,8 +901,7 @@
"function B(x) { this.x = x; }\n"
"var a = new A(" STRING_LITERAL_FOR_TEST ");\n"
"var b = new B(a);");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("json"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
TestJSONStream stream;
@@ -916,19 +914,26 @@
// Verify that snapshot string is valid JSON.
OneByteResource* json_res = new OneByteResource(json);
v8::Local<v8::String> json_string =
- v8::String::NewExternal(env->GetIsolate(), json_res);
- env->Global()->Set(v8_str("json_snapshot"), json_string);
+ v8::String::NewExternalOneByte(env->GetIsolate(), json_res)
+ .ToLocalChecked();
+ env->Global()
+ ->Set(env.local(), v8_str("json_snapshot"), json_string)
+ .FromJust();
v8::Local<v8::Value> snapshot_parse_result = CompileRun(
"var parsed = JSON.parse(json_snapshot); true;");
CHECK(!snapshot_parse_result.IsEmpty());
// Verify that snapshot object has required fields.
v8::Local<v8::Object> parsed_snapshot =
- env->Global()->Get(v8_str("parsed"))->ToObject(isolate);
- CHECK(parsed_snapshot->Has(v8_str("snapshot")));
- CHECK(parsed_snapshot->Has(v8_str("nodes")));
- CHECK(parsed_snapshot->Has(v8_str("edges")));
- CHECK(parsed_snapshot->Has(v8_str("strings")));
+ env->Global()
+ ->Get(env.local(), v8_str("parsed"))
+ .ToLocalChecked()
+ ->ToObject(env.local())
+ .ToLocalChecked();
+ CHECK(parsed_snapshot->Has(env.local(), v8_str("snapshot")).FromJust());
+ CHECK(parsed_snapshot->Has(env.local(), v8_str("nodes")).FromJust());
+ CHECK(parsed_snapshot->Has(env.local(), v8_str("edges")).FromJust());
+ CHECK(parsed_snapshot->Has(env.local(), v8_str("strings")).FromJust());
// Get node and edge "member" offsets.
v8::Local<v8::Value> meta_analysis_result = CompileRun(
@@ -979,22 +984,35 @@
" \"x\", property_type),"
" \"s\", property_type)");
CHECK(!string_obj_pos_val.IsEmpty());
- int string_obj_pos =
- static_cast<int>(string_obj_pos_val->ToNumber(isolate)->Value());
+ int string_obj_pos = static_cast<int>(
+ string_obj_pos_val->ToNumber(env.local()).ToLocalChecked()->Value());
v8::Local<v8::Object> nodes_array =
- parsed_snapshot->Get(v8_str("nodes"))->ToObject(isolate);
- int string_index = static_cast<int>(
- nodes_array->Get(string_obj_pos + 1)->ToNumber(isolate)->Value());
+ parsed_snapshot->Get(env.local(), v8_str("nodes"))
+ .ToLocalChecked()
+ ->ToObject(env.local())
+ .ToLocalChecked();
+ int string_index =
+ static_cast<int>(nodes_array->Get(env.local(), string_obj_pos + 1)
+ .ToLocalChecked()
+ ->ToNumber(env.local())
+ .ToLocalChecked()
+ ->Value());
CHECK_GT(string_index, 0);
v8::Local<v8::Object> strings_array =
- parsed_snapshot->Get(v8_str("strings"))->ToObject(isolate);
- v8::Local<v8::String> string =
- strings_array->Get(string_index)->ToString(isolate);
- v8::Local<v8::String> ref_string =
- CompileRun(STRING_LITERAL_FOR_TEST)->ToString(isolate);
+ parsed_snapshot->Get(env.local(), v8_str("strings"))
+ .ToLocalChecked()
+ ->ToObject(env.local())
+ .ToLocalChecked();
+ v8::Local<v8::String> string = strings_array->Get(env.local(), string_index)
+ .ToLocalChecked()
+ ->ToString(env.local())
+ .ToLocalChecked();
+ v8::Local<v8::String> ref_string = CompileRun(STRING_LITERAL_FOR_TEST)
+ ->ToString(env.local())
+ .ToLocalChecked();
#undef STRING_LITERAL_FOR_TEST
- CHECK_EQ(*v8::String::Utf8Value(ref_string),
- *v8::String::Utf8Value(string));
+ CHECK_EQ(0, strcmp(*v8::String::Utf8Value(ref_string),
+ *v8::String::Utf8Value(string)));
}
@@ -1002,8 +1020,7 @@
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("abort"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
TestJSONStream stream(5);
snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON);
@@ -1033,13 +1050,13 @@
virtual ~TestStatsStream() {}
virtual void EndOfStream() { ++eos_signaled_; }
virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {
- DCHECK(false);
+ CHECK(false);
return kAbort;
}
virtual WriteResult WriteHeapStatsChunk(v8::HeapStatsUpdate* buffer,
int updates_written) {
++intervals_count_;
- DCHECK(updates_written);
+ CHECK(updates_written);
updates_written_ += updates_written;
entries_count_ = 0;
if (first_interval_index_ == -1 && updates_written != 0)
@@ -1073,9 +1090,12 @@
v8::HeapProfiler* heap_profiler,
v8::SnapshotObjectId* object_id = NULL) {
TestStatsStream stream;
- v8::SnapshotObjectId last_seen_id = heap_profiler->GetHeapStats(&stream);
+ int64_t timestamp = -1;
+ v8::SnapshotObjectId last_seen_id =
+ heap_profiler->GetHeapStats(&stream, ×tamp);
if (object_id)
*object_id = last_seen_id;
+ CHECK_NE(-1, timestamp);
CHECK_EQ(1, stream.eos_signaled());
return stream;
}
@@ -1090,7 +1110,7 @@
// We have to call GC 6 times. In other case the garbage will be
// the reason of flakiness.
for (int i = 0; i < 6; ++i) {
- CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+ CcTest::heap()->CollectAllGarbage();
}
v8::SnapshotObjectId initial_id;
@@ -1100,14 +1120,14 @@
&initial_id);
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
- CHECK_LT(0, stats_update.entries_size());
+ CHECK_LT(0u, stats_update.entries_size());
CHECK_EQ(0, stats_update.first_interval_index());
}
// No data expected in update because nothing has happened.
v8::SnapshotObjectId same_id;
CHECK_EQ(0, GetHeapStatsUpdate(heap_profiler, &same_id).updates_written());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(initial_id, same_id);
+ CHECK_EQ(initial_id, same_id);
{
v8::SnapshotObjectId additional_string_id;
@@ -1120,15 +1140,15 @@
CHECK_LT(same_id, additional_string_id);
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
- CHECK_LT(0, stats_update.entries_size());
- CHECK_EQ(1, stats_update.entries_count());
+ CHECK_LT(0u, stats_update.entries_size());
+ CHECK_EQ(1u, stats_update.entries_count());
CHECK_EQ(2, stats_update.first_interval_index());
}
// No data expected in update because nothing happened.
v8::SnapshotObjectId last_id;
CHECK_EQ(0, GetHeapStatsUpdate(heap_profiler, &last_id).updates_written());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(additional_string_id, last_id);
+ CHECK_EQ(additional_string_id, last_id);
{
v8::HandleScope inner_scope_2(env->GetIsolate());
@@ -1145,8 +1165,8 @@
TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
- CHECK_LT(0, entries_size = stats_update.entries_size());
- CHECK_EQ(3, stats_update.entries_count());
+ CHECK_LT(0u, entries_size = stats_update.entries_size());
+ CHECK_EQ(3u, stats_update.entries_count());
CHECK_EQ(4, stats_update.first_interval_index());
}
}
@@ -1157,7 +1177,7 @@
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
CHECK_GT(entries_size, stats_update.entries_size());
- CHECK_EQ(1, stats_update.entries_count());
+ CHECK_EQ(1u, stats_update.entries_count());
// Two strings from forth interval were released.
CHECK_EQ(4, stats_update.first_interval_index());
}
@@ -1168,8 +1188,8 @@
TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
- CHECK_EQ(0, stats_update.entries_size());
- CHECK_EQ(0, stats_update.entries_count());
+ CHECK_EQ(0u, stats_update.entries_size());
+ CHECK_EQ(0u, stats_update.entries_count());
// The last string from forth interval was released.
CHECK_EQ(4, stats_update.first_interval_index());
}
@@ -1179,16 +1199,16 @@
TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
- CHECK_EQ(0, stats_update.entries_size());
- CHECK_EQ(0, stats_update.entries_count());
+ CHECK_EQ(0u, stats_update.entries_size());
+ CHECK_EQ(0u, stats_update.entries_count());
// The only string from the second interval was released.
CHECK_EQ(2, stats_update.first_interval_index());
}
v8::Local<v8::Array> array = v8::Array::New(env->GetIsolate());
- CHECK_EQ(0, array->Length());
+ CHECK_EQ(0u, array->Length());
// Force array's buffer allocation.
- array->Set(2, v8_num(7));
+ array->Set(env.local(), 2, v8_num(7)).FromJust();
uint32_t entries_size;
{
@@ -1196,14 +1216,14 @@
TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
CHECK_EQ(1, stats_update.intervals_count());
CHECK_EQ(1, stats_update.updates_written());
- CHECK_LT(0, entries_size = stats_update.entries_size());
+ CHECK_LT(0u, entries_size = stats_update.entries_size());
// They are the array and its buffer.
- CHECK_EQ(2, stats_update.entries_count());
+ CHECK_EQ(2u, stats_update.entries_count());
CHECK_EQ(8, stats_update.first_interval_index());
}
for (int i = 0; i < 100; ++i)
- array->Set(i, v8_num(i));
+ array->Set(env.local(), i, v8_num(i)).FromJust();
{
// Single chunk of data with 1 entry expected in update.
@@ -1213,7 +1233,7 @@
// The second interval was changed because new buffer was allocated.
CHECK_EQ(2, stats_update.updates_written());
CHECK_LT(entries_size, stats_update.entries_size());
- CHECK_EQ(2, stats_update.entries_count());
+ CHECK_EQ(2u, stats_update.entries_count());
CHECK_EQ(8, stats_update.first_interval_index());
}
@@ -1228,7 +1248,7 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
const int kLength = 10;
- v8::Handle<v8::Object> objects[kLength];
+ v8::Local<v8::Object> objects[kLength];
v8::SnapshotObjectId ids[kLength];
heap_profiler->StartTrackingHeapObjects(false);
@@ -1240,7 +1260,7 @@
for (int i = 0; i < kLength; i++) {
v8::SnapshotObjectId id = heap_profiler->GetObjectId(objects[i]);
- CHECK_NE(v8::HeapProfiler::kUnknownObjectId, static_cast<int>(id));
+ CHECK_NE(v8::HeapProfiler::kUnknownObjectId, id);
ids[i] = id;
}
@@ -1249,16 +1269,16 @@
for (int i = 0; i < kLength; i++) {
v8::SnapshotObjectId id = heap_profiler->GetObjectId(objects[i]);
- CHECK_EQ(static_cast<int>(ids[i]), static_cast<int>(id));
- v8::Handle<v8::Value> obj = heap_profiler->FindObjectById(ids[i]);
- CHECK_EQ(objects[i], obj);
+ CHECK_EQ(ids[i], id);
+ v8::Local<v8::Value> obj = heap_profiler->FindObjectById(ids[i]);
+ CHECK(objects[i]->Equals(env.local(), obj).FromJust());
}
heap_profiler->ClearObjectIds();
for (int i = 0; i < kLength; i++) {
v8::SnapshotObjectId id = heap_profiler->GetObjectId(objects[i]);
- CHECK_EQ(v8::HeapProfiler::kUnknownObjectId, static_cast<int>(id));
- v8::Handle<v8::Value> obj = heap_profiler->FindObjectById(ids[i]);
+ CHECK_EQ(v8::HeapProfiler::kUnknownObjectId, id);
+ v8::Local<v8::Value> obj = heap_profiler->FindObjectById(ids[i]);
CHECK(obj.IsEmpty());
}
}
@@ -1273,7 +1293,7 @@
const v8::HeapGraphEdge* prop = node->GetChild(i);
const v8::HeapGraphNode* child =
snapshot->GetNodeById(prop->GetToNode()->GetId());
- CHECK_EQ_SNAPSHOT_OBJECT_ID(prop->GetToNode()->GetId(), child->GetId());
+ CHECK_EQ(prop->GetToNode()->GetId(), child->GetId());
CHECK_EQ(prop->GetToNode(), child);
CheckChildrenIds(snapshot, child, level + 1, max_level);
}
@@ -1285,13 +1305,12 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("id"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* root = snapshot->GetRoot();
CheckChildrenIds(snapshot, root, 0, 3);
// Check a big id, which should not exist yet.
- CHECK_EQ(NULL, snapshot->GetNodeById(0x1000000UL));
+ CHECK(!snapshot->GetNodeById(0x1000000UL));
}
@@ -1300,23 +1319,21 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("globalObject = {};\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("get_snapshot_object_id"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* global_object =
GetProperty(global, v8::HeapGraphEdge::kProperty, "globalObject");
CHECK(global_object);
- v8::Local<v8::Value> globalObjectHandle = env->Global()->Get(
- v8::String::NewFromUtf8(env->GetIsolate(), "globalObject"));
+ v8::Local<v8::Value> globalObjectHandle =
+ env->Global()->Get(env.local(), v8_str("globalObject")).ToLocalChecked();
CHECK(!globalObjectHandle.IsEmpty());
CHECK(globalObjectHandle->IsObject());
v8::SnapshotObjectId id = heap_profiler->GetObjectId(globalObjectHandle);
- CHECK_NE(static_cast<int>(v8::HeapProfiler::kUnknownObjectId),
- id);
- CHECK_EQ(static_cast<int>(id), global_object->GetId());
+ CHECK_NE(v8::HeapProfiler::kUnknownObjectId, id);
+ CHECK_EQ(id, global_object->GetId());
}
@@ -1325,12 +1342,11 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("globalObject = {};\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("unknown_object_id"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* node =
snapshot->GetNodeById(v8::HeapProfiler::kUnknownObjectId);
- CHECK_EQ(NULL, node);
+ CHECK(!node);
}
@@ -1353,7 +1369,8 @@
int total_;
int abort_count_;
};
-}
+
+} // namespace
TEST(TakeHeapSnapshotAborting) {
@@ -1364,19 +1381,16 @@
const int snapshots_count = heap_profiler->GetSnapshotCount();
TestActivityControl aborting_control(1);
const v8::HeapSnapshot* no_snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("abort"),
- &aborting_control);
- CHECK_EQ(NULL, no_snapshot);
+ heap_profiler->TakeHeapSnapshot(&aborting_control);
+ CHECK(!no_snapshot);
CHECK_EQ(snapshots_count, heap_profiler->GetSnapshotCount());
CHECK_GT(aborting_control.total(), aborting_control.done());
TestActivityControl control(-1); // Don't abort.
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("full"),
- &control);
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot(&control);
CHECK(ValidateSnapshot(snapshot));
- CHECK_NE(NULL, snapshot);
+ CHECK(snapshot);
CHECK_EQ(snapshots_count + 1, heap_profiler->GetSnapshotCount());
CHECK_EQ(control.total(), control.done());
CHECK_GT(control.total(), 0);
@@ -1416,7 +1430,7 @@
bool disposed() { return disposed_; }
static v8::RetainedObjectInfo* WrapperInfoCallback(
- uint16_t class_id, v8::Handle<v8::Value> wrapper) {
+ uint16_t class_id, v8::Local<v8::Value> wrapper) {
if (class_id == 1) {
if (wrapper->IsString()) {
v8::String::Utf8Value utf8(wrapper);
@@ -1449,7 +1463,8 @@
i::List<TestRetainedObjectInfo*> TestRetainedObjectInfo::instances;
-}
+
+} // namespace
static const v8::HeapGraphNode* GetNode(const v8::HeapGraphNode* parent,
@@ -1484,8 +1499,7 @@
v8::Persistent<v8::String> p_CCC(isolate, v8_str("CCC"));
p_CCC.SetWrapperClassId(2);
CHECK_EQ(0, TestRetainedObjectInfo::instances.length());
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("retained"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
CHECK_EQ(3, TestRetainedObjectInfo::instances.length());
@@ -1496,29 +1510,29 @@
const v8::HeapGraphNode* native_group_aaa = GetNode(
snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "aaa-group");
- CHECK_NE(NULL, native_group_aaa);
+ CHECK(native_group_aaa);
CHECK_EQ(1, native_group_aaa->GetChildrenCount());
const v8::HeapGraphNode* aaa = GetNode(
native_group_aaa, v8::HeapGraphNode::kNative, "aaa / 100 entries");
- CHECK_NE(NULL, aaa);
+ CHECK(aaa);
CHECK_EQ(2, aaa->GetChildrenCount());
const v8::HeapGraphNode* native_group_ccc = GetNode(
snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "ccc-group");
const v8::HeapGraphNode* ccc = GetNode(
native_group_ccc, v8::HeapGraphNode::kNative, "ccc");
- CHECK_NE(NULL, ccc);
+ CHECK(ccc);
const v8::HeapGraphNode* n_AAA = GetNode(
aaa, v8::HeapGraphNode::kString, "AAA");
- CHECK_NE(NULL, n_AAA);
+ CHECK(n_AAA);
const v8::HeapGraphNode* n_BBB = GetNode(
aaa, v8::HeapGraphNode::kString, "BBB");
- CHECK_NE(NULL, n_BBB);
+ CHECK(n_BBB);
CHECK_EQ(1, ccc->GetChildrenCount());
const v8::HeapGraphNode* n_CCC = GetNode(
ccc, v8::HeapGraphNode::kString, "CCC");
- CHECK_NE(NULL, n_CCC);
+ CHECK(n_CCC);
CHECK_EQ(aaa, GetProperty(n_AAA, v8::HeapGraphEdge::kInternal, "native"));
CHECK_EQ(aaa, GetProperty(n_BBB, v8::HeapGraphEdge::kInternal, "native"));
@@ -1530,20 +1544,24 @@
public:
static const int kObjectsCount = 4;
explicit GraphWithImplicitRefs(LocalContext* env) {
- CHECK_EQ(NULL, instance_);
+ CHECK(!instance_);
instance_ = this;
isolate_ = (*env)->GetIsolate();
for (int i = 0; i < kObjectsCount; i++) {
objects_[i].Reset(isolate_, v8::Object::New(isolate_));
}
- (*env)->Global()->Set(v8_str("root_object"),
- v8::Local<v8::Value>::New(isolate_, objects_[0]));
+ (*env)
+ ->Global()
+ ->Set(isolate_->GetCurrentContext(), v8_str("root_object"),
+ v8::Local<v8::Value>::New(isolate_, objects_[0]))
+ .FromJust();
}
~GraphWithImplicitRefs() {
instance_ = NULL;
}
- static void gcPrologue(v8::GCType type, v8::GCCallbackFlags flags) {
+ static void gcPrologue(v8::Isolate* isolate, v8::GCType type,
+ v8::GCCallbackFlags flags) {
instance_->AddImplicitReferences();
}
@@ -1575,10 +1593,9 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
GraphWithImplicitRefs graph(&env);
- v8::V8::AddGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue);
+ env->GetIsolate()->AddGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue);
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("implicit_refs"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global_object = GetGlobalObject(snapshot);
@@ -1599,7 +1616,8 @@
}
}
CHECK_EQ(2, implicit_targets_count);
- v8::V8::RemoveGCPrologueCallback(&GraphWithImplicitRefs::gcPrologue);
+ env->GetIsolate()->RemoveGCPrologueCallback(
+ &GraphWithImplicitRefs::gcPrologue);
}
@@ -1611,28 +1629,25 @@
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
heap_profiler->DeleteAllHeapSnapshots();
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
- CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("1")));
+ CHECK(heap_profiler->TakeHeapSnapshot());
CHECK_EQ(1, heap_profiler->GetSnapshotCount());
heap_profiler->DeleteAllHeapSnapshots();
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
- CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("1")));
- CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("2")));
+ CHECK(heap_profiler->TakeHeapSnapshot());
+ CHECK(heap_profiler->TakeHeapSnapshot());
CHECK_EQ(2, heap_profiler->GetSnapshotCount());
heap_profiler->DeleteAllHeapSnapshots();
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
}
-static const v8::HeapSnapshot* FindHeapSnapshot(v8::HeapProfiler* profiler,
- unsigned uid) {
+static bool FindHeapSnapshot(v8::HeapProfiler* profiler,
+ const v8::HeapSnapshot* snapshot) {
int length = profiler->GetSnapshotCount();
for (int i = 0; i < length; i++) {
- const v8::HeapSnapshot* snapshot = profiler->GetHeapSnapshot(i);
- if (snapshot->GetUid() == uid) {
- return snapshot;
- }
+ if (snapshot == profiler->GetHeapSnapshot(i)) return true;
}
- return NULL;
+ return false;
}
@@ -1642,44 +1657,37 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
- const v8::HeapSnapshot* s1 =
- heap_profiler->TakeHeapSnapshot(v8_str("1"));
+ const v8::HeapSnapshot* s1 = heap_profiler->TakeHeapSnapshot();
- CHECK_NE(NULL, s1);
+ CHECK(s1);
CHECK_EQ(1, heap_profiler->GetSnapshotCount());
- unsigned uid1 = s1->GetUid();
- CHECK_EQ(s1, FindHeapSnapshot(heap_profiler, uid1));
+ CHECK(FindHeapSnapshot(heap_profiler, s1));
const_cast<v8::HeapSnapshot*>(s1)->Delete();
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
- CHECK_EQ(NULL, FindHeapSnapshot(heap_profiler, uid1));
+ CHECK(!FindHeapSnapshot(heap_profiler, s1));
- const v8::HeapSnapshot* s2 =
- heap_profiler->TakeHeapSnapshot(v8_str("2"));
- CHECK_NE(NULL, s2);
+ const v8::HeapSnapshot* s2 = heap_profiler->TakeHeapSnapshot();
+ CHECK(s2);
CHECK_EQ(1, heap_profiler->GetSnapshotCount());
- unsigned uid2 = s2->GetUid();
- CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2));
- CHECK_EQ(s2, FindHeapSnapshot(heap_profiler, uid2));
- const v8::HeapSnapshot* s3 =
- heap_profiler->TakeHeapSnapshot(v8_str("3"));
- CHECK_NE(NULL, s3);
+ CHECK(FindHeapSnapshot(heap_profiler, s2));
+ const v8::HeapSnapshot* s3 = heap_profiler->TakeHeapSnapshot();
+ CHECK(s3);
CHECK_EQ(2, heap_profiler->GetSnapshotCount());
- unsigned uid3 = s3->GetUid();
- CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3));
- CHECK_EQ(s3, FindHeapSnapshot(heap_profiler, uid3));
+ CHECK_NE(s2, s3);
+ CHECK(FindHeapSnapshot(heap_profiler, s3));
const_cast<v8::HeapSnapshot*>(s2)->Delete();
CHECK_EQ(1, heap_profiler->GetSnapshotCount());
- CHECK_EQ(NULL, FindHeapSnapshot(heap_profiler, uid2));
- CHECK_EQ(s3, FindHeapSnapshot(heap_profiler, uid3));
+ CHECK(!FindHeapSnapshot(heap_profiler, s2));
+ CHECK(FindHeapSnapshot(heap_profiler, s3));
const_cast<v8::HeapSnapshot*>(s3)->Delete();
CHECK_EQ(0, heap_profiler->GetSnapshotCount());
- CHECK_EQ(NULL, FindHeapSnapshot(heap_profiler, uid3));
+ CHECK(!FindHeapSnapshot(heap_profiler, s3));
}
class NameResolver : public v8::HeapProfiler::ObjectNameResolver {
public:
- virtual const char* GetName(v8::Handle<v8::Object> object) {
+ virtual const char* GetName(v8::Local<v8::Object> object) {
return "Global object name";
}
};
@@ -1694,15 +1702,14 @@
NameResolver name_resolver;
const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("document"),
- NULL,
- &name_resolver);
+ heap_profiler->TakeHeapSnapshot(NULL, &name_resolver);
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
- CHECK_EQ("Object / Global object name" ,
- const_cast<i::HeapEntry*>(
- reinterpret_cast<const i::HeapEntry*>(global))->name());
+ CHECK(global);
+ CHECK_EQ(0,
+ strcmp("Object / Global object name",
+ const_cast<i::HeapEntry*>(
+ reinterpret_cast<const i::HeapEntry*>(global))->name()));
}
@@ -1711,19 +1718,15 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("obj = {};");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- const v8::HeapGraphNode* builtins =
- GetProperty(global, v8::HeapGraphEdge::kInternal, "builtins");
- CHECK_NE(NULL, builtins);
const v8::HeapGraphNode* native_context =
GetProperty(global, v8::HeapGraphEdge::kInternal, "native_context");
- CHECK_NE(NULL, native_context);
+ CHECK(native_context);
const v8::HeapGraphNode* global_proxy =
GetProperty(global, v8::HeapGraphEdge::kInternal, "global_proxy");
- CHECK_NE(NULL, global_proxy);
+ CHECK(global_proxy);
}
@@ -1734,10 +1737,9 @@
CompileRun("document = { URL:\"abcdefgh\" };");
- v8::Handle<v8::String> name(v8_str("leakz"));
i::Isolate* isolate = CcTest::i_isolate();
int count_before = i::HandleScope::NumberOfHandles(isolate);
- heap_profiler->TakeHeapSnapshot(name);
+ heap_profiler->TakeHeapSnapshot();
int count_after = i::HandleScope::NumberOfHandles(isolate);
CHECK_EQ(count_before, count_after);
}
@@ -1747,11 +1749,10 @@
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("iteration"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
// Verify that we can find this object by iteration.
const int nodes_count = snapshot->GetNodesCount();
int count = 0;
@@ -1769,8 +1770,7 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("a = { s_prop: \'value\', n_prop: \'value2\' };");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("value"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
CHECK(heap_profiler->FindObjectById(global->GetId())->IsObject());
@@ -1780,17 +1780,21 @@
const v8::HeapGraphNode* obj = GetProperty(
global, v8::HeapGraphEdge::kProperty, "a");
CHECK(heap_profiler->FindObjectById(obj->GetId())->IsObject());
- v8::Local<v8::Object> js_obj = js_global->Get(v8_str("a")).As<v8::Object>();
+ v8::Local<v8::Object> js_obj = js_global->Get(env.local(), v8_str("a"))
+ .ToLocalChecked()
+ .As<v8::Object>();
CHECK(js_obj == heap_profiler->FindObjectById(obj->GetId()));
const v8::HeapGraphNode* s_prop =
GetProperty(obj, v8::HeapGraphEdge::kProperty, "s_prop");
- v8::Local<v8::String> js_s_prop =
- js_obj->Get(v8_str("s_prop")).As<v8::String>();
+ v8::Local<v8::String> js_s_prop = js_obj->Get(env.local(), v8_str("s_prop"))
+ .ToLocalChecked()
+ .As<v8::String>();
CHECK(js_s_prop == heap_profiler->FindObjectById(s_prop->GetId()));
const v8::HeapGraphNode* n_prop =
GetProperty(obj, v8::HeapGraphEdge::kProperty, "n_prop");
- v8::Local<v8::String> js_n_prop =
- js_obj->Get(v8_str("n_prop")).As<v8::String>();
+ v8::Local<v8::String> js_n_prop = js_obj->Get(env.local(), v8_str("n_prop"))
+ .ToLocalChecked()
+ .As<v8::String>();
CHECK(js_n_prop == heap_profiler->FindObjectById(n_prop->GetId()));
}
@@ -1804,8 +1808,7 @@
// property of the "a" object. Also, the "p" object can't be an empty one
// because the empty object is static and isn't actually deleted.
CompileRun("a = { p: { r: {} } };");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* obj = GetProperty(
@@ -1824,7 +1827,7 @@
static int StringCmp(const char* ref, i::String* act) {
- i::SmartArrayPointer<char> s_act = act->ToCString();
+ v8::base::SmartArrayPointer<char> s_act = act->ToCString();
int result = strcmp(ref, s_act.get());
if (result != 0)
fprintf(stderr, "Expected: \"%s\", Actual: \"%s\"\n", ref, s_act.get());
@@ -1842,42 +1845,56 @@
"var Constructor2 = function() {};\n"
"var obj2 = new Constructor2();\n"
"var obj3 = {};\n"
- "obj3.constructor = function Constructor3() {};\n"
+ "obj3.__proto__ = { constructor: function Constructor3() {} };\n"
"var obj4 = {};\n"
"// Slow properties\n"
"for (var i=0; i<2000; ++i) obj4[\"p\" + i] = i;\n"
- "obj4.constructor = function Constructor4() {};\n"
+ "obj4.__proto__ = { constructor: function Constructor4() {} };\n"
"var obj5 = {};\n"
"var obj6 = {};\n"
"obj6.constructor = 6;");
v8::Local<v8::Object> js_global =
env->Global()->GetPrototype().As<v8::Object>();
- v8::Local<v8::Object> obj1 = js_global->Get(v8_str("obj1")).As<v8::Object>();
- i::Handle<i::JSObject> js_obj1 = v8::Utils::OpenHandle(*obj1);
+ v8::Local<v8::Object> obj1 = js_global->Get(env.local(), v8_str("obj1"))
+ .ToLocalChecked()
+ .As<v8::Object>();
+ i::Handle<i::JSObject> js_obj1 =
+ i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj1));
CHECK_EQ(0, StringCmp(
"Constructor1", i::V8HeapExplorer::GetConstructorName(*js_obj1)));
- v8::Local<v8::Object> obj2 = js_global->Get(v8_str("obj2")).As<v8::Object>();
- i::Handle<i::JSObject> js_obj2 = v8::Utils::OpenHandle(*obj2);
+ v8::Local<v8::Object> obj2 = js_global->Get(env.local(), v8_str("obj2"))
+ .ToLocalChecked()
+ .As<v8::Object>();
+ i::Handle<i::JSObject> js_obj2 =
+ i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj2));
CHECK_EQ(0, StringCmp(
"Constructor2", i::V8HeapExplorer::GetConstructorName(*js_obj2)));
- v8::Local<v8::Object> obj3 = js_global->Get(v8_str("obj3")).As<v8::Object>();
- i::Handle<i::JSObject> js_obj3 = v8::Utils::OpenHandle(*obj3);
- // TODO(verwaest): Restore to Constructor3 once supported by the
- // heap-snapshot-generator.
- CHECK_EQ(
- 0, StringCmp("Object", i::V8HeapExplorer::GetConstructorName(*js_obj3)));
- v8::Local<v8::Object> obj4 = js_global->Get(v8_str("obj4")).As<v8::Object>();
- i::Handle<i::JSObject> js_obj4 = v8::Utils::OpenHandle(*obj4);
- // TODO(verwaest): Restore to Constructor4 once supported by the
- // heap-snapshot-generator.
- CHECK_EQ(
- 0, StringCmp("Object", i::V8HeapExplorer::GetConstructorName(*js_obj4)));
- v8::Local<v8::Object> obj5 = js_global->Get(v8_str("obj5")).As<v8::Object>();
- i::Handle<i::JSObject> js_obj5 = v8::Utils::OpenHandle(*obj5);
+ v8::Local<v8::Object> obj3 = js_global->Get(env.local(), v8_str("obj3"))
+ .ToLocalChecked()
+ .As<v8::Object>();
+ i::Handle<i::JSObject> js_obj3 =
+ i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj3));
+ CHECK_EQ(0, StringCmp("Constructor3",
+ i::V8HeapExplorer::GetConstructorName(*js_obj3)));
+ v8::Local<v8::Object> obj4 = js_global->Get(env.local(), v8_str("obj4"))
+ .ToLocalChecked()
+ .As<v8::Object>();
+ i::Handle<i::JSObject> js_obj4 =
+ i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj4));
+ CHECK_EQ(0, StringCmp("Constructor4",
+ i::V8HeapExplorer::GetConstructorName(*js_obj4)));
+ v8::Local<v8::Object> obj5 = js_global->Get(env.local(), v8_str("obj5"))
+ .ToLocalChecked()
+ .As<v8::Object>();
+ i::Handle<i::JSObject> js_obj5 =
+ i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj5));
CHECK_EQ(0, StringCmp(
"Object", i::V8HeapExplorer::GetConstructorName(*js_obj5)));
- v8::Local<v8::Object> obj6 = js_global->Get(v8_str("obj6")).As<v8::Object>();
- i::Handle<i::JSObject> js_obj6 = v8::Utils::OpenHandle(*obj6);
+ v8::Local<v8::Object> obj6 = js_global->Get(env.local(), v8_str("obj6"))
+ .ToLocalChecked()
+ .As<v8::Object>();
+ i::Handle<i::JSObject> js_obj6 =
+ i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj6));
CHECK_EQ(0, StringCmp(
"Object", i::V8HeapExplorer::GetConstructorName(*js_obj6)));
}
@@ -1895,24 +1912,23 @@
"obj1.__defineSetter__('propWithSetter', function Z(value) {\n"
" return this.value_ = value;\n"
"});\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("fastCaseAccessors"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
const v8::HeapGraphNode* obj1 =
GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1");
- CHECK_NE(NULL, obj1);
+ CHECK(obj1);
const v8::HeapGraphNode* func;
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithGetter");
- CHECK_NE(NULL, func);
+ CHECK(func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithGetter");
- CHECK_EQ(NULL, func);
+ CHECK(!func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithSetter");
- CHECK_NE(NULL, func);
+ CHECK(func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithSetter");
- CHECK_EQ(NULL, func);
+ CHECK(!func);
}
@@ -1937,23 +1953,24 @@
"});\n");
v8::Local<v8::Object> js_global =
env->Global()->GetPrototype().As<v8::Object>();
- i::Handle<i::JSObject> js_obj1 =
- v8::Utils::OpenHandle(*js_global->Get(v8_str("obj1")).As<v8::Object>());
+ i::Handle<i::JSReceiver> js_obj1 =
+ v8::Utils::OpenHandle(*js_global->Get(env.local(), v8_str("obj1"))
+ .ToLocalChecked()
+ .As<v8::Object>());
USE(js_obj1);
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("fastCaseAccessors"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
const v8::HeapGraphNode* obj1 =
GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1");
- CHECK_NE(NULL, obj1);
+ CHECK(obj1);
const v8::HeapGraphNode* func;
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get prop");
- CHECK_NE(NULL, func);
+ CHECK(func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set prop");
- CHECK_NE(NULL, func);
+ CHECK(func);
}
@@ -1970,24 +1987,23 @@
"obj1.__defineSetter__('propWithSetter', function Z(value) {\n"
" return this.value_ = value;\n"
"});\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("slowCaseAccessors"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
const v8::HeapGraphNode* obj1 =
GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1");
- CHECK_NE(NULL, obj1);
+ CHECK(obj1);
const v8::HeapGraphNode* func;
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithGetter");
- CHECK_NE(NULL, func);
+ CHECK(func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithGetter");
- CHECK_EQ(NULL, func);
+ CHECK(!func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithSetter");
- CHECK_NE(NULL, func);
+ CHECK(func);
func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithSetter");
- CHECK_EQ(NULL, func);
+ CHECK(!func);
}
@@ -2000,31 +2016,33 @@
CompileRun(
"function C(x) { this.a = this; this.b = x; }\n"
"c = new C(2012);\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("HiddenPropertiesFastCase1"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* c =
GetProperty(global, v8::HeapGraphEdge::kProperty, "c");
- CHECK_NE(NULL, c);
+ CHECK(c);
const v8::HeapGraphNode* hidden_props =
- GetProperty(c, v8::HeapGraphEdge::kInternal, "hidden_properties");
- CHECK_EQ(NULL, hidden_props);
+ GetProperty(c, v8::HeapGraphEdge::kProperty, "<symbol>");
+ CHECK(!hidden_props);
- v8::Handle<v8::Value> cHandle =
- env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "c"));
+ v8::Local<v8::Value> cHandle =
+ env->Global()->Get(env.local(), v8_str("c")).ToLocalChecked();
CHECK(!cHandle.IsEmpty() && cHandle->IsObject());
- cHandle->ToObject(isolate)->SetHiddenValue(v8_str("key"), v8_str("val"));
+ cHandle->ToObject(env.local())
+ .ToLocalChecked()
+ ->SetPrivate(env.local(),
+ v8::Private::ForApi(env->GetIsolate(), v8_str("key")),
+ v8_str("val"))
+ .FromJust();
- snapshot = heap_profiler->TakeHeapSnapshot(
- v8_str("HiddenPropertiesFastCase2"));
+ snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
global = GetGlobalObject(snapshot);
c = GetProperty(global, v8::HeapGraphEdge::kProperty, "c");
- CHECK_NE(NULL, c);
- hidden_props = GetProperty(c, v8::HeapGraphEdge::kInternal,
- "hidden_properties");
- CHECK_NE(NULL, hidden_props);
+ CHECK(c);
+ hidden_props = GetProperty(c, v8::HeapGraphEdge::kProperty, "<symbol>");
+ CHECK(hidden_props);
}
@@ -2034,37 +2052,36 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("function foo(x) { }\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("AccessorInfoTest"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* foo =
GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
- CHECK_NE(NULL, foo);
+ CHECK(foo);
const v8::HeapGraphNode* map =
GetProperty(foo, v8::HeapGraphEdge::kInternal, "map");
- CHECK_NE(NULL, map);
+ CHECK(map);
const v8::HeapGraphNode* descriptors =
GetProperty(map, v8::HeapGraphEdge::kInternal, "descriptors");
- CHECK_NE(NULL, descriptors);
+ CHECK(descriptors);
const v8::HeapGraphNode* length_name =
GetProperty(descriptors, v8::HeapGraphEdge::kInternal, "2");
- CHECK_NE(NULL, length_name);
- CHECK_EQ("length", *v8::String::Utf8Value(length_name->GetName()));
+ CHECK(length_name);
+ CHECK_EQ(0, strcmp("length", *v8::String::Utf8Value(length_name->GetName())));
const v8::HeapGraphNode* length_accessor =
GetProperty(descriptors, v8::HeapGraphEdge::kInternal, "4");
- CHECK_NE(NULL, length_accessor);
- CHECK_EQ("system / ExecutableAccessorInfo",
- *v8::String::Utf8Value(length_accessor->GetName()));
+ CHECK(length_accessor);
+ CHECK_EQ(0, strcmp("system / ExecutableAccessorInfo",
+ *v8::String::Utf8Value(length_accessor->GetName())));
const v8::HeapGraphNode* name =
GetProperty(length_accessor, v8::HeapGraphEdge::kInternal, "name");
- CHECK_NE(NULL, name);
+ CHECK(name);
const v8::HeapGraphNode* getter =
GetProperty(length_accessor, v8::HeapGraphEdge::kInternal, "getter");
- CHECK_NE(NULL, getter);
+ CHECK(getter);
const v8::HeapGraphNode* setter =
GetProperty(length_accessor, v8::HeapGraphEdge::kInternal, "setter");
- CHECK_NE(NULL, setter);
+ CHECK(setter);
}
@@ -2080,23 +2097,21 @@
bool HasWeakGlobalHandle() {
v8::Isolate* isolate = CcTest::isolate();
v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("weaks"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* gc_roots = GetNode(
snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "(GC roots)");
- CHECK_NE(NULL, gc_roots);
+ CHECK(gc_roots);
const v8::HeapGraphNode* global_handles = GetNode(
gc_roots, v8::HeapGraphNode::kSynthetic, "(Global handles)");
- CHECK_NE(NULL, global_handles);
+ CHECK(global_handles);
return HasWeakEdge(global_handles);
}
static void PersistentHandleCallback(
- const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
+ const v8::WeakCallbackInfo<v8::Persistent<v8::Object> >& data) {
data.GetParameter()->Reset();
- delete data.GetParameter();
}
@@ -2108,7 +2123,8 @@
v8::Persistent<v8::Object> handle(env->GetIsolate(),
v8::Object::New(env->GetIsolate()));
- handle.SetWeak(&handle, PersistentHandleCallback);
+ handle.SetWeak(&handle, PersistentHandleCallback,
+ v8::WeakCallbackType::kParameter);
CHECK(HasWeakGlobalHandle());
}
@@ -2121,11 +2137,10 @@
CompileRun(
"fun = (function (x) { return function () { return x + 1; } })(1);");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("fun"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
const v8::HeapGraphNode* fun =
GetProperty(global, v8::HeapGraphEdge::kProperty, "fun");
CHECK(!HasWeakEdge(fun));
@@ -2142,8 +2157,7 @@
CHECK(CcTest::i_isolate()->debug()->Load());
CompileRun("foo = {};");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* root = snapshot->GetRoot();
int globals_count = 0;
@@ -2154,7 +2168,7 @@
const v8::HeapGraphNode* global = edge->GetToNode();
const v8::HeapGraphNode* foo =
GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
- CHECK_NE(NULL, foo);
+ CHECK(foo);
}
}
CHECK_EQ(1, globals_count);
@@ -2167,15 +2181,14 @@
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("foo = {};");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* gc_roots = GetNode(
snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "(GC roots)");
- CHECK_NE(NULL, gc_roots);
+ CHECK(gc_roots);
const v8::HeapGraphNode* strong_roots = GetNode(
gc_roots, v8::HeapGraphNode::kSynthetic, "(Strong roots)");
- CHECK_NE(NULL, strong_roots);
+ CHECK(strong_roots);
for (int i = 0; i < strong_roots->GetChildrenCount(); ++i) {
const v8::HeapGraphEdge* edge = strong_roots->GetChild(i);
CHECK_EQ(v8::HeapGraphEdge::kInternal, edge->GetType());
@@ -2190,19 +2203,18 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("global_object = {};\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* global_object =
GetProperty(global, v8::HeapGraphEdge::kProperty, "global_object");
- CHECK_NE(NULL, global_object);
+ CHECK(global_object);
const v8::HeapGraphNode* properties =
GetProperty(global_object, v8::HeapGraphEdge::kInternal, "properties");
- CHECK_EQ(NULL, properties);
+ CHECK(!properties);
const v8::HeapGraphNode* elements =
GetProperty(global_object, v8::HeapGraphEdge::kInternal, "elements");
- CHECK_EQ(NULL, elements);
+ CHECK(!elements);
}
@@ -2211,23 +2223,22 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("obj = { a: 10 };\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* global_object =
GetProperty(global, v8::HeapGraphEdge::kProperty, "obj");
- CHECK_NE(NULL, global_object);
+ CHECK(global_object);
const v8::HeapGraphNode* map =
GetProperty(global_object, v8::HeapGraphEdge::kInternal, "map");
- CHECK_NE(NULL, map);
+ CHECK(map);
const v8::HeapGraphNode* own_descriptors = GetProperty(
map, v8::HeapGraphEdge::kInternal, "descriptors");
- CHECK_NE(NULL, own_descriptors);
+ CHECK(own_descriptors);
const v8::HeapGraphNode* own_transitions = GetProperty(
map, v8::HeapGraphEdge::kInternal, "transitions");
- CHECK_EQ(NULL, own_transitions);
+ CHECK(!own_transitions);
}
@@ -2250,18 +2261,17 @@
"result.push('return f_' + (n - 1) + ';');"
"result.push('})()');"
"var ok = eval(result.join('\\n'));");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
const v8::HeapGraphNode* ok_object =
GetProperty(global, v8::HeapGraphEdge::kProperty, "ok");
- CHECK_NE(NULL, ok_object);
+ CHECK(ok_object);
const v8::HeapGraphNode* context_object =
GetProperty(ok_object, v8::HeapGraphEdge::kInternal, "context");
- CHECK_NE(NULL, context_object);
+ CHECK(context_object);
// Check the objects are not duplicated in the context.
CHECK_EQ(v8::internal::Context::MIN_CONTEXT_SLOTS + num_objects - 1,
context_object->GetChildrenCount());
@@ -2272,7 +2282,7 @@
i::SNPrintF(var_name, "f_%d", i);
const v8::HeapGraphNode* f_object = GetProperty(
context_object, v8::HeapGraphEdge::kContextVariable, var_name.start());
- CHECK_NE(NULL, f_object);
+ CHECK(f_object);
}
}
@@ -2285,52 +2295,60 @@
CompileRun(
"fun = function () { var a = [3, 2, 1]; return a; }\n"
"fun();");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
- CHECK_NE(NULL, global);
+ CHECK(global);
const v8::HeapGraphNode* fun_code =
GetProperty(global, v8::HeapGraphEdge::kProperty, "fun");
- CHECK_NE(NULL, fun_code);
+ CHECK(fun_code);
const v8::HeapGraphNode* literals =
GetProperty(fun_code, v8::HeapGraphEdge::kInternal, "literals");
- CHECK_NE(NULL, literals);
+ CHECK(literals);
CHECK_EQ(v8::HeapGraphNode::kArray, literals->GetType());
- CHECK_EQ(2, literals->GetChildrenCount());
+ CHECK_EQ(1, literals->GetChildrenCount());
- // The second value in the literals array should be the boilerplate,
+ // The first value in the literals array should be the boilerplate,
// after an AllocationSite.
- const v8::HeapGraphEdge* prop = literals->GetChild(1);
+ const v8::HeapGraphEdge* prop = literals->GetChild(0);
const v8::HeapGraphNode* allocation_site = prop->GetToNode();
v8::String::Utf8Value name(allocation_site->GetName());
- CHECK_EQ("system / AllocationSite", *name);
+ CHECK_EQ(0, strcmp("system / AllocationSite", *name));
const v8::HeapGraphNode* transition_info =
GetProperty(allocation_site, v8::HeapGraphEdge::kInternal,
"transition_info");
- CHECK_NE(NULL, transition_info);
+ CHECK(transition_info);
const v8::HeapGraphNode* elements =
GetProperty(transition_info, v8::HeapGraphEdge::kInternal,
"elements");
- CHECK_NE(NULL, elements);
+ CHECK(elements);
CHECK_EQ(v8::HeapGraphNode::kArray, elements->GetType());
CHECK_EQ(v8::internal::FixedArray::SizeFor(3),
static_cast<int>(elements->GetShallowSize()));
- v8::Handle<v8::Value> array_val =
+ v8::Local<v8::Value> array_val =
heap_profiler->FindObjectById(transition_info->GetId());
CHECK(array_val->IsArray());
- v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(array_val);
+ v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(array_val);
// Verify the array is "a" in the code above.
- CHECK_EQ(3, array->Length());
- CHECK_EQ(v8::Integer::New(isolate, 3),
- array->Get(v8::Integer::New(isolate, 0)));
- CHECK_EQ(v8::Integer::New(isolate, 2),
- array->Get(v8::Integer::New(isolate, 1)));
- CHECK_EQ(v8::Integer::New(isolate, 1),
- array->Get(v8::Integer::New(isolate, 2)));
+ CHECK_EQ(3u, array->Length());
+ CHECK(v8::Integer::New(isolate, 3)
+ ->Equals(env.local(),
+ array->Get(env.local(), v8::Integer::New(isolate, 0))
+ .ToLocalChecked())
+ .FromJust());
+ CHECK(v8::Integer::New(isolate, 2)
+ ->Equals(env.local(),
+ array->Get(env.local(), v8::Integer::New(isolate, 1))
+ .ToLocalChecked())
+ .FromJust());
+ CHECK(v8::Integer::New(isolate, 1)
+ ->Equals(env.local(),
+ array->Get(env.local(), v8::Integer::New(isolate, 2))
+ .ToLocalChecked())
+ .FromJust());
}
@@ -2339,16 +2357,15 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("function foo(x, y) { return x + y; }\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* foo_func =
GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
- CHECK_NE(NULL, foo_func);
+ CHECK(foo_func);
const v8::HeapGraphNode* code =
GetProperty(foo_func, v8::HeapGraphEdge::kInternal, "code");
- CHECK_NE(NULL, code);
+ CHECK(code);
}
@@ -2381,8 +2398,7 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("var a = 1.1;");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("CheckCodeNames"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const char* stub_path[] = {
@@ -2393,22 +2409,19 @@
};
const v8::HeapGraphNode* node = GetNodeByPath(snapshot,
stub_path, arraysize(stub_path));
- CHECK_NE(NULL, node);
+ CHECK(node);
- const char* builtin_path1[] = {
- "::(GC roots)",
- "::(Builtins)",
- "::(KeyedLoadIC_Generic builtin)"
- };
+ const char* builtin_path1[] = {"::(GC roots)", "::(Builtins)",
+ "::(KeyedLoadIC_Megamorphic builtin)"};
node = GetNodeByPath(snapshot, builtin_path1, arraysize(builtin_path1));
- CHECK_NE(NULL, node);
+ CHECK(node);
const char* builtin_path2[] = {"::(GC roots)", "::(Builtins)",
"::(CompileLazy builtin)"};
node = GetNodeByPath(snapshot, builtin_path2, arraysize(builtin_path2));
- CHECK_NE(NULL, node);
+ CHECK(node);
v8::String::Utf8Value node_name(node->GetName());
- CHECK_EQ("(CompileLazy builtin)", *node_name);
+ CHECK_EQ(0, strcmp("(CompileLazy builtin)", *node_name));
}
@@ -2491,7 +2504,7 @@
const char* names[] = {""};
AllocationTracker* tracker =
reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
- CHECK_NE(NULL, tracker);
+ CHECK(tracker);
// Resolve all function locations.
tracker->PrepareForSerialization();
// Print for better diagnostics in case of failure.
@@ -2499,9 +2512,9 @@
AllocationTraceNode* node =
FindNode(tracker, Vector<const char*>(names, arraysize(names)));
- CHECK_NE(NULL, node);
- CHECK_GE(node->allocation_count(), 2);
- CHECK_GE(node->allocation_size(), 4 * 5);
+ CHECK(node);
+ CHECK_GE(node->allocation_count(), 2u);
+ CHECK_GE(node->allocation_size(), 4u * 5u);
heap_profiler->StopTrackingHeapObjects();
}
@@ -2517,7 +2530,7 @@
AllocationTracker* tracker =
reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
- CHECK_NE(NULL, tracker);
+ CHECK(tracker);
// Resolve all function locations.
tracker->PrepareForSerialization();
// Print for better diagnostics in case of failure.
@@ -2526,30 +2539,31 @@
const char* names[] = {"", "start", "f_0_0", "f_0_1", "f_0_2"};
AllocationTraceNode* node =
FindNode(tracker, Vector<const char*>(names, arraysize(names)));
- CHECK_NE(NULL, node);
- CHECK_GE(node->allocation_count(), 100);
+ CHECK(node);
+ CHECK_GE(node->allocation_count(), 100u);
CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
heap_profiler->StopTrackingHeapObjects();
}
static const char* inline_heap_allocation_source =
-"function f_0(x) {\n"
-" return f_1(x+1);\n"
-"}\n"
-"%NeverOptimizeFunction(f_0);\n"
-"function f_1(x) {\n"
-" return new f_2(x+1);\n"
-"}\n"
-"function f_2(x) {\n"
-" this.foo = x;\n"
-"}\n"
-"var instances = [];\n"
-"function start() {\n"
-" instances.push(f_0(0));\n"
-"}\n"
-"\n"
-"for (var i = 0; i < 100; i++) start();\n";
+ "function f_0(x) {\n"
+ " return f_1(x+1);\n"
+ "}\n"
+ "%NeverOptimizeFunction(f_0);\n"
+ "function f_1(x) {\n"
+ " return new f_2(x+1);\n"
+ "}\n"
+ "%NeverOptimizeFunction(f_1);\n"
+ "function f_2(x) {\n"
+ " this.foo = x;\n"
+ "}\n"
+ "var instances = [];\n"
+ "function start() {\n"
+ " instances.push(f_0(0));\n"
+ "}\n"
+ "\n"
+ "for (var i = 0; i < 100; i++) start();\n";
TEST(TrackBumpPointerAllocations) {
@@ -2567,7 +2581,7 @@
AllocationTracker* tracker =
reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
- CHECK_NE(NULL, tracker);
+ CHECK(tracker);
// Resolve all function locations.
tracker->PrepareForSerialization();
// Print for better diagnostics in case of failure.
@@ -2575,8 +2589,8 @@
AllocationTraceNode* node =
FindNode(tracker, Vector<const char*>(names, arraysize(names)));
- CHECK_NE(NULL, node);
- CHECK_GE(node->allocation_count(), 100);
+ CHECK(node);
+ CHECK_GE(node->allocation_count(), 100u);
CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
heap_profiler->StopTrackingHeapObjects();
}
@@ -2593,7 +2607,7 @@
AllocationTracker* tracker =
reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
- CHECK_NE(NULL, tracker);
+ CHECK(tracker);
// Resolve all function locations.
tracker->PrepareForSerialization();
// Print for better diagnostics in case of failure.
@@ -2601,8 +2615,8 @@
AllocationTraceNode* node =
FindNode(tracker, Vector<const char*>(names, arraysize(names)));
- CHECK_NE(NULL, node);
- CHECK_LT(node->allocation_count(), 100);
+ CHECK(node);
+ CHECK_LT(node->allocation_count(), 100u);
CcTest::heap()->DisableInlineAllocation();
heap_profiler->StopTrackingHeapObjects();
@@ -2618,12 +2632,12 @@
const char* names[] = { "(V8 API)" };
heap_profiler->StartTrackingHeapObjects(true);
- v8::Handle<v8::Object> o1 = v8::Object::New(env->GetIsolate());
+ v8::Local<v8::Object> o1 = v8::Object::New(env->GetIsolate());
o1->Clone();
AllocationTracker* tracker =
reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
- CHECK_NE(NULL, tracker);
+ CHECK(tracker);
// Resolve all function locations.
tracker->PrepareForSerialization();
// Print for better diagnostics in case of failure.
@@ -2631,8 +2645,8 @@
AllocationTraceNode* node =
FindNode(tracker, Vector<const char*>(names, arraysize(names)));
- CHECK_NE(NULL, node);
- CHECK_GE(node->allocation_count(), 2);
+ CHECK(node);
+ CHECK_GE(node->allocation_count(), 2u);
CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
heap_profiler->StopTrackingHeapObjects();
}
@@ -2643,22 +2657,18 @@
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
CompileRun("arr1 = new Uint32Array(100);\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* arr1_obj =
GetProperty(global, v8::HeapGraphEdge::kProperty, "arr1");
- CHECK_NE(NULL, arr1_obj);
+ CHECK(arr1_obj);
const v8::HeapGraphNode* arr1_buffer =
GetProperty(arr1_obj, v8::HeapGraphEdge::kInternal, "buffer");
- CHECK_NE(NULL, arr1_buffer);
- const v8::HeapGraphNode* first_view =
- GetProperty(arr1_buffer, v8::HeapGraphEdge::kWeak, "weak_first_view");
- CHECK_NE(NULL, first_view);
+ CHECK(arr1_buffer);
const v8::HeapGraphNode* backing_store =
GetProperty(arr1_buffer, v8::HeapGraphEdge::kInternal, "backing_store");
- CHECK_NE(NULL, backing_store);
+ CHECK(backing_store);
CHECK_EQ(400, static_cast<int>(backing_store->GetShallowSize()));
}
@@ -2692,32 +2702,31 @@
CHECK_EQ(1024, static_cast<int>(ab_contents.ByteLength()));
void* data = ab_contents.Data();
- DCHECK(data != NULL);
+ CHECK(data != NULL);
v8::Local<v8::ArrayBuffer> ab2 =
v8::ArrayBuffer::New(isolate, data, ab_contents.ByteLength());
CHECK(ab2->IsExternal());
- env->Global()->Set(v8_str("ab1"), ab);
- env->Global()->Set(v8_str("ab2"), ab2);
+ env->Global()->Set(env.local(), v8_str("ab1"), ab).FromJust();
+ env->Global()->Set(env.local(), v8_str("ab2"), ab2).FromJust();
- v8::Handle<v8::Value> result = CompileRun("ab2.byteLength");
- CHECK_EQ(1024, result->Int32Value());
+ v8::Local<v8::Value> result = CompileRun("ab2.byteLength");
+ CHECK_EQ(1024, result->Int32Value(env.local()).FromJust());
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* ab1_node =
GetProperty(global, v8::HeapGraphEdge::kProperty, "ab1");
- CHECK_NE(NULL, ab1_node);
+ CHECK(ab1_node);
const v8::HeapGraphNode* ab1_data =
GetProperty(ab1_node, v8::HeapGraphEdge::kInternal, "backing_store");
- CHECK_NE(NULL, ab1_data);
+ CHECK(ab1_data);
const v8::HeapGraphNode* ab2_node =
GetProperty(global, v8::HeapGraphEdge::kProperty, "ab2");
- CHECK_NE(NULL, ab2_node);
+ CHECK(ab2_node);
const v8::HeapGraphNode* ab2_data =
GetProperty(ab2_node, v8::HeapGraphEdge::kInternal, "backing_store");
- CHECK_NE(NULL, ab2_data);
+ CHECK(ab2_data);
CHECK_EQ(ab1_data, ab2_data);
CHECK_EQ(2, GetRetainersCount(snapshot, ab1_data));
free(data);
@@ -2728,27 +2737,26 @@
v8::Isolate* isolate = CcTest::isolate();
v8::HandleScope scope(isolate);
LocalContext env;
- v8::Handle<v8::Object> global_proxy = env->Global();
- v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
+ v8::Local<v8::Object> global_proxy = env->Global();
+ v8::Local<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
i::Factory* factory = CcTest::i_isolate()->factory();
i::Handle<i::String> string = factory->NewStringFromStaticChars("string");
i::Handle<i::Object> box = factory->NewBox(string);
- global->Set(0, v8::ToApiHandle<v8::Object>(box));
+ global->Set(env.local(), 0, v8::ToApiHandle<v8::Object>(box)).FromJust();
v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
const v8::HeapGraphNode* box_node =
GetProperty(global_node, v8::HeapGraphEdge::kElement, "0");
- CHECK_NE(NULL, box_node);
+ CHECK(box_node);
v8::String::Utf8Value box_node_name(box_node->GetName());
- CHECK_EQ("system / Box", *box_node_name);
+ CHECK_EQ(0, strcmp("system / Box", *box_node_name));
const v8::HeapGraphNode* box_value =
GetProperty(box_node, v8::HeapGraphEdge::kInternal, "value");
- CHECK_NE(NULL, box_value);
+ CHECK(box_value);
}
@@ -2765,16 +2773,15 @@
"foo(obj);\n"
"%OptimizeFunctionOnNextCall(foo);\n"
"foo(obj);\n");
- const v8::HeapSnapshot* snapshot =
- heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
+ const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
CHECK(ValidateSnapshot(snapshot));
const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
const v8::HeapGraphNode* obj =
GetProperty(global, v8::HeapGraphEdge::kProperty, "obj");
- CHECK_NE(NULL, obj);
+ CHECK(obj);
const v8::HeapGraphNode* map =
GetProperty(obj, v8::HeapGraphEdge::kInternal, "map");
- CHECK_NE(NULL, map);
+ CHECK(map);
const v8::HeapGraphNode* dependent_code =
GetProperty(map, v8::HeapGraphEdge::kInternal, "dependent_code");
if (!dependent_code) return;
@@ -2795,53 +2802,53 @@
TEST(AddressToTraceMap) {
i::AddressToTraceMap map;
- CHECK_EQ(0, map.GetTraceNodeId(ToAddress(150)));
+ CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(150)));
// [0x100, 0x200) -> 1
map.AddRange(ToAddress(0x100), 0x100, 1U);
- CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x50)));
- CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x100)));
- CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x150)));
- CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x100 + 0x100)));
- CHECK_EQ(1, static_cast<int>(map.size()));
+ CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x50)));
+ CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x100)));
+ CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x150)));
+ CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x100 + 0x100)));
+ CHECK_EQ(1u, map.size());
// [0x100, 0x200) -> 1, [0x200, 0x300) -> 2
map.AddRange(ToAddress(0x200), 0x100, 2U);
- CHECK_EQ(2, map.GetTraceNodeId(ToAddress(0x2a0)));
- CHECK_EQ(2, static_cast<int>(map.size()));
+ CHECK_EQ(2u, map.GetTraceNodeId(ToAddress(0x2a0)));
+ CHECK_EQ(2u, map.size());
// [0x100, 0x180) -> 1, [0x180, 0x280) -> 3, [0x280, 0x300) -> 2
map.AddRange(ToAddress(0x180), 0x100, 3U);
- CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x17F)));
- CHECK_EQ(2, map.GetTraceNodeId(ToAddress(0x280)));
- CHECK_EQ(3, map.GetTraceNodeId(ToAddress(0x180)));
- CHECK_EQ(3, static_cast<int>(map.size()));
+ CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x17F)));
+ CHECK_EQ(2u, map.GetTraceNodeId(ToAddress(0x280)));
+ CHECK_EQ(3u, map.GetTraceNodeId(ToAddress(0x180)));
+ CHECK_EQ(3u, map.size());
// [0x100, 0x180) -> 1, [0x180, 0x280) -> 3, [0x280, 0x300) -> 2,
// [0x400, 0x500) -> 4
map.AddRange(ToAddress(0x400), 0x100, 4U);
- CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x17F)));
- CHECK_EQ(2, map.GetTraceNodeId(ToAddress(0x280)));
- CHECK_EQ(3, map.GetTraceNodeId(ToAddress(0x180)));
- CHECK_EQ(4, map.GetTraceNodeId(ToAddress(0x450)));
- CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x500)));
- CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x350)));
- CHECK_EQ(4, static_cast<int>(map.size()));
+ CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x17F)));
+ CHECK_EQ(2u, map.GetTraceNodeId(ToAddress(0x280)));
+ CHECK_EQ(3u, map.GetTraceNodeId(ToAddress(0x180)));
+ CHECK_EQ(4u, map.GetTraceNodeId(ToAddress(0x450)));
+ CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x500)));
+ CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x350)));
+ CHECK_EQ(4u, map.size());
// [0x100, 0x180) -> 1, [0x180, 0x200) -> 3, [0x200, 0x600) -> 5
map.AddRange(ToAddress(0x200), 0x400, 5U);
- CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x200)));
- CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x400)));
- CHECK_EQ(3, static_cast<int>(map.size()));
+ CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x200)));
+ CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x400)));
+ CHECK_EQ(3u, map.size());
// [0x100, 0x180) -> 1, [0x180, 0x200) -> 7, [0x200, 0x600) ->5
map.AddRange(ToAddress(0x180), 0x80, 6U);
map.AddRange(ToAddress(0x180), 0x80, 7U);
- CHECK_EQ(7, map.GetTraceNodeId(ToAddress(0x180)));
- CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x200)));
- CHECK_EQ(3, static_cast<int>(map.size()));
+ CHECK_EQ(7u, map.GetTraceNodeId(ToAddress(0x180)));
+ CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x200)));
+ CHECK_EQ(3u, map.size());
map.Clear();
- CHECK_EQ(0, static_cast<int>(map.size()));
- CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x400)));
+ CHECK_EQ(0u, map.size());
+ CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x400)));
}