From 3005cbd6f98ac7a4df69e79b956c03c9518a65a7 Mon Sep 17 00:00:00 2001 From: hablich Date: Thu, 24 Nov 2016 00:57:28 -0800 Subject: [PATCH] Revert of [cleanup] Refactor builtins-number.cc (patchset #2 id:40001 of https://codereview.chromium.org/2517833005/ ) Reason for revert: Secondary dependency to revert https://codereview.chromium.org/2522393002/ Original issue's description: > [cleanup] Refactor builtins-number.cc > > Introducing a TF_BUILTIN macro that wraps CodeStubAssembler usage > into a convenient interface (using a subclass under the hood). > > Committed: https://crrev.com/cbf59c4c704e83a43b52c5ba6825df576fdaece8 > Cr-Commit-Position: refs/heads/master@{#41236} TBR=ishell@chromium.org,jkummerow@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true Review-Url: https://codereview.chromium.org/2529873002 Cr-Commit-Position: refs/heads/master@{#41252} --- src/builtins/builtins-number.cc | 1666 +++++++++++++++++-------------- src/builtins/builtins-utils.h | 25 - 2 files changed, 937 insertions(+), 754 deletions(-) diff --git a/src/builtins/builtins-number.cc b/src/builtins/builtins-number.cc index 457ef0857f..a63066cfbd 100644 --- a/src/builtins/builtins-number.cc +++ b/src/builtins/builtins-number.cc @@ -5,251 +5,255 @@ #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 - void BitwiseOp(std::function 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 - void BitwiseShiftOp(std::function body) { - BitwiseOp([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 ) -TF_BUILTIN(NumberIsFinite, CodeStubAssembler) { - Node* number = Parameter(1); +void Builtins::Generate_NumberIsFinite(compiler::CodeAssemblerState* state) { + typedef CodeStubAssembler::Label Label; + typedef compiler::Node Node; + CodeStubAssembler assembler(state); - Label return_true(this), return_false(this); + Node* number = assembler.Parameter(1); + + Label return_true(&assembler), return_false(&assembler); // Check if {number} is a Smi. - GotoIf(TaggedIsSmi(number), &return_true); + assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true); // Check if {number} is a HeapNumber. - GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false); + assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number), + assembler.HeapNumberMapConstant()), + &return_false); // Check if {number} contains a finite, non-NaN value. - Node* number_value = LoadHeapNumberValue(number); - BranchIfFloat64IsNaN(Float64Sub(number_value, number_value), &return_false, - &return_true); + Node* number_value = assembler.LoadHeapNumberValue(number); + assembler.BranchIfFloat64IsNaN( + assembler.Float64Sub(number_value, number_value), &return_false, + &return_true); - Bind(&return_true); - Return(BooleanConstant(true)); + assembler.Bind(&return_true); + assembler.Return(assembler.BooleanConstant(true)); - Bind(&return_false); - Return(BooleanConstant(false)); + assembler.Bind(&return_false); + assembler.Return(assembler.BooleanConstant(false)); } // ES6 section 20.1.2.3 Number.isInteger ( number ) -TF_BUILTIN(NumberIsInteger, CodeStubAssembler) { - Node* number = Parameter(1); +void Builtins::Generate_NumberIsInteger(compiler::CodeAssemblerState* state) { + typedef CodeStubAssembler::Label Label; + typedef compiler::Node Node; + CodeStubAssembler assembler(state); - Label return_true(this), return_false(this); + Node* number = assembler.Parameter(1); + + Label return_true(&assembler), return_false(&assembler); // Check if {number} is a Smi. - GotoIf(TaggedIsSmi(number), &return_true); + assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true); // Check if {number} is a HeapNumber. - GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false); + assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number), + assembler.HeapNumberMapConstant()), + &return_false); // Load the actual value of {number}. - Node* number_value = LoadHeapNumberValue(number); + Node* number_value = assembler.LoadHeapNumberValue(number); // Truncate the value of {number} to an integer (or an infinity). - Node* integer = Float64Trunc(number_value); + Node* integer = assembler.Float64Trunc(number_value); // Check if {number}s value matches the integer (ruling out the infinities). - Branch(Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)), - &return_true, &return_false); + assembler.Branch( + assembler.Float64Equal(assembler.Float64Sub(number_value, integer), + assembler.Float64Constant(0.0)), + &return_true, &return_false); - Bind(&return_true); - Return(BooleanConstant(true)); + assembler.Bind(&return_true); + assembler.Return(assembler.BooleanConstant(true)); - Bind(&return_false); - Return(BooleanConstant(false)); + assembler.Bind(&return_false); + assembler.Return(assembler.BooleanConstant(false)); } // ES6 section 20.1.2.4 Number.isNaN ( number ) -TF_BUILTIN(NumberIsNaN, CodeStubAssembler) { - Node* number = Parameter(1); +void Builtins::Generate_NumberIsNaN(compiler::CodeAssemblerState* state) { + typedef CodeStubAssembler::Label Label; + typedef compiler::Node Node; + CodeStubAssembler assembler(state); - Label return_true(this), return_false(this); + Node* number = assembler.Parameter(1); + + Label return_true(&assembler), return_false(&assembler); // Check if {number} is a Smi. - GotoIf(TaggedIsSmi(number), &return_false); + assembler.GotoIf(assembler.TaggedIsSmi(number), &return_false); // Check if {number} is a HeapNumber. - GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false); + assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number), + assembler.HeapNumberMapConstant()), + &return_false); // Check if {number} contains a NaN value. - Node* number_value = LoadHeapNumberValue(number); - BranchIfFloat64IsNaN(number_value, &return_true, &return_false); + Node* number_value = assembler.LoadHeapNumberValue(number); + assembler.BranchIfFloat64IsNaN(number_value, &return_true, &return_false); - Bind(&return_true); - Return(BooleanConstant(true)); + assembler.Bind(&return_true); + assembler.Return(assembler.BooleanConstant(true)); - Bind(&return_false); - Return(BooleanConstant(false)); + assembler.Bind(&return_false); + assembler.Return(assembler.BooleanConstant(false)); } // ES6 section 20.1.2.5 Number.isSafeInteger ( number ) -TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) { - Node* number = Parameter(1); +void Builtins::Generate_NumberIsSafeInteger( + compiler::CodeAssemblerState* state) { + typedef CodeStubAssembler::Label Label; + typedef compiler::Node Node; + CodeStubAssembler assembler(state); - Label return_true(this), return_false(this); + Node* number = assembler.Parameter(1); + + Label return_true(&assembler), return_false(&assembler); // Check if {number} is a Smi. - GotoIf(TaggedIsSmi(number), &return_true); + assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true); // Check if {number} is a HeapNumber. - GotoUnless(IsHeapNumberMap(LoadMap(number)), &return_false); + assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number), + assembler.HeapNumberMapConstant()), + &return_false); // Load the actual value of {number}. - Node* number_value = LoadHeapNumberValue(number); + Node* number_value = assembler.LoadHeapNumberValue(number); // Truncate the value of {number} to an integer (or an infinity). - Node* integer = Float64Trunc(number_value); + Node* integer = assembler.Float64Trunc(number_value); // Check if {number}s value matches the integer (ruling out the infinities). - GotoUnless( - Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)), + assembler.GotoUnless( + assembler.Float64Equal(assembler.Float64Sub(number_value, integer), + assembler.Float64Constant(0.0)), &return_false); // Check if the {integer} value is in safe integer range. - Branch(Float64LessThanOrEqual(Float64Abs(integer), - Float64Constant(kMaxSafeInteger)), - &return_true, &return_false); + assembler.Branch(assembler.Float64LessThanOrEqual( + assembler.Float64Abs(integer), + assembler.Float64Constant(kMaxSafeInteger)), + &return_true, &return_false); - Bind(&return_true); - Return(BooleanConstant(true)); + assembler.Bind(&return_true); + assembler.Return(assembler.BooleanConstant(true)); - Bind(&return_false); - Return(BooleanConstant(false)); + assembler.Bind(&return_false); + assembler.Return(assembler.BooleanConstant(false)); } // ES6 section 20.1.2.12 Number.parseFloat ( string ) -TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { - Node* context = Parameter(4); +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); // We might need to loop once for ToString conversion. - Variable var_input(this, MachineRepresentation::kTagged); - Label loop(this, &var_input); - var_input.Bind(Parameter(1)); - Goto(&loop); - Bind(&loop); + Variable var_input(&assembler, MachineRepresentation::kTagged); + Label loop(&assembler, &var_input); + var_input.Bind(assembler.Parameter(1)); + assembler.Goto(&loop); + assembler.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(this), if_inputisnotsmi(this); - Branch(TaggedIsSmi(input), &if_inputissmi, &if_inputisnotsmi); + Label if_inputissmi(&assembler), if_inputisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(input), &if_inputissmi, + &if_inputisnotsmi); - Bind(&if_inputissmi); + assembler.Bind(&if_inputissmi); { // The {input} is already a Number, no need to do anything. - Return(input); + assembler.Return(input); } - Bind(&if_inputisnotsmi); + assembler.Bind(&if_inputisnotsmi); { // The {input} is a HeapObject, check if it's already a String. - 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); + 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); - Bind(&if_inputisstring); + assembler.Bind(&if_inputisstring); { // The {input} is already a String, check if {input} contains // a cached array index. - 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); + 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); - Bind(&if_inputcached); + assembler.Bind(&if_inputcached); { // Just return the {input}s cached array index. Node* input_array_index = - DecodeWordFromWord32(input_hash); - Return(SmiTag(input_array_index)); + assembler.DecodeWordFromWord32( + input_hash); + assembler.Return(assembler.SmiTag(input_array_index)); } - Bind(&if_inputnotcached); + assembler.Bind(&if_inputnotcached); { // Need to fall back to the runtime to convert {input} to double. - Return(CallRuntime(Runtime::kStringParseFloat, context, input)); + assembler.Return(assembler.CallRuntime(Runtime::kStringParseFloat, + context, input)); } } - Bind(&if_inputisnotstring); + assembler.Bind(&if_inputisnotstring); { // The {input} is neither a String nor a Smi, check for HeapNumber. - Label if_inputisnumber(this), - if_inputisnotnumber(this, Label::kDeferred); - Branch(IsHeapNumberMap(input_map), &if_inputisnumber, - &if_inputisnotnumber); + Label if_inputisnumber(&assembler), + if_inputisnotnumber(&assembler, Label::kDeferred); + assembler.Branch( + assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()), + &if_inputisnumber, &if_inputisnotnumber); - Bind(&if_inputisnumber); + assembler.Bind(&if_inputisnumber); { // The {input} is already a Number, take care of -0. - Label if_inputiszero(this), if_inputisnotzero(this); - Node* input_value = LoadHeapNumberValue(input); - Branch(Float64Equal(input_value, Float64Constant(0.0)), - &if_inputiszero, &if_inputisnotzero); + 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); - Bind(&if_inputiszero); - Return(SmiConstant(0)); + assembler.Bind(&if_inputiszero); + assembler.Return(assembler.SmiConstant(0)); - Bind(&if_inputisnotzero); - Return(input); + assembler.Bind(&if_inputisnotzero); + assembler.Return(input); } - Bind(&if_inputisnotnumber); + assembler.Bind(&if_inputisnotnumber); { // Need to convert the {input} to String first. // TODO(bmeurer): This could be more efficient if necessary. - Callable callable = CodeFactory::ToString(isolate()); - var_input.Bind(CallStub(callable, context, input)); - Goto(&loop); + Callable callable = CodeFactory::ToString(assembler.isolate()); + var_input.Bind(assembler.CallStub(callable, context, input)); + assembler.Goto(&loop); } } } @@ -257,79 +261,99 @@ TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { } // ES6 section 20.1.2.13 Number.parseInt ( string, radix ) -TF_BUILTIN(NumberParseInt, CodeStubAssembler) { - Node* input = Parameter(1); - Node* radix = Parameter(2); - Node* context = Parameter(5); +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); // Check if {radix} is treated as 10 (i.e. undefined, 0 or 10). - 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); + 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); - Bind(&if_radix10); + assembler.Bind(&if_radix10); { // Check if we can avoid the ToString conversion on {input}. - 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); + 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); - Bind(&if_inputissmi); + assembler.Bind(&if_inputissmi); { // Just return the {input}. - Return(input); + assembler.Return(input); } - Bind(&if_inputisheapnumber); + assembler.Bind(&if_inputisheapnumber); { // Check if the {input} value is in Signed32 range. - Label if_inputissigned32(this); - Node* input_value = LoadHeapNumberValue(input); - Node* input_value32 = TruncateFloat64ToWord32(input_value); - GotoIf(Float64Equal(input_value, ChangeInt32ToFloat64(input_value32)), - &if_inputissigned32); + 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); // Check if the absolute {input} value is in the ]0.01,1e9[ range. - Node* input_value_abs = Float64Abs(input_value); + Node* input_value_abs = assembler.Float64Abs(input_value); - GotoUnless(Float64LessThan(input_value_abs, Float64Constant(1e9)), - &if_generic); - Branch(Float64LessThan(Float64Constant(0.01), input_value_abs), - &if_inputissigned32, &if_generic); + 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); // Return the truncated int32 value, and return the tagged result. - Bind(&if_inputissigned32); - Node* result = ChangeInt32ToTagged(input_value32); - Return(result); + assembler.Bind(&if_inputissigned32); + Node* result = assembler.ChangeInt32ToTagged(input_value32); + assembler.Return(result); } - Bind(&if_inputisstring); + assembler.Bind(&if_inputisstring); { // Check if the String {input} has a cached array index. - Node* input_hash = LoadNameHashField(input); - Node* input_bit = Word32And( - input_hash, Int32Constant(String::kContainsCachedArrayIndexMask)); - GotoIf(Word32NotEqual(input_bit, Int32Constant(0)), &if_generic); + 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); // Return the cached array index as result. Node* input_index = - DecodeWordFromWord32(input_hash); - Node* result = SmiTag(input_index); - Return(result); + assembler.DecodeWordFromWord32( + input_hash); + Node* result = assembler.SmiTag(input_index); + assembler.Return(result); } } - Bind(&if_generic); + assembler.Bind(&if_generic); { - Node* result = CallRuntime(Runtime::kStringParseInt, context, input, radix); - Return(result); + Node* result = + assembler.CallRuntime(Runtime::kStringParseInt, context, input, radix); + assembler.Return(result); } } @@ -542,315 +566,344 @@ BUILTIN(NumberPrototypeToString) { } // ES6 section 20.1.3.7 Number.prototype.valueOf ( ) -TF_BUILTIN(NumberPrototypeValueOf, CodeStubAssembler) { - Node* receiver = Parameter(0); - Node* context = Parameter(3); +void Builtins::Generate_NumberPrototypeValueOf( + compiler::CodeAssemblerState* state) { + typedef compiler::Node Node; + CodeStubAssembler assembler(state); - Node* result = ToThisValue(context, receiver, PrimitiveType::kNumber, - "Number.prototype.valueOf"); - Return(result); + Node* receiver = assembler.Parameter(0); + Node* context = assembler.Parameter(3); + + Node* result = assembler.ToThisValue( + context, receiver, PrimitiveType::kNumber, "Number.prototype.valueOf"); + assembler.Return(result); } -TF_BUILTIN(Add, CodeStubAssembler) { - Node* left = Parameter(0); - Node* right = Parameter(1); - Node* context = Parameter(2); +// 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); // Shared entry for floating point addition. - Label do_fadd(this); - Variable var_fadd_lhs(this, MachineRepresentation::kFloat64), - var_fadd_rhs(this, MachineRepresentation::kFloat64); + Label do_fadd(&assembler); + Variable var_fadd_lhs(&assembler, MachineRepresentation::kFloat64), + var_fadd_rhs(&assembler, MachineRepresentation::kFloat64); // We might need to loop several times due to ToPrimitive, ToString and/or // ToNumber conversions. - Variable var_lhs(this, MachineRepresentation::kTagged), - var_rhs(this, MachineRepresentation::kTagged), - var_result(this, MachineRepresentation::kTagged); + Variable var_lhs(&assembler, MachineRepresentation::kTagged), + var_rhs(&assembler, MachineRepresentation::kTagged), + var_result(&assembler, MachineRepresentation::kTagged); Variable* loop_vars[2] = {&var_lhs, &var_rhs}; - Label loop(this, 2, loop_vars), end(this), - string_add_convert_left(this, Label::kDeferred), - string_add_convert_right(this, Label::kDeferred); + Label loop(&assembler, 2, loop_vars), end(&assembler), + string_add_convert_left(&assembler, Label::kDeferred), + string_add_convert_right(&assembler, Label::kDeferred); var_lhs.Bind(left); var_rhs.Bind(right); - Goto(&loop); - Bind(&loop); + assembler.Goto(&loop); + assembler.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(this), if_lhsisnotsmi(this); - Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); + Label if_lhsissmi(&assembler), if_lhsisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); - Bind(&if_lhsissmi); + assembler.Bind(&if_lhsissmi); { // Check if the {rhs} is also a Smi. - Label if_rhsissmi(this), if_rhsisnotsmi(this); - Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi); + Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi, + &if_rhsisnotsmi); - Bind(&if_rhsissmi); + assembler.Bind(&if_rhsissmi); { // Try fast Smi addition first. - Node* pair = IntPtrAddWithOverflow(BitcastTaggedToWord(lhs), - BitcastTaggedToWord(rhs)); - Node* overflow = Projection(1, pair); + Node* pair = + assembler.IntPtrAddWithOverflow(assembler.BitcastTaggedToWord(lhs), + assembler.BitcastTaggedToWord(rhs)); + Node* overflow = assembler.Projection(1, pair); // Check if the Smi additon overflowed. - Label if_overflow(this), if_notoverflow(this); - Branch(overflow, &if_overflow, &if_notoverflow); + Label if_overflow(&assembler), if_notoverflow(&assembler); + assembler.Branch(overflow, &if_overflow, &if_notoverflow); - Bind(&if_overflow); + assembler.Bind(&if_overflow); { - var_fadd_lhs.Bind(SmiToFloat64(lhs)); - var_fadd_rhs.Bind(SmiToFloat64(rhs)); - Goto(&do_fadd); + var_fadd_lhs.Bind(assembler.SmiToFloat64(lhs)); + var_fadd_rhs.Bind(assembler.SmiToFloat64(rhs)); + assembler.Goto(&do_fadd); } - Bind(&if_notoverflow); - var_result.Bind(BitcastWordToTaggedSigned(Projection(0, pair))); - Goto(&end); + assembler.Bind(&if_notoverflow); + var_result.Bind( + assembler.BitcastWordToTaggedSigned(assembler.Projection(0, pair))); + assembler.Goto(&end); } - Bind(&if_rhsisnotsmi); + assembler.Bind(&if_rhsisnotsmi); { // Load the map of {rhs}. - Node* rhs_map = LoadMap(rhs); + Node* rhs_map = assembler.LoadMap(rhs); // Check if the {rhs} is a HeapNumber. - Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred); - Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber); + Label if_rhsisnumber(&assembler), + if_rhsisnotnumber(&assembler, Label::kDeferred); + assembler.Branch(assembler.IsHeapNumberMap(rhs_map), &if_rhsisnumber, + &if_rhsisnotnumber); - Bind(&if_rhsisnumber); + assembler.Bind(&if_rhsisnumber); { - var_fadd_lhs.Bind(SmiToFloat64(lhs)); - var_fadd_rhs.Bind(LoadHeapNumberValue(rhs)); - Goto(&do_fadd); + var_fadd_lhs.Bind(assembler.SmiToFloat64(lhs)); + var_fadd_rhs.Bind(assembler.LoadHeapNumberValue(rhs)); + assembler.Goto(&do_fadd); } - Bind(&if_rhsisnotnumber); + assembler.Bind(&if_rhsisnotnumber); { // Load the instance type of {rhs}. - Node* rhs_instance_type = LoadMapInstanceType(rhs_map); + Node* rhs_instance_type = assembler.LoadMapInstanceType(rhs_map); // Check if the {rhs} is a String. - Label if_rhsisstring(this, Label::kDeferred), - if_rhsisnotstring(this, Label::kDeferred); - Branch(IsStringInstanceType(rhs_instance_type), &if_rhsisstring, - &if_rhsisnotstring); + Label if_rhsisstring(&assembler, Label::kDeferred), + if_rhsisnotstring(&assembler, Label::kDeferred); + assembler.Branch(assembler.IsStringInstanceType(rhs_instance_type), + &if_rhsisstring, &if_rhsisnotstring); - Bind(&if_rhsisstring); + assembler.Bind(&if_rhsisstring); { var_lhs.Bind(lhs); var_rhs.Bind(rhs); - Goto(&string_add_convert_left); + assembler.Goto(&string_add_convert_left); } - Bind(&if_rhsisnotstring); + assembler.Bind(&if_rhsisnotstring); { // Check if {rhs} is a JSReceiver. - Label if_rhsisreceiver(this, Label::kDeferred), - if_rhsisnotreceiver(this, Label::kDeferred); - Branch(IsJSReceiverInstanceType(rhs_instance_type), - &if_rhsisreceiver, &if_rhsisnotreceiver); + Label if_rhsisreceiver(&assembler, Label::kDeferred), + if_rhsisnotreceiver(&assembler, Label::kDeferred); + assembler.Branch( + assembler.IsJSReceiverInstanceType(rhs_instance_type), + &if_rhsisreceiver, &if_rhsisnotreceiver); - Bind(&if_rhsisreceiver); + assembler.Bind(&if_rhsisreceiver); { // Convert {rhs} to a primitive first passing no hint. Callable callable = - CodeFactory::NonPrimitiveToPrimitive(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + CodeFactory::NonPrimitiveToPrimitive(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } - Bind(&if_rhsisnotreceiver); + assembler.Bind(&if_rhsisnotreceiver); { // Convert {rhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } } } } } - Bind(&if_lhsisnotsmi); + assembler.Bind(&if_lhsisnotsmi); { // Load the map and instance type of {lhs}. - Node* lhs_instance_type = LoadInstanceType(lhs); + Node* lhs_instance_type = assembler.LoadInstanceType(lhs); // Check if {lhs} is a String. - Label if_lhsisstring(this), if_lhsisnotstring(this); - Branch(IsStringInstanceType(lhs_instance_type), &if_lhsisstring, - &if_lhsisnotstring); + Label if_lhsisstring(&assembler), if_lhsisnotstring(&assembler); + assembler.Branch(assembler.IsStringInstanceType(lhs_instance_type), + &if_lhsisstring, &if_lhsisnotstring); - Bind(&if_lhsisstring); + assembler.Bind(&if_lhsisstring); { var_lhs.Bind(lhs); var_rhs.Bind(rhs); - Goto(&string_add_convert_right); + assembler.Goto(&string_add_convert_right); } - Bind(&if_lhsisnotstring); + assembler.Bind(&if_lhsisnotstring); { // Check if {rhs} is a Smi. - Label if_rhsissmi(this), if_rhsisnotsmi(this); - Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi); + Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi, + &if_rhsisnotsmi); - Bind(&if_rhsissmi); + assembler.Bind(&if_rhsissmi); { // Check if {lhs} is a Number. - Label if_lhsisnumber(this), if_lhsisnotnumber(this, Label::kDeferred); - Branch( - Word32Equal(lhs_instance_type, Int32Constant(HEAP_NUMBER_TYPE)), + 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); - Bind(&if_lhsisnumber); + assembler.Bind(&if_lhsisnumber); { // The {lhs} is a HeapNumber, the {rhs} is a Smi, just add them. - var_fadd_lhs.Bind(LoadHeapNumberValue(lhs)); - var_fadd_rhs.Bind(SmiToFloat64(rhs)); - Goto(&do_fadd); + var_fadd_lhs.Bind(assembler.LoadHeapNumberValue(lhs)); + var_fadd_rhs.Bind(assembler.SmiToFloat64(rhs)); + assembler.Goto(&do_fadd); } - Bind(&if_lhsisnotnumber); + assembler.Bind(&if_lhsisnotnumber); { // The {lhs} is neither a Number nor a String, and the {rhs} is a // Smi. - Label if_lhsisreceiver(this, Label::kDeferred), - if_lhsisnotreceiver(this, Label::kDeferred); - Branch(IsJSReceiverInstanceType(lhs_instance_type), - &if_lhsisreceiver, &if_lhsisnotreceiver); + Label if_lhsisreceiver(&assembler, Label::kDeferred), + if_lhsisnotreceiver(&assembler, Label::kDeferred); + assembler.Branch( + assembler.IsJSReceiverInstanceType(lhs_instance_type), + &if_lhsisreceiver, &if_lhsisnotreceiver); - Bind(&if_lhsisreceiver); + assembler.Bind(&if_lhsisreceiver); { // Convert {lhs} to a primitive first passing no hint. Callable callable = - CodeFactory::NonPrimitiveToPrimitive(isolate()); - var_lhs.Bind(CallStub(callable, context, lhs)); - Goto(&loop); + CodeFactory::NonPrimitiveToPrimitive(assembler.isolate()); + var_lhs.Bind(assembler.CallStub(callable, context, lhs)); + assembler.Goto(&loop); } - Bind(&if_lhsisnotreceiver); + assembler.Bind(&if_lhsisnotreceiver); { // Convert {lhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_lhs.Bind(CallStub(callable, context, lhs)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_lhs.Bind(assembler.CallStub(callable, context, lhs)); + assembler.Goto(&loop); } } } - Bind(&if_rhsisnotsmi); + assembler.Bind(&if_rhsisnotsmi); { // Load the instance type of {rhs}. - Node* rhs_instance_type = LoadInstanceType(rhs); + Node* rhs_instance_type = assembler.LoadInstanceType(rhs); // Check if {rhs} is a String. - Label if_rhsisstring(this), if_rhsisnotstring(this); - Branch(IsStringInstanceType(rhs_instance_type), &if_rhsisstring, - &if_rhsisnotstring); + Label if_rhsisstring(&assembler), if_rhsisnotstring(&assembler); + assembler.Branch(assembler.IsStringInstanceType(rhs_instance_type), + &if_rhsisstring, &if_rhsisnotstring); - Bind(&if_rhsisstring); + assembler.Bind(&if_rhsisstring); { var_lhs.Bind(lhs); var_rhs.Bind(rhs); - Goto(&string_add_convert_left); + assembler.Goto(&string_add_convert_left); } - Bind(&if_rhsisnotstring); + assembler.Bind(&if_rhsisnotstring); { // Check if {lhs} is a HeapNumber. - Label if_lhsisnumber(this), if_lhsisnotnumber(this); - Branch( - Word32Equal(lhs_instance_type, Int32Constant(HEAP_NUMBER_TYPE)), - &if_lhsisnumber, &if_lhsisnotnumber); + Label if_lhsisnumber(&assembler), if_lhsisnotnumber(&assembler); + assembler.Branch(assembler.Word32Equal( + lhs_instance_type, + assembler.Int32Constant(HEAP_NUMBER_TYPE)), + &if_lhsisnumber, &if_lhsisnotnumber); - Bind(&if_lhsisnumber); + assembler.Bind(&if_lhsisnumber); { // Check if {rhs} is also a HeapNumber. - Label if_rhsisnumber(this), - if_rhsisnotnumber(this, Label::kDeferred); - Branch(Word32Equal(rhs_instance_type, - Int32Constant(HEAP_NUMBER_TYPE)), - &if_rhsisnumber, &if_rhsisnotnumber); + 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); - Bind(&if_rhsisnumber); + assembler.Bind(&if_rhsisnumber); { // Perform a floating point addition. - var_fadd_lhs.Bind(LoadHeapNumberValue(lhs)); - var_fadd_rhs.Bind(LoadHeapNumberValue(rhs)); - Goto(&do_fadd); + var_fadd_lhs.Bind(assembler.LoadHeapNumberValue(lhs)); + var_fadd_rhs.Bind(assembler.LoadHeapNumberValue(rhs)); + assembler.Goto(&do_fadd); } - Bind(&if_rhsisnotnumber); + assembler.Bind(&if_rhsisnotnumber); { // Check if {rhs} is a JSReceiver. - Label if_rhsisreceiver(this, Label::kDeferred), - if_rhsisnotreceiver(this, Label::kDeferred); - Branch(IsJSReceiverInstanceType(rhs_instance_type), - &if_rhsisreceiver, &if_rhsisnotreceiver); + Label if_rhsisreceiver(&assembler, Label::kDeferred), + if_rhsisnotreceiver(&assembler, Label::kDeferred); + assembler.Branch( + assembler.IsJSReceiverInstanceType(rhs_instance_type), + &if_rhsisreceiver, &if_rhsisnotreceiver); - Bind(&if_rhsisreceiver); + assembler.Bind(&if_rhsisreceiver); { // Convert {rhs} to a primitive first passing no hint. Callable callable = - CodeFactory::NonPrimitiveToPrimitive(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + CodeFactory::NonPrimitiveToPrimitive(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } - Bind(&if_rhsisnotreceiver); + assembler.Bind(&if_rhsisnotreceiver); { // Convert {rhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } } } - Bind(&if_lhsisnotnumber); + assembler.Bind(&if_lhsisnotnumber); { // Check if {lhs} is a JSReceiver. - Label if_lhsisreceiver(this, Label::kDeferred), - if_lhsisnotreceiver(this); - Branch(IsJSReceiverInstanceType(lhs_instance_type), - &if_lhsisreceiver, &if_lhsisnotreceiver); + Label if_lhsisreceiver(&assembler, Label::kDeferred), + if_lhsisnotreceiver(&assembler); + assembler.Branch( + assembler.IsJSReceiverInstanceType(lhs_instance_type), + &if_lhsisreceiver, &if_lhsisnotreceiver); - Bind(&if_lhsisreceiver); + assembler.Bind(&if_lhsisreceiver); { // Convert {lhs} to a primitive first passing no hint. Callable callable = - CodeFactory::NonPrimitiveToPrimitive(isolate()); - var_lhs.Bind(CallStub(callable, context, lhs)); - Goto(&loop); + CodeFactory::NonPrimitiveToPrimitive(assembler.isolate()); + var_lhs.Bind(assembler.CallStub(callable, context, lhs)); + assembler.Goto(&loop); } - Bind(&if_lhsisnotreceiver); + assembler.Bind(&if_lhsisnotreceiver); { // Check if {rhs} is a JSReceiver. - Label if_rhsisreceiver(this, Label::kDeferred), - if_rhsisnotreceiver(this, Label::kDeferred); - Branch(IsJSReceiverInstanceType(rhs_instance_type), - &if_rhsisreceiver, &if_rhsisnotreceiver); + Label if_rhsisreceiver(&assembler, Label::kDeferred), + if_rhsisnotreceiver(&assembler, Label::kDeferred); + assembler.Branch( + assembler.IsJSReceiverInstanceType(rhs_instance_type), + &if_rhsisreceiver, &if_rhsisnotreceiver); - Bind(&if_rhsisreceiver); + assembler.Bind(&if_rhsisreceiver); { // Convert {rhs} to a primitive first passing no hint. Callable callable = - CodeFactory::NonPrimitiveToPrimitive(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + CodeFactory::NonPrimitiveToPrimitive(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } - Bind(&if_rhsisnotreceiver); + assembler.Bind(&if_rhsisnotreceiver); { // Convert {lhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_lhs.Bind(CallStub(callable, context, lhs)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_lhs.Bind(assembler.CallStub(callable, context, lhs)); + assembler.Goto(&loop); } } } @@ -859,767 +912,922 @@ TF_BUILTIN(Add, CodeStubAssembler) { } } } - 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(isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED); - var_result.Bind( - CallStub(callable, context, var_lhs.value(), var_rhs.value())); - Goto(&end); - } - - Bind(&string_add_convert_right); + assembler.Bind(&string_add_convert_left); { // Convert {lhs}, which is a Smi, to a String and concatenate the // resulting string with the String {rhs}. Callable callable = CodeFactory::StringAdd( - isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED); - var_result.Bind( - CallStub(callable, context, var_lhs.value(), var_rhs.value())); - Goto(&end); + assembler.isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED); + var_result.Bind(assembler.CallStub(callable, context, var_lhs.value(), + var_rhs.value())); + assembler.Goto(&end); } - Bind(&do_fadd); + assembler.Bind(&string_add_convert_right); + { + // Convert {lhs}, which is a Smi, to a String and concatenate the + // resulting string with the String {rhs}. + Callable callable = CodeFactory::StringAdd( + assembler.isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED); + var_result.Bind(assembler.CallStub(callable, context, var_lhs.value(), + var_rhs.value())); + assembler.Goto(&end); + } + + assembler.Bind(&do_fadd); { Node* lhs_value = var_fadd_lhs.value(); Node* rhs_value = var_fadd_rhs.value(); - Node* value = Float64Add(lhs_value, rhs_value); - Node* result = AllocateHeapNumberWithValue(value); + Node* value = assembler.Float64Add(lhs_value, rhs_value); + Node* result = assembler.AllocateHeapNumberWithValue(value); var_result.Bind(result); - Goto(&end); + assembler.Goto(&end); } - Bind(&end); - Return(var_result.value()); + assembler.Bind(&end); + assembler.Return(var_result.value()); } -TF_BUILTIN(Subtract, CodeStubAssembler) { - Node* left = Parameter(0); - Node* right = Parameter(1); - Node* context = Parameter(2); +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); // Shared entry for floating point subtraction. - Label do_fsub(this), end(this); - Variable var_fsub_lhs(this, MachineRepresentation::kFloat64), - var_fsub_rhs(this, MachineRepresentation::kFloat64); + Label do_fsub(&assembler), end(&assembler); + Variable var_fsub_lhs(&assembler, MachineRepresentation::kFloat64), + var_fsub_rhs(&assembler, MachineRepresentation::kFloat64); // We might need to loop several times due to ToPrimitive and/or ToNumber // conversions. - Variable var_lhs(this, MachineRepresentation::kTagged), - var_rhs(this, MachineRepresentation::kTagged), - var_result(this, MachineRepresentation::kTagged); + Variable var_lhs(&assembler, MachineRepresentation::kTagged), + var_rhs(&assembler, MachineRepresentation::kTagged), + var_result(&assembler, MachineRepresentation::kTagged); Variable* loop_vars[2] = {&var_lhs, &var_rhs}; - Label loop(this, 2, loop_vars); + Label loop(&assembler, 2, loop_vars); var_lhs.Bind(left); var_rhs.Bind(right); - Goto(&loop); - Bind(&loop); + assembler.Goto(&loop); + assembler.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(this), if_lhsisnotsmi(this); - Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); + Label if_lhsissmi(&assembler), if_lhsisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); - Bind(&if_lhsissmi); + assembler.Bind(&if_lhsissmi); { // Check if the {rhs} is also a Smi. - Label if_rhsissmi(this), if_rhsisnotsmi(this); - Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi); + Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi, + &if_rhsisnotsmi); - Bind(&if_rhsissmi); + assembler.Bind(&if_rhsissmi); { // Try a fast Smi subtraction first. - Node* pair = IntPtrSubWithOverflow(BitcastTaggedToWord(lhs), - BitcastTaggedToWord(rhs)); - Node* overflow = Projection(1, pair); + Node* pair = + assembler.IntPtrSubWithOverflow(assembler.BitcastTaggedToWord(lhs), + assembler.BitcastTaggedToWord(rhs)); + Node* overflow = assembler.Projection(1, pair); // Check if the Smi subtraction overflowed. - Label if_overflow(this), if_notoverflow(this); - Branch(overflow, &if_overflow, &if_notoverflow); + Label if_overflow(&assembler), if_notoverflow(&assembler); + assembler.Branch(overflow, &if_overflow, &if_notoverflow); - Bind(&if_overflow); + assembler.Bind(&if_overflow); { // The result doesn't fit into Smi range. - var_fsub_lhs.Bind(SmiToFloat64(lhs)); - var_fsub_rhs.Bind(SmiToFloat64(rhs)); - Goto(&do_fsub); + var_fsub_lhs.Bind(assembler.SmiToFloat64(lhs)); + var_fsub_rhs.Bind(assembler.SmiToFloat64(rhs)); + assembler.Goto(&do_fsub); } - Bind(&if_notoverflow); - var_result.Bind(BitcastWordToTaggedSigned(Projection(0, pair))); - Goto(&end); + assembler.Bind(&if_notoverflow); + var_result.Bind( + assembler.BitcastWordToTaggedSigned(assembler.Projection(0, pair))); + assembler.Goto(&end); } - Bind(&if_rhsisnotsmi); + assembler.Bind(&if_rhsisnotsmi); { // Load the map of the {rhs}. - Node* rhs_map = LoadMap(rhs); + Node* rhs_map = assembler.LoadMap(rhs); // Check if {rhs} is a HeapNumber. - Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred); - Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber); + Label if_rhsisnumber(&assembler), + if_rhsisnotnumber(&assembler, Label::kDeferred); + assembler.Branch(assembler.IsHeapNumberMap(rhs_map), &if_rhsisnumber, + &if_rhsisnotnumber); - Bind(&if_rhsisnumber); + assembler.Bind(&if_rhsisnumber); { // Perform a floating point subtraction. - var_fsub_lhs.Bind(SmiToFloat64(lhs)); - var_fsub_rhs.Bind(LoadHeapNumberValue(rhs)); - Goto(&do_fsub); + var_fsub_lhs.Bind(assembler.SmiToFloat64(lhs)); + var_fsub_rhs.Bind(assembler.LoadHeapNumberValue(rhs)); + assembler.Goto(&do_fsub); } - Bind(&if_rhsisnotnumber); + assembler.Bind(&if_rhsisnotnumber); { // Convert the {rhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } } } - Bind(&if_lhsisnotsmi); + assembler.Bind(&if_lhsisnotsmi); { // Load the map of the {lhs}. - Node* lhs_map = LoadMap(lhs); + Node* lhs_map = assembler.LoadMap(lhs); // Check if the {lhs} is a HeapNumber. - Label if_lhsisnumber(this), if_lhsisnotnumber(this, Label::kDeferred); - Node* number_map = HeapNumberMapConstant(); - Branch(WordEqual(lhs_map, number_map), &if_lhsisnumber, - &if_lhsisnotnumber); + 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); - Bind(&if_lhsisnumber); + assembler.Bind(&if_lhsisnumber); { // Check if the {rhs} is a Smi. - Label if_rhsissmi(this), if_rhsisnotsmi(this); - Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi); + Label if_rhsissmi(&assembler), if_rhsisnotsmi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(rhs), &if_rhsissmi, + &if_rhsisnotsmi); - Bind(&if_rhsissmi); + assembler.Bind(&if_rhsissmi); { // Perform a floating point subtraction. - var_fsub_lhs.Bind(LoadHeapNumberValue(lhs)); - var_fsub_rhs.Bind(SmiToFloat64(rhs)); - Goto(&do_fsub); + var_fsub_lhs.Bind(assembler.LoadHeapNumberValue(lhs)); + var_fsub_rhs.Bind(assembler.SmiToFloat64(rhs)); + assembler.Goto(&do_fsub); } - Bind(&if_rhsisnotsmi); + assembler.Bind(&if_rhsisnotsmi); { // Load the map of the {rhs}. - Node* rhs_map = LoadMap(rhs); + Node* rhs_map = assembler.LoadMap(rhs); // Check if the {rhs} is a HeapNumber. - Label if_rhsisnumber(this), if_rhsisnotnumber(this, Label::kDeferred); - Branch(WordEqual(rhs_map, number_map), &if_rhsisnumber, - &if_rhsisnotnumber); + Label if_rhsisnumber(&assembler), + if_rhsisnotnumber(&assembler, Label::kDeferred); + assembler.Branch(assembler.WordEqual(rhs_map, number_map), + &if_rhsisnumber, &if_rhsisnotnumber); - Bind(&if_rhsisnumber); + assembler.Bind(&if_rhsisnumber); { // Perform a floating point subtraction. - var_fsub_lhs.Bind(LoadHeapNumberValue(lhs)); - var_fsub_rhs.Bind(LoadHeapNumberValue(rhs)); - Goto(&do_fsub); + var_fsub_lhs.Bind(assembler.LoadHeapNumberValue(lhs)); + var_fsub_rhs.Bind(assembler.LoadHeapNumberValue(rhs)); + assembler.Goto(&do_fsub); } - Bind(&if_rhsisnotnumber); + assembler.Bind(&if_rhsisnotnumber); { // Convert the {rhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_rhs.Bind(CallStub(callable, context, rhs)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_rhs.Bind(assembler.CallStub(callable, context, rhs)); + assembler.Goto(&loop); } } } - Bind(&if_lhsisnotnumber); + assembler.Bind(&if_lhsisnotnumber); { // Convert the {lhs} to a Number first. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_lhs.Bind(CallStub(callable, context, lhs)); - Goto(&loop); + Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate()); + var_lhs.Bind(assembler.CallStub(callable, context, lhs)); + assembler.Goto(&loop); } } } - Bind(&do_fsub); + assembler.Bind(&do_fsub); { Node* lhs_value = var_fsub_lhs.value(); Node* rhs_value = var_fsub_rhs.value(); - Node* value = Float64Sub(lhs_value, rhs_value); - var_result.Bind(AllocateHeapNumberWithValue(value)); - Goto(&end); + Node* value = assembler.Float64Sub(lhs_value, rhs_value); + var_result.Bind(assembler.AllocateHeapNumberWithValue(value)); + assembler.Goto(&end); } - Bind(&end); - Return(var_result.value()); + assembler.Bind(&end); + assembler.Return(var_result.value()); } -TF_BUILTIN(Multiply, CodeStubAssembler) { - Node* left = Parameter(0); - Node* right = Parameter(1); - Node* context = Parameter(2); +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); // Shared entry point for floating point multiplication. - Label do_fmul(this), return_result(this); - Variable var_lhs_float64(this, MachineRepresentation::kFloat64), - var_rhs_float64(this, MachineRepresentation::kFloat64); + Label do_fmul(&assembler), return_result(&assembler); + Variable var_lhs_float64(&assembler, MachineRepresentation::kFloat64), + var_rhs_float64(&assembler, MachineRepresentation::kFloat64); - Node* number_map = HeapNumberMapConstant(); + Node* number_map = assembler.HeapNumberMapConstant(); // We might need to loop one or two times due to ToNumber conversions. - Variable var_lhs(this, MachineRepresentation::kTagged), - var_rhs(this, MachineRepresentation::kTagged), - var_result(this, MachineRepresentation::kTagged); + Variable var_lhs(&assembler, MachineRepresentation::kTagged), + var_rhs(&assembler, MachineRepresentation::kTagged), + var_result(&assembler, MachineRepresentation::kTagged); Variable* loop_variables[] = {&var_lhs, &var_rhs}; - Label loop(this, 2, loop_variables); + Label loop(&assembler, 2, loop_variables); var_lhs.Bind(left); var_rhs.Bind(right); - Goto(&loop); - Bind(&loop); + assembler.Goto(&loop); + assembler.Bind(&loop); { Node* lhs = var_lhs.value(); Node* rhs = var_rhs.value(); - Label lhs_is_smi(this), lhs_is_not_smi(this); - Branch(TaggedIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi); + Label lhs_is_smi(&assembler), lhs_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi); - Bind(&lhs_is_smi); + assembler.Bind(&lhs_is_smi); { - Label rhs_is_smi(this), rhs_is_not_smi(this); - Branch(TaggedIsSmi(rhs), &rhs_is_smi, &rhs_is_not_smi); + Label rhs_is_smi(&assembler), rhs_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(rhs), &rhs_is_smi, + &rhs_is_not_smi); - Bind(&rhs_is_smi); + assembler.Bind(&rhs_is_smi); { // Both {lhs} and {rhs} are Smis. The result is not necessarily a smi, // in case of overflow. - var_result.Bind(SmiMul(lhs, rhs)); - Goto(&return_result); + var_result.Bind(assembler.SmiMul(lhs, rhs)); + assembler.Goto(&return_result); } - Bind(&rhs_is_not_smi); + assembler.Bind(&rhs_is_not_smi); { - Node* rhs_map = LoadMap(rhs); + Node* rhs_map = assembler.LoadMap(rhs); // Check if {rhs} is a HeapNumber. - 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); + 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); - Bind(&rhs_is_number); + assembler.Bind(&rhs_is_number); { // Convert {lhs} to a double and multiply it with the value of {rhs}. - var_lhs_float64.Bind(SmiToFloat64(lhs)); - var_rhs_float64.Bind(LoadHeapNumberValue(rhs)); - Goto(&do_fmul); + var_lhs_float64.Bind(assembler.SmiToFloat64(lhs)); + var_rhs_float64.Bind(assembler.LoadHeapNumberValue(rhs)); + assembler.Goto(&do_fmul); } - Bind(&rhs_is_not_number); + assembler.Bind(&rhs_is_not_number); { // Multiplication is commutative, swap {lhs} with {rhs} and loop. var_lhs.Bind(rhs); var_rhs.Bind(lhs); - Goto(&loop); + assembler.Goto(&loop); } } } - Bind(&lhs_is_not_smi); + assembler.Bind(&lhs_is_not_smi); { - Node* lhs_map = LoadMap(lhs); + Node* lhs_map = assembler.LoadMap(lhs); // Check if {lhs} is a HeapNumber. - 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); + 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); - Bind(&lhs_is_number); + assembler.Bind(&lhs_is_number); { // Check if {rhs} is a Smi. - Label rhs_is_smi(this), rhs_is_not_smi(this); - Branch(TaggedIsSmi(rhs), &rhs_is_smi, &rhs_is_not_smi); + Label rhs_is_smi(&assembler), rhs_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(rhs), &rhs_is_smi, + &rhs_is_not_smi); - Bind(&rhs_is_smi); + assembler.Bind(&rhs_is_smi); { // Convert {rhs} to a double and multiply it with the value of {lhs}. - var_lhs_float64.Bind(LoadHeapNumberValue(lhs)); - var_rhs_float64.Bind(SmiToFloat64(rhs)); - Goto(&do_fmul); + var_lhs_float64.Bind(assembler.LoadHeapNumberValue(lhs)); + var_rhs_float64.Bind(assembler.SmiToFloat64(rhs)); + assembler.Goto(&do_fmul); } - Bind(&rhs_is_not_smi); + assembler.Bind(&rhs_is_not_smi); { - Node* rhs_map = LoadMap(rhs); + Node* rhs_map = assembler.LoadMap(rhs); // Check if {rhs} is a HeapNumber. - 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); + 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); - Bind(&rhs_is_number); + assembler.Bind(&rhs_is_number); { // Both {lhs} and {rhs} are HeapNumbers. Load their values and // multiply them. - var_lhs_float64.Bind(LoadHeapNumberValue(lhs)); - var_rhs_float64.Bind(LoadHeapNumberValue(rhs)); - Goto(&do_fmul); + var_lhs_float64.Bind(assembler.LoadHeapNumberValue(lhs)); + var_rhs_float64.Bind(assembler.LoadHeapNumberValue(rhs)); + assembler.Goto(&do_fmul); } - Bind(&rhs_is_not_number); + assembler.Bind(&rhs_is_not_number); { // Multiplication is commutative, swap {lhs} with {rhs} and loop. var_lhs.Bind(rhs); var_rhs.Bind(lhs); - Goto(&loop); + assembler.Goto(&loop); } } } - Bind(&lhs_is_not_number); + assembler.Bind(&lhs_is_not_number); { // Convert {lhs} to a Number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_lhs.Bind(CallStub(callable, context, lhs)); - Goto(&loop); + Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate()); + var_lhs.Bind(assembler.CallStub(callable, context, lhs)); + assembler.Goto(&loop); } } } - Bind(&do_fmul); + assembler.Bind(&do_fmul); { - Node* value = Float64Mul(var_lhs_float64.value(), var_rhs_float64.value()); - Node* result = AllocateHeapNumberWithValue(value); + Node* value = + assembler.Float64Mul(var_lhs_float64.value(), var_rhs_float64.value()); + Node* result = assembler.AllocateHeapNumberWithValue(value); var_result.Bind(result); - Goto(&return_result); + assembler.Goto(&return_result); } - Bind(&return_result); - Return(var_result.value()); + assembler.Bind(&return_result); + assembler.Return(var_result.value()); } -TF_BUILTIN(Divide, CodeStubAssembler) { - Node* left = Parameter(0); - Node* right = Parameter(1); - Node* context = Parameter(2); +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); // Shared entry point for floating point division. - Label do_fdiv(this), end(this); - Variable var_dividend_float64(this, MachineRepresentation::kFloat64), - var_divisor_float64(this, MachineRepresentation::kFloat64); + Label do_fdiv(&assembler), end(&assembler); + Variable var_dividend_float64(&assembler, MachineRepresentation::kFloat64), + var_divisor_float64(&assembler, MachineRepresentation::kFloat64); - Node* number_map = HeapNumberMapConstant(); + Node* number_map = assembler.HeapNumberMapConstant(); // We might need to loop one or two times due to ToNumber conversions. - Variable var_dividend(this, MachineRepresentation::kTagged), - var_divisor(this, MachineRepresentation::kTagged), - var_result(this, MachineRepresentation::kTagged); + Variable var_dividend(&assembler, MachineRepresentation::kTagged), + var_divisor(&assembler, MachineRepresentation::kTagged), + var_result(&assembler, MachineRepresentation::kTagged); Variable* loop_variables[] = {&var_dividend, &var_divisor}; - Label loop(this, 2, loop_variables); + Label loop(&assembler, 2, loop_variables); var_dividend.Bind(left); var_divisor.Bind(right); - Goto(&loop); - Bind(&loop); + assembler.Goto(&loop); + assembler.Bind(&loop); { Node* dividend = var_dividend.value(); Node* divisor = var_divisor.value(); - Label dividend_is_smi(this), dividend_is_not_smi(this); - Branch(TaggedIsSmi(dividend), ÷nd_is_smi, ÷nd_is_not_smi); + Label dividend_is_smi(&assembler), dividend_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(dividend), ÷nd_is_smi, + ÷nd_is_not_smi); - Bind(÷nd_is_smi); + assembler.Bind(÷nd_is_smi); { - Label divisor_is_smi(this), divisor_is_not_smi(this); - Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi); + Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi, + &divisor_is_not_smi); - Bind(&divisor_is_smi); + assembler.Bind(&divisor_is_smi); { - Label bailout(this); + Label bailout(&assembler); // Do floating point division if {divisor} is zero. - GotoIf(WordEqual(divisor, IntPtrConstant(0)), &bailout); + assembler.GotoIf( + assembler.WordEqual(divisor, assembler.IntPtrConstant(0)), + &bailout); // Do floating point division {dividend} is zero and {divisor} is // negative. - Label dividend_is_zero(this), dividend_is_not_zero(this); - Branch(WordEqual(dividend, IntPtrConstant(0)), ÷nd_is_zero, - ÷nd_is_not_zero); + 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); - Bind(÷nd_is_zero); + assembler.Bind(÷nd_is_zero); { - GotoIf(IntPtrLessThan(divisor, IntPtrConstant(0)), &bailout); - Goto(÷nd_is_not_zero); + assembler.GotoIf( + assembler.IntPtrLessThan(divisor, assembler.IntPtrConstant(0)), + &bailout); + assembler.Goto(÷nd_is_not_zero); } - Bind(÷nd_is_not_zero); + assembler.Bind(÷nd_is_not_zero); - Node* untagged_divisor = SmiUntag(divisor); - Node* untagged_dividend = SmiUntag(dividend); + Node* untagged_divisor = assembler.SmiUntag(divisor); + Node* untagged_dividend = assembler.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(this), divisor_is_not_minus_one(this); - Branch(Word32Equal(untagged_divisor, Int32Constant(-1)), - &divisor_is_minus_one, &divisor_is_not_minus_one); + 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); - Bind(&divisor_is_minus_one); + assembler.Bind(&divisor_is_minus_one); { - GotoIf( - Word32Equal(untagged_dividend, - Int32Constant(kSmiValueSize == 32 ? kMinInt - : (kMinInt >> 1))), + assembler.GotoIf( + assembler.Word32Equal( + untagged_dividend, + assembler.Int32Constant( + kSmiValueSize == 32 ? kMinInt : (kMinInt >> 1))), &bailout); - Goto(&divisor_is_not_minus_one); + assembler.Goto(&divisor_is_not_minus_one); } - Bind(&divisor_is_not_minus_one); + assembler.Bind(&divisor_is_not_minus_one); // TODO(epertoso): consider adding a machine instruction that returns // both the result and the remainder. - Node* untagged_result = Int32Div(untagged_dividend, untagged_divisor); - Node* truncated = Int32Mul(untagged_result, untagged_divisor); + Node* untagged_result = + assembler.Int32Div(untagged_dividend, untagged_divisor); + Node* truncated = assembler.Int32Mul(untagged_result, untagged_divisor); // Do floating point division if the remainder is not 0. - GotoIf(Word32NotEqual(untagged_dividend, truncated), &bailout); - var_result.Bind(SmiTag(untagged_result)); - Goto(&end); + assembler.GotoIf(assembler.Word32NotEqual(untagged_dividend, truncated), + &bailout); + var_result.Bind(assembler.SmiTag(untagged_result)); + assembler.Goto(&end); // Bailout: convert {dividend} and {divisor} to double and do double // division. - Bind(&bailout); + assembler.Bind(&bailout); { - var_dividend_float64.Bind(SmiToFloat64(dividend)); - var_divisor_float64.Bind(SmiToFloat64(divisor)); - Goto(&do_fdiv); + var_dividend_float64.Bind(assembler.SmiToFloat64(dividend)); + var_divisor_float64.Bind(assembler.SmiToFloat64(divisor)); + assembler.Goto(&do_fdiv); } } - Bind(&divisor_is_not_smi); + assembler.Bind(&divisor_is_not_smi); { - Node* divisor_map = LoadMap(divisor); + Node* divisor_map = assembler.LoadMap(divisor); // Check if {divisor} is a HeapNumber. - 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); + 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); - Bind(&divisor_is_number); + assembler.Bind(&divisor_is_number); { // Convert {dividend} to a double and divide it with the value of // {divisor}. - var_dividend_float64.Bind(SmiToFloat64(dividend)); - var_divisor_float64.Bind(LoadHeapNumberValue(divisor)); - Goto(&do_fdiv); + var_dividend_float64.Bind(assembler.SmiToFloat64(dividend)); + var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor)); + assembler.Goto(&do_fdiv); } - Bind(&divisor_is_not_number); + assembler.Bind(&divisor_is_not_number); { // Convert {divisor} to a number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_divisor.Bind(CallStub(callable, context, divisor)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_divisor.Bind(assembler.CallStub(callable, context, divisor)); + assembler.Goto(&loop); } } } - Bind(÷nd_is_not_smi); + assembler.Bind(÷nd_is_not_smi); { - Node* dividend_map = LoadMap(dividend); + Node* dividend_map = assembler.LoadMap(dividend); // Check if {dividend} is a HeapNumber. - 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); + 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); - Bind(÷nd_is_number); + assembler.Bind(÷nd_is_number); { // Check if {divisor} is a Smi. - Label divisor_is_smi(this), divisor_is_not_smi(this); - Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi); + Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi, + &divisor_is_not_smi); - Bind(&divisor_is_smi); + assembler.Bind(&divisor_is_smi); { // Convert {divisor} to a double and use it for a floating point // division. - var_dividend_float64.Bind(LoadHeapNumberValue(dividend)); - var_divisor_float64.Bind(SmiToFloat64(divisor)); - Goto(&do_fdiv); + var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend)); + var_divisor_float64.Bind(assembler.SmiToFloat64(divisor)); + assembler.Goto(&do_fdiv); } - Bind(&divisor_is_not_smi); + assembler.Bind(&divisor_is_not_smi); { - Node* divisor_map = LoadMap(divisor); + Node* divisor_map = assembler.LoadMap(divisor); // Check if {divisor} is a HeapNumber. - 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); + 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); - Bind(&divisor_is_number); + assembler.Bind(&divisor_is_number); { // Both {dividend} and {divisor} are HeapNumbers. Load their values // and divide them. - var_dividend_float64.Bind(LoadHeapNumberValue(dividend)); - var_divisor_float64.Bind(LoadHeapNumberValue(divisor)); - Goto(&do_fdiv); + var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend)); + var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor)); + assembler.Goto(&do_fdiv); } - Bind(&divisor_is_not_number); + assembler.Bind(&divisor_is_not_number); { // Convert {divisor} to a number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_divisor.Bind(CallStub(callable, context, divisor)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_divisor.Bind(assembler.CallStub(callable, context, divisor)); + assembler.Goto(&loop); } } } - Bind(÷nd_is_not_number); + assembler.Bind(÷nd_is_not_number); { // Convert {dividend} to a Number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_dividend.Bind(CallStub(callable, context, dividend)); - Goto(&loop); + Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate()); + var_dividend.Bind(assembler.CallStub(callable, context, dividend)); + assembler.Goto(&loop); } } } - Bind(&do_fdiv); + assembler.Bind(&do_fdiv); { - Node* value = - Float64Div(var_dividend_float64.value(), var_divisor_float64.value()); - var_result.Bind(AllocateHeapNumberWithValue(value)); - Goto(&end); + Node* value = assembler.Float64Div(var_dividend_float64.value(), + var_divisor_float64.value()); + var_result.Bind(assembler.AllocateHeapNumberWithValue(value)); + assembler.Goto(&end); } - Bind(&end); - Return(var_result.value()); + assembler.Bind(&end); + assembler.Return(var_result.value()); } -TF_BUILTIN(Modulus, CodeStubAssembler) { - Node* left = Parameter(0); - Node* right = Parameter(1); - Node* context = Parameter(2); +void Builtins::Generate_Modulus(compiler::CodeAssemblerState* state) { + typedef CodeStubAssembler::Label Label; + typedef compiler::Node Node; + typedef CodeStubAssembler::Variable Variable; + CodeStubAssembler assembler(state); - Variable var_result(this, MachineRepresentation::kTagged); - Label return_result(this, &var_result); + 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); // Shared entry point for floating point modulus. - Label do_fmod(this); - Variable var_dividend_float64(this, MachineRepresentation::kFloat64), - var_divisor_float64(this, MachineRepresentation::kFloat64); + Label do_fmod(&assembler); + Variable var_dividend_float64(&assembler, MachineRepresentation::kFloat64), + var_divisor_float64(&assembler, MachineRepresentation::kFloat64); - Node* number_map = HeapNumberMapConstant(); + Node* number_map = assembler.HeapNumberMapConstant(); // We might need to loop one or two times due to ToNumber conversions. - Variable var_dividend(this, MachineRepresentation::kTagged), - var_divisor(this, MachineRepresentation::kTagged); + Variable var_dividend(&assembler, MachineRepresentation::kTagged), + var_divisor(&assembler, MachineRepresentation::kTagged); Variable* loop_variables[] = {&var_dividend, &var_divisor}; - Label loop(this, 2, loop_variables); + Label loop(&assembler, 2, loop_variables); var_dividend.Bind(left); var_divisor.Bind(right); - Goto(&loop); - Bind(&loop); + assembler.Goto(&loop); + assembler.Bind(&loop); { Node* dividend = var_dividend.value(); Node* divisor = var_divisor.value(); - Label dividend_is_smi(this), dividend_is_not_smi(this); - Branch(TaggedIsSmi(dividend), ÷nd_is_smi, ÷nd_is_not_smi); + Label dividend_is_smi(&assembler), dividend_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(dividend), ÷nd_is_smi, + ÷nd_is_not_smi); - Bind(÷nd_is_smi); + assembler.Bind(÷nd_is_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); + 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); - Bind(&divisor_is_smi); + assembler.Bind(&divisor_is_smi); { // Compute the modulus of two Smis. - var_result.Bind(SmiMod(dividend, divisor)); - Goto(&return_result); + var_result.Bind(assembler.SmiMod(dividend, divisor)); + assembler.Goto(&return_result); } - Bind(&divisor_is_not_smi); + assembler.Bind(&divisor_is_not_smi); { - Node* divisor_map = LoadMap(divisor); + Node* divisor_map = assembler.LoadMap(divisor); // Check if {divisor} is a HeapNumber. - 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); + 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); - Bind(&divisor_is_number); + assembler.Bind(&divisor_is_number); { // Convert {dividend} to a double and compute its modulus with the // value of {dividend}. - var_dividend_float64.Bind(SmiToFloat64(dividend)); - var_divisor_float64.Bind(LoadHeapNumberValue(divisor)); - Goto(&do_fmod); + var_dividend_float64.Bind(assembler.SmiToFloat64(dividend)); + var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor)); + assembler.Goto(&do_fmod); } - Bind(&divisor_is_not_number); + assembler.Bind(&divisor_is_not_number); { // Convert {divisor} to a number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_divisor.Bind(CallStub(callable, context, divisor)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_divisor.Bind(assembler.CallStub(callable, context, divisor)); + assembler.Goto(&loop); } } } - Bind(÷nd_is_not_smi); + assembler.Bind(÷nd_is_not_smi); { - Node* dividend_map = LoadMap(dividend); + Node* dividend_map = assembler.LoadMap(dividend); // Check if {dividend} is a HeapNumber. - 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); + 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); - Bind(÷nd_is_number); + assembler.Bind(÷nd_is_number); { // Check if {divisor} is a Smi. - Label divisor_is_smi(this), divisor_is_not_smi(this); - Branch(TaggedIsSmi(divisor), &divisor_is_smi, &divisor_is_not_smi); + Label divisor_is_smi(&assembler), divisor_is_not_smi(&assembler); + assembler.Branch(assembler.TaggedIsSmi(divisor), &divisor_is_smi, + &divisor_is_not_smi); - Bind(&divisor_is_smi); + assembler.Bind(&divisor_is_smi); { // Convert {divisor} to a double and compute {dividend}'s modulus with // it. - var_dividend_float64.Bind(LoadHeapNumberValue(dividend)); - var_divisor_float64.Bind(SmiToFloat64(divisor)); - Goto(&do_fmod); + var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend)); + var_divisor_float64.Bind(assembler.SmiToFloat64(divisor)); + assembler.Goto(&do_fmod); } - Bind(&divisor_is_not_smi); + assembler.Bind(&divisor_is_not_smi); { - Node* divisor_map = LoadMap(divisor); + Node* divisor_map = assembler.LoadMap(divisor); // Check if {divisor} is a HeapNumber. - 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); + 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); - Bind(&divisor_is_number); + assembler.Bind(&divisor_is_number); { // Both {dividend} and {divisor} are HeapNumbers. Load their values // and compute their modulus. - var_dividend_float64.Bind(LoadHeapNumberValue(dividend)); - var_divisor_float64.Bind(LoadHeapNumberValue(divisor)); - Goto(&do_fmod); + var_dividend_float64.Bind(assembler.LoadHeapNumberValue(dividend)); + var_divisor_float64.Bind(assembler.LoadHeapNumberValue(divisor)); + assembler.Goto(&do_fmod); } - Bind(&divisor_is_not_number); + assembler.Bind(&divisor_is_not_number); { // Convert {divisor} to a number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_divisor.Bind(CallStub(callable, context, divisor)); - Goto(&loop); + Callable callable = + CodeFactory::NonNumberToNumber(assembler.isolate()); + var_divisor.Bind(assembler.CallStub(callable, context, divisor)); + assembler.Goto(&loop); } } } - Bind(÷nd_is_not_number); + assembler.Bind(÷nd_is_not_number); { // Convert {dividend} to a Number and loop. - Callable callable = CodeFactory::NonNumberToNumber(isolate()); - var_dividend.Bind(CallStub(callable, context, dividend)); - Goto(&loop); + Callable callable = CodeFactory::NonNumberToNumber(assembler.isolate()); + var_dividend.Bind(assembler.CallStub(callable, context, dividend)); + assembler.Goto(&loop); } } } - Bind(&do_fmod); + assembler.Bind(&do_fmod); { - Node* value = - Float64Mod(var_dividend_float64.value(), var_divisor_float64.value()); - var_result.Bind(AllocateHeapNumberWithValue(value)); - Goto(&return_result); + Node* value = assembler.Float64Mod(var_dividend_float64.value(), + var_divisor_float64.value()); + var_result.Bind(assembler.AllocateHeapNumberWithValue(value)); + assembler.Goto(&return_result); } - Bind(&return_result); - Return(var_result.value()); + assembler.Bind(&return_result); + assembler.Return(var_result.value()); } -TF_BUILTIN(ShiftLeft, NumberBuiltinsAssembler) { - BitwiseShiftOp([this](Node* lhs, Node* shift_count) { - return Word32Shl(lhs, shift_count); - }); +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(ShiftRight, NumberBuiltinsAssembler) { - BitwiseShiftOp([this](Node* lhs, Node* shift_count) { - return Word32Sar(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(ShiftRightLogical, NumberBuiltinsAssembler) { - BitwiseShiftOp([this](Node* lhs, Node* shift_count) { - return Word32Shr(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(BitwiseAnd, NumberBuiltinsAssembler) { - BitwiseOp([this](Node* lhs, Node* rhs) { return Word32And(lhs, rhs); }); +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(BitwiseOr, NumberBuiltinsAssembler) { - BitwiseOp([this](Node* lhs, Node* rhs) { return Word32Or(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(BitwiseXor, NumberBuiltinsAssembler) { - BitwiseOp([this](Node* lhs, Node* rhs) { return Word32Xor(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(LessThan, NumberBuiltinsAssembler) { - RelationalComparisonBuiltin(kLessThan); +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(LessThanOrEqual, NumberBuiltinsAssembler) { - RelationalComparisonBuiltin(kLessThanOrEqual); +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(GreaterThan, NumberBuiltinsAssembler) { - RelationalComparisonBuiltin(kGreaterThan); +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(GreaterThanOrEqual, NumberBuiltinsAssembler) { - RelationalComparisonBuiltin(kGreaterThanOrEqual); +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(Equal, CodeStubAssembler) { - Node* lhs = Parameter(0); - Node* rhs = Parameter(1); - Node* context = Parameter(2); +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); - Return(Equal(kDontNegateResult, lhs, rhs, context)); + assembler.Return( + assembler.Equal(CodeStubAssembler::kDontNegateResult, lhs, rhs, context)); } -TF_BUILTIN(NotEqual, CodeStubAssembler) { - Node* lhs = Parameter(0); - Node* rhs = Parameter(1); - Node* context = Parameter(2); +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); - Return(Equal(kNegateResult, lhs, rhs, context)); + assembler.Return( + assembler.Equal(CodeStubAssembler::kNegateResult, lhs, rhs, context)); } -TF_BUILTIN(StrictEqual, CodeStubAssembler) { - Node* lhs = Parameter(0); - Node* rhs = Parameter(1); - Node* context = Parameter(2); +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); - Return(StrictEqual(kDontNegateResult, lhs, rhs, context)); + assembler.Return(assembler.StrictEqual(CodeStubAssembler::kDontNegateResult, + lhs, rhs, context)); } -TF_BUILTIN(StrictNotEqual, CodeStubAssembler) { - Node* lhs = Parameter(0); - Node* rhs = Parameter(1); - Node* context = Parameter(2); +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); - Return(StrictEqual(kNegateResult, lhs, rhs, context)); + assembler.Return(assembler.StrictEqual(CodeStubAssembler::kNegateResult, lhs, + rhs, context)); } } // namespace internal diff --git a/src/builtins/builtins-utils.h b/src/builtins/builtins-utils.h index 80e0d29f17..6378fdfad5 100644 --- a/src/builtins/builtins-utils.h +++ b/src/builtins/builtins-utils.h @@ -101,31 +101,6 @@ class BuiltinArguments : public Arguments { MUST_USE_RESULT static Object* Builtin_Impl_##name(BuiltinArguments args, \ Isolate* isolate) -// ---------------------------------------------------------------------------- -// Support macro for defining builtins with Turbofan. -// ---------------------------------------------------------------------------- -// -// A builtin function is defined by writing: -// -// TF_BUILTIN(name, code_assember_base_class) { -// ... -// } -// -// In the body of the builtin function the arguments can be accessed -// as "Parameter(n)". -#define TF_BUILTIN(Name, AssemblerBase) \ - class Name##Assembler : public AssemblerBase { \ - public: \ - explicit Name##Assembler(compiler::CodeAssemblerState* state) \ - : AssemblerBase(state) {} \ - void Generate##Name(); \ - }; \ - void Builtins::Generate_##Name(compiler::CodeAssemblerState* state) { \ - Name##Assembler assembler(state); \ - assembler.Generate##Name(); \ - } \ - void Name##Assembler::Generate##Name() - // ---------------------------------------------------------------------------- #define CHECK_RECEIVER(Type, name, method) \