Update V8 to version 4.1.0.21
This is a cherry-pick of all commits up to and including the
4.1.0.21 cherry-pick in Chromium.
Original commit message:
Version 4.1.0.21 (cherry-pick)
Merged 206e9136bde0f2b5ae8cb77afbb1e7833e5bd412
Unlink pages from the space page list after evacuation.
BUG=430201
LOG=N
R=jkummerow@chromium.org
Review URL: https://codereview.chromium.org/953813002
Cr-Commit-Position: refs/branch-heads/4.1@{#22}
Cr-Branched-From: 2e08d2a7aa9d65d269d8c57aba82eb38a8cb0a18-refs/heads/candidates@{#25353}
---
FPIIM-449
Change-Id: I8c23c7bbb70772b4858fe8a47b64fa97ee0d1f8c
diff --git a/src/compiler/js-graph.h b/src/compiler/js-graph.h
index 2b2dfd1..040a745 100644
--- a/src/compiler/js-graph.h
+++ b/src/compiler/js-graph.h
@@ -24,17 +24,15 @@
class JSGraph : public ZoneObject {
public:
JSGraph(Graph* graph, CommonOperatorBuilder* common,
- JSOperatorBuilder* javascript, Typer* typer,
- MachineOperatorBuilder* machine)
+ JSOperatorBuilder* javascript, MachineOperatorBuilder* machine)
: graph_(graph),
common_(common),
javascript_(javascript),
- typer_(typer),
machine_(machine),
cache_(zone()) {}
// Canonicalized global constants.
- Node* CEntryStubConstant();
+ Node* CEntryStubConstant(int result_size);
Node* UndefinedConstant();
Node* TheHoleConstant();
Node* TrueConstant();
@@ -46,11 +44,11 @@
// Creates a HeapConstant node, possibly canonicalized, without inspecting the
// object.
- Node* HeapConstant(Unique<Object> value);
+ Node* HeapConstant(Unique<HeapObject> value);
// Creates a HeapConstant node, possibly canonicalized, and may access the
// heap to inspect the object.
- Node* HeapConstant(Handle<Object> value);
+ Node* HeapConstant(Handle<HeapObject> value);
// Creates a Constant node of the appropriate type for the given object.
// Accesses the heap to inspect the object and determine whether one of the
@@ -69,6 +67,33 @@
return Int32Constant(bit_cast<int32_t>(value));
}
+ // Creates a HeapConstant node for either true or false.
+ Node* BooleanConstant(bool is_true) {
+ return is_true ? TrueConstant() : FalseConstant();
+ }
+
+ // Creates a Int64Constant node, usually canonicalized.
+ Node* Int64Constant(int64_t value);
+ Node* Uint64Constant(uint64_t value) {
+ return Int64Constant(bit_cast<int64_t>(value));
+ }
+
+ // Creates a Int32Constant/Int64Constant node, depending on the word size of
+ // the target machine.
+ // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer
+ // constants is probably not serializable.
+ Node* IntPtrConstant(intptr_t value) {
+ return machine()->Is32() ? Int32Constant(static_cast<int32_t>(value))
+ : Int64Constant(static_cast<int64_t>(value));
+ }
+ template <typename T>
+ Node* PointerConstant(T* value) {
+ return IntPtrConstant(bit_cast<intptr_t>(value));
+ }
+
+ // Creates a Float32Constant node, usually canonicalized.
+ Node* Float32Constant(float value);
+
// Creates a Float64Constant node, usually canonicalized.
Node* Float64Constant(double value);
@@ -80,20 +105,27 @@
return Constant(immediate);
}
+ // Creates a dummy Constant node, used to satisfy calling conventions of
+ // stubs and runtime functions that do not require a context.
+ Node* NoContextConstant() { return ZeroConstant(); }
+
JSOperatorBuilder* javascript() { return javascript_; }
CommonOperatorBuilder* common() { return common_; }
MachineOperatorBuilder* machine() { return machine_; }
Graph* graph() { return graph_; }
Zone* zone() { return graph()->zone(); }
Isolate* isolate() { return zone()->isolate(); }
+ Factory* factory() { return isolate()->factory(); }
+
+ void GetCachedNodes(NodeVector* nodes);
private:
Graph* graph_;
CommonOperatorBuilder* common_;
JSOperatorBuilder* javascript_;
- Typer* typer_;
MachineOperatorBuilder* machine_;
+ // TODO(titzer): make this into a simple array.
SetOncePointer<Node> c_entry_stub_constant_;
SetOncePointer<Node> undefined_constant_;
SetOncePointer<Node> the_hole_constant_;
@@ -106,11 +138,10 @@
CommonNodeCache cache_;
- Node* ImmovableHeapConstant(Handle<Object> value);
+ Node* ImmovableHeapConstant(Handle<HeapObject> value);
Node* NumberConstant(double value);
- Node* NewNode(const Operator* op);
- Factory* factory() { return isolate()->factory(); }
+ DISALLOW_COPY_AND_ASSIGN(JSGraph);
};
} // namespace compiler