Skip to content

V
V8
Commit 2a50c752 authored by adamk's avatar adamk Committed by Commit bot
Browse files
Options

Revert of [ignition] Inline the binary op TurboFan code stubs in the bytecode... 

Revert of [ignition] Inline the binary op TurboFan code stubs in the bytecode handlers. (patchset #1 id:1 of https://codereview.chromium.org/1974293002/ )

Reason for revert:
Causes cctest/test-serialize/SnapshotDataBlobWithWarmup failure on arm64:
https://build.chromium.org/p/client.v8.ports/builders/V8%20Linux%20-%20arm64%20-%20sim%20-%20debug/builds/534

Original issue's description:
> [ignition] Inline the binary op TurboFan code stubs in the bytecode handlers.
>
> Trying to reland http://crrev.com/1902823002.
>
> This time some blocks have been shuffled around in the AddStub so that the frame still doesn't get built for the fast path.
>
> Committed: https://crrev.com/567160122de0bdb78aea79a9faa0dc15a564484c
> Cr-Commit-Position: refs/heads/master@{#36251}

TBR=bmeurer@chromium.org,rmcilroy@chromium.org,epertoso@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review-Url: https://codereview.chromium.org/1978993003
Cr-Commit-Position: refs/heads/master@{#36255}
parent d33aedb7
Show whitespace changes
Inline Side-by-side
Showing with 137 additions and 217 deletions
src/code-stubs.cc
View file @ 2a50c752
......@@ -487,14 +487,13 @@ void StringLengthStub::GenerateAssembly(CodeStubAssembler* assembler) const {
assembler->Return(result);
}
// static
compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left, compiler::Node* right,
compiler::Node* context) {
void AddStub::GenerateAssembly(CodeStubAssembler* assembler) const {
typedef CodeStubAssembler::Label Label;
typedef compiler::Node Node;
typedef CodeStubAssembler::Variable Variable;
Node* context = assembler->Parameter(2);
// Shared entry for floating point addition.
Label do_fadd(assembler);
Variable var_fadd_lhs(assembler, MachineRepresentation::kFloat64),
......@@ -503,14 +502,11 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
// We might need to loop several times due to ToPrimitive, ToString and/or
// ToNumber conversions.
Variable var_lhs(assembler, MachineRepresentation::kTagged),
var_rhs(assembler, MachineRepresentation::kTagged),
var_result(assembler, MachineRepresentation::kTagged);
var_rhs(assembler, MachineRepresentation::kTagged);
Variable* loop_vars[2] = {&var_lhs, &var_rhs};
Label loop(assembler, 2, loop_vars), end(assembler),
string_add_convert_left(assembler, Label::kDeferred),
string_add_convert_right(assembler, Label::kDeferred);
var_lhs.Bind(left);
var_rhs.Bind(right);
Label loop(assembler, 2, loop_vars);
var_lhs.Bind(assembler->Parameter(0));
var_rhs.Bind(assembler->Parameter(1));
assembler->Goto(&loop);
assembler->Bind(&loop);
{
......@@ -547,8 +543,7 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
}
assembler->Bind(&if_notoverflow);
var_result.Bind(assembler->Projection(0, pair));
assembler->Goto(&end);
assembler->Return(assembler->Projection(0, pair));
}
assembler->Bind(&if_rhsisnotsmi);
......@@ -585,9 +580,11 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&if_rhsisstring);
{
var_lhs.Bind(lhs);
var_rhs.Bind(rhs);
assembler->Goto(&string_add_convert_left);
// Convert {lhs}, which is a Smi, to a String and concatenate the
// resulting string with the String {rhs}.
Callable callable = CodeFactory::StringAdd(
assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED);
assembler->TailCallStub(callable, context, lhs, rhs);
}
assembler->Bind(&if_rhsisnotstring);
......@@ -637,9 +634,11 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&if_lhsisstring);
{
var_lhs.Bind(lhs);
var_rhs.Bind(rhs);
assembler->Goto(&string_add_convert_right);
// Convert {rhs} to a String (using the sequence of ToPrimitive with
// no hint followed by ToString) and concatenate the strings.
Callable callable = CodeFactory::StringAdd(
assembler->isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED);
assembler->TailCallStub(callable, context, lhs, rhs);
}
assembler->Bind(&if_lhsisnotstring);
......@@ -713,9 +712,11 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&if_rhsisstring);
{
var_lhs.Bind(lhs);
var_rhs.Bind(rhs);
assembler->Goto(&string_add_convert_left);
// Convert {lhs} to a String (using the sequence of ToPrimitive with
// no hint followed by ToString) and concatenate the strings.
Callable callable = CodeFactory::StringAdd(
assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED);
assembler->TailCallStub(callable, context, lhs, rhs);
}
assembler->Bind(&if_rhsisnotstring);
......@@ -831,27 +832,6 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
}
}
}
assembler->Bind(&string_add_convert_left);
{
// Convert {lhs}, which is a Smi, to a String and concatenate the
// resulting string with the String {rhs}.
Callable callable = CodeFactory::StringAdd(
assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED);
var_result.Bind(assembler->CallStub(callable, context, var_lhs.value(),
var_rhs.value()));
assembler->Goto(&end);
}
assembler->Bind(&string_add_convert_right);
{
// Convert {lhs}, which is a Smi, to a String and concatenate the
// resulting string with the String {rhs}.
Callable callable = CodeFactory::StringAdd(
assembler->isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED);
var_result.Bind(assembler->CallStub(callable, context, var_lhs.value(),
var_rhs.value()));
assembler->Goto(&end);
}
assembler->Bind(&do_fadd);
{
......@@ -859,36 +839,30 @@ compiler::Node* AddStub::Generate(CodeStubAssembler* assembler,
Node* rhs_value = var_fadd_rhs.value();
Node* value = assembler->Float64Add(lhs_value, rhs_value);
Node* result = assembler->ChangeFloat64ToTagged(value);
var_result.Bind(result);
assembler->Goto(&end);
assembler->Return(result);
}
assembler->Bind(&end);
return var_result.value();
}
// static
compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void SubtractStub::GenerateAssembly(CodeStubAssembler* assembler) const {
typedef CodeStubAssembler::Label Label;
typedef compiler::Node Node;
typedef CodeStubAssembler::Variable Variable;
Node* context = assembler->Parameter(2);
// Shared entry for floating point subtraction.
Label do_fsub(assembler), end(assembler);
Label do_fsub(assembler);
Variable var_fsub_lhs(assembler, MachineRepresentation::kFloat64),
var_fsub_rhs(assembler, MachineRepresentation::kFloat64);
// We might need to loop several times due to ToPrimitive and/or ToNumber
// conversions.
Variable var_lhs(assembler, MachineRepresentation::kTagged),
var_rhs(assembler, MachineRepresentation::kTagged),
var_result(assembler, MachineRepresentation::kTagged);
var_rhs(assembler, MachineRepresentation::kTagged);
Variable* loop_vars[2] = {&var_lhs, &var_rhs};
Label loop(assembler, 2, loop_vars);
var_lhs.Bind(left);
var_rhs.Bind(right);
var_lhs.Bind(assembler->Parameter(0));
var_rhs.Bind(assembler->Parameter(1));
assembler->Goto(&loop);
assembler->Bind(&loop);
{
......@@ -926,8 +900,7 @@ compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
}
assembler->Bind(&if_notoverflow);
var_result.Bind(assembler->Projection(0, pair));
assembler->Goto(&end);
assembler->Return(assembler->Projection(0, pair));
}
assembler->Bind(&if_rhsisnotsmi);
......@@ -953,8 +926,7 @@ compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&if_rhsisnotnumber);
{
// Convert the {rhs} to a Number first.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_rhs.Bind(assembler->CallStub(callable, context, rhs));
assembler->Goto(&loop);
}
......@@ -1010,8 +982,7 @@ compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&if_rhsisnotnumber);
{
// Convert the {rhs} to a Number first.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_rhs.Bind(assembler->CallStub(callable, context, rhs));
assembler->Goto(&loop);
}
......@@ -1021,8 +992,7 @@ compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&if_lhsisnotnumber);
{
// Convert the {lhs} to a Number first.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_lhs.Bind(assembler->CallStub(callable, context, lhs));
assembler->Goto(&loop);
}
......@@ -1034,22 +1004,18 @@ compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
Node* lhs_value = var_fsub_lhs.value();
Node* rhs_value = var_fsub_rhs.value();
Node* value = assembler->Float64Sub(lhs_value, rhs_value);
var_result.Bind(assembler->ChangeFloat64ToTagged(value));
assembler->Goto(&end);
Node* result = assembler->ChangeFloat64ToTagged(value);
assembler->Return(result);
}
assembler->Bind(&end);
return var_result.value();
}
// static
compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void MultiplyStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
typedef CodeStubAssembler::Label Label;
typedef CodeStubAssembler::Variable Variable;
Node* context = assembler->Parameter(2);
// Shared entry point for floating point multiplication.
Label do_fmul(assembler);
Variable var_lhs_float64(assembler, MachineRepresentation::kFloat64),
......@@ -1062,8 +1028,8 @@ compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
var_rhs(assembler, MachineRepresentation::kTagged);
Variable* loop_variables[] = {&var_lhs, &var_rhs};
Label loop(assembler, 2, loop_variables);
var_lhs.Bind(left);
var_rhs.Bind(right);
var_lhs.Bind(assembler->Parameter(0));
var_rhs.Bind(assembler->Parameter(1));
assembler->Goto(&loop);
assembler->Bind(&loop);
{
......@@ -1173,8 +1139,7 @@ compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&lhs_is_not_number);
{
// Convert {lhs} to a Number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_lhs.Bind(assembler->CallStub(callable, context, lhs));
assembler->Goto(&loop);
}
......@@ -1186,21 +1151,19 @@ compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
Node* value =
assembler->Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
Node* result = assembler->ChangeFloat64ToTagged(value);
return result;
assembler->Return(result);
}
}
// static
compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void DivideStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
typedef CodeStubAssembler::Label Label;
typedef CodeStubAssembler::Variable Variable;
Node* context = assembler->Parameter(2);
// Shared entry point for floating point division.
Label do_fdiv(assembler), end(assembler);
Label do_fdiv(assembler);
Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64),
var_divisor_float64(assembler, MachineRepresentation::kFloat64);
......@@ -1208,12 +1171,11 @@ compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
// We might need to loop one or two times due to ToNumber conversions.
Variable var_dividend(assembler, MachineRepresentation::kTagged),
var_divisor(assembler, MachineRepresentation::kTagged),
var_result(assembler, MachineRepresentation::kTagged);
var_divisor(assembler, MachineRepresentation::kTagged);
Variable* loop_variables[] = {&var_dividend, &var_divisor};
Label loop(assembler, 2, loop_variables);
var_dividend.Bind(left);
var_divisor.Bind(right);
var_dividend.Bind(assembler->Parameter(0));
var_divisor.Bind(assembler->Parameter(1));
assembler->Goto(&loop);
assembler->Bind(&loop);
{
......@@ -1287,8 +1249,7 @@ compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
// Do floating point division if the remainder is not 0.
assembler->GotoIf(
assembler->Word32NotEqual(untagged_dividend, truncated), &bailout);
var_result.Bind(assembler->SmiTag(untagged_result));
assembler->Goto(&end);
assembler->Return(assembler->SmiTag(untagged_result));
// Bailout: convert {dividend} and {divisor} to double and do double
// division.
......@@ -1322,8 +1283,7 @@ compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&divisor_is_not_number);
{
// Convert {divisor} to a number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_divisor.Bind(assembler->CallStub(callable, context, divisor));
assembler->Goto(&loop);
}
......@@ -1378,8 +1338,7 @@ compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&divisor_is_not_number);
{
// Convert {divisor} to a number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_divisor.Bind(assembler->CallStub(callable, context, divisor));
assembler->Goto(&loop);
}
......@@ -1389,8 +1348,7 @@ compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&dividend_is_not_number);
{
// Convert {dividend} to a Number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_dividend.Bind(assembler->CallStub(callable, context, dividend));
assembler->Goto(&loop);
}
......@@ -1401,22 +1359,31 @@ compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler,
{
Node* value = assembler->Float64Div(var_dividend_float64.value(),
var_divisor_float64.value());
var_result.Bind(assembler->ChangeFloat64ToTagged(value));
assembler->Goto(&end);
Node* result = assembler->ChangeFloat64ToTagged(value);
assembler->Return(result);
}
assembler->Bind(&end);
return var_result.value();
}
// static
compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void BitwiseAndStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
Node* lhs = assembler->Parameter(0);
Node* rhs = assembler->Parameter(1);
Node* context = assembler->Parameter(2);
Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
Node* value = assembler->Word32And(lhs_value, rhs_value);
Node* result = assembler->ChangeInt32ToTagged(value);
assembler->Return(result);
}
void ModulusStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
typedef CodeStubAssembler::Label Label;
typedef CodeStubAssembler::Variable Variable;
Node* context = assembler->Parameter(2);
// Shared entry point for floating point modulus.
Label do_fmod(assembler);
Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64),
......@@ -1429,8 +1396,8 @@ compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
var_divisor(assembler, MachineRepresentation::kTagged);
Variable* loop_variables[] = {&var_dividend, &var_divisor};
Label loop(assembler, 2, loop_variables);
var_dividend.Bind(left);
var_divisor.Bind(right);
var_dividend.Bind(assembler->Parameter(0));
var_divisor.Bind(assembler->Parameter(1));
assembler->Goto(&loop);
assembler->Bind(&loop);
{
......@@ -1477,8 +1444,7 @@ compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&divisor_is_not_number);
{
// Convert {divisor} to a number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_divisor.Bind(assembler->CallStub(callable, context, divisor));
assembler->Goto(&loop);
}
......@@ -1533,8 +1499,7 @@ compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&divisor_is_not_number);
{
// Convert {divisor} to a number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_divisor.Bind(assembler->CallStub(callable, context, divisor));
assembler->Goto(&loop);
}
......@@ -1544,8 +1509,7 @@ compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
assembler->Bind(&dividend_is_not_number);
{
// Convert {dividend} to a Number and loop.
Callable callable =
CodeFactory::NonNumberToNumber(assembler->isolate());
Callable callable = CodeFactory::NonNumberToNumber(isolate());
var_dividend.Bind(assembler->CallStub(callable, context, dividend));
assembler->Goto(&loop);
}
......@@ -1557,98 +1521,80 @@ compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler,
Node* value = assembler->Float64Mod(var_dividend_float64.value(),
var_divisor_float64.value());
Node* result = assembler->ChangeFloat64ToTagged(value);
return result;
assembler->Return(result);
}
}
// static
compiler::Node* ShiftLeftStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void ShiftLeftStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
Node* lhs = assembler->Parameter(0);
Node* rhs = assembler->Parameter(1);
Node* context = assembler->Parameter(2);
Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
Node* shift_count =
assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
Node* value = assembler->Word32Shl(lhs_value, shift_count);
Node* result = assembler->ChangeInt32ToTagged(value);
return result;
assembler->Return(result);
}
// static
compiler::Node* ShiftRightStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void ShiftRightStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
Node* lhs = assembler->Parameter(0);
Node* rhs = assembler->Parameter(1);
Node* context = assembler->Parameter(2);
Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
Node* shift_count =
assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
Node* value = assembler->Word32Sar(lhs_value, shift_count);
Node* result = assembler->ChangeInt32ToTagged(value);
return result;
assembler->Return(result);
}
// static
compiler::Node* ShiftRightLogicalStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void ShiftRightLogicalStub::GenerateAssembly(
CodeStubAssembler* assembler) const {
using compiler::Node;
Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
Node* lhs = assembler->Parameter(0);
Node* rhs = assembler->Parameter(1);
Node* context = assembler->Parameter(2);
Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
Node* shift_count =
assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
Node* value = assembler->Word32Shr(lhs_value, shift_count);
Node* result = assembler->ChangeUint32ToTagged(value);
return result;
}
// static
compiler::Node* BitwiseAndStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
using compiler::Node;
Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
Node* value = assembler->Word32And(lhs_value, rhs_value);
Node* result = assembler->ChangeInt32ToTagged(value);
return result;
assembler->Return(result);
}
// static
compiler::Node* BitwiseOrStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void BitwiseOrStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
Node* lhs = assembler->Parameter(0);
Node* rhs = assembler->Parameter(1);
Node* context = assembler->Parameter(2);
Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
Node* value = assembler->Word32Or(lhs_value, rhs_value);
Node* result = assembler->ChangeInt32ToTagged(value);
return result;
assembler->Return(result);
}
// static
compiler::Node* BitwiseXorStub::Generate(CodeStubAssembler* assembler,
compiler::Node* left,
compiler::Node* right,
compiler::Node* context) {
void BitwiseXorStub::GenerateAssembly(CodeStubAssembler* assembler) const {
using compiler::Node;
Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
Node* lhs = assembler->Parameter(0);
Node* rhs = assembler->Parameter(1);
Node* context = assembler->Parameter(2);
Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs);
Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs);
Node* value = assembler->Word32Xor(lhs_value, rhs_value);
Node* result = assembler->ChangeInt32ToTagged(value);
return result;
assembler->Return(result);
}
void IncStub::GenerateAssembly(CodeStubAssembler* assembler) const {
......
src/code-stubs.h
View file @ 2a50c752
......@@ -402,18 +402,6 @@ class CodeStub BASE_EMBEDDED {
void GenerateAssembly(CodeStubAssembler* assembler) const override; \
DEFINE_CODE_STUB(NAME, SUPER)
#define DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(NAME, SUPER) \
public: \
static compiler::Node* Generate(CodeStubAssembler* assembler, \
compiler::Node* left, compiler::Node* right, \
compiler::Node* context); \
void GenerateAssembly(CodeStubAssembler* assembler) const override { \
assembler->Return(Generate(assembler, assembler->Parameter(0), \
assembler->Parameter(1), \
assembler->Parameter(2))); \
} \
DEFINE_CODE_STUB(NAME, SUPER)
#define DEFINE_HANDLER_CODE_STUB(NAME, SUPER) \
public: \
Handle<Code> GenerateCode() override; \
......@@ -693,7 +681,7 @@ class AddStub final : public TurboFanCodeStub {
explicit AddStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(Add, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(Add, TurboFanCodeStub);
};
class SubtractStub final : public TurboFanCodeStub {
......@@ -701,7 +689,7 @@ class SubtractStub final : public TurboFanCodeStub {
explicit SubtractStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(Subtract, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(Subtract, TurboFanCodeStub);
};
class MultiplyStub final : public TurboFanCodeStub {
......@@ -709,7 +697,7 @@ class MultiplyStub final : public TurboFanCodeStub {
explicit MultiplyStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(Multiply, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(Multiply, TurboFanCodeStub);
};
class DivideStub final : public TurboFanCodeStub {
......@@ -717,7 +705,7 @@ class DivideStub final : public TurboFanCodeStub {
explicit DivideStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(Divide, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(Divide, TurboFanCodeStub);
};
class ModulusStub final : public TurboFanCodeStub {
......@@ -725,7 +713,7 @@ class ModulusStub final : public TurboFanCodeStub {
explicit ModulusStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(Modulus, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(Modulus, TurboFanCodeStub);
};
class ShiftRightStub final : public TurboFanCodeStub {
......@@ -733,7 +721,7 @@ class ShiftRightStub final : public TurboFanCodeStub {
explicit ShiftRightStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(ShiftRight, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(ShiftRight, TurboFanCodeStub);
};
class ShiftRightLogicalStub final : public TurboFanCodeStub {
......@@ -742,7 +730,7 @@ class ShiftRightLogicalStub final : public TurboFanCodeStub {
: TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(ShiftRightLogical, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(ShiftRightLogical, TurboFanCodeStub);
};
class ShiftLeftStub final : public TurboFanCodeStub {
......@@ -750,7 +738,7 @@ class ShiftLeftStub final : public TurboFanCodeStub {
explicit ShiftLeftStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(ShiftLeft, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(ShiftLeft, TurboFanCodeStub);
};
class BitwiseAndStub final : public TurboFanCodeStub {
......@@ -758,7 +746,7 @@ class BitwiseAndStub final : public TurboFanCodeStub {
explicit BitwiseAndStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(BitwiseAnd, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(BitwiseAnd, TurboFanCodeStub);
};
class BitwiseOrStub final : public TurboFanCodeStub {
......@@ -766,7 +754,7 @@ class BitwiseOrStub final : public TurboFanCodeStub {
explicit BitwiseOrStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(BitwiseOr, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(BitwiseOr, TurboFanCodeStub);
};
class BitwiseXorStub final : public TurboFanCodeStub {
......@@ -774,7 +762,7 @@ class BitwiseXorStub final : public TurboFanCodeStub {
explicit BitwiseXorStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(BitwiseXor, TurboFanCodeStub);
DEFINE_TURBOFAN_CODE_STUB(BitwiseXor, TurboFanCodeStub);
};
class IncStub final : public TurboFanCodeStub {
......
src/interpreter/interpreter.cc
View file @ 2a50c752
......@@ -729,22 +729,12 @@ void Interpreter::DoBinaryOp(Runtime::FunctionId function_id,
__ Dispatch();
}
template <class Generator>
void Interpreter::DoBinaryOp(InterpreterAssembler* assembler) {
Node* reg_index = __ BytecodeOperandReg(0);
Node* lhs = __ LoadRegister(reg_index);
Node* rhs = __ GetAccumulator();
Node* context = __ GetContext();
Node* result = Generator::Generate(assembler, lhs, rhs, context);
__ SetAccumulator(result);
__ Dispatch();
}
// Add <src>
//
// Add register <src> to accumulator.
void Interpreter::DoAdd(InterpreterAssembler* assembler) {
DoBinaryOp<AddStub>(assembler);
DoBinaryOp(CodeFactory::Add(isolate_), assembler);
}
......@@ -752,7 +742,7 @@ void Interpreter::DoAdd(InterpreterAssembler* assembler) {
//
// Subtract register <src> from accumulator.
void Interpreter::DoSub(InterpreterAssembler* assembler) {
DoBinaryOp<SubtractStub>(assembler);
DoBinaryOp(CodeFactory::Subtract(isolate_), assembler);
}
......@@ -760,7 +750,7 @@ void Interpreter::DoSub(InterpreterAssembler* assembler) {
//
// Multiply accumulator by register <src>.
void Interpreter::DoMul(InterpreterAssembler* assembler) {
DoBinaryOp<MultiplyStub>(assembler);
DoBinaryOp(CodeFactory::Multiply(isolate_), assembler);
}
......@@ -768,7 +758,7 @@ void Interpreter::DoMul(InterpreterAssembler* assembler) {
//
// Divide register <src> by accumulator.
void Interpreter::DoDiv(InterpreterAssembler* assembler) {
DoBinaryOp<DivideStub>(assembler);
DoBinaryOp(CodeFactory::Divide(isolate_), assembler);
}
......@@ -776,7 +766,7 @@ void Interpreter::DoDiv(InterpreterAssembler* assembler) {
//
// Modulo register <src> by accumulator.
void Interpreter::DoMod(InterpreterAssembler* assembler) {
DoBinaryOp<ModulusStub>(assembler);
DoBinaryOp(CodeFactory::Modulus(isolate_), assembler);
}
......@@ -784,7 +774,7 @@ void Interpreter::DoMod(InterpreterAssembler* assembler) {
//
// BitwiseOr register <src> to accumulator.
void Interpreter::DoBitwiseOr(InterpreterAssembler* assembler) {
DoBinaryOp<BitwiseOrStub>(assembler);
DoBinaryOp(CodeFactory::BitwiseOr(isolate_), assembler);
}
......@@ -792,7 +782,7 @@ void Interpreter::DoBitwiseOr(InterpreterAssembler* assembler) {
//
// BitwiseXor register <src> to accumulator.
void Interpreter::DoBitwiseXor(InterpreterAssembler* assembler) {
DoBinaryOp<BitwiseXorStub>(assembler);
DoBinaryOp(CodeFactory::BitwiseXor(isolate_), assembler);
}
......@@ -800,7 +790,7 @@ void Interpreter::DoBitwiseXor(InterpreterAssembler* assembler) {
//
// BitwiseAnd register <src> to accumulator.
void Interpreter::DoBitwiseAnd(InterpreterAssembler* assembler) {
DoBinaryOp<BitwiseAndStub>(assembler);
DoBinaryOp(CodeFactory::BitwiseAnd(isolate_), assembler);
}
......@@ -811,7 +801,7 @@ void Interpreter::DoBitwiseAnd(InterpreterAssembler* assembler) {
// before the operation. 5 lsb bits from the accumulator are used as count
// i.e. <src> << (accumulator & 0x1F).
void Interpreter::DoShiftLeft(InterpreterAssembler* assembler) {
DoBinaryOp<ShiftLeftStub>(assembler);
DoBinaryOp(CodeFactory::ShiftLeft(isolate_), assembler);
}
......@@ -822,7 +812,7 @@ void Interpreter::DoShiftLeft(InterpreterAssembler* assembler) {
// accumulator to uint32 before the operation. 5 lsb bits from the accumulator
// are used as count i.e. <src> >> (accumulator & 0x1F).
void Interpreter::DoShiftRight(InterpreterAssembler* assembler) {
DoBinaryOp<ShiftRightStub>(assembler);
DoBinaryOp(CodeFactory::ShiftRight(isolate_), assembler);
}
......@@ -833,7 +823,7 @@ void Interpreter::DoShiftRight(InterpreterAssembler* assembler) {
// uint32 before the operation 5 lsb bits from the accumulator are used as
// count i.e. <src> << (accumulator & 0x1F).
void Interpreter::DoShiftRightLogical(InterpreterAssembler* assembler) {
DoBinaryOp<ShiftRightLogicalStub>(assembler);
DoBinaryOp(CodeFactory::ShiftRightLogical(isolate_), assembler);
}
void Interpreter::DoCountOp(Callable callable,
......
src/interpreter/interpreter.h
View file @ 2a50c752
......@@ -73,10 +73,6 @@ class Interpreter {
void DoBinaryOp(Runtime::FunctionId function_id,
InterpreterAssembler* assembler);
// Generates code to perform the binary operations via |Generator|.
template <class Generator>
void DoBinaryOp(InterpreterAssembler* assembler);
// Generates code to perform the count operations via |callable|.
void DoCountOp(Callable callable, InterpreterAssembler* assembler);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment