Lines Matching refs:__
94 #define __ ACCESS_MASM((&masm_))
113 __ jmp(&entry_label_); // We'll write the entry code when we know more.
114 __ bind(&start_label_); // And then continue from here.
137 __ addq(rdi, Immediate(by * char_size()));
146 __ addp(register_location(reg), Immediate(by));
155 __ addp(rbx, code_object_pointer());
156 __ jmp(rbx);
161 __ bind(label);
166 __ cmpl(current_character(), Immediate(c));
172 __ cmpl(current_character(), Immediate(limit));
180 __ cmpl(Operand(rbp, kStartIndex), Immediate(0));
183 __ leap(rax, Operand(rsi, rdi, times_1, 0));
184 __ cmpp(rax, Operand(rbp, kInputStart));
186 __ bind(¬_at_start);
192 __ cmpl(Operand(rbp, kStartIndex), Immediate(0));
195 __ leap(rax, Operand(rsi, rdi, times_1, 0));
196 __ cmpp(rax, Operand(rbp, kInputStart));
202 __ cmpl(current_character(), Immediate(limit));
209 __ cmpl(rdi, Operand(backtrack_stackpointer(), 0));
210 __ j(not_equal, &fallthrough);
213 __ bind(&fallthrough);
223 __ subp(rbx, rdx); // Length of capture.
237 __ j(equal, &fallthrough);
243 __ movl(rax, rdi);
244 __ addl(rax, rbx);
253 __ leap(r9, Operand(rsi, rdx, times_1, 0));
254 __ leap(r11, Operand(rsi, rdi, times_1, 0));
255 __ addp(rbx, r9); // End of capture
262 __ bind(&loop);
263 __ movzxbl(rdx, Operand(r9, 0));
264 __ movzxbl(rax, Operand(r11, 0));
267 __ cmpb(rax, rdx);
268 __ j(equal, &loop_increment);
273 __ orp(rax, Immediate(0x20)); // Convert match character to lower-case.
274 __ orp(rdx, Immediate(0x20)); // Convert capture character to lower-case.
275 __ cmpb(rax, rdx);
276 __ j(not_equal, on_no_match); // Definitely not equal.
277 __ subb(rax, Immediate('a'));
278 __ cmpb(rax, Immediate('z' - 'a'));
279 __ j(below_equal, &loop_increment); // In range 'a'-'z'.
281 __ subb(rax, Immediate(224 - 'a'));
282 __ cmpb(rax, Immediate(254 - 224));
283 __ j(above, on_no_match); // Weren't Latin-1 letters.
284 __ cmpb(rax, Immediate(247 - 224)); // Check for 247.
285 __ j(equal, on_no_match);
286 __ bind(&loop_increment);
288 __ addp(r11, Immediate(1));
289 __ addp(r9, Immediate(1));
291 __ cmpp(r9, rbx);
292 __ j(below, &loop);
295 __ movp(rdi, r11);
296 __ subq(rdi, rsi);
302 __ pushq(rsi);
303 __ pushq(rdi);
305 __ pushq(backtrack_stackpointer());
308 __ PrepareCallCFunction(num_arguments);
317 __ leap(rcx, Operand(rsi, rdx, times_1, 0));
319 __ leap(rdx, Operand(rsi, rdi, times_1, 0));
321 __ movp(r8, rbx);
323 __ LoadAddress(r9, ExternalReference::isolate_address(isolate()));
326 __ leap(rax, Operand(rsi, rdi, times_1, 0));
328 __ leap(rdi, Operand(rsi, rdx, times_1, 0));
330 __ movp(rsi, rax);
332 __ movp(rdx, rbx);
334 __ LoadAddress(rcx, ExternalReference::isolate_address(isolate()));
342 __ CallCFunction(compare, num_arguments);
346 __ Move(code_object_pointer(), masm_.CodeObject());
347 __ popq(backtrack_stackpointer());
349 __ popq(rdi);
350 __ popq(rsi);
354 __ testp(rax, rax);
358 __ addq(rdi, rbx);
360 __ bind(&fallthrough);
372 __ subp(rax, rdx); // Length to check.
377 __ Check(greater_equal, kInvalidCaptureReferenced);
380 __ j(equal, &fallthrough);
387 __ movl(rbx, rdi);
388 __ addl(rbx, rax);
392 __ leap(rbx, Operand(rsi, rdi, times_1, 0)); // Start of match.
393 __ addp(rdx, rsi); // Start of capture.
394 __ leap(r9, Operand(rdx, rax, times_1, 0)); // End of capture
402 __ bind(&loop);
404 __ movzxbl(rax, Operand(rdx, 0));
405 __ cmpb(rax, Operand(rbx, 0));
408 __ movzxwl(rax, Operand(rdx, 0));
409 __ cmpw(rax, Operand(rbx, 0));
413 __ addp(rbx, Immediate(char_size()));
414 __ addp(rdx, Immediate(char_size()));
416 __ cmpp(rdx, r9);
417 __ j(below, &loop);
421 __ movp(rdi, rbx);
422 __ subq(rdi, rsi);
424 __ bind(&fallthrough);
430 __ cmpl(current_character(), Immediate(c));
439 __ testl(current_character(), Immediate(mask));
441 __ movl(rax, Immediate(mask));
442 __ andp(rax, current_character());
443 __ cmpl(rax, Immediate(c));
453 __ testl(current_character(), Immediate(mask));
455 __ movl(rax, Immediate(mask));
456 __ andp(rax, current_character());
457 __ cmpl(rax, Immediate(c));
469 __ leap(rax, Operand(current_character(), -minus));
470 __ andp(rax, Immediate(mask));
471 __ cmpl(rax, Immediate(c));
480 __ leal(rax, Operand(current_character(), -from));
481 __ cmpl(rax, Immediate(to - from));
490 __ leal(rax, Operand(current_character(), -from));
491 __ cmpl(rax, Immediate(to - from));
499 __ Move(rax, table);
502 __ movp(rbx, current_character());
503 __ andp(rbx, Immediate(kTableMask));
506 __ cmpb(FieldOperand(rax, index, times_1, ByteArray::kHeaderSize),
524 __ cmpl(current_character(), Immediate(' '));
525 __ j(equal, &success, Label::kNear);
527 __ leap(rax, Operand(current_character(), -'\t'));
528 __ cmpl(rax, Immediate('\r' - '\t'));
529 __ j(below_equal, &success, Label::kNear);
531 __ cmpl(rax, Immediate(0x00a0 - '\t'));
533 __ bind(&success);
542 __ leap(rax, Operand(current_character(), -'0'));
543 __ cmpl(rax, Immediate('9' - '0'));
548 __ leap(rax, Operand(current_character(), -'0'));
549 __ cmpl(rax, Immediate('9' - '0'));
554 __ movl(rax, current_character());
555 __ xorp(rax, Immediate(0x01));
557 __ subl(rax, Immediate(0x0b));
558 __ cmpl(rax, Immediate(0x0c - 0x0b));
564 __ subl(rax, Immediate(0x2028 - 0x0b));
565 __ cmpl(rax, Immediate(0x2029 - 0x2028));
572 __ movl(rax, current_character());
573 __ xorp(rax, Immediate(0x01));
575 __ subl(rax, Immediate(0x0b));
576 __ cmpl(rax, Immediate(0x0c - 0x0b));
585 __ subl(rax, Immediate(0x2028 - 0x0b));
586 __ cmpl(rax, Immediate(0x2029 - 0x2028));
588 __ bind(&done);
595 __ cmpl(current_character(), Immediate('z'));
598 __ Move(rbx, ExternalReference::re_word_character_map());
600 __ testb(Operand(rbx, current_character(), times_1, 0),
609 __ cmpl(current_character(), Immediate('z'));
610 __ j(above, &done);
612 __ Move(rbx, ExternalReference::re_word_character_map());
614 __ testb(Operand(rbx, current_character(), times_1, 0),
618 __ bind(&done);
636 __ Set(rax, FAILURE);
638 __ jmp(&exit_label_);
647 __ bind(&entry_label_);
654 __ pushq(rbp);
655 __ movp(rbp, rsp);
661 __ movq(Operand(rbp, kInputString), rcx);
662 __ movq(Operand(rbp, kStartIndex), rdx); // Passed as int32 in edx.
663 __ movq(Operand(rbp, kInputStart), r8);
664 __ movq(Operand(rbp, kInputEnd), r9);
666 __ pushq(rsi);
667 __ pushq(rdi);
668 __ pushq(rbx);
678 __ pushq(rdi);
679 __ pushq(rsi);
680 __ pushq(rdx);
681 __ pushq(rcx);
682 __ pushq(r8);
683 __ pushq(r9);
685 __ pushq(rbx); // Callee-save
688 __ Push(Immediate(0)); // Number of successful matches in a global regexp.
689 __ Push(Immediate(0)); // Make room for "input start - 1" constant.
697 __ movp(rcx, rsp);
698 __ Move(kScratchRegister, stack_limit);
699 __ subp(rcx, Operand(kScratchRegister, 0));
701 __ j(below_equal, &stack_limit_hit);
704 __ cmpp(rcx, Immediate(num_registers_ * kPointerSize));
705 __ j(above_equal, &stack_ok);
708 __ Set(rax, EXCEPTION);
709 __ jmp(&return_rax);
711 __ bind(&stack_limit_hit);
712 __ Move(code_object_pointer(), masm_.CodeObject());
714 __ testp(rax, rax);
716 __ j(not_zero, &return_rax);
718 __ bind(&stack_ok);
721 __ subp(rsp, Immediate(num_registers_ * kPointerSize));
723 __ movp(rsi, Operand(rbp, kInputEnd));
725 __ movp(rdi, Operand(rbp, kInputStart));
727 __ subq(rdi, rsi);
730 __ movp(rbx, Operand(rbp, kStartIndex));
731 __ negq(rbx);
733 __ leap(rax, Operand(rdi, rbx, times_2, -char_size()));
735 __ leap(rax, Operand(rdi, rbx, times_1, -char_size()));
739 __ movp(Operand(rbp, kInputStartMinusOne), rax);
749 __ movp(register_location(i), rax); // One write every page.
754 __ Move(code_object_pointer(), masm_.CodeObject());
758 __ cmpl(Operand(rbp, kStartIndex), Immediate(0));
759 __ j(not_equal, &load_char_start_regexp, Label::kNear);
760 __ Set(current_character(), '\n');
761 __ jmp(&start_regexp, Label::kNear);
764 __ bind(&load_char_start_regexp);
767 __ bind(&start_regexp);
775 __ Set(rcx, kRegisterZero);
777 __ bind(&init_loop);
778 __ movp(Operand(rbp, rcx, times_1, 0), rax);
779 __ subq(rcx, Immediate(kPointerSize));
780 __ cmpq(rcx,
782 __ j(greater, &init_loop);
785 __ movp(register_location(i), rax);
791 __ movp(backtrack_stackpointer(), Operand(rbp, kStackHighEnd));
793 __ jmp(&start_label_);
798 __ bind(&success_label_);
801 __ movp(rdx, Operand(rbp, kStartIndex));
802 __ movp(rbx, Operand(rbp, kRegisterOutput));
803 __ movp(rcx, Operand(rbp, kInputEnd));
804 __ subp(rcx, Operand(rbp, kInputStart));
806 __ leap(rcx, Operand(rcx, rdx, times_2, 0));
808 __ addp(rcx, rdx);
811 __ movp(rax, register_location(i));
814 __ movp(rdx, rax);
816 __ addp(rax, rcx); // Convert to index from start, not end.
818 __ sarp(rax, Immediate(1)); // Convert byte index to character index.
820 __ movl(Operand(rbx, i * kIntSize), rax);
827 __ incp(Operand(rbp, kSuccessfulCaptures));
830 __ movsxlq(rcx, Operand(rbp, kNumOutputRegisters));
831 __ subp(rcx, Immediate(num_saved_registers_));
833 __ cmpp(rcx, Immediate(num_saved_registers_));
834 __ j(less, &exit_label_);
836 __ movp(Operand(rbp, kNumOutputRegisters), rcx);
838 __ addp(Operand(rbp, kRegisterOutput),
842 __ movp(rax, Operand(rbp, kInputStartMinusOne));
847 __ cmpp(rdi, rdx);
849 __ j(not_equal, &load_char_start_regexp);
851 __ testp(rdi, rdi);
852 __ j(zero, &exit_label_, Label::kNear);
855 __ addq(rdi, Immediate(2));
857 __ incq(rdi);
861 __ jmp(&load_char_start_regexp);
863 __ movp(rax, Immediate(SUCCESS));
867 __ bind(&exit_label_);
870 __ movp(rax, Operand(rbp, kSuccessfulCaptures));
873 __ bind(&return_rax);
876 __ leap(rsp, Operand(rbp, kLastCalleeSaveRegister));
877 __ popq(rbx);
878 __ popq(rdi);
879 __ popq(rsi);
883 __ movp(rbx, Operand(rbp, kBackup_rbx));
885 __ movp(rsp, rbp);
888 __ popq(rbp);
889 __ ret(0);
893 __ bind(&backtrack_label_);
903 __ pushq(backtrack_stackpointer());
904 __ pushq(rdi);
907 __ testp(rax, rax);
910 __ j(not_zero, &return_rax);
913 __ Move(code_object_pointer(), masm_.CodeObject());
914 __ popq(rdi);
915 __ popq(backtrack_stackpointer());
917 __ movp(rsi, Operand(rbp, kInputEnd));
930 __ pushq(rsi);
931 __ pushq(rdi);
936 __ PrepareCallCFunction(num_arguments);
940 __ leap(rdx, Operand(rbp, kStackHighEnd)); // Second argument
941 __ LoadAddress(r8, ExternalReference::isolate_address(isolate()));
944 __ movp(rdi, backtrack_stackpointer()); // First argument.
945 __ leap(rsi, Operand(rbp, kStackHighEnd)); // Second argument.
946 __ LoadAddress(rdx, ExternalReference::isolate_address(isolate()));
950 __ CallCFunction(grow_stack, num_arguments);
953 __ testp(rax, rax);
954 __ j(equal, &exit_with_exception);
956 __ movp(backtrack_stackpointer(), rax);
958 __ Move(code_object_pointer(), masm_.CodeObject());
960 __ popq(rdi);
961 __ popq(rsi);
968 __ bind(&exit_with_exception);
970 __ Set(rax, EXCEPTION);
971 __ jmp(&return_rax);
995 __ cmpp(register_location(reg), Immediate(comparand));
1003 __ cmpp(register_location(reg), Immediate(comparand));
1010 __ cmpp(rdi, register_location(reg));
1041 __ movp(register_location(register_index), rax);
1058 __ movp(rax, register_location(register_index));
1069 __ movq(rdi, register_location(reg));
1072 __ movsxlq(rdi, register_location(reg));
1079 __ movq(dst, register_location(reg));
1082 __ movsxlq(dst, register_location(reg));
1088 __ movp(backtrack_stackpointer(), register_location(reg));
1089 __ addp(backtrack_stackpointer(), Operand(rbp, kStackHighEnd));
1095 __ cmpp(rdi, Immediate(-by * char_size()));
1096 __ j(greater_equal, &after_position, Label::kNear);
1097 __ movq(rdi, Immediate(-by * char_size()));
1102 __ bind(&after_position);
1108 __ movp(register_location(register_index), Immediate(to));
1113 __ jmp(&success_label_);
1121 __ movp(register_location(reg), rdi);
1123 __ leap(rax, Operand(rdi, cp_offset * char_size()));
1124 __ movp(register_location(reg), rax);
1131 __ movp(rax, Operand(rbp, kInputStartMinusOne));
1133 __ movp(register_location(reg), rax);
1139 __ movp(rax, backtrack_stackpointer());
1140 __ subp(rax, Operand(rbp, kStackHighEnd));
1141 __ movp(register_location(reg), rax);
1151 __ PrepareCallCFunction(num_arguments);
1154 __ movp(rdx, code_object_pointer());
1156 __ movp(r8, rbp);
1159 __ leap(rcx, Operand(rsp, -kPointerSize));
1162 __ movp(rdx, rbp);
1164 __ movp(rsi, code_object_pointer());
1167 __ leap(rdi, Operand(rsp, -kRegisterSize));
1171 __ CallCFunction(stack_check, num_arguments);
1292 __ cmpl(rdi, Immediate(-cp_offset * char_size()));
1304 __ jmp(to);
1308 __ j(condition, &backtrack_label_);
1311 __ j(condition, to);
1316 __ call(to);
1321 __ bind(label);
1322 __ subp(Operand(rsp, 0), code_object_pointer());
1327 __ addp(Operand(rsp, 0), code_object_pointer());
1328 __ ret(0);
1335 __ subp(backtrack_stackpointer(), Immediate(kIntSize));
1336 __ movl(Operand(backtrack_stackpointer(), 0), source);
1342 __ subp(backtrack_stackpointer(), Immediate(kIntSize));
1343 __ movl(Operand(backtrack_stackpointer(), 0), value);
1366 __ subp(backtrack_stackpointer(), Immediate(kIntSize));
1367 __ movl(Operand(backtrack_stackpointer(), 0), backtrack_target);
1374 __ movsxlq(target, Operand(backtrack_stackpointer(), 0));
1376 __ addp(backtrack_stackpointer(), Immediate(kIntSize));
1381 __ addp(backtrack_stackpointer(), Immediate(kIntSize));
1390 __ load_rax(stack_limit);
1391 __ cmpp(rsp, rax);
1392 __ j(above, &no_preempt);
1396 __ bind(&no_preempt);
1404 __ load_rax(stack_limit);
1405 __ cmpp(backtrack_stackpointer(), rax);
1406 __ j(above, &no_stack_overflow);
1410 __ bind(&no_stack_overflow);
1418 __ movl(current_character(), Operand(rsi, rdi, times_1, cp_offset));
1420 __ movzxwl(current_character(), Operand(rsi, rdi, times_1, cp_offset));
1423 __ movzxbl(current_character(), Operand(rsi, rdi, times_1, cp_offset));
1428 __ movl(current_character(),
1432 __ movzxwl(current_character(),
1438 #undef __