Lines Matching defs:__
93 #define __ masm->
98 __ push(v8::internal::kSmiConstantRegister);
99 __ push(v8::internal::kRootRegister);
100 __ InitializeSmiConstantRegister();
101 __ InitializeRootRegister();
107 __ Move(rdx, Smi::FromInt(1));
108 __ cmpq(rdx, v8::internal::kSmiConstantRegister);
109 __ movq(rdx, Immediate(-1));
110 __ cmovq(not_equal, rax, rdx);
111 __ pop(v8::internal::kRootRegister);
112 __ pop(v8::internal::kSmiConstantRegister);
143 __ movl(rax, Immediate(id));
144 __ Move(rcx, Smi::FromInt(0));
145 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
146 __ cmpq(rcx, rdx);
147 __ j(not_equal, exit);
164 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro.
182 __ xor_(rax, rax); // Success.
183 __ bind(&exit);
185 __ ret(0);
196 __ Move(rcx, Smi::FromInt(x));
197 __ movq(r8, rcx);
198 __ Move(rdx, Smi::FromInt(y));
199 __ movq(r9, rdx);
200 __ SmiCompare(rcx, rdx);
202 __ movl(rax, Immediate(id + 1));
203 __ j(greater_equal, exit);
205 __ movl(rax, Immediate(id + 2));
206 __ j(less_equal, exit);
209 __ movl(rax, Immediate(id + 3));
210 __ j(not_equal, exit);
212 __ movl(rax, Immediate(id + 4));
213 __ cmpq(rcx, r8);
214 __ j(not_equal, exit);
215 __ incq(rax);
216 __ cmpq(rdx, r9);
217 __ j(not_equal, exit);
220 __ SmiCompare(rdx, rcx);
222 __ movl(rax, Immediate(id + 9));
223 __ j(greater_equal, exit);
226 __ movl(rax, Immediate(id + 10));
227 __ j(less_equal, exit);
230 __ cmpq(rcx, rcx);
231 __ movl(rax, Immediate(id + 11));
232 __ j(not_equal, exit);
233 __ incq(rax);
234 __ cmpq(rcx, r8);
235 __ j(not_equal, exit);
280 __ xor_(rax, rax); // Success.
281 __ bind(&exit);
283 __ ret(0);
312 __ movq(rax, Immediate(1)); // Test number.
313 __ movl(rcx, Immediate(0));
314 __ Integer32ToSmi(rcx, rcx);
315 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
316 __ cmpq(rcx, rdx);
317 __ j(not_equal, &exit);
319 __ movq(rax, Immediate(2)); // Test number.
320 __ movl(rcx, Immediate(1024));
321 __ Integer32ToSmi(rcx, rcx);
322 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024)));
323 __ cmpq(rcx, rdx);
324 __ j(not_equal, &exit);
326 __ movq(rax, Immediate(3)); // Test number.
327 __ movl(rcx, Immediate(-1));
328 __ Integer32ToSmi(rcx, rcx);
329 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1)));
330 __ cmpq(rcx, rdx);
331 __ j(not_equal, &exit);
333 __ movq(rax, Immediate(4)); // Test number.
334 __ movl(rcx, Immediate(Smi::kMaxValue));
335 __ Integer32ToSmi(rcx, rcx);
336 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue)));
337 __ cmpq(rcx, rdx);
338 __ j(not_equal, &exit);
340 __ movq(rax, Immediate(5)); // Test number.
341 __ movl(rcx, Immediate(Smi::kMinValue));
342 __ Integer32ToSmi(rcx, rcx);
343 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue)));
344 __ cmpq(rcx, rdx);
345 __ j(not_equal, &exit);
349 __ movq(rax, Immediate(6)); // Test number.
350 __ movl(rcx, Immediate(0));
351 __ Integer32ToSmi(r8, rcx);
352 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(0)));
353 __ cmpq(r8, rdx);
354 __ j(not_equal, &exit);
356 __ movq(rax, Immediate(7)); // Test number.
357 __ movl(rcx, Immediate(1024));
358 __ Integer32ToSmi(r8, rcx);
359 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(1024)));
360 __ cmpq(r8, rdx);
361 __ j(not_equal, &exit);
363 __ movq(rax, Immediate(8)); // Test number.
364 __ movl(rcx, Immediate(-1));
365 __ Integer32ToSmi(r8, rcx);
366 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(-1)));
367 __ cmpq(r8, rdx);
368 __ j(not_equal, &exit);
370 __ movq(rax, Immediate(9)); // Test number.
371 __ movl(rcx, Immediate(Smi::kMaxValue));
372 __ Integer32ToSmi(r8, rcx);
373 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMaxValue)));
374 __ cmpq(r8, rdx);
375 __ j(not_equal, &exit);
377 __ movq(rax, Immediate(10)); // Test number.
378 __ movl(rcx, Immediate(Smi::kMinValue));
379 __ Integer32ToSmi(r8, rcx);
380 __ Set(rdx, reinterpret_cast<intptr_t>(Smi::FromInt(Smi::kMinValue)));
381 __ cmpq(r8, rdx);
382 __ j(not_equal, &exit);
385 __ xor_(rax, rax); // Success.
386 __ bind(&exit);
388 __ ret(0);
405 __ movl(rax, Immediate(id));
406 __ Move(r8, Smi::FromInt(static_cast<int>(result)));
407 __ movq(rcx, x, RelocInfo::NONE);
408 __ movq(r11, rcx);
409 __ Integer64PlusConstantToSmi(rdx, rcx, y);
410 __ cmpq(rdx, r8);
411 __ j(not_equal, exit);
413 __ incq(rax);
414 __ cmpq(r11, rcx);
415 __ j(not_equal, exit);
417 __ incq(rax);
418 __ Integer64PlusConstantToSmi(rcx, rcx, y);
419 __ cmpq(rcx, r8);
420 __ j(not_equal, exit);
457 __ xor_(rax, rax); // Success.
458 __ bind(&exit);
460 __ ret(0);
489 __ movl(rax, Immediate(1)); // Test number.
493 __ movl(rcx, Immediate(0));
494 __ Integer32ToSmi(rcx, rcx);
496 __ j(NegateCondition(cond), &exit);
498 __ incq(rax);
499 __ xor_(rcx, Immediate(kSmiTagMask));
501 __ j(cond, &exit);
503 __ incq(rax);
504 __
505 __ Integer32ToSmi(rcx, rcx);
507 __ j(NegateCondition(cond), &exit);
509 __ incq(rax);
510 __ xor_(rcx, Immediate(kSmiTagMask));
512 __ j(cond, &exit);
514 __ incq(rax);
515 __ movl(rcx, Immediate(Smi::kMaxValue));
516 __ Integer32ToSmi(rcx, rcx);
518 __ j(NegateCondition(cond), &exit);
520 __ incq(rax);
521 __ xor_(rcx, Immediate(kSmiTagMask));
523 __ j(cond, &exit);
525 __ incq(rax);
526 __ movl(rcx, Immediate(Smi::kMinValue));
527 __ Integer32ToSmi(rcx, rcx);
529 __ j(NegateCondition(cond), &exit);
531 __ incq(rax);
532 __ xor_(rcx, Immediate(kSmiTagMask));
534 __ j(cond, &exit);
538 __ incq(rax);
539 __ movl(rcx, Immediate(0));
540 __ Integer32ToSmi(rcx, rcx);
542 __ j(NegateCondition(cond), &exit);
544 __ incq(rax);
545 __ xor_(rcx, Immediate(kSmiTagMask));
547 __ j(cond, &exit);
549 __ incq(rax);
550 __ movq(rcx, Immediate(-1));
551 __ Integer32ToSmi(rcx, rcx);
553 __ j(cond, &exit);
555 __ incq(rax);
556 __ movq(rcx, Immediate(Smi::kMinValue));
557 __ Integer32ToSmi(rcx, rcx);
559 __ j(cond, &exit);
561 __ incq(rax);
562 __ xor_(rcx, Immediate(kSmiTagMask));
564 __ j(cond, &exit);
566 __ incq(rax);
567 __ movq(rcx, Immediate(Smi::kMaxValue));
568 __ Integer32ToSmi(rcx, rcx);
570 __ j(NegateCondition(cond), &exit);
572 __ incq(rax);
573 __ xor_(rcx, Immediate(kSmiTagMask));
575 __ j(cond, &exit);
579 __ incq(rax);
580 __ movq(rcx, Immediate(Smi::kMaxValue));
581 __ Integer32ToSmi(rcx, rcx);
583 __ j(cond, &exit);
585 __ incq(rax);
586 __ movq(rcx, Immediate(0));
587 __ Integer32ToSmi(rcx, rcx);
589 __ j(cond, &exit);
591 __ incq(rax);
592 __ movq(rcx, Immediate(Smi::kMinValue));
593 __ Integer32ToSmi(rcx, rcx);
595 __ j(NegateCondition(cond), &exit);
597 __ incq(rax);
598 __ movq(rcx, Immediate(Smi::kMinValue + 1));
599 __ Integer32ToSmi(rcx, rcx);
601 __ j(cond, &exit);
605 __ incq(rax);
606 __ movq(rcx, Immediate(Smi::kMaxValue));
607 __ Integer32ToSmi(rcx, rcx);
608 __ movq(rdx, Immediate(Smi::kMinValue));
609 __ Integer32ToSmi(rdx, rdx);
611 __ j(NegateCondition(cond), &exit);
613 __ incq(rax);
614 __ xor_(rcx, Immediate(kSmiTagMask));
616 __ j(cond, &exit);
618 __ incq(rax);
619 __ xor_(rdx, Immediate(kSmiTagMask));
621 __ j(cond, &exit);
623 __ incq(rax);
624 __ xor_(rcx, Immediate(kSmiTagMask));
626 __ j(cond, &exit);
628 __ incq(rax);
630 __ j(NegateCondition(cond), &exit);
632 __ incq(rax);
634 __ j(cond, &exit);
637 __ incq(rax);
638 __ movq(rcx, Immediate(0));
640 __ j(NegateCondition(cond), &exit);
642 __ incq(rax);
643 __ movq(rcx, Immediate(-1));
645 __ j(NegateCondition(cond), &exit);
647 __ incq(rax);
648 __ movq(rcx, Immediate(Smi::kMaxValue));
650 __ j(NegateCondition(cond), &exit);
652 __ incq(rax);
653 __ movq(rcx, Immediate(Smi::kMinValue));
655 __ j(NegateCondition(cond), &exit);
658 __ xor_(rax, rax);
660 __ bind(&exit);
662 __ ret(0);
674 __ Move(rcx, Smi::FromInt(x));
675 __ movq(r11, rcx);
678 __ movl(rax, Immediate(id + 8));
679 __ SmiNeg(r9, rcx, exit);
681 __ incq(rax);
682 __ cmpq(r11, rcx);
683 __ j(not_equal, exit);
685 __ incq(rax);
686 __ SmiNeg(rcx, rcx, exit);
688 __ incq(rax);
689 __ cmpq(r11, rcx);
690 __ j(not_equal, exit);
694 __ movl(rax, Immediate(id));
695 __ Move(r8, Smi::FromInt(result));
697 __ SmiNeg(r9, rcx, &smi_ok);
698 __ jmp(exit);
699 __ bind(&smi_ok);
700 __ incq(rax);
701 __ cmpq(r9, r8);
702 __ j(not_equal, exit);
704 __ incq(rax);
705 __ cmpq(r11, rcx);
706 __ j(not_equal, exit);
708 __ incq(rax);
709 __ SmiNeg(rcx, rcx, &smi_ok2);
710 __ jmp(exit);
711 __ bind(&smi_ok2);
712 __ incq(rax);
713 __ cmpq(rcx, r8);
714 __ j(not_equal, exit);
747 __ xor_(rax, rax); // Success.
748 __ bind(&exit);
750 __ ret(0);
767 __ movl(rcx, Immediate(first));
768 __ Integer32ToSmi(rcx, rcx);
769 __ movl(rdx, Immediate(second));
770 __ Integer32ToSmi(rdx, rdx);
771 __ movl(r8, Immediate(first + second));
772 __ Integer32ToSmi(r8, r8);
774 __ movl(rax, Immediate(id)); // Test number.
775 __ SmiAdd(r9, rcx, rdx, exit);
776 __ cmpq(r9, r8);
777 __ j(not_equal, exit);
779 __ incq(rax);
780 __ SmiAdd(rcx, rcx, rdx, exit); \
781 __ cmpq(rcx, r8);
782 __ j(not_equal, exit);
784 __ movl(rcx, Immediate(first));
785 __ Integer32ToSmi(rcx, rcx);
787 __ incq(rax);
788 __ SmiAddConstant(r9, rcx, Smi::FromInt(second));
789 __ cmpq(r9, r8);
790 __ j(not_equal, exit);
792 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second));
793 __ cmpq(rcx, r8);
794 __ j(not_equal, exit);
796 __ movl(rcx, Immediate(first));
797 __ Integer32ToSmi(rcx, rcx);
799 __ incq(rax);
800 __ SmiAddConstant(r9, rcx, Smi::FromInt(second), exit);
801 __ cmpq(r9, r8);
802 __ j(not_equal, exit);
804 __ incq(rax);
805 __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), exit);
806 __ cmpq(rcx, r8);
807 __ j(not_equal, exit);
838 __ xor_(rax, rax); // Success.
839 __ bind(&exit);
841 __ ret(0);
856 __ Move(rcx, Smi::FromInt(first));
857 __ Move(rdx, Smi::FromInt(second));
858 __ Move(r8, Smi::FromInt(first - second));
860 __ movl(rax, Immediate(id)); // Test 0.
861 __ SmiSub(r9, rcx, rdx, exit);
862 __ cmpq(r9, r8);
863 __ j(not_equal, exit);
865 __ incq(rax); // Test 1.
866 __ SmiSub(rcx, rcx, rdx, exit);
867 __ cmpq(rcx, r8);
868 __ j(not_equal, exit);
870 __ Move(rcx, Smi::FromInt(first));
872 __ incq(rax); // Test 2.
873 __ SmiSubConstant(r9, rcx, Smi::FromInt(second));
874 __ cmpq(r9, r8);
875 __ j(not_equal, exit);
877 __ incq(rax); // Test 3.
878 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second));
879 __ cmpq(rcx, r8);
880 __ j(not_equal, exit);
882 __ Move(rcx, Smi::FromInt(first));
884 __ incq(rax); // Test 4.
885 __ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit);
886 __ cmpq(r9, r8);
887 __ j(not_equal, exit);
889 __ incq(rax); // Test 5.
890 __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit);
891 __ cmpq(rcx, r8);
892 __ j(not_equal, exit);
904 __ movl(rax, Immediate(id));
905 __ Move(rcx, Smi::FromInt(x));
906 __ movq(r11, rcx); // Store original Smi value of x in r11.
907 __ Move(rdx, Smi::FromInt(y_min));
910 __ SmiSub(r9, rcx, rdx, &overflow_ok);
911 __ jmp(exit);
912 __ bind(&overflow_ok);
913 __ incq(rax);
914 __ cmpq(rcx, r11);
915 __ j(not_equal, exit);
920 __ incq(rax);
921 __ SmiSub(rcx, rcx, rdx, &overflow_ok);
922 __ jmp(exit);
923 __ bind(&overflow_ok);
924 __ incq(rax);
925 __ cmpq(rcx, r11);
926 __ j(not_equal, exit);
929 __ movq(rcx, r11);
932 __ incq(rax);
933 __ SmiSubConstant(r9, rcx, Smi::FromInt(y_min), &overflow_ok);
934 __ jmp(exit);
935 __ bind(&overflow_ok);
936 __ incq(rax);
937 __ cmpq(rcx, r11);
938 __ j(not_equal, exit);
943 __ incq(rax);
944 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_min), &overflow_ok);
945 __ jmp(exit);
946 __ bind(&overflow_ok);
947 __ incq(rax);
948 __ cmpq(rcx, r11);
949 __ j(not_equal, exit);
952 __ Move(rdx, Smi::FromInt(y_max));
956 __ incq(rax);
957 __ SmiSub(r9, rcx, rdx, &overflow_ok);
958 __ jmp(exit);
959 __ bind(&overflow_ok);
960 __ incq(rax);
961 __ cmpq(rcx, r11);
962 __ j(not_equal, exit);
967 __ incq(rax);
968 __ SmiSub(rcx, rcx, rdx, &overflow_ok);
969 __ jmp(exit);
970 __ bind(&overflow_ok);
971 __ incq(rax);
972 __ cmpq(rcx, r11);
973 __ j(not_equal, exit);
976 __ movq(rcx, r11);
979 __ incq(rax);
980 __ SmiSubConstant(r9, rcx, Smi::FromInt(y_max), &overflow_ok);
981 __ jmp(exit);
982 __ bind(&overflow_ok);
983 __ incq(rax);
984 __ cmpq(rcx, r11);
985 __ j(not_equal, exit);
990 __ incq(rax);
991 __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), &overflow_ok);
992 __ jmp(exit);
993 __ bind(&overflow_ok);
994 __ incq(rax);
995 __ cmpq(rcx, r11);
996 __ j(not_equal, exit);
1038 __ xor_(rax, rax); // Success.
1039 __ bind(&exit);
1041 __ ret(0);
1055 __ Move(rcx, Smi::FromInt(x));
1056 __ movq(r11, rcx);
1057 __ Move(rdx, Smi::FromInt(y));
1059 __ movl(rax, Immediate(id));
1060 __ Move(r8, Smi::FromIntptr(result));
1061 __ SmiMul(r9, rcx, rdx, exit);
1062 __ incq(rax);
1063 __ cmpq(r11, rcx);
1064 __ j(not_equal, exit);
1065 __ incq(rax);
1066 __ cmpq(r9, r8);
1067 __ j(not_equal, exit);
1069 __ incq(rax);
1070 __ SmiMul(rcx, rcx, rdx, exit);
1071 __ cmpq(rcx, r8);
1072 __ j(not_equal, exit);
1074 __ movl(rax, Immediate(id + 8));
1076 __ SmiMul(r9, rcx, rdx, &overflow_ok);
1077 __ jmp(exit);
1078 __ bind(&overflow_ok);
1079 __ incq(rax);
1080 __ cmpq(r11, rcx);
1081 __ j(not_equal, exit);
1082 __ incq(rax);
1083 __ SmiMul(rcx, rcx, rdx, &overflow_ok2);
1084 __ jmp(exit);
1085 __ bind(&overflow_ok2);
1087 // __ incq(rax);
1088 // __ cmpq(r11, rcx);
1089 // __ j(not_equal, exit);
1127 __ xor_(rax, rax); // Success.
1128 __ bind(&exit);
1130 __ ret(0);
1149 __ Move(r11, Smi::FromInt(x));
1150 __ Move(r14, Smi::FromInt(y));
1153 __ movq(rcx, r11);
1154 __ movq(r15, Immediate(id));
1156 __ Move(r8, Smi::FromInt(result));
1157 __ SmiDiv(r9, rcx, r14, exit);
1159 __ incq(r15);
1160 __ cmpq(r9, r8);
1161 __ j(not_equal, exit);
1163 __ incq(r15);
1164 __ movq(rcx, r11);
1165 __ Move(r14, Smi::FromInt(y));
1166 __ cmpq(rcx, r11);
1167 __ j(not_equal, exit);
1169 __ incq(r15);
1170 __ SmiDiv(rcx, rcx, r14, exit);
1172 __ incq(r15);
1173 __ cmpq(rcx, r8);
1174 __ j(not_equal, exit);
1177 __ movq(r15, Immediate(id + 8));
1180 __ movq(rcx, r11);
1181 __ SmiDiv(r9, rcx, r14, &fail_ok);
1182 __ jmp(exit);
1183 __ bind(&fail_ok);
1185 __ incq(r15);
1186 __ cmpq(rcx, r11);
1187 __ j(not_equal, exit);
1189 __ incq(r15);
1190 __ SmiDiv(rcx, rcx, r14, &fail_ok2);
1191 __ jmp(exit);
1192 __ bind(&fail_ok2);
1194 __ incq(r15);
1195 __ cmpq(rcx, r11);
1196 __ j(not_equal, exit);
1220 __ push(r14);
1221 __ push(r15);
1243 __ xor_(r15, r15); // Success.
1244 __ bind(&exit);
1245 __ movq(rax, r15);
1246 __ pop(r15);
1247 __ pop(r14);
1249 __ ret(0);
1264 __ Move(rcx, Smi::FromInt(x));
1265 __ movq(r11, rcx);
1266 __ Move(r14, Smi::FromInt(y));
1269 __ movq(r15, Immediate(id));
1271 __ Move(r8, Smi::FromInt(result));
1272 __ SmiMod(r9, rcx, r14, exit);
1274 __ incq(r15);
1275 __ cmpq(r9, r8);
1276 __ j(not_equal, exit);
1278 __ incq(r15);
1279 __ cmpq(rcx, r11);
1280 __ j(not_equal, exit);
1282 __ incq(r15);
1283 __ SmiMod(rcx, rcx, r14, exit);
1285 __ incq(r15);
1286 __ cmpq(rcx, r8);
1287 __ j(not_equal, exit);
1290 __ movq(r15, Immediate(id + 8));
1293 __ SmiMod(r9, rcx, r14, &fail_ok);
1294 __ jmp(exit);
1295 __ bind(&fail_ok);
1297 __ incq(r15);
1298 __ cmpq(rcx, r11);
1299 __ j(not_equal, exit);
1301 __ incq(r15);
1302 __ SmiMod(rcx, rcx, r14, &fail_ok2);
1303 __ jmp(exit);
1304 __ bind(&fail_ok2);
1306 __ incq(r15);
1307 __ cmpq(rcx, r11);
1308 __ j(not_equal, exit);
1332 __ push(r14);
1333 __ push(r15);
1355 __ xor_(r15, r15); // Success.
1356 __ bind(&exit);
1357 __ movq(rax, r15);
1358 __ pop(r15);
1359 __ pop(r14);
1361 __ ret(0);
1372 __ movl(rax, Immediate(id));
1375 __ Move(rcx, Smi::FromInt(x));
1378 __ shl(index.reg, Immediate(index.scale));
1379 __ Set(r8, static_cast<intptr_t>(x) << i);
1380 __ cmpq(index.reg, r8);
1381 __ j(not_equal, exit);
1382 __ incq(rax);
1383 __ Move(rcx, Smi::FromInt(x));
1386 __ shl(rcx, Immediate(index.scale));
1387 __ Set(r8, static_cast<intptr_t>(x) << i);
1388 __ cmpq(rcx, r8);
1389 __ j(not_equal, exit);
1390 __ incq(rax);
1392 __ Move(rcx, Smi::FromInt(x));
1395 __ shl(index.reg, Immediate(index.scale));
1396 __ Set(r8, static_cast<intptr_t>(-x) << i);
1397 __ cmpq(index.reg, r8);
1398 __ j(not_equal, exit);
1399 __ incq(rax);
1400 __ Move(rcx, Smi::FromInt(x));
1403 __ shl(rcx, Immediate(index.scale));
1404 __ Set(r8, static_cast<intptr_t>(-x) << i);
1405 __ cmpq(rcx, r8);
1406 __ j(not_equal, exit);
1407 __ incq(rax);
1436 __ xor_(rax, rax); // Success.
1437 __ bind(&exit);
1439 __ ret(0);
1450 __ movl(rax, Immediate(id));
1451 __ Move(rcx, Smi::FromInt(x));
1452 __ Move(rdx, Smi::FromInt(y));
1453 __ xor_(rdx, Immediate(kSmiTagMask));
1454 __ SelectNonSmi(r9, rcx, rdx, exit);
1456 __ incq(rax);
1457 __ cmpq(r9, rdx);
1458 __ j(not_equal, exit);
1460 __ incq(rax);
1461 __ Move(rcx, Smi::FromInt(x));
1462 __ Move(rdx, Smi::FromInt(y));
1463 __ xor_(rcx, Immediate(kSmiTagMask));
1464 __ SelectNonSmi(r9, rcx, rdx, exit);
1466 __ incq(rax);
1467 __ cmpq(r9, rcx);
1468 __ j(not_equal, exit);
1470 __ incq(rax);
1472 __ Move(rcx, Smi::FromInt(x));
1473 __ Move(rdx, Smi::FromInt(y));
1474 __ xor_(rcx, Immediate(kSmiTagMask));
1475 __ xor_(rdx, Immediate(kSmiTagMask));
1476 __ SelectNonSmi(r9, rcx, rdx, &fail_ok);
1477 __ jmp(exit);
1478 __ bind(&fail_ok);
1511 __ xor_(rax, rax); // Success.
1512 __ bind(&exit);
1514 __ ret(0);
1527 __ movl(rax, Immediate(id));
1529 __ Move(rcx, Smi::FromInt(x));
1530 __ movq(r11, rcx);
1531 __ Move(rdx, Smi::FromInt(y));
1532 __ Move(r8, Smi::FromInt(result));
1533 __ SmiAnd(r9, rcx, rdx);
1534 __ cmpq(r8, r9);
1535 __ j(not_equal, exit);
1537 __ incq(rax);
1538 __ cmpq(r11, rcx);
1539 __ j(not_equal, exit);
1541 __ incq(rax);
1542 __ SmiAnd(rcx, rcx, rdx);
1543 __ cmpq(r8, rcx);
1544 __ j(not_equal, exit);
1546 __ movq(rcx, r11);
1547 __ incq(rax);
1548 __ SmiAndConstant(r9, rcx, Smi::FromInt(y));
1549 __ cmpq(r8, r9);
1550 __ j(not_equal, exit);
1552 __ incq(rax);
1553 __ cmpq(r11, rcx);
1554 __ j(not_equal, exit);
1556 __ incq(rax);
1557 __ SmiAndConstant(rcx, rcx, Smi::FromInt(y));
1558 __ cmpq(r8, rcx);
1559 __ j(not_equal, exit);
1594 __ xor_(rax, rax); // Success.
1595 __ bind(&exit);
1597 __ ret(0);
1610 __ movl(rax, Immediate(id));
1612 __ Move(rcx, Smi::FromInt(x));
1613 __ movq(r11, rcx);
1614 __ Move(rdx, Smi::FromInt(y));
1615 __ Move(r8, Smi::FromInt(result));
1616 __ SmiOr(r9, rcx, rdx);
1617 __ cmpq(r8, r9);
1618 __ j(not_equal, exit);
1620 __ incq(rax);
1621 __ cmpq(r11, rcx);
1622 __ j(not_equal, exit);
1624 __ incq(rax);
1625 __ SmiOr(rcx, rcx, rdx);
1626 __ cmpq(r8, rcx);
1627 __ j(not_equal, exit);
1629 __ movq(rcx, r11);
1630 __ incq(rax);
1631 __ SmiOrConstant(r9, rcx, Smi::FromInt(y));
1632 __ cmpq(r8, r9);
1633 __ j(not_equal, exit);
1635 __ incq(rax);
1636 __ cmpq(r11, rcx);
1637 __ j(not_equal, exit);
1639 __ incq(rax);
1640 __ SmiOrConstant(rcx, rcx, Smi::FromInt(y));
1641 __ cmpq(r8, rcx);
1642 __ j(not_equal, exit);
1679 __ xor_(rax, rax); // Success.
1680 __ bind(&exit);
1682 __ ret(0);
1695 __ movl(rax, Immediate(id));
1697 __ Move(rcx, Smi::FromInt(x));
1698 __ movq(r11, rcx);
1699 __ Move(rdx, Smi::FromInt(y));
1700 __ Move(r8, Smi::FromInt(result));
1701 __ SmiXor(r9, rcx, rdx);
1702 __ cmpq(r8, r9);
1703 __ j(not_equal, exit);
1705 __ incq(rax);
1706 __ cmpq(r11, rcx);
1707 __ j(not_equal, exit);
1709 __ incq(rax);
1710 __ SmiXor(rcx, rcx, rdx);
1711 __ cmpq(r8, rcx);
1712 __ j(not_equal, exit);
1714 __ movq(rcx, r11);
1715 __ incq(rax);
1716 __ SmiXorConstant(r9, rcx, Smi::FromInt(y));
1717 __ cmpq(r8, r9);
1718 __ j(not_equal, exit);
1720 __ incq(rax);
1721 __ cmpq(r11, rcx);
1722 __ j(not_equal, exit);
1724 __ incq(rax);
1725 __ SmiXorConstant(rcx, rcx, Smi::FromInt(y));
1726 __ cmpq(r8, rcx);
1727 __ j(not_equal, exit);
1764 __ xor_(rax, rax); // Success.
1765 __ bind(&exit);
1767 __ ret(0);
1779 __ movl(rax, Immediate(id));
1781 __ Move(r8, Smi::FromInt(result));
1782 __ Move(rcx, Smi::FromInt(x));
1783 __ movq(r11, rcx);
1785 __ SmiNot(r9, rcx);
1786 __ cmpq(r9, r8);
1787 __ j(not_equal, exit);
1789 __ incq(rax);
1790 __ cmpq(r11, rcx);
1791 __ j(not_equal, exit);
1793 __ incq(rax);
1794 __ SmiNot(rcx, rcx);
1795 __ cmpq(rcx, r8);
1796 __ j(not_equal, exit);
1828 __ xor_(rax, rax); // Success.
1829 __ bind(&exit);
1831 __ ret(0);
1844 __ movl(rax, Immediate(id));
1850 __ Move(r8, Smi::FromInt(result));
1851 __ Move(rcx, Smi::FromInt(x));
1852 __ SmiShiftLeftConstant(r9, rcx, shift);
1854 __ incq(rax);
1855 __ cmpq(r9, r8);
1856 __ j(not_equal, exit);
1858 __ incq(rax);
1859 __ Move(rcx, Smi::FromInt(x));
1860 __ SmiShiftLeftConstant(rcx, rcx, shift);
1862 __ incq(rax);
1863 __ cmpq(rcx, r8);
1864 __ j(not_equal, exit);
1866 __ incq(rax);
1867 __ Move(rdx, Smi::FromInt(x));
1868 __ Move(rcx, Smi::FromInt(shift));
1869 __ SmiShiftLeft(r9, rdx, rcx);
1871 __ incq(rax);
1872 __ cmpq(r9, r8);
1873 __ j(not_equal, exit);
1875 __ incq(rax);
1876 __ Move(rdx, Smi::FromInt(x));
1877 __ Move(r11, Smi::FromInt(shift));
1878 __ SmiShiftLeft(r9, rdx, r11);
1880 __ incq(rax);
1881 __ cmpq(r9, r8);
1882 __ j(not_equal, exit);
1884 __ incq(rax);
1885 __ Move(rdx, Smi::FromInt(x));
1886 __ Move(r11, Smi::FromInt(shift));
1887 __ SmiShiftLeft(rdx, rdx, r11);
1889 __ incq(rax);
1890 __ cmpq(rdx, r8);
1891 __ j(not_equal, exit);
1893 __ incq(rax);
1925 __ xor_(rax, rax); // Success.
1926 __ bind(&exit);
1928 __ ret(0);
1944 __ movl(rax, Immediate(id));
1949 __ Move(r8, Smi::FromInt(static_cast<int>(result)));
1950 __ Move(rcx, Smi::FromInt(x));
1951 __ SmiShiftLogicalRightConstant(r9, rcx, shift, exit);
1953 __ incq(rax);
1954 __ cmpq(r9, r8);
1955 __ j(not_equal, exit);
1957 __ incq(rax);
1958 __ Move(rdx, Smi::FromInt(x));
1959 __ Move(rcx, Smi::FromInt(shift));
1960 __ SmiShiftLogicalRight(r9, rdx, rcx, exit);
1962 __ incq(rax);
1963 __ cmpq(r9, r8);
1964 __ j(not_equal, exit);
1966 __ incq(rax);
1967 __ Move(rdx, Smi::FromInt(x));
1968 __ Move(r11, Smi::FromInt(shift));
1969 __ SmiShiftLogicalRight(r9, rdx, r11, exit);
1971 __ incq(rax);
1972 __ cmpq(r9, r8);
1973 __ j(not_equal, exit);
1975 __ incq(rax);
1979 __ Move(rcx, Smi::FromInt(x));
1980 __ movq(r11, rcx);
1981 __ SmiShiftLogicalRightConstant(r9, rcx, shift, &fail_ok);
1982 __ jmp(exit);
1983 __ bind(&fail_ok);
1985 __ incq(rax);
1986 __ cmpq(rcx, r11);
1987 __ j(not_equal, exit);
1989 __ incq(rax);
1990 __ Move(r8, Smi::FromInt(shift));
1992 __ SmiShiftLogicalRight(r9, rcx, r8, &fail_ok3);
1993 __ jmp(exit);
1994 __ bind(&fail_ok3);
1996 __ incq(rax);
1997 __ cmpq(rcx, r11);
1998 __ j(not_equal, exit);
2000 __ addq(rax, Immediate(3));
2033 __ xor_(rax, rax); // Success.
2034 __ bind(&exit);
2036 __ ret(0);
2052 __ movl(rax, Immediate(id));
2057 __ Move(r8, Smi::FromInt(result));
2058 __ Move(rcx, Smi::FromInt(x));
2059 __ SmiShiftArithmeticRightConstant(rcx, rcx, shift);
2061 __ cmpq(rcx, r8);
2062 __ j(not_equal, exit);
2064 __ incq(rax);
2065 __ Move(rdx, Smi::FromInt(x));
2066 __ Move(r11, Smi::FromInt(shift));
2067 __ SmiShiftArithmeticRight(rdx, rdx, r11);
2069 __ cmpq(rdx, r8);
2070 __ j(not_equal, exit);
2072 __ incq(rax);
2104 __ xor_(rax, rax); // Success.
2105 __ bind(&exit);
2107 __ ret(0);
2121 __ movl(rax, Immediate(id));
2125 __ Set(r8, result);
2126 __ Move(rcx, Smi::FromInt(x));
2127 __ movq(r11, rcx);
2128 __ PositiveSmiTimesPowerOfTwoToInteger64(rdx, rcx, power);
2129 __ cmpq(rdx, r8);
2130 __ j(not_equal, exit);
2131 __ incq(rax);
2132 __ cmpq(r11, rcx); // rcx unchanged.
2133 __ j(not_equal, exit);
2134 __ incq(rax);
2135 __ PositiveSmiTimesPowerOfTwoToInteger64(rcx, rcx, power);
2136 __ cmpq(rdx, r8);
2137 __ j(not_equal, exit);
2138 __ incq(rax);
2172 __ xor_(rax, rax); // Success.
2173 __ bind(&exit);
2175 __ ret(0);
2207 __ push(r13);
2208 __ push(r14);
2209 __ push(rbx);
2210 __ push(rbp);
2211 __ push(Immediate(0x100)); // <-- rbp
2212 __ movq(rbp, rsp);
2213 __ push(Immediate(0x101));
2214 __ push(Immediate(0x102));
2215 __ push(Immediate(0x103));
2216 __ push(Immediate(0x104));
2217 __ push(Immediate(0x105)); // <-- rbx
2218 __ push(Immediate(0x106));
2219 __ push(Immediate(0x107));
2220 __ push(Immediate(0x108));
2221 __ push(Immediate(0x109)); // <-- rsp
2226 __ lea(r14, Operand(rsp, 3 * kPointerSize));
2227 __ lea(r13, Operand(rbp, -3 * kPointerSize));
2228 __ lea(rbx, Operand(rbp, -5 * kPointerSize));
2229 __ movl(rcx, Immediate(2));
2230 __ movq(r8, reinterpret_cast<uintptr_t>(&data[128]), RelocInfo::NONE);
2231 __ movl(rax, Immediate(1));
2236 __ movl(rdx, sp0); // Sanity check.
2237 __ cmpl(rdx, Immediate(0x109));
2238 __ j(not_equal, &exit);
2239 __ incq(rax);
2243 __ movl(rdx, Operand(sp0, 2 * kPointerSize));
2244 __ cmpl(rdx, Immediate(0x107));
2245 __ j(not_equal, &exit);
2246 __ incq(rax);
2251 __ movl(rdx, sp2); // Sanity check.
2252 __ cmpl(rdx, Immediate(0x107));
2253 __ j(not_equal, &exit);
2254 __ incq(rax);
2256 __ movl(rdx, Operand(sp2, 2 * kPointerSize));
2257 __ cmpl(rdx, Immediate(0x105));
2258 __ j(not_equal, &exit);
2259 __ incq(rax);
2262 __ movl(rdx, Operand(sp2, -2 * kPointerSize));
2263 __ cmpl(rdx, Immediate(0x109));
2264 __ j(not_equal, &exit);
2265 __ incq(rax);
2270 __ movl(rdx, sp2c2); // Sanity check.
2271 __ cmpl(rdx, Immediate(0x105));
2272 __ j(not_equal, &exit);
2273 __ incq(rax);
2275 __ movl(rdx, Operand(sp2c2, 2 * kPointerSize));
2276 __ cmpl(rdx, Immediate(0x103));
2277 __ j(not_equal, &exit);
2278 __ incq(rax);
2281 __ movl(rdx, Operand(sp2c2, -2 * kPointerSize));
2282 __ cmpl(rdx, Immediate(0x107));
2283 __ j(not_equal, &exit);
2284 __ incq(rax);
2290 __ movl(rdx, bp0); // Sanity check.
2291 __ cmpl(rdx, Immediate(0x100));
2292 __ j(not_equal, &exit);
2293 __ incq(rax);
2296 __ movl(rdx, Operand(bp0, -2 * kPointerSize));
2297 __ cmpl(rdx, Immediate(0x102));
2298 __ j(not_equal, &exit);
2299 __ incq(rax);
2304 __ movl(rdx, bp2); // Sanity check.
2305 __ cmpl(rdx, Immediate(0x102));
2306 __ j(not_equal, &exit);
2307 __ incq(rax);
2310 __ movl(rdx, Operand(bp2, 2 * kPointerSize));
2311 __ cmpl(rdx, Immediate(0x100));
2312 __ j(not_equal, &exit);
2313 __ incq(rax);
2315 __ movl(rdx, Operand(bp2, -2 * kPointerSize));
2316 __ cmpl(rdx, Immediate(0x104));
2317 __ j(not_equal, &exit);
2318 __ incq(rax);
2323 __ movl(rdx, bp2c4); // Sanity check.
2324 __ cmpl(rdx, Immediate(0x102));
2325 __ j(not_equal, &exit);
2326 __
2328 __ movl(rdx, Operand(bp2c4, 2 * kPointerSize));
2329 __ cmpl(rdx, Immediate(0x100));
2330 __ j(not_equal, &exit);
2331 __ incq(rax);
2333 __ movl(rdx, Operand(bp2c4, -2 * kPointerSize));
2334 __ cmpl(rdx, Immediate(0x104));
2335 __ j(not_equal, &exit);
2336 __ incq(rax);
2341 __ movl(rdx, bx0); // Sanity check.
2342 __ cmpl(rdx, Immediate(0x105));
2343 __ j(not_equal, &exit);
2344 __ incq(rax);
2346 __ movl(rdx, Operand(bx0, 5 * kPointerSize));
2347 __ cmpl(rdx, Immediate(0x100));
2348 __ j(not_equal, &exit);
2349 __ incq(rax);
2351 __ movl(rdx, Operand(bx0, -4 * kPointerSize));
2352 __ cmpl(rdx, Immediate(0x109));
2353 __ j(not_equal, &exit);
2354 __ incq(rax);
2359 __ movl(rdx, bx2); // Sanity check.
2360 __ cmpl(rdx, Immediate(0x103));
2361 __ j(not_equal, &exit);
2362 __ incq(rax);
2364 __ movl(rdx, Operand(bx2, 2 * kPointerSize));
2365 __ cmpl(rdx, Immediate(0x101));
2366 __ j(not_equal, &exit);
2367 __ incq(rax);
2370 __ movl(rdx, Operand(bx2, -2 * kPointerSize));
2371 __ cmpl(rdx, Immediate(0x105));
2372 __ j(not_equal, &exit);
2373 __ incq(rax);
2378 __ movl(rdx, bx2c2); // Sanity check.
2379 __ cmpl(rdx, Immediate(0x105));
2380 __ j(not_equal, &exit);
2381 __ incq(rax);
2383 __ movl(rdx, Operand(bx2c2, 2 * kPointerSize));
2384 __ cmpl(rdx, Immediate(0x103));
2385 __ j(not_equal, &exit);
2386 __ incq(rax);
2388 __ movl(rdx, Operand(bx2c2, -2 * kPointerSize));
2389 __ cmpl(rdx, Immediate(0x107));
2390 __ j(not_equal, &exit);
2391 __ incq(rax);
2396 __ movl(rdx, r80); // Sanity check.
2397 __ cmpl(rdx, Immediate(0x80808080));
2398 __ j(not_equal, &exit);
2399 __ incq(rax);
2401 __ movl(rdx, Operand(r80, -8 * kIntSize));
2402 __ cmpl(rdx, Immediate(0x78787878));
2403 __ j(not_equal, &exit);
2404 __ incq(rax);
2406 __ movl(rdx, Operand(r80, 8 * kIntSize));
2407 __ cmpl(rdx, Immediate(0x88888888));
2408 __ j(not_equal, &exit);
2409 __ incq(rax);
2411 __ movl(rdx, Operand(r80, -64 * kIntSize));
2412 __ cmpl(rdx, Immediate(0x40404040));
2413 __ j(not_equal, &exit);
2414 __ incq(rax);
2416 __ movl(rdx, Operand(r80, 64 * kIntSize));
2417 __ cmpl(rdx, Immediate(0xC0C0C0C0));
2418 __ j(not_equal, &exit);
2419 __ incq(rax);
2424 __ movl(rdx, r88); // Sanity check.
2425 __ cmpl(rdx, Immediate(0x88888888));
2426 __ j(not_equal, &exit);
2427 __ incq(rax);
2429 __ movl(rdx, Operand(r88, -8 * kIntSize));
2430 __ cmpl(rdx, Immediate(0x80808080));
2431 __ j(not_equal, &exit);
2432 __ incq(rax);
2434 __ movl(rdx, Operand(r88, 8 * kIntSize));
2435 __ cmpl(rdx, Immediate(0x90909090));
2436 __ j(not_equal, &exit);
2437 __ incq(rax);
2439 __ movl(rdx, Operand(r88, -64 * kIntSize));
2440 __ cmpl(rdx, Immediate(0x48484848));
2441 __ j(not_equal, &exit);
2442 __ incq(rax);
2444 __ movl(rdx, Operand(r88, 64 * kIntSize));
2445 __ cmpl(rdx, Immediate(0xC8C8C8C8));
2446 __ j(not_equal, &exit);
2447 __ incq(rax);
2453 __ movl(rdx, r864); // Sanity check.
2454 __ cmpl(rdx, Immediate(0xC0C0C0C0));
2455 __ j(not_equal, &exit);
2456 __ incq(rax);
2458 __ movl(rdx, Operand(r864, -8 * kIntSize));
2459 __ cmpl(rdx, Immediate(0xB8B8B8B8));
2460 __ j(not_equal, &exit);
2461 __ incq(rax);
2463 __ movl(rdx, Operand(r864, 8 * kIntSize));
2464 __ cmpl(rdx, Immediate(0xC8C8C8C8));
2465 __ j(not_equal, &exit);
2466 __ incq(rax);
2468 __ movl(rdx, Operand(r864, -64 * kIntSize));
2469 __ cmpl(rdx, Immediate(0x80808080));
2470 __ j(not_equal, &exit);
2471 __ incq(rax);
2473 __ movl(rdx, Operand(r864, 32 * kIntSize));
2474 __ cmpl(rdx, Immediate(0xE0E0E0E0));
2475 __ j(not_equal, &exit);
2476 __ incq(rax);
2479 __ movl(rdx, Operand(r864, -60 * kIntSize));
2480 __ cmpl(rdx, Immediate(0x84848484));
2481 __ j(not_equal, &exit);
2482 __ incq(rax);
2484 __ movl(rdx, Operand(r864, 60 * kIntSize));
2485 __ cmpl(rdx, Immediate(0xFCFCFCFC));
2486 __ j(not_equal, &exit);
2487 __ incq(rax);
2492 __ movl(rdx, Operand(r80, 2));
2493 __ cmpl(rdx, Immediate(0x81818080));
2494 __ j(not_equal, &exit);
2495 __ incq(rax);
2497 __ movl(rdx, Operand(r80, -2));
2498 __ cmpl(rdx, Immediate(0x80807F7F));
2499 __ j(not_equal, &exit);
2500 __ incq(rax);
2502 __ movl(rdx, Operand(r80, 126));
2503 __ cmpl(rdx, Immediate(0xA0A09F9F));
2504 __ j(not_equal, &exit);
2505 __ incq(rax);
2507 __ movl(rdx, Operand(r80, -126));
2508 __ cmpl(rdx, Immediate(0x61616060));
2509 __ j(not_equal, &exit);
2510 __ incq(rax);
2512 __ movl(rdx, Operand(r80, 254));
2513 __ cmpl(rdx, Immediate(0xC0C0BFBF));
2514 __ j(not_equal, &exit);
2515 __ incq(rax);
2517 __ movl(rdx, Operand(r80, -254));
2518 __ cmpl(rdx, Immediate(0x41414040));
2519 __ j(not_equal, &exit);
2520 __ incq(rax);
2524 __ movl(rax, Immediate(0));
2525 __ bind(&exit);
2526 __ lea(rsp, Operand(rbp, kPointerSize));
2527 __ pop(rbp);
2528 __ pop(rbx);
2529 __ pop(r14);
2530 __ pop(r13);
2532 __ ret(0);
2544 #undef __
