| Index: src/builtins/builtins-number.cc
|
| diff --git a/src/builtins/builtins-number.cc b/src/builtins/builtins-number.cc
|
| index a63066cfbd7857b42cdf99db8d646f68feae2b6b..457ef0857ff2d5efa44fe208f48e2616a0a3f24f 100644
|
| --- a/src/builtins/builtins-number.cc
|
| +++ b/src/builtins/builtins-number.cc
|
| @@ -5,255 +5,251 @@
|
| #include "src/builtins/builtins-utils.h"
|
| #include "src/builtins/builtins.h"
|
| #include "src/code-factory.h"
|
| +#include "src/code-stub-assembler.h"
|
|
|
| namespace v8 {
|
| namespace internal {
|
|
|
| +class NumberBuiltinsAssembler : public CodeStubAssembler {
|
| + public:
|
| + explicit NumberBuiltinsAssembler(compiler::CodeAssemblerState* state)
|
| + : CodeStubAssembler(state) {}
|
| +
|
| + protected:
|
| + template <Signedness signed_result = kSigned>
|
| + void BitwiseOp(std::function<Node*(Node* lhs, Node* rhs)> body) {
|
| + Node* left = Parameter(0);
|
| + Node* right = Parameter(1);
|
| + Node* context = Parameter(2);
|
| +
|
| + Node* lhs_value = TruncateTaggedToWord32(context, left);
|
| + Node* rhs_value = TruncateTaggedToWord32(context, right);
|
| + Node* value = body(lhs_value, rhs_value);
|
| + Node* result = signed_result == kSigned ? ChangeInt32ToTagged(value)
|
| + : ChangeUint32ToTagged(value);
|
| + Return(result);
|
| + }
|
| +
|
| + template <Signedness signed_result = kSigned>
|
| + void BitwiseShiftOp(std::function<Node*(Node* lhs, Node* shift_count)> body) {
|
| + BitwiseOp<signed_result>([this, body](Node* lhs, Node* rhs) {
|
| + Node* shift_count = Word32And(rhs, Int32Constant(0x1f));
|
| + return body(lhs, shift_count);
|
| + });
|
| + }
|
| +
|
| + void RelationalComparisonBuiltin(RelationalComparisonMode mode) {
|
| + Node* lhs = Parameter(0);
|
| + Node* rhs = Parameter(1);
|
| + Node* context = Parameter(2);
|
| +
|
| + Return(RelationalComparison(mode, lhs, rhs, context));
|
| + }
|
| +};
|
| +
|
| // -----------------------------------------------------------------------------
|
| // ES6 section 20.1 Number Objects
|
|
|
| // ES6 section 20.1.2.2 Number.isFinite ( number )
|
| -void Builtins::Generate_NumberIsFinite(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* number = assembler.Parameter(1);
|
| +TF_BUILTIN(NumberIsFinite, CodeStubAssembler) {
|
| + Node* number = Parameter(1);
|
|
|
| - Label return_true(&assembler), return_false(&assembler);
|
| + Label return_true(this), return_false(this);
|
|
|
| // Check if {number} is a Smi.
|
| - assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
|
| + GotoIf(TaggedIsSmi(number), &return_true);
|
|
|
| // Check if {number} is a HeapNumber.
|
| - assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
|
| - assembler.HeapNumberMapConstant()),
|
| - &return_false);
|
| + GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false);
|
|
|
| // Check if {number} contains a finite, non-NaN value.
|
| - Node* number_value = assembler.LoadHeapNumberValue(number);
|
| - assembler.BranchIfFloat64IsNaN(
|
| - assembler.Float64Sub(number_value, number_value), &return_false,
|
| - &return_true);
|
| + Node* number_value = LoadHeapNumberValue(number);
|
| + BranchIfFloat64IsNaN(Float64Sub(number_value, number_value), &return_false,
|
| + &return_true);
|
|
|
| - assembler.Bind(&return_true);
|
| - assembler.Return(assembler.BooleanConstant(true));
|
| + Bind(&return_true);
|
| + Return(BooleanConstant(true));
|
|
|
| - assembler.Bind(&return_false);
|
| - assembler.Return(assembler.BooleanConstant(false));
|
| + Bind(&return_false);
|
| + Return(BooleanConstant(false));
|
| }
|
|
|
| // ES6 section 20.1.2.3 Number.isInteger ( number )
|
| -void Builtins::Generate_NumberIsInteger(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - CodeStubAssembler assembler(state);
|
| +TF_BUILTIN(NumberIsInteger, CodeStubAssembler) {
|
| + Node* number = Parameter(1);
|
|
|
| - Node* number = assembler.Parameter(1);
|
| -
|
| - Label return_true(&assembler), return_false(&assembler);
|
| + Label return_true(this), return_false(this);
|
|
|
| // Check if {number} is a Smi.
|
| - assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
|
| + GotoIf(TaggedIsSmi(number), &return_true);
|
|
|
| // Check if {number} is a HeapNumber.
|
| - assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
|
| - assembler.HeapNumberMapConstant()),
|
| - &return_false);
|
| + GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false);
|
|
|
| // Load the actual value of {number}.
|
| - Node* number_value = assembler.LoadHeapNumberValue(number);
|
| + Node* number_value = LoadHeapNumberValue(number);
|
|
|
| // Truncate the value of {number} to an integer (or an infinity).
|
| - Node* integer = assembler.Float64Trunc(number_value);
|
| + Node* integer = Float64Trunc(number_value);
|
|
|
| // Check if {number}s value matches the integer (ruling out the infinities).
|
| - assembler.Branch(
|
| - assembler.Float64Equal(assembler.Float64Sub(number_value, integer),
|
| - assembler.Float64Constant(0.0)),
|
| - &return_true, &return_false);
|
| + Branch(Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
|
| + &return_true, &return_false);
|
|
|
| - assembler.Bind(&return_true);
|
| - assembler.Return(assembler.BooleanConstant(true));
|
| + Bind(&return_true);
|
| + Return(BooleanConstant(true));
|
|
|
| - assembler.Bind(&return_false);
|
| - assembler.Return(assembler.BooleanConstant(false));
|
| + Bind(&return_false);
|
| + Return(BooleanConstant(false));
|
| }
|
|
|
| // ES6 section 20.1.2.4 Number.isNaN ( number )
|
| -void Builtins::Generate_NumberIsNaN(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* number = assembler.Parameter(1);
|
| +TF_BUILTIN(NumberIsNaN, CodeStubAssembler) {
|
| + Node* number = Parameter(1);
|
|
|
| - Label return_true(&assembler), return_false(&assembler);
|
| + Label return_true(this), return_false(this);
|
|
|
| // Check if {number} is a Smi.
|
| - assembler.GotoIf(assembler.TaggedIsSmi(number), &return_false);
|
| + GotoIf(TaggedIsSmi(number), &return_false);
|
|
|
| // Check if {number} is a HeapNumber.
|
| - assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
|
| - assembler.HeapNumberMapConstant()),
|
| - &return_false);
|
| + GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false);
|
|
|
| // Check if {number} contains a NaN value.
|
| - Node* number_value = assembler.LoadHeapNumberValue(number);
|
| - assembler.BranchIfFloat64IsNaN(number_value, &return_true, &return_false);
|
| + Node* number_value = LoadHeapNumberValue(number);
|
| + BranchIfFloat64IsNaN(number_value, &return_true, &return_false);
|
|
|
| - assembler.Bind(&return_true);
|
| - assembler.Return(assembler.BooleanConstant(true));
|
| + Bind(&return_true);
|
| + Return(BooleanConstant(true));
|
|
|
| - assembler.Bind(&return_false);
|
| - assembler.Return(assembler.BooleanConstant(false));
|
| + Bind(&return_false);
|
| + Return(BooleanConstant(false));
|
| }
|
|
|
| // ES6 section 20.1.2.5 Number.isSafeInteger ( number )
|
| -void Builtins::Generate_NumberIsSafeInteger(
|
| - compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - CodeStubAssembler assembler(state);
|
| +TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) {
|
| + Node* number = Parameter(1);
|
|
|
| - Node* number = assembler.Parameter(1);
|
| -
|
| - Label return_true(&assembler), return_false(&assembler);
|
| + Label return_true(this), return_false(this);
|
|
|
| // Check if {number} is a Smi.
|
| - assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
|
| + GotoIf(TaggedIsSmi(number), &return_true);
|
|
|
| // Check if {number} is a HeapNumber.
|
| - assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
|
| - assembler.HeapNumberMapConstant()),
|
| - &return_false);
|
| + GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false);
|
|
|
| // Load the actual value of {number}.
|
| - Node* number_value = assembler.LoadHeapNumberValue(number);
|
| + Node* number_value = LoadHeapNumberValue(number);
|
|
|
| // Truncate the value of {number} to an integer (or an infinity).
|
| - Node* integer = assembler.Float64Trunc(number_value);
|
| + Node* integer = Float64Trunc(number_value);
|
|
|
| // Check if {number}s value matches the integer (ruling out the infinities).
|
| - assembler.GotoUnless(
|
| - assembler.Float64Equal(assembler.Float64Sub(number_value, integer),
|
| - assembler.Float64Constant(0.0)),
|
| + GotoUnless(
|
| + Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
|
| &return_false);
|
|
|
| // Check if the {integer} value is in safe integer range.
|
| - assembler.Branch(assembler.Float64LessThanOrEqual(
|
| - assembler.Float64Abs(integer),
|
| - assembler.Float64Constant(kMaxSafeInteger)),
|
| - &return_true, &return_false);
|
| + Branch(Float64LessThanOrEqual(Float64Abs(integer),
|
| + Float64Constant(kMaxSafeInteger)),
|
| + &return_true, &return_false);
|
|
|
| - assembler.Bind(&return_true);
|
| - assembler.Return(assembler.BooleanConstant(true));
|
| + Bind(&return_true);
|
| + Return(BooleanConstant(true));
|
|
|
| - assembler.Bind(&return_false);
|
| - assembler.Return(assembler.BooleanConstant(false));
|
| + Bind(&return_false);
|
| + Return(BooleanConstant(false));
|
| }
|
|
|
| // ES6 section 20.1.2.12 Number.parseFloat ( string )
|
| -void Builtins::Generate_NumberParseFloat(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - typedef CodeStubAssembler::Variable Variable;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* context = assembler.Parameter(4);
|
| +TF_BUILTIN(NumberParseFloat, CodeStubAssembler) {
|
| + Node* context = Parameter(4);
|
|
|
| // We might need to loop once for ToString conversion.
|
| - Variable var_input(&assembler, MachineRepresentation::kTagged);
|
| - Label loop(&assembler, &var_input);
|
| - var_input.Bind(assembler.Parameter(1));
|
| - assembler.Goto(&loop);
|
| - assembler.Bind(&loop);
|
| + Variable var_input(this, MachineRepresentation::kTagged);
|
| + Label loop(this, &var_input);
|
| + var_input.Bind(Parameter(1));
|
| + Goto(&loop);
|
| + Bind(&loop);
|
| {
|
| // Load the current {input} value.
|
| Node* input = var_input.value();
|
|
|
| // Check if the {input} is a HeapObject or a Smi.
|
| - Label if_inputissmi(&assembler), if_inputisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(input), &if_inputissmi,
|
| - &if_inputisnotsmi);
|
| + Label if_inputissmi(this), if_inputisnotsmi(this);
|
| + Branch(TaggedIsSmi(input), &if_inputissmi, &if_inputisnotsmi);
|
|
|
| - assembler.Bind(&if_inputissmi);
|
| + Bind(&if_inputissmi);
|
| {
|
| // The {input} is already a Number, no need to do anything.
|
| - assembler.Return(input);
|
| + Return(input);
|
| }
|
|
|
| - assembler.Bind(&if_inputisnotsmi);
|
| + Bind(&if_inputisnotsmi);
|
| {
|
| // The {input} is a HeapObject, check if it's already a String.
|
| - Label if_inputisstring(&assembler), if_inputisnotstring(&assembler);
|
| - Node* input_map = assembler.LoadMap(input);
|
| - Node* input_instance_type = assembler.LoadMapInstanceType(input_map);
|
| - assembler.Branch(assembler.IsStringInstanceType(input_instance_type),
|
| - &if_inputisstring, &if_inputisnotstring);
|
| + Label if_inputisstring(this), if_inputisnotstring(this);
|
| + Node* input_map = LoadMap(input);
|
| + Node* input_instance_type = LoadMapInstanceType(input_map);
|
| + Branch(IsStringInstanceType(input_instance_type), &if_inputisstring,
|
| + &if_inputisnotstring);
|
|
|
| - assembler.Bind(&if_inputisstring);
|
| + Bind(&if_inputisstring);
|
| {
|
| // The {input} is already a String, check if {input} contains
|
| // a cached array index.
|
| - Label if_inputcached(&assembler), if_inputnotcached(&assembler);
|
| - Node* input_hash = assembler.LoadNameHashField(input);
|
| - Node* input_bit = assembler.Word32And(
|
| - input_hash,
|
| - assembler.Int32Constant(String::kContainsCachedArrayIndexMask));
|
| - assembler.Branch(
|
| - assembler.Word32Equal(input_bit, assembler.Int32Constant(0)),
|
| - &if_inputcached, &if_inputnotcached);
|
| -
|
| - assembler.Bind(&if_inputcached);
|
| + Label if_inputcached(this), if_inputnotcached(this);
|
| + Node* input_hash = LoadNameHashField(input);
|
| + Node* input_bit = Word32And(
|
| + input_hash, Int32Constant(String::kContainsCachedArrayIndexMask));
|
| + Branch(Word32Equal(input_bit, Int32Constant(0)), &if_inputcached,
|
| + &if_inputnotcached);
|
| +
|
| + Bind(&if_inputcached);
|
| {
|
| // Just return the {input}s cached array index.
|
| Node* input_array_index =
|
| - assembler.DecodeWordFromWord32<String::ArrayIndexValueBits>(
|
| - input_hash);
|
| - assembler.Return(assembler.SmiTag(input_array_index));
|
| + DecodeWordFromWord32<String::ArrayIndexValueBits>(input_hash);
|
| + Return(SmiTag(input_array_index));
|
| }
|
|
|
| - assembler.Bind(&if_inputnotcached);
|
| + Bind(&if_inputnotcached);
|
| {
|
| // Need to fall back to the runtime to convert {input} to double.
|
| - assembler.Return(assembler.CallRuntime(Runtime::kStringParseFloat,
|
| - context, input));
|
| + Return(CallRuntime(Runtime::kStringParseFloat, context, input));
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_inputisnotstring);
|
| + Bind(&if_inputisnotstring);
|
| {
|
| // The {input} is neither a String nor a Smi, check for HeapNumber.
|
| - Label if_inputisnumber(&assembler),
|
| - if_inputisnotnumber(&assembler, Label::kDeferred);
|
| - assembler.Branch(
|
| - assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()),
|
| - &if_inputisnumber, &if_inputisnotnumber);
|
| + Label if_inputisnumber(this),
|
| + if_inputisnotnumber(this, Label::kDeferred);
|
| + Branch(IsHeapNumberMap(input_map), &if_inputisnumber,
|
| + &if_inputisnotnumber);
|
|
|
| - assembler.Bind(&if_inputisnumber);
|
| + Bind(&if_inputisnumber);
|
| {
|
| // The {input} is already a Number, take care of -0.
|
| - Label if_inputiszero(&assembler), if_inputisnotzero(&assembler);
|
| - Node* input_value = assembler.LoadHeapNumberValue(input);
|
| - assembler.Branch(assembler.Float64Equal(
|
| - input_value, assembler.Float64Constant(0.0)),
|
| - &if_inputiszero, &if_inputisnotzero);
|
| + Label if_inputiszero(this), if_inputisnotzero(this);
|
| + Node* input_value = LoadHeapNumberValue(input);
|
| + Branch(Float64Equal(input_value, Float64Constant(0.0)),
|
| + &if_inputiszero, &if_inputisnotzero);
|
|
|
| - assembler.Bind(&if_inputiszero);
|
| - assembler.Return(assembler.SmiConstant(0));
|
| + Bind(&if_inputiszero);
|
| + Return(SmiConstant(0));
|
|
|
| - assembler.Bind(&if_inputisnotzero);
|
| - assembler.Return(input);
|
| + Bind(&if_inputisnotzero);
|
| + Return(input);
|
| }
|
|
|
| - assembler.Bind(&if_inputisnotnumber);
|
| + Bind(&if_inputisnotnumber);
|
| {
|
| // Need to convert the {input} to String first.
|
| // TODO(bmeurer): This could be more efficient if necessary.
|
| - Callable callable = CodeFactory::ToString(assembler.isolate());
|
| - var_input.Bind(assembler.CallStub(callable, context, input));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::ToString(isolate());
|
| + var_input.Bind(CallStub(callable, context, input));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
| @@ -261,99 +257,79 @@ void Builtins::Generate_NumberParseFloat(compiler::CodeAssemblerState* state) {
|
| }
|
|
|
| // ES6 section 20.1.2.13 Number.parseInt ( string, radix )
|
| -void Builtins::Generate_NumberParseInt(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* input = assembler.Parameter(1);
|
| - Node* radix = assembler.Parameter(2);
|
| - Node* context = assembler.Parameter(5);
|
| +TF_BUILTIN(NumberParseInt, CodeStubAssembler) {
|
| + Node* input = Parameter(1);
|
| + Node* radix = Parameter(2);
|
| + Node* context = Parameter(5);
|
|
|
| // Check if {radix} is treated as 10 (i.e. undefined, 0 or 10).
|
| - Label if_radix10(&assembler), if_generic(&assembler, Label::kDeferred);
|
| - assembler.GotoIf(assembler.WordEqual(radix, assembler.UndefinedConstant()),
|
| - &if_radix10);
|
| - assembler.GotoIf(
|
| - assembler.WordEqual(radix, assembler.SmiConstant(Smi::FromInt(10))),
|
| - &if_radix10);
|
| - assembler.GotoIf(
|
| - assembler.WordEqual(radix, assembler.SmiConstant(Smi::FromInt(0))),
|
| - &if_radix10);
|
| - assembler.Goto(&if_generic);
|
| -
|
| - assembler.Bind(&if_radix10);
|
| + Label if_radix10(this), if_generic(this, Label::kDeferred);
|
| + GotoIf(WordEqual(radix, UndefinedConstant()), &if_radix10);
|
| + GotoIf(WordEqual(radix, SmiConstant(Smi::FromInt(10))), &if_radix10);
|
| + GotoIf(WordEqual(radix, SmiConstant(Smi::FromInt(0))), &if_radix10);
|
| + Goto(&if_generic);
|
| +
|
| + Bind(&if_radix10);
|
| {
|
| // Check if we can avoid the ToString conversion on {input}.
|
| - Label if_inputissmi(&assembler), if_inputisheapnumber(&assembler),
|
| - if_inputisstring(&assembler);
|
| - assembler.GotoIf(assembler.TaggedIsSmi(input), &if_inputissmi);
|
| - Node* input_map = assembler.LoadMap(input);
|
| - assembler.GotoIf(
|
| - assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()),
|
| - &if_inputisheapnumber);
|
| - Node* input_instance_type = assembler.LoadMapInstanceType(input_map);
|
| - assembler.Branch(assembler.IsStringInstanceType(input_instance_type),
|
| - &if_inputisstring, &if_generic);
|
| -
|
| - assembler.Bind(&if_inputissmi);
|
| + Label if_inputissmi(this), if_inputisheapnumber(this),
|
| + if_inputisstring(this);
|
| + GotoIf(TaggedIsSmi(input), &if_inputissmi);
|
| + Node* input_map = LoadMap(input);
|
| + GotoIf(IsHeapNumberMap(input_map), &if_inputisheapnumber);
|
| + Node* input_instance_type = LoadMapInstanceType(input_map);
|
| + Branch(IsStringInstanceType(input_instance_type), &if_inputisstring,
|
| + &if_generic);
|
| +
|
| + Bind(&if_inputissmi);
|
| {
|
| // Just return the {input}.
|
| - assembler.Return(input);
|
| + Return(input);
|
| }
|
|
|
| - assembler.Bind(&if_inputisheapnumber);
|
| + Bind(&if_inputisheapnumber);
|
| {
|
| // Check if the {input} value is in Signed32 range.
|
| - Label if_inputissigned32(&assembler);
|
| - Node* input_value = assembler.LoadHeapNumberValue(input);
|
| - Node* input_value32 = assembler.TruncateFloat64ToWord32(input_value);
|
| - assembler.GotoIf(
|
| - assembler.Float64Equal(input_value,
|
| - assembler.ChangeInt32ToFloat64(input_value32)),
|
| - &if_inputissigned32);
|
| + Label if_inputissigned32(this);
|
| + Node* input_value = LoadHeapNumberValue(input);
|
| + Node* input_value32 = TruncateFloat64ToWord32(input_value);
|
| + GotoIf(Float64Equal(input_value, ChangeInt32ToFloat64(input_value32)),
|
| + &if_inputissigned32);
|
|
|
| // Check if the absolute {input} value is in the ]0.01,1e9[ range.
|
| - Node* input_value_abs = assembler.Float64Abs(input_value);
|
| + Node* input_value_abs = Float64Abs(input_value);
|
|
|
| - assembler.GotoUnless(assembler.Float64LessThan(
|
| - input_value_abs, assembler.Float64Constant(1e9)),
|
| - &if_generic);
|
| - assembler.Branch(assembler.Float64LessThan(
|
| - assembler.Float64Constant(0.01), input_value_abs),
|
| - &if_inputissigned32, &if_generic);
|
| + GotoUnless(Float64LessThan(input_value_abs, Float64Constant(1e9)),
|
| + &if_generic);
|
| + Branch(Float64LessThan(Float64Constant(0.01), input_value_abs),
|
| + &if_inputissigned32, &if_generic);
|
|
|
| // Return the truncated int32 value, and return the tagged result.
|
| - assembler.Bind(&if_inputissigned32);
|
| - Node* result = assembler.ChangeInt32ToTagged(input_value32);
|
| - assembler.Return(result);
|
| + Bind(&if_inputissigned32);
|
| + Node* result = ChangeInt32ToTagged(input_value32);
|
| + Return(result);
|
| }
|
|
|
| - assembler.Bind(&if_inputisstring);
|
| + Bind(&if_inputisstring);
|
| {
|
| // Check if the String {input} has a cached array index.
|
| - Node* input_hash = assembler.LoadNameHashField(input);
|
| - Node* input_bit = assembler.Word32And(
|
| - input_hash,
|
| - assembler.Int32Constant(String::kContainsCachedArrayIndexMask));
|
| - assembler.GotoIf(
|
| - assembler.Word32NotEqual(input_bit, assembler.Int32Constant(0)),
|
| - &if_generic);
|
| + Node* input_hash = LoadNameHashField(input);
|
| + Node* input_bit = Word32And(
|
| + input_hash, Int32Constant(String::kContainsCachedArrayIndexMask));
|
| + GotoIf(Word32NotEqual(input_bit, Int32Constant(0)), &if_generic);
|
|
|
| // Return the cached array index as result.
|
| Node* input_index =
|
| - assembler.DecodeWordFromWord32<String::ArrayIndexValueBits>(
|
| - input_hash);
|
| - Node* result = assembler.SmiTag(input_index);
|
| - assembler.Return(result);
|
| + DecodeWordFromWord32<String::ArrayIndexValueBits>(input_hash);
|
| + Node* result = SmiTag(input_index);
|
| + Return(result);
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_generic);
|
| + Bind(&if_generic);
|
| {
|
| - Node* result =
|
| - assembler.CallRuntime(Runtime::kStringParseInt, context, input, radix);
|
| - assembler.Return(result);
|
| + Node* result = CallRuntime(Runtime::kStringParseInt, context, input, radix);
|
| + Return(result);
|
| }
|
| }
|
|
|
| @@ -566,344 +542,315 @@ BUILTIN(NumberPrototypeToString) {
|
| }
|
|
|
| // ES6 section 20.1.3.7 Number.prototype.valueOf ( )
|
| -void Builtins::Generate_NumberPrototypeValueOf(
|
| - compiler::CodeAssemblerState* state) {
|
| - typedef compiler::Node Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* receiver = assembler.Parameter(0);
|
| - Node* context = assembler.Parameter(3);
|
| +TF_BUILTIN(NumberPrototypeValueOf, CodeStubAssembler) {
|
| + Node* receiver = Parameter(0);
|
| + Node* context = Parameter(3);
|
|
|
| - Node* result = assembler.ToThisValue(
|
| - context, receiver, PrimitiveType::kNumber, "Number.prototype.valueOf");
|
| - assembler.Return(result);
|
| + Node* result = ToThisValue(context, receiver, PrimitiveType::kNumber,
|
| + "Number.prototype.valueOf");
|
| + Return(result);
|
| }
|
|
|
| -// static
|
| -void Builtins::Generate_Add(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - typedef CodeStubAssembler::Variable Variable;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(Add, CodeStubAssembler) {
|
| + Node* left = Parameter(0);
|
| + Node* right = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| // Shared entry for floating point addition.
|
| - Label do_fadd(&assembler);
|
| - Variable var_fadd_lhs(&assembler, MachineRepresentation::kFloat64),
|
| - var_fadd_rhs(&assembler, MachineRepresentation::kFloat64);
|
| + Label do_fadd(this);
|
| + Variable var_fadd_lhs(this, MachineRepresentation::kFloat64),
|
| + var_fadd_rhs(this, MachineRepresentation::kFloat64);
|
|
|
| // 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);
|
| + Variable var_lhs(this, MachineRepresentation::kTagged),
|
| + var_rhs(this, MachineRepresentation::kTagged),
|
| + var_result(this, 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);
|
| + Label loop(this, 2, loop_vars), end(this),
|
| + string_add_convert_left(this, Label::kDeferred),
|
| + string_add_convert_right(this, Label::kDeferred);
|
| var_lhs.Bind(left);
|
| var_rhs.Bind(right);
|
| - assembler.Goto(&loop);
|
| - assembler.Bind(&loop);
|
| + Goto(&loop);
|
| + Bind(&loop);
|
| {
|
| // Load the current {lhs} and {rhs} values.
|
| Node* lhs = var_lhs.value();
|
| Node* rhs = var_rhs.value();
|
|
|
| // Check if the {lhs} is a Smi or a HeapObject.
|
| - Label if_lhsissmi(&assembler), if_lhsisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
|
| + Label if_lhsissmi(this), if_lhsisnotsmi(this);
|
| + Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
|
|
|
| - assembler.Bind(&if_lhsissmi);
|
| + Bind(&if_lhsissmi);
|
| {
|
| // Check if the {rhs} is also a Smi.
|
| - Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi,
|
| - &if_rhsisnotsmi);
|
| + Label if_rhsissmi(this), if_rhsisnotsmi(this);
|
| + Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
|
|
|
| - assembler.Bind(&if_rhsissmi);
|
| + Bind(&if_rhsissmi);
|
| {
|
| // Try fast Smi addition first.
|
| - Node* pair =
|
| - assembler.IntPtrAddWithOverflow(assembler.BitcastTaggedToWord(lhs),
|
| - assembler.BitcastTaggedToWord(rhs));
|
| - Node* overflow = assembler.Projection(1, pair);
|
| + Node* pair = IntPtrAddWithOverflow(BitcastTaggedToWord(lhs),
|
| + BitcastTaggedToWord(rhs));
|
| + Node* overflow = Projection(1, pair);
|
|
|
| // Check if the Smi additon overflowed.
|
| - Label if_overflow(&assembler), if_notoverflow(&assembler);
|
| - assembler.Branch(overflow, &if_overflow, &if_notoverflow);
|
| + Label if_overflow(this), if_notoverflow(this);
|
| + Branch(overflow, &if_overflow, &if_notoverflow);
|
|
|
| - assembler.Bind(&if_overflow);
|
| + Bind(&if_overflow);
|
| {
|
| - var_fadd_lhs.Bind(assembler.SmiToFloat64(lhs));
|
| - var_fadd_rhs.Bind(assembler.SmiToFloat64(rhs));
|
| - assembler.Goto(&do_fadd);
|
| + var_fadd_lhs.Bind(SmiToFloat64(lhs));
|
| + var_fadd_rhs.Bind(SmiToFloat64(rhs));
|
| + Goto(&do_fadd);
|
| }
|
|
|
| - assembler.Bind(&if_notoverflow);
|
| - var_result.Bind(
|
| - assembler.BitcastWordToTaggedSigned(assembler.Projection(0, pair)));
|
| - assembler.Goto(&end);
|
| + Bind(&if_notoverflow);
|
| + var_result.Bind(BitcastWordToTaggedSigned(Projection(0, pair)));
|
| + Goto(&end);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotsmi);
|
| + Bind(&if_rhsisnotsmi);
|
| {
|
| // Load the map of {rhs}.
|
| - Node* rhs_map = assembler.LoadMap(rhs);
|
| + Node* rhs_map = LoadMap(rhs);
|
|
|
| // Check if the {rhs} is a HeapNumber.
|
| - Label if_rhsisnumber(&assembler),
|
| - if_rhsisnotnumber(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.IsHeapNumberMap(rhs_map), &if_rhsisnumber,
|
| - &if_rhsisnotnumber);
|
| + Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred);
|
| + Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber);
|
|
|
| - assembler.Bind(&if_rhsisnumber);
|
| + Bind(&if_rhsisnumber);
|
| {
|
| - var_fadd_lhs.Bind(assembler.SmiToFloat64(lhs));
|
| - var_fadd_rhs.Bind(assembler.LoadHeapNumberValue(rhs));
|
| - assembler.Goto(&do_fadd);
|
| + var_fadd_lhs.Bind(SmiToFloat64(lhs));
|
| + var_fadd_rhs.Bind(LoadHeapNumberValue(rhs));
|
| + Goto(&do_fadd);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotnumber);
|
| + Bind(&if_rhsisnotnumber);
|
| {
|
| // Load the instance type of {rhs}.
|
| - Node* rhs_instance_type = assembler.LoadMapInstanceType(rhs_map);
|
| + Node* rhs_instance_type = LoadMapInstanceType(rhs_map);
|
|
|
| // Check if the {rhs} is a String.
|
| - Label if_rhsisstring(&assembler, Label::kDeferred),
|
| - if_rhsisnotstring(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.IsStringInstanceType(rhs_instance_type),
|
| - &if_rhsisstring, &if_rhsisnotstring);
|
| + Label if_rhsisstring(this, Label::kDeferred),
|
| + if_rhsisnotstring(this, Label::kDeferred);
|
| + Branch(IsStringInstanceType(rhs_instance_type), &if_rhsisstring,
|
| + &if_rhsisnotstring);
|
|
|
| - assembler.Bind(&if_rhsisstring);
|
| + Bind(&if_rhsisstring);
|
| {
|
| var_lhs.Bind(lhs);
|
| var_rhs.Bind(rhs);
|
| - assembler.Goto(&string_add_convert_left);
|
| + Goto(&string_add_convert_left);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotstring);
|
| + Bind(&if_rhsisnotstring);
|
| {
|
| // Check if {rhs} is a JSReceiver.
|
| - Label if_rhsisreceiver(&assembler, Label::kDeferred),
|
| - if_rhsisnotreceiver(&assembler, Label::kDeferred);
|
| - assembler.Branch(
|
| - assembler.IsJSReceiverInstanceType(rhs_instance_type),
|
| - &if_rhsisreceiver, &if_rhsisnotreceiver);
|
| + Label if_rhsisreceiver(this, Label::kDeferred),
|
| + if_rhsisnotreceiver(this, Label::kDeferred);
|
| + Branch(IsJSReceiverInstanceType(rhs_instance_type),
|
| + &if_rhsisreceiver, &if_rhsisnotreceiver);
|
|
|
| - assembler.Bind(&if_rhsisreceiver);
|
| + Bind(&if_rhsisreceiver);
|
| {
|
| // Convert {rhs} to a primitive first passing no hint.
|
| Callable callable =
|
| - CodeFactory::NonPrimitiveToPrimitive(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + CodeFactory::NonPrimitiveToPrimitive(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotreceiver);
|
| + Bind(&if_rhsisnotreceiver);
|
| {
|
| // Convert {rhs} to a Number first.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotsmi);
|
| + Bind(&if_lhsisnotsmi);
|
| {
|
| // Load the map and instance type of {lhs}.
|
| - Node* lhs_instance_type = assembler.LoadInstanceType(lhs);
|
| + Node* lhs_instance_type = LoadInstanceType(lhs);
|
|
|
| // Check if {lhs} is a String.
|
| - Label if_lhsisstring(&assembler), if_lhsisnotstring(&assembler);
|
| - assembler.Branch(assembler.IsStringInstanceType(lhs_instance_type),
|
| - &if_lhsisstring, &if_lhsisnotstring);
|
| + Label if_lhsisstring(this), if_lhsisnotstring(this);
|
| + Branch(IsStringInstanceType(lhs_instance_type), &if_lhsisstring,
|
| + &if_lhsisnotstring);
|
|
|
| - assembler.Bind(&if_lhsisstring);
|
| + Bind(&if_lhsisstring);
|
| {
|
| var_lhs.Bind(lhs);
|
| var_rhs.Bind(rhs);
|
| - assembler.Goto(&string_add_convert_right);
|
| + Goto(&string_add_convert_right);
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotstring);
|
| + Bind(&if_lhsisnotstring);
|
| {
|
| // Check if {rhs} is a Smi.
|
| - Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi,
|
| - &if_rhsisnotsmi);
|
| + Label if_rhsissmi(this), if_rhsisnotsmi(this);
|
| + Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
|
|
|
| - assembler.Bind(&if_rhsissmi);
|
| + Bind(&if_rhsissmi);
|
| {
|
| // Check if {lhs} is a Number.
|
| - Label if_lhsisnumber(&assembler),
|
| - if_lhsisnotnumber(&assembler, Label::kDeferred);
|
| - assembler.Branch(
|
| - assembler.Word32Equal(lhs_instance_type,
|
| - assembler.Int32Constant(HEAP_NUMBER_TYPE)),
|
| + Label if_lhsisnumber(this), if_lhsisnotnumber(this, Label::kDeferred);
|
| + Branch(
|
| + Word32Equal(lhs_instance_type, Int32Constant(HEAP_NUMBER_TYPE)),
|
| &if_lhsisnumber, &if_lhsisnotnumber);
|
|
|
| - assembler.Bind(&if_lhsisnumber);
|
| + Bind(&if_lhsisnumber);
|
| {
|
| // The {lhs} is a HeapNumber, the {rhs} is a Smi, just add them.
|
| - var_fadd_lhs.Bind(assembler.LoadHeapNumberValue(lhs));
|
| - var_fadd_rhs.Bind(assembler.SmiToFloat64(rhs));
|
| - assembler.Goto(&do_fadd);
|
| + var_fadd_lhs.Bind(LoadHeapNumberValue(lhs));
|
| + var_fadd_rhs.Bind(SmiToFloat64(rhs));
|
| + Goto(&do_fadd);
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotnumber);
|
| + Bind(&if_lhsisnotnumber);
|
| {
|
| // The {lhs} is neither a Number nor a String, and the {rhs} is a
|
| // Smi.
|
| - Label if_lhsisreceiver(&assembler, Label::kDeferred),
|
| - if_lhsisnotreceiver(&assembler, Label::kDeferred);
|
| - assembler.Branch(
|
| - assembler.IsJSReceiverInstanceType(lhs_instance_type),
|
| - &if_lhsisreceiver, &if_lhsisnotreceiver);
|
| + Label if_lhsisreceiver(this, Label::kDeferred),
|
| + if_lhsisnotreceiver(this, Label::kDeferred);
|
| + Branch(IsJSReceiverInstanceType(lhs_instance_type),
|
| + &if_lhsisreceiver, &if_lhsisnotreceiver);
|
|
|
| - assembler.Bind(&if_lhsisreceiver);
|
| + Bind(&if_lhsisreceiver);
|
| {
|
| // Convert {lhs} to a primitive first passing no hint.
|
| Callable callable =
|
| - CodeFactory::NonPrimitiveToPrimitive(assembler.isolate());
|
| - var_lhs.Bind(assembler.CallStub(callable, context, lhs));
|
| - assembler.Goto(&loop);
|
| + CodeFactory::NonPrimitiveToPrimitive(isolate());
|
| + var_lhs.Bind(CallStub(callable, context, lhs));
|
| + Goto(&loop);
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotreceiver);
|
| + Bind(&if_lhsisnotreceiver);
|
| {
|
| // Convert {lhs} to a Number first.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_lhs.Bind(assembler.CallStub(callable, context, lhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_lhs.Bind(CallStub(callable, context, lhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotsmi);
|
| + Bind(&if_rhsisnotsmi);
|
| {
|
| // Load the instance type of {rhs}.
|
| - Node* rhs_instance_type = assembler.LoadInstanceType(rhs);
|
| + Node* rhs_instance_type = LoadInstanceType(rhs);
|
|
|
| // Check if {rhs} is a String.
|
| - Label if_rhsisstring(&assembler), if_rhsisnotstring(&assembler);
|
| - assembler.Branch(assembler.IsStringInstanceType(rhs_instance_type),
|
| - &if_rhsisstring, &if_rhsisnotstring);
|
| + Label if_rhsisstring(this), if_rhsisnotstring(this);
|
| + Branch(IsStringInstanceType(rhs_instance_type), &if_rhsisstring,
|
| + &if_rhsisnotstring);
|
|
|
| - assembler.Bind(&if_rhsisstring);
|
| + Bind(&if_rhsisstring);
|
| {
|
| var_lhs.Bind(lhs);
|
| var_rhs.Bind(rhs);
|
| - assembler.Goto(&string_add_convert_left);
|
| + Goto(&string_add_convert_left);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotstring);
|
| + Bind(&if_rhsisnotstring);
|
| {
|
| // Check if {lhs} is a HeapNumber.
|
| - Label if_lhsisnumber(&assembler), if_lhsisnotnumber(&assembler);
|
| - assembler.Branch(assembler.Word32Equal(
|
| - lhs_instance_type,
|
| - assembler.Int32Constant(HEAP_NUMBER_TYPE)),
|
| - &if_lhsisnumber, &if_lhsisnotnumber);
|
| + Label if_lhsisnumber(this), if_lhsisnotnumber(this);
|
| + Branch(
|
| + Word32Equal(lhs_instance_type, Int32Constant(HEAP_NUMBER_TYPE)),
|
| + &if_lhsisnumber, &if_lhsisnotnumber);
|
|
|
| - assembler.Bind(&if_lhsisnumber);
|
| + Bind(&if_lhsisnumber);
|
| {
|
| // Check if {rhs} is also a HeapNumber.
|
| - Label if_rhsisnumber(&assembler),
|
| - if_rhsisnotnumber(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.Word32Equal(
|
| - rhs_instance_type,
|
| - assembler.Int32Constant(HEAP_NUMBER_TYPE)),
|
| - &if_rhsisnumber, &if_rhsisnotnumber);
|
| -
|
| - assembler.Bind(&if_rhsisnumber);
|
| + Label if_rhsisnumber(this),
|
| + if_rhsisnotnumber(this, Label::kDeferred);
|
| + Branch(Word32Equal(rhs_instance_type,
|
| + Int32Constant(HEAP_NUMBER_TYPE)),
|
| + &if_rhsisnumber, &if_rhsisnotnumber);
|
| +
|
| + Bind(&if_rhsisnumber);
|
| {
|
| // Perform a floating point addition.
|
| - var_fadd_lhs.Bind(assembler.LoadHeapNumberValue(lhs));
|
| - var_fadd_rhs.Bind(assembler.LoadHeapNumberValue(rhs));
|
| - assembler.Goto(&do_fadd);
|
| + var_fadd_lhs.Bind(LoadHeapNumberValue(lhs));
|
| + var_fadd_rhs.Bind(LoadHeapNumberValue(rhs));
|
| + Goto(&do_fadd);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotnumber);
|
| + Bind(&if_rhsisnotnumber);
|
| {
|
| // Check if {rhs} is a JSReceiver.
|
| - Label if_rhsisreceiver(&assembler, Label::kDeferred),
|
| - if_rhsisnotreceiver(&assembler, Label::kDeferred);
|
| - assembler.Branch(
|
| - assembler.IsJSReceiverInstanceType(rhs_instance_type),
|
| - &if_rhsisreceiver, &if_rhsisnotreceiver);
|
| + Label if_rhsisreceiver(this, Label::kDeferred),
|
| + if_rhsisnotreceiver(this, Label::kDeferred);
|
| + Branch(IsJSReceiverInstanceType(rhs_instance_type),
|
| + &if_rhsisreceiver, &if_rhsisnotreceiver);
|
|
|
| - assembler.Bind(&if_rhsisreceiver);
|
| + Bind(&if_rhsisreceiver);
|
| {
|
| // Convert {rhs} to a primitive first passing no hint.
|
| Callable callable =
|
| - CodeFactory::NonPrimitiveToPrimitive(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + CodeFactory::NonPrimitiveToPrimitive(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotreceiver);
|
| + Bind(&if_rhsisnotreceiver);
|
| {
|
| // Convert {rhs} to a Number first.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotnumber);
|
| + Bind(&if_lhsisnotnumber);
|
| {
|
| // Check if {lhs} is a JSReceiver.
|
| - Label if_lhsisreceiver(&assembler, Label::kDeferred),
|
| - if_lhsisnotreceiver(&assembler);
|
| - assembler.Branch(
|
| - assembler.IsJSReceiverInstanceType(lhs_instance_type),
|
| - &if_lhsisreceiver, &if_lhsisnotreceiver);
|
| + Label if_lhsisreceiver(this, Label::kDeferred),
|
| + if_lhsisnotreceiver(this);
|
| + Branch(IsJSReceiverInstanceType(lhs_instance_type),
|
| + &if_lhsisreceiver, &if_lhsisnotreceiver);
|
|
|
| - assembler.Bind(&if_lhsisreceiver);
|
| + Bind(&if_lhsisreceiver);
|
| {
|
| // Convert {lhs} to a primitive first passing no hint.
|
| Callable callable =
|
| - CodeFactory::NonPrimitiveToPrimitive(assembler.isolate());
|
| - var_lhs.Bind(assembler.CallStub(callable, context, lhs));
|
| - assembler.Goto(&loop);
|
| + CodeFactory::NonPrimitiveToPrimitive(isolate());
|
| + var_lhs.Bind(CallStub(callable, context, lhs));
|
| + Goto(&loop);
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotreceiver);
|
| + Bind(&if_lhsisnotreceiver);
|
| {
|
| // Check if {rhs} is a JSReceiver.
|
| - Label if_rhsisreceiver(&assembler, Label::kDeferred),
|
| - if_rhsisnotreceiver(&assembler, Label::kDeferred);
|
| - assembler.Branch(
|
| - assembler.IsJSReceiverInstanceType(rhs_instance_type),
|
| - &if_rhsisreceiver, &if_rhsisnotreceiver);
|
| + Label if_rhsisreceiver(this, Label::kDeferred),
|
| + if_rhsisnotreceiver(this, Label::kDeferred);
|
| + Branch(IsJSReceiverInstanceType(rhs_instance_type),
|
| + &if_rhsisreceiver, &if_rhsisnotreceiver);
|
|
|
| - assembler.Bind(&if_rhsisreceiver);
|
| + Bind(&if_rhsisreceiver);
|
| {
|
| // Convert {rhs} to a primitive first passing no hint.
|
| Callable callable =
|
| - CodeFactory::NonPrimitiveToPrimitive(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + CodeFactory::NonPrimitiveToPrimitive(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotreceiver);
|
| + Bind(&if_rhsisnotreceiver);
|
| {
|
| // Convert {lhs} to a Number first.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_lhs.Bind(assembler.CallStub(callable, context, lhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_lhs.Bind(CallStub(callable, context, lhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
| @@ -912,922 +859,767 @@ void Builtins::Generate_Add(compiler::CodeAssemblerState* state) {
|
| }
|
| }
|
| }
|
| - assembler.Bind(&string_add_convert_left);
|
| + 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);
|
| + Callable callable =
|
| + CodeFactory::StringAdd(isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED);
|
| + var_result.Bind(
|
| + CallStub(callable, context, var_lhs.value(), var_rhs.value()));
|
| + Goto(&end);
|
| }
|
|
|
| - assembler.Bind(&string_add_convert_right);
|
| + 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);
|
| + isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED);
|
| + var_result.Bind(
|
| + CallStub(callable, context, var_lhs.value(), var_rhs.value()));
|
| + Goto(&end);
|
| }
|
|
|
| - assembler.Bind(&do_fadd);
|
| + Bind(&do_fadd);
|
| {
|
| Node* lhs_value = var_fadd_lhs.value();
|
| Node* rhs_value = var_fadd_rhs.value();
|
| - Node* value = assembler.Float64Add(lhs_value, rhs_value);
|
| - Node* result = assembler.AllocateHeapNumberWithValue(value);
|
| + Node* value = Float64Add(lhs_value, rhs_value);
|
| + Node* result = AllocateHeapNumberWithValue(value);
|
| var_result.Bind(result);
|
| - assembler.Goto(&end);
|
| + Goto(&end);
|
| }
|
| - assembler.Bind(&end);
|
| - assembler.Return(var_result.value());
|
| + Bind(&end);
|
| + Return(var_result.value());
|
| }
|
|
|
| -void Builtins::Generate_Subtract(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - typedef CodeStubAssembler::Variable Variable;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(Subtract, CodeStubAssembler) {
|
| + Node* left = Parameter(0);
|
| + Node* right = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| // Shared entry for floating point subtraction.
|
| - Label do_fsub(&assembler), end(&assembler);
|
| - Variable var_fsub_lhs(&assembler, MachineRepresentation::kFloat64),
|
| - var_fsub_rhs(&assembler, MachineRepresentation::kFloat64);
|
| + Label do_fsub(this), end(this);
|
| + Variable var_fsub_lhs(this, MachineRepresentation::kFloat64),
|
| + var_fsub_rhs(this, 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);
|
| + Variable var_lhs(this, MachineRepresentation::kTagged),
|
| + var_rhs(this, MachineRepresentation::kTagged),
|
| + var_result(this, MachineRepresentation::kTagged);
|
| Variable* loop_vars[2] = {&var_lhs, &var_rhs};
|
| - Label loop(&assembler, 2, loop_vars);
|
| + Label loop(this, 2, loop_vars);
|
| var_lhs.Bind(left);
|
| var_rhs.Bind(right);
|
| - assembler.Goto(&loop);
|
| - assembler.Bind(&loop);
|
| + Goto(&loop);
|
| + Bind(&loop);
|
| {
|
| // Load the current {lhs} and {rhs} values.
|
| Node* lhs = var_lhs.value();
|
| Node* rhs = var_rhs.value();
|
|
|
| // Check if the {lhs} is a Smi or a HeapObject.
|
| - Label if_lhsissmi(&assembler), if_lhsisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
|
| + Label if_lhsissmi(this), if_lhsisnotsmi(this);
|
| + Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
|
|
|
| - assembler.Bind(&if_lhsissmi);
|
| + Bind(&if_lhsissmi);
|
| {
|
| // Check if the {rhs} is also a Smi.
|
| - Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi,
|
| - &if_rhsisnotsmi);
|
| + Label if_rhsissmi(this), if_rhsisnotsmi(this);
|
| + Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
|
|
|
| - assembler.Bind(&if_rhsissmi);
|
| + Bind(&if_rhsissmi);
|
| {
|
| // Try a fast Smi subtraction first.
|
| - Node* pair =
|
| - assembler.IntPtrSubWithOverflow(assembler.BitcastTaggedToWord(lhs),
|
| - assembler.BitcastTaggedToWord(rhs));
|
| - Node* overflow = assembler.Projection(1, pair);
|
| + Node* pair = IntPtrSubWithOverflow(BitcastTaggedToWord(lhs),
|
| + BitcastTaggedToWord(rhs));
|
| + Node* overflow = Projection(1, pair);
|
|
|
| // Check if the Smi subtraction overflowed.
|
| - Label if_overflow(&assembler), if_notoverflow(&assembler);
|
| - assembler.Branch(overflow, &if_overflow, &if_notoverflow);
|
| + Label if_overflow(this), if_notoverflow(this);
|
| + Branch(overflow, &if_overflow, &if_notoverflow);
|
|
|
| - assembler.Bind(&if_overflow);
|
| + Bind(&if_overflow);
|
| {
|
| // The result doesn't fit into Smi range.
|
| - var_fsub_lhs.Bind(assembler.SmiToFloat64(lhs));
|
| - var_fsub_rhs.Bind(assembler.SmiToFloat64(rhs));
|
| - assembler.Goto(&do_fsub);
|
| + var_fsub_lhs.Bind(SmiToFloat64(lhs));
|
| + var_fsub_rhs.Bind(SmiToFloat64(rhs));
|
| + Goto(&do_fsub);
|
| }
|
|
|
| - assembler.Bind(&if_notoverflow);
|
| - var_result.Bind(
|
| - assembler.BitcastWordToTaggedSigned(assembler.Projection(0, pair)));
|
| - assembler.Goto(&end);
|
| + Bind(&if_notoverflow);
|
| + var_result.Bind(BitcastWordToTaggedSigned(Projection(0, pair)));
|
| + Goto(&end);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotsmi);
|
| + Bind(&if_rhsisnotsmi);
|
| {
|
| // Load the map of the {rhs}.
|
| - Node* rhs_map = assembler.LoadMap(rhs);
|
| + Node* rhs_map = LoadMap(rhs);
|
|
|
| // Check if {rhs} is a HeapNumber.
|
| - Label if_rhsisnumber(&assembler),
|
| - if_rhsisnotnumber(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.IsHeapNumberMap(rhs_map), &if_rhsisnumber,
|
| - &if_rhsisnotnumber);
|
| + Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred);
|
| + Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber);
|
|
|
| - assembler.Bind(&if_rhsisnumber);
|
| + Bind(&if_rhsisnumber);
|
| {
|
| // Perform a floating point subtraction.
|
| - var_fsub_lhs.Bind(assembler.SmiToFloat64(lhs));
|
| - var_fsub_rhs.Bind(assembler.LoadHeapNumberValue(rhs));
|
| - assembler.Goto(&do_fsub);
|
| + var_fsub_lhs.Bind(SmiToFloat64(lhs));
|
| + var_fsub_rhs.Bind(LoadHeapNumberValue(rhs));
|
| + Goto(&do_fsub);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotnumber);
|
| + Bind(&if_rhsisnotnumber);
|
| {
|
| // Convert the {rhs} to a Number first.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotsmi);
|
| + Bind(&if_lhsisnotsmi);
|
| {
|
| // Load the map of the {lhs}.
|
| - Node* lhs_map = assembler.LoadMap(lhs);
|
| + Node* lhs_map = LoadMap(lhs);
|
|
|
| // Check if the {lhs} is a HeapNumber.
|
| - Label if_lhsisnumber(&assembler),
|
| - if_lhsisnotnumber(&assembler, Label::kDeferred);
|
| - Node* number_map = assembler.HeapNumberMapConstant();
|
| - assembler.Branch(assembler.WordEqual(lhs_map, number_map),
|
| - &if_lhsisnumber, &if_lhsisnotnumber);
|
| + Label if_lhsisnumber(this), if_lhsisnotnumber(this, Label::kDeferred);
|
| + Node* number_map = HeapNumberMapConstant();
|
| + Branch(WordEqual(lhs_map, number_map), &if_lhsisnumber,
|
| + &if_lhsisnotnumber);
|
|
|
| - assembler.Bind(&if_lhsisnumber);
|
| + Bind(&if_lhsisnumber);
|
| {
|
| // Check if the {rhs} is a Smi.
|
| - Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi,
|
| - &if_rhsisnotsmi);
|
| + Label if_rhsissmi(this), if_rhsisnotsmi(this);
|
| + Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
|
|
|
| - assembler.Bind(&if_rhsissmi);
|
| + Bind(&if_rhsissmi);
|
| {
|
| // Perform a floating point subtraction.
|
| - var_fsub_lhs.Bind(assembler.LoadHeapNumberValue(lhs));
|
| - var_fsub_rhs.Bind(assembler.SmiToFloat64(rhs));
|
| - assembler.Goto(&do_fsub);
|
| + var_fsub_lhs.Bind(LoadHeapNumberValue(lhs));
|
| + var_fsub_rhs.Bind(SmiToFloat64(rhs));
|
| + Goto(&do_fsub);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotsmi);
|
| + Bind(&if_rhsisnotsmi);
|
| {
|
| // Load the map of the {rhs}.
|
| - Node* rhs_map = assembler.LoadMap(rhs);
|
| + Node* rhs_map = LoadMap(rhs);
|
|
|
| // Check if the {rhs} is a HeapNumber.
|
| - Label if_rhsisnumber(&assembler),
|
| - if_rhsisnotnumber(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(rhs_map, number_map),
|
| - &if_rhsisnumber, &if_rhsisnotnumber);
|
| + Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred);
|
| + Branch(WordEqual(rhs_map, number_map), &if_rhsisnumber,
|
| + &if_rhsisnotnumber);
|
|
|
| - assembler.Bind(&if_rhsisnumber);
|
| + Bind(&if_rhsisnumber);
|
| {
|
| // Perform a floating point subtraction.
|
| - var_fsub_lhs.Bind(assembler.LoadHeapNumberValue(lhs));
|
| - var_fsub_rhs.Bind(assembler.LoadHeapNumberValue(rhs));
|
| - assembler.Goto(&do_fsub);
|
| + var_fsub_lhs.Bind(LoadHeapNumberValue(lhs));
|
| + var_fsub_rhs.Bind(LoadHeapNumberValue(rhs));
|
| + Goto(&do_fsub);
|
| }
|
|
|
| - assembler.Bind(&if_rhsisnotnumber);
|
| + Bind(&if_rhsisnotnumber);
|
| {
|
| // Convert the {rhs} to a Number first.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_rhs.Bind(assembler.CallStub(callable, context, rhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_rhs.Bind(CallStub(callable, context, rhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&if_lhsisnotnumber);
|
| + Bind(&if_lhsisnotnumber);
|
| {
|
| // Convert the {lhs} to a Number first.
|
| - Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_lhs.Bind(assembler.CallStub(callable, context, lhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_lhs.Bind(CallStub(callable, context, lhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&do_fsub);
|
| + Bind(&do_fsub);
|
| {
|
| 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.AllocateHeapNumberWithValue(value));
|
| - assembler.Goto(&end);
|
| + Node* value = Float64Sub(lhs_value, rhs_value);
|
| + var_result.Bind(AllocateHeapNumberWithValue(value));
|
| + Goto(&end);
|
| }
|
| - assembler.Bind(&end);
|
| - assembler.Return(var_result.value());
|
| + Bind(&end);
|
| + Return(var_result.value());
|
| }
|
|
|
| -void Builtins::Generate_Multiply(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - typedef CodeStubAssembler::Variable Variable;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(Multiply, CodeStubAssembler) {
|
| + Node* left = Parameter(0);
|
| + Node* right = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| // Shared entry point for floating point multiplication.
|
| - Label do_fmul(&assembler), return_result(&assembler);
|
| - Variable var_lhs_float64(&assembler, MachineRepresentation::kFloat64),
|
| - var_rhs_float64(&assembler, MachineRepresentation::kFloat64);
|
| + Label do_fmul(this), return_result(this);
|
| + Variable var_lhs_float64(this, MachineRepresentation::kFloat64),
|
| + var_rhs_float64(this, MachineRepresentation::kFloat64);
|
|
|
| - Node* number_map = assembler.HeapNumberMapConstant();
|
| + Node* number_map = HeapNumberMapConstant();
|
|
|
| // We might need to loop one or two times due to ToNumber conversions.
|
| - Variable var_lhs(&assembler, MachineRepresentation::kTagged),
|
| - var_rhs(&assembler, MachineRepresentation::kTagged),
|
| - var_result(&assembler, MachineRepresentation::kTagged);
|
| + Variable var_lhs(this, MachineRepresentation::kTagged),
|
| + var_rhs(this, MachineRepresentation::kTagged),
|
| + var_result(this, MachineRepresentation::kTagged);
|
| Variable* loop_variables[] = {&var_lhs, &var_rhs};
|
| - Label loop(&assembler, 2, loop_variables);
|
| + Label loop(this, 2, loop_variables);
|
| var_lhs.Bind(left);
|
| var_rhs.Bind(right);
|
| - assembler.Goto(&loop);
|
| - assembler.Bind(&loop);
|
| + Goto(&loop);
|
| + Bind(&loop);
|
| {
|
| Node* lhs = var_lhs.value();
|
| Node* rhs = var_rhs.value();
|
|
|
| - Label lhs_is_smi(&assembler), lhs_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi);
|
| + Label lhs_is_smi(this), lhs_is_not_smi(this);
|
| + Branch(TaggedIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi);
|
|
|
| - assembler.Bind(&lhs_is_smi);
|
| + Bind(&lhs_is_smi);
|
| {
|
| - Label rhs_is_smi(&assembler), rhs_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(rhs), &rhs_is_smi,
|
| - &rhs_is_not_smi);
|
| + Label rhs_is_smi(this), rhs_is_not_smi(this);
|
| + Branch(TaggedIsSmi(rhs), &rhs_is_smi, &rhs_is_not_smi);
|
|
|
| - assembler.Bind(&rhs_is_smi);
|
| + Bind(&rhs_is_smi);
|
| {
|
| // Both {lhs} and {rhs} are Smis. The result is not necessarily a smi,
|
| // in case of overflow.
|
| - var_result.Bind(assembler.SmiMul(lhs, rhs));
|
| - assembler.Goto(&return_result);
|
| + var_result.Bind(SmiMul(lhs, rhs));
|
| + Goto(&return_result);
|
| }
|
|
|
| - assembler.Bind(&rhs_is_not_smi);
|
| + Bind(&rhs_is_not_smi);
|
| {
|
| - Node* rhs_map = assembler.LoadMap(rhs);
|
| + Node* rhs_map = LoadMap(rhs);
|
|
|
| // Check if {rhs} is a HeapNumber.
|
| - Label rhs_is_number(&assembler),
|
| - rhs_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(rhs_map, number_map),
|
| - &rhs_is_number, &rhs_is_not_number);
|
| + Label rhs_is_number(this), rhs_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(rhs_map, number_map), &rhs_is_number,
|
| + &rhs_is_not_number);
|
|
|
| - assembler.Bind(&rhs_is_number);
|
| + Bind(&rhs_is_number);
|
| {
|
| // Convert {lhs} to a double and multiply it with the value of {rhs}.
|
| - var_lhs_float64.Bind(assembler.SmiToFloat64(lhs));
|
| - var_rhs_float64.Bind(assembler.LoadHeapNumberValue(rhs));
|
| - assembler.Goto(&do_fmul);
|
| + var_lhs_float64.Bind(SmiToFloat64(lhs));
|
| + var_rhs_float64.Bind(LoadHeapNumberValue(rhs));
|
| + Goto(&do_fmul);
|
| }
|
|
|
| - assembler.Bind(&rhs_is_not_number);
|
| + Bind(&rhs_is_not_number);
|
| {
|
| // Multiplication is commutative, swap {lhs} with {rhs} and loop.
|
| var_lhs.Bind(rhs);
|
| var_rhs.Bind(lhs);
|
| - assembler.Goto(&loop);
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&lhs_is_not_smi);
|
| + Bind(&lhs_is_not_smi);
|
| {
|
| - Node* lhs_map = assembler.LoadMap(lhs);
|
| + Node* lhs_map = LoadMap(lhs);
|
|
|
| // Check if {lhs} is a HeapNumber.
|
| - Label lhs_is_number(&assembler),
|
| - lhs_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(lhs_map, number_map), &lhs_is_number,
|
| - &lhs_is_not_number);
|
| + Label lhs_is_number(this), lhs_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(lhs_map, number_map), &lhs_is_number,
|
| + &lhs_is_not_number);
|
|
|
| - assembler.Bind(&lhs_is_number);
|
| + Bind(&lhs_is_number);
|
| {
|
| // Check if {rhs} is a Smi.
|
| - Label rhs_is_smi(&assembler), rhs_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(rhs), &rhs_is_smi,
|
| - &rhs_is_not_smi);
|
| + Label rhs_is_smi(this), rhs_is_not_smi(this);
|
| + Branch(TaggedIsSmi(rhs), &rhs_is_smi, &rhs_is_not_smi);
|
|
|
| - assembler.Bind(&rhs_is_smi);
|
| + Bind(&rhs_is_smi);
|
| {
|
| // Convert {rhs} to a double and multiply it with the value of {lhs}.
|
| - var_lhs_float64.Bind(assembler.LoadHeapNumberValue(lhs));
|
| - var_rhs_float64.Bind(assembler.SmiToFloat64(rhs));
|
| - assembler.Goto(&do_fmul);
|
| + var_lhs_float64.Bind(LoadHeapNumberValue(lhs));
|
| + var_rhs_float64.Bind(SmiToFloat64(rhs));
|
| + Goto(&do_fmul);
|
| }
|
|
|
| - assembler.Bind(&rhs_is_not_smi);
|
| + Bind(&rhs_is_not_smi);
|
| {
|
| - Node* rhs_map = assembler.LoadMap(rhs);
|
| + Node* rhs_map = LoadMap(rhs);
|
|
|
| // Check if {rhs} is a HeapNumber.
|
| - Label rhs_is_number(&assembler),
|
| - rhs_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(rhs_map, number_map),
|
| - &rhs_is_number, &rhs_is_not_number);
|
| + Label rhs_is_number(this), rhs_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(rhs_map, number_map), &rhs_is_number,
|
| + &rhs_is_not_number);
|
|
|
| - assembler.Bind(&rhs_is_number);
|
| + Bind(&rhs_is_number);
|
| {
|
| // Both {lhs} and {rhs} are HeapNumbers. Load their values and
|
| // multiply them.
|
| - var_lhs_float64.Bind(assembler.LoadHeapNumberValue(lhs));
|
| - var_rhs_float64.Bind(assembler.LoadHeapNumberValue(rhs));
|
| - assembler.Goto(&do_fmul);
|
| + var_lhs_float64.Bind(LoadHeapNumberValue(lhs));
|
| + var_rhs_float64.Bind(LoadHeapNumberValue(rhs));
|
| + Goto(&do_fmul);
|
| }
|
|
|
| - assembler.Bind(&rhs_is_not_number);
|
| + Bind(&rhs_is_not_number);
|
| {
|
| // Multiplication is commutative, swap {lhs} with {rhs} and loop.
|
| var_lhs.Bind(rhs);
|
| var_rhs.Bind(lhs);
|
| - assembler.Goto(&loop);
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&lhs_is_not_number);
|
| + Bind(&lhs_is_not_number);
|
| {
|
| // Convert {lhs} to a Number and loop.
|
| - Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_lhs.Bind(assembler.CallStub(callable, context, lhs));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_lhs.Bind(CallStub(callable, context, lhs));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&do_fmul);
|
| + Bind(&do_fmul);
|
| {
|
| - Node* value =
|
| - assembler.Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
|
| - Node* result = assembler.AllocateHeapNumberWithValue(value);
|
| + Node* value = Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
|
| + Node* result = AllocateHeapNumberWithValue(value);
|
| var_result.Bind(result);
|
| - assembler.Goto(&return_result);
|
| + Goto(&return_result);
|
| }
|
|
|
| - assembler.Bind(&return_result);
|
| - assembler.Return(var_result.value());
|
| + Bind(&return_result);
|
| + Return(var_result.value());
|
| }
|
|
|
| -void Builtins::Generate_Divide(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - typedef CodeStubAssembler::Variable Variable;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(Divide, CodeStubAssembler) {
|
| + Node* left = Parameter(0);
|
| + Node* right = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| // Shared entry point for floating point division.
|
| - Label do_fdiv(&assembler), end(&assembler);
|
| - Variable var_dividend_float64(&assembler, MachineRepresentation::kFloat64),
|
| - var_divisor_float64(&assembler, MachineRepresentation::kFloat64);
|
| + Label do_fdiv(this), end(this);
|
| + Variable var_dividend_float64(this, MachineRepresentation::kFloat64),
|
| + var_divisor_float64(this, MachineRepresentation::kFloat64);
|
|
|
| - Node* number_map = assembler.HeapNumberMapConstant();
|
| + Node* number_map = HeapNumberMapConstant();
|
|
|
| // 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);
|
| + Variable var_dividend(this, MachineRepresentation::kTagged),
|
| + var_divisor(this, MachineRepresentation::kTagged),
|
| + var_result(this, MachineRepresentation::kTagged);
|
| Variable* loop_variables[] = {&var_dividend, &var_divisor};
|
| - Label loop(&assembler, 2, loop_variables);
|
| + Label loop(this, 2, loop_variables);
|
| var_dividend.Bind(left);
|
| var_divisor.Bind(right);
|
| - assembler.Goto(&loop);
|
| - assembler.Bind(&loop);
|
| + Goto(&loop);
|
| + Bind(&loop);
|
| {
|
| Node* dividend = var_dividend.value();
|
| Node* divisor = var_divisor.value();
|
|
|
| - Label dividend_is_smi(&assembler), dividend_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(dividend), ÷nd_is_smi,
|
| - ÷nd_is_not_smi);
|
| + Label dividend_is_smi(this), dividend_is_not_smi(this);
|
| + Branch(TaggedIsSmi(dividend), ÷nd_is_smi, ÷nd_is_not_smi);
|
|
|
| - assembler.Bind(÷nd_is_smi);
|
| + Bind(÷nd_is_smi);
|
| {
|
| - Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi,
|
| - &divisor_is_not_smi);
|
| + Label divisor_is_smi(this), divisor_is_not_smi(this);
|
| + Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
|
|
|
| - assembler.Bind(&divisor_is_smi);
|
| + Bind(&divisor_is_smi);
|
| {
|
| - Label bailout(&assembler);
|
| + Label bailout(this);
|
|
|
| // Do floating point division if {divisor} is zero.
|
| - assembler.GotoIf(
|
| - assembler.WordEqual(divisor, assembler.IntPtrConstant(0)),
|
| - &bailout);
|
| + GotoIf(WordEqual(divisor, IntPtrConstant(0)), &bailout);
|
|
|
| // Do floating point division {dividend} is zero and {divisor} is
|
| // negative.
|
| - Label dividend_is_zero(&assembler), dividend_is_not_zero(&assembler);
|
| - assembler.Branch(
|
| - assembler.WordEqual(dividend, assembler.IntPtrConstant(0)),
|
| - ÷nd_is_zero, ÷nd_is_not_zero);
|
| + Label dividend_is_zero(this), dividend_is_not_zero(this);
|
| + Branch(WordEqual(dividend, IntPtrConstant(0)), ÷nd_is_zero,
|
| + ÷nd_is_not_zero);
|
|
|
| - assembler.Bind(÷nd_is_zero);
|
| + Bind(÷nd_is_zero);
|
| {
|
| - assembler.GotoIf(
|
| - assembler.IntPtrLessThan(divisor, assembler.IntPtrConstant(0)),
|
| - &bailout);
|
| - assembler.Goto(÷nd_is_not_zero);
|
| + GotoIf(IntPtrLessThan(divisor, IntPtrConstant(0)), &bailout);
|
| + Goto(÷nd_is_not_zero);
|
| }
|
| - assembler.Bind(÷nd_is_not_zero);
|
| + Bind(÷nd_is_not_zero);
|
|
|
| - Node* untagged_divisor = assembler.SmiUntag(divisor);
|
| - Node* untagged_dividend = assembler.SmiUntag(dividend);
|
| + Node* untagged_divisor = SmiUntag(divisor);
|
| + Node* untagged_dividend = SmiUntag(dividend);
|
|
|
| // Do floating point division if {dividend} is kMinInt (or kMinInt - 1
|
| // if the Smi size is 31) and {divisor} is -1.
|
| - Label divisor_is_minus_one(&assembler),
|
| - divisor_is_not_minus_one(&assembler);
|
| - assembler.Branch(assembler.Word32Equal(untagged_divisor,
|
| - assembler.Int32Constant(-1)),
|
| - &divisor_is_minus_one, &divisor_is_not_minus_one);
|
| + Label divisor_is_minus_one(this), divisor_is_not_minus_one(this);
|
| + Branch(Word32Equal(untagged_divisor, Int32Constant(-1)),
|
| + &divisor_is_minus_one, &divisor_is_not_minus_one);
|
|
|
| - assembler.Bind(&divisor_is_minus_one);
|
| + Bind(&divisor_is_minus_one);
|
| {
|
| - assembler.GotoIf(
|
| - assembler.Word32Equal(
|
| - untagged_dividend,
|
| - assembler.Int32Constant(
|
| - kSmiValueSize == 32 ? kMinInt : (kMinInt >> 1))),
|
| + GotoIf(
|
| + Word32Equal(untagged_dividend,
|
| + Int32Constant(kSmiValueSize == 32 ? kMinInt
|
| + : (kMinInt >> 1))),
|
| &bailout);
|
| - assembler.Goto(&divisor_is_not_minus_one);
|
| + Goto(&divisor_is_not_minus_one);
|
| }
|
| - assembler.Bind(&divisor_is_not_minus_one);
|
| + Bind(&divisor_is_not_minus_one);
|
|
|
| // TODO(epertoso): consider adding a machine instruction that returns
|
| // both the result and the remainder.
|
| - Node* untagged_result =
|
| - assembler.Int32Div(untagged_dividend, untagged_divisor);
|
| - Node* truncated = assembler.Int32Mul(untagged_result, untagged_divisor);
|
| + Node* untagged_result = Int32Div(untagged_dividend, untagged_divisor);
|
| + Node* truncated = Int32Mul(untagged_result, untagged_divisor);
|
| // 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);
|
| + GotoIf(Word32NotEqual(untagged_dividend, truncated), &bailout);
|
| + var_result.Bind(SmiTag(untagged_result));
|
| + Goto(&end);
|
|
|
| // Bailout: convert {dividend} and {divisor} to double and do double
|
| // division.
|
| - assembler.Bind(&bailout);
|
| + Bind(&bailout);
|
| {
|
| - var_dividend_float64.Bind(assembler.SmiToFloat64(dividend));
|
| - var_divisor_float64.Bind(assembler.SmiToFloat64(divisor));
|
| - assembler.Goto(&do_fdiv);
|
| + var_dividend_float64.Bind(SmiToFloat64(dividend));
|
| + var_divisor_float64.Bind(SmiToFloat64(divisor));
|
| + Goto(&do_fdiv);
|
| }
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_smi);
|
| + Bind(&divisor_is_not_smi);
|
| {
|
| - Node* divisor_map = assembler.LoadMap(divisor);
|
| + Node* divisor_map = LoadMap(divisor);
|
|
|
| // Check if {divisor} is a HeapNumber.
|
| - Label divisor_is_number(&assembler),
|
| - divisor_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(divisor_map, number_map),
|
| - &divisor_is_number, &divisor_is_not_number);
|
| + Label divisor_is_number(this),
|
| + divisor_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
|
| + &divisor_is_not_number);
|
|
|
| - assembler.Bind(&divisor_is_number);
|
| + Bind(&divisor_is_number);
|
| {
|
| // Convert {dividend} to a double and divide it with the value of
|
| // {divisor}.
|
| - var_dividend_float64.Bind(assembler.SmiToFloat64(dividend));
|
| - var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor));
|
| - assembler.Goto(&do_fdiv);
|
| + var_dividend_float64.Bind(SmiToFloat64(dividend));
|
| + var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
|
| + Goto(&do_fdiv);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_number);
|
| + Bind(&divisor_is_not_number);
|
| {
|
| // Convert {divisor} to a number and loop.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_divisor.Bind(assembler.CallStub(callable, context, divisor));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_divisor.Bind(CallStub(callable, context, divisor));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(÷nd_is_not_smi);
|
| + Bind(÷nd_is_not_smi);
|
| {
|
| - Node* dividend_map = assembler.LoadMap(dividend);
|
| + Node* dividend_map = LoadMap(dividend);
|
|
|
| // Check if {dividend} is a HeapNumber.
|
| - Label dividend_is_number(&assembler),
|
| - dividend_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(dividend_map, number_map),
|
| - ÷nd_is_number, ÷nd_is_not_number);
|
| + Label dividend_is_number(this),
|
| + dividend_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(dividend_map, number_map), ÷nd_is_number,
|
| + ÷nd_is_not_number);
|
|
|
| - assembler.Bind(÷nd_is_number);
|
| + Bind(÷nd_is_number);
|
| {
|
| // Check if {divisor} is a Smi.
|
| - Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi,
|
| - &divisor_is_not_smi);
|
| + Label divisor_is_smi(this), divisor_is_not_smi(this);
|
| + Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
|
|
|
| - assembler.Bind(&divisor_is_smi);
|
| + Bind(&divisor_is_smi);
|
| {
|
| // Convert {divisor} to a double and use it for a floating point
|
| // division.
|
| - var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend));
|
| - var_divisor_float64.Bind(assembler.SmiToFloat64(divisor));
|
| - assembler.Goto(&do_fdiv);
|
| + var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
|
| + var_divisor_float64.Bind(SmiToFloat64(divisor));
|
| + Goto(&do_fdiv);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_smi);
|
| + Bind(&divisor_is_not_smi);
|
| {
|
| - Node* divisor_map = assembler.LoadMap(divisor);
|
| + Node* divisor_map = LoadMap(divisor);
|
|
|
| // Check if {divisor} is a HeapNumber.
|
| - Label divisor_is_number(&assembler),
|
| - divisor_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(divisor_map, number_map),
|
| - &divisor_is_number, &divisor_is_not_number);
|
| + Label divisor_is_number(this),
|
| + divisor_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
|
| + &divisor_is_not_number);
|
|
|
| - assembler.Bind(&divisor_is_number);
|
| + Bind(&divisor_is_number);
|
| {
|
| // Both {dividend} and {divisor} are HeapNumbers. Load their values
|
| // and divide them.
|
| - var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend));
|
| - var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor));
|
| - assembler.Goto(&do_fdiv);
|
| + var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
|
| + var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
|
| + Goto(&do_fdiv);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_number);
|
| + Bind(&divisor_is_not_number);
|
| {
|
| // Convert {divisor} to a number and loop.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_divisor.Bind(assembler.CallStub(callable, context, divisor));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_divisor.Bind(CallStub(callable, context, divisor));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(÷nd_is_not_number);
|
| + Bind(÷nd_is_not_number);
|
| {
|
| // Convert {dividend} to a Number and loop.
|
| - Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_dividend.Bind(assembler.CallStub(callable, context, dividend));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_dividend.Bind(CallStub(callable, context, dividend));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&do_fdiv);
|
| + Bind(&do_fdiv);
|
| {
|
| - Node* value = assembler.Float64Div(var_dividend_float64.value(),
|
| - var_divisor_float64.value());
|
| - var_result.Bind(assembler.AllocateHeapNumberWithValue(value));
|
| - assembler.Goto(&end);
|
| + Node* value =
|
| + Float64Div(var_dividend_float64.value(), var_divisor_float64.value());
|
| + var_result.Bind(AllocateHeapNumberWithValue(value));
|
| + Goto(&end);
|
| }
|
| - assembler.Bind(&end);
|
| - assembler.Return(var_result.value());
|
| + Bind(&end);
|
| + Return(var_result.value());
|
| }
|
|
|
| -void Builtins::Generate_Modulus(compiler::CodeAssemblerState* state) {
|
| - typedef CodeStubAssembler::Label Label;
|
| - typedef compiler::Node Node;
|
| - typedef CodeStubAssembler::Variable Variable;
|
| - CodeStubAssembler assembler(state);
|
| +TF_BUILTIN(Modulus, CodeStubAssembler) {
|
| + Node* left = Parameter(0);
|
| + Node* right = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - Variable var_result(&assembler, MachineRepresentation::kTagged);
|
| - Label return_result(&assembler, &var_result);
|
| + Variable var_result(this, MachineRepresentation::kTagged);
|
| + Label return_result(this, &var_result);
|
|
|
| // Shared entry point for floating point modulus.
|
| - Label do_fmod(&assembler);
|
| - Variable var_dividend_float64(&assembler, MachineRepresentation::kFloat64),
|
| - var_divisor_float64(&assembler, MachineRepresentation::kFloat64);
|
| + Label do_fmod(this);
|
| + Variable var_dividend_float64(this, MachineRepresentation::kFloat64),
|
| + var_divisor_float64(this, MachineRepresentation::kFloat64);
|
|
|
| - Node* number_map = assembler.HeapNumberMapConstant();
|
| + Node* number_map = HeapNumberMapConstant();
|
|
|
| // We might need to loop one or two times due to ToNumber conversions.
|
| - Variable var_dividend(&assembler, MachineRepresentation::kTagged),
|
| - var_divisor(&assembler, MachineRepresentation::kTagged);
|
| + Variable var_dividend(this, MachineRepresentation::kTagged),
|
| + var_divisor(this, MachineRepresentation::kTagged);
|
| Variable* loop_variables[] = {&var_dividend, &var_divisor};
|
| - Label loop(&assembler, 2, loop_variables);
|
| + Label loop(this, 2, loop_variables);
|
| var_dividend.Bind(left);
|
| var_divisor.Bind(right);
|
| - assembler.Goto(&loop);
|
| - assembler.Bind(&loop);
|
| + Goto(&loop);
|
| + Bind(&loop);
|
| {
|
| Node* dividend = var_dividend.value();
|
| Node* divisor = var_divisor.value();
|
|
|
| - Label dividend_is_smi(&assembler), dividend_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(dividend), ÷nd_is_smi,
|
| - ÷nd_is_not_smi);
|
| + Label dividend_is_smi(this), dividend_is_not_smi(this);
|
| + Branch(TaggedIsSmi(dividend), ÷nd_is_smi, ÷nd_is_not_smi);
|
|
|
| - assembler.Bind(÷nd_is_smi);
|
| + Bind(÷nd_is_smi);
|
| {
|
| - Label dividend_is_not_zero(&assembler);
|
| - Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi,
|
| - &divisor_is_not_smi);
|
| + Label dividend_is_not_zero(this);
|
| + Label divisor_is_smi(this), divisor_is_not_smi(this);
|
| + Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
|
|
|
| - assembler.Bind(&divisor_is_smi);
|
| + Bind(&divisor_is_smi);
|
| {
|
| // Compute the modulus of two Smis.
|
| - var_result.Bind(assembler.SmiMod(dividend, divisor));
|
| - assembler.Goto(&return_result);
|
| + var_result.Bind(SmiMod(dividend, divisor));
|
| + Goto(&return_result);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_smi);
|
| + Bind(&divisor_is_not_smi);
|
| {
|
| - Node* divisor_map = assembler.LoadMap(divisor);
|
| + Node* divisor_map = LoadMap(divisor);
|
|
|
| // Check if {divisor} is a HeapNumber.
|
| - Label divisor_is_number(&assembler),
|
| - divisor_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(divisor_map, number_map),
|
| - &divisor_is_number, &divisor_is_not_number);
|
| + Label divisor_is_number(this),
|
| + divisor_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
|
| + &divisor_is_not_number);
|
|
|
| - assembler.Bind(&divisor_is_number);
|
| + Bind(&divisor_is_number);
|
| {
|
| // Convert {dividend} to a double and compute its modulus with the
|
| // value of {dividend}.
|
| - var_dividend_float64.Bind(assembler.SmiToFloat64(dividend));
|
| - var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor));
|
| - assembler.Goto(&do_fmod);
|
| + var_dividend_float64.Bind(SmiToFloat64(dividend));
|
| + var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
|
| + Goto(&do_fmod);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_number);
|
| + Bind(&divisor_is_not_number);
|
| {
|
| // Convert {divisor} to a number and loop.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_divisor.Bind(assembler.CallStub(callable, context, divisor));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_divisor.Bind(CallStub(callable, context, divisor));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(÷nd_is_not_smi);
|
| + Bind(÷nd_is_not_smi);
|
| {
|
| - Node* dividend_map = assembler.LoadMap(dividend);
|
| + Node* dividend_map = LoadMap(dividend);
|
|
|
| // Check if {dividend} is a HeapNumber.
|
| - Label dividend_is_number(&assembler),
|
| - dividend_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(dividend_map, number_map),
|
| - ÷nd_is_number, ÷nd_is_not_number);
|
| + Label dividend_is_number(this),
|
| + dividend_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(dividend_map, number_map), ÷nd_is_number,
|
| + ÷nd_is_not_number);
|
|
|
| - assembler.Bind(÷nd_is_number);
|
| + Bind(÷nd_is_number);
|
| {
|
| // Check if {divisor} is a Smi.
|
| - Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler);
|
| - assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi,
|
| - &divisor_is_not_smi);
|
| + Label divisor_is_smi(this), divisor_is_not_smi(this);
|
| + Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi);
|
|
|
| - assembler.Bind(&divisor_is_smi);
|
| + Bind(&divisor_is_smi);
|
| {
|
| // Convert {divisor} to a double and compute {dividend}'s modulus with
|
| // it.
|
| - var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend));
|
| - var_divisor_float64.Bind(assembler.SmiToFloat64(divisor));
|
| - assembler.Goto(&do_fmod);
|
| + var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
|
| + var_divisor_float64.Bind(SmiToFloat64(divisor));
|
| + Goto(&do_fmod);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_smi);
|
| + Bind(&divisor_is_not_smi);
|
| {
|
| - Node* divisor_map = assembler.LoadMap(divisor);
|
| + Node* divisor_map = LoadMap(divisor);
|
|
|
| // Check if {divisor} is a HeapNumber.
|
| - Label divisor_is_number(&assembler),
|
| - divisor_is_not_number(&assembler, Label::kDeferred);
|
| - assembler.Branch(assembler.WordEqual(divisor_map, number_map),
|
| - &divisor_is_number, &divisor_is_not_number);
|
| + Label divisor_is_number(this),
|
| + divisor_is_not_number(this, Label::kDeferred);
|
| + Branch(WordEqual(divisor_map, number_map), &divisor_is_number,
|
| + &divisor_is_not_number);
|
|
|
| - assembler.Bind(&divisor_is_number);
|
| + Bind(&divisor_is_number);
|
| {
|
| // Both {dividend} and {divisor} are HeapNumbers. Load their values
|
| // and compute their modulus.
|
| - var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend));
|
| - var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor));
|
| - assembler.Goto(&do_fmod);
|
| + var_dividend_float64.Bind(LoadHeapNumberValue(dividend));
|
| + var_divisor_float64.Bind(LoadHeapNumberValue(divisor));
|
| + Goto(&do_fmod);
|
| }
|
|
|
| - assembler.Bind(&divisor_is_not_number);
|
| + Bind(&divisor_is_not_number);
|
| {
|
| // Convert {divisor} to a number and loop.
|
| - Callable callable =
|
| - CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_divisor.Bind(assembler.CallStub(callable, context, divisor));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_divisor.Bind(CallStub(callable, context, divisor));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(÷nd_is_not_number);
|
| + Bind(÷nd_is_not_number);
|
| {
|
| // Convert {dividend} to a Number and loop.
|
| - Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate());
|
| - var_dividend.Bind(assembler.CallStub(callable, context, dividend));
|
| - assembler.Goto(&loop);
|
| + Callable callable = CodeFactory::NonNumberToNumber(isolate());
|
| + var_dividend.Bind(CallStub(callable, context, dividend));
|
| + Goto(&loop);
|
| }
|
| }
|
| }
|
|
|
| - assembler.Bind(&do_fmod);
|
| + Bind(&do_fmod);
|
| {
|
| - Node* value = assembler.Float64Mod(var_dividend_float64.value(),
|
| - var_divisor_float64.value());
|
| - var_result.Bind(assembler.AllocateHeapNumberWithValue(value));
|
| - assembler.Goto(&return_result);
|
| + Node* value =
|
| + Float64Mod(var_dividend_float64.value(), var_divisor_float64.value());
|
| + var_result.Bind(AllocateHeapNumberWithValue(value));
|
| + Goto(&return_result);
|
| }
|
|
|
| - assembler.Bind(&return_result);
|
| - assembler.Return(var_result.value());
|
| + Bind(&return_result);
|
| + Return(var_result.value());
|
| }
|
|
|
| -void Builtins::Generate_ShiftLeft(compiler::CodeAssemblerState* state) {
|
| - using compiler::Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - Node* lhs_value = assembler.TruncateTaggedToWord32(context, left);
|
| - Node* rhs_value = assembler.TruncateTaggedToWord32(context, right);
|
| - Node* shift_count =
|
| - assembler.Word32And(rhs_value, assembler.Int32Constant(0x1f));
|
| - Node* value = assembler.Word32Shl(lhs_value, shift_count);
|
| - Node* result = assembler.ChangeInt32ToTagged(value);
|
| - assembler.Return(result);
|
| +TF_BUILTIN(ShiftLeft, NumberBuiltinsAssembler) {
|
| + BitwiseShiftOp([this](Node* lhs, Node* shift_count) {
|
| + return Word32Shl(lhs, shift_count);
|
| + });
|
| }
|
|
|
| -void Builtins::Generate_ShiftRight(compiler::CodeAssemblerState* state) {
|
| - using compiler::Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - Node* lhs_value = assembler.TruncateTaggedToWord32(context, left);
|
| - Node* rhs_value = assembler.TruncateTaggedToWord32(context, right);
|
| - Node* shift_count =
|
| - assembler.Word32And(rhs_value, assembler.Int32Constant(0x1f));
|
| - Node* value = assembler.Word32Sar(lhs_value, shift_count);
|
| - Node* result = assembler.ChangeInt32ToTagged(value);
|
| - assembler.Return(result);
|
| +TF_BUILTIN(ShiftRight, NumberBuiltinsAssembler) {
|
| + BitwiseShiftOp([this](Node* lhs, Node* shift_count) {
|
| + return Word32Sar(lhs, shift_count);
|
| + });
|
| }
|
|
|
| -void Builtins::Generate_ShiftRightLogical(compiler::CodeAssemblerState* state) {
|
| - using compiler::Node;
|
| - CodeStubAssembler assembler(state);
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - Node* lhs_value = assembler.TruncateTaggedToWord32(context, left);
|
| - Node* rhs_value = assembler.TruncateTaggedToWord32(context, right);
|
| - Node* shift_count =
|
| - assembler.Word32And(rhs_value, assembler.Int32Constant(0x1f));
|
| - Node* value = assembler.Word32Shr(lhs_value, shift_count);
|
| - Node* result = assembler.ChangeUint32ToTagged(value);
|
| - assembler.Return(result);
|
| +TF_BUILTIN(ShiftRightLogical, NumberBuiltinsAssembler) {
|
| + BitwiseShiftOp<kUnsigned>([this](Node* lhs, Node* shift_count) {
|
| + return Word32Shr(lhs, shift_count);
|
| + });
|
| }
|
|
|
| -void Builtins::Generate_BitwiseAnd(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - using compiler::Node;
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - 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);
|
| - assembler.Return(result);
|
| +TF_BUILTIN(BitwiseAnd, NumberBuiltinsAssembler) {
|
| + BitwiseOp([this](Node* lhs, Node* rhs) { return Word32And(lhs, rhs); });
|
| }
|
|
|
| -void Builtins::Generate_BitwiseOr(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - using compiler::Node;
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - Node* lhs_value = assembler.TruncateTaggedToWord32(context, left);
|
| - Node* rhs_value = assembler.TruncateTaggedToWord32(context, right);
|
| - Node* value = assembler.Word32Or(lhs_value, rhs_value);
|
| - Node* result = assembler.ChangeInt32ToTagged(value);
|
| - assembler.Return(result);
|
| +TF_BUILTIN(BitwiseOr, NumberBuiltinsAssembler) {
|
| + BitwiseOp([this](Node* lhs, Node* rhs) { return Word32Or(lhs, rhs); });
|
| }
|
|
|
| -void Builtins::Generate_BitwiseXor(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - using compiler::Node;
|
| -
|
| - Node* left = assembler.Parameter(0);
|
| - Node* right = assembler.Parameter(1);
|
| - Node* context = assembler.Parameter(2);
|
| -
|
| - Node* lhs_value = assembler.TruncateTaggedToWord32(context, left);
|
| - Node* rhs_value = assembler.TruncateTaggedToWord32(context, right);
|
| - Node* value = assembler.Word32Xor(lhs_value, rhs_value);
|
| - Node* result = assembler.ChangeInt32ToTagged(value);
|
| - assembler.Return(result);
|
| +TF_BUILTIN(BitwiseXor, NumberBuiltinsAssembler) {
|
| + BitwiseOp([this](Node* lhs, Node* rhs) { return Word32Xor(lhs, rhs); });
|
| }
|
|
|
| -void Builtins::Generate_LessThan(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| -
|
| - assembler.Return(assembler.RelationalComparison(CodeStubAssembler::kLessThan,
|
| - lhs, rhs, context));
|
| +TF_BUILTIN(LessThan, NumberBuiltinsAssembler) {
|
| + RelationalComparisonBuiltin(kLessThan);
|
| }
|
|
|
| -void Builtins::Generate_LessThanOrEqual(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| -
|
| - assembler.Return(assembler.RelationalComparison(
|
| - CodeStubAssembler::kLessThanOrEqual, lhs, rhs, context));
|
| +TF_BUILTIN(LessThanOrEqual, NumberBuiltinsAssembler) {
|
| + RelationalComparisonBuiltin(kLessThanOrEqual);
|
| }
|
|
|
| -void Builtins::Generate_GreaterThan(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| -
|
| - assembler.Return(assembler.RelationalComparison(
|
| - CodeStubAssembler::kGreaterThan, lhs, rhs, context));
|
| +TF_BUILTIN(GreaterThan, NumberBuiltinsAssembler) {
|
| + RelationalComparisonBuiltin(kGreaterThan);
|
| }
|
|
|
| -void Builtins::Generate_GreaterThanOrEqual(
|
| - compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| -
|
| - assembler.Return(assembler.RelationalComparison(
|
| - CodeStubAssembler::kGreaterThanOrEqual, lhs, rhs, context));
|
| +TF_BUILTIN(GreaterThanOrEqual, NumberBuiltinsAssembler) {
|
| + RelationalComparisonBuiltin(kGreaterThanOrEqual);
|
| }
|
|
|
| -void Builtins::Generate_Equal(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(Equal, CodeStubAssembler) {
|
| + Node* lhs = Parameter(0);
|
| + Node* rhs = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| - assembler.Return(
|
| - assembler.Equal(CodeStubAssembler::kDontNegateResult, lhs, rhs, context));
|
| + Return(Equal(kDontNegateResult, lhs, rhs, context));
|
| }
|
|
|
| -void Builtins::Generate_NotEqual(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(NotEqual, CodeStubAssembler) {
|
| + Node* lhs = Parameter(0);
|
| + Node* rhs = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| - assembler.Return(
|
| - assembler.Equal(CodeStubAssembler::kNegateResult, lhs, rhs, context));
|
| + Return(Equal(kNegateResult, lhs, rhs, context));
|
| }
|
|
|
| -void Builtins::Generate_StrictEqual(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(StrictEqual, CodeStubAssembler) {
|
| + Node* lhs = Parameter(0);
|
| + Node* rhs = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| - assembler.Return(assembler.StrictEqual(CodeStubAssembler::kDontNegateResult,
|
| - lhs, rhs, context));
|
| + Return(StrictEqual(kDontNegateResult, lhs, rhs, context));
|
| }
|
|
|
| -void Builtins::Generate_StrictNotEqual(compiler::CodeAssemblerState* state) {
|
| - CodeStubAssembler assembler(state);
|
| - compiler::Node* lhs = assembler.Parameter(0);
|
| - compiler::Node* rhs = assembler.Parameter(1);
|
| - compiler::Node* context = assembler.Parameter(2);
|
| +TF_BUILTIN(StrictNotEqual, CodeStubAssembler) {
|
| + Node* lhs = Parameter(0);
|
| + Node* rhs = Parameter(1);
|
| + Node* context = Parameter(2);
|
|
|
| - assembler.Return(assembler.StrictEqual(CodeStubAssembler::kNegateResult, lhs,
|
| - rhs, context));
|
| + Return(StrictEqual(kNegateResult, lhs, rhs, context));
|
| }
|
|
|
| } // namespace internal
|
|
|
Chromium Code Reviews
Issue 2517833005:
[cleanup] Refactor builtins-number.cc (Closed)
