diff options
Diffstat (limited to 'deps/v8/src/compiler/raw-machine-assembler.h')
| -rw-r--r-- | deps/v8/src/compiler/raw-machine-assembler.h | 89 |
1 files changed, 61 insertions, 28 deletions
diff --git a/deps/v8/src/compiler/raw-machine-assembler.h b/deps/v8/src/compiler/raw-machine-assembler.h index 5c232ed1d1..a0cb7a0bfb 100644 --- a/deps/v8/src/compiler/raw-machine-assembler.h +++ b/deps/v8/src/compiler/raw-machine-assembler.h @@ -79,6 +79,9 @@ class RawMachineAssembler { Node* Int32Constant(int32_t value) { return AddNode(common()->Int32Constant(value)); } + Node* StackSlot(MachineRepresentation rep) { + return AddNode(machine()->StackSlot(rep)); + } Node* Int64Constant(int64_t value) { return AddNode(common()->Int64Constant(value)); } @@ -147,7 +150,7 @@ class RawMachineAssembler { return AddNode(machine()->WordEqual(), a, b); } Node* WordNotEqual(Node* a, Node* b) { - return WordBinaryNot(WordEqual(a, b)); + return Word32BinaryNot(WordEqual(a, b)); } Node* WordNot(Node* a) { if (machine()->Is32()) { @@ -156,13 +159,6 @@ class RawMachineAssembler { return Word64Not(a); } } - Node* WordBinaryNot(Node* a) { - if (machine()->Is32()) { - return Word32BinaryNot(a); - } else { - return Word64BinaryNot(a); - } - } Node* Word32And(Node* a, Node* b) { return AddNode(machine()->Word32And(), a, b); @@ -221,10 +217,9 @@ class RawMachineAssembler { return AddNode(machine()->Word64Equal(), a, b); } Node* Word64NotEqual(Node* a, Node* b) { - return Word64BinaryNot(Word64Equal(a, b)); + return Word32BinaryNot(Word64Equal(a, b)); } Node* Word64Not(Node* a) { return Word64Xor(a, Int64Constant(-1)); } - Node* Word64BinaryNot(Node* a) { return Word64Equal(a, Int64Constant(0)); } Node* Int32Add(Node* a, Node* b) { return AddNode(machine()->Int32Add(), a, b); @@ -275,6 +270,10 @@ class RawMachineAssembler { Node* Int32GreaterThanOrEqual(Node* a, Node* b) { return Int32LessThanOrEqual(b, a); } + Node* Uint32GreaterThan(Node* a, Node* b) { return Uint32LessThan(b, a); } + Node* Uint32GreaterThanOrEqual(Node* a, Node* b) { + return Uint32LessThanOrEqual(b, a); + } Node* Int32Neg(Node* a) { return Int32Sub(Int32Constant(0), a); } Node* Int64Add(Node* a, Node* b) { @@ -315,6 +314,10 @@ class RawMachineAssembler { Node* Int64GreaterThanOrEqual(Node* a, Node* b) { return Int64LessThanOrEqual(b, a); } + Node* Uint64GreaterThan(Node* a, Node* b) { return Uint64LessThan(b, a); } + Node* Uint64GreaterThanOrEqual(Node* a, Node* b) { + return Uint64LessThanOrEqual(b, a); + } Node* Uint64Div(Node* a, Node* b) { return AddNode(machine()->Uint64Div(), a, b); } @@ -339,6 +342,19 @@ class RawMachineAssembler { #undef INTPTR_BINOP +#define UINTPTR_BINOP(prefix, name) \ + Node* UintPtr##name(Node* a, Node* b) { \ + return kPointerSize == 8 ? prefix##64##name(a, b) \ + : prefix##32##name(a, b); \ + } + + UINTPTR_BINOP(Uint, LessThan); + UINTPTR_BINOP(Uint, LessThanOrEqual); + UINTPTR_BINOP(Uint, GreaterThanOrEqual); + UINTPTR_BINOP(Uint, GreaterThan); + +#undef UINTPTR_BINOP + Node* Float32Add(Node* a, Node* b) { return AddNode(machine()->Float32Add(), a, b); } @@ -363,7 +379,7 @@ class RawMachineAssembler { return AddNode(machine()->Float32Equal(), a, b); } Node* Float32NotEqual(Node* a, Node* b) { - return WordBinaryNot(Float32Equal(a, b)); + return Word32BinaryNot(Float32Equal(a, b)); } Node* Float32LessThan(Node* a, Node* b) { return AddNode(machine()->Float32LessThan(), a, b); @@ -403,7 +419,7 @@ class RawMachineAssembler { return AddNode(machine()->Float64Equal(), a, b); } Node* Float64NotEqual(Node* a, Node* b) { - return WordBinaryNot(Float64Equal(a, b)); + return Word32BinaryNot(Float64Equal(a, b)); } Node* Float64LessThan(Node* a, Node* b) { return AddNode(machine()->Float64LessThan(), a, b); @@ -432,10 +448,11 @@ class RawMachineAssembler { Node* ChangeFloat64ToUint32(Node* a) { return AddNode(machine()->ChangeFloat64ToUint32(), a); } - Node* TruncateFloat32ToInt64(Node* a) { - // TODO(ahaas): Remove this function as soon as it is not used anymore in - // WebAssembly. - return AddNode(machine()->TryTruncateFloat32ToInt64(), a); + Node* TruncateFloat32ToInt32(Node* a) { + return AddNode(machine()->TruncateFloat32ToInt32(), a); + } + Node* TruncateFloat32ToUint32(Node* a) { + return AddNode(machine()->TruncateFloat32ToUint32(), a); } Node* TryTruncateFloat32ToInt64(Node* a) { return AddNode(machine()->TryTruncateFloat32ToInt64(), a); @@ -448,11 +465,6 @@ class RawMachineAssembler { Node* TryTruncateFloat64ToInt64(Node* a) { return AddNode(machine()->TryTruncateFloat64ToInt64(), a); } - Node* TruncateFloat32ToUint64(Node* a) { - // TODO(ahaas): Remove this function as soon as it is not used anymore in - // WebAssembly. - return AddNode(machine()->TryTruncateFloat32ToUint64(), a); - } Node* TryTruncateFloat32ToUint64(Node* a) { return AddNode(machine()->TryTruncateFloat32ToUint64(), a); } @@ -479,12 +491,18 @@ class RawMachineAssembler { Node* TruncateInt64ToInt32(Node* a) { return AddNode(machine()->TruncateInt64ToInt32(), a); } + Node* RoundInt32ToFloat32(Node* a) { + return AddNode(machine()->RoundInt32ToFloat32(), a); + } Node* RoundInt64ToFloat32(Node* a) { return AddNode(machine()->RoundInt64ToFloat32(), a); } Node* RoundInt64ToFloat64(Node* a) { return AddNode(machine()->RoundInt64ToFloat64(), a); } + Node* RoundUint32ToFloat32(Node* a) { + return AddNode(machine()->RoundUint32ToFloat32(), a); + } Node* RoundUint64ToFloat32(Node* a) { return AddNode(machine()->RoundUint64ToFloat32(), a); } @@ -548,6 +566,9 @@ class RawMachineAssembler { // Stack operations. Node* LoadStackPointer() { return AddNode(machine()->LoadStackPointer()); } Node* LoadFramePointer() { return AddNode(machine()->LoadFramePointer()); } + Node* LoadParentFramePointer() { + return AddNode(machine()->LoadParentFramePointer()); + } // Parameters. Node* Parameter(size_t index); @@ -568,11 +589,16 @@ class RawMachineAssembler { // Call a given call descriptor and the given arguments and frame-state. Node* CallNWithFrameState(CallDescriptor* desc, Node* function, Node** args, Node* frame_state); + // Call to a runtime function with zero arguments. + Node* CallRuntime0(Runtime::FunctionId function, Node* context); // Call to a runtime function with one arguments. Node* CallRuntime1(Runtime::FunctionId function, Node* arg0, Node* context); // Call to a runtime function with two arguments. Node* CallRuntime2(Runtime::FunctionId function, Node* arg1, Node* arg2, Node* context); + // Call to a runtime function with three arguments. + Node* CallRuntime3(Runtime::FunctionId function, Node* arg1, Node* arg2, + Node* arg3, Node* context); // Call to a runtime function with four arguments. Node* CallRuntime4(Runtime::FunctionId function, Node* arg1, Node* arg2, Node* arg3, Node* arg4, Node* context); @@ -602,7 +628,12 @@ class RawMachineAssembler { // Tail call to a runtime function with two arguments. Node* TailCallRuntime2(Runtime::FunctionId function, Node* arg1, Node* arg2, Node* context); - + // Tail call to a runtime function with three arguments. + Node* TailCallRuntime3(Runtime::FunctionId function, Node* arg1, Node* arg2, + Node* arg3, Node* context); + // Tail call to a runtime function with four arguments. + Node* TailCallRuntime4(Runtime::FunctionId function, Node* arg1, Node* arg2, + Node* arg3, Node* arg4, Node* context); // =========================================================================== // The following utility methods deal with control flow, hence might switch @@ -622,24 +653,26 @@ class RawMachineAssembler { // Variables. Node* Phi(MachineRepresentation rep, Node* n1, Node* n2) { - return AddNode(common()->Phi(rep, 2), n1, n2); + return AddNode(common()->Phi(rep, 2), n1, n2, graph()->start()); } Node* Phi(MachineRepresentation rep, Node* n1, Node* n2, Node* n3) { - return AddNode(common()->Phi(rep, 3), n1, n2, n3); + return AddNode(common()->Phi(rep, 3), n1, n2, n3, graph()->start()); } Node* Phi(MachineRepresentation rep, Node* n1, Node* n2, Node* n3, Node* n4) { - return AddNode(common()->Phi(rep, 4), n1, n2, n3, n4); + return AddNode(common()->Phi(rep, 4), n1, n2, n3, n4, graph()->start()); } + Node* Phi(MachineRepresentation rep, int input_count, Node* const* inputs); + void AppendPhiInput(Node* phi, Node* new_input); // =========================================================================== // The following generic node creation methods can be used for operators that // are not covered by the above utility methods. There should rarely be a need // to do that outside of testing though. - Node* AddNode(const Operator* op, int input_count, Node** inputs); + Node* AddNode(const Operator* op, int input_count, Node* const* inputs); Node* AddNode(const Operator* op) { - return AddNode(op, 0, static_cast<Node**>(nullptr)); + return AddNode(op, 0, static_cast<Node* const*>(nullptr)); } template <class... TArgs> @@ -649,7 +682,7 @@ class RawMachineAssembler { } private: - Node* MakeNode(const Operator* op, int input_count, Node** inputs); + Node* MakeNode(const Operator* op, int input_count, Node* const* inputs); BasicBlock* Use(RawMachineLabel* label); BasicBlock* EnsureBlock(RawMachineLabel* label); BasicBlock* CurrentBlock(); |