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/code-stubs.h" | 5 #include "src/code-stubs.h" |
6 | 6 |
7 #include <sstream> | 7 #include <sstream> |
8 | 8 |
9 #include "src/bootstrapper.h" | 9 #include "src/bootstrapper.h" |
10 #include "src/code-factory.h" | 10 #include "src/code-factory.h" |
(...skipping 469 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
480 | 480 |
481 void StringLengthStub::GenerateAssembly(CodeStubAssembler* assembler) const { | 481 void StringLengthStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
482 compiler::Node* value = assembler->Parameter(0); | 482 compiler::Node* value = assembler->Parameter(0); |
483 compiler::Node* string = | 483 compiler::Node* string = |
484 assembler->LoadObjectField(value, JSValue::kValueOffset); | 484 assembler->LoadObjectField(value, JSValue::kValueOffset); |
485 compiler::Node* result = | 485 compiler::Node* result = |
486 assembler->LoadObjectField(string, String::kLengthOffset); | 486 assembler->LoadObjectField(string, String::kLengthOffset); |
487 assembler->Return(result); | 487 assembler->Return(result); |
488 } | 488 } |
489 | 489 |
490 // static | 490 void AddStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
491 compiler::Node* AddStub::Generate(CodeStubAssembler* assembler, | |
492 compiler::Node* left, compiler::Node* right, | |
493 compiler::Node* context) { | |
494 typedef CodeStubAssembler::Label Label; | 491 typedef CodeStubAssembler::Label Label; |
495 typedef compiler::Node Node; | 492 typedef compiler::Node Node; |
496 typedef CodeStubAssembler::Variable Variable; | 493 typedef CodeStubAssembler::Variable Variable; |
497 | 494 |
| 495 Node* context = assembler->Parameter(2); |
| 496 |
498 // Shared entry for floating point addition. | 497 // Shared entry for floating point addition. |
499 Label do_fadd(assembler); | 498 Label do_fadd(assembler); |
500 Variable var_fadd_lhs(assembler, MachineRepresentation::kFloat64), | 499 Variable var_fadd_lhs(assembler, MachineRepresentation::kFloat64), |
501 var_fadd_rhs(assembler, MachineRepresentation::kFloat64); | 500 var_fadd_rhs(assembler, MachineRepresentation::kFloat64); |
502 | 501 |
503 // We might need to loop several times due to ToPrimitive, ToString and/or | 502 // We might need to loop several times due to ToPrimitive, ToString and/or |
504 // ToNumber conversions. | 503 // ToNumber conversions. |
505 Variable var_lhs(assembler, MachineRepresentation::kTagged), | 504 Variable var_lhs(assembler, MachineRepresentation::kTagged), |
506 var_rhs(assembler, MachineRepresentation::kTagged), | 505 var_rhs(assembler, MachineRepresentation::kTagged); |
507 var_result(assembler, MachineRepresentation::kTagged); | |
508 Variable* loop_vars[2] = {&var_lhs, &var_rhs}; | 506 Variable* loop_vars[2] = {&var_lhs, &var_rhs}; |
509 Label loop(assembler, 2, loop_vars), end(assembler), | 507 Label loop(assembler, 2, loop_vars); |
510 string_add_convert_left(assembler, Label::kDeferred), | 508 var_lhs.Bind(assembler->Parameter(0)); |
511 string_add_convert_right(assembler, Label::kDeferred); | 509 var_rhs.Bind(assembler->Parameter(1)); |
512 var_lhs.Bind(left); | |
513 var_rhs.Bind(right); | |
514 assembler->Goto(&loop); | 510 assembler->Goto(&loop); |
515 assembler->Bind(&loop); | 511 assembler->Bind(&loop); |
516 { | 512 { |
517 // Load the current {lhs} and {rhs} values. | 513 // Load the current {lhs} and {rhs} values. |
518 Node* lhs = var_lhs.value(); | 514 Node* lhs = var_lhs.value(); |
519 Node* rhs = var_rhs.value(); | 515 Node* rhs = var_rhs.value(); |
520 | 516 |
521 // Check if the {lhs} is a Smi or a HeapObject. | 517 // Check if the {lhs} is a Smi or a HeapObject. |
522 Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler); | 518 Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler); |
523 assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); | 519 assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); |
(...skipping 16 matching lines...) Expand all Loading... |
540 assembler->Branch(overflow, &if_overflow, &if_notoverflow); | 536 assembler->Branch(overflow, &if_overflow, &if_notoverflow); |
541 | 537 |
542 assembler->Bind(&if_overflow); | 538 assembler->Bind(&if_overflow); |
543 { | 539 { |
544 var_fadd_lhs.Bind(assembler->SmiToFloat64(lhs)); | 540 var_fadd_lhs.Bind(assembler->SmiToFloat64(lhs)); |
545 var_fadd_rhs.Bind(assembler->SmiToFloat64(rhs)); | 541 var_fadd_rhs.Bind(assembler->SmiToFloat64(rhs)); |
546 assembler->Goto(&do_fadd); | 542 assembler->Goto(&do_fadd); |
547 } | 543 } |
548 | 544 |
549 assembler->Bind(&if_notoverflow); | 545 assembler->Bind(&if_notoverflow); |
550 var_result.Bind(assembler->Projection(0, pair)); | 546 assembler->Return(assembler->Projection(0, pair)); |
551 assembler->Goto(&end); | |
552 } | 547 } |
553 | 548 |
554 assembler->Bind(&if_rhsisnotsmi); | 549 assembler->Bind(&if_rhsisnotsmi); |
555 { | 550 { |
556 // Load the map of {rhs}. | 551 // Load the map of {rhs}. |
557 Node* rhs_map = assembler->LoadObjectField(rhs, HeapObject::kMapOffset); | 552 Node* rhs_map = assembler->LoadObjectField(rhs, HeapObject::kMapOffset); |
558 | 553 |
559 // Check if the {rhs} is a HeapNumber. | 554 // Check if the {rhs} is a HeapNumber. |
560 Label if_rhsisnumber(assembler), | 555 Label if_rhsisnumber(assembler), |
561 if_rhsisnotnumber(assembler, Label::kDeferred); | 556 if_rhsisnotnumber(assembler, Label::kDeferred); |
(...skipping 16 matching lines...) Expand all Loading... |
578 // Check if the {rhs} is a String. | 573 // Check if the {rhs} is a String. |
579 Label if_rhsisstring(assembler, Label::kDeferred), | 574 Label if_rhsisstring(assembler, Label::kDeferred), |
580 if_rhsisnotstring(assembler, Label::kDeferred); | 575 if_rhsisnotstring(assembler, Label::kDeferred); |
581 assembler->Branch(assembler->Int32LessThan( | 576 assembler->Branch(assembler->Int32LessThan( |
582 rhs_instance_type, | 577 rhs_instance_type, |
583 assembler->Int32Constant(FIRST_NONSTRING_TYPE)), | 578 assembler->Int32Constant(FIRST_NONSTRING_TYPE)), |
584 &if_rhsisstring, &if_rhsisnotstring); | 579 &if_rhsisstring, &if_rhsisnotstring); |
585 | 580 |
586 assembler->Bind(&if_rhsisstring); | 581 assembler->Bind(&if_rhsisstring); |
587 { | 582 { |
588 var_lhs.Bind(lhs); | 583 // Convert {lhs}, which is a Smi, to a String and concatenate the |
589 var_rhs.Bind(rhs); | 584 // resulting string with the String {rhs}. |
590 assembler->Goto(&string_add_convert_left); | 585 Callable callable = CodeFactory::StringAdd( |
| 586 assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED); |
| 587 assembler->TailCallStub(callable, context, lhs, rhs); |
591 } | 588 } |
592 | 589 |
593 assembler->Bind(&if_rhsisnotstring); | 590 assembler->Bind(&if_rhsisnotstring); |
594 { | 591 { |
595 // Check if {rhs} is a JSReceiver. | 592 // Check if {rhs} is a JSReceiver. |
596 Label if_rhsisreceiver(assembler, Label::kDeferred), | 593 Label if_rhsisreceiver(assembler, Label::kDeferred), |
597 if_rhsisnotreceiver(assembler, Label::kDeferred); | 594 if_rhsisnotreceiver(assembler, Label::kDeferred); |
598 assembler->Branch( | 595 assembler->Branch( |
599 assembler->Int32LessThanOrEqual( | 596 assembler->Int32LessThanOrEqual( |
600 assembler->Int32Constant(FIRST_JS_RECEIVER_TYPE), | 597 assembler->Int32Constant(FIRST_JS_RECEIVER_TYPE), |
(...skipping 29 matching lines...) Expand all Loading... |
630 | 627 |
631 // Check if {lhs} is a String. | 628 // Check if {lhs} is a String. |
632 Label if_lhsisstring(assembler), if_lhsisnotstring(assembler); | 629 Label if_lhsisstring(assembler), if_lhsisnotstring(assembler); |
633 assembler->Branch(assembler->Int32LessThan( | 630 assembler->Branch(assembler->Int32LessThan( |
634 lhs_instance_type, | 631 lhs_instance_type, |
635 assembler->Int32Constant(FIRST_NONSTRING_TYPE)), | 632 assembler->Int32Constant(FIRST_NONSTRING_TYPE)), |
636 &if_lhsisstring, &if_lhsisnotstring); | 633 &if_lhsisstring, &if_lhsisnotstring); |
637 | 634 |
638 assembler->Bind(&if_lhsisstring); | 635 assembler->Bind(&if_lhsisstring); |
639 { | 636 { |
640 var_lhs.Bind(lhs); | 637 // Convert {rhs} to a String (using the sequence of ToPrimitive with |
641 var_rhs.Bind(rhs); | 638 // no hint followed by ToString) and concatenate the strings. |
642 assembler->Goto(&string_add_convert_right); | 639 Callable callable = CodeFactory::StringAdd( |
| 640 assembler->isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED); |
| 641 assembler->TailCallStub(callable, context, lhs, rhs); |
643 } | 642 } |
644 | 643 |
645 assembler->Bind(&if_lhsisnotstring); | 644 assembler->Bind(&if_lhsisnotstring); |
646 { | 645 { |
647 // Check if {rhs} is a Smi. | 646 // Check if {rhs} is a Smi. |
648 Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler); | 647 Label if_rhsissmi(assembler), if_rhsisnotsmi(assembler); |
649 assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, | 648 assembler->Branch(assembler->WordIsSmi(rhs), &if_rhsissmi, |
650 &if_rhsisnotsmi); | 649 &if_rhsisnotsmi); |
651 | 650 |
652 assembler->Bind(&if_rhsissmi); | 651 assembler->Bind(&if_rhsissmi); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
706 | 705 |
707 // Check if {rhs} is a String. | 706 // Check if {rhs} is a String. |
708 Label if_rhsisstring(assembler), if_rhsisnotstring(assembler); | 707 Label if_rhsisstring(assembler), if_rhsisnotstring(assembler); |
709 assembler->Branch(assembler->Int32LessThan( | 708 assembler->Branch(assembler->Int32LessThan( |
710 rhs_instance_type, | 709 rhs_instance_type, |
711 assembler->Int32Constant(FIRST_NONSTRING_TYPE)), | 710 assembler->Int32Constant(FIRST_NONSTRING_TYPE)), |
712 &if_rhsisstring, &if_rhsisnotstring); | 711 &if_rhsisstring, &if_rhsisnotstring); |
713 | 712 |
714 assembler->Bind(&if_rhsisstring); | 713 assembler->Bind(&if_rhsisstring); |
715 { | 714 { |
716 var_lhs.Bind(lhs); | 715 // Convert {lhs} to a String (using the sequence of ToPrimitive with |
717 var_rhs.Bind(rhs); | 716 // no hint followed by ToString) and concatenate the strings. |
718 assembler->Goto(&string_add_convert_left); | 717 Callable callable = CodeFactory::StringAdd( |
| 718 assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED); |
| 719 assembler->TailCallStub(callable, context, lhs, rhs); |
719 } | 720 } |
720 | 721 |
721 assembler->Bind(&if_rhsisnotstring); | 722 assembler->Bind(&if_rhsisnotstring); |
722 { | 723 { |
723 // Check if {lhs} is a HeapNumber. | 724 // Check if {lhs} is a HeapNumber. |
724 Label if_lhsisnumber(assembler), if_lhsisnotnumber(assembler); | 725 Label if_lhsisnumber(assembler), if_lhsisnotnumber(assembler); |
725 assembler->Branch(assembler->Word32Equal( | 726 assembler->Branch(assembler->Word32Equal( |
726 lhs_instance_type, | 727 lhs_instance_type, |
727 assembler->Int32Constant(HEAP_NUMBER_TYPE)), | 728 assembler->Int32Constant(HEAP_NUMBER_TYPE)), |
728 &if_lhsisnumber, &if_lhsisnotnumber); | 729 &if_lhsisnumber, &if_lhsisnotnumber); |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
824 var_lhs.Bind(assembler->CallStub(callable, context, lhs)); | 825 var_lhs.Bind(assembler->CallStub(callable, context, lhs)); |
825 assembler->Goto(&loop); | 826 assembler->Goto(&loop); |
826 } | 827 } |
827 } | 828 } |
828 } | 829 } |
829 } | 830 } |
830 } | 831 } |
831 } | 832 } |
832 } | 833 } |
833 } | 834 } |
834 assembler->Bind(&string_add_convert_left); | |
835 { | |
836 // Convert {lhs}, which is a Smi, to a String and concatenate the | |
837 // resulting string with the String {rhs}. | |
838 Callable callable = CodeFactory::StringAdd( | |
839 assembler->isolate(), STRING_ADD_CONVERT_LEFT, NOT_TENURED); | |
840 var_result.Bind(assembler->CallStub(callable, context, var_lhs.value(), | |
841 var_rhs.value())); | |
842 assembler->Goto(&end); | |
843 } | |
844 | |
845 assembler->Bind(&string_add_convert_right); | |
846 { | |
847 // Convert {lhs}, which is a Smi, to a String and concatenate the | |
848 // resulting string with the String {rhs}. | |
849 Callable callable = CodeFactory::StringAdd( | |
850 assembler->isolate(), STRING_ADD_CONVERT_RIGHT, NOT_TENURED); | |
851 var_result.Bind(assembler->CallStub(callable, context, var_lhs.value(), | |
852 var_rhs.value())); | |
853 assembler->Goto(&end); | |
854 } | |
855 | 835 |
856 assembler->Bind(&do_fadd); | 836 assembler->Bind(&do_fadd); |
857 { | 837 { |
858 Node* lhs_value = var_fadd_lhs.value(); | 838 Node* lhs_value = var_fadd_lhs.value(); |
859 Node* rhs_value = var_fadd_rhs.value(); | 839 Node* rhs_value = var_fadd_rhs.value(); |
860 Node* value = assembler->Float64Add(lhs_value, rhs_value); | 840 Node* value = assembler->Float64Add(lhs_value, rhs_value); |
861 Node* result = assembler->ChangeFloat64ToTagged(value); | 841 Node* result = assembler->ChangeFloat64ToTagged(value); |
862 var_result.Bind(result); | 842 assembler->Return(result); |
863 assembler->Goto(&end); | |
864 } | 843 } |
865 assembler->Bind(&end); | |
866 return var_result.value(); | |
867 } | 844 } |
868 | 845 |
869 // static | 846 void SubtractStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
870 compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler, | |
871 compiler::Node* left, | |
872 compiler::Node* right, | |
873 compiler::Node* context) { | |
874 typedef CodeStubAssembler::Label Label; | 847 typedef CodeStubAssembler::Label Label; |
875 typedef compiler::Node Node; | 848 typedef compiler::Node Node; |
876 typedef CodeStubAssembler::Variable Variable; | 849 typedef CodeStubAssembler::Variable Variable; |
877 | 850 |
| 851 Node* context = assembler->Parameter(2); |
| 852 |
878 // Shared entry for floating point subtraction. | 853 // Shared entry for floating point subtraction. |
879 Label do_fsub(assembler), end(assembler); | 854 Label do_fsub(assembler); |
880 Variable var_fsub_lhs(assembler, MachineRepresentation::kFloat64), | 855 Variable var_fsub_lhs(assembler, MachineRepresentation::kFloat64), |
881 var_fsub_rhs(assembler, MachineRepresentation::kFloat64); | 856 var_fsub_rhs(assembler, MachineRepresentation::kFloat64); |
882 | 857 |
883 // We might need to loop several times due to ToPrimitive and/or ToNumber | 858 // We might need to loop several times due to ToPrimitive and/or ToNumber |
884 // conversions. | 859 // conversions. |
885 Variable var_lhs(assembler, MachineRepresentation::kTagged), | 860 Variable var_lhs(assembler, MachineRepresentation::kTagged), |
886 var_rhs(assembler, MachineRepresentation::kTagged), | 861 var_rhs(assembler, MachineRepresentation::kTagged); |
887 var_result(assembler, MachineRepresentation::kTagged); | |
888 Variable* loop_vars[2] = {&var_lhs, &var_rhs}; | 862 Variable* loop_vars[2] = {&var_lhs, &var_rhs}; |
889 Label loop(assembler, 2, loop_vars); | 863 Label loop(assembler, 2, loop_vars); |
890 var_lhs.Bind(left); | 864 var_lhs.Bind(assembler->Parameter(0)); |
891 var_rhs.Bind(right); | 865 var_rhs.Bind(assembler->Parameter(1)); |
892 assembler->Goto(&loop); | 866 assembler->Goto(&loop); |
893 assembler->Bind(&loop); | 867 assembler->Bind(&loop); |
894 { | 868 { |
895 // Load the current {lhs} and {rhs} values. | 869 // Load the current {lhs} and {rhs} values. |
896 Node* lhs = var_lhs.value(); | 870 Node* lhs = var_lhs.value(); |
897 Node* rhs = var_rhs.value(); | 871 Node* rhs = var_rhs.value(); |
898 | 872 |
899 // Check if the {lhs} is a Smi or a HeapObject. | 873 // Check if the {lhs} is a Smi or a HeapObject. |
900 Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler); | 874 Label if_lhsissmi(assembler), if_lhsisnotsmi(assembler); |
901 assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); | 875 assembler->Branch(assembler->WordIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi); |
(...skipping 17 matching lines...) Expand all Loading... |
919 | 893 |
920 assembler->Bind(&if_overflow); | 894 assembler->Bind(&if_overflow); |
921 { | 895 { |
922 // The result doesn't fit into Smi range. | 896 // The result doesn't fit into Smi range. |
923 var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs)); | 897 var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs)); |
924 var_fsub_rhs.Bind(assembler->SmiToFloat64(rhs)); | 898 var_fsub_rhs.Bind(assembler->SmiToFloat64(rhs)); |
925 assembler->Goto(&do_fsub); | 899 assembler->Goto(&do_fsub); |
926 } | 900 } |
927 | 901 |
928 assembler->Bind(&if_notoverflow); | 902 assembler->Bind(&if_notoverflow); |
929 var_result.Bind(assembler->Projection(0, pair)); | 903 assembler->Return(assembler->Projection(0, pair)); |
930 assembler->Goto(&end); | |
931 } | 904 } |
932 | 905 |
933 assembler->Bind(&if_rhsisnotsmi); | 906 assembler->Bind(&if_rhsisnotsmi); |
934 { | 907 { |
935 // Load the map of the {rhs}. | 908 // Load the map of the {rhs}. |
936 Node* rhs_map = assembler->LoadMap(rhs); | 909 Node* rhs_map = assembler->LoadMap(rhs); |
937 | 910 |
938 // Check if {rhs} is a HeapNumber. | 911 // Check if {rhs} is a HeapNumber. |
939 Label if_rhsisnumber(assembler), | 912 Label if_rhsisnumber(assembler), |
940 if_rhsisnotnumber(assembler, Label::kDeferred); | 913 if_rhsisnotnumber(assembler, Label::kDeferred); |
941 Node* number_map = assembler->HeapNumberMapConstant(); | 914 Node* number_map = assembler->HeapNumberMapConstant(); |
942 assembler->Branch(assembler->WordEqual(rhs_map, number_map), | 915 assembler->Branch(assembler->WordEqual(rhs_map, number_map), |
943 &if_rhsisnumber, &if_rhsisnotnumber); | 916 &if_rhsisnumber, &if_rhsisnotnumber); |
944 | 917 |
945 assembler->Bind(&if_rhsisnumber); | 918 assembler->Bind(&if_rhsisnumber); |
946 { | 919 { |
947 // Perform a floating point subtraction. | 920 // Perform a floating point subtraction. |
948 var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs)); | 921 var_fsub_lhs.Bind(assembler->SmiToFloat64(lhs)); |
949 var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs)); | 922 var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs)); |
950 assembler->Goto(&do_fsub); | 923 assembler->Goto(&do_fsub); |
951 } | 924 } |
952 | 925 |
953 assembler->Bind(&if_rhsisnotnumber); | 926 assembler->Bind(&if_rhsisnotnumber); |
954 { | 927 { |
955 // Convert the {rhs} to a Number first. | 928 // Convert the {rhs} to a Number first. |
956 Callable callable = | 929 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
957 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
958 var_rhs.Bind(assembler->CallStub(callable, context, rhs)); | 930 var_rhs.Bind(assembler->CallStub(callable, context, rhs)); |
959 assembler->Goto(&loop); | 931 assembler->Goto(&loop); |
960 } | 932 } |
961 } | 933 } |
962 } | 934 } |
963 | 935 |
964 assembler->Bind(&if_lhsisnotsmi); | 936 assembler->Bind(&if_lhsisnotsmi); |
965 { | 937 { |
966 // Load the map of the {lhs}. | 938 // Load the map of the {lhs}. |
967 Node* lhs_map = assembler->LoadMap(lhs); | 939 Node* lhs_map = assembler->LoadMap(lhs); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1003 { | 975 { |
1004 // Perform a floating point subtraction. | 976 // Perform a floating point subtraction. |
1005 var_fsub_lhs.Bind(assembler->LoadHeapNumberValue(lhs)); | 977 var_fsub_lhs.Bind(assembler->LoadHeapNumberValue(lhs)); |
1006 var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs)); | 978 var_fsub_rhs.Bind(assembler->LoadHeapNumberValue(rhs)); |
1007 assembler->Goto(&do_fsub); | 979 assembler->Goto(&do_fsub); |
1008 } | 980 } |
1009 | 981 |
1010 assembler->Bind(&if_rhsisnotnumber); | 982 assembler->Bind(&if_rhsisnotnumber); |
1011 { | 983 { |
1012 // Convert the {rhs} to a Number first. | 984 // Convert the {rhs} to a Number first. |
1013 Callable callable = | 985 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1014 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1015 var_rhs.Bind(assembler->CallStub(callable, context, rhs)); | 986 var_rhs.Bind(assembler->CallStub(callable, context, rhs)); |
1016 assembler->Goto(&loop); | 987 assembler->Goto(&loop); |
1017 } | 988 } |
1018 } | 989 } |
1019 } | 990 } |
1020 | 991 |
1021 assembler->Bind(&if_lhsisnotnumber); | 992 assembler->Bind(&if_lhsisnotnumber); |
1022 { | 993 { |
1023 // Convert the {lhs} to a Number first. | 994 // Convert the {lhs} to a Number first. |
1024 Callable callable = | 995 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1025 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1026 var_lhs.Bind(assembler->CallStub(callable, context, lhs)); | 996 var_lhs.Bind(assembler->CallStub(callable, context, lhs)); |
1027 assembler->Goto(&loop); | 997 assembler->Goto(&loop); |
1028 } | 998 } |
1029 } | 999 } |
1030 } | 1000 } |
1031 | 1001 |
1032 assembler->Bind(&do_fsub); | 1002 assembler->Bind(&do_fsub); |
1033 { | 1003 { |
1034 Node* lhs_value = var_fsub_lhs.value(); | 1004 Node* lhs_value = var_fsub_lhs.value(); |
1035 Node* rhs_value = var_fsub_rhs.value(); | 1005 Node* rhs_value = var_fsub_rhs.value(); |
1036 Node* value = assembler->Float64Sub(lhs_value, rhs_value); | 1006 Node* value = assembler->Float64Sub(lhs_value, rhs_value); |
1037 var_result.Bind(assembler->ChangeFloat64ToTagged(value)); | 1007 Node* result = assembler->ChangeFloat64ToTagged(value); |
1038 assembler->Goto(&end); | 1008 assembler->Return(result); |
1039 } | 1009 } |
1040 assembler->Bind(&end); | |
1041 return var_result.value(); | |
1042 } | 1010 } |
1043 | 1011 |
1044 // static | 1012 void MultiplyStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1045 compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler, | |
1046 compiler::Node* left, | |
1047 compiler::Node* right, | |
1048 compiler::Node* context) { | |
1049 using compiler::Node; | 1013 using compiler::Node; |
1050 typedef CodeStubAssembler::Label Label; | 1014 typedef CodeStubAssembler::Label Label; |
1051 typedef CodeStubAssembler::Variable Variable; | 1015 typedef CodeStubAssembler::Variable Variable; |
1052 | 1016 |
| 1017 Node* context = assembler->Parameter(2); |
| 1018 |
1053 // Shared entry point for floating point multiplication. | 1019 // Shared entry point for floating point multiplication. |
1054 Label do_fmul(assembler); | 1020 Label do_fmul(assembler); |
1055 Variable var_lhs_float64(assembler, MachineRepresentation::kFloat64), | 1021 Variable var_lhs_float64(assembler, MachineRepresentation::kFloat64), |
1056 var_rhs_float64(assembler, MachineRepresentation::kFloat64); | 1022 var_rhs_float64(assembler, MachineRepresentation::kFloat64); |
1057 | 1023 |
1058 Node* number_map = assembler->HeapNumberMapConstant(); | 1024 Node* number_map = assembler->HeapNumberMapConstant(); |
1059 | 1025 |
1060 // We might need to loop one or two times due to ToNumber conversions. | 1026 // We might need to loop one or two times due to ToNumber conversions. |
1061 Variable var_lhs(assembler, MachineRepresentation::kTagged), | 1027 Variable var_lhs(assembler, MachineRepresentation::kTagged), |
1062 var_rhs(assembler, MachineRepresentation::kTagged); | 1028 var_rhs(assembler, MachineRepresentation::kTagged); |
1063 Variable* loop_variables[] = {&var_lhs, &var_rhs}; | 1029 Variable* loop_variables[] = {&var_lhs, &var_rhs}; |
1064 Label loop(assembler, 2, loop_variables); | 1030 Label loop(assembler, 2, loop_variables); |
1065 var_lhs.Bind(left); | 1031 var_lhs.Bind(assembler->Parameter(0)); |
1066 var_rhs.Bind(right); | 1032 var_rhs.Bind(assembler->Parameter(1)); |
1067 assembler->Goto(&loop); | 1033 assembler->Goto(&loop); |
1068 assembler->Bind(&loop); | 1034 assembler->Bind(&loop); |
1069 { | 1035 { |
1070 Node* lhs = var_lhs.value(); | 1036 Node* lhs = var_lhs.value(); |
1071 Node* rhs = var_rhs.value(); | 1037 Node* rhs = var_rhs.value(); |
1072 | 1038 |
1073 Label lhs_is_smi(assembler), lhs_is_not_smi(assembler); | 1039 Label lhs_is_smi(assembler), lhs_is_not_smi(assembler); |
1074 assembler->Branch(assembler->WordIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi); | 1040 assembler->Branch(assembler->WordIsSmi(lhs), &lhs_is_smi, &lhs_is_not_smi); |
1075 | 1041 |
1076 assembler->Bind(&lhs_is_smi); | 1042 assembler->Bind(&lhs_is_smi); |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1166 var_lhs.Bind(rhs); | 1132 var_lhs.Bind(rhs); |
1167 var_rhs.Bind(lhs); | 1133 var_rhs.Bind(lhs); |
1168 assembler->Goto(&loop); | 1134 assembler->Goto(&loop); |
1169 } | 1135 } |
1170 } | 1136 } |
1171 } | 1137 } |
1172 | 1138 |
1173 assembler->Bind(&lhs_is_not_number); | 1139 assembler->Bind(&lhs_is_not_number); |
1174 { | 1140 { |
1175 // Convert {lhs} to a Number and loop. | 1141 // Convert {lhs} to a Number and loop. |
1176 Callable callable = | 1142 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1177 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1178 var_lhs.Bind(assembler->CallStub(callable, context, lhs)); | 1143 var_lhs.Bind(assembler->CallStub(callable, context, lhs)); |
1179 assembler->Goto(&loop); | 1144 assembler->Goto(&loop); |
1180 } | 1145 } |
1181 } | 1146 } |
1182 } | 1147 } |
1183 | 1148 |
1184 assembler->Bind(&do_fmul); | 1149 assembler->Bind(&do_fmul); |
1185 { | 1150 { |
1186 Node* value = | 1151 Node* value = |
1187 assembler->Float64Mul(var_lhs_float64.value(), var_rhs_float64.value()); | 1152 assembler->Float64Mul(var_lhs_float64.value(), var_rhs_float64.value()); |
1188 Node* result = assembler->ChangeFloat64ToTagged(value); | 1153 Node* result = assembler->ChangeFloat64ToTagged(value); |
1189 return result; | 1154 assembler->Return(result); |
1190 } | 1155 } |
1191 } | 1156 } |
1192 | 1157 |
1193 // static | 1158 void DivideStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1194 compiler::Node* DivideStub::Generate(CodeStubAssembler* assembler, | |
1195 compiler::Node* left, | |
1196 compiler::Node* right, | |
1197 compiler::Node* context) { | |
1198 using compiler::Node; | 1159 using compiler::Node; |
1199 typedef CodeStubAssembler::Label Label; | 1160 typedef CodeStubAssembler::Label Label; |
1200 typedef CodeStubAssembler::Variable Variable; | 1161 typedef CodeStubAssembler::Variable Variable; |
1201 | 1162 |
| 1163 Node* context = assembler->Parameter(2); |
| 1164 |
1202 // Shared entry point for floating point division. | 1165 // Shared entry point for floating point division. |
1203 Label do_fdiv(assembler), end(assembler); | 1166 Label do_fdiv(assembler); |
1204 Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64), | 1167 Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64), |
1205 var_divisor_float64(assembler, MachineRepresentation::kFloat64); | 1168 var_divisor_float64(assembler, MachineRepresentation::kFloat64); |
1206 | 1169 |
1207 Node* number_map = assembler->HeapNumberMapConstant(); | 1170 Node* number_map = assembler->HeapNumberMapConstant(); |
1208 | 1171 |
1209 // We might need to loop one or two times due to ToNumber conversions. | 1172 // We might need to loop one or two times due to ToNumber conversions. |
1210 Variable var_dividend(assembler, MachineRepresentation::kTagged), | 1173 Variable var_dividend(assembler, MachineRepresentation::kTagged), |
1211 var_divisor(assembler, MachineRepresentation::kTagged), | 1174 var_divisor(assembler, MachineRepresentation::kTagged); |
1212 var_result(assembler, MachineRepresentation::kTagged); | |
1213 Variable* loop_variables[] = {&var_dividend, &var_divisor}; | 1175 Variable* loop_variables[] = {&var_dividend, &var_divisor}; |
1214 Label loop(assembler, 2, loop_variables); | 1176 Label loop(assembler, 2, loop_variables); |
1215 var_dividend.Bind(left); | 1177 var_dividend.Bind(assembler->Parameter(0)); |
1216 var_divisor.Bind(right); | 1178 var_divisor.Bind(assembler->Parameter(1)); |
1217 assembler->Goto(&loop); | 1179 assembler->Goto(&loop); |
1218 assembler->Bind(&loop); | 1180 assembler->Bind(&loop); |
1219 { | 1181 { |
1220 Node* dividend = var_dividend.value(); | 1182 Node* dividend = var_dividend.value(); |
1221 Node* divisor = var_divisor.value(); | 1183 Node* divisor = var_divisor.value(); |
1222 | 1184 |
1223 Label dividend_is_smi(assembler), dividend_is_not_smi(assembler); | 1185 Label dividend_is_smi(assembler), dividend_is_not_smi(assembler); |
1224 assembler->Branch(assembler->WordIsSmi(dividend), ÷nd_is_smi, | 1186 assembler->Branch(assembler->WordIsSmi(dividend), ÷nd_is_smi, |
1225 ÷nd_is_not_smi); | 1187 ÷nd_is_not_smi); |
1226 | 1188 |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1280 | 1242 |
1281 // TODO(epertoso): consider adding a machine instruction that returns | 1243 // TODO(epertoso): consider adding a machine instruction that returns |
1282 // both the result and the remainder. | 1244 // both the result and the remainder. |
1283 Node* untagged_result = | 1245 Node* untagged_result = |
1284 assembler->Int32Div(untagged_dividend, untagged_divisor); | 1246 assembler->Int32Div(untagged_dividend, untagged_divisor); |
1285 Node* truncated = | 1247 Node* truncated = |
1286 assembler->IntPtrMul(untagged_result, untagged_divisor); | 1248 assembler->IntPtrMul(untagged_result, untagged_divisor); |
1287 // Do floating point division if the remainder is not 0. | 1249 // Do floating point division if the remainder is not 0. |
1288 assembler->GotoIf( | 1250 assembler->GotoIf( |
1289 assembler->Word32NotEqual(untagged_dividend, truncated), &bailout); | 1251 assembler->Word32NotEqual(untagged_dividend, truncated), &bailout); |
1290 var_result.Bind(assembler->SmiTag(untagged_result)); | 1252 assembler->Return(assembler->SmiTag(untagged_result)); |
1291 assembler->Goto(&end); | |
1292 | 1253 |
1293 // Bailout: convert {dividend} and {divisor} to double and do double | 1254 // Bailout: convert {dividend} and {divisor} to double and do double |
1294 // division. | 1255 // division. |
1295 assembler->Bind(&bailout); | 1256 assembler->Bind(&bailout); |
1296 { | 1257 { |
1297 var_dividend_float64.Bind(assembler->SmiToFloat64(dividend)); | 1258 var_dividend_float64.Bind(assembler->SmiToFloat64(dividend)); |
1298 var_divisor_float64.Bind(assembler->SmiToFloat64(divisor)); | 1259 var_divisor_float64.Bind(assembler->SmiToFloat64(divisor)); |
1299 assembler->Goto(&do_fdiv); | 1260 assembler->Goto(&do_fdiv); |
1300 } | 1261 } |
1301 } | 1262 } |
(...skipping 13 matching lines...) Expand all Loading... |
1315 // Convert {dividend} to a double and divide it with the value of | 1276 // Convert {dividend} to a double and divide it with the value of |
1316 // {divisor}. | 1277 // {divisor}. |
1317 var_dividend_float64.Bind(assembler->SmiToFloat64(dividend)); | 1278 var_dividend_float64.Bind(assembler->SmiToFloat64(dividend)); |
1318 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); | 1279 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); |
1319 assembler->Goto(&do_fdiv); | 1280 assembler->Goto(&do_fdiv); |
1320 } | 1281 } |
1321 | 1282 |
1322 assembler->Bind(&divisor_is_not_number); | 1283 assembler->Bind(&divisor_is_not_number); |
1323 { | 1284 { |
1324 // Convert {divisor} to a number and loop. | 1285 // Convert {divisor} to a number and loop. |
1325 Callable callable = | 1286 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1326 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1327 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); | 1287 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); |
1328 assembler->Goto(&loop); | 1288 assembler->Goto(&loop); |
1329 } | 1289 } |
1330 } | 1290 } |
1331 } | 1291 } |
1332 | 1292 |
1333 assembler->Bind(÷nd_is_not_smi); | 1293 assembler->Bind(÷nd_is_not_smi); |
1334 { | 1294 { |
1335 Node* dividend_map = assembler->LoadMap(dividend); | 1295 Node* dividend_map = assembler->LoadMap(dividend); |
1336 | 1296 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1371 // Both {dividend} and {divisor} are HeapNumbers. Load their values | 1331 // Both {dividend} and {divisor} are HeapNumbers. Load their values |
1372 // and divide them. | 1332 // and divide them. |
1373 var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend)); | 1333 var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend)); |
1374 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); | 1334 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); |
1375 assembler->Goto(&do_fdiv); | 1335 assembler->Goto(&do_fdiv); |
1376 } | 1336 } |
1377 | 1337 |
1378 assembler->Bind(&divisor_is_not_number); | 1338 assembler->Bind(&divisor_is_not_number); |
1379 { | 1339 { |
1380 // Convert {divisor} to a number and loop. | 1340 // Convert {divisor} to a number and loop. |
1381 Callable callable = | 1341 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1382 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1383 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); | 1342 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); |
1384 assembler->Goto(&loop); | 1343 assembler->Goto(&loop); |
1385 } | 1344 } |
1386 } | 1345 } |
1387 } | 1346 } |
1388 | 1347 |
1389 assembler->Bind(÷nd_is_not_number); | 1348 assembler->Bind(÷nd_is_not_number); |
1390 { | 1349 { |
1391 // Convert {dividend} to a Number and loop. | 1350 // Convert {dividend} to a Number and loop. |
1392 Callable callable = | 1351 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1393 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1394 var_dividend.Bind(assembler->CallStub(callable, context, dividend)); | 1352 var_dividend.Bind(assembler->CallStub(callable, context, dividend)); |
1395 assembler->Goto(&loop); | 1353 assembler->Goto(&loop); |
1396 } | 1354 } |
1397 } | 1355 } |
1398 } | 1356 } |
1399 | 1357 |
1400 assembler->Bind(&do_fdiv); | 1358 assembler->Bind(&do_fdiv); |
1401 { | 1359 { |
1402 Node* value = assembler->Float64Div(var_dividend_float64.value(), | 1360 Node* value = assembler->Float64Div(var_dividend_float64.value(), |
1403 var_divisor_float64.value()); | 1361 var_divisor_float64.value()); |
1404 var_result.Bind(assembler->ChangeFloat64ToTagged(value)); | 1362 Node* result = assembler->ChangeFloat64ToTagged(value); |
1405 assembler->Goto(&end); | 1363 assembler->Return(result); |
1406 } | 1364 } |
1407 assembler->Bind(&end); | |
1408 return var_result.value(); | |
1409 } | 1365 } |
1410 | 1366 |
1411 // static | 1367 void BitwiseAndStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1412 compiler::Node* ModulusStub::Generate(CodeStubAssembler* assembler, | 1368 using compiler::Node; |
1413 compiler::Node* left, | 1369 |
1414 compiler::Node* right, | 1370 Node* lhs = assembler->Parameter(0); |
1415 compiler::Node* context) { | 1371 Node* rhs = assembler->Parameter(1); |
| 1372 Node* context = assembler->Parameter(2); |
| 1373 Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs); |
| 1374 Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs); |
| 1375 Node* value = assembler->Word32And(lhs_value, rhs_value); |
| 1376 Node* result = assembler->ChangeInt32ToTagged(value); |
| 1377 assembler->Return(result); |
| 1378 } |
| 1379 |
| 1380 void ModulusStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1416 using compiler::Node; | 1381 using compiler::Node; |
1417 typedef CodeStubAssembler::Label Label; | 1382 typedef CodeStubAssembler::Label Label; |
1418 typedef CodeStubAssembler::Variable Variable; | 1383 typedef CodeStubAssembler::Variable Variable; |
1419 | 1384 |
| 1385 Node* context = assembler->Parameter(2); |
| 1386 |
1420 // Shared entry point for floating point modulus. | 1387 // Shared entry point for floating point modulus. |
1421 Label do_fmod(assembler); | 1388 Label do_fmod(assembler); |
1422 Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64), | 1389 Variable var_dividend_float64(assembler, MachineRepresentation::kFloat64), |
1423 var_divisor_float64(assembler, MachineRepresentation::kFloat64); | 1390 var_divisor_float64(assembler, MachineRepresentation::kFloat64); |
1424 | 1391 |
1425 Node* number_map = assembler->HeapNumberMapConstant(); | 1392 Node* number_map = assembler->HeapNumberMapConstant(); |
1426 | 1393 |
1427 // We might need to loop one or two times due to ToNumber conversions. | 1394 // We might need to loop one or two times due to ToNumber conversions. |
1428 Variable var_dividend(assembler, MachineRepresentation::kTagged), | 1395 Variable var_dividend(assembler, MachineRepresentation::kTagged), |
1429 var_divisor(assembler, MachineRepresentation::kTagged); | 1396 var_divisor(assembler, MachineRepresentation::kTagged); |
1430 Variable* loop_variables[] = {&var_dividend, &var_divisor}; | 1397 Variable* loop_variables[] = {&var_dividend, &var_divisor}; |
1431 Label loop(assembler, 2, loop_variables); | 1398 Label loop(assembler, 2, loop_variables); |
1432 var_dividend.Bind(left); | 1399 var_dividend.Bind(assembler->Parameter(0)); |
1433 var_divisor.Bind(right); | 1400 var_divisor.Bind(assembler->Parameter(1)); |
1434 assembler->Goto(&loop); | 1401 assembler->Goto(&loop); |
1435 assembler->Bind(&loop); | 1402 assembler->Bind(&loop); |
1436 { | 1403 { |
1437 Node* dividend = var_dividend.value(); | 1404 Node* dividend = var_dividend.value(); |
1438 Node* divisor = var_divisor.value(); | 1405 Node* divisor = var_divisor.value(); |
1439 | 1406 |
1440 Label dividend_is_smi(assembler), dividend_is_not_smi(assembler); | 1407 Label dividend_is_smi(assembler), dividend_is_not_smi(assembler); |
1441 assembler->Branch(assembler->WordIsSmi(dividend), ÷nd_is_smi, | 1408 assembler->Branch(assembler->WordIsSmi(dividend), ÷nd_is_smi, |
1442 ÷nd_is_not_smi); | 1409 ÷nd_is_not_smi); |
1443 | 1410 |
(...skipping 26 matching lines...) Expand all Loading... |
1470 // Convert {dividend} to a double and compute its modulus with the | 1437 // Convert {dividend} to a double and compute its modulus with the |
1471 // value of {dividend}. | 1438 // value of {dividend}. |
1472 var_dividend_float64.Bind(assembler->SmiToFloat64(dividend)); | 1439 var_dividend_float64.Bind(assembler->SmiToFloat64(dividend)); |
1473 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); | 1440 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); |
1474 assembler->Goto(&do_fmod); | 1441 assembler->Goto(&do_fmod); |
1475 } | 1442 } |
1476 | 1443 |
1477 assembler->Bind(&divisor_is_not_number); | 1444 assembler->Bind(&divisor_is_not_number); |
1478 { | 1445 { |
1479 // Convert {divisor} to a number and loop. | 1446 // Convert {divisor} to a number and loop. |
1480 Callable callable = | 1447 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1481 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1482 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); | 1448 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); |
1483 assembler->Goto(&loop); | 1449 assembler->Goto(&loop); |
1484 } | 1450 } |
1485 } | 1451 } |
1486 } | 1452 } |
1487 | 1453 |
1488 assembler->Bind(÷nd_is_not_smi); | 1454 assembler->Bind(÷nd_is_not_smi); |
1489 { | 1455 { |
1490 Node* dividend_map = assembler->LoadMap(dividend); | 1456 Node* dividend_map = assembler->LoadMap(dividend); |
1491 | 1457 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1526 // Both {dividend} and {divisor} are HeapNumbers. Load their values | 1492 // Both {dividend} and {divisor} are HeapNumbers. Load their values |
1527 // and compute their modulus. | 1493 // and compute their modulus. |
1528 var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend)); | 1494 var_dividend_float64.Bind(assembler->LoadHeapNumberValue(dividend)); |
1529 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); | 1495 var_divisor_float64.Bind(assembler->LoadHeapNumberValue(divisor)); |
1530 assembler->Goto(&do_fmod); | 1496 assembler->Goto(&do_fmod); |
1531 } | 1497 } |
1532 | 1498 |
1533 assembler->Bind(&divisor_is_not_number); | 1499 assembler->Bind(&divisor_is_not_number); |
1534 { | 1500 { |
1535 // Convert {divisor} to a number and loop. | 1501 // Convert {divisor} to a number and loop. |
1536 Callable callable = | 1502 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1537 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1538 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); | 1503 var_divisor.Bind(assembler->CallStub(callable, context, divisor)); |
1539 assembler->Goto(&loop); | 1504 assembler->Goto(&loop); |
1540 } | 1505 } |
1541 } | 1506 } |
1542 } | 1507 } |
1543 | 1508 |
1544 assembler->Bind(÷nd_is_not_number); | 1509 assembler->Bind(÷nd_is_not_number); |
1545 { | 1510 { |
1546 // Convert {dividend} to a Number and loop. | 1511 // Convert {dividend} to a Number and loop. |
1547 Callable callable = | 1512 Callable callable = CodeFactory::NonNumberToNumber(isolate()); |
1548 CodeFactory::NonNumberToNumber(assembler->isolate()); | |
1549 var_dividend.Bind(assembler->CallStub(callable, context, dividend)); | 1513 var_dividend.Bind(assembler->CallStub(callable, context, dividend)); |
1550 assembler->Goto(&loop); | 1514 assembler->Goto(&loop); |
1551 } | 1515 } |
1552 } | 1516 } |
1553 } | 1517 } |
1554 | 1518 |
1555 assembler->Bind(&do_fmod); | 1519 assembler->Bind(&do_fmod); |
1556 { | 1520 { |
1557 Node* value = assembler->Float64Mod(var_dividend_float64.value(), | 1521 Node* value = assembler->Float64Mod(var_dividend_float64.value(), |
1558 var_divisor_float64.value()); | 1522 var_divisor_float64.value()); |
1559 Node* result = assembler->ChangeFloat64ToTagged(value); | 1523 Node* result = assembler->ChangeFloat64ToTagged(value); |
1560 return result; | 1524 assembler->Return(result); |
1561 } | 1525 } |
1562 } | 1526 } |
1563 | 1527 |
1564 // static | 1528 void ShiftLeftStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1565 compiler::Node* ShiftLeftStub::Generate(CodeStubAssembler* assembler, | |
1566 compiler::Node* left, | |
1567 compiler::Node* right, | |
1568 compiler::Node* context) { | |
1569 using compiler::Node; | 1529 using compiler::Node; |
1570 | 1530 |
1571 Node* lhs_value = assembler->TruncateTaggedToWord32(context, left); | 1531 Node* lhs = assembler->Parameter(0); |
1572 Node* rhs_value = assembler->TruncateTaggedToWord32(context, right); | 1532 Node* rhs = assembler->Parameter(1); |
| 1533 Node* context = assembler->Parameter(2); |
| 1534 Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs); |
| 1535 Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs); |
1573 Node* shift_count = | 1536 Node* shift_count = |
1574 assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f)); | 1537 assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f)); |
1575 Node* value = assembler->Word32Shl(lhs_value, shift_count); | 1538 Node* value = assembler->Word32Shl(lhs_value, shift_count); |
1576 Node* result = assembler->ChangeInt32ToTagged(value); | 1539 Node* result = assembler->ChangeInt32ToTagged(value); |
1577 return result; | 1540 assembler->Return(result); |
1578 } | 1541 } |
1579 | 1542 |
1580 // static | 1543 void ShiftRightStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1581 compiler::Node* ShiftRightStub::Generate(CodeStubAssembler* assembler, | |
1582 compiler::Node* left, | |
1583 compiler::Node* right, | |
1584 compiler::Node* context) { | |
1585 using compiler::Node; | 1544 using compiler::Node; |
1586 | 1545 |
1587 Node* lhs_value = assembler->TruncateTaggedToWord32(context, left); | 1546 Node* lhs = assembler->Parameter(0); |
1588 Node* rhs_value = assembler->TruncateTaggedToWord32(context, right); | 1547 Node* rhs = assembler->Parameter(1); |
| 1548 Node* context = assembler->Parameter(2); |
| 1549 Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs); |
| 1550 Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs); |
1589 Node* shift_count = | 1551 Node* shift_count = |
1590 assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f)); | 1552 assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f)); |
1591 Node* value = assembler->Word32Sar(lhs_value, shift_count); | 1553 Node* value = assembler->Word32Sar(lhs_value, shift_count); |
1592 Node* result = assembler->ChangeInt32ToTagged(value); | 1554 Node* result = assembler->ChangeInt32ToTagged(value); |
1593 return result; | 1555 assembler->Return(result); |
1594 } | 1556 } |
1595 | 1557 |
1596 // static | 1558 void ShiftRightLogicalStub::GenerateAssembly( |
1597 compiler::Node* ShiftRightLogicalStub::Generate(CodeStubAssembler* assembler, | 1559 CodeStubAssembler* assembler) const { |
1598 compiler::Node* left, | |
1599 compiler::Node* right, | |
1600 compiler::Node* context) { | |
1601 using compiler::Node; | 1560 using compiler::Node; |
1602 | 1561 |
1603 Node* lhs_value = assembler->TruncateTaggedToWord32(context, left); | 1562 Node* lhs = assembler->Parameter(0); |
1604 Node* rhs_value = assembler->TruncateTaggedToWord32(context, right); | 1563 Node* rhs = assembler->Parameter(1); |
| 1564 Node* context = assembler->Parameter(2); |
| 1565 Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs); |
| 1566 Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs); |
1605 Node* shift_count = | 1567 Node* shift_count = |
1606 assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f)); | 1568 assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f)); |
1607 Node* value = assembler->Word32Shr(lhs_value, shift_count); | 1569 Node* value = assembler->Word32Shr(lhs_value, shift_count); |
1608 Node* result = assembler->ChangeUint32ToTagged(value); | 1570 Node* result = assembler->ChangeUint32ToTagged(value); |
1609 return result; | 1571 assembler->Return(result); |
1610 } | 1572 } |
1611 | 1573 |
1612 // static | 1574 void BitwiseOrStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1613 compiler::Node* BitwiseAndStub::Generate(CodeStubAssembler* assembler, | |
1614 compiler::Node* left, | |
1615 compiler::Node* right, | |
1616 compiler::Node* context) { | |
1617 using compiler::Node; | 1575 using compiler::Node; |
1618 | 1576 |
1619 Node* lhs_value = assembler->TruncateTaggedToWord32(context, left); | 1577 Node* lhs = assembler->Parameter(0); |
1620 Node* rhs_value = assembler->TruncateTaggedToWord32(context, right); | 1578 Node* rhs = assembler->Parameter(1); |
1621 Node* value = assembler->Word32And(lhs_value, rhs_value); | 1579 Node* context = assembler->Parameter(2); |
| 1580 Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs); |
| 1581 Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs); |
| 1582 Node* value = assembler->Word32Or(lhs_value, rhs_value); |
1622 Node* result = assembler->ChangeInt32ToTagged(value); | 1583 Node* result = assembler->ChangeInt32ToTagged(value); |
1623 return result; | 1584 assembler->Return(result); |
1624 } | 1585 } |
1625 | 1586 |
1626 // static | 1587 void BitwiseXorStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1627 compiler::Node* BitwiseOrStub::Generate(CodeStubAssembler* assembler, | |
1628 compiler::Node* left, | |
1629 compiler::Node* right, | |
1630 compiler::Node* context) { | |
1631 using compiler::Node; | 1588 using compiler::Node; |
1632 | 1589 |
1633 Node* lhs_value = assembler->TruncateTaggedToWord32(context, left); | 1590 Node* lhs = assembler->Parameter(0); |
1634 Node* rhs_value = assembler->TruncateTaggedToWord32(context, right); | 1591 Node* rhs = assembler->Parameter(1); |
1635 Node* value = assembler->Word32Or(lhs_value, rhs_value); | 1592 Node* context = assembler->Parameter(2); |
1636 Node* result = assembler->ChangeInt32ToTagged(value); | 1593 Node* lhs_value = assembler->TruncateTaggedToWord32(context, lhs); |
1637 return result; | 1594 Node* rhs_value = assembler->TruncateTaggedToWord32(context, rhs); |
1638 } | |
1639 | |
1640 // static | |
1641 compiler::Node* BitwiseXorStub::Generate(CodeStubAssembler* assembler, | |
1642 compiler::Node* left, | |
1643 compiler::Node* right, | |
1644 compiler::Node* context) { | |
1645 using compiler::Node; | |
1646 | |
1647 Node* lhs_value = assembler->TruncateTaggedToWord32(context, left); | |
1648 Node* rhs_value = assembler->TruncateTaggedToWord32(context, right); | |
1649 Node* value = assembler->Word32Xor(lhs_value, rhs_value); | 1595 Node* value = assembler->Word32Xor(lhs_value, rhs_value); |
1650 Node* result = assembler->ChangeInt32ToTagged(value); | 1596 Node* result = assembler->ChangeInt32ToTagged(value); |
1651 return result; | 1597 assembler->Return(result); |
1652 } | 1598 } |
1653 | 1599 |
1654 void IncStub::GenerateAssembly(CodeStubAssembler* assembler) const { | 1600 void IncStub::GenerateAssembly(CodeStubAssembler* assembler) const { |
1655 typedef CodeStubAssembler::Label Label; | 1601 typedef CodeStubAssembler::Label Label; |
1656 typedef compiler::Node Node; | 1602 typedef compiler::Node Node; |
1657 typedef CodeStubAssembler::Variable Variable; | 1603 typedef CodeStubAssembler::Variable Variable; |
1658 | 1604 |
1659 Node* context = assembler->Parameter(1); | 1605 Node* context = assembler->Parameter(1); |
1660 | 1606 |
1661 // Shared entry for floating point increment. | 1607 // Shared entry for floating point increment. |
(...skipping 2820 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4482 if (type->Is(Type::UntaggedPointer())) { | 4428 if (type->Is(Type::UntaggedPointer())) { |
4483 return Representation::External(); | 4429 return Representation::External(); |
4484 } | 4430 } |
4485 | 4431 |
4486 DCHECK(!type->Is(Type::Untagged())); | 4432 DCHECK(!type->Is(Type::Untagged())); |
4487 return Representation::Tagged(); | 4433 return Representation::Tagged(); |
4488 } | 4434 } |
4489 | 4435 |
4490 } // namespace internal | 4436 } // namespace internal |
4491 } // namespace v8 | 4437 } // namespace v8 |
OLD | NEW |