diff options
Diffstat (limited to 'deps/v8/src/builtins/builtins-number.cc')
| -rw-r--r-- | deps/v8/src/builtins/builtins-number.cc | 1663 |
1 files changed, 730 insertions, 933 deletions
diff --git a/deps/v8/src/builtins/builtins-number.cc b/deps/v8/src/builtins/builtins-number.cc index 3e2bc556b6..7e750139de 100644 --- a/deps/v8/src/builtins/builtins-number.cc +++ b/deps/v8/src/builtins/builtins-number.cc @@ -5,253 +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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; +TF_BUILTIN(NumberIsFinite, 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); // 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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; +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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; +TF_BUILTIN(NumberIsNaN, 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_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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - - Node* number = assembler->Parameter(1); +TF_BUILTIN(NumberIsSafeInteger, 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); // 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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - typedef CodeStubAssembler::Variable Variable; - - 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); } } } @@ -259,106 +257,86 @@ void Builtins::Generate_NumberParseFloat(CodeStubAssembler* assembler) { } // ES6 section 20.1.2.13 Number.parseInt ( string, radix ) -void Builtins::Generate_NumberParseInt(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - - 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); } } // ES6 section 20.1.3.2 Number.prototype.toExponential ( fractionDigits ) BUILTIN(NumberPrototypeToExponential) { HandleScope scope(isolate); - Handle<Object> value = args.at<Object>(0); + Handle<Object> value = args.at(0); Handle<Object> fraction_digits = args.atOrUndefined(isolate, 1); // Unwrap the receiver {value}. @@ -401,7 +379,7 @@ BUILTIN(NumberPrototypeToExponential) { // ES6 section 20.1.3.3 Number.prototype.toFixed ( fractionDigits ) BUILTIN(NumberPrototypeToFixed) { HandleScope scope(isolate); - Handle<Object> value = args.at<Object>(0); + Handle<Object> value = args.at(0); Handle<Object> fraction_digits = args.atOrUndefined(isolate, 1); // Unwrap the receiver {value}. @@ -444,7 +422,7 @@ BUILTIN(NumberPrototypeToFixed) { // ES6 section 20.1.3.4 Number.prototype.toLocaleString ( [ r1 [ , r2 ] ] ) BUILTIN(NumberPrototypeToLocaleString) { HandleScope scope(isolate); - Handle<Object> value = args.at<Object>(0); + Handle<Object> value = args.at(0); // Unwrap the receiver {value}. if (value->IsJSValue()) { @@ -464,7 +442,7 @@ BUILTIN(NumberPrototypeToLocaleString) { // ES6 section 20.1.3.5 Number.prototype.toPrecision ( precision ) BUILTIN(NumberPrototypeToPrecision) { HandleScope scope(isolate); - Handle<Object> value = args.at<Object>(0); + Handle<Object> value = args.at(0); Handle<Object> precision = args.atOrUndefined(isolate, 1); // Unwrap the receiver {value}. @@ -508,7 +486,7 @@ BUILTIN(NumberPrototypeToPrecision) { // ES6 section 20.1.3.6 Number.prototype.toString ( [ radix ] ) BUILTIN(NumberPrototypeToString) { HandleScope scope(isolate); - Handle<Object> value = args.at<Object>(0); + Handle<Object> value = args.at(0); Handle<Object> radix = args.atOrUndefined(isolate, 1); // Unwrap the receiver {value}. @@ -543,7 +521,8 @@ BUILTIN(NumberPrototypeToString) { } // Fast case where the result is a one character string. - if (IsUint32Double(value_number) && value_number < radix_number) { + if ((IsUint32Double(value_number) && value_number < radix_number) || + value_number == -0.0) { // Character array used for conversion. static const char kCharTable[] = "0123456789abcdefghijklmnopqrstuvwxyz"; return *isolate->factory()->LookupSingleCharacterStringFromCode( @@ -564,342 +543,315 @@ BUILTIN(NumberPrototypeToString) { } // ES6 section 20.1.3.7 Number.prototype.valueOf ( ) -void Builtins::Generate_NumberPrototypeValueOf(CodeStubAssembler* assembler) { - typedef compiler::Node Node; +TF_BUILTIN(NumberPrototypeValueOf, CodeStubAssembler) { + Node* receiver = Parameter(0); + Node* context = Parameter(3); - Node* receiver = assembler->Parameter(0); - Node* context = assembler->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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - typedef CodeStubAssembler::Variable Variable; - - 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)), - &if_lhsisnumber, &if_lhsisnotnumber); - - assembler->Bind(&if_lhsisnumber); + Label if_lhsisnumber(this), if_lhsisnotnumber(this, Label::kDeferred); + Branch( + Word32Equal(lhs_instance_type, Int32Constant(HEAP_NUMBER_TYPE)), + &if_lhsisnumber, &if_lhsisnotnumber); + + 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); + Callable callable = + 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); + Callable callable = + 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); } } } @@ -908,910 +860,755 @@ void Builtins::Generate_Add(CodeStubAssembler* assembler) { } } } - 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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - typedef CodeStubAssembler::Variable Variable; - - 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); + Branch(IsHeapNumberMap(lhs_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(IsHeapNumberMap(rhs_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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - typedef CodeStubAssembler::Variable Variable; - - 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); - - Node* number_map = assembler->HeapNumberMapConstant(); + Label do_fmul(this), return_result(this); + Variable var_lhs_float64(this, MachineRepresentation::kFloat64), + var_rhs_float64(this, MachineRepresentation::kFloat64); // 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(IsHeapNumberMap(rhs_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(IsHeapNumberMap(lhs_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(IsHeapNumberMap(rhs_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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - typedef CodeStubAssembler::Variable Variable; - - 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); - - Node* number_map = assembler->HeapNumberMapConstant(); + Label do_fdiv(this), end(this); + Variable var_dividend_float64(this, MachineRepresentation::kFloat64), + var_divisor_float64(this, MachineRepresentation::kFloat64); // 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(SmiEqual(divisor, SmiConstant(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(SmiEqual(dividend, SmiConstant(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(SmiLessThan(divisor, SmiConstant(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 = SmiToWord32(divisor); + Node* untagged_dividend = SmiToWord32(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(SmiFromWord32(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(IsHeapNumberMap(divisor_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(IsHeapNumberMap(dividend_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(IsHeapNumberMap(divisor_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(CodeStubAssembler* assembler) { - typedef CodeStubAssembler::Label Label; - typedef compiler::Node Node; - typedef CodeStubAssembler::Variable Variable; +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); - - Node* number_map = assembler->HeapNumberMapConstant(); + Label do_fmod(this); + Variable var_dividend_float64(this, MachineRepresentation::kFloat64), + var_divisor_float64(this, MachineRepresentation::kFloat64); // 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(IsHeapNumberMap(divisor_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(IsHeapNumberMap(dividend_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(IsHeapNumberMap(divisor_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(CodeStubAssembler* assembler) { - compiler::Node* left = assembler->Parameter(0); - compiler::Node* right = assembler->Parameter(1); - compiler::Node* context = assembler->Parameter(2); - - using compiler::Node; - - 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(CodeStubAssembler* assembler) { - compiler::Node* left = assembler->Parameter(0); - compiler::Node* right = assembler->Parameter(1); - compiler::Node* context = assembler->Parameter(2); - - using compiler::Node; - - 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(CodeStubAssembler* assembler) { - compiler::Node* left = assembler->Parameter(0); - compiler::Node* right = assembler->Parameter(1); - compiler::Node* context = assembler->Parameter(2); - - using compiler::Node; - - 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(CodeStubAssembler* assembler) { - compiler::Node* left = assembler->Parameter(0); - compiler::Node* right = assembler->Parameter(1); - compiler::Node* context = assembler->Parameter(2); - - 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); - assembler->Return(result); +TF_BUILTIN(BitwiseAnd, NumberBuiltinsAssembler) { + BitwiseOp([this](Node* lhs, Node* rhs) { return Word32And(lhs, rhs); }); } -void Builtins::Generate_BitwiseOr(CodeStubAssembler* assembler) { - compiler::Node* left = assembler->Parameter(0); - compiler::Node* right = assembler->Parameter(1); - compiler::Node* context = assembler->Parameter(2); - - using compiler::Node; - - 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(CodeStubAssembler* assembler) { - compiler::Node* left = assembler->Parameter(0); - compiler::Node* right = assembler->Parameter(1); - compiler::Node* context = assembler->Parameter(2); - - using compiler::Node; - - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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(CodeStubAssembler* assembler) { - 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 |