Lines Matching refs:__
78 #define __ ACCESS_MASM(masm_)
95 __ jmp(&entry_label_); // We'll write the entry code later.
96 __ bind(&start_label_); // And then continue from here.
120 __ add(edi, Immediate(by * char_size()));
129 __ add(register_location(reg), Immediate(by));
138 __ add(ebx, Immediate(masm_->CodeObject()));
139 __ jmp(ebx);
144 __ bind(label);
149 __ cmp(current_character(), c);
155 __ cmp(current_character(), limit);
163 __ cmp(Operand(ebp, kStartIndex), Immediate(0));
166 __ lea(eax, Operand(esi, edi, times_1, 0));
167 __ cmp(eax, Operand(ebp, kInputStart));
169 __ bind(¬_at_start);
175 __ cmp(Operand(ebp, kStartIndex), Immediate(0));
178 __ lea(eax, Operand(esi, edi, times_1, 0));
179 __ cmp(eax, Operand(ebp, kInputStart));
185 __ cmp(current_character(), limit);
192 __ cmp(edi, Operand(backtrack_stackpointer(), 0));
193 __ j(not_equal, &fallthrough);
194 __ add(backtrack_stackpointer(), Immediate(kPointerSize)); // Pop.
196 __ bind(&fallthrough);
204 __ mov(edx, register_location(start_reg)); // Index of start of capture
205 __ mov(ebx, register_location(start_reg + 1)); // Index of end of capture
206 __ sub(ebx, edx); // Length of capture.
215 __ j(equal, &fallthrough);
218 __ mov(eax, edi);
219 __ add(eax, ebx);
227 __ push(edi);
228 __ push(backtrack_stackpointer());
231 __ add(edx, esi); // Start of capture
232 __ add(edi, esi); // Start of text to match against capture.
233 __ add(ebx, edi); // End of text to match against capture.
236 __ bind(&loop);
237 __ movzx_b(eax, Operand(edi, 0));
238 __ cmpb_al(Operand(edx, 0));
239 __ j(equal, &loop_increment);
242 __ or_(eax, 0x20); // Convert match character to lower-case.
243 __ lea(ecx, Operand(eax, -'a'));
244 __ cmp(ecx, static_cast<int32_t>('z' - 'a')); // Is eax a lowercase letter?
246 __ j(below_equal, &convert_capture); // In range 'a'-'z'.
248 __ sub(ecx, Immediate(224 - 'a'));
249 __ cmp(ecx, Immediate(254 - 224));
250 __ j(above, &fail); // Weren't Latin-1 letters.
251 __ cmp(ecx, Immediate(247 - 224)); // Check for 247.
252 __ j(equal, &fail);
253 __ bind(&convert_capture);
255 __ movzx_b(ecx, Operand(edx, 0));
256 __ or_(ecx, 0x20);
258 __ cmp(eax, ecx);
259 __ j(not_equal, &fail);
261 __ bind(&loop_increment);
263 __ add(edx, Immediate(1));
264 __ add(edi, Immediate(1));
266 __ cmp(edi, ebx);
267 __ j(below, &loop);
268 __ jmp(&success);
270 __ bind(&fail);
272 __ pop(backtrack_stackpointer());
273 __ pop(edi);
276 __ bind(&success);
278 __ pop(backtrack_stackpointer());
280 __ add(esp, Immediate(kPointerSize));
282 __ sub(edi, esi);
286 __ push(esi);
287 __ push(edi);
288 __ push(backtrack_stackpointer());
289 __ push(ebx);
292 __ PrepareCallCFunction(argument_count, ecx);
301 __ mov(Operand(esp, 3 * kPointerSize),
304 __ mov(Operand(esp, 2 * kPointerSize), ebx);
308 __ add(edi, esi);
309 __ mov(Operand(esp, 1 * kPointerSize), edi);
312 __ add(edx, esi);
313 __ mov(Operand(esp, 0 * kPointerSize), edx);
319 __ CallCFunction(compare, argument_count);
322 __ pop(ebx);
323 __ pop(backtrack_stackpointer());
324 __ pop(edi);
325 __ pop(esi);
328 __ or_(eax, eax);
331 __ add(edi, ebx);
333 __ bind(&fallthrough);
345 __ mov(edx, register_location(start_reg));
346 __ mov(eax, register_location(start_reg + 1));
347 __ sub(eax, edx); // Length to check.
351 __ j(equal, &fallthrough);
354 __ mov(ebx, edi);
355 __ add(ebx, eax);
359 __ push(backtrack_stackpointer());
362 __ lea(ebx, Operand(esi, edi, times_1, 0)); // Start of match.
363 __ add(edx, esi); // Start of capture.
364 __ lea(ecx, Operand(eax, ebx, times_1, 0)); // End of match
367 __ bind(&loop);
369 __ movzx_b(eax, Operand(edx, 0));
370 __ cmpb_al(Operand(ebx, 0));
373 __ movzx_w(eax, Operand(edx, 0));
374 __ cmpw_ax(Operand(ebx, 0));
376 __ j(not_equal, &fail);
378 __ add(edx, Immediate(char_size()));
379 __ add(ebx, Immediate(char_size()));
381 __ cmp(ebx, ecx);
382 __ j(below, &loop);
383 __ jmp(&success);
385 __ bind(&fail);
387 __ pop(backtrack_stackpointer());
390 __ bind(&success);
392 __ mov(edi, ecx);
393 __ sub(edi, esi);
395 __ pop(backtrack_stackpointer());
397 __ bind(&fallthrough);
403 __ cmp(current_character(), c);
412 __ test(current_character(), Immediate(mask));
414 __ mov(eax, mask);
415 __ and_(eax, current_character());
416 __ cmp(eax, c);
426 __ test(current_character(), Immediate(mask));
428 __ mov(eax, mask);
429 __ and_(eax, current_character());
430 __ cmp(eax, c);
442 __ lea(eax, Operand(current_character(), -minus));
444 __ test(eax, Immediate(mask));
446 __ and_(eax, mask);
447 __ cmp(eax, c);
457 __ lea(eax, Operand(current_character(), -from));
458 __ cmp(eax, to - from);
467 __ lea(eax, Operand(current_character(), -from));
468 __ cmp(eax, to - from);
476 __ mov(eax, Immediate(table));
479 __ mov(ebx, kTableSize - 1);
480 __ and_(ebx, current_character());
483 __ cmpb(FieldOperand(eax, index, times_1, ByteArray::kHeaderSize), 0);
498 __ cmp(current_character(), ' ');
499 __ j(equal, &success, Label::kNear);
501 __ lea(eax, Operand(current_character(), -'\t'));
502 __ cmp(eax, '\r' - '\t');
503 __ j(below_equal, &success, Label::kNear);
505 __ cmp(eax, 0x00a0 - '\t');
507 __ bind(&success);
516 __ lea(eax, Operand(current_character(), -'0'));
517 __ cmp(eax, '9' - '0');
522 __ lea(eax, Operand(current_character(), -'0'));
523 __ cmp(eax, '9' - '0');
528 __ mov(eax, current_character());
529 __ xor_(eax, Immediate(0x01));
531 __ sub(eax, Immediate(0x0b));
532 __ cmp(eax, 0x0c - 0x0b);
538 __ sub(eax, Immediate(0x2028 - 0x0b));
539 __ cmp(eax, 0x2029 - 0x2028);
547 __ cmp(current_character(), Immediate('z'));
552 __ test_b(current_character(),
561 __ cmp(current_character(), Immediate('z'));
562 __ j(above, &done);
566 __ test_b(current_character(),
570 __ bind(&done);
581 __ mov(eax, current_character());
582 __ xor_(eax, Immediate(0x01));
584 __ sub(eax, Immediate(0x0b));
585 __ cmp(eax, 0x0c - 0x0b);
595 __ sub(eax, Immediate(0x2028 - 0x0b));
596 __ cmp(eax, 1);
598 __ bind(&done);
612 __ Move(eax, Immediate(FAILURE));
614 __ jmp(&exit_label_);
624 __ bind(&entry_label_);
631 __ push(ebp);
632 __ mov(ebp, esp);
635 __ push(esi);
636 __ push(edi);
637 __ push(ebx); // Callee-save on MacOS.
638 __ push(Immediate(0)); // Number of successful matches in a global regexp.
639 __ push(Immediate(0)); // Make room for "input start - 1" constant.
647 __ mov(ecx, esp);
648 __ sub(ecx, Operand::StaticVariable(stack_limit));
650 __ j(below_equal, &stack_limit_hit);
653 __ cmp(ecx, num_registers_ * kPointerSize);
654 __ j(above_equal, &stack_ok);
657 __ mov(eax, EXCEPTION);
658 __ jmp(&return_eax);
660 __ bind(&stack_limit_hit);
662 __ or_(eax, eax);
664 __ j(not_zero, &return_eax);
666 __ bind(&stack_ok);
668 __ mov(ebx, Operand(ebp, kStartIndex));
671 __ sub(esp, Immediate(num_registers_ * kPointerSize));
673 __ mov(esi, Operand(ebp, kInputEnd));
675 __ mov(edi, Operand(ebp, kInputStart));
677 __ sub(edi, esi);
681 __ neg(ebx);
683 __ lea(eax, Operand(edi, ebx, times_2, -char_size()));
685 __ lea(eax, Operand(edi, ebx, times_1, -char_size()));
689 __ mov(Operand(ebp, kInputStartMinusOne), eax);
699 __ mov(register_location(i), eax); // One write every page.
705 __ cmp(Operand(ebp, kStartIndex), Immediate(0));
706 __ j(not_equal, &load_char_start_regexp, Label::kNear);
707 __ mov(current_character(), '\n');
708 __ jmp(&start_regexp, Label::kNear);
711 __ bind(&load_char_start_regexp);
714 __ bind(&start_regexp);
722 __ mov(ecx, kRegisterZero);
724 __ bind(&init_loop);
725 __ mov(Operand(ebp, ecx, times_1, 0), eax);
726 __ sub(ecx, Immediate(kPointerSize));
727 __ cmp(ecx, kRegisterZero - num_saved_registers_ * kPointerSize);
728 __ j(greater, &init_loop);
731 __ mov(register_location(i), eax);
737 __ mov(backtrack_stackpointer(), Operand(ebp, kStackHighEnd));
739 __ jmp(&start_label_);
744 __ bind(&success_label_);
747 __ mov(ebx, Operand(ebp, kRegisterOutput));
748 __ mov(ecx, Operand(ebp, kInputEnd));
749 __ mov(edx, Operand(ebp, kStartIndex));
750 __ sub(ecx, Operand(ebp, kInputStart));
752 __ lea(ecx, Operand(ecx, edx, times_2, 0));
754 __ add(ecx, edx);
757 __ mov(eax, register_location(i));
760 __ mov(edx, eax);
763 __ add(eax, ecx);
765 __ sar(eax, 1); // Convert byte index to character index.
767 __ mov(Operand(ebx, i * kPointerSize), eax);
774 __ inc(Operand(ebp, kSuccessfulCaptures));
777 __ mov(ecx, Operand(ebp, kNumOutputRegisters));
778 __ sub(ecx, Immediate(num_saved_registers_));
780 __ cmp(ecx, Immediate(num_saved_registers_));
781 __ j(less, &exit_label_);
783 __ mov(Operand(ebp, kNumOutputRegisters), ecx);
785 __ add(Operand(ebp, kRegisterOutput),
789 __ mov(eax, Operand(ebp, kInputStartMinusOne));
794 __ cmp(edi, edx);
796 __ j(not_equal, &load_char_start_regexp);
798 __ test(edi, edi);
799 __ j(zero, &exit_label_, Label::kNear);
802 __ add(edi, Immediate(2));
804 __ inc(edi);
808 __ jmp(&load_char_start_regexp);
810 __ mov(eax, Immediate(SUCCESS));
814 __ bind(&exit_label_);
817 __ mov(eax, Operand(ebp, kSuccessfulCaptures));
820 __ bind(&return_eax);
822 __ lea(esp, Operand(ebp, kBackup_ebx));
824 __ pop(ebx);
825 __ pop(edi);
826 __ pop(esi);
828 __ pop(ebp);
829 __ ret(0);
833 __ bind(&backtrack_label_);
843 __ push(backtrack_stackpointer());
844 __ push(edi);
847 __ or_(eax, eax);
850 __ j(not_zero, &return_eax);
852 __ pop(edi);
853 __ pop(backtrack_stackpointer());
855 __ mov(esi, Operand(ebp, kInputEnd));
866 __ push(esi);
867 __ push(edi);
871 __ PrepareCallCFunction(num_arguments, ebx);
872 __ mov(Operand(esp, 2 * kPointerSize),
874 __ lea(eax, Operand(ebp, kStackHighEnd));
875 __ mov(Operand(esp, 1 * kPointerSize), eax);
876 __ mov(Operand(esp, 0 * kPointerSize), backtrack_stackpointer());
879 __ CallCFunction(grow_stack, num_arguments);
882 __ or_(eax, eax);
883 __ j(equal, &exit_with_exception);
885 __ mov(backtrack_stackpointer(), eax);
887 __ pop(edi);
888 __ pop(esi);
894 __ bind(&exit_with_exception);
896 __ mov(eax, EXCEPTION);
897 __ jmp(&return_eax);
919 __ cmp(register_location(reg), Immediate(comparand));
927 __ cmp(register_location(reg), Immediate(comparand));
934 __ cmp(edi, register_location(reg));
965 __ mov(register_location(register_index), eax);
982 __ mov(eax, register_location(register_index));
989 __ mov(edi, register_location(reg));
994 __ mov(backtrack_stackpointer(), register_location(reg));
995 __ add(backtrack_stackpointer(), Operand(ebp, kStackHighEnd));
1000 __ cmp(edi, -by * char_size());
1001 __ j(greater_equal, &after_position, Label::kNear);
1002 __ mov(edi, -by * char_size());
1007 __ bind(&after_position);
1013 __ mov(register_location(register_index), Immediate(to));
1018 __ jmp(&success_label_);
1026 __ mov(register_location(reg), edi);
1028 __ lea(eax, Operand(edi, cp_offset * char_size()));
1029 __ mov(register_location(reg), eax);
1036 __ mov(eax, Operand(ebp, kInputStartMinusOne));
1038 __ mov(register_location(reg), eax);
1044 __ mov(eax, backtrack_stackpointer());
1045 __ sub(eax, Operand(ebp, kStackHighEnd));
1046 __ mov(register_location(reg), eax);
1054 __ PrepareCallCFunction(num_arguments, scratch);
1056 __ mov(Operand(esp, 2 * kPointerSize), ebp);
1058 __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject()));
1060 __ lea(eax, Operand(esp, -kPointerSize));
1061 __ mov(Operand(esp, 0 * kPointerSize), eax);
1064 __ CallCFunction(check_stack_guard, num_arguments);
1185 __ cmp(edi, -cp_offset * char_size());
1197 __ jmp(to);
1201 __ j(condition, &backtrack_label_);
1204 __ j(condition, to);
1210 __ push(Immediate::CodeRelativeOffset(&return_to));
1211 __ jmp(to);
1212 __ bind(&return_to);
1217 __ pop(ebx);
1218 __ add(ebx, Immediate(masm_->CodeObject()));
1219 __ jmp(ebx);
1224 __ bind(name);
1231 __ sub(backtrack_stackpointer(), Immediate(kPointerSize));
1232 __ mov(Operand(backtrack_stackpointer(), 0), source);
1238 __ sub(backtrack_stackpointer(), Immediate(kPointerSize));
1239 __ mov(Operand(backtrack_stackpointer(), 0), value);
1245 __ mov(target, Operand(backtrack_stackpointer(), 0));
1247 __ add(backtrack_stackpointer(), Immediate(kPointerSize));
1256 __ cmp(esp, Operand::StaticVariable(stack_limit));
1257 __ j(above, &no_preempt);
1261 __ bind(&no_preempt);
1269 __ cmp(backtrack_stackpointer(), Operand::StaticVariable(stack_limit));
1270 __ j(above, &no_stack_overflow);
1274 __ bind(&no_stack_overflow);
1282 __ mov(current_character(), Operand(esi, edi, times_1, cp_offset));
1284 __ movzx_w(current_character(), Operand(esi, edi, times_1, cp_offset));
1287 __ movzx_b(current_character(), Operand(esi, edi, times_1, cp_offset));
1292 __ mov(current_character(),
1296 __ movzx_w(current_character(),
1303 #undef __