Lines Matching defs:__
112 #define __ ACCESS_MASM((&masm_))
129 __ jmp(&entry_label_); // We'll write the entry code when we know more.
130 __ bind(&start_label_); // And then continue from here.
153 __ addq(rdi, Immediate(by * char_size()));
162 __ addq(register_location(reg), Immediate(by));
171 __ addq(rbx, code_object_pointer());
172 __ jmp(rbx);
177 __ bind(label);
182 __ cmpl(current_character(), Immediate(c));
188 __ cmpl(current_character(), Immediate(limit));
196 __ cmpl(Operand(rbp, kStartIndex), Immediate(0));
199 __ lea(rax, Operand(rsi, rdi, times_1, 0));
200 __ cmpq(rax, Operand(rbp, kInputStart));
202 __ bind(¬_at_start);
208 __ cmpl(Operand(rbp, kStartIndex), Immediate(0));
211 __ lea(rax, Operand(rsi, rdi, times_1, 0));
212 __ cmpq(rax, Operand(rbp, kInputStart));
218 __ cmpl(current_character(), Immediate(limit));
238 __ cmpl(rdi, Immediate(-(byte_offset + byte_length)));
253 __ cmpb(Operand(rsi, rdi, times_1, byte_offset),
258 __ movzxwl(rax,
260 __ cmpl(rax, Immediate(static_cast<int32_t>(str[0])));
264 __ lea(rbx, Operand(rsi, rdi, times_1, 0));
277 __ movq(rax, combined_chars, RelocInfo::NONE);
278 __ cmpq(rax, Operand(rbx, byte_offset + i));
286 __ cmpl(Operand(rbx, byte_offset + i), Immediate(combined_chars));
289 __ cmpb(Operand(rbx, byte_offset + i),
297 __ movq(rax, combined_chars, RelocInfo::NONE);
298 __ cmpq(rax,
303 __ cmpl(Operand(rsi, rdi, times_1, byte_offset + i * sizeof(uc16)),
307 __ movzxwl(rax,
309 __ cmpl(rax, Immediate(str[i]));
320 __ cmpl(rdi, Operand(backtrack_stackpointer(), 0));
321 __ j(not_equal, &fallthrough);
324 __ bind(&fallthrough);
332 __ movq(rdx, register_location(start_reg)); // Offset of start of capture
333 __ movq(rbx, register_location(start_reg + 1)); // Offset of end of capture
334 __ subq(rbx, rdx); // Length of capture.
348 __ j(equal, &fallthrough);
356 __ lea(r9, Operand(rsi, rdx, times_1, 0));
357 __ lea(r11, Operand(rsi, rdi, times_1, 0));
358 __ addq(rbx, r9); // End of capture
365 __ bind(&loop);
366 __ movzxbl(rdx, Operand(r9, 0));
367 __ movzxbl(rax, Operand(r11, 0));
370 __ cmpb(rax, rdx);
371 __ j(equal, &loop_increment);
376 __ or_(rax, Immediate(0x20)); // Convert match character to lower-case.
377 __ or_(rdx, Immediate(0x20)); // Convert capture character to lower-case.
378 __ cmpb(rax, rdx);
379 __ j(not_equal, on_no_match); // Definitely not equal.
380 __ subb(rax, Immediate('a'));
381 __ cmpb(rax, Immediate('z' - 'a'));
382 __ j(above, on_no_match); // Weren't letters anyway.
384 __ bind(&loop_increment);
386 __ addq(r11, Immediate(1));
387 __ addq(r9, Immediate(1));
389 __ cmpq(r9, rbx);
390 __ j(below, &loop);
393 __ movq(rdi, r11);
394 __ subq(rdi, rsi);
400 __ push(rsi);
401 __ push(rdi);
403 __ push(backtrack_stackpointer());
406 __ PrepareCallCFunction(num_arguments);
415 __ lea(rcx, Operand(rsi, rdx, times_1, 0));
417 __ lea(rdx, Operand(rsi, rdi, times_1, 0));
419 __ movq(r8, rbx);
421 __ LoadAddress(r9, ExternalReference::isolate_address());
424 __ lea(rax, Operand(rsi, rdi, times_1, 0));
426 __ lea(rdi, Operand(rsi, rdx, times_1, 0));
428 __ movq(rsi, rax);
430 __ movq(rdx, rbx);
432 __
440 __ CallCFunction(compare, num_arguments);
444 __ Move(code_object_pointer(), masm_.CodeObject());
445 __ pop(backtrack_stackpointer());
447 __ pop(rdi);
448 __ pop(rsi);
452 __ testq(rax, rax);
456 __ addq(rdi, rbx);
458 __ bind(&fallthrough);
468 __ movq(rdx, register_location(start_reg));
469 __ movq(rax, register_location(start_reg + 1));
470 __ subq(rax, rdx); // Length to check.
475 __ Check(greater_equal, "Invalid capture referenced");
478 __ j(equal, &fallthrough);
485 __ movl(rbx, rdi);
486 __ addl(rbx, rax);
490 __ lea(rbx, Operand(rsi, rdi, times_1, 0)); // Start of match.
491 __ addq(rdx, rsi); // Start of capture.
492 __ lea(r9, Operand(rdx, rax, times_1, 0)); // End of capture
500 __ bind(&loop);
502 __ movzxbl(rax, Operand(rdx, 0));
503 __ cmpb(rax, Operand(rbx, 0));
506 __ movzxwl(rax, Operand(rdx, 0));
507 __ cmpw(rax, Operand(rbx, 0));
511 __ addq(rbx, Immediate(char_size()));
512 __ addq(rdx, Immediate(char_size()));
514 __ cmpq(rdx, r9);
515 __ j(below, &loop);
519 __ movq(rdi, rbx);
520 __ subq(rdi, rsi);
522 __ bind(&fallthrough);
529 __ movq(rax, register_location(reg1));
530 __ cmpq(rax, register_location(reg2));
537 __ cmpl(current_character(), Immediate(c));
545 __ movl(rax, current_character());
546 __ and_(rax, Immediate(mask));
547 __ cmpl(rax, Immediate(c));
555 __ movl(rax, current_character());
556 __ and_(rax, Immediate(mask));
557 __ cmpl(rax, Immediate(c));
568 __ lea(rax, Operand(current_character(), -minus));
569 __ and_(rax, Immediate(mask));
570 __ cmpl(rax, Immediate(c));
587 __ cmpl(current_character(), Immediate(' '));
588 __ j(equal, &success);
590 __ lea(rax, Operand(current_character(), -'\t'));
591 __ cmpl(rax, Immediate('\r' - '\t'));
593 __ bind(&success);
601 __ cmpl(current_character(), Immediate(' '));
603 __ lea(rax, Operand(current_character(), -'\t'));
604 __ cmpl(rax, Immediate('\r' - '\t'));
611 __ lea(rax, Operand(current_character(), -'0'));
612 __ cmpl(rax, Immediate('9' - '0'));
617 __ lea(rax, Operand(current_character(), -'0'));
618 __ cmpl(rax, Immediate('9' - '0'));
623 __ movl(rax, current_character());
624 __ xor_(rax, Immediate(0x01));
626 __ subl(rax, Immediate(0x0b));
627 __ cmpl(rax, Immediate(0x0c - 0x0b));
633 __ subl(rax, Immediate(0x2028 - 0x0b));
634 __ cmpl(rax, Immediate(0x2029 - 0x2028));
641 __ movl(rax, current_character());
642 __ xor_(rax, Immediate(0x01));
644 __ subl(rax, Immediate(0x0b));
645 __ cmpl(rax, Immediate(0x0c - 0x0b));
654 __ subl(rax, Immediate(0x2028 - 0x0b));
655 __ cmpl(rax, Immediate(0x2029 - 0x2028));
657 __ bind(&done);
664 __ cmpl(current_character(), Immediate('z'));
667 __ movq(rbx, ExternalReference::re_word_character_map());
669 __ testb(Operand(rbx, current_character(), times_1, 0),
678 __ cmpl(current_character(), Immediate('z'));
679 __ j(above, &done);
681 __ movq(rbx, ExternalReference::re_word_character_map());
683 __ testb(Operand(rbx, current_character(), times_1, 0),
687 __ bind(&done);
704 __ Set(rax, 0);
705 __ jmp(&exit_label_);
713 __ bind(&entry_label_);
720 __ push(rbp);
721 __ movq(rbp, rsp);
727 __ movq(Operand(rbp, kInputString), rcx);
728 __ movq(Operand(rbp, kStartIndex), rdx); // Passed as int32 in edx.
729 __ movq(Operand(rbp, kInputStart), r8);
730 __ movq(Operand(rbp, kInputEnd), r9);
732 __ push(rsi);
733 __ push(rdi);
734 __ push(rbx);
744 __ push(rdi);
745 __ push(rsi);
746 __ push(rdx);
747 __ push(rcx);
748 __ push(r8);
749 __ push(r9);
751 __ push(rbx); // Callee-save
754 __ push(Immediate(0)); // Make room for "at start" constant.
762 __ movq(rcx, rsp);
763 __ movq(kScratchRegister, stack_limit);
764 __ subq(rcx, Operand(kScratchRegister, 0));
766 __ j(below_equal, &stack_limit_hit);
769 __ cmpq(rcx, Immediate(num_registers_ * kPointerSize));
770 __ j(above_equal, &stack_ok);
773 __ Set(rax, EXCEPTION);
774 __ jmp(&exit_label_);
776 __ bind(&stack_limit_hit);
777 __ Move(code_object_pointer(), masm_.CodeObject());
779 __ testq(rax, rax);
781 __ j(not_zero, &exit_label_);
783 __ bind(&stack_ok);
786 __ subq(rsp, Immediate(num_registers_ * kPointerSize));
788 __ movq(rsi, Operand(rbp, kInputEnd));
790 __ movq(rdi, Operand(rbp, kInputStart));
792 __ subq(rdi, rsi);
795 __ movq(rbx, Operand(rbp, kStartIndex));
796 __ neg(rbx);
798 __ lea(rax, Operand(rdi, rbx, times_2, -char_size()));
800 __ lea(rax, Operand(rdi, rbx, times_1, -char_size()));
804 __ movq(Operand(rbp, kInputStartMinusOne), rax);
810 __ Set(rcx, kRegisterZero);
812 __ bind(&init_loop);
813 __ movq(Operand(rbp, rcx, times_1, 0), rax);
814 __ subq(rcx, Immediate(kPointerSize));
815 __ cmpq(rcx,
817 __ j(greater, &init_loop);
826 __ movq(register_location(i), rax); // One write every page.
830 __ movq(backtrack_stackpointer(), Operand(rbp, kStackHighEnd));
832 __ Move(code_object_pointer(), masm_.CodeObject());
835 __ cmpb(Operand(rbp, kStartIndex), Immediate(0));
836 __ j(equal, &at_start);
838 __ jmp(&start_label_);
839 __ bind(&at_start);
840 __ Set(current_character(), '\n');
841 __ jmp(&start_label_);
847 __ bind(&success_label_);
850 __ movq(rdx, Operand(rbp, kStartIndex));
851 __ movq(rbx, Operand(rbp, kRegisterOutput));
852 __ movq(rcx, Operand(rbp, kInputEnd));
853 __ subq(rcx, Operand(rbp, kInputStart));
855 __ lea(rcx, Operand(rcx, rdx, times_2, 0));
857 __ addq(rcx, rdx);
860 __ movq(rax, register_location(i));
861 __ addq(rax, rcx); // Convert to index from start, not end.
863 __ sar(rax, Immediate(1)); // Convert byte index to character index.
865 __ movl(Operand(rbx, i * kIntSize), rax);
868 __ Set(rax, SUCCESS);
872 __ bind(&exit_label_);
876 __ lea(rsp, Operand(rbp, kLastCalleeSaveRegister));
877 __ pop(rbx);
878 __ pop(rdi);
879 __ pop(rsi);
883 __ movq(rbx, Operand(rbp, kBackup_rbx));
885 __ movq(rsp, rbp);
888 __ pop(rbp);
889 __ ret(0);
893 __ bind(&backtrack_label_);
903 __ push(backtrack_stackpointer());
904 __ push(rdi);
907 __ testq(rax, rax);
910 __ j(not_zero, &exit_label_);
913 __ Move(code_object_pointer(), masm_.CodeObject());
914 __ pop(rdi);
915 __ pop(backtrack_stackpointer());
917 __ movq(rsi, Operand(rbp, kInputEnd));
930 __ push(rsi);
931 __ push(rdi);
936 __ PrepareCallCFunction(num_arguments);
940 __ lea(rdx, Operand(rbp, kStackHighEnd)); // Second argument
941 __ LoadAddress(r8, ExternalReference::isolate_address());
944 __ movq(rdi, backtrack_stackpointer()); // First argument.
945 __ lea(rsi, Operand(rbp, kStackHighEnd)); // Second argument.
946 __ LoadAddress(rdx, ExternalReference::isolate_address());
950 __ CallCFunction(grow_stack, num_arguments);
953 __ testq(rax, rax);
954 __ j(equal, &exit_with_exception);
956 __ movq(backtrack_stackpointer(), rax);
958 __ Move(code_object_pointer(), masm_.CodeObject());
960 __ pop(rdi);
961 __ pop(rsi);
968 __ bind(&exit_with_exception);
970 __ Set(rax, EXCEPTION);
971 __ jmp(&exit_label_);
995 __ cmpq(register_location(reg), Immediate(comparand));
1003 __ cmpq(register_location(reg), Immediate(comparand));
1010 __ cmpq(rdi, register_location(reg));
1041 __ movq(register_location(register_index), rax);
1058 __ movq(rax, register_location(register_index));
1065 __ movq(rdi, register_location(reg));
1070 __ movq(backtrack_stackpointer(), register_location(reg));
1071 __ addq(backtrack_stackpointer(), Operand(rbp, kStackHighEnd));
1077 __ cmpq(rdi, Immediate(-by * char_size()));
1078 __ j(greater_equal, &after_position, Label::kNear);
1079 __ movq(rdi, Immediate(-by * char_size()));
1084 __ bind(&after_position);
1090 __ movq(register_location(register_index), Immediate(to));
1095 __ jmp(&success_label_);
1102 __ movq(register_location(reg), rdi);
1104 __ lea(rax, Operand(rdi, cp_offset * char_size()));
1105 __ movq(register_location(reg), rax);
1112 __ movq(rax, Operand(rbp, kInputStartMinusOne));
1114 __ movq(register_location(reg), rax);
1120 __ movq(rax, backtrack_stackpointer());
1121 __ subq(rax, Operand(rbp, kStackHighEnd));
1122 __ movq(register_location(reg), rax);
1132 __ PrepareCallCFunction(num_arguments);
1135 __ movq(rdx, code_object_pointer());
1137 __ movq(r8, rbp);
1140 __ lea(rcx, Operand(rsp, -kPointerSize));
1143 __ movq(rdx, rbp);
1145 __ movq(rsi, code_object_pointer());
1148 __ lea(rdi, Operand(rsp, -kPointerSize));
1152 __ CallCFunction(stack_check, num_arguments);
1273 __ cmpl(rdi, Immediate(-cp_offset * char_size()));
1285 __ jmp(to);
1289 __ j(condition, &backtrack_label_);
1292 __ j(condition, to);
1297 __ call(to);
1302 __ bind(label);
1303 __ subq(Operand(rsp, 0), code_object_pointer());
1308 __ addq(Operand(rsp, 0), code_object_pointer());
1309 __ ret(0);
1316 __ subq(backtrack_stackpointer(), Immediate(kIntSize));
1317 __ movl(Operand(backtrack_stackpointer(), 0), source);
1323 __ subq(backtrack_stackpointer(), Immediate(kIntSize));
1324 __ movl(Operand(backtrack_stackpointer(), 0), value);
1347 __ subq(backtrack_stackpointer(), Immediate(kIntSize));
1348 __ movl(Operand(backtrack_stackpointer(), 0), backtrack_target);
1355 __ movsxlq(target, Operand(backtrack_stackpointer(), 0));
1357 __ addq(backtrack_stackpointer(), Immediate(kIntSize));
1362 __ addq(backtrack_stackpointer(), Immediate(kIntSize));
1371 __ load_rax(stack_limit);
1372 __ cmpq(rsp, rax);
1373 __ j(above, &no_preempt);
1377 __ bind(&no_preempt);
1385 __ load_rax(stack_limit);
1386 __ cmpq(backtrack_stackpointer(), rax);
1387 __ j(above, &no_stack_overflow);
1391 __ bind(&no_stack_overflow);
1399 __ movl(current_character(), Operand(rsi, rdi, times_1, cp_offset));
1401 __ movzxwl(current_character(), Operand(rsi, rdi, times_1, cp_offset));
1404 __ movzxbl(current_character(), Operand(rsi, rdi, times_1, cp_offset));
1409 __ movl(current_character(),
1413 __ movzxwl(current_character(),
1419 #undef __
