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/src/compiler/js-graph.cc b/src/compiler/js-graph.cc
index 7759ba1..e938798 100644
--- a/src/compiler/js-graph.cc
+++ b/src/compiler/js-graph.cc
@@ -4,110 +4,82 @@
#include "src/code-stubs.h"
#include "src/compiler/js-graph.h"
-#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/node-properties.h"
#include "src/compiler/typer.h"
namespace v8 {
namespace internal {
namespace compiler {
-Node* JSGraph::ImmovableHeapConstant(Handle<HeapObject> object) {
- Unique<HeapObject> unique = Unique<HeapObject>::CreateImmovable(object);
- return graph()->NewNode(common()->HeapConstant(unique));
-}
+#define CACHED(name, expr) \
+ cached_nodes_[name] ? cached_nodes_[name] : (cached_nodes_[name] = (expr))
Node* JSGraph::CEntryStubConstant(int result_size) {
if (result_size == 1) {
- if (!c_entry_stub_constant_.is_set()) {
- c_entry_stub_constant_.set(
- ImmovableHeapConstant(CEntryStub(isolate(), 1).GetCode()));
- }
- return c_entry_stub_constant_.get();
+ return CACHED(kCEntryStubConstant,
+ HeapConstant(CEntryStub(isolate(), 1).GetCode()));
}
+ return HeapConstant(CEntryStub(isolate(), result_size).GetCode());
+}
- return ImmovableHeapConstant(CEntryStub(isolate(), result_size).GetCode());
+
+Node* JSGraph::EmptyFixedArrayConstant() {
+ return CACHED(kEmptyFixedArrayConstant,
+ HeapConstant(factory()->empty_fixed_array()));
}
Node* JSGraph::UndefinedConstant() {
- if (!undefined_constant_.is_set()) {
- undefined_constant_.set(
- ImmovableHeapConstant(factory()->undefined_value()));
- }
- return undefined_constant_.get();
+ return CACHED(kUndefinedConstant, HeapConstant(factory()->undefined_value()));
}
Node* JSGraph::TheHoleConstant() {
- if (!the_hole_constant_.is_set()) {
- the_hole_constant_.set(ImmovableHeapConstant(factory()->the_hole_value()));
- }
- return the_hole_constant_.get();
+ return CACHED(kTheHoleConstant, HeapConstant(factory()->the_hole_value()));
}
Node* JSGraph::TrueConstant() {
- if (!true_constant_.is_set()) {
- true_constant_.set(ImmovableHeapConstant(factory()->true_value()));
- }
- return true_constant_.get();
+ return CACHED(kTrueConstant, HeapConstant(factory()->true_value()));
}
Node* JSGraph::FalseConstant() {
- if (!false_constant_.is_set()) {
- false_constant_.set(ImmovableHeapConstant(factory()->false_value()));
- }
- return false_constant_.get();
+ return CACHED(kFalseConstant, HeapConstant(factory()->false_value()));
}
Node* JSGraph::NullConstant() {
- if (!null_constant_.is_set()) {
- null_constant_.set(ImmovableHeapConstant(factory()->null_value()));
- }
- return null_constant_.get();
+ return CACHED(kNullConstant, HeapConstant(factory()->null_value()));
}
Node* JSGraph::ZeroConstant() {
- if (!zero_constant_.is_set()) zero_constant_.set(NumberConstant(0.0));
- return zero_constant_.get();
+ return CACHED(kZeroConstant, NumberConstant(0.0));
}
Node* JSGraph::OneConstant() {
- if (!one_constant_.is_set()) one_constant_.set(NumberConstant(1.0));
- return one_constant_.get();
+ return CACHED(kOneConstant, NumberConstant(1.0));
}
Node* JSGraph::NaNConstant() {
- if (!nan_constant_.is_set()) {
- nan_constant_.set(NumberConstant(base::OS::nan_value()));
- }
- return nan_constant_.get();
-}
-
-
-Node* JSGraph::HeapConstant(Unique<HeapObject> value) {
- // TODO(turbofan): canonicalize heap constants using Unique<T>
- return graph()->NewNode(common()->HeapConstant(value));
+ return CACHED(kNaNConstant,
+ NumberConstant(std::numeric_limits<double>::quiet_NaN()));
}
Node* JSGraph::HeapConstant(Handle<HeapObject> value) {
- // TODO(titzer): We could also match against the addresses of immortable
- // immovables here, even without access to the heap, thus always
- // canonicalizing references to them.
- // return HeapConstant(Unique<Object>::CreateUninitialized(value));
- // TODO(turbofan): This is a work-around to make Unique::HashCode() work for
- // value numbering. We need some sane way to compute a unique hash code for
- // arbitrary handles here.
- Unique<HeapObject> unique(reinterpret_cast<Address>(*value.location()),
- value);
- return HeapConstant(unique);
+ if (value->IsConsString()) {
+ value = String::Flatten(Handle<String>::cast(value), TENURED);
+ }
+ Node** loc = cache_.FindHeapConstant(value);
+ if (*loc == nullptr) {
+ *loc = graph()->NewNode(common()->HeapConstant(value));
+ }
+ return *loc;
}
@@ -148,7 +120,7 @@
Node* JSGraph::Int32Constant(int32_t value) {
Node** loc = cache_.FindInt32Constant(value);
- if (*loc == NULL) {
+ if (*loc == nullptr) {
*loc = graph()->NewNode(common()->Int32Constant(value));
}
return *loc;
@@ -157,7 +129,7 @@
Node* JSGraph::Int64Constant(int64_t value) {
Node** loc = cache_.FindInt64Constant(value);
- if (*loc == NULL) {
+ if (*loc == nullptr) {
*loc = graph()->NewNode(common()->Int64Constant(value));
}
return *loc;
@@ -166,7 +138,7 @@
Node* JSGraph::NumberConstant(double value) {
Node** loc = cache_.FindNumberConstant(value);
- if (*loc == NULL) {
+ if (*loc == nullptr) {
*loc = graph()->NewNode(common()->NumberConstant(value));
}
return *loc;
@@ -175,7 +147,7 @@
Node* JSGraph::Float32Constant(float value) {
Node** loc = cache_.FindFloat32Constant(value);
- if (*loc == NULL) {
+ if (*loc == nullptr) {
*loc = graph()->NewNode(common()->Float32Constant(value));
}
return *loc;
@@ -184,7 +156,7 @@
Node* JSGraph::Float64Constant(double value) {
Node** loc = cache_.FindFloat64Constant(value);
- if (*loc == NULL) {
+ if (*loc == nullptr) {
*loc = graph()->NewNode(common()->Float64Constant(value));
}
return *loc;
@@ -193,21 +165,44 @@
Node* JSGraph::ExternalConstant(ExternalReference reference) {
Node** loc = cache_.FindExternalConstant(reference);
- if (*loc == NULL) {
+ if (*loc == nullptr) {
*loc = graph()->NewNode(common()->ExternalConstant(reference));
}
return *loc;
}
+Node* JSGraph::ExternalConstant(Runtime::FunctionId function_id) {
+ return ExternalConstant(ExternalReference(function_id, isolate()));
+}
+
+
+Node* JSGraph::EmptyFrameState() {
+ Node* empty_frame_state = cached_nodes_[kEmptyFrameState];
+ if (!empty_frame_state || empty_frame_state->IsDead()) {
+ Node* state_values = graph()->NewNode(common()->StateValues(0));
+ empty_frame_state = graph()->NewNode(
+ common()->FrameState(BailoutId::None(),
+ OutputFrameStateCombine::Ignore(), nullptr),
+ state_values, state_values, state_values, NoContextConstant(),
+ UndefinedConstant(), graph()->start());
+ cached_nodes_[kEmptyFrameState] = empty_frame_state;
+ }
+ return empty_frame_state;
+}
+
+
+Node* JSGraph::Dead() {
+ return CACHED(kDead, graph()->NewNode(common()->Dead()));
+}
+
+
void JSGraph::GetCachedNodes(NodeVector* nodes) {
cache_.GetCachedNodes(nodes);
- SetOncePointer<Node>* ptrs[] = {
- &c_entry_stub_constant_, &undefined_constant_, &the_hole_constant_,
- &true_constant_, &false_constant_, &null_constant_,
- &zero_constant_, &one_constant_, &nan_constant_};
- for (size_t i = 0; i < arraysize(ptrs); i++) {
- if (ptrs[i]->is_set()) nodes->push_back(ptrs[i]->get());
+ for (size_t i = 0; i < arraysize(cached_nodes_); i++) {
+ if (Node* node = cached_nodes_[i]) {
+ if (!node->IsDead()) nodes->push_back(node);
+ }
}
}