diff --git a/AUTHORS b/AUTHORS index b017f6d22f..79493db533 100644 --- a/AUTHORS +++ b/AUTHORS @@ -45,6 +45,7 @@ Alessandro Pignotti Alex Kodat Alexander Botero-Lowry Alexander Karpinsky +Alexander Neville Alexandre Vassalotti Alexis Campailla Allan Sandfeld Jensen diff --git a/BUILD.gn b/BUILD.gn index 5b6ba9872f..73a8c55f08 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -940,6 +940,7 @@ torque_files = [ "src/builtins/extras-utils.tq", "src/builtins/internal-coverage.tq", "src/builtins/iterator.tq", + "src/builtins/math.tq", "src/builtins/object-fromentries.tq", "src/builtins/proxy.tq", "src/builtins/proxy-constructor.tq", @@ -997,6 +998,7 @@ torque_namespaces = [ "growable-fixed-array", "internal-coverage", "iterator", + "math", "object", "proxy", "regexp", diff --git a/src/builtins/base.tq b/src/builtins/base.tq index 3b016230c5..581ea41933 100644 --- a/src/builtins/base.tq +++ b/src/builtins/base.tq @@ -1749,6 +1749,7 @@ extern macro ChangeFloat64ToUintPtr(float64): uintptr; extern macro ChangeInt32ToIntPtr(int32): intptr; // Sign-extends. extern macro ChangeUint32ToWord(uint32): uintptr; // Doesn't sign-extend. extern macro LoadNativeContext(Context): NativeContext; +extern macro TruncateFloat64ToFloat32(float64): float32; extern macro LoadJSArrayElementsMap(constexpr ElementsKind, Context): Map; extern macro LoadJSArrayElementsMap(ElementsKind, Context): Map; extern macro ChangeNonnegativeNumberToUintPtr(Number): uintptr; @@ -1944,6 +1945,12 @@ Convert(n: Number): uintptr { Convert(f: float32): float64 { return ChangeFloat32ToFloat64(f); } +Convert(f: float64): float32 { + return TruncateFloat64ToFloat32(f); +} +Convert(n: Number): float32 { + return Convert(ChangeNumberToFloat64(n)); +} Convert(d: float64): Number { return AllocateHeapNumberWithValue(d); } diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h index da3397dbc4..6d5ef811c7 100644 --- a/src/builtins/builtins-definitions.h +++ b/src/builtins/builtins-definitions.h @@ -643,50 +643,16 @@ namespace internal { /* Math */ \ /* ES6 #sec-math.abs */ \ TFJ(MathAbs, 1, kReceiver, kX) \ - /* ES6 #sec-math.acos */ \ - TFJ(MathAcos, 1, kReceiver, kX) \ - /* ES6 #sec-math.acosh */ \ - TFJ(MathAcosh, 1, kReceiver, kX) \ - /* ES6 #sec-math.asin */ \ - TFJ(MathAsin, 1, kReceiver, kX) \ - /* ES6 #sec-math.asinh */ \ - TFJ(MathAsinh, 1, kReceiver, kX) \ - /* ES6 #sec-math.atan */ \ - TFJ(MathAtan, 1, kReceiver, kX) \ - /* ES6 #sec-math.atanh */ \ - TFJ(MathAtanh, 1, kReceiver, kX) \ - /* ES6 #sec-math.atan2 */ \ - TFJ(MathAtan2, 2, kReceiver, kY, kX) \ - /* ES6 #sec-math.cbrt */ \ - TFJ(MathCbrt, 1, kReceiver, kX) \ /* ES6 #sec-math.ceil */ \ TFJ(MathCeil, 1, kReceiver, kX) \ /* ES6 #sec-math.clz32 */ \ TFJ(MathClz32, 1, kReceiver, kX) \ - /* ES6 #sec-math.cos */ \ - TFJ(MathCos, 1, kReceiver, kX) \ - /* ES6 #sec-math.cosh */ \ - TFJ(MathCosh, 1, kReceiver, kX) \ - /* ES6 #sec-math.exp */ \ - TFJ(MathExp, 1, kReceiver, kX) \ - /* ES6 #sec-math.expm1 */ \ - TFJ(MathExpm1, 1, kReceiver, kX) \ /* ES6 #sec-math.floor */ \ TFJ(MathFloor, 1, kReceiver, kX) \ - /* ES6 #sec-math.fround */ \ - TFJ(MathFround, 1, kReceiver, kX) \ /* ES6 #sec-math.hypot */ \ CPP(MathHypot) \ /* ES6 #sec-math.imul */ \ TFJ(MathImul, 2, kReceiver, kX, kY) \ - /* ES6 #sec-math.log */ \ - TFJ(MathLog, 1, kReceiver, kX) \ - /* ES6 #sec-math.log1p */ \ - TFJ(MathLog1p, 1, kReceiver, kX) \ - /* ES6 #sec-math.log10 */ \ - TFJ(MathLog10, 1, kReceiver, kX) \ - /* ES6 #sec-math.log2 */ \ - TFJ(MathLog2, 1, kReceiver, kX) \ /* ES6 #sec-math.max */ \ TFJ(MathMax, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \ /* ES6 #sec-math.min */ \ @@ -699,16 +665,6 @@ namespace internal { TFJ(MathRound, 1, kReceiver, kX) \ /* ES6 #sec-math.sign */ \ TFJ(MathSign, 1, kReceiver, kX) \ - /* ES6 #sec-math.sin */ \ - TFJ(MathSin, 1, kReceiver, kX) \ - /* ES6 #sec-math.sinh */ \ - TFJ(MathSinh, 1, kReceiver, kX) \ - /* ES6 #sec-math.sqrt */ \ - TFJ(MathTan, 1, kReceiver, kX) \ - /* ES6 #sec-math.tan */ \ - TFJ(MathTanh, 1, kReceiver, kX) \ - /* ES6 #sec-math.tanh */ \ - TFJ(MathSqrt, 1, kReceiver, kX) \ /* ES6 #sec-math.trunc */ \ TFJ(MathTrunc, 1, kReceiver, kX) \ \ diff --git a/src/builtins/builtins-math-gen.cc b/src/builtins/builtins-math-gen.cc index 16d1e7d234..13ecb542e4 100644 --- a/src/builtins/builtins-math-gen.cc +++ b/src/builtins/builtins-math-gen.cc @@ -141,15 +141,6 @@ void MathBuiltinsAssembler::MathRoundingOperation( } } -void MathBuiltinsAssembler::MathUnaryOperation( - Node* context, Node* x, - TNode (CodeStubAssembler::*float64op)(SloppyTNode)) { - Node* x_value = TruncateTaggedToFloat64(context, x); - Node* value = (this->*float64op)(x_value); - Node* result = AllocateHeapNumberWithValue(value); - Return(result); -} - void MathBuiltinsAssembler::MathMaxMin( Node* context, Node* argc, TNode (CodeStubAssembler::*float64op)(SloppyTNode, @@ -170,60 +161,6 @@ void MathBuiltinsAssembler::MathMaxMin( arguments.PopAndReturn(ChangeFloat64ToTagged(result.value())); } -// ES6 #sec-math.acos -TF_BUILTIN(MathAcos, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Acos); -} - -// ES6 #sec-math.acosh -TF_BUILTIN(MathAcosh, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Acosh); -} - -// ES6 #sec-math.asin -TF_BUILTIN(MathAsin, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Asin); -} - -// ES6 #sec-math.asinh -TF_BUILTIN(MathAsinh, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Asinh); -} - -// ES6 #sec-math.atan -TF_BUILTIN(MathAtan, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Atan); -} - -// ES6 #sec-math.atanh -TF_BUILTIN(MathAtanh, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Atanh); -} - -// ES6 #sec-math.atan2 -TF_BUILTIN(MathAtan2, CodeStubAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* y = Parameter(Descriptor::kY); - Node* x = Parameter(Descriptor::kX); - - Node* y_value = TruncateTaggedToFloat64(context, y); - Node* x_value = TruncateTaggedToFloat64(context, x); - Node* value = Float64Atan2(y_value, x_value); - Node* result = AllocateHeapNumberWithValue(value); - Return(result); -} // ES6 #sec-math.ceil TF_BUILTIN(MathCeil, MathBuiltinsAssembler) { @@ -232,13 +169,6 @@ TF_BUILTIN(MathCeil, MathBuiltinsAssembler) { MathRoundingOperation(context, x, &CodeStubAssembler::Float64Ceil); } -// ES6 #sec-math.cbrt -TF_BUILTIN(MathCbrt, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Cbrt); -} - // ES6 #sec-math.clz32 TF_BUILTIN(MathClz32, CodeStubAssembler) { Node* context = Parameter(Descriptor::kContext); @@ -297,34 +227,6 @@ TF_BUILTIN(MathClz32, CodeStubAssembler) { } } -// ES6 #sec-math.cos -TF_BUILTIN(MathCos, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Cos); -} - -// ES6 #sec-math.cosh -TF_BUILTIN(MathCosh, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Cosh); -} - -// ES6 #sec-math.exp -TF_BUILTIN(MathExp, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Exp); -} - -// ES6 #sec-math.expm1 -TF_BUILTIN(MathExpm1, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Expm1); -} - // ES6 #sec-math.floor TF_BUILTIN(MathFloor, MathBuiltinsAssembler) { Node* context = Parameter(Descriptor::kContext); @@ -332,17 +234,6 @@ TF_BUILTIN(MathFloor, MathBuiltinsAssembler) { MathRoundingOperation(context, x, &CodeStubAssembler::Float64Floor); } -// ES6 #sec-math.fround -TF_BUILTIN(MathFround, CodeStubAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - Node* x_value = TruncateTaggedToFloat64(context, x); - Node* value32 = TruncateFloat64ToFloat32(x_value); - Node* value = ChangeFloat32ToFloat64(value32); - Node* result = AllocateHeapNumberWithValue(value); - Return(result); -} - // ES6 #sec-math.imul TF_BUILTIN(MathImul, CodeStubAssembler) { Node* context = Parameter(Descriptor::kContext); @@ -355,34 +246,6 @@ TF_BUILTIN(MathImul, CodeStubAssembler) { Return(result); } -// ES6 #sec-math.log -TF_BUILTIN(MathLog, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Log); -} - -// ES6 #sec-math.log1p -TF_BUILTIN(MathLog1p, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Log1p); -} - -// ES6 #sec-math.log10 -TF_BUILTIN(MathLog10, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Log10); -} - -// ES6 #sec-math.log2 -TF_BUILTIN(MathLog2, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Log2); -} - CodeStubAssembler::Node* MathBuiltinsAssembler::MathPow(Node* context, Node* base, Node* exponent) { @@ -466,41 +329,6 @@ TF_BUILTIN(MathSign, CodeStubAssembler) { Return(SmiConstant(1)); } -// ES6 #sec-math.sin -TF_BUILTIN(MathSin, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Sin); -} - -// ES6 #sec-math.sinh -TF_BUILTIN(MathSinh, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Sinh); -} - -// ES6 #sec-math.sqrt -TF_BUILTIN(MathSqrt, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Sqrt); -} - -// ES6 #sec-math.tan -TF_BUILTIN(MathTan, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Tan); -} - -// ES6 #sec-math.tanh -TF_BUILTIN(MathTanh, MathBuiltinsAssembler) { - Node* context = Parameter(Descriptor::kContext); - Node* x = Parameter(Descriptor::kX); - MathUnaryOperation(context, x, &CodeStubAssembler::Float64Tanh); -} - // ES6 #sec-math.trunc TF_BUILTIN(MathTrunc, MathBuiltinsAssembler) { Node* context = Parameter(Descriptor::kContext); diff --git a/src/builtins/builtins-math-gen.h b/src/builtins/builtins-math-gen.h index 7b9079b6e9..0b28e92360 100644 --- a/src/builtins/builtins-math-gen.h +++ b/src/builtins/builtins-math-gen.h @@ -21,9 +21,6 @@ class MathBuiltinsAssembler : public CodeStubAssembler { void MathRoundingOperation( Node* context, Node* x, TNode (CodeStubAssembler::*float64op)(SloppyTNode)); - void MathUnaryOperation( - Node* context, Node* x, - TNode (CodeStubAssembler::*float64op)(SloppyTNode)); void MathMaxMin(Node* context, Node* argc, TNode (CodeStubAssembler::*float64op)( SloppyTNode, SloppyTNode), diff --git a/src/builtins/data-view.tq b/src/builtins/data-view.tq index 383be19a9d..842e9527ee 100644 --- a/src/builtins/data-view.tq +++ b/src/builtins/data-view.tq @@ -527,7 +527,6 @@ namespace data_view { extern macro ToNumber(Context, Object): Number; extern macro ToBigInt(Context, Object): BigInt; - extern macro TruncateFloat64ToFloat32(float64): float32; extern macro TruncateFloat64ToWord32(float64): uint32; extern macro DataViewBuiltinsAssembler::StoreWord8(RawPtr, uintptr, uint32): diff --git a/src/builtins/math.tq b/src/builtins/math.tq new file mode 100644 index 0000000000..6c80475945 --- /dev/null +++ b/src/builtins/math.tq @@ -0,0 +1,203 @@ +// Copyright 2019 the V8 project authors. All rights reserved. Use of this +// source code is governed by a BSD-style license that can be found in the +// LICENSE file. + +namespace math { + // ES6 #sec-math.acos + extern macro Float64Acos(float64): float64; + + transitioning javascript builtin + MathAcos(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Acos(value)); + } + + // ES6 #sec-math.acosh + extern macro Float64Acosh(float64): float64; + + transitioning javascript builtin + MathAcosh(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Acosh(value)); + } + + // ES6 #sec-math.asin + extern macro Float64Asin(float64): float64; + + transitioning javascript builtin + MathAsin(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Asin(value)); + } + + // ES6 #sec-math.asinh + extern macro Float64Asinh(float64): float64; + + transitioning javascript builtin + MathAsinh(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Asinh(value)); + } + + // ES6 #sec-math.atan + extern macro Float64Atan(float64): float64; + + transitioning javascript builtin + MathAtan(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Atan(value)); + } + + // ES6 #sec-math.atan2 + extern macro Float64Atan2(float64, float64): float64; + + transitioning javascript builtin + MathAtan2(context: Context, receiver: Object, y: Object, x: Object): Number { + const yValue = Convert(ToNumber_Inline(context, y)); + const xValue = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Atan2(yValue, xValue)); + } + + // ES6 #sec-math.atanh + extern macro Float64Atanh(float64): float64; + + transitioning javascript builtin + MathAtanh(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Atanh(value)); + } + + // ES6 #sec-math.cbrt + extern macro Float64Cbrt(float64): float64; + + transitioning javascript builtin + MathCbrt(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Cbrt(value)); + } + + // ES6 #sec-math.cos + extern macro Float64Cos(float64): float64; + + transitioning javascript builtin + MathCos(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Cos(value)); + } + + // ES6 #sec-math.cosh + extern macro Float64Cosh(float64): float64; + + transitioning javascript builtin + MathCosh(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Cosh(value)); + } + + // ES6 #sec-math.exp + extern macro Float64Exp(float64): float64; + + transitioning javascript builtin + MathExp(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Exp(value)); + } + + // ES6 #sec-math.expm1 + extern macro Float64Expm1(float64): float64; + + transitioning javascript builtin + MathExpm1(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Expm1(value)); + } + + // ES6 #sec-math.fround + transitioning javascript builtin + MathFround(context: Context, receiver: Object, x: Object): Number { + const x32 = Convert(ToNumber_Inline(context, x)); + const x64 = Convert(x32); + return Convert(x64); + } + + // ES6 #sec-math.log + extern macro Float64Log(float64): float64; + + transitioning javascript builtin + MathLog(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Log(value)); + } + + // ES6 #sec-math.log1p + extern macro Float64Log1p(float64): float64; + + transitioning javascript builtin + MathLog1p(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Log1p(value)); + } + + // ES6 #sec-math.log10 + extern macro Float64Log10(float64): float64; + + transitioning javascript builtin + MathLog10(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Log10(value)); + } + + // ES6 #sec-math.log2 + extern macro Float64Log2(float64): float64; + + transitioning javascript builtin + MathLog2(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Log2(value)); + } + + // ES6 #sec-math.sin + extern macro Float64Sin(float64): float64; + + transitioning javascript builtin + MathSin(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Sin(value)); + } + + // ES6 #sec-math.sinh + extern macro Float64Sinh(float64): float64; + + transitioning javascript builtin + MathSinh(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Sinh(value)); + } + + // ES6 #sec-math.sqrt + extern macro Float64Sqrt(float64): float64; + + transitioning javascript builtin + MathSqrt(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Sqrt(value)); + } + + // ES6 #sec-math.tan + extern macro Float64Tan(float64): float64; + + transitioning javascript builtin + MathTan(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Tan(value)); + } + + // ES6 #sec-math.tanh + extern macro Float64Tanh(float64): float64; + + transitioning javascript builtin + MathTanh(context: Context, receiver: Object, x: Object): Number { + const value = Convert(ToNumber_Inline(context, x)); + return Convert(Float64Tanh(value)); + } +}