OLD | NEW |
---|---|
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/builtins.h" | 5 #include "src/builtins.h" |
6 | 6 |
7 #include "src/api-arguments.h" | 7 #include "src/api-arguments.h" |
8 #include "src/api-natives.h" | 8 #include "src/api-natives.h" |
9 #include "src/api.h" | 9 #include "src/api.h" |
10 #include "src/base/ieee754.h" | 10 #include "src/base/ieee754.h" |
(...skipping 2234 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2245 using compiler::Node; | 2245 using compiler::Node; |
2246 Node* x = assembler->Parameter(1); | 2246 Node* x = assembler->Parameter(1); |
2247 Node* context = assembler->Parameter(4); | 2247 Node* context = assembler->Parameter(4); |
2248 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2248 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2249 Node* value = assembler->Float64Abs(x_value); | 2249 Node* value = assembler->Float64Abs(x_value); |
2250 Node* result = assembler->ChangeFloat64ToTagged(value); | 2250 Node* result = assembler->ChangeFloat64ToTagged(value); |
2251 assembler->Return(result); | 2251 assembler->Return(result); |
2252 } | 2252 } |
2253 | 2253 |
2254 // ES6 section 20.2.2.2 Math.acos ( x ) | 2254 // ES6 section 20.2.2.2 Math.acos ( x ) |
2255 BUILTIN(MathAcos) { | 2255 void Builtins::Generate_MathAcos(CodeStubAssembler* assembler) { |
2256 HandleScope scope(isolate); | 2256 using compiler::Node; |
2257 DCHECK_EQ(2, args.length()); | 2257 |
2258 Handle<Object> x = args.at<Object>(1); | 2258 Node* x = assembler->Parameter(1); |
2259 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x, Object::ToNumber(x)); | 2259 Node* context = assembler->Parameter(4); |
2260 return *isolate->factory()->NewHeapNumber(std::acos(x->Number())); | 2260 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2261 Node* value = assembler->Float64Acos(x_value); | |
2262 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2263 assembler->Return(result); | |
2264 } | |
2265 | |
2266 // ES6 section 20.2.2.3 Math.acosh ( x ) | |
2267 void Builtins::Generate_MathAcosh(CodeStubAssembler* assembler) { | |
2268 using compiler::Node; | |
2269 | |
2270 Node* x = assembler->Parameter(1); | |
2271 Node* context = assembler->Parameter(4); | |
2272 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2273 Node* value = assembler->Float64Acosh(x_value); | |
2274 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2275 assembler->Return(result); | |
2261 } | 2276 } |
2262 | 2277 |
2263 // ES6 section 20.2.2.4 Math.asin ( x ) | 2278 // ES6 section 20.2.2.4 Math.asin ( x ) |
2264 BUILTIN(MathAsin) { | 2279 void Builtins::Generate_MathAsin(CodeStubAssembler* assembler) { |
2265 HandleScope scope(isolate); | 2280 using compiler::Node; |
2266 DCHECK_EQ(2, args.length()); | 2281 |
2267 Handle<Object> x = args.at<Object>(1); | 2282 Node* x = assembler->Parameter(1); |
2268 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x, Object::ToNumber(x)); | 2283 Node* context = assembler->Parameter(4); |
2269 return *isolate->factory()->NewHeapNumber(std::asin(x->Number())); | 2284 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2285 Node* value = assembler->Float64Asin(x_value); | |
2286 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2287 assembler->Return(result); | |
2270 } | 2288 } |
2271 | 2289 |
2272 // ES6 section 20.2.2.18 Math.hypot ( value1, value2, ...values ) | 2290 // ES6 section 20.2.2.5 Math.asinh ( x ) |
2273 BUILTIN(MathHypot) { | 2291 void Builtins::Generate_MathAsinh(CodeStubAssembler* assembler) { |
2274 HandleScope scope(isolate); | 2292 using compiler::Node; |
2275 int const length = args.length() - 1; | |
2276 if (length == 0) return Smi::FromInt(0); | |
2277 DCHECK_LT(0, length); | |
2278 double max = 0; | |
2279 bool one_arg_is_nan = false; | |
2280 List<double> abs_values(length); | |
2281 for (int i = 0; i < length; i++) { | |
2282 Handle<Object> x = args.at<Object>(i + 1); | |
2283 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x, Object::ToNumber(x)); | |
2284 double abs_value = std::abs(x->Number()); | |
2285 | 2293 |
2286 if (std::isnan(abs_value)) { | 2294 Node* x = assembler->Parameter(1); |
2287 one_arg_is_nan = true; | 2295 Node* context = assembler->Parameter(4); |
2288 } else { | 2296 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2289 abs_values.Add(abs_value); | 2297 Node* value = assembler->Float64Asinh(x_value); |
2290 if (max < abs_value) { | 2298 Node* result = assembler->ChangeFloat64ToTagged(value); |
2291 max = abs_value; | 2299 assembler->Return(result); |
2292 } | |
2293 } | |
2294 } | |
2295 | |
2296 if (max == V8_INFINITY) { | |
2297 return *isolate->factory()->NewNumber(V8_INFINITY); | |
2298 } | |
2299 | |
2300 if (one_arg_is_nan) { | |
2301 return *isolate->factory()->nan_value(); | |
2302 } | |
2303 | |
2304 if (max == 0) { | |
2305 return Smi::FromInt(0); | |
2306 } | |
2307 DCHECK_GT(max, 0); | |
2308 | |
2309 // Kahan summation to avoid rounding errors. | |
2310 // Normalize the numbers to the largest one to avoid overflow. | |
2311 double sum = 0; | |
2312 double compensation = 0; | |
2313 for (int i = 0; i < length; i++) { | |
2314 double n = abs_values.at(i) / max; | |
2315 double summand = n * n - compensation; | |
2316 double preliminary = sum + summand; | |
2317 compensation = (preliminary - sum) - summand; | |
2318 sum = preliminary; | |
2319 } | |
2320 | |
2321 return *isolate->factory()->NewNumber(std::sqrt(sum) * max); | |
2322 } | 2300 } |
2323 | 2301 |
2324 // ES6 section 20.2.2.6 Math.atan ( x ) | 2302 // ES6 section 20.2.2.6 Math.atan ( x ) |
2325 void Builtins::Generate_MathAtan(CodeStubAssembler* assembler) { | 2303 void Builtins::Generate_MathAtan(CodeStubAssembler* assembler) { |
2326 using compiler::Node; | 2304 using compiler::Node; |
2327 | 2305 |
2328 Node* x = assembler->Parameter(1); | 2306 Node* x = assembler->Parameter(1); |
2329 Node* context = assembler->Parameter(4); | 2307 Node* context = assembler->Parameter(4); |
2330 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2308 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2331 Node* value = assembler->Float64Atan(x_value); | 2309 Node* value = assembler->Float64Atan(x_value); |
2332 Node* result = assembler->ChangeFloat64ToTagged(value); | 2310 Node* result = assembler->ChangeFloat64ToTagged(value); |
2333 assembler->Return(result); | 2311 assembler->Return(result); |
2334 } | 2312 } |
2335 | |
2336 // ES6 section 20.2.2.8 Math.atan2 ( y, x ) | |
2337 void Builtins::Generate_MathAtan2(CodeStubAssembler* assembler) { | |
2338 using compiler::Node; | |
2339 | |
2340 Node* y = assembler->Parameter(1); | |
2341 Node* x = assembler->Parameter(2); | |
2342 Node* context = assembler->Parameter(5); | |
2343 Node* y_value = assembler->TruncateTaggedToFloat64(context, y); | |
2344 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2345 Node* value = assembler->Float64Atan2(y_value, x_value); | |
2346 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2347 assembler->Return(result); | |
2348 } | |
2349 | 2313 |
2350 // ES6 section 20.2.2.7 Math.atanh ( x ) | 2314 // ES6 section 20.2.2.7 Math.atanh ( x ) |
2351 void Builtins::Generate_MathAtanh(CodeStubAssembler* assembler) { | 2315 void Builtins::Generate_MathAtanh(CodeStubAssembler* assembler) { |
2352 using compiler::Node; | 2316 using compiler::Node; |
2353 | 2317 |
2354 Node* x = assembler->Parameter(1); | 2318 Node* x = assembler->Parameter(1); |
2355 Node* context = assembler->Parameter(4); | 2319 Node* context = assembler->Parameter(4); |
2356 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2320 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2357 Node* value = assembler->Float64Atanh(x_value); | 2321 Node* value = assembler->Float64Atanh(x_value); |
2358 Node* result = assembler->ChangeFloat64ToTagged(value); | 2322 Node* result = assembler->ChangeFloat64ToTagged(value); |
2359 assembler->Return(result); | 2323 assembler->Return(result); |
2360 } | 2324 } |
2361 | 2325 |
2326 // ES6 section 20.2.2.8 Math.atan2 ( y, x ) | |
2327 void Builtins::Generate_MathAtan2(CodeStubAssembler* assembler) { | |
2328 using compiler::Node; | |
2329 | |
2330 Node* y = assembler->Parameter(1); | |
2331 Node* x = assembler->Parameter(2); | |
2332 Node* context = assembler->Parameter(5); | |
2333 Node* y_value = assembler->TruncateTaggedToFloat64(context, y); | |
2334 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2335 Node* value = assembler->Float64Atan2(y_value, x_value); | |
2336 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2337 assembler->Return(result); | |
2338 } | |
2339 | |
2362 namespace { | 2340 namespace { |
2363 | 2341 |
2364 void Generate_MathRoundingOperation( | 2342 void Generate_MathRoundingOperation( |
2365 CodeStubAssembler* assembler, | 2343 CodeStubAssembler* assembler, |
2366 compiler::Node* (CodeStubAssembler::*float64op)(compiler::Node*)) { | 2344 compiler::Node* (CodeStubAssembler::*float64op)(compiler::Node*)) { |
2367 typedef CodeStubAssembler::Label Label; | 2345 typedef CodeStubAssembler::Label Label; |
2368 typedef compiler::Node Node; | 2346 typedef compiler::Node Node; |
2369 typedef CodeStubAssembler::Variable Variable; | 2347 typedef CodeStubAssembler::Variable Variable; |
2370 | 2348 |
2371 Node* context = assembler->Parameter(4); | 2349 Node* context = assembler->Parameter(4); |
(...skipping 170 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2542 Node* result = assembler->ChangeFloat64ToTagged(value); | 2520 Node* result = assembler->ChangeFloat64ToTagged(value); |
2543 assembler->Return(result); | 2521 assembler->Return(result); |
2544 } | 2522 } |
2545 | 2523 |
2546 // ES6 section 20.2.2.16 Math.floor ( x ) | 2524 // ES6 section 20.2.2.16 Math.floor ( x ) |
2547 void Builtins::Generate_MathFloor(CodeStubAssembler* assembler) { | 2525 void Builtins::Generate_MathFloor(CodeStubAssembler* assembler) { |
2548 Generate_MathRoundingOperation(assembler, &CodeStubAssembler::Float64Floor); | 2526 Generate_MathRoundingOperation(assembler, &CodeStubAssembler::Float64Floor); |
2549 } | 2527 } |
2550 | 2528 |
2551 // ES6 section 20.2.2.17 Math.fround ( x ) | 2529 // ES6 section 20.2.2.17 Math.fround ( x ) |
2552 BUILTIN(MathFround) { | 2530 void Builtins::Generate_MathFround(CodeStubAssembler* assembler) { |
2531 using compiler::Node; | |
2532 | |
2533 Node* x = assembler->Parameter(1); | |
2534 Node* context = assembler->Parameter(4); | |
2535 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2536 Node* value32 = assembler->TruncateFloat64ToFloat32(x_value); | |
2537 Node* value = assembler->ChangeFloat32ToFloat64(value32); | |
2538 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2539 assembler->Return(result); | |
2540 } | |
2541 | |
2542 // ES6 section 20.2.2.18 Math.hypot ( value1, value2, ...values ) | |
2543 BUILTIN(MathHypot) { | |
2553 HandleScope scope(isolate); | 2544 HandleScope scope(isolate); |
2554 DCHECK_EQ(2, args.length()); | 2545 int const length = args.length() - 1; |
2555 Handle<Object> x = args.at<Object>(1); | 2546 if (length == 0) return Smi::FromInt(0); |
2556 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x, Object::ToNumber(x)); | 2547 DCHECK_LT(0, length); |
2557 float x32 = DoubleToFloat32(x->Number()); | 2548 double max = 0; |
2558 return *isolate->factory()->NewNumber(x32); | 2549 bool one_arg_is_nan = false; |
2550 List<double> abs_values(length); | |
2551 for (int i = 0; i < length; i++) { | |
2552 Handle<Object> x = args.at<Object>(i + 1); | |
2553 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x, Object::ToNumber(x)); | |
2554 double abs_value = std::abs(x->Number()); | |
2555 | |
2556 if (std::isnan(abs_value)) { | |
2557 one_arg_is_nan = true; | |
2558 } else { | |
2559 abs_values.Add(abs_value); | |
2560 if (max < abs_value) { | |
2561 max = abs_value; | |
2562 } | |
2563 } | |
2564 } | |
2565 | |
2566 if (max == V8_INFINITY) { | |
2567 return *isolate->factory()->NewNumber(V8_INFINITY); | |
2568 } | |
2569 | |
2570 if (one_arg_is_nan) { | |
2571 return *isolate->factory()->nan_value(); | |
2572 } | |
2573 | |
2574 if (max == 0) { | |
2575 return Smi::FromInt(0); | |
2576 } | |
2577 DCHECK_GT(max, 0); | |
2578 | |
2579 // Kahan summation to avoid rounding errors. | |
2580 // Normalize the numbers to the largest one to avoid overflow. | |
2581 double sum = 0; | |
2582 double compensation = 0; | |
2583 for (int i = 0; i < length; i++) { | |
2584 double n = abs_values.at(i) / max; | |
2585 double summand = n * n - compensation; | |
2586 double preliminary = sum + summand; | |
2587 compensation = (preliminary - sum) - summand; | |
2588 sum = preliminary; | |
2589 } | |
2590 | |
2591 return *isolate->factory()->NewNumber(std::sqrt(sum) * max); | |
2559 } | 2592 } |
2560 | 2593 |
2561 // ES6 section 20.2.2.19 Math.imul ( x, y ) | 2594 // ES6 section 20.2.2.19 Math.imul ( x, y ) |
2562 BUILTIN(MathImul) { | 2595 void Builtins::Generate_MathImul(CodeStubAssembler* assembler) { |
2563 HandleScope scope(isolate); | 2596 using compiler::Node; |
2564 DCHECK_EQ(3, args.length()); | 2597 |
2565 Handle<Object> x = args.at<Object>(1); | 2598 Node* x = assembler->Parameter(1); |
2566 Handle<Object> y = args.at<Object>(2); | 2599 Node* y = assembler->Parameter(2); |
2567 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, x, Object::ToNumber(x)); | 2600 Node* context = assembler->Parameter(5); |
2568 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, y, Object::ToNumber(y)); | 2601 Node* x_value = assembler->TruncateTaggedToWord32(context, x); |
2569 int product = static_cast<int>(NumberToUint32(*x) * NumberToUint32(*y)); | 2602 Node* y_value = assembler->TruncateTaggedToWord32(context, y); |
2570 return *isolate->factory()->NewNumberFromInt(product); | 2603 Node* value = assembler->Int32Mul(x_value, y_value); |
2604 Node* result = assembler->ChangeInt32ToTagged(value); | |
2605 assembler->Return(result); | |
2571 } | 2606 } |
2572 | 2607 |
2573 // ES6 section 20.2.2.20 Math.log ( x ) | 2608 // ES6 section 20.2.2.20 Math.log ( x ) |
2574 void Builtins::Generate_MathLog(CodeStubAssembler* assembler) { | 2609 void Builtins::Generate_MathLog(CodeStubAssembler* assembler) { |
2575 using compiler::Node; | 2610 using compiler::Node; |
2576 | 2611 |
2577 Node* x = assembler->Parameter(1); | 2612 Node* x = assembler->Parameter(1); |
2578 Node* context = assembler->Parameter(4); | 2613 Node* context = assembler->Parameter(4); |
2579 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2614 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2580 Node* value = assembler->Float64Log(x_value); | 2615 Node* value = assembler->Float64Log(x_value); |
2581 Node* result = assembler->ChangeFloat64ToTagged(value); | 2616 Node* result = assembler->ChangeFloat64ToTagged(value); |
2582 assembler->Return(result); | 2617 assembler->Return(result); |
2583 } | 2618 } |
2584 | 2619 |
2585 // ES6 section 20.2.2.21 Math.log1p ( x ) | 2620 // ES6 section 20.2.2.21 Math.log1p ( x ) |
2586 void Builtins::Generate_MathLog1p(CodeStubAssembler* assembler) { | 2621 void Builtins::Generate_MathLog1p(CodeStubAssembler* assembler) { |
2587 using compiler::Node; | 2622 using compiler::Node; |
2588 | 2623 |
2589 Node* x = assembler->Parameter(1); | 2624 Node* x = assembler->Parameter(1); |
2590 Node* context = assembler->Parameter(4); | 2625 Node* context = assembler->Parameter(4); |
2591 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2626 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2592 Node* value = assembler->Float64Log1p(x_value); | 2627 Node* value = assembler->Float64Log1p(x_value); |
2593 Node* result = assembler->ChangeFloat64ToTagged(value); | 2628 Node* result = assembler->ChangeFloat64ToTagged(value); |
2594 assembler->Return(result); | 2629 assembler->Return(result); |
2595 } | 2630 } |
2596 | 2631 |
2632 // ES6 section 20.2.2.22 Math.log10 ( x ) | |
2633 void Builtins::Generate_MathLog10(CodeStubAssembler* assembler) { | |
2634 using compiler::Node; | |
2635 | |
2636 Node* x = assembler->Parameter(1); | |
2637 Node* context = assembler->Parameter(4); | |
2638 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2639 Node* value = assembler->Float64Log10(x_value); | |
2640 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2641 assembler->Return(result); | |
2642 } | |
2643 | |
2597 // ES6 section 20.2.2.23 Math.log2 ( x ) | 2644 // ES6 section 20.2.2.23 Math.log2 ( x ) |
2598 void Builtins::Generate_MathLog2(CodeStubAssembler* assembler) { | 2645 void Builtins::Generate_MathLog2(CodeStubAssembler* assembler) { |
2599 using compiler::Node; | 2646 using compiler::Node; |
2600 | 2647 |
2601 Node* x = assembler->Parameter(1); | 2648 Node* x = assembler->Parameter(1); |
2602 Node* context = assembler->Parameter(4); | 2649 Node* context = assembler->Parameter(4); |
2603 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2650 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2604 Node* value = assembler->Float64Log2(x_value); | 2651 Node* value = assembler->Float64Log2(x_value); |
2605 Node* result = assembler->ChangeFloat64ToTagged(value); | 2652 Node* result = assembler->ChangeFloat64ToTagged(value); |
2606 assembler->Return(result); | 2653 assembler->Return(result); |
2607 } | 2654 } |
2608 | |
2609 // ES6 section 20.2.2.22 Math.log10 ( x ) | |
2610 void Builtins::Generate_MathLog10(CodeStubAssembler* assembler) { | |
2611 using compiler::Node; | |
2612 | |
2613 Node* x = assembler->Parameter(1); | |
2614 Node* context = assembler->Parameter(4); | |
2615 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2616 Node* value = assembler->Float64Log10(x_value); | |
2617 Node* result = assembler->ChangeFloat64ToTagged(value); | |
2618 assembler->Return(result); | |
2619 } | |
2620 | 2655 |
2621 // ES6 section 20.2.2.15 Math.expm1 ( x ) | 2656 // ES6 section 20.2.2.15 Math.expm1 ( x ) |
2622 void Builtins::Generate_MathExpm1(CodeStubAssembler* assembler) { | 2657 void Builtins::Generate_MathExpm1(CodeStubAssembler* assembler) { |
2623 using compiler::Node; | 2658 using compiler::Node; |
2624 | 2659 |
2625 Node* x = assembler->Parameter(1); | 2660 Node* x = assembler->Parameter(1); |
2626 Node* context = assembler->Parameter(4); | 2661 Node* context = assembler->Parameter(4); |
2627 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2662 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2628 Node* value = assembler->Float64Expm1(x_value); | 2663 Node* value = assembler->Float64Expm1(x_value); |
2629 Node* result = assembler->ChangeFloat64ToTagged(value); | 2664 Node* result = assembler->ChangeFloat64ToTagged(value); |
2630 assembler->Return(result); | 2665 assembler->Return(result); |
2631 } | 2666 } |
2632 | 2667 |
2633 // ES6 section 20.2.2.28 Math.round ( x ) | |
2634 void Builtins::Generate_MathRound(CodeStubAssembler* assembler) { | |
2635 Generate_MathRoundingOperation(assembler, &CodeStubAssembler::Float64Round); | |
2636 } | |
2637 | |
2638 // ES6 section 20.2.2.26 Math.pow ( x, y ) | 2668 // ES6 section 20.2.2.26 Math.pow ( x, y ) |
2639 void Builtins::Generate_MathPow(CodeStubAssembler* assembler) { | 2669 void Builtins::Generate_MathPow(CodeStubAssembler* assembler) { |
2640 using compiler::Node; | 2670 using compiler::Node; |
2641 | 2671 |
2642 Node* x = assembler->Parameter(1); | 2672 Node* x = assembler->Parameter(1); |
2643 Node* y = assembler->Parameter(2); | 2673 Node* y = assembler->Parameter(2); |
2644 Node* context = assembler->Parameter(5); | 2674 Node* context = assembler->Parameter(5); |
2645 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2675 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2646 Node* y_value = assembler->TruncateTaggedToFloat64(context, y); | 2676 Node* y_value = assembler->TruncateTaggedToFloat64(context, y); |
2647 Node* value = assembler->Float64Pow(x_value, y_value); | 2677 Node* value = assembler->Float64Pow(x_value, y_value); |
2648 Node* result = assembler->ChangeFloat64ToTagged(value); | 2678 Node* result = assembler->ChangeFloat64ToTagged(value); |
2649 assembler->Return(result); | 2679 assembler->Return(result); |
2650 } | 2680 } |
2651 | 2681 |
2682 // ES6 section 20.2.2.28 Math.round ( x ) | |
2683 void Builtins::Generate_MathRound(CodeStubAssembler* assembler) { | |
2684 Generate_MathRoundingOperation(assembler, &CodeStubAssembler::Float64Round); | |
2685 } | |
2686 | |
2687 // ES6 section 20.2.2.29 Math.sign ( x ) | |
2688 void Builtins::Generate_MathSign(CodeStubAssembler* assembler) { | |
2689 typedef CodeStubAssembler::Label Label; | |
2690 using compiler::Node; | |
2691 | |
2692 // Convert the {x} value to a Number. | |
2693 Node* x = assembler->Parameter(1); | |
2694 Node* context = assembler->Parameter(4); | |
2695 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | |
2696 | |
2697 // Return -1 if {x} is negative, 1 if {x} is positive, or {x} itself. | |
2698 Label if_xisnegative(assembler), if_xispositive(assembler); | |
2699 assembler->GotoIf( | |
2700 assembler->Float64LessThan(x_value, assembler->Float64Constant(0.0)), | |
2701 &if_xisnegative); | |
2702 assembler->GotoIf( | |
2703 assembler->Float64LessThan(assembler->Float64Constant(0.0), x_value), | |
2704 &if_xispositive); | |
2705 assembler->Return(assembler->ChangeFloat64ToTagged(x_value)); | |
Franzi
2016/07/01 09:09:48
Can we return x instead of converting the float ba
Benedikt Meurer
2016/07/01 10:48:33
No we can't because x can be anything, not even a
| |
2706 | |
2707 assembler->Bind(&if_xisnegative); | |
2708 assembler->Return(assembler->SmiConstant(Smi::FromInt(-1))); | |
2709 | |
2710 assembler->Bind(&if_xispositive); | |
2711 assembler->Return(assembler->SmiConstant(Smi::FromInt(1))); | |
2712 } | |
2713 | |
2652 // ES6 section 20.2.2.30 Math.sin ( x ) | 2714 // ES6 section 20.2.2.30 Math.sin ( x ) |
2653 void Builtins::Generate_MathSin(CodeStubAssembler* assembler) { | 2715 void Builtins::Generate_MathSin(CodeStubAssembler* assembler) { |
2654 using compiler::Node; | 2716 using compiler::Node; |
2655 | 2717 |
2656 Node* x = assembler->Parameter(1); | 2718 Node* x = assembler->Parameter(1); |
2657 Node* context = assembler->Parameter(4); | 2719 Node* context = assembler->Parameter(4); |
2658 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); | 2720 Node* x_value = assembler->TruncateTaggedToFloat64(context, x); |
2659 Node* value = assembler->Float64Sin(x_value); | 2721 Node* value = assembler->Float64Sin(x_value); |
2660 Node* result = assembler->ChangeFloat64ToTagged(value); | 2722 Node* result = assembler->ChangeFloat64ToTagged(value); |
2661 assembler->Return(result); | 2723 assembler->Return(result); |
(...skipping 3693 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6355 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H) | 6417 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H) |
6356 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A) | 6418 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A) |
6357 #undef DEFINE_BUILTIN_ACCESSOR_C | 6419 #undef DEFINE_BUILTIN_ACCESSOR_C |
6358 #undef DEFINE_BUILTIN_ACCESSOR_A | 6420 #undef DEFINE_BUILTIN_ACCESSOR_A |
6359 #undef DEFINE_BUILTIN_ACCESSOR_T | 6421 #undef DEFINE_BUILTIN_ACCESSOR_T |
6360 #undef DEFINE_BUILTIN_ACCESSOR_S | 6422 #undef DEFINE_BUILTIN_ACCESSOR_S |
6361 #undef DEFINE_BUILTIN_ACCESSOR_H | 6423 #undef DEFINE_BUILTIN_ACCESSOR_H |
6362 | 6424 |
6363 } // namespace internal | 6425 } // namespace internal |
6364 } // namespace v8 | 6426 } // namespace v8 |
OLD | NEW |