AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[turbofan] make GraphAssembler isolate independent

Browse Source 
This enables using the GraphAssembler for Wasm.

Change-Id: Id1f46db6cc05c9de6e878fb062434211a9c390ff
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1977160
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Michael Stanton <mvstanton@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65552}
This commit is contained in:
Tobias Tebbi 2019-12-19 23:05:11 +01:00 committed by Commit Bot
parent d873128a67
commit c679efc440
11 changed files with 178 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/compiler/effect-control-linearizer.cc
View File

@ -274,7 +274,7 @@ class EffectControlLinearizer {
return js_graph_->simplified(); return js_graph_->simplified();
} }
MachineOperatorBuilder* machine() const { return js_graph_->machine(); } MachineOperatorBuilder* machine() const { return js_graph_->machine(); }
GraphAssembler* gasm() { return &graph_assembler_; } JSGraphAssembler* gasm() { return &graph_assembler_; }
JSGraph* js_graph_; JSGraph* js_graph_;
Schedule* schedule_; Schedule* schedule_;
@ -284,7 +284,7 @@ class EffectControlLinearizer {
RegionObservability region_observability_ = RegionObservability::kObservable; RegionObservability region_observability_ = RegionObservability::kObservable;
SourcePositionTable* source_positions_; SourcePositionTable* source_positions_;
NodeOriginTable* node_origins_; NodeOriginTable* node_origins_;
GraphAssembler graph_assembler_; JSGraphAssembler graph_assembler_;
Node* frame_state_zapper_; // For tracking down compiler::Node::New crashes. Node* frame_state_zapper_; // For tracking down compiler::Node::New crashes.
}; };

119
src/compiler/graph-assembler.cc
View File

@ -335,27 +335,28 @@ BasicBlock* GraphAssembler::BasicBlockUpdater::Finalize(BasicBlock* original) {
return block; return block;
} }
GraphAssembler::GraphAssembler(JSGraph* jsgraph, Zone* zone, Schedule* schedule) GraphAssembler::GraphAssembler(MachineGraph* mcgraph, Zone* zone,
Schedule* schedule)
: temp_zone_(zone), : temp_zone_(zone),
jsgraph_(jsgraph), mcgraph_(mcgraph),
effect_(nullptr), effect_(nullptr),
control_(nullptr), control_(nullptr),
block_updater_(schedule != nullptr ? new BasicBlockUpdater( block_updater_(schedule != nullptr ? new BasicBlockUpdater(
schedule, jsgraph->graph(), zone) schedule, mcgraph->graph(), zone)
: nullptr) {} : nullptr) {}
GraphAssembler::~GraphAssembler() = default; GraphAssembler::~GraphAssembler() = default;
Node* GraphAssembler::IntPtrConstant(intptr_t value) { Node* GraphAssembler::IntPtrConstant(intptr_t value) {
return AddClonedNode(jsgraph()->IntPtrConstant(value)); return AddClonedNode(mcgraph()->IntPtrConstant(value));
} }
Node* GraphAssembler::Int32Constant(int32_t value) { Node* GraphAssembler::Int32Constant(int32_t value) {
return AddClonedNode(jsgraph()->Int32Constant(value)); return AddClonedNode(mcgraph()->Int32Constant(value));
} }
Node* GraphAssembler::Int64Constant(int64_t value) { Node* GraphAssembler::Int64Constant(int64_t value) {
return AddClonedNode(jsgraph()->Int64Constant(value)); return AddClonedNode(mcgraph()->Int64Constant(value));
} }
Node* GraphAssembler::UniqueIntPtrConstant(intptr_t value) { Node* GraphAssembler::UniqueIntPtrConstant(intptr_t value) {
@ -365,37 +366,37 @@ Node* GraphAssembler::UniqueIntPtrConstant(intptr_t value) {
: common()->Int32Constant(static_cast<int32_t>(value)))); : common()->Int32Constant(static_cast<int32_t>(value))));
} }
Node* GraphAssembler::SmiConstant(int32_t value) { Node* JSGraphAssembler::SmiConstant(int32_t value) {
return AddClonedNode(jsgraph()->SmiConstant(value)); return AddClonedNode(jsgraph()->SmiConstant(value));
} }
Node* GraphAssembler::Uint32Constant(uint32_t value) { Node* GraphAssembler::Uint32Constant(uint32_t value) {
return AddClonedNode(jsgraph()->Uint32Constant(value)); return AddClonedNode(mcgraph()->Uint32Constant(value));
} }
Node* GraphAssembler::Float64Constant(double value) { Node* GraphAssembler::Float64Constant(double value) {
return AddClonedNode(jsgraph()->Float64Constant(value)); return AddClonedNode(mcgraph()->Float64Constant(value));
} }
TNode<HeapObject> GraphAssembler::HeapConstant(Handle<HeapObject> object) { TNode<HeapObject> JSGraphAssembler::HeapConstant(Handle<HeapObject> object) {
return TNode<HeapObject>::UncheckedCast( return TNode<HeapObject>::UncheckedCast(
AddClonedNode(jsgraph()->HeapConstant(object))); AddClonedNode(jsgraph()->HeapConstant(object)));
} }
TNode<Object> GraphAssembler::Constant(const ObjectRef& ref) { TNode<Object> JSGraphAssembler::Constant(const ObjectRef& ref) {
return TNode<Object>::UncheckedCast(AddClonedNode(jsgraph()->Constant(ref))); return TNode<Object>::UncheckedCast(AddClonedNode(jsgraph()->Constant(ref)));
} }
TNode<Number> GraphAssembler::NumberConstant(double value) { TNode<Number> JSGraphAssembler::NumberConstant(double value) {
return TNode<Number>::UncheckedCast( return TNode<Number>::UncheckedCast(
AddClonedNode(jsgraph()->Constant(value))); AddClonedNode(jsgraph()->Constant(value)));
} }
Node* GraphAssembler::ExternalConstant(ExternalReference ref) { Node* GraphAssembler::ExternalConstant(ExternalReference ref) {
return AddClonedNode(jsgraph()->ExternalConstant(ref)); return AddClonedNode(mcgraph()->ExternalConstant(ref));
} }
Node* GraphAssembler::CEntryStubConstant(int result_size) { Node* JSGraphAssembler::CEntryStubConstant(int result_size) {
return AddClonedNode(jsgraph()->CEntryStubConstant(result_size)); return AddClonedNode(jsgraph()->CEntryStubConstant(result_size));
} }
@ -404,17 +405,17 @@ Node* GraphAssembler::LoadFramePointer() {
} }
#define SINGLETON_CONST_DEF(Name, Type) \ #define SINGLETON_CONST_DEF(Name, Type) \
TNode<Type> GraphAssembler::Name##Constant() { \ TNode<Type> JSGraphAssembler::Name##Constant() { \
return TNode<Type>::UncheckedCast( \ return TNode<Type>::UncheckedCast( \
AddClonedNode(jsgraph()->Name##Constant())); \ AddClonedNode(jsgraph()->Name##Constant())); \
} }
JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_DEF) JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_DEF)
#undef SINGLETON_CONST_DEF #undef SINGLETON_CONST_DEF
#define SINGLETON_CONST_TEST_DEF(Name, ...) \ #define SINGLETON_CONST_TEST_DEF(Name, ...) \
TNode<Boolean> GraphAssembler::Is##Name(TNode<Object> value) { \ TNode<Boolean> JSGraphAssembler::Is##Name(TNode<Object> value) { \
return TNode<Boolean>::UncheckedCast( \ return TNode<Boolean>::UncheckedCast( \
ReferenceEqual(value, Name##Constant())); \ ReferenceEqual(value, Name##Constant())); \
} }
JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_TEST_DEF) JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_TEST_DEF)
#undef SINGLETON_CONST_TEST_DEF #undef SINGLETON_CONST_TEST_DEF
@ -485,115 +486,118 @@ Node* GraphAssembler::Projection(int index, Node* value) {
graph()->NewNode(common()->Projection(index), value, control())); graph()->NewNode(common()->Projection(index), value, control()));
} }
Node* GraphAssembler::Allocate(AllocationType allocation, Node* size) { Node* JSGraphAssembler::Allocate(AllocationType allocation, Node* size) {
return AddNode( return AddNode(
graph()->NewNode(simplified()->AllocateRaw(Type::Any(), allocation), size, graph()->NewNode(simplified()->AllocateRaw(Type::Any(), allocation), size,
effect(), control())); effect(), control()));
} }
Node* GraphAssembler::LoadField(FieldAccess const& access, Node* object) { Node* JSGraphAssembler::LoadField(FieldAccess const& access, Node* object) {
Node* value = AddNode(graph()->NewNode(simplified()->LoadField(access), Node* value = AddNode(graph()->NewNode(simplified()->LoadField(access),
object, effect(), control())); object, effect(), control()));
return value; return value;
} }
Node* GraphAssembler::LoadElement(ElementAccess const& access, Node* object, Node* JSGraphAssembler::LoadElement(ElementAccess const& access, Node* object,
Node* index) { Node* index) {
Node* value = AddNode(graph()->NewNode(simplified()->LoadElement(access), Node* value = AddNode(graph()->NewNode(simplified()->LoadElement(access),
object, index, effect(), control())); object, index, effect(), control()));
return value; return value;
} }
Node* GraphAssembler::StoreField(FieldAccess const& access, Node* object, Node* JSGraphAssembler::StoreField(FieldAccess const& access, Node* object,
Node* value) { Node* value) {
return AddNode(graph()->NewNode(simplified()->StoreField(access), object, return AddNode(graph()->NewNode(simplified()->StoreField(access), object,
value, effect(), control())); value, effect(), control()));
} }
Node* GraphAssembler::StoreElement(ElementAccess const& access, Node* object, Node* JSGraphAssembler::StoreElement(ElementAccess const& access, Node* object,
Node* index, Node* value) { Node* index, Node* value) {
return AddNode(graph()->NewNode(simplified()->StoreElement(access), object, return AddNode(graph()->NewNode(simplified()->StoreElement(access), object,
index, value, effect(), control())); index, value, effect(), control()));
} }
void GraphAssembler::TransitionAndStoreElement(MapRef double_map, void JSGraphAssembler::TransitionAndStoreElement(MapRef double_map,
MapRef fast_map, MapRef fast_map,
TNode<HeapObject> object, TNode<HeapObject> object,
TNode<Number> index, TNode<Number> index,
TNode<Object> value) { TNode<Object> value) {
AddNode(graph()->NewNode(simplified()->TransitionAndStoreElement( AddNode(graph()->NewNode(simplified()->TransitionAndStoreElement(
double_map.object(), fast_map.object()), double_map.object(), fast_map.object()),
object, index, value, effect(), control())); object, index, value, effect(), control()));
} }
TNode<Number> GraphAssembler::StringLength(TNode<String> string) { TNode<Number> JSGraphAssembler::StringLength(TNode<String> string) {
return AddNode<Number>( return AddNode<Number>(
graph()->NewNode(simplified()->StringLength(), string)); graph()->NewNode(simplified()->StringLength(), string));
} }
TNode<Boolean> GraphAssembler::ReferenceEqual(TNode<Object> lhs, TNode<Boolean> JSGraphAssembler::ReferenceEqual(TNode<Object> lhs,
TNode<Object> rhs) { TNode<Object> rhs) {
return AddNode<Boolean>( return AddNode<Boolean>(
graph()->NewNode(simplified()->ReferenceEqual(), lhs, rhs)); graph()->NewNode(simplified()->ReferenceEqual(), lhs, rhs));
} }
TNode<Number> GraphAssembler::NumberMin(TNode<Number> lhs, TNode<Number> rhs) { TNode<Number> JSGraphAssembler::NumberMin(TNode<Number> lhs,
TNode<Number> rhs) {
return AddNode<Number>(graph()->NewNode(simplified()->NumberMin(), lhs, rhs)); return AddNode<Number>(graph()->NewNode(simplified()->NumberMin(), lhs, rhs));
} }
TNode<Number> GraphAssembler::NumberMax(TNode<Number> lhs, TNode<Number> rhs) { TNode<Number> JSGraphAssembler::NumberMax(TNode<Number> lhs,
TNode<Number> rhs) {
return AddNode<Number>(graph()->NewNode(simplified()->NumberMax(), lhs, rhs)); return AddNode<Number>(graph()->NewNode(simplified()->NumberMax(), lhs, rhs));
} }
TNode<Number> GraphAssembler::NumberAdd(TNode<Number> lhs, TNode<Number> rhs) { TNode<Number> JSGraphAssembler::NumberAdd(TNode<Number> lhs,
TNode<Number> rhs) {
return AddNode<Number>(graph()->NewNode(simplified()->NumberAdd(), lhs, rhs)); return AddNode<Number>(graph()->NewNode(simplified()->NumberAdd(), lhs, rhs));
} }
TNode<Number> GraphAssembler::NumberSubtract(TNode<Number> lhs, TNode<Number> JSGraphAssembler::NumberSubtract(TNode<Number> lhs,
TNode<Number> rhs) { TNode<Number> rhs) {
return AddNode<Number>( return AddNode<Number>(
graph()->NewNode(simplified()->NumberSubtract(), lhs, rhs)); graph()->NewNode(simplified()->NumberSubtract(), lhs, rhs));
} }
TNode<Boolean> GraphAssembler::NumberLessThan(TNode<Number> lhs, TNode<Boolean> JSGraphAssembler::NumberLessThan(TNode<Number> lhs,
TNode<Number> rhs) { TNode<Number> rhs) {
return AddNode<Boolean>( return AddNode<Boolean>(
graph()->NewNode(simplified()->NumberLessThan(), lhs, rhs)); graph()->NewNode(simplified()->NumberLessThan(), lhs, rhs));
} }
TNode<Boolean> GraphAssembler::NumberLessThanOrEqual(TNode<Number> lhs, TNode<Boolean> JSGraphAssembler::NumberLessThanOrEqual(TNode<Number> lhs,
TNode<Number> rhs) { TNode<Number> rhs) {
return AddNode<Boolean>( return AddNode<Boolean>(
graph()->NewNode(simplified()->NumberLessThanOrEqual(), lhs, rhs)); graph()->NewNode(simplified()->NumberLessThanOrEqual(), lhs, rhs));
} }
TNode<String> GraphAssembler::StringSubstring(TNode<String> string, TNode<String> JSGraphAssembler::StringSubstring(TNode<String> string,
TNode<Number> from, TNode<Number> from,
TNode<Number> to) { TNode<Number> to) {
return AddNode<String>(graph()->NewNode( return AddNode<String>(graph()->NewNode(
simplified()->StringSubstring(), string, from, to, effect(), control())); simplified()->StringSubstring(), string, from, to, effect(), control()));
} }
TNode<Boolean> GraphAssembler::ObjectIsCallable(TNode<Object> value) { TNode<Boolean> JSGraphAssembler::ObjectIsCallable(TNode<Object> value) {
return AddNode<Boolean>( return AddNode<Boolean>(
graph()->NewNode(simplified()->ObjectIsCallable(), value)); graph()->NewNode(simplified()->ObjectIsCallable(), value));
} }
Node* GraphAssembler::CheckIf(Node* cond, DeoptimizeReason reason) { Node* JSGraphAssembler::CheckIf(Node* cond, DeoptimizeReason reason) {
return AddNode(graph()->NewNode(simplified()->CheckIf(reason), cond, effect(), return AddNode(graph()->NewNode(simplified()->CheckIf(reason), cond, effect(),
control())); control()));
} }
TNode<Boolean> GraphAssembler::NumberIsFloat64Hole(TNode<Number> value) { TNode<Boolean> JSGraphAssembler::NumberIsFloat64Hole(TNode<Number> value) {
return AddNode<Boolean>( return AddNode<Boolean>(
graph()->NewNode(simplified()->NumberIsFloat64Hole(), value)); graph()->NewNode(simplified()->NumberIsFloat64Hole(), value));
} }
TNode<Boolean> GraphAssembler::ToBoolean(TNode<Object> value) { TNode<Boolean> JSGraphAssembler::ToBoolean(TNode<Object> value) {
return AddNode<Boolean>(graph()->NewNode(simplified()->ToBoolean(), value)); return AddNode<Boolean>(graph()->NewNode(simplified()->ToBoolean(), value));
} }
TNode<FixedArrayBase> GraphAssembler::MaybeGrowFastElements( TNode<FixedArrayBase> JSGraphAssembler::MaybeGrowFastElements(
ElementsKind kind, const FeedbackSource& feedback, TNode<JSArray> array, ElementsKind kind, const FeedbackSource& feedback, TNode<JSArray> array,
TNode<FixedArrayBase> elements, TNode<Number> new_length, TNode<FixedArrayBase> elements, TNode<Number> new_length,
TNode<Number> old_length) { TNode<Number> old_length) {
@ -677,7 +681,7 @@ Node* GraphAssembler::UnsafePointerAdd(Node* base, Node* external) {
effect(), control())); effect(), control()));
} }
TNode<Number> GraphAssembler::ToNumber(TNode<Object> value) { TNode<Number> JSGraphAssembler::ToNumber(TNode<Object> value) {
return AddNode<Number>(graph()->NewNode(ToNumberOperator(), return AddNode<Number>(graph()->NewNode(ToNumberOperator(),
ToNumberBuiltinConstant(), value, ToNumberBuiltinConstant(), value,
NoContextConstant(), effect())); NoContextConstant(), effect()));
@ -798,7 +802,7 @@ void GraphAssembler::GotoIfBasicBlock(BasicBlock* block, Node* branch,
BasicBlock* GraphAssembler::FinalizeCurrentBlock(BasicBlock* block) { BasicBlock* GraphAssembler::FinalizeCurrentBlock(BasicBlock* block) {
if (block_updater_) { if (block_updater_) {
block = block_updater_->Finalize(block); block = block_updater_->Finalize(block);
if (control() == jsgraph()->Dead()) { if (control() == mcgraph()->Dead()) {
// If the block's end is unreachable, then reset current effect and // If the block's end is unreachable, then reset current effect and
// control to that of the block's throw control node. // control to that of the block's throw control node.
DCHECK(block->control() == BasicBlock::kThrow); DCHECK(block->control() == BasicBlock::kThrow);
@ -814,7 +818,7 @@ void GraphAssembler::ConnectUnreachableToEnd() {
DCHECK_EQ(effect()->opcode(), IrOpcode::kUnreachable); DCHECK_EQ(effect()->opcode(), IrOpcode::kUnreachable);
Node* throw_node = graph()->NewNode(common()->Throw(), effect(), control()); Node* throw_node = graph()->NewNode(common()->Throw(), effect(), control());
NodeProperties::MergeControlToEnd(graph(), common(), throw_node); NodeProperties::MergeControlToEnd(graph(), common(), throw_node);
effect_ = control_ = jsgraph()->Dead(); effect_ = control_ = mcgraph()->Dead();
if (block_updater_) { if (block_updater_) {
block_updater_->AddThrow(throw_node); block_updater_->AddThrow(throw_node);
} }
@ -856,10 +860,9 @@ void GraphAssembler::InitializeEffectControl(Node* effect, Node* control) {
control_ = control; control_ = control;
} }
Operator const* GraphAssembler::ToNumberOperator() { Operator const* JSGraphAssembler::ToNumberOperator() {
if (!to_number_operator_.is_set()) { if (!to_number_operator_.is_set()) {
Callable callable = Callable callable = Builtins::CallableFor(isolate(), Builtins::kToNumber);
Builtins::CallableFor(jsgraph()->isolate(), Builtins::kToNumber);
CallDescriptor::Flags flags = CallDescriptor::kNoFlags; CallDescriptor::Flags flags = CallDescriptor::kNoFlags;
auto call_descriptor = Linkage::GetStubCallDescriptor( auto call_descriptor = Linkage::GetStubCallDescriptor(
graph()->zone(), callable.descriptor(), graph()->zone(), callable.descriptor(),

161
src/compiler/graph-assembler.h
View File

@ -232,7 +232,8 @@ class V8_EXPORT_PRIVATE GraphAssembler {
public: public:
// Constructs a GraphAssembler. If {schedule} is not null, the graph assembler // Constructs a GraphAssembler. If {schedule} is not null, the graph assembler
// will maintain the schedule as it updates blocks. // will maintain the schedule as it updates blocks.
GraphAssembler(JSGraph* jsgraph, Zone* zone, Schedule* schedule = nullptr); GraphAssembler(MachineGraph* jsgraph, Zone* zone,
Schedule* schedule = nullptr);
virtual ~GraphAssembler(); virtual ~GraphAssembler();
void Reset(BasicBlock* block); void Reset(BasicBlock* block);
@ -271,26 +272,12 @@ class V8_EXPORT_PRIVATE GraphAssembler {
Node* Int32Constant(int32_t value); Node* Int32Constant(int32_t value);
Node* Int64Constant(int64_t value); Node* Int64Constant(int64_t value);
Node* UniqueIntPtrConstant(intptr_t value); Node* UniqueIntPtrConstant(intptr_t value);
Node* SmiConstant(int32_t value);
Node* Float64Constant(double value); Node* Float64Constant(double value);
Node* Projection(int index, Node* value); Node* Projection(int index, Node* value);
TNode<HeapObject> HeapConstant(Handle<HeapObject> object);
TNode<Object> Constant(const ObjectRef& ref);
TNode<Number> NumberConstant(double value);
Node* CEntryStubConstant(int result_size);
Node* ExternalConstant(ExternalReference ref); Node* ExternalConstant(ExternalReference ref);
Node* LoadFramePointer(); Node* LoadFramePointer();
#define SINGLETON_CONST_DECL(Name, Type) TNode<Type> Name##Constant();
JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_DECL)
#undef SINGLETON_CONST_DECL
#define SINGLETON_CONST_TEST_DECL(Name, ...) \
TNode<Boolean> Is##Name(TNode<Object> value);
JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_TEST_DECL)
#undef SINGLETON_CONST_TEST_DECL
#define PURE_UNOP_DECL(Name) Node* Name(Node* input); #define PURE_UNOP_DECL(Name) Node* Name(Node* input);
PURE_ASSEMBLER_MACH_UNOP_LIST(PURE_UNOP_DECL) PURE_ASSEMBLER_MACH_UNOP_LIST(PURE_UNOP_DECL)
#undef PURE_UNOP_DECL #undef PURE_UNOP_DECL
@ -314,54 +301,9 @@ class V8_EXPORT_PRIVATE GraphAssembler {
Node* Float64RoundDown(Node* value); Node* Float64RoundDown(Node* value);
Node* Float64RoundTruncate(Node* value); Node* Float64RoundTruncate(Node* value);
TNode<Number> ToNumber(TNode<Object> value);
Node* BitcastWordToTagged(Node* value); Node* BitcastWordToTagged(Node* value);
Node* BitcastTaggedToWord(Node* value); Node* BitcastTaggedToWord(Node* value);
Node* BitcastTaggedToWordForTagAndSmiBits(Node* value); Node* BitcastTaggedToWordForTagAndSmiBits(Node* value);
Node* Allocate(AllocationType allocation, Node* size);
Node* LoadField(FieldAccess const&, Node* object);
template <typename T>
TNode<T> LoadField(FieldAccess const& access, TNode<HeapObject> object) {
// TODO(jgruber): Investigate issues on ptr compression bots and enable.
// DCHECK(IsMachineRepresentationOf<T>(
// access.machine_type.representation()));
return TNode<T>::UncheckedCast(LoadField(access, object));
}
Node* LoadElement(ElementAccess const&, Node* object, Node* index);
template <typename T>
TNode<T> LoadElement(ElementAccess const& access, TNode<HeapObject> object,
TNode<Number> index) {
// TODO(jgruber): Investigate issues on ptr compression bots and enable.
// DCHECK(IsMachineRepresentationOf<T>(
// access.machine_type.representation()));
return TNode<T>::UncheckedCast(LoadElement(access, object, index));
}
Node* StoreField(FieldAccess const&, Node* object, Node* value);
Node* StoreElement(ElementAccess const&, Node* object, Node* index,
Node* value);
void TransitionAndStoreElement(MapRef double_map, MapRef fast_map,
TNode<HeapObject> object, TNode<Number> index,
TNode<Object> value);
TNode<Number> StringLength(TNode<String> string);
TNode<Boolean> ReferenceEqual(TNode<Object> lhs, TNode<Object> rhs);
TNode<Number> NumberMin(TNode<Number> lhs, TNode<Number> rhs);
TNode<Number> NumberMax(TNode<Number> lhs, TNode<Number> rhs);
TNode<Boolean> NumberLessThan(TNode<Number> lhs, TNode<Number> rhs);
TNode<Boolean> NumberLessThanOrEqual(TNode<Number> lhs, TNode<Number> rhs);
TNode<Number> NumberAdd(TNode<Number> lhs, TNode<Number> rhs);
TNode<Number> NumberSubtract(TNode<Number> lhs, TNode<Number> rhs);
TNode<String> StringSubstring(TNode<String> string, TNode<Number> from,
TNode<Number> to);
TNode<Boolean> ObjectIsCallable(TNode<Object> value);
Node* CheckIf(Node* cond, DeoptimizeReason reason);
TNode<Boolean> NumberIsFloat64Hole(TNode<Number> value);
TNode<Boolean> ToBoolean(TNode<Object> value);
TNode<FixedArrayBase> MaybeGrowFastElements(ElementsKind kind,
const FeedbackSource& feedback,
TNode<JSArray> array,
TNode<FixedArrayBase> elements,
TNode<Number> new_length,
TNode<Number> old_length);
Node* TypeGuard(Type type, Node* value); Node* TypeGuard(Type type, Node* value);
Node* Checkpoint(FrameState frame_state); Node* Checkpoint(FrameState frame_state);
@ -468,17 +410,11 @@ class V8_EXPORT_PRIVATE GraphAssembler {
V8_INLINE Node* AddClonedNode(Node* node); V8_INLINE Node* AddClonedNode(Node* node);
Operator const* ToNumberOperator(); MachineGraph* mcgraph() const { return mcgraph_; }
Graph* graph() const { return mcgraph_->graph(); }
JSGraph* jsgraph() const { return jsgraph_; }
Isolate* isolate() const { return jsgraph_->isolate(); }
Graph* graph() const { return jsgraph_->graph(); }
Zone* temp_zone() const { return temp_zone_; } Zone* temp_zone() const { return temp_zone_; }
CommonOperatorBuilder* common() const { return jsgraph()->common(); } CommonOperatorBuilder* common() const { return mcgraph()->common(); }
MachineOperatorBuilder* machine() const { return jsgraph()->machine(); } MachineOperatorBuilder* machine() const { return mcgraph()->machine(); }
SimplifiedOperatorBuilder* simplified() const {
return jsgraph()->simplified();
}
private: private:
template <typename... Vars> template <typename... Vars>
@ -491,9 +427,8 @@ class V8_EXPORT_PRIVATE GraphAssembler {
BasicBlock* if_true_block, BasicBlock* if_true_block,
BasicBlock* if_false_block); BasicBlock* if_false_block);
SetOncePointer<Operator const> to_number_operator_;
Zone* temp_zone_; Zone* temp_zone_;
JSGraph* jsgraph_; MachineGraph* mcgraph_;
Node* effect_; Node* effect_;
Node* control_; Node* control_;
std::unique_ptr<BasicBlockUpdater> block_updater_; std::unique_ptr<BasicBlockUpdater> block_updater_;
@ -718,6 +653,88 @@ Node* GraphAssembler::Call(const Operator* op, Args... args) {
return AddNode(call); return AddNode(call);
} }
class V8_EXPORT_PRIVATE JSGraphAssembler : public GraphAssembler {
public:
// Constructs a JSGraphAssembler. If {schedule} is not null, the graph
// assembler will maintain the schedule as it updates blocks.
JSGraphAssembler(JSGraph* jsgraph, Zone* zone, Schedule* schedule = nullptr)
: GraphAssembler(jsgraph, zone, schedule), jsgraph_(jsgraph) {}
Node* SmiConstant(int32_t value);
TNode<HeapObject> HeapConstant(Handle<HeapObject> object);
TNode<Object> Constant(const ObjectRef& ref);
TNode<Number> NumberConstant(double value);
Node* CEntryStubConstant(int result_size);
#define SINGLETON_CONST_DECL(Name, Type) TNode<Type> Name##Constant();
JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_DECL)
#undef SINGLETON_CONST_DECL
#define SINGLETON_CONST_TEST_DECL(Name, ...) \
TNode<Boolean> Is##Name(TNode<Object> value);
JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_TEST_DECL)
#undef SINGLETON_CONST_TEST_DECL
Node* Allocate(AllocationType allocation, Node* size);
Node* LoadField(FieldAccess const&, Node* object);
template <typename T>
TNode<T> LoadField(FieldAccess const& access, TNode<HeapObject> object) {
// TODO(jgruber): Investigate issues on ptr compression bots and enable.
// DCHECK(IsMachineRepresentationOf<T>(
// access.machine_type.representation()));
return TNode<T>::UncheckedCast(LoadField(access, object));
}
Node* LoadElement(ElementAccess const&, Node* object, Node* index);
template <typename T>
TNode<T> LoadElement(ElementAccess const& access, TNode<HeapObject> object,
TNode<Number> index) {
// TODO(jgruber): Investigate issues on ptr compression bots and enable.
// DCHECK(IsMachineRepresentationOf<T>(
// access.machine_type.representation()));
return TNode<T>::UncheckedCast(LoadElement(access, object, index));
}
Node* StoreField(FieldAccess const&, Node* object, Node* value);
Node* StoreElement(ElementAccess const&, Node* object, Node* index,
Node* value);
void TransitionAndStoreElement(MapRef double_map, MapRef fast_map,
TNode<HeapObject> object, TNode<Number> index,
TNode<Object> value);
TNode<Number> StringLength(TNode<String> string);
TNode<Boolean> ReferenceEqual(TNode<Object> lhs, TNode<Object> rhs);
TNode<Number> ToNumber(TNode<Object> value);
TNode<Number> NumberMin(TNode<Number> lhs, TNode<Number> rhs);
TNode<Number> NumberMax(TNode<Number> lhs, TNode<Number> rhs);
TNode<Boolean> NumberLessThan(TNode<Number> lhs, TNode<Number> rhs);
TNode<Boolean> NumberLessThanOrEqual(TNode<Number> lhs, TNode<Number> rhs);
TNode<Number> NumberAdd(TNode<Number> lhs, TNode<Number> rhs);
TNode<Number> NumberSubtract(TNode<Number> lhs, TNode<Number> rhs);
TNode<String> StringSubstring(TNode<String> string, TNode<Number> from,
TNode<Number> to);
TNode<Boolean> ObjectIsCallable(TNode<Object> value);
Node* CheckIf(Node* cond, DeoptimizeReason reason);
TNode<Boolean> NumberIsFloat64Hole(TNode<Number> value);
TNode<Boolean> ToBoolean(TNode<Object> value);
TNode<FixedArrayBase> MaybeGrowFastElements(ElementsKind kind,
const FeedbackSource& feedback,
TNode<JSArray> array,
TNode<FixedArrayBase> elements,
TNode<Number> new_length,
TNode<Number> old_length);
JSGraph* jsgraph() const { return jsgraph_; }
Isolate* isolate() const { return jsgraph()->isolate(); }
SimplifiedOperatorBuilder* simplified() const {
return jsgraph()->simplified();
}
protected:
Operator const* ToNumberOperator();
private:
JSGraph* jsgraph_;
SetOncePointer<Operator const> to_number_operator_;
};
} // namespace compiler } // namespace compiler
} // namespace internal } // namespace internal
} // namespace v8 } // namespace v8

24
src/compiler/js-call-reducer.cc
View File

@ -41,10 +41,12 @@ namespace compiler {
// Shorter lambda declarations with less visual clutter. // Shorter lambda declarations with less visual clutter.
#define _ [&]() // NOLINT(whitespace/braces) #define _ [&]() // NOLINT(whitespace/braces)
class JSCallReducerAssembler : public GraphAssembler { class JSCallReducerAssembler : public JSGraphAssembler {
public: public:
JSCallReducerAssembler(JSGraph* jsgraph, Zone* zone, Node* node) JSCallReducerAssembler(JSGraph* jsgraph, Zone* zone, Node* node)
: GraphAssembler(jsgraph, zone), node_(node), if_exception_nodes_(zone) { : JSGraphAssembler(jsgraph, zone),
node_(node),
if_exception_nodes_(zone) {
InitializeEffectControl(NodeProperties::GetEffectInput(node), InitializeEffectControl(NodeProperties::GetEffectInput(node),
NodeProperties::GetControlInput(node)); NodeProperties::GetControlInput(node));
@ -84,7 +86,7 @@ class JSCallReducerAssembler : public GraphAssembler {
// implementation. // implementation.
class IfBuilder0 { class IfBuilder0 {
public: public:
IfBuilder0(GraphAssembler* gasm, TNode<Boolean> cond, bool negate_cond) IfBuilder0(JSGraphAssembler* gasm, TNode<Boolean> cond, bool negate_cond)
: gasm_(gasm), cond_(cond), negate_cond_(negate_cond) {} : gasm_(gasm), cond_(cond), negate_cond_(negate_cond) {}
V8_WARN_UNUSED_RESULT IfBuilder0& ExpectTrue() { V8_WARN_UNUSED_RESULT IfBuilder0& ExpectTrue() {
@ -134,7 +136,7 @@ class JSCallReducerAssembler : public GraphAssembler {
} }
private: private:
GraphAssembler* const gasm_; JSGraphAssembler* const gasm_;
const TNode<Boolean> cond_; const TNode<Boolean> cond_;
const bool negate_cond_; const bool negate_cond_;
BranchHint hint_ = BranchHint::kNone; BranchHint hint_ = BranchHint::kNone;
@ -150,7 +152,7 @@ class JSCallReducerAssembler : public GraphAssembler {
using If1BodyFunction = std::function<TNode<T>()>; using If1BodyFunction = std::function<TNode<T>()>;
public: public:
IfBuilder1(GraphAssembler* gasm, TNode<Boolean> cond) IfBuilder1(JSGraphAssembler* gasm, TNode<Boolean> cond)
: gasm_(gasm), cond_(cond) {} : gasm_(gasm), cond_(cond) {}
V8_WARN_UNUSED_RESULT IfBuilder1& ExpectTrue() { V8_WARN_UNUSED_RESULT IfBuilder1& ExpectTrue() {
@ -200,7 +202,7 @@ class JSCallReducerAssembler : public GraphAssembler {
static constexpr MachineRepresentation kPhiRepresentation = static constexpr MachineRepresentation kPhiRepresentation =
MachineRepresentation::kTagged; MachineRepresentation::kTagged;
GraphAssembler* const gasm_; JSGraphAssembler* const gasm_;
const TNode<Boolean> cond_; const TNode<Boolean> cond_;
BranchHint hint_ = BranchHint::kNone; BranchHint hint_ = BranchHint::kNone;
If1BodyFunction then_body_; If1BodyFunction then_body_;
@ -288,7 +290,7 @@ class JSCallReducerAssembler : public GraphAssembler {
using For0BodyFunction = std::function<void(TNode<Number>)>; using For0BodyFunction = std::function<void(TNode<Number>)>;
public: public:
ForBuilder0(GraphAssembler* gasm, TNode<Number> initial_value, ForBuilder0(JSGraphAssembler* gasm, TNode<Number> initial_value,
const ConditionFunction1& cond, const StepFunction1& step) const ConditionFunction1& cond, const StepFunction1& step)
: gasm_(gasm), : gasm_(gasm),
initial_value_(initial_value), initial_value_(initial_value),
@ -324,7 +326,7 @@ class JSCallReducerAssembler : public GraphAssembler {
static constexpr MachineRepresentation kPhiRepresentation = static constexpr MachineRepresentation kPhiRepresentation =
MachineRepresentation::kTagged; MachineRepresentation::kTagged;
GraphAssembler* const gasm_; JSGraphAssembler* const gasm_;
const TNode<Number> initial_value_; const TNode<Number> initial_value_;
const ConditionFunction1 cond_; const ConditionFunction1 cond_;
const StepFunction1 step_; const StepFunction1 step_;
@ -347,7 +349,7 @@ class JSCallReducerAssembler : public GraphAssembler {
using For1BodyFunction = std::function<void(TNode<Number>, TNode<Object>*)>; using For1BodyFunction = std::function<void(TNode<Number>, TNode<Object>*)>;
class ForBuilder1 { class ForBuilder1 {
public: public:
ForBuilder1(GraphAssembler* gasm, TNode<Number> initial_value, ForBuilder1(JSGraphAssembler* gasm, TNode<Number> initial_value,
const ConditionFunction1& cond, const StepFunction1& step, const ConditionFunction1& cond, const StepFunction1& step,
TNode<Object> initial_arg0) TNode<Object> initial_arg0)
: gasm_(gasm), : gasm_(gasm),
@ -399,7 +401,7 @@ class JSCallReducerAssembler : public GraphAssembler {
static constexpr MachineRepresentation kPhiRepresentation = static constexpr MachineRepresentation kPhiRepresentation =
MachineRepresentation::kTagged; MachineRepresentation::kTagged;
GraphAssembler* const gasm_; JSGraphAssembler* const gasm_;
const TNode<Number> initial_value_; const TNode<Number> initial_value_;
const ConditionFunction1 cond_; const ConditionFunction1 cond_;
const StepFunction1 step_; const StepFunction1 step_;
@ -670,7 +672,7 @@ TNode<JSArray> JSCallReducerAssembler::CreateArrayNoThrow(TNode<Object> ctor,
TNode<JSArray> JSCallReducerAssembler::AllocateEmptyJSArray( TNode<JSArray> JSCallReducerAssembler::AllocateEmptyJSArray(
ElementsKind kind, const NativeContextRef& native_context) { ElementsKind kind, const NativeContextRef& native_context) {
// TODO(jgruber): Port AllocationBuilder to GraphAssembler. // TODO(jgruber): Port AllocationBuilder to JSGraphAssembler.
MapRef map = native_context.GetInitialJSArrayMap(kind); MapRef map = native_context.GetInitialJSArrayMap(kind);
AllocationBuilder ab(jsgraph(), effect(), control()); AllocationBuilder ab(jsgraph(), effect(), control());

2
src/compiler/memory-lowering.cc
View File

@ -44,7 +44,7 @@ class MemoryLowering::AllocationGroup final : public ZoneObject {
}; };
MemoryLowering::MemoryLowering(JSGraph* jsgraph, Zone* zone, MemoryLowering::MemoryLowering(JSGraph* jsgraph, Zone* zone,
GraphAssembler* graph_assembler, JSGraphAssembler* graph_assembler,
PoisoningMitigationLevel poisoning_level, PoisoningMitigationLevel poisoning_level,
AllocationFolding allocation_folding, AllocationFolding allocation_folding,
WriteBarrierAssertFailedCallback callback, WriteBarrierAssertFailedCallback callback,

6
src/compiler/memory-lowering.h
View File

@ -71,7 +71,7 @@ class MemoryLowering final : public Reducer {
Node* node, Node* object, const char* name, Zone* temp_zone)>; Node* node, Node* object, const char* name, Zone* temp_zone)>;
MemoryLowering( MemoryLowering(
JSGraph* jsgraph, Zone* zone, GraphAssembler* graph_assembler, JSGraph* jsgraph, Zone* zone, JSGraphAssembler* graph_assembler,
PoisoningMitigationLevel poisoning_level, PoisoningMitigationLevel poisoning_level,
AllocationFolding allocation_folding = AllocationFolding allocation_folding =
AllocationFolding::kDontAllocationFolding, AllocationFolding::kDontAllocationFolding,
@ -116,7 +116,7 @@ class MemoryLowering final : public Reducer {
Zone* graph_zone() const { return graph_zone_; } Zone* graph_zone() const { return graph_zone_; }
CommonOperatorBuilder* common() const { return common_; } CommonOperatorBuilder* common() const { return common_; }
MachineOperatorBuilder* machine() const { return machine_; } MachineOperatorBuilder* machine() const { return machine_; }
GraphAssembler* gasm() const { return graph_assembler_; } JSGraphAssembler* gasm() const { return graph_assembler_; }
SetOncePointer<const Operator> allocate_operator_; SetOncePointer<const Operator> allocate_operator_;
Isolate* isolate_; Isolate* isolate_;
@ -124,7 +124,7 @@ class MemoryLowering final : public Reducer {
Zone* graph_zone_; Zone* graph_zone_;
CommonOperatorBuilder* common_; CommonOperatorBuilder* common_;
MachineOperatorBuilder* machine_; MachineOperatorBuilder* machine_;
GraphAssembler* graph_assembler_; JSGraphAssembler* graph_assembler_;
AllocationFolding allocation_folding_; AllocationFolding allocation_folding_;
PoisoningMitigationLevel poisoning_level_; PoisoningMitigationLevel poisoning_level_;
WriteBarrierAssertFailedCallback write_barrier_assert_failed_; WriteBarrierAssertFailedCallback write_barrier_assert_failed_;

2
src/compiler/memory-optimizer.h
View File

@ -79,7 +79,7 @@ class MemoryOptimizer final {
JSGraph* jsgraph() const { return jsgraph_; } JSGraph* jsgraph() const { return jsgraph_; }
Zone* zone() const { return zone_; } Zone* zone() const { return zone_; }
GraphAssembler graph_assembler_; JSGraphAssembler graph_assembler_;
MemoryLowering memory_lowering_; MemoryLowering memory_lowering_;
JSGraph* jsgraph_; JSGraph* jsgraph_;
AllocationState const* const empty_state_; AllocationState const* const empty_state_;

2
src/compiler/pipeline.cc
View File

@ -1801,7 +1801,7 @@ struct LateOptimizationPhase {
CommonOperatorReducer common_reducer(&graph_reducer, data->graph(), CommonOperatorReducer common_reducer(&graph_reducer, data->graph(),
data->broker(), data->common(), data->broker(), data->common(),
data->machine(), temp_zone); data->machine(), temp_zone);
GraphAssembler graph_assembler(data->jsgraph(), temp_zone); JSGraphAssembler graph_assembler(data->jsgraph(), temp_zone);
SelectLowering select_lowering(&graph_assembler, data->graph()); SelectLowering select_lowering(&graph_assembler, data->graph());
AddReducer(data, &graph_reducer, &branch_condition_elimination); AddReducer(data, &graph_reducer, &branch_condition_elimination);
AddReducer(data, &graph_reducer, &dead_code_elimination); AddReducer(data, &graph_reducer, &dead_code_elimination);

4
src/compiler/scheduled-machine-lowering.h
View File

@ -32,11 +32,11 @@ class ScheduledMachineLowering final {
private: private:
bool LowerNode(Node* node); bool LowerNode(Node* node);
GraphAssembler* gasm() { return &graph_assembler_; } JSGraphAssembler* gasm() { return &graph_assembler_; }
Schedule* schedule() { return schedule_; } Schedule* schedule() { return schedule_; }
Schedule* schedule_; Schedule* schedule_;
GraphAssembler graph_assembler_; JSGraphAssembler graph_assembler_;
SelectLowering select_lowering_; SelectLowering select_lowering_;
MemoryLowering memory_lowering_; MemoryLowering memory_lowering_;
ZoneVector<Reducer*> reducers_; ZoneVector<Reducer*> reducers_;

2
src/compiler/select-lowering.cc
View File

@ -15,7 +15,7 @@ namespace v8 {
namespace internal { namespace internal {
namespace compiler { namespace compiler {
SelectLowering::SelectLowering(GraphAssembler* graph_assembler, Graph* graph) SelectLowering::SelectLowering(JSGraphAssembler* graph_assembler, Graph* graph)
: graph_assembler_(graph_assembler), start_(graph->start()) {} : graph_assembler_(graph_assembler), start_(graph->start()) {}
SelectLowering::~SelectLowering() = default; SelectLowering::~SelectLowering() = default;

8
src/compiler/select-lowering.h
View File

@ -12,12 +12,12 @@ namespace internal {
namespace compiler { namespace compiler {
// Forward declarations. // Forward declarations.
class GraphAssembler; class JSGraphAssembler;
// Lowers Select nodes to diamonds. // Lowers Select nodes to diamonds.
class SelectLowering final : public Reducer { class SelectLowering final : public Reducer {
public: public:
SelectLowering(GraphAssembler* graph_assembler, Graph* graph); SelectLowering(JSGraphAssembler* graph_assembler, Graph* graph);
~SelectLowering() override; ~SelectLowering() override;
const char* reducer_name() const override { return "SelectLowering"; } const char* reducer_name() const override { return "SelectLowering"; }
@ -27,10 +27,10 @@ class SelectLowering final : public Reducer {
private: private:
Reduction LowerSelect(Node* node); Reduction LowerSelect(Node* node);
GraphAssembler* gasm() const { return graph_assembler_; } JSGraphAssembler* gasm() const { return graph_assembler_; }
Node* start() const { return start_; } Node* start() const { return start_; }
GraphAssembler* graph_assembler_; JSGraphAssembler* graph_assembler_;
Node* start_; Node* start_;
}; };