diff --git a/src/builtins/builtins-number-gen.cc b/src/builtins/builtins-number-gen.cc index 2aa996eba0..fc737b793b 100644 --- a/src/builtins/builtins-number-gen.cc +++ b/src/builtins/builtins-number-gen.cc @@ -22,57 +22,58 @@ class NumberBuiltinsAssembler : public CodeStubAssembler { protected: template void EmitBitwiseOp(Operation op) { - Node* left = Parameter(Descriptor::kLeft); - Node* right = Parameter(Descriptor::kRight); - Node* context = Parameter(Descriptor::kContext); + TNode left = CAST(Parameter(Descriptor::kLeft)); + TNode right = CAST(Parameter(Descriptor::kRight)); + TNode context = CAST(Parameter(Descriptor::kContext)); - VARIABLE(var_left_word32, MachineRepresentation::kWord32); - VARIABLE(var_right_word32, MachineRepresentation::kWord32); - VARIABLE(var_left_bigint, MachineRepresentation::kTagged, left); - VARIABLE(var_right_bigint, MachineRepresentation::kTagged); + TVARIABLE(Word32T, var_left_word32); + TVARIABLE(Word32T, var_right_word32); + TVARIABLE(Object, var_left_maybe_bigint, left); + TVARIABLE(Object, var_right_maybe_bigint); Label if_left_number(this), do_number_op(this); Label if_left_bigint(this), do_bigint_op(this); TaggedToWord32OrBigInt(context, left, &if_left_number, &var_left_word32, - &if_left_bigint, &var_left_bigint); + &if_left_bigint, &var_left_maybe_bigint); BIND(&if_left_number); TaggedToWord32OrBigInt(context, right, &do_number_op, &var_right_word32, - &do_bigint_op, &var_right_bigint); + &do_bigint_op, &var_right_maybe_bigint); BIND(&do_number_op); Return(BitwiseOp(var_left_word32.value(), var_right_word32.value(), op)); // BigInt cases. BIND(&if_left_bigint); - TaggedToNumeric(context, right, &do_bigint_op, &var_right_bigint); + TaggedToNumeric(context, right, &do_bigint_op, &var_right_maybe_bigint); BIND(&do_bigint_op); Return(CallRuntime(Runtime::kBigIntBinaryOp, context, - var_left_bigint.value(), var_right_bigint.value(), - SmiConstant(op))); + var_left_maybe_bigint.value(), + var_right_maybe_bigint.value(), SmiConstant(op))); } template void RelationalComparisonBuiltin(Operation op) { - Node* lhs = Parameter(Descriptor::kLeft); - Node* rhs = Parameter(Descriptor::kRight); - Node* context = Parameter(Descriptor::kContext); + TNode lhs = CAST(Parameter(Descriptor::kLeft)); + TNode rhs = CAST(Parameter(Descriptor::kRight)); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(RelationalComparison(op, lhs, rhs, context)); } template - void UnaryOp(Variable* var_input, Label* do_smi, Label* do_double, - Variable* var_input_double, Label* do_bigint); + void UnaryOp(TVariable* var_input, Label* do_smi, Label* do_double, + TVariable* var_input_double, Label* do_bigint); template - void BinaryOp(Label* smis, Variable* var_left, Variable* var_right, - Label* doubles, Variable* var_left_double, - Variable* var_right_double, Label* bigints); + void BinaryOp(Label* smis, TVariable* var_left, + TVariable* var_right, Label* doubles, + TVariable* var_left_double, + TVariable* var_right_double, Label* bigints); }; // ES6 #sec-number.isfinite TF_BUILTIN(NumberIsFinite, CodeStubAssembler) { - Node* number = Parameter(Descriptor::kNumber); + TNode number = CAST(Parameter(Descriptor::kNumber)); Label return_true(this), return_false(this); @@ -80,10 +81,11 @@ TF_BUILTIN(NumberIsFinite, CodeStubAssembler) { GotoIf(TaggedIsSmi(number), &return_true); // Check if {number} is a HeapNumber. - GotoIfNot(IsHeapNumber(number), &return_false); + TNode number_heap_object = CAST(number); + GotoIfNot(IsHeapNumber(number_heap_object), &return_false); // Check if {number} contains a finite, non-NaN value. - TNode number_value = LoadHeapNumberValue(number); + TNode number_value = LoadHeapNumberValue(number_heap_object); BranchIfFloat64IsNaN(Float64Sub(number_value, number_value), &return_false, &return_true); @@ -107,7 +109,7 @@ TF_BUILTIN(NumberIsInteger, CodeStubAssembler) { // ES6 #sec-number.isnan TF_BUILTIN(NumberIsNaN, CodeStubAssembler) { - Node* number = Parameter(Descriptor::kNumber); + TNode number = CAST(Parameter(Descriptor::kNumber)); Label return_true(this), return_false(this); @@ -115,10 +117,11 @@ TF_BUILTIN(NumberIsNaN, CodeStubAssembler) { GotoIf(TaggedIsSmi(number), &return_false); // Check if {number} is a HeapNumber. - GotoIfNot(IsHeapNumber(number), &return_false); + TNode number_heap_object = CAST(number); + GotoIfNot(IsHeapNumber(number_heap_object), &return_false); // Check if {number} contains a NaN value. - TNode number_value = LoadHeapNumberValue(number); + TNode number_value = LoadHeapNumberValue(number_heap_object); BranchIfFloat64IsNaN(number_value, &return_true, &return_false); BIND(&return_true); @@ -136,17 +139,16 @@ TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) { // ES6 #sec-number.parsefloat TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); // We might need to loop once for ToString conversion. - VARIABLE(var_input, MachineRepresentation::kTagged, - Parameter(Descriptor::kString)); + TVARIABLE(Object, var_input, CAST(Parameter(Descriptor::kString))); Label loop(this, &var_input); Goto(&loop); BIND(&loop); { // Load the current {input} value. - Node* input = var_input.value(); + TNode input = var_input.value(); // Check if the {input} is a HeapObject or a Smi. Label if_inputissmi(this), if_inputisnotsmi(this); @@ -161,8 +163,9 @@ TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { BIND(&if_inputisnotsmi); { // The {input} is a HeapObject, check if it's already a String. + TNode input_heap_object = CAST(input); Label if_inputisstring(this), if_inputisnotstring(this); - TNode input_map = LoadMap(input); + TNode input_map = LoadMap(input_heap_object); TNode input_instance_type = LoadMapInstanceType(input_map); Branch(IsStringInstanceType(input_instance_type), &if_inputisstring, &if_inputisnotstring); @@ -172,7 +175,7 @@ TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { // The {input} is already a String, check if {input} contains // a cached array index. Label if_inputcached(this), if_inputnotcached(this); - TNode input_hash = LoadNameHashField(input); + TNode input_hash = LoadNameHashField(CAST(input)); Branch(IsClearWord32(input_hash, Name::kDoesNotContainCachedArrayIndexMask), &if_inputcached, &if_inputnotcached); @@ -204,7 +207,7 @@ TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { { // The {input} is already a Number, take care of -0. Label if_inputiszero(this), if_inputisnotzero(this); - TNode input_value = LoadHeapNumberValue(input); + TNode input_value = LoadHeapNumberValue(input_heap_object); Branch(Float64Equal(input_value, Float64Constant(0.0)), &if_inputiszero, &if_inputisnotzero); @@ -219,7 +222,7 @@ TF_BUILTIN(NumberParseFloat, CodeStubAssembler) { { // Need to convert the {input} to String first. // TODO(bmeurer): This could be more efficient if necessary. - var_input.Bind(CallBuiltin(Builtins::kToString, context, input)); + var_input = CallBuiltin(Builtins::kToString, context, input); Goto(&loop); } } @@ -309,9 +312,9 @@ TF_BUILTIN(ParseInt, CodeStubAssembler) { // ES6 #sec-number.parseint TF_BUILTIN(NumberParseInt, CodeStubAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* input = Parameter(Descriptor::kString); - Node* radix = Parameter(Descriptor::kRadix); + TNode context = CAST(Parameter(Descriptor::kContext)); + TNode input = CAST(Parameter(Descriptor::kString)); + TNode radix = CAST(Parameter(Descriptor::kRadix)); Return(CallBuiltin(Builtins::kParseInt, context, input, radix)); } @@ -331,27 +334,29 @@ class AddStubAssembler : public CodeStubAssembler { : CodeStubAssembler(state) {} protected: - void ConvertReceiverAndLoop(Variable* var_value, Label* loop, Node* context) { + TNode ConvertReceiver(TNode js_receiver, + TNode context) { // Call ToPrimitive explicitly without hint (whereas ToNumber // would pass a "number" hint). Callable callable = CodeFactory::NonPrimitiveToPrimitive(isolate()); - var_value->Bind(CallStub(callable, context, var_value->value())); + return CallStub(callable, context, js_receiver); + } + + void ConvertNonReceiverAndLoop(TVariable* var_value, Label* loop, + TNode context) { + *var_value = + CallBuiltin(Builtins::kNonNumberToNumeric, context, var_value->value()); Goto(loop); } - void ConvertNonReceiverAndLoop(Variable* var_value, Label* loop, - Node* context) { - var_value->Bind(CallBuiltin(Builtins::kNonNumberToNumeric, context, - var_value->value())); - Goto(loop); - } - - void ConvertAndLoop(Variable* var_value, Node* instance_type, Label* loop, - Node* context) { + void ConvertAndLoop(TVariable* var_value, + TNode instance_type, Label* loop, + TNode context) { Label is_not_receiver(this, Label::kDeferred); GotoIfNot(IsJSReceiverInstanceType(instance_type), &is_not_receiver); - ConvertReceiverAndLoop(var_value, loop, context); + *var_value = ConvertReceiver(CAST(var_value->value()), context); + Goto(loop); BIND(&is_not_receiver); ConvertNonReceiverAndLoop(var_value, loop, context); @@ -359,30 +364,26 @@ class AddStubAssembler : public CodeStubAssembler { }; TF_BUILTIN(Add, AddStubAssembler) { - Node* context = Parameter(Descriptor::kContext); - VARIABLE(var_left, MachineRepresentation::kTagged, - Parameter(Descriptor::kLeft)); - VARIABLE(var_right, MachineRepresentation::kTagged, - Parameter(Descriptor::kRight)); + TNode context = CAST(Parameter(Descriptor::kContext)); + TVARIABLE(Object, var_left, CAST(Parameter(Descriptor::kLeft))); + TVARIABLE(Object, var_right, CAST(Parameter(Descriptor::kRight))); // Shared entry for floating point addition. Label do_double_add(this); - VARIABLE(var_left_double, MachineRepresentation::kFloat64); - VARIABLE(var_right_double, MachineRepresentation::kFloat64); + TVARIABLE(Float64T, var_left_double); + TVARIABLE(Float64T, var_right_double); // We might need to loop several times due to ToPrimitive, ToString and/or // ToNumeric conversions. - VARIABLE(var_result, MachineRepresentation::kTagged); - Variable* loop_vars[2] = {&var_left, &var_right}; - Label loop(this, 2, loop_vars), + Label loop(this, {&var_left, &var_right}), string_add_convert_left(this, Label::kDeferred), string_add_convert_right(this, Label::kDeferred), do_bigint_add(this, Label::kDeferred); Goto(&loop); BIND(&loop); { - Node* left = var_left.value(); - Node* right = var_right.value(); + TNode left = var_left.value(); + TNode right = var_right.value(); Label if_left_smi(this), if_left_heapobject(this); Branch(TaggedIsSmi(left), &if_left_smi, &if_left_heapobject); @@ -395,27 +396,30 @@ TF_BUILTIN(Add, AddStubAssembler) { BIND(&if_right_smi); { Label if_overflow(this); - TNode result = TrySmiAdd(CAST(left), CAST(right), &if_overflow); + TNode left_smi = CAST(left); + TNode right_smi = CAST(right); + TNode result = TrySmiAdd(left_smi, right_smi, &if_overflow); Return(result); BIND(&if_overflow); { - var_left_double.Bind(SmiToFloat64(left)); - var_right_double.Bind(SmiToFloat64(right)); + var_left_double = SmiToFloat64(left_smi); + var_right_double = SmiToFloat64(right_smi); Goto(&do_double_add); } } // if_right_smi BIND(&if_right_heapobject); { - TNode right_map = LoadMap(right); + TNode right_heap_object = CAST(right); + TNode right_map = LoadMap(right_heap_object); Label if_right_not_number(this, Label::kDeferred); GotoIfNot(IsHeapNumberMap(right_map), &if_right_not_number); // {right} is a HeapNumber. - var_left_double.Bind(SmiToFloat64(left)); - var_right_double.Bind(LoadHeapNumberValue(right)); + var_left_double = SmiToFloat64(CAST(left)); + var_right_double = LoadHeapNumberValue(right_heap_object); Goto(&do_double_add); BIND(&if_right_not_number); @@ -431,7 +435,8 @@ TF_BUILTIN(Add, AddStubAssembler) { BIND(&if_left_heapobject); { - TNode left_map = LoadMap(left); + TNode left_heap_object = CAST(left); + TNode left_map = LoadMap(left_heap_object); Label if_right_smi(this), if_right_heapobject(this); Branch(TaggedIsSmi(right), &if_right_smi, &if_right_heapobject); @@ -441,8 +446,8 @@ TF_BUILTIN(Add, AddStubAssembler) { GotoIfNot(IsHeapNumberMap(left_map), &if_left_not_number); // {left} is a HeapNumber, {right} is a Smi. - var_left_double.Bind(LoadHeapNumberValue(left)); - var_right_double.Bind(SmiToFloat64(right)); + var_left_double = LoadHeapNumberValue(left_heap_object); + var_right_double = SmiToFloat64(CAST(right)); Goto(&do_double_add); BIND(&if_left_not_number); @@ -458,7 +463,8 @@ TF_BUILTIN(Add, AddStubAssembler) { BIND(&if_right_heapobject); { - TNode right_map = LoadMap(right); + TNode right_heap_object = CAST(right); + TNode right_map = LoadMap(right_heap_object); Label if_left_number(this), if_left_not_number(this, Label::kDeferred); Branch(IsHeapNumberMap(left_map), &if_left_number, &if_left_not_number); @@ -469,8 +475,8 @@ TF_BUILTIN(Add, AddStubAssembler) { GotoIfNot(IsHeapNumberMap(right_map), &if_right_not_number); // Both {left} and {right} are HeapNumbers. - var_left_double.Bind(LoadHeapNumberValue(left)); - var_right_double.Bind(LoadHeapNumberValue(right)); + var_left_double = LoadHeapNumberValue(CAST(left)); + var_right_double = LoadHeapNumberValue(right_heap_object); Goto(&do_double_add); BIND(&if_right_not_number); @@ -499,7 +505,8 @@ TF_BUILTIN(Add, AddStubAssembler) { GotoIfNot(IsJSReceiverInstanceType(left_instance_type), &if_left_not_receiver); // {left} is a JSReceiver, convert it first. - ConvertReceiverAndLoop(&var_left, &loop, context); + var_left = ConvertReceiver(CAST(var_left.value()), context); + Goto(&loop); BIND(&if_left_bigint); { @@ -515,7 +522,8 @@ TF_BUILTIN(Add, AddStubAssembler) { &if_right_not_receiver); // {left} is a Primitive, but {right} is a JSReceiver, so convert // {right} with priority. - ConvertReceiverAndLoop(&var_right, &loop, context); + var_right = ConvertReceiver(CAST(var_right.value()), context); + Goto(&loop); BIND(&if_right_not_receiver); // Neither {left} nor {right} are JSReceivers. @@ -553,54 +561,46 @@ TF_BUILTIN(Add, AddStubAssembler) { } template -void NumberBuiltinsAssembler::UnaryOp(Variable* var_input, Label* do_smi, - Label* do_double, - Variable* var_input_double, +void NumberBuiltinsAssembler::UnaryOp(TVariable* var_input, + Label* do_smi, Label* do_double, + TVariable* var_input_double, Label* do_bigint) { - DCHECK_EQ(var_input->rep(), MachineRepresentation::kTagged); - DCHECK_IMPLIES(var_input_double != nullptr, - var_input_double->rep() == MachineRepresentation::kFloat64); - - Node* context = Parameter(Descriptor::kContext); - var_input->Bind(Parameter(Descriptor::kValue)); + TNode context = CAST(Parameter(Descriptor::kContext)); + *var_input = CAST(Parameter(Descriptor::kValue)); // We might need to loop for ToNumeric conversion. Label loop(this, {var_input}); Goto(&loop); BIND(&loop); - Node* input = var_input->value(); + TNode input = var_input->value(); Label not_number(this); GotoIf(TaggedIsSmi(input), do_smi); - GotoIfNot(IsHeapNumber(input), ¬_number); + TNode input_heap_object = CAST(input); + GotoIfNot(IsHeapNumber(input_heap_object), ¬_number); if (var_input_double != nullptr) { - var_input_double->Bind(LoadHeapNumberValue(input)); + *var_input_double = LoadHeapNumberValue(input_heap_object); } Goto(do_double); BIND(¬_number); - GotoIf(IsBigInt(input), do_bigint); - var_input->Bind(CallBuiltin(Builtins::kNonNumberToNumeric, context, input)); + GotoIf(IsBigInt(input_heap_object), do_bigint); + *var_input = CallBuiltin(Builtins::kNonNumberToNumeric, context, input); Goto(&loop); } template -void NumberBuiltinsAssembler::BinaryOp(Label* smis, Variable* var_left, - Variable* var_right, Label* doubles, - Variable* var_left_double, - Variable* var_right_double, +void NumberBuiltinsAssembler::BinaryOp(Label* smis, TVariable* var_left, + TVariable* var_right, + Label* doubles, + TVariable* var_left_double, + TVariable* var_right_double, Label* bigints) { - DCHECK_EQ(var_left->rep(), MachineRepresentation::kTagged); - DCHECK_EQ(var_right->rep(), MachineRepresentation::kTagged); - DCHECK_IMPLIES(var_left_double != nullptr, - var_left_double->rep() == MachineRepresentation::kFloat64); - DCHECK_IMPLIES(var_right_double != nullptr, - var_right_double->rep() == MachineRepresentation::kFloat64); DCHECK_EQ(var_left_double == nullptr, var_right_double == nullptr); - Node* context = Parameter(Descriptor::kContext); - var_left->Bind(Parameter(Descriptor::kLeft)); - var_right->Bind(Parameter(Descriptor::kRight)); + TNode context = CAST(Parameter(Descriptor::kContext)); + *var_left = CAST(Parameter(Descriptor::kLeft)); + *var_right = CAST(Parameter(Descriptor::kRight)); // We might need to loop for ToNumeric conversions. Label loop(this, {var_left, var_right}); @@ -613,32 +613,36 @@ void NumberBuiltinsAssembler::BinaryOp(Label* smis, Variable* var_left, GotoIf(TaggedIsSmi(var_right->value()), smis); // At this point, var_left is a Smi but var_right is not. - GotoIfNot(IsHeapNumber(var_right->value()), &right_not_number); + TNode var_left_smi = CAST(var_left->value()); + TNode var_right_heap_object = CAST(var_right->value()); + GotoIfNot(IsHeapNumber(var_right_heap_object), &right_not_number); if (var_left_double != nullptr) { - var_left_double->Bind(SmiToFloat64(var_left->value())); - var_right_double->Bind(LoadHeapNumberValue(var_right->value())); + *var_left_double = SmiToFloat64(var_left_smi); + *var_right_double = LoadHeapNumberValue(var_right_heap_object); } Goto(doubles); BIND(&left_not_smi); { - GotoIfNot(IsHeapNumber(var_left->value()), &left_not_number); + TNode var_left_heap_object = CAST(var_left->value()); + GotoIfNot(IsHeapNumber(var_left_heap_object), &left_not_number); GotoIfNot(TaggedIsSmi(var_right->value()), &right_not_smi); // At this point, var_left is a HeapNumber and var_right is a Smi. if (var_left_double != nullptr) { - var_left_double->Bind(LoadHeapNumberValue(var_left->value())); - var_right_double->Bind(SmiToFloat64(var_right->value())); + *var_left_double = LoadHeapNumberValue(var_left_heap_object); + *var_right_double = SmiToFloat64(CAST(var_right->value())); } Goto(doubles); } BIND(&right_not_smi); { - GotoIfNot(IsHeapNumber(var_right->value()), &right_not_number); + TNode var_right_heap_object = CAST(var_right->value()); + GotoIfNot(IsHeapNumber(var_right_heap_object), &right_not_number); if (var_left_double != nullptr) { - var_left_double->Bind(LoadHeapNumberValue(var_left->value())); - var_right_double->Bind(LoadHeapNumberValue(var_right->value())); + *var_left_double = LoadHeapNumberValue(CAST(var_left->value())); + *var_right_double = LoadHeapNumberValue(var_right_heap_object); } Goto(doubles); } @@ -646,37 +650,38 @@ void NumberBuiltinsAssembler::BinaryOp(Label* smis, Variable* var_left, BIND(&left_not_number); { Label left_bigint(this); - GotoIf(IsBigInt(var_left->value()), &left_bigint); - var_left->Bind( - CallBuiltin(Builtins::kNonNumberToNumeric, context, var_left->value())); + GotoIf(IsBigInt(CAST(var_left->value())), &left_bigint); + *var_left = + CallBuiltin(Builtins::kNonNumberToNumeric, context, var_left->value()); Goto(&loop); BIND(&left_bigint); { // Jump to {bigints} if {var_right} is already a Numeric. GotoIf(TaggedIsSmi(var_right->value()), bigints); - GotoIf(IsBigInt(var_right->value()), bigints); - GotoIf(IsHeapNumber(var_right->value()), bigints); - var_right->Bind(CallBuiltin(Builtins::kNonNumberToNumeric, context, - var_right->value())); + TNode var_right_heap_object = CAST(var_right->value()); + GotoIf(IsBigInt(var_right_heap_object), bigints); + GotoIf(IsHeapNumber(var_right_heap_object), bigints); + *var_right = CallBuiltin(Builtins::kNonNumberToNumeric, context, + var_right->value()); Goto(&loop); } } BIND(&right_not_number); { - GotoIf(IsBigInt(var_right->value()), bigints); - var_right->Bind(CallBuiltin(Builtins::kNonNumberToNumeric, context, - var_right->value())); + GotoIf(IsBigInt(CAST(var_right->value())), bigints); + *var_right = + CallBuiltin(Builtins::kNonNumberToNumeric, context, var_right->value()); Goto(&loop); } } TF_BUILTIN(Subtract, NumberBuiltinsAssembler) { - VARIABLE(var_left, MachineRepresentation::kTagged); - VARIABLE(var_right, MachineRepresentation::kTagged); - VARIABLE(var_left_double, MachineRepresentation::kFloat64); - VARIABLE(var_right_double, MachineRepresentation::kFloat64); + TVARIABLE(Object, var_left); + TVARIABLE(Object, var_right); + TVARIABLE(Float64T, var_left_double); + TVARIABLE(Float64T, var_right_double); Label do_smi_sub(this), do_double_sub(this), do_bigint_sub(this); BinaryOp(&do_smi_sub, &var_left, &var_right, &do_double_sub, @@ -685,14 +690,15 @@ TF_BUILTIN(Subtract, NumberBuiltinsAssembler) { BIND(&do_smi_sub); { Label if_overflow(this); - TNode result = TrySmiSub(CAST(var_left.value()), - CAST(var_right.value()), &if_overflow); + TNode var_left_smi = CAST(var_left.value()); + TNode var_right_smi = CAST(var_right.value()); + TNode result = TrySmiSub(var_left_smi, var_right_smi, &if_overflow); Return(result); BIND(&if_overflow); { - var_left_double.Bind(SmiToFloat64(var_left.value())); - var_right_double.Bind(SmiToFloat64(var_right.value())); + var_left_double = SmiToFloat64(var_left_smi); + var_right_double = SmiToFloat64(var_right_smi); Goto(&do_double_sub); } } @@ -706,15 +712,15 @@ TF_BUILTIN(Subtract, NumberBuiltinsAssembler) { BIND(&do_bigint_sub); { - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(CallRuntime(Runtime::kBigIntBinaryOp, context, var_left.value(), var_right.value(), SmiConstant(Operation::kSubtract))); } } TF_BUILTIN(BitwiseNot, NumberBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - VARIABLE(var_input, MachineRepresentation::kTagged); + TNode context = CAST(Parameter(Descriptor::kContext)); + TVARIABLE(Object, var_input); Label do_number(this), do_bigint(this); UnaryOp(&var_input, &do_number, &do_number, nullptr, &do_bigint); @@ -733,8 +739,8 @@ TF_BUILTIN(BitwiseNot, NumberBuiltinsAssembler) { } TF_BUILTIN(Decrement, NumberBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - VARIABLE(var_input, MachineRepresentation::kTagged); + TNode context = CAST(Parameter(Descriptor::kContext)); + TVARIABLE(Object, var_input); Label do_number(this), do_bigint(this); UnaryOp(&var_input, &do_number, &do_number, nullptr, &do_bigint); @@ -753,8 +759,8 @@ TF_BUILTIN(Decrement, NumberBuiltinsAssembler) { } TF_BUILTIN(Increment, NumberBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - VARIABLE(var_input, MachineRepresentation::kTagged); + TNode context = CAST(Parameter(Descriptor::kContext)); + TVARIABLE(Object, var_input); Label do_number(this), do_bigint(this); UnaryOp(&var_input, &do_number, &do_number, nullptr, &do_bigint); @@ -772,8 +778,8 @@ TF_BUILTIN(Increment, NumberBuiltinsAssembler) { } TF_BUILTIN(Negate, NumberBuiltinsAssembler) { - VARIABLE(var_input, MachineRepresentation::kTagged); - VARIABLE(var_input_double, MachineRepresentation::kFloat64); + TVARIABLE(Object, var_input); + TVARIABLE(Float64T, var_input_double); Label do_smi(this), do_double(this), do_bigint(this); UnaryOp(&var_input, &do_smi, &do_double, &var_input_double, @@ -791,17 +797,17 @@ TF_BUILTIN(Negate, NumberBuiltinsAssembler) { BIND(&do_bigint); { - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(CallRuntime(Runtime::kBigIntUnaryOp, context, var_input.value(), SmiConstant(Operation::kNegate))); } } TF_BUILTIN(Multiply, NumberBuiltinsAssembler) { - VARIABLE(var_left, MachineRepresentation::kTagged); - VARIABLE(var_right, MachineRepresentation::kTagged); - VARIABLE(var_left_double, MachineRepresentation::kFloat64); - VARIABLE(var_right_double, MachineRepresentation::kFloat64); + TVARIABLE(Object, var_left); + TVARIABLE(Object, var_right); + TVARIABLE(Float64T, var_left_double); + TVARIABLE(Float64T, var_right_double); Label do_smi_mul(this), do_double_mul(this), do_bigint_mul(this); BinaryOp(&do_smi_mul, &var_left, &var_right, &do_double_mul, @@ -818,17 +824,17 @@ TF_BUILTIN(Multiply, NumberBuiltinsAssembler) { BIND(&do_bigint_mul); { - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(CallRuntime(Runtime::kBigIntBinaryOp, context, var_left.value(), var_right.value(), SmiConstant(Operation::kMultiply))); } } TF_BUILTIN(Divide, NumberBuiltinsAssembler) { - VARIABLE(var_left, MachineRepresentation::kTagged); - VARIABLE(var_right, MachineRepresentation::kTagged); - VARIABLE(var_left_double, MachineRepresentation::kFloat64); - VARIABLE(var_right_double, MachineRepresentation::kFloat64); + TVARIABLE(Object, var_left); + TVARIABLE(Object, var_right); + TVARIABLE(Float64T, var_left_double); + TVARIABLE(Float64T, var_right_double); Label do_smi_div(this), do_double_div(this), do_bigint_div(this); BinaryOp(&do_smi_div, &var_left, &var_right, &do_double_div, @@ -889,8 +895,8 @@ TF_BUILTIN(Divide, NumberBuiltinsAssembler) { // division. BIND(&bailout); { - var_left_double.Bind(SmiToFloat64(dividend)); - var_right_double.Bind(SmiToFloat64(divisor)); + var_left_double = SmiToFloat64(dividend); + var_right_double = SmiToFloat64(divisor); Goto(&do_double_div); } } @@ -904,17 +910,17 @@ TF_BUILTIN(Divide, NumberBuiltinsAssembler) { BIND(&do_bigint_div); { - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(CallRuntime(Runtime::kBigIntBinaryOp, context, var_left.value(), var_right.value(), SmiConstant(Operation::kDivide))); } } TF_BUILTIN(Modulus, NumberBuiltinsAssembler) { - VARIABLE(var_left, MachineRepresentation::kTagged); - VARIABLE(var_right, MachineRepresentation::kTagged); - VARIABLE(var_left_double, MachineRepresentation::kFloat64); - VARIABLE(var_right_double, MachineRepresentation::kFloat64); + TVARIABLE(Object, var_left); + TVARIABLE(Object, var_right); + TVARIABLE(Float64T, var_left_double); + TVARIABLE(Float64T, var_right_double); Label do_smi_mod(this), do_double_mod(this), do_bigint_mod(this); BinaryOp(&do_smi_mod, &var_left, &var_right, &do_double_mod, @@ -930,17 +936,17 @@ TF_BUILTIN(Modulus, NumberBuiltinsAssembler) { BIND(&do_bigint_mod); { - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(CallRuntime(Runtime::kBigIntBinaryOp, context, var_left.value(), var_right.value(), SmiConstant(Operation::kModulus))); } } TF_BUILTIN(Exponentiate, NumberBuiltinsAssembler) { - VARIABLE(var_left, MachineRepresentation::kTagged); - VARIABLE(var_right, MachineRepresentation::kTagged); + TVARIABLE(Object, var_left); + TVARIABLE(Object, var_right); Label do_number_exp(this), do_bigint_exp(this); - Node* context = Parameter(Descriptor::kContext); + TNode context = CAST(Parameter(Descriptor::kContext)); BinaryOp(&do_number_exp, &var_left, &var_right, &do_number_exp, nullptr, nullptr, &do_bigint_exp); @@ -997,9 +1003,9 @@ TF_BUILTIN(GreaterThanOrEqual, NumberBuiltinsAssembler) { } TF_BUILTIN(Equal, CodeStubAssembler) { - Node* lhs = Parameter(Descriptor::kLeft); - Node* rhs = Parameter(Descriptor::kRight); - Node* context = Parameter(Descriptor::kContext); + TNode lhs = CAST(Parameter(Descriptor::kLeft)); + TNode rhs = CAST(Parameter(Descriptor::kRight)); + TNode context = CAST(Parameter(Descriptor::kContext)); Return(Equal(lhs, rhs, context)); } diff --git a/src/codegen/code-stub-assembler.cc b/src/codegen/code-stub-assembler.cc index bd7958ac17..8ad66de442 100644 --- a/src/codegen/code-stub-assembler.cc +++ b/src/codegen/code-stub-assembler.cc @@ -5629,48 +5629,43 @@ TNode CodeStubAssembler::TruncateTaggedToFloat64( TNode CodeStubAssembler::TruncateTaggedToWord32( SloppyTNode context, SloppyTNode value) { - VARIABLE(var_result, MachineRepresentation::kWord32); + TVARIABLE(Word32T, var_result); Label done(this); TaggedToWord32OrBigIntImpl(context, value, &done, &var_result); BIND(&done); - return UncheckedCast(var_result.value()); + return var_result.value(); } // Truncate {value} to word32 and jump to {if_number} if it is a Number, // or find that it is a BigInt and jump to {if_bigint}. -void CodeStubAssembler::TaggedToWord32OrBigInt(Node* context, Node* value, - Label* if_number, - Variable* var_word32, - Label* if_bigint, - Variable* var_bigint) { +void CodeStubAssembler::TaggedToWord32OrBigInt( + TNode context, TNode value, Label* if_number, + TVariable* var_word32, Label* if_bigint, + TVariable* var_maybe_bigint) { TaggedToWord32OrBigIntImpl( - context, value, if_number, var_word32, if_bigint, var_bigint); + context, value, if_number, var_word32, if_bigint, var_maybe_bigint); } // Truncate {value} to word32 and jump to {if_number} if it is a Number, // or find that it is a BigInt and jump to {if_bigint}. In either case, // store the type feedback in {var_feedback}. void CodeStubAssembler::TaggedToWord32OrBigIntWithFeedback( - Node* context, Node* value, Label* if_number, Variable* var_word32, - Label* if_bigint, Variable* var_bigint, Variable* var_feedback) { + TNode context, TNode value, Label* if_number, + TVariable* var_word32, Label* if_bigint, + TVariable* var_maybe_bigint, TVariable* var_feedback) { TaggedToWord32OrBigIntImpl( - context, value, if_number, var_word32, if_bigint, var_bigint, + context, value, if_number, var_word32, if_bigint, var_maybe_bigint, var_feedback); } template void CodeStubAssembler::TaggedToWord32OrBigIntImpl( - Node* context, Node* value, Label* if_number, Variable* var_word32, - Label* if_bigint, Variable* var_bigint, Variable* var_feedback) { - DCHECK(var_word32->rep() == MachineRepresentation::kWord32); - DCHECK(var_bigint == nullptr || - var_bigint->rep() == MachineRepresentation::kTagged); - DCHECK(var_feedback == nullptr || - var_feedback->rep() == MachineRepresentation::kTaggedSigned); - + TNode context, TNode value, Label* if_number, + TVariable* var_word32, Label* if_bigint, + TVariable* var_maybe_bigint, TVariable* var_feedback) { // We might need to loop after conversion. - VARIABLE(var_value, MachineRepresentation::kTagged, value); + TVARIABLE(Object, var_value, value); OverwriteFeedback(var_feedback, BinaryOperationFeedback::kNone); Variable* loop_vars[] = {&var_value, var_feedback}; int num_vars = @@ -5685,12 +5680,13 @@ void CodeStubAssembler::TaggedToWord32OrBigIntImpl( GotoIf(TaggedIsNotSmi(value), ¬_smi); // {value} is a Smi. - var_word32->Bind(SmiToInt32(value)); + *var_word32 = SmiToInt32(CAST(value)); CombineFeedback(var_feedback, BinaryOperationFeedback::kSignedSmall); Goto(if_number); BIND(¬_smi); - TNode map = LoadMap(value); + TNode value_heap_object = CAST(value); + TNode map = LoadMap(value_heap_object); GotoIf(IsHeapNumberMap(map), &is_heap_number); TNode instance_type = LoadMapInstanceType(map); if (conversion == Object::Conversion::kToNumeric) { @@ -5703,7 +5699,7 @@ void CodeStubAssembler::TaggedToWord32OrBigIntImpl( // We do not require an Or with earlier feedback here because once we // convert the value to a Numeric, we cannot reach this path. We can // only reach this path on the first pass when the feedback is kNone. - CSA_ASSERT(this, SmiEqual(CAST(var_feedback->value()), + CSA_ASSERT(this, SmiEqual(var_feedback->value(), SmiConstant(BinaryOperationFeedback::kNone))); } GotoIf(InstanceTypeEqual(instance_type, ODDBALL_TYPE), &is_oddball); @@ -5711,25 +5707,25 @@ void CodeStubAssembler::TaggedToWord32OrBigIntImpl( auto builtin = conversion == Object::Conversion::kToNumeric ? Builtins::kNonNumberToNumeric : Builtins::kNonNumberToNumber; - var_value.Bind(CallBuiltin(builtin, context, value)); + var_value = CallBuiltin(builtin, context, value); OverwriteFeedback(var_feedback, BinaryOperationFeedback::kAny); Goto(&loop); BIND(&is_oddball); - var_value.Bind(LoadObjectField(value, Oddball::kToNumberOffset)); + var_value = LoadObjectField(value_heap_object, Oddball::kToNumberOffset); OverwriteFeedback(var_feedback, BinaryOperationFeedback::kNumberOrOddball); Goto(&loop); } BIND(&is_heap_number); - var_word32->Bind(TruncateHeapNumberValueToWord32(CAST(value))); + *var_word32 = TruncateHeapNumberValueToWord32(CAST(value)); CombineFeedback(var_feedback, BinaryOperationFeedback::kNumber); Goto(if_number); if (conversion == Object::Conversion::kToNumeric) { BIND(&is_bigint); - var_bigint->Bind(value); + *var_maybe_bigint = value; CombineFeedback(var_feedback, BinaryOperationFeedback::kBigInt); Goto(if_bigint); } @@ -11547,8 +11543,8 @@ Operation Reverse(Operation op) { } // anonymous namespace TNode CodeStubAssembler::RelationalComparison( - Operation op, SloppyTNode left, SloppyTNode right, - SloppyTNode context, TVariable* var_type_feedback) { + Operation op, TNode left, TNode right, + TNode context, TVariable* var_type_feedback) { Label return_true(this), return_false(this), do_float_comparison(this), end(this); TVARIABLE(Oddball, var_result); // Actually only "true" or "false". diff --git a/src/codegen/code-stub-assembler.h b/src/codegen/code-stub-assembler.h index f70fb28fb2..f5a05caf04 100644 --- a/src/codegen/code-stub-assembler.h +++ b/src/codegen/code-stub-assembler.h @@ -2305,12 +2305,16 @@ class V8_EXPORT_PRIVATE CodeStubAssembler SloppyTNode value); TNode TruncateTaggedToWord32(SloppyTNode context, SloppyTNode value); - void TaggedToWord32OrBigInt(Node* context, Node* value, Label* if_number, - Variable* var_word32, Label* if_bigint, - Variable* var_bigint); - void TaggedToWord32OrBigIntWithFeedback( - Node* context, Node* value, Label* if_number, Variable* var_word32, - Label* if_bigint, Variable* var_bigint, Variable* var_feedback); + void TaggedToWord32OrBigInt(TNode context, TNode value, + Label* if_number, TVariable* var_word32, + Label* if_bigint, + TVariable* var_maybe_bigint); + void TaggedToWord32OrBigIntWithFeedback(TNode context, + TNode value, Label* if_number, + TVariable* var_word32, + Label* if_bigint, + TVariable* var_maybe_bigint, + TVariable* var_feedback); // Truncate the floating point value of a HeapNumber to an Int32. TNode TruncateHeapNumberValueToWord32(TNode object); @@ -3409,9 +3413,8 @@ class V8_EXPORT_PRIVATE CodeStubAssembler TNode end_offset, RootIndex root); TNode RelationalComparison( - Operation op, SloppyTNode left, SloppyTNode right, - SloppyTNode context, - TVariable* var_type_feedback = nullptr); + Operation op, TNode left, TNode right, + TNode context, TVariable* var_type_feedback = nullptr); void BranchIfNumberRelationalComparison(Operation op, SloppyTNode left, @@ -3811,11 +3814,12 @@ class V8_EXPORT_PRIVATE CodeStubAssembler Variable* var_numeric, Variable* var_feedback); template - void TaggedToWord32OrBigIntImpl(Node* context, Node* value, Label* if_number, - Variable* var_word32, + void TaggedToWord32OrBigIntImpl(TNode context, TNode value, + Label* if_number, + TVariable* var_word32, Label* if_bigint = nullptr, - Variable* var_bigint = nullptr, - Variable* var_feedback = nullptr); + TVariable* var_maybe_bigint = nullptr, + TVariable* var_feedback = nullptr); private: // Low-level accessors for Descriptor arrays.