2b873b94e9
This CL adds functionality to read the source positions directly from the JS heap rather than from serialized data. In order to do this, we create a PersistentHandles container in the OptimizedCompilationInfo which gets passed onto the JSHeapBroker. This allows us to create the handles in the main thread and pass them safely to the background thread. In order to read safely from the background thread, we need a LocalHeap which blocks the GC from running and potentially moving the handles. This LocalHeap is created only when the JSHeapBroker has finalized serializing and destroyed when retiring it. Bug: v8:7790 Change-Id: I19f8b08d12e5be0a3df34d6af2043310c0c7b6fe Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2277802 Reviewed-by: Ulan Degenbaev <ulan@chromium.org> Reviewed-by: Dominik Inführ <dinfuehr@chromium.org> Reviewed-by: Georg Neis <neis@chromium.org> Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org> Cr-Commit-Position: refs/heads/master@{#68836}
415 lines
13 KiB
C++
415 lines
13 KiB
C++
// Copyright 2014 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "src/codegen/assembler.h"
|
|
#include "src/compiler/js-graph.h"
|
|
#include "src/compiler/js-heap-broker.h"
|
|
#include "src/compiler/node-properties.h"
|
|
#include "src/heap/factory-inl.h"
|
|
#include "test/cctest/cctest.h"
|
|
#include "test/cctest/compiler/value-helper.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace compiler {
|
|
|
|
class JSCacheTesterHelper {
|
|
protected:
|
|
explicit JSCacheTesterHelper(Zone* zone)
|
|
: main_graph_(zone),
|
|
main_common_(zone),
|
|
main_javascript_(zone),
|
|
main_machine_(zone) {}
|
|
Graph main_graph_;
|
|
CommonOperatorBuilder main_common_;
|
|
JSOperatorBuilder main_javascript_;
|
|
MachineOperatorBuilder main_machine_;
|
|
};
|
|
|
|
|
|
// TODO(dcarney): JSConstantCacheTester inherits from JSGraph???
|
|
class JSConstantCacheTester : public HandleAndZoneScope,
|
|
public JSCacheTesterHelper,
|
|
public JSGraph {
|
|
public:
|
|
JSConstantCacheTester()
|
|
: JSCacheTesterHelper(main_zone()),
|
|
JSGraph(main_isolate(), &main_graph_, &main_common_, &main_javascript_,
|
|
nullptr, &main_machine_),
|
|
canonical_(main_isolate()),
|
|
broker_(main_isolate(), main_zone(),
|
|
main_isolate()->NewPersistentHandles()) {
|
|
main_graph_.SetStart(main_graph_.NewNode(common()->Start(0)));
|
|
main_graph_.SetEnd(
|
|
main_graph_.NewNode(common()->End(1), main_graph_.start()));
|
|
}
|
|
|
|
Handle<HeapObject> handle(Node* node) {
|
|
CHECK_EQ(IrOpcode::kHeapConstant, node->opcode());
|
|
return HeapConstantOf(node->op());
|
|
}
|
|
|
|
Factory* factory() { return main_isolate()->factory(); }
|
|
JSHeapBroker* broker() { return &broker_; }
|
|
|
|
private:
|
|
CanonicalHandleScope canonical_;
|
|
JSHeapBroker broker_;
|
|
};
|
|
|
|
|
|
TEST(ZeroConstant1) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* zero = T.ZeroConstant();
|
|
|
|
CHECK_EQ(IrOpcode::kNumberConstant, zero->opcode());
|
|
CHECK_EQ(zero, T.Constant(0));
|
|
CHECK_NE(zero, T.Constant(-0.0));
|
|
CHECK_NE(zero, T.Constant(1.0));
|
|
CHECK_NE(zero, T.Constant(std::numeric_limits<double>::quiet_NaN()));
|
|
CHECK_NE(zero, T.Float64Constant(0));
|
|
CHECK_NE(zero, T.Int32Constant(0));
|
|
}
|
|
|
|
|
|
TEST(MinusZeroConstant) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* minus_zero = T.Constant(-0.0);
|
|
Node* zero = T.ZeroConstant();
|
|
|
|
CHECK_EQ(IrOpcode::kNumberConstant, minus_zero->opcode());
|
|
CHECK_EQ(minus_zero, T.Constant(-0.0));
|
|
CHECK_NE(zero, minus_zero);
|
|
|
|
double zero_value = OpParameter<double>(zero->op());
|
|
double minus_zero_value = OpParameter<double>(minus_zero->op());
|
|
|
|
CHECK(bit_cast<uint64_t>(0.0) == bit_cast<uint64_t>(zero_value));
|
|
CHECK(bit_cast<uint64_t>(-0.0) != bit_cast<uint64_t>(zero_value));
|
|
CHECK(bit_cast<uint64_t>(0.0) != bit_cast<uint64_t>(minus_zero_value));
|
|
CHECK(bit_cast<uint64_t>(-0.0) == bit_cast<uint64_t>(minus_zero_value));
|
|
}
|
|
|
|
|
|
TEST(ZeroConstant2) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* zero = T.Constant(0);
|
|
|
|
CHECK_EQ(IrOpcode::kNumberConstant, zero->opcode());
|
|
CHECK_EQ(zero, T.ZeroConstant());
|
|
CHECK_NE(zero, T.Constant(-0.0));
|
|
CHECK_NE(zero, T.Constant(1.0));
|
|
CHECK_NE(zero, T.Constant(std::numeric_limits<double>::quiet_NaN()));
|
|
CHECK_NE(zero, T.Float64Constant(0));
|
|
CHECK_NE(zero, T.Int32Constant(0));
|
|
}
|
|
|
|
|
|
TEST(OneConstant1) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* one = T.OneConstant();
|
|
|
|
CHECK_EQ(IrOpcode::kNumberConstant, one->opcode());
|
|
CHECK_EQ(one, T.Constant(1));
|
|
CHECK_EQ(one, T.Constant(1.0));
|
|
CHECK_NE(one, T.Constant(1.01));
|
|
CHECK_NE(one, T.Constant(-1.01));
|
|
CHECK_NE(one, T.Constant(std::numeric_limits<double>::quiet_NaN()));
|
|
CHECK_NE(one, T.Float64Constant(1.0));
|
|
CHECK_NE(one, T.Int32Constant(1));
|
|
}
|
|
|
|
|
|
TEST(OneConstant2) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* one = T.Constant(1);
|
|
|
|
CHECK_EQ(IrOpcode::kNumberConstant, one->opcode());
|
|
CHECK_EQ(one, T.OneConstant());
|
|
CHECK_EQ(one, T.Constant(1.0));
|
|
CHECK_NE(one, T.Constant(1.01));
|
|
CHECK_NE(one, T.Constant(-1.01));
|
|
CHECK_NE(one, T.Constant(std::numeric_limits<double>::quiet_NaN()));
|
|
CHECK_NE(one, T.Float64Constant(1.0));
|
|
CHECK_NE(one, T.Int32Constant(1));
|
|
}
|
|
|
|
|
|
TEST(Canonicalizations) {
|
|
JSConstantCacheTester T;
|
|
|
|
CHECK_EQ(T.ZeroConstant(), T.ZeroConstant());
|
|
CHECK_EQ(T.UndefinedConstant(), T.UndefinedConstant());
|
|
CHECK_EQ(T.TheHoleConstant(), T.TheHoleConstant());
|
|
CHECK_EQ(T.TrueConstant(), T.TrueConstant());
|
|
CHECK_EQ(T.FalseConstant(), T.FalseConstant());
|
|
CHECK_EQ(T.NullConstant(), T.NullConstant());
|
|
CHECK_EQ(T.ZeroConstant(), T.ZeroConstant());
|
|
CHECK_EQ(T.OneConstant(), T.OneConstant());
|
|
CHECK_EQ(T.NaNConstant(), T.NaNConstant());
|
|
}
|
|
|
|
|
|
TEST(NoAliasing) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* nodes[] = {T.UndefinedConstant(), T.TheHoleConstant(), T.TrueConstant(),
|
|
T.FalseConstant(), T.NullConstant(), T.ZeroConstant(),
|
|
T.OneConstant(), T.NaNConstant(), T.Constant(21),
|
|
T.Constant(22.2)};
|
|
|
|
for (size_t i = 0; i < arraysize(nodes); i++) {
|
|
for (size_t j = 0; j < arraysize(nodes); j++) {
|
|
if (i != j) CHECK_NE(nodes[i], nodes[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(CanonicalizingNumbers) {
|
|
JSConstantCacheTester T;
|
|
|
|
FOR_FLOAT64_INPUTS(i) {
|
|
Node* node = T.Constant(i);
|
|
for (int j = 0; j < 5; j++) {
|
|
CHECK_EQ(node, T.Constant(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HeapNumbers) {
|
|
JSConstantCacheTester T;
|
|
|
|
FOR_FLOAT64_INPUTS(value) {
|
|
Handle<Object> num = T.factory()->NewNumber(value);
|
|
Handle<HeapNumber> heap = T.factory()->NewHeapNumber(value);
|
|
Node* node1 = T.Constant(value);
|
|
Node* node2 = T.Constant(ObjectRef(T.broker(), num));
|
|
Node* node3 = T.Constant(ObjectRef(T.broker(), heap));
|
|
CHECK_EQ(node1, node2);
|
|
CHECK_EQ(node1, node3);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(OddballHandle) {
|
|
JSConstantCacheTester T;
|
|
|
|
CHECK_EQ(T.UndefinedConstant(),
|
|
T.Constant(ObjectRef(T.broker(), T.factory()->undefined_value())));
|
|
CHECK_EQ(T.TheHoleConstant(),
|
|
T.Constant(ObjectRef(T.broker(), T.factory()->the_hole_value())));
|
|
CHECK_EQ(T.TrueConstant(),
|
|
T.Constant(ObjectRef(T.broker(), T.factory()->true_value())));
|
|
CHECK_EQ(T.FalseConstant(),
|
|
T.Constant(ObjectRef(T.broker(), T.factory()->false_value())));
|
|
CHECK_EQ(T.NullConstant(),
|
|
T.Constant(ObjectRef(T.broker(), T.factory()->null_value())));
|
|
CHECK_EQ(T.NaNConstant(),
|
|
T.Constant(ObjectRef(T.broker(), T.factory()->nan_value())));
|
|
}
|
|
|
|
|
|
TEST(OddballValues) {
|
|
JSConstantCacheTester T;
|
|
|
|
CHECK_EQ(*T.factory()->undefined_value(), *T.handle(T.UndefinedConstant()));
|
|
CHECK_EQ(*T.factory()->the_hole_value(), *T.handle(T.TheHoleConstant()));
|
|
CHECK_EQ(*T.factory()->true_value(), *T.handle(T.TrueConstant()));
|
|
CHECK_EQ(*T.factory()->false_value(), *T.handle(T.FalseConstant()));
|
|
CHECK_EQ(*T.factory()->null_value(), *T.handle(T.NullConstant()));
|
|
}
|
|
|
|
|
|
TEST(ExternalReferences) {
|
|
// TODO(titzer): test canonicalization of external references.
|
|
}
|
|
|
|
|
|
static bool Contains(NodeVector* nodes, Node* n) {
|
|
for (size_t i = 0; i < nodes->size(); i++) {
|
|
if (nodes->at(i) == n) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
static void CheckGetCachedNodesContains(JSConstantCacheTester* T, Node* n) {
|
|
NodeVector nodes(T->main_zone());
|
|
T->GetCachedNodes(&nodes);
|
|
CHECK(Contains(&nodes, n));
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes1) {
|
|
JSConstantCacheTester T;
|
|
CheckGetCachedNodesContains(&T, T.TrueConstant());
|
|
CheckGetCachedNodesContains(&T, T.UndefinedConstant());
|
|
CheckGetCachedNodesContains(&T, T.TheHoleConstant());
|
|
CheckGetCachedNodesContains(&T, T.TrueConstant());
|
|
CheckGetCachedNodesContains(&T, T.FalseConstant());
|
|
CheckGetCachedNodesContains(&T, T.NullConstant());
|
|
CheckGetCachedNodesContains(&T, T.ZeroConstant());
|
|
CheckGetCachedNodesContains(&T, T.OneConstant());
|
|
CheckGetCachedNodesContains(&T, T.NaNConstant());
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes_int32) {
|
|
JSConstantCacheTester T;
|
|
|
|
int32_t constants[] = {0, 1, 1, 1, 1, 2, 3, 4, 11, 12, 13,
|
|
14, 55, -55, -44, -33, -22, -11, 16, 16, 17, 17,
|
|
18, 18, 19, 19, 20, 20, 21, 21, 22, 23, 24,
|
|
25, 15, 30, 31, 45, 46, 47, 48};
|
|
|
|
for (size_t i = 0; i < arraysize(constants); i++) {
|
|
size_t count_before = T.graph()->NodeCount();
|
|
NodeVector nodes_before(T.main_zone());
|
|
T.GetCachedNodes(&nodes_before);
|
|
Node* n = T.Int32Constant(constants[i]);
|
|
if (n->id() < count_before) {
|
|
// An old ID indicates a cached node. It should have been in the set.
|
|
CHECK(Contains(&nodes_before, n));
|
|
}
|
|
// Old or new, it should be in the cached set afterwards.
|
|
CheckGetCachedNodesContains(&T, n);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes_float64) {
|
|
JSConstantCacheTester T;
|
|
|
|
double constants[] = {0, 11.1, 12.2, 13, 14, 55.5, -55.5, -44.4,
|
|
-33, -22, -11, 0, 11.1, 11.1, 12.3, 12.3,
|
|
11, 11, -33.3, -33.3, -22, -11};
|
|
|
|
for (size_t i = 0; i < arraysize(constants); i++) {
|
|
size_t count_before = T.graph()->NodeCount();
|
|
NodeVector nodes_before(T.main_zone());
|
|
T.GetCachedNodes(&nodes_before);
|
|
Node* n = T.Float64Constant(constants[i]);
|
|
if (n->id() < count_before) {
|
|
// An old ID indicates a cached node. It should have been in the set.
|
|
CHECK(Contains(&nodes_before, n));
|
|
}
|
|
// Old or new, it should be in the cached set afterwards.
|
|
CheckGetCachedNodesContains(&T, n);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes_int64) {
|
|
JSConstantCacheTester T;
|
|
|
|
int32_t constants[] = {0, 11, 12, 13, 14, 55, -55, -44, -33,
|
|
-22, -11, 16, 16, 17, 17, 18, 18, 19,
|
|
19, 20, 20, 21, 21, 22, 23, 24, 25};
|
|
|
|
for (size_t i = 0; i < arraysize(constants); i++) {
|
|
size_t count_before = T.graph()->NodeCount();
|
|
NodeVector nodes_before(T.main_zone());
|
|
T.GetCachedNodes(&nodes_before);
|
|
Node* n = T.Int64Constant(constants[i]);
|
|
if (n->id() < count_before) {
|
|
// An old ID indicates a cached node. It should have been in the set.
|
|
CHECK(Contains(&nodes_before, n));
|
|
}
|
|
// Old or new, it should be in the cached set afterwards.
|
|
CheckGetCachedNodesContains(&T, n);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes_number) {
|
|
JSConstantCacheTester T;
|
|
|
|
double constants[] = {0, 11.1, 12.2, 13, 14, 55.5, -55.5, -44.4,
|
|
-33, -22, -11, 0, 11.1, 11.1, 12.3, 12.3,
|
|
11, 11, -33.3, -33.3, -22, -11};
|
|
|
|
for (size_t i = 0; i < arraysize(constants); i++) {
|
|
size_t count_before = T.graph()->NodeCount();
|
|
NodeVector nodes_before(T.main_zone());
|
|
T.GetCachedNodes(&nodes_before);
|
|
Node* n = T.Constant(constants[i]);
|
|
if (n->id() < count_before) {
|
|
// An old ID indicates a cached node. It should have been in the set.
|
|
CHECK(Contains(&nodes_before, n));
|
|
}
|
|
// Old or new, it should be in the cached set afterwards.
|
|
CheckGetCachedNodesContains(&T, n);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes_external) {
|
|
JSConstantCacheTester T;
|
|
|
|
ExternalReference constants[] = {ExternalReference::address_of_min_int(),
|
|
ExternalReference::address_of_min_int(),
|
|
ExternalReference::address_of_min_int(),
|
|
ExternalReference::address_of_one_half(),
|
|
ExternalReference::address_of_one_half(),
|
|
ExternalReference::address_of_min_int(),
|
|
ExternalReference::address_of_the_hole_nan(),
|
|
ExternalReference::address_of_one_half()};
|
|
|
|
for (size_t i = 0; i < arraysize(constants); i++) {
|
|
size_t count_before = T.graph()->NodeCount();
|
|
NodeVector nodes_before(T.main_zone());
|
|
T.GetCachedNodes(&nodes_before);
|
|
Node* n = T.ExternalConstant(constants[i]);
|
|
if (n->id() < count_before) {
|
|
// An old ID indicates a cached node. It should have been in the set.
|
|
CHECK(Contains(&nodes_before, n));
|
|
}
|
|
// Old or new, it should be in the cached set afterwards.
|
|
CheckGetCachedNodesContains(&T, n);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(JSGraph_GetCachedNodes_together) {
|
|
JSConstantCacheTester T;
|
|
|
|
Node* constants[] = {
|
|
T.TrueConstant(),
|
|
T.UndefinedConstant(),
|
|
T.TheHoleConstant(),
|
|
T.TrueConstant(),
|
|
T.FalseConstant(),
|
|
T.NullConstant(),
|
|
T.ZeroConstant(),
|
|
T.OneConstant(),
|
|
T.NaNConstant(),
|
|
T.Int32Constant(0),
|
|
T.Int32Constant(1),
|
|
T.Int64Constant(-2),
|
|
T.Int64Constant(-4),
|
|
T.Float64Constant(0.9),
|
|
T.Float64Constant(V8_INFINITY),
|
|
T.Constant(0.99),
|
|
T.Constant(1.11),
|
|
T.ExternalConstant(ExternalReference::address_of_one_half())};
|
|
|
|
NodeVector nodes(T.main_zone());
|
|
T.GetCachedNodes(&nodes);
|
|
|
|
for (size_t i = 0; i < arraysize(constants); i++) {
|
|
CHECK(Contains(&nodes, constants[i]));
|
|
}
|
|
}
|
|
|
|
} // namespace compiler
|
|
} // namespace internal
|
|
} // namespace v8
|