Lines Matching refs:__
79 #define __ ACCESS_MASM(masm_)
96 __ jmp(&entry_label_); // We'll write the entry code later.
97 __ bind(&start_label_); // And then continue from here.
121 __ add(edi, Immediate(by * char_size()));
130 __ add(register_location(reg), Immediate(by));
139 __ add(ebx, Immediate(masm_->CodeObject()));
140 __ jmp(ebx);
145 __ bind(label);
150 __ cmp(current_character(), c);
156 __ cmp(current_character(), limit);
164 __ cmp(Operand(ebp, kStartIndex), Immediate(0));
167 __ lea(eax, Operand(esi, edi, times_1, 0));
168 __ cmp(eax, Operand(ebp, kInputStart));
170 __ bind(¬_at_start);
176 __ cmp(Operand(ebp, kStartIndex), Immediate(0));
179 __ lea(eax, Operand(esi, edi, times_1, 0));
180 __ cmp(eax, Operand(ebp, kInputStart));
186 __ cmp(current_character(), limit);
193 __ cmp(edi, Operand(backtrack_stackpointer(), 0));
194 __ j(not_equal, &fallthrough);
195 __ add(backtrack_stackpointer(), Immediate(kPointerSize)); // Pop.
197 __ bind(&fallthrough);
205 __ mov(edx, register_location(start_reg)); // Index of start of capture
206 __ mov(ebx, register_location(start_reg + 1)); // Index of end of capture
207 __ sub(ebx, edx); // Length of capture.
216 __ j(equal, &fallthrough);
219 __ mov(eax, edi);
220 __ add(eax, ebx);
228 __ push(edi);
229 __ push(backtrack_stackpointer());
232 __ add(edx, esi); // Start of capture
233 __ add(edi, esi); // Start of text to match against capture.
234 __ add(ebx, edi); // End of text to match against capture.
237 __ bind(&loop);
238 __ movzx_b(eax, Operand(edi, 0));
239 __ cmpb_al(Operand(edx, 0));
240 __ j(equal, &loop_increment);
243 __ or_(eax, 0x20); // Convert match character to lower-case.
244 __ lea(ecx, Operand(eax, -'a'));
245 __ cmp(ecx, static_cast<int32_t>('z' - 'a')); // Is eax a lowercase letter?
247 __ j(below_equal, &convert_capture); // In range 'a'-'z'.
249 __ sub(ecx, Immediate(224 - 'a'));
250 __ cmp(ecx, Immediate(254 - 224));
251 __ j(above, &fail); // Weren't Latin-1 letters.
252 __ cmp(ecx, Immediate(247 - 224)); // Check for 247.
253 __ j(equal, &fail);
254 __ bind(&convert_capture);
256 __ movzx_b(ecx, Operand(edx, 0));
257 __ or_(ecx, 0x20);
259 __ cmp(eax, ecx);
260 __ j(not_equal, &fail);
262 __ bind(&loop_increment);
264 __ add(edx, Immediate(1));
265 __ add(edi, Immediate(1));
267 __ cmp(edi, ebx);
268 __ j(below, &loop);
269 __ jmp(&success);
271 __ bind(&fail);
273 __ pop(backtrack_stackpointer());
274 __ pop(edi);
277 __ bind(&success);
279 __ pop(backtrack_stackpointer());
281 __ add(esp, Immediate(kPointerSize));
283 __ sub(edi, esi);
287 __ push(esi);
288 __ push(edi);
289 __ push(backtrack_stackpointer());
290 __ push(ebx);
293 __ PrepareCallCFunction(argument_count, ecx);
302 __ mov(Operand(esp, 3 * kPointerSize),
305 __ mov(Operand(esp, 2 * kPointerSize), ebx);
309 __ add(edi, esi);
310 __ mov(Operand(esp, 1 * kPointerSize), edi);
313 __ add(edx, esi);
314 __ mov(Operand(esp, 0 * kPointerSize), edx);
320 __ CallCFunction(compare, argument_count);
323 __ pop(ebx);
324 __ pop(backtrack_stackpointer());
325 __ pop(edi);
326 __ pop(esi);
329 __ or_(eax, eax);
332 __ add(edi, ebx);
334 __ bind(&fallthrough);
346 __ mov(edx, register_location(start_reg));
347 __ mov(eax, register_location(start_reg + 1));
348 __ sub(eax, edx); // Length to check.
352 __ j(equal, &fallthrough);
355 __ mov(ebx, edi);
356 __ add(ebx, eax);
360 __ push(backtrack_stackpointer());
363 __ lea(ebx, Operand(esi, edi, times_1, 0)); // Start of match.
364 __ add(edx, esi); // Start of capture.
365 __ lea(ecx, Operand(eax, ebx, times_1, 0)); // End of match
368 __ bind(&loop);
370 __ movzx_b(eax, Operand(edx, 0));
371 __ cmpb_al(Operand(ebx, 0));
374 __ movzx_w(eax, Operand(edx, 0));
375 __ cmpw_ax(Operand(ebx, 0));
377 __ j(not_equal, &fail);
379 __ add(edx, Immediate(char_size()));
380 __ add(ebx, Immediate(char_size()));
382 __ cmp(ebx, ecx);
383 __ j(below, &loop);
384 __ jmp(&success);
386 __ bind(&fail);
388 __ pop(backtrack_stackpointer());
391 __ bind(&success);
393 __ mov(edi, ecx);
394 __ sub(edi, esi);
396 __ pop(backtrack_stackpointer());
398 __ bind(&fallthrough);
404 __ cmp(current_character(), c);
413 __ test(current_character(), Immediate(mask));
415 __ mov(eax, mask);
416 __ and_(eax, current_character());
417 __ cmp(eax, c);
427 __ test(current_character(), Immediate(mask));
429 __ mov(eax, mask);
430 __ and_(eax, current_character());
431 __ cmp(eax, c);
443 __ lea(eax, Operand(current_character(), -minus));
445 __ test(eax, Immediate(mask));
447 __ and_(eax, mask);
448 __ cmp(eax, c);
458 __ lea(eax, Operand(current_character(), -from));
459 __ cmp(eax, to - from);
468 __ lea(eax, Operand(current_character(), -from));
469 __ cmp(eax, to - from);
477 __ mov(eax, Immediate(table));
480 __ mov(ebx, kTableSize - 1);
481 __ and_(ebx, current_character());
484 __ cmpb(FieldOperand(eax, index, times_1, ByteArray::kHeaderSize), 0);
499 __ cmp(current_character(), ' ');
500 __ j(equal, &success, Label::kNear);
502 __ lea(eax, Operand(current_character(), -'\t'));
503 __ cmp(eax, '\r' - '\t');
504 __ j(below_equal, &success, Label::kNear);
506 __ cmp(eax, 0x00a0 - '\t');
508 __ bind(&success);
517 __ lea(eax, Operand(current_character(), -'0'));
518 __ cmp(eax, '9' - '0');
523 __ lea(eax, Operand(current_character(), -'0'));
524 __ cmp(eax, '9' - '0');
529 __ mov(eax, current_character());
530 __ xor_(eax, Immediate(0x01));
532 __ sub(eax, Immediate(0x0b));
533 __ cmp(eax, 0x0c - 0x0b);
539 __ sub(eax, Immediate(0x2028 - 0x0b));
540 __ cmp(eax, 0x2029 - 0x2028);
548 __ cmp(current_character(), Immediate('z'));
553 __ test_b(current_character(),
562 __ cmp(current_character(), Immediate('z'));
563 __ j(above, &done);
567 __ test_b(current_character(),
571 __ bind(&done);
582 __ mov(eax, current_character());
583 __ xor_(eax, Immediate(0x01));
585 __ sub(eax, Immediate(0x0b));
586 __ cmp(eax, 0x0c - 0x0b);
596 __ sub(eax, Immediate(0x2028 - 0x0b));
597 __ cmp(eax, 1);
599 __ bind(&done);
613 __ Move(eax, Immediate(FAILURE));
615 __ jmp(&exit_label_);
625 __ bind(&entry_label_);
632 __ push(ebp);
633 __ mov(ebp, esp);
636 __ push(esi);
637 __ push(edi);
638 __ push(ebx); // Callee-save on MacOS.
639 __ push(Immediate(0)); // Number of successful matches in a global regexp.
640 __ push(Immediate(0)); // Make room for "input start - 1" constant.
648 __ mov(ecx, esp);
649 __ sub(ecx, Operand::StaticVariable(stack_limit));
651 __ j(below_equal, &stack_limit_hit);
654 __ cmp(ecx, num_registers_ * kPointerSize);
655 __ j(above_equal, &stack_ok);
658 __ mov(eax, EXCEPTION);
659 __ jmp(&return_eax);
661 __ bind(&stack_limit_hit);
663 __ or_(eax, eax);
665 __ j(not_zero, &return_eax);
667 __ bind(&stack_ok);
669 __ mov(ebx, Operand(ebp, kStartIndex));
672 __ sub(esp, Immediate(num_registers_ * kPointerSize));
674 __ mov(esi, Operand(ebp, kInputEnd));
676 __ mov(edi, Operand(ebp, kInputStart));
678 __ sub(edi, esi);
682 __ neg(ebx);
684 __ lea(eax, Operand(edi, ebx, times_2, -char_size()));
686 __ lea(eax, Operand(edi, ebx, times_1, -char_size()));
690 __ mov(Operand(ebp, kInputStartMinusOne), eax);
700 __ mov(register_location(i), eax); // One write every page.
706 __ cmp(Operand(ebp, kStartIndex), Immediate(0));
707 __ j(not_equal, &load_char_start_regexp, Label::kNear);
708 __ mov(current_character(), '\n');
709 __ jmp(&start_regexp, Label::kNear);
712 __ bind(&load_char_start_regexp);
715 __ bind(&start_regexp);
723 __ mov(ecx, kRegisterZero);
725 __ bind(&init_loop);
726 __ mov(Operand(ebp, ecx, times_1, 0), eax);
727 __ sub(ecx, Immediate(kPointerSize));
728 __ cmp(ecx, kRegisterZero - num_saved_registers_ * kPointerSize);
729 __ j(greater, &init_loop);
732 __ mov(register_location(i), eax);
738 __ mov(backtrack_stackpointer(), Operand(ebp, kStackHighEnd));
740 __ jmp(&start_label_);
745 __ bind(&success_label_);
748 __ mov(ebx, Operand(ebp, kRegisterOutput));
749 __ mov(ecx, Operand(ebp, kInputEnd));
750 __ mov(edx, Operand(ebp, kStartIndex));
751 __ sub(ecx, Operand(ebp, kInputStart));
753 __ lea(ecx, Operand(ecx, edx, times_2, 0));
755 __ add(ecx, edx);
758 __ mov(eax, register_location(i));
761 __ mov(edx, eax);
764 __ add(eax, ecx);
766 __ sar(eax, 1); // Convert byte index to character index.
768 __ mov(Operand(ebx, i * kPointerSize), eax);
775 __ inc(Operand(ebp, kSuccessfulCaptures));
778 __ mov(ecx, Operand(ebp, kNumOutputRegisters));
779 __ sub(ecx, Immediate(num_saved_registers_));
781 __ cmp(ecx, Immediate(num_saved_registers_));
782 __ j(less, &exit_label_);
784 __ mov(Operand(ebp, kNumOutputRegisters), ecx);
786 __ add(Operand(ebp, kRegisterOutput),
790 __ mov(eax, Operand(ebp, kInputStartMinusOne));
795 __ cmp(edi, edx);
797 __ j(not_equal, &load_char_start_regexp);
799 __ test(edi, edi);
800 __ j(zero, &exit_label_, Label::kNear);
803 __ add(edi, Immediate(2));
805 __ inc(edi);
809 __ jmp(&load_char_start_regexp);
811 __ mov(eax, Immediate(SUCCESS));
815 __ bind(&exit_label_);
818 __ mov(eax, Operand(ebp, kSuccessfulCaptures));
821 __ bind(&return_eax);
823 __ lea(esp, Operand(ebp, kBackup_ebx));
825 __ pop(ebx);
826 __ pop(edi);
827 __ pop(esi);
829 __ pop(ebp);
830 __ ret(0);
834 __ bind(&backtrack_label_);
844 __ push(backtrack_stackpointer());
845 __ push(edi);
848 __ or_(eax, eax);
851 __ j(not_zero, &return_eax);
853 __ pop(edi);
854 __ pop(backtrack_stackpointer());
856 __ mov(esi, Operand(ebp, kInputEnd));
867 __ push(esi);
868 __ push(edi);
872 __ PrepareCallCFunction(num_arguments, ebx);
873 __ mov(Operand(esp, 2 * kPointerSize),
875 __ lea(eax, Operand(ebp, kStackHighEnd));
876 __ mov(Operand(esp, 1 * kPointerSize), eax);
877 __ mov(Operand(esp, 0 * kPointerSize), backtrack_stackpointer());
880 __ CallCFunction(grow_stack, num_arguments);
883 __ or_(eax, eax);
884 __ j(equal, &exit_with_exception);
886 __ mov(backtrack_stackpointer(), eax);
888 __ pop(edi);
889 __ pop(esi);
895 __ bind(&exit_with_exception);
897 __ mov(eax, EXCEPTION);
898 __ jmp(&return_eax);
920 __ cmp(register_location(reg), Immediate(comparand));
928 __ cmp(register_location(reg), Immediate(comparand));
935 __ cmp(edi, register_location(reg));
966 __ mov(register_location(register_index), eax);
983 __ mov(eax, register_location(register_index));
990 __ mov(edi, register_location(reg));
995 __ mov(backtrack_stackpointer(), register_location(reg));
996 __ add(backtrack_stackpointer(), Operand(ebp, kStackHighEnd));
1001 __ cmp(edi, -by * char_size());
1002 __ j(greater_equal, &after_position, Label::kNear);
1003 __ mov(edi, -by * char_size());
1008 __ bind(&after_position);
1014 __ mov(register_location(register_index), Immediate(to));
1019 __ jmp(&success_label_);
1027 __ mov(register_location(reg), edi);
1029 __ lea(eax, Operand(edi, cp_offset * char_size()));
1030 __ mov(register_location(reg), eax);
1037 __ mov(eax, Operand(ebp, kInputStartMinusOne));
1039 __ mov(register_location(reg), eax);
1045 __ mov(eax, backtrack_stackpointer());
1046 __ sub(eax, Operand(ebp, kStackHighEnd));
1047 __ mov(register_location(reg), eax);
1055 __ PrepareCallCFunction(num_arguments, scratch);
1057 __ mov(Operand(esp, 2 * kPointerSize), ebp);
1059 __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject()));
1061 __ lea(eax, Operand(esp, -kPointerSize));
1062 __ mov(Operand(esp, 0 * kPointerSize), eax);
1065 __ CallCFunction(check_stack_guard, num_arguments);
1186 __ cmp(edi, -cp_offset * char_size());
1198 __ jmp(to);
1202 __ j(condition, &backtrack_label_);
1205 __ j(condition, to);
1211 __ push(Immediate::CodeRelativeOffset(&return_to));
1212 __ jmp(to);
1213 __ bind(&return_to);
1218 __ pop(ebx);
1219 __ add(ebx, Immediate(masm_->CodeObject()));
1220 __ jmp(ebx);
1225 __ bind(name);
1232 __ sub(backtrack_stackpointer(), Immediate(kPointerSize));
1233 __ mov(Operand(backtrack_stackpointer(), 0), source);
1239 __ sub(backtrack_stackpointer(), Immediate(kPointerSize));
1240 __ mov(Operand(backtrack_stackpointer(), 0), value);
1246 __ mov(target, Operand(backtrack_stackpointer(), 0));
1248 __ add(backtrack_stackpointer(), Immediate(kPointerSize));
1257 __ cmp(esp, Operand::StaticVariable(stack_limit));
1258 __ j(above, &no_preempt);
1262 __ bind(&no_preempt);
1270 __ cmp(backtrack_stackpointer(), Operand::StaticVariable(stack_limit));
1271 __ j(above, &no_stack_overflow);
1275 __ bind(&no_stack_overflow);
1283 __ mov(current_character(), Operand(esi, edi, times_1, cp_offset));
1285 __ movzx_w(current_character(), Operand(esi, edi, times_1, cp_offset));
1288 __ movzx_b(current_character(), Operand(esi, edi, times_1, cp_offset));
1293 __ mov(current_character(),
1297 __ movzx_w(current_character(),
1304 #undef __