Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(149)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/builtins/builtins-number.cc

Issue 2517833005: [cleanup] Refactor builtins-number.cc (Closed)
Patch Set: Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | src/builtins/builtins-utils.h » ('j') | src/builtins/builtins-utils.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/builtins/builtins-number.cc
diff --git a/src/builtins/builtins-number.cc b/src/builtins/builtins-number.cc
index a63066cfbd7857b42cdf99db8d646f68feae2b6b..22c048b088d4ab0cf7afd8f7c89c66fb0977494d 100644
--- a/src/builtins/builtins-number.cc
+++ b/src/builtins/builtins-number.cc
@@ -5,255 +5,228 @@
#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:
+ // TODO(jkummerow): Add useful helpers here, and derive from
+ // NumberBuiltinsAssembler below.
+};
+
// -----------------------------------------------------------------------------
// ES6 section 20.1 Number Objects
// ES6 section 20.1.2.2 Number.isFinite ( number )
-void Builtins::Generate_NumberIsFinite(compiler::CodeAssemblerState* state) {
- typedef CodeStubAssembler::Label Label;
- typedef compiler::Node Node;
- CodeStubAssembler assembler(state);
+TF_BUILTIN(NumberIsFinite, CodeStubAssembler) {
+ Node* number = Parameter(1);
- Node* number = assembler.Parameter(1);
-
- Label return_true(&assembler), return_false(&assembler);
+ Label return_true(this), return_false(this);
// Check if {number} is a Smi.
- assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
+ GotoIf(TaggedIsSmi(number), &return_true);
// Check if {number} is a HeapNumber.
- assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
- assembler.HeapNumberMapConstant()),
- &return_false);
+ GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+ &return_false);
// Check if {number} contains a finite, non-NaN value.
- Node* number_value = assembler.LoadHeapNumberValue(number);
- assembler.BranchIfFloat64IsNaN(
- assembler.Float64Sub(number_value, number_value), &return_false,
- &return_true);
+ Node* number_value = LoadHeapNumberValue(number);
+ BranchIfFloat64IsNaN(Float64Sub(number_value, number_value), &return_false,
+ &return_true);
- assembler.Bind(&return_true);
- assembler.Return(assembler.BooleanConstant(true));
+ Bind(&return_true);
+ Return(BooleanConstant(true));
- assembler.Bind(&return_false);
- assembler.Return(assembler.BooleanConstant(false));
+ Bind(&return_false);
+ Return(BooleanConstant(false));
}
// ES6 section 20.1.2.3 Number.isInteger ( number )
-void Builtins::Generate_NumberIsInteger(compiler::CodeAssemblerState* state) {
- typedef CodeStubAssembler::Label Label;
- typedef compiler::Node Node;
- CodeStubAssembler assembler(state);
+TF_BUILTIN(NumberIsInteger, CodeStubAssembler) {
+ Node* number = Parameter(1);
- Node* number = assembler.Parameter(1);
-
- Label return_true(&assembler), return_false(&assembler);
+ Label return_true(this), return_false(this);
// Check if {number} is a Smi.
- assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
+ GotoIf(TaggedIsSmi(number), &return_true);
// Check if {number} is a HeapNumber.
- assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
- assembler.HeapNumberMapConstant()),
- &return_false);
+ GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+ &return_false);
// Load the actual value of {number}.
- Node* number_value = assembler.LoadHeapNumberValue(number);
+ Node* number_value = LoadHeapNumberValue(number);
// Truncate the value of {number} to an integer (or an infinity).
- Node* integer = assembler.Float64Trunc(number_value);
+ Node* integer = Float64Trunc(number_value);
// Check if {number}s value matches the integer (ruling out the infinities).
- assembler.Branch(
- assembler.Float64Equal(assembler.Float64Sub(number_value, integer),
- assembler.Float64Constant(0.0)),
- &return_true, &return_false);
+ Branch(Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
+ &return_true, &return_false);
- assembler.Bind(&return_true);
- assembler.Return(assembler.BooleanConstant(true));
+ Bind(&return_true);
+ Return(BooleanConstant(true));
- assembler.Bind(&return_false);
- assembler.Return(assembler.BooleanConstant(false));
+ Bind(&return_false);
+ Return(BooleanConstant(false));
}
// ES6 section 20.1.2.4 Number.isNaN ( number )
-void Builtins::Generate_NumberIsNaN(compiler::CodeAssemblerState* state) {
- typedef CodeStubAssembler::Label Label;
- typedef compiler::Node Node;
- CodeStubAssembler assembler(state);
-
- Node* number = assembler.Parameter(1);
+TF_BUILTIN(NumberIsNaN, CodeStubAssembler) {
+ Node* number = Parameter(1);
- Label return_true(&assembler), return_false(&assembler);
+ Label return_true(this), return_false(this);
// Check if {number} is a Smi.
- assembler.GotoIf(assembler.TaggedIsSmi(number), &return_false);
+ GotoIf(TaggedIsSmi(number), &return_false);
// Check if {number} is a HeapNumber.
- assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
- assembler.HeapNumberMapConstant()),
- &return_false);
+ GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+ &return_false);
// Check if {number} contains a NaN value.
- Node* number_value = assembler.LoadHeapNumberValue(number);
- assembler.BranchIfFloat64IsNaN(number_value, &return_true, &return_false);
+ Node* number_value = LoadHeapNumberValue(number);
+ BranchIfFloat64IsNaN(number_value, &return_true, &return_false);
- assembler.Bind(&return_true);
- assembler.Return(assembler.BooleanConstant(true));
+ Bind(&return_true);
+ Return(BooleanConstant(true));
- assembler.Bind(&return_false);
- assembler.Return(assembler.BooleanConstant(false));
+ Bind(&return_false);
+ Return(BooleanConstant(false));
}
// ES6 section 20.1.2.5 Number.isSafeInteger ( number )
-void Builtins::Generate_NumberIsSafeInteger(
- compiler::CodeAssemblerState* state) {
- typedef CodeStubAssembler::Label Label;
- typedef compiler::Node Node;
- CodeStubAssembler assembler(state);
+TF_BUILTIN(NumberIsSafeInteger, CodeStubAssembler) {
+ Node* number = Parameter(1);
- Node* number = assembler.Parameter(1);
-
- Label return_true(&assembler), return_false(&assembler);
+ Label return_true(this), return_false(this);
// Check if {number} is a Smi.
- assembler.GotoIf(assembler.TaggedIsSmi(number), &return_true);
+ GotoIf(TaggedIsSmi(number), &return_true);
// Check if {number} is a HeapNumber.
- assembler.GotoUnless(assembler.WordEqual(assembler.LoadMap(number),
- assembler.HeapNumberMapConstant()),
- &return_false);
+ GotoUnless(WordEqual(LoadMap(number), HeapNumberMapConstant()),
+ &return_false);
// Load the actual value of {number}.
- Node* number_value = assembler.LoadHeapNumberValue(number);
+ Node* number_value = LoadHeapNumberValue(number);
// Truncate the value of {number} to an integer (or an infinity).
- Node* integer = assembler.Float64Trunc(number_value);
+ Node* integer = Float64Trunc(number_value);
// Check if {number}s value matches the integer (ruling out the infinities).
- assembler.GotoUnless(
- assembler.Float64Equal(assembler.Float64Sub(number_value, integer),
- assembler.Float64Constant(0.0)),
+ GotoUnless(
+ Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
&return_false);
// Check if the {integer} value is in safe integer range.
- assembler.Branch(assembler.Float64LessThanOrEqual(
- assembler.Float64Abs(integer),
- assembler.Float64Constant(kMaxSafeInteger)),
- &return_true, &return_false);
+ Branch(Float64LessThanOrEqual(Float64Abs(integer),
+ Float64Constant(kMaxSafeInteger)),
+ &return_true, &return_false);
- assembler.Bind(&return_true);
- assembler.Return(assembler.BooleanConstant(true));
+ Bind(&return_true);
+ Return(BooleanConstant(true));
- assembler.Bind(&return_false);
- assembler.Return(assembler.BooleanConstant(false));
+ Bind(&return_false);
+ Return(BooleanConstant(false));
}
// ES6 section 20.1.2.12 Number.parseFloat ( string )
-void Builtins::Generate_NumberParseFloat(compiler::CodeAssemblerState* state) {
- typedef CodeStubAssembler::Label Label;
- typedef compiler::Node Node;
- typedef CodeStubAssembler::Variable Variable;
- CodeStubAssembler assembler(state);
-
- Node* context = assembler.Parameter(4);
+TF_BUILTIN(NumberParseFloat, CodeStubAssembler) {
+ Node* context = Parameter(4);
// We might need to loop once for ToString conversion.
- Variable var_input(&assembler, MachineRepresentation::kTagged);
- Label loop(&assembler, &var_input);
- var_input.Bind(assembler.Parameter(1));
- assembler.Goto(&loop);
- assembler.Bind(&loop);
+ Variable var_input(this, MachineRepresentation::kTagged);
+ Label loop(this, &var_input);
+ var_input.Bind(Parameter(1));
+ Goto(&loop);
+ Bind(&loop);
{
// Load the current {input} value.
Node* input = var_input.value();
// Check if the {input} is a HeapObject or a Smi.
- Label if_inputissmi(&assembler), if_inputisnotsmi(&assembler);
- assembler.Branch(assembler.TaggedIsSmi(input), &if_inputissmi,
- &if_inputisnotsmi);
+ Label if_inputissmi(this), if_inputisnotsmi(this);
+ Branch(TaggedIsSmi(input), &if_inputissmi, &if_inputisnotsmi);
- assembler.Bind(&if_inputissmi);
+ Bind(&if_inputissmi);
{
// The {input} is already a Number, no need to do anything.
- assembler.Return(input);
+ Return(input);
}
- assembler.Bind(&if_inputisnotsmi);
+ Bind(&if_inputisnotsmi);
{
// The {input} is a HeapObject, check if it's already a String.
- Label if_inputisstring(&assembler), if_inputisnotstring(&assembler);
- Node* input_map = assembler.LoadMap(input);
- Node* input_instance_type = assembler.LoadMapInstanceType(input_map);
- assembler.Branch(assembler.IsStringInstanceType(input_instance_type),
- &if_inputisstring, &if_inputisnotstring);
+ Label if_inputisstring(this), if_inputisnotstring(this);
+ Node* input_map = LoadMap(input);
+ Node* input_instance_type = LoadMapInstanceType(input_map);
+ Branch(IsStringInstanceType(input_instance_type), &if_inputisstring,
+ &if_inputisnotstring);
- assembler.Bind(&if_inputisstring);
+ Bind(&if_inputisstring);
{
// The {input} is already a String, check if {input} contains
// a cached array index.
- Label if_inputcached(&assembler), if_inputnotcached(&assembler);
- Node* input_hash = assembler.LoadNameHashField(input);
- Node* input_bit = assembler.Word32And(
- input_hash,
- assembler.Int32Constant(String::kContainsCachedArrayIndexMask));
- assembler.Branch(
- assembler.Word32Equal(input_bit, assembler.Int32Constant(0)),
- &if_inputcached, &if_inputnotcached);
-
- assembler.Bind(&if_inputcached);
+ Label if_inputcached(this), if_inputnotcached(this);
+ Node* input_hash = LoadNameHashField(input);
+ Node* input_bit = Word32And(
+ input_hash, Int32Constant(String::kContainsCachedArrayIndexMask));
+ Branch(Word32Equal(input_bit, Int32Constant(0)), &if_inputcached,
+ &if_inputnotcached);
+
+ Bind(&if_inputcached);
{
// Just return the {input}s cached array index.
Node* input_array_index =
- assembler.DecodeWordFromWord32<String::ArrayIndexValueBits>(
- input_hash);
- assembler.Return(assembler.SmiTag(input_array_index));
+ DecodeWordFromWord32<String::ArrayIndexValueBits>(input_hash);
+ Return(SmiTag(input_array_index));
}
- assembler.Bind(&if_inputnotcached);
+ Bind(&if_inputnotcached);
{
// Need to fall back to the runtime to convert {input} to double.
- assembler.Return(assembler.CallRuntime(Runtime::kStringParseFloat,
- context, input));
+ Return(CallRuntime(Runtime::kStringParseFloat, context, input));
}
}
- assembler.Bind(&if_inputisnotstring);
+ Bind(&if_inputisnotstring);
{
// The {input} is neither a String nor a Smi, check for HeapNumber.
- Label if_inputisnumber(&assembler),
- if_inputisnotnumber(&assembler, Label::kDeferred);
- assembler.Branch(
- assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()),
- &if_inputisnumber, &if_inputisnotnumber);
+ Label if_inputisnumber(this),
+ if_inputisnotnumber(this, Label::kDeferred);
+ Branch(WordEqual(input_map, HeapNumberMapConstant()), &if_inputisnumber,
+ &if_inputisnotnumber);
- assembler.Bind(&if_inputisnumber);
+ Bind(&if_inputisnumber);
{
// The {input} is already a Number, take care of -0.
- Label if_inputiszero(&assembler), if_inputisnotzero(&assembler);
- Node* input_value = assembler.LoadHeapNumberValue(input);
- assembler.Branch(assembler.Float64Equal(
- input_value, assembler.Float64Constant(0.0)),
- &if_inputiszero, &if_inputisnotzero);
+ Label if_inputiszero(this), if_inputisnotzero(this);
+ Node* input_value = LoadHeapNumberValue(input);
+ Branch(Float64Equal(input_value, Float64Constant(0.0)),
+ &if_inputiszero, &if_inputisnotzero);
- assembler.Bind(&if_inputiszero);
- assembler.Return(assembler.SmiConstant(0));
+ Bind(&if_inputiszero);
+ Return(SmiConstant(0));
- assembler.Bind(&if_inputisnotzero);
- assembler.Return(input);
+ Bind(&if_inputisnotzero);
+ Return(input);
}
- assembler.Bind(&if_inputisnotnumber);
+ Bind(&if_inputisnotnumber);
{
// Need to convert the {input} to String first.
// TODO(bmeurer): This could be more efficient if necessary.
- Callable callable = CodeFactory::ToString(assembler.isolate());
- var_input.Bind(assembler.CallStub(callable, context, input));
- assembler.Goto(&loop);
+ Callable callable = CodeFactory::ToString(isolate());
+ var_input.Bind(CallStub(callable, context, input));
+ Goto(&loop);
}
}
}
@@ -261,99 +234,80 @@ void Builtins::Generate_NumberParseFloat(compiler::CodeAssemblerState* state) {
}
// ES6 section 20.1.2.13 Number.parseInt ( string, radix )
-void Builtins::Generate_NumberParseInt(compiler::CodeAssemblerState* state) {
- typedef CodeStubAssembler::Label Label;
- typedef compiler::Node Node;
- CodeStubAssembler assembler(state);
-
- Node* input = assembler.Parameter(1);
- Node* radix = assembler.Parameter(2);
- Node* context = assembler.Parameter(5);
+TF_BUILTIN(NumberParseInt, CodeStubAssembler) {
+ Node* input = Parameter(1);
+ Node* radix = Parameter(2);
+ Node* context = Parameter(5);
// Check if {radix} is treated as 10 (i.e. undefined, 0 or 10).
- Label if_radix10(&assembler), if_generic(&assembler, Label::kDeferred);
- assembler.GotoIf(assembler.WordEqual(radix, assembler.UndefinedConstant()),
- &if_radix10);
- assembler.GotoIf(
- assembler.WordEqual(radix, assembler.SmiConstant(Smi::FromInt(10))),
- &if_radix10);
- assembler.GotoIf(
- assembler.WordEqual(radix, assembler.SmiConstant(Smi::FromInt(0))),
- &if_radix10);
- assembler.Goto(&if_generic);
-
- assembler.Bind(&if_radix10);
+ Label if_radix10(this), if_generic(this, Label::kDeferred);
+ GotoIf(WordEqual(radix, UndefinedConstant()), &if_radix10);
+ GotoIf(WordEqual(radix, SmiConstant(Smi::FromInt(10))), &if_radix10);
+ GotoIf(WordEqual(radix, SmiConstant(Smi::FromInt(0))), &if_radix10);
+ Goto(&if_generic);
+
+ Bind(&if_radix10);
{
// Check if we can avoid the ToString conversion on {input}.
- Label if_inputissmi(&assembler), if_inputisheapnumber(&assembler),
- if_inputisstring(&assembler);
- assembler.GotoIf(assembler.TaggedIsSmi(input), &if_inputissmi);
- Node* input_map = assembler.LoadMap(input);
- assembler.GotoIf(
- assembler.WordEqual(input_map, assembler.HeapNumberMapConstant()),
- &if_inputisheapnumber);
- Node* input_instance_type = assembler.LoadMapInstanceType(input_map);
- assembler.Branch(assembler.IsStringInstanceType(input_instance_type),
- &if_inputisstring, &if_generic);
-
- assembler.Bind(&if_inputissmi);
+ Label if_inputissmi(this), if_inputisheapnumber(this),
+ if_inputisstring(this);
+ GotoIf(TaggedIsSmi(input), &if_inputissmi);
+ Node* input_map = LoadMap(input);
+ GotoIf(WordEqual(input_map, HeapNumberMapConstant()),
+ &if_inputisheapnumber);
+ Node* input_instance_type = LoadMapInstanceType(input_map);
+ Branch(IsStringInstanceType(input_instance_type), &if_inputisstring,
+ &if_generic);
+
+ Bind(&if_inputissmi);
{
// Just return the {input}.
- assembler.Return(input);
+ Return(input);
}
- assembler.Bind(&if_inputisheapnumber);
+ Bind(&if_inputisheapnumber);
{
// Check if the {input} value is in Signed32 range.
- Label if_inputissigned32(&assembler);
- Node* input_value = assembler.LoadHeapNumberValue(input);
- Node* input_value32 = assembler.TruncateFloat64ToWord32(input_value);
- assembler.GotoIf(
- assembler.Float64Equal(input_value,
- assembler.ChangeInt32ToFloat64(input_value32)),
- &if_inputissigned32);
+ Label if_inputissigned32(this);
+ Node* input_value = LoadHeapNumberValue(input);
+ Node* input_value32 = TruncateFloat64ToWord32(input_value);
+ GotoIf(Float64Equal(input_value, ChangeInt32ToFloat64(input_value32)),
+ &if_inputissigned32);
// Check if the absolute {input} value is in the ]0.01,1e9[ range.
- Node* input_value_abs = assembler.Float64Abs(input_value);
+ Node* input_value_abs = Float64Abs(input_value);
- assembler.GotoUnless(assembler.Float64LessThan(
- input_value_abs, assembler.Float64Constant(1e9)),
- &if_generic);
- assembler.Branch(assembler.Float64LessThan(
- assembler.Float64Constant(0.01), input_value_abs),
- &if_inputissigned32, &if_generic);
+ GotoUnless(Float64LessThan(input_value_abs, Float64Constant(1e9)),
+ &if_generic);
+ Branch(Float64LessThan(Float64Constant(0.01), input_value_abs),
+ &if_inputissigned32, &if_generic);
// Return the truncated int32 value, and return the tagged result.
- assembler.Bind(&if_inputissigned32);
- Node* result = assembler.ChangeInt32ToTagged(input_value32);
- assembler.Return(result);
+ Bind(&if_inputissigned32);
+ Node* result = ChangeInt32ToTagged(input_value32);
+ Return(result);
}
- assembler.Bind(&if_inputisstring);
+ Bind(&if_inputisstring);
{
// Check if the String {input} has a cached array index.
- Node* input_hash = assembler.LoadNameHashField(input);
- Node* input_bit = assembler.Word32And(
- input_hash,
- assembler.Int32Constant(String::kContainsCachedArrayIndexMask));
- assembler.GotoIf(
- assembler.Word32NotEqual(input_bit, assembler.Int32Constant(0)),
- &if_generic);
+ Node* input_hash = LoadNameHashField(input);
+ Node* input_bit = Word32And(
+ input_hash, Int32Constant(String::kContainsCachedArrayIndexMask));
+ GotoIf(Word32NotEqual(input_bit, Int32Constant(0)), &if_generic);
// Return the cached array index as result.
Node* input_index =
- assembler.DecodeWordFromWord32<String::ArrayIndexValueBits>(
- input_hash);
- Node* result = assembler.SmiTag(input_index);
- assembler.Return(result);
+ DecodeWordFromWord32<String::ArrayIndexValueBits>(input_hash);
+ Node* result = SmiTag(input_index);
+ Return(result);
}
}
- assembler.Bind(&if_generic);
+ Bind(&if_generic);
{
- Node* result =
- assembler.CallRuntime(Runtime::kStringParseInt, context, input, radix);
- assembler.Return(result);
+ Node* result = CallRuntime(Runtime::kStringParseInt, context, input, radix);
+ Return(result);
}
}
« no previous file with comments | « no previous file | src/builtins/builtins-utils.h » ('j') | src/builtins/builtins-utils.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698