Lines Matching refs:__
99 #define __ ACCESS_MASM(masm)
116 __ push(descriptor.GetEnvironmentParameterRegister(i));
118 __ CallExternalReference(miss, param_count);
121 __ ret(0);
129 __ pushad();
131 __ sub(esp, Immediate(kDoubleSize * XMMRegister::kMaxNumRegisters));
134 __ movsd(Operand(esp, i * kDoubleSize), reg);
140 __ PrepareCallCFunction(argument_count, ecx);
141 __ mov(Operand(esp, 0 * kPointerSize),
143 __ CallCFunction(
149 __ movsd(reg, Operand(esp, i * kDoubleSize));
151 __ add(esp, Immediate(kDoubleSize * XMMRegister::kMaxNumRegisters));
153 __ popad();
154 __ ret(0);
217 __ push(scratch1);
218 __ push(save_reg);
221 __ mov(scratch1, mantissa_operand);
225 __ fld_d(mantissa_operand);
227 __ mov(ecx, exponent_operand);
228 if (stash_exponent_copy) __ push(ecx);
230 __ and_(ecx, HeapNumber::kExponentMask);
231 __ shr(ecx, HeapNumber::kExponentShift);
232 __ lea(result_reg, MemOperand(ecx, -HeapNumber::kExponentBias));
233 __ cmp(result_reg, Immediate(HeapNumber::kMantissaBits));
234 __ j(below, &process_64_bits);
239 __ fstp(0);
241 __ sub(ecx, Immediate(delta));
242 __ xor_(result_reg, result_reg);
243 __ cmp(ecx, Immediate(31));
244 __ j(above, &done);
245 __ shl_cl(scratch1);
246 __ jmp(&check_negative);
248 __ bind(&process_64_bits);
254 __ sub(esp, Immediate(kDoubleSize / 2));
257 __ sub(esp, Immediate(kDoubleSize)); // Nolint.
260 __ fisttp_d(Operand(esp, 0));
261 __ mov(result_reg, Operand(esp, 0)); // Load low word of answer as result
262 __ add(esp, Immediate(kDoubleSize));
263 __ jmp(&done_no_stash);
266 __ sub(ecx, Immediate(delta));
267 __ neg(ecx);
269 __ mov(result_reg, MemOperand(esp, 0));
271 __ mov(result_reg, exponent_operand);
273 __ and_(result_reg,
275 __ add(result_reg,
277 __ shrd(result_reg, scratch1);
278 __ shr_cl(result_reg);
279 __ test(ecx, Immediate(32));
280 __ cmov(not_equal, scratch1, result_reg);
284 __ bind(&check_negative);
285 __ mov(result_reg, scratch1);
286 __ neg(result_reg);
288 __ cmp(MemOperand(esp, 0), Immediate(0));
290 __ cmp(exponent_operand, Immediate(0));
292 __ cmov(greater, result_reg, scratch1);
295 __ bind(&done);
297 __ add(esp, Immediate(kDoubleSize / 2));
299 __ bind(&done_no_stash);
302 __ mov(final_result_reg, result_reg);
304 __ pop(save_reg);
305 __ pop(scratch1);
306 __ ret(0);
314 __ JumpIfSmi(number, &load_smi, Label::kNear);
315 __ fld_d(FieldOperand(number, HeapNumber::kValueOffset));
316 __ jmp(&done, Label::kNear);
318 __ bind(&load_smi);
319 __ SmiUntag(number);
320 __ push(number);
321 __ fild_s(Operand(esp, 0));
322 __ pop(number);
324 __ bind(&done);
332 __ JumpIfSmi(edx, &load_smi_edx, Label::kNear);
334 __ cmp(FieldOperand(edx, HeapObject::kMapOffset), factory->heap_number_map());
335 __ j(not_equal, not_numbers); // Argument in edx is not a number.
336 __ movsd(xmm0, FieldOperand(edx, HeapNumber::kValueOffset));
337 __ bind(&load_eax);
339 __ JumpIfSmi(eax, &load_smi_eax, Label::kNear);
340 __ cmp(FieldOperand(eax, HeapObject::kMapOffset), factory->heap_number_map());
341 __ j(equal, &load_float_eax, Label::kNear);
342 __ jmp(not_numbers); // Argument in eax is not a number.
343 __ bind(&load_smi_edx);
344 __ SmiUntag(edx); // Untag smi before converting to float.
345 __ Cvtsi2sd(xmm0, edx);
346 __ SmiTag(edx); // Retag smi for heap number overwriting test.
347 __ jmp(&load_eax);
348 __ bind(&load_smi_eax);
349 __ SmiUntag(eax); // Untag smi before converting to float.
350 __ Cvtsi2sd(xmm1, eax);
351 __ SmiTag(eax); // Retag smi for heap number overwriting test.
352 __ jmp(&done, Label::kNear);
353 __ bind(&load_float_eax);
354 __ movsd(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
355 __ bind(&done);
365 __ JumpIfSmi(edx, &test_other, Label::kNear);
366 __ mov(scratch, FieldOperand(edx, HeapObject::kMapOffset));
368 __ cmp(scratch, factory->heap_number_map());
369 __ j(not_equal, non_float); // argument in edx is not a number -> NaN
371 __ bind(&test_other);
372 __ JumpIfSmi(eax, &done, Label::kNear);
373 __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset));
374 __ cmp(scratch, factory->heap_number_map());
375 __ j(not_equal, non_float); // argument in eax is not a number -> NaN
378 __ bind(&done);
396 __ mov(scratch, Immediate(1));
397 __ Cvtsi2sd(double_result, scratch);
404 __ mov(base, Operand(esp, 2 * kPointerSize));
405 __ mov(exponent, Operand(esp, 1 * kPointerSize));
407 __ JumpIfSmi(base, &base_is_smi, Label::kNear);
408 __ cmp(FieldOperand(base, HeapObject::kMapOffset),
410 __ j(not_equal, &call_runtime);
412 __ movsd(double_base, FieldOperand(base, HeapNumber::kValueOffset));
413 __ jmp(&unpack_exponent, Label::kNear);
415 __ bind(&base_is_smi);
416 __ SmiUntag(base);
417 __ Cvtsi2sd(double_base, base);
419 __ bind(&unpack_exponent);
420 __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
421 __ SmiUntag(exponent);
422 __ jmp(&int_exponent);
424 __ bind(&exponent_not_smi);
425 __ cmp(FieldOperand(exponent, HeapObject::kMapOffset),
427 __ j(not_equal, &call_runtime);
428 __ movsd(double_exponent,
431 __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
432 __ SmiUntag(exponent);
433 __ jmp(&int_exponent);
435 __ bind(&exponent_not_smi);
436 __ movsd(double_exponent,
442 __ DoubleToI(exponent, double_exponent, double_scratch,
446 __ jmp(&int_exponent);
448 __ bind(&try_arithmetic_simplification);
450 __ cvttsd2si(exponent, Operand(double_exponent));
451 __ cmp(exponent, Immediate(0x1));
452 __ j(overflow, &call_runtime);
461 __ mov(scratch, Immediate(0x3F000000u));
462 __ movd(double_scratch, scratch);
463 __ cvtss2sd(double_scratch, double_scratch);
465 __ ucomisd(double_scratch, double_exponent);
466 __ j(not_equal, ¬_plus_half, Label::kNear);
472 __ mov(scratch, 0xFF800000u);
473 __ movd(double_scratch, scratch);
474 __ cvtss2sd(double_scratch, double_scratch);
475 __ ucomisd(double_base, double_scratch);
478 __ j(not_equal, &continue_sqrt, Label::kNear);
479 __ j(carry, &continue_sqrt, Label::kNear);
482 __ xorps(double_result, double_result);
483 __ subsd(double_result, double_scratch);
484 __ jmp(&done);
486 __ bind(&continue_sqrt);
488 __ xorps(double_scratch, double_scratch);
489 __ addsd(double_scratch, double_base); // Convert -0 to +0.
490 __ sqrtsd(double_result, double_scratch);
491 __ jmp(&done);
494 __ bind(¬_plus_half);
496 __ subsd(double_scratch, double_result);
498 __ ucomisd(double_scratch, double_exponent);
499 __ j(not_equal, &fast_power, Label::kNear);
505 __ mov(scratch, 0xFF800000u);
506 __ movd(double_scratch, scratch);
507 __ cvtss2sd(double_scratch, double_scratch);
508 __ ucomisd(double_base, double_scratch);
511 __ j(not_equal, &continue_rsqrt, Label::kNear);
512 __ j(carry, &continue_rsqrt, Label::kNear);
515 __ xorps(double_result, double_result);
516 __ jmp(&done);
518 __ bind(&continue_rsqrt);
520 __ xorps(double_exponent, double_exponent);
521 __ addsd(double_exponent, double_base); // Convert -0 to +0.
522 __ sqrtsd(double_exponent, double_exponent);
523 __ divsd(double_result, double_exponent);
524 __ jmp(&done);
529 __ bind(&fast_power);
530 __ fnclex(); // Clear flags to catch exceptions later.
532 __ sub(esp, Immediate(kDoubleSize));
533 __ movsd(Operand(esp, 0), double_exponent);
534 __ fld_d(Operand(esp, 0)); // E
535 __ movsd(Operand(esp, 0), double_base);
536 __ fld_d(Operand(esp, 0)); // B, E
541 __ fyl2x(); // X
542 __ fld(0); // X, X
543 __ frndint(); // rnd(X), X
544 __ fsub(1); // rnd(X), X-rnd(X)
545 __ fxch(1); // X - rnd(X), rnd(X)
547 __ f2xm1(); // 2^(X-rnd(X)) - 1, rnd(X)
548 __ fld1(); // 1, 2^(X-rnd(X)) - 1, rnd(X)
549 __ faddp(1); // 2^(X-rnd(X)), rnd(X)
551 __ fscale(); // 2^X, rnd(X)
552 __ fstp(1); // 2^X
554 __ fnstsw_ax();
555 __ test_b(eax, 0x5F); // We check for all but precision exception.
556 __ j(not_zero, &fast_power_failed, Label::kNear);
557 __ fstp_d(Operand(esp, 0));
558 __ movsd(double_result, Operand(esp, 0));
559 __ add(esp, Immediate(kDoubleSize));
560 __ jmp(&done);
562 __ bind(&fast_power_failed);
563 __ fninit();
564 __ add(esp, Immediate(kDoubleSize));
565 __ jmp(&call_runtime);
569 __ bind(&int_exponent);
571 __ mov(scratch, exponent); // Back up exponent.
572 __ movsd(double_scratch, double_base); // Back up base.
573 __ movsd(double_scratch2, double_result); // Load double_exponent with 1.
577 __ test(scratch, scratch);
578 __ j(positive, &no_neg, Label::kNear);
579 __ neg(scratch);
580 __ bind(&no_neg);
582 __ j(zero, &while_false, Label::kNear);
583 __ shr(scratch, 1);
586 __ j(above, &while_true, Label::kNear);
587 __ movsd(double_result, double_scratch);
588 __ j(zero, &while_false, Label::kNear);
590 __ bind(&while_true);
591 __ shr(scratch, 1);
592 __ mulsd(double_scratch, double_scratch);
593 __ j(above, &while_true, Label::kNear);
594 __ mulsd(double_result, double_scratch);
595 __ j(not_zero, &while_true);
597 __ bind(&while_false);
600 __ test(exponent, exponent);
601 __ j(positive, &done);
602 __ divsd(double_scratch2, double_result);
603 __ movsd(double_result, double_scratch2);
606 __ xorps(double_scratch2, double_scratch2);
607 __ ucomisd(double_scratch2, double_result); // Result cannot be NaN.
611 __ j(not_equal, &done);
612 __ Cvtsi2sd(double_exponent, exponent);
618 __ bind(&call_runtime);
619 __ TailCallRuntime(Runtime::kMathPowRT, 2, 1);
623 __ bind(&done);
624 __ AllocateHeapNumber(eax, scratch, base, &call_runtime);
625 __ movsd(FieldOperand(eax, HeapNumber::kValueOffset), double_result);
626 __ IncrementCounter(counters->math_pow(), 1);
627 __ ret(2 * kPointerSize);
629 __ bind(&call_runtime);
632 __ PrepareCallCFunction(4, scratch);
633 __ movsd(Operand(esp, 0 * kDoubleSize), double_base);
634 __ movsd(Operand(esp, 1 * kDoubleSize), double_exponent);
635 __ CallCFunction(
640 __ sub(esp, Immediate(kDoubleSize));
641 __ fstp_d(Operand(esp, 0));
642 __ movsd(double_result, Operand(esp, 0));
643 __ add(esp, Immediate(kDoubleSize));
645 __ bind(&done);
646 __ IncrementCounter(counters->math_pow(), 1);
647 __ ret(0);
658 __ bind(&miss);
674 __ test(key, Immediate(kSmiTagMask | kSmiSignMask));
675 __ j(not_zero, &slow);
678 __ pop(scratch);
679 __ push(receiver); // receiver
680 __ push(key); // key
681 __ push(scratch); // return address
686 __ TailCallExternalReference(ref, 2, 1);
688 __ bind(&slow);
706 __ JumpIfNotSmi(edx, &slow, Label::kNear);
710 __ mov(ebx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
711 __ mov(ecx, Operand(ebx, StandardFrameConstants::kContextOffset));
712 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
713 __ j(equal, &adaptor, Label::kNear);
718 __ cmp(edx, eax);
719 __ j(above_equal, &slow, Label::kNear);
724 __ lea(ebx, Operand(ebp, eax, times_2, 0));
725 __ neg(edx);
726 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
727 __ ret(0);
732 __ bind(&adaptor);
733 __ mov(ecx, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
734 __ cmp(edx, ecx);
735 __ j(above_equal, &slow, Label::kNear);
740 __ lea(ebx, Operand(ebx, ecx, times_2, 0));
741 __ neg(edx);
742 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
743 __ ret(0);
747 __ bind(&slow);
748 __ pop(ebx); // Return address.
749 __ push(edx);
750 __ push(ebx);
751 __ TailCallRuntime(Runtime::kGetArgumentsProperty, 1, 1);
763 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
764 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
765 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
766 __ j(not_equal, &runtime, Label::kNear);
769 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
770 __ mov(Operand(esp, 1 * kPointerSize), ecx);
771 __ lea(edx, Operand(edx, ecx, times_2,
773 __ mov(Operand(esp, 2 * kPointerSize), edx);
775 __ bind(&runtime);
776 __ TailCallRuntime(Runtime::kNewSloppyArguments, 3, 1);
787 __ mov(ebx, Operand(esp, 1 * kPointerSize));
794 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
795 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
796 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
797 __ j(equal, &adaptor_frame, Label::kNear);
800 __ mov(ecx, ebx);
801 __ jmp(&try_allocate, Label::kNear);
804 __ bind(&adaptor_frame);
805 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
806 __ lea(edx, Operand(edx, ecx, times_2,
808 __ mov(Operand(esp, 2 * kPointerSize), edx);
815 __ cmp(ebx, ecx);
816 __ j(less_equal, &try_allocate, Label::kNear);
817 __ mov(ebx, ecx);
819 __ bind(&try_allocate);
822 __ push(ebx);
829 __ test(ebx, ebx);
830 __ j(zero, &no_parameter_map, Label::kNear);
831 __ lea(ebx, Operand(ebx, times_2, kParameterMapHeaderSize));
832 __ bind(&no_parameter_map);
835 __ lea(ebx, Operand(ebx, ecx, times_2, FixedArray::kHeaderSize));
838 __ add(ebx, Immediate(Heap::kSloppyArgumentsObjectSize));
841 __ Allocate(ebx, eax, edx, edi, &runtime, TAG_OBJECT);
850 __ mov(edi, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
851 __ mov(edi, FieldOperand(edi, GlobalObject::kNativeContextOffset));
852 __ mov(ebx, Operand(esp, 0 * kPointerSize));
853 __ test(ebx, ebx);
854 __ j(not_zero, &has_mapped_parameters, Label::kNear);
855 __ mov(
858 __ jmp(&instantiate, Label::kNear);
860 __ bind(&has_mapped_parameters);
861 __ mov(
864 __ bind(&instantiate);
874 __ mov(FieldOperand(eax, JSObject::kMapOffset), edi);
875 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
877 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
882 __ mov(edx, Operand(esp, 4 * kPointerSize));
883 __ AssertNotSmi(edx);
884 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
889 __ AssertSmi(ecx);
891 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
898 __ lea(edi, Operand(eax, Heap::kSloppyArgumentsObjectSize));
899 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
909 __ push(eax);
913 __ test(ebx, ebx);
914 __ j(zero, &skip_parameter_map);
916 __ mov(FieldOperand(edi, FixedArray::kMapOffset),
918 __ lea(eax, Operand(ebx, reinterpret_cast<intptr_t>(Smi::FromInt(2))));
919 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), eax);
920 __ mov(FieldOperand(edi, FixedArray::kHeaderSize + 0 * kPointerSize), esi);
921 __ lea(eax, Operand(edi, ebx, times_2, kParameterMapHeaderSize));
922 __ mov(FieldOperand(edi, FixedArray::kHeaderSize + 1 * kPointerSize), eax);
933 __ push(ecx);
934 __ mov(eax, Operand(esp, 2 * kPointerSize));
935 __ mov(ebx, Immediate(Smi::FromInt(Context::MIN_CONTEXT_SLOTS)));
936 __ add(ebx, Operand(esp, 4 * kPointerSize));
937 __ sub(ebx, eax);
938 __ mov(ecx, isolate()->factory()->the_hole_value());
939 __ mov(edx, edi);
940 __ lea(edi, Operand(edi, eax, times_2, kParameterMapHeaderSize));
951 __ jmp(¶meters_test, Label::kNear);
953 __ bind(¶meters_loop);
954 __ sub(eax, Immediate(Smi::FromInt(1)));
955 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
956 __ mov(FieldOperand(edi, eax, times_2, FixedArray::kHeaderSize), ecx);
957 __ add(ebx, Immediate(Smi::FromInt(1)));
958 __ bind(¶meters_test);
959 __ test(eax, eax);
960 __ j(not_zero, ¶meters_loop, Label::kNear);
961 __ pop(ecx);
963 __ bind(&skip_parameter_map);
972 __ mov(FieldOperand(edi, FixedArray::kMapOffset),
974 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx);
977 __ mov(ebx, Operand(esp, 1 * kPointerSize));
978 __ mov(edx, Operand(esp, 4 * kPointerSize));
979 __ sub(edx, ebx); // Is there a smarter way to do negative scaling?
980 __ sub(edx, ebx);
981 __ jmp(&arguments_test, Label::kNear);
983 __ bind(&arguments_loop);
984 __ sub(edx, Immediate(kPointerSize));
985 __ mov(eax, Operand(edx, 0));
986 __ mov(FieldOperand(edi, ebx, times_2, FixedArray::kHeaderSize), eax);
987 __ add(ebx, Immediate(Smi::FromInt(1)));
989 __ bind(&arguments_test);
990 __ cmp(ebx, ecx);
991 __ j(less, &arguments_loop, Label::kNear);
994 __ pop(eax); // Address of arguments object.
995 __ pop(ebx); // Parameter count.
998 __ ret(3 * kPointerSize);
1001 __ bind(&runtime);
1002 __ pop(eax); // Remove saved parameter count.
1003 __ mov(Operand(esp, 1 * kPointerSize), ecx); // Patch argument count.
1004 __ TailCallRuntime(Runtime::kNewSloppyArguments, 3, 1);
1016 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
1017 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
1018 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
1019 __ j(equal, &adaptor_frame, Label::kNear);
1022 __ mov(ecx, Operand(esp, 1 * kPointerSize));
1023 __ jmp(&try_allocate, Label::kNear);
1026 __ bind(&adaptor_frame);
1027 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
1028 __ mov(Operand(esp, 1 * kPointerSize), ecx);
1029 __ lea(edx, Operand(edx, ecx, times_2,
1031 __ mov(Operand(esp, 2 * kPointerSize), edx);
1036 __ bind(&try_allocate);
1037 __ test(ecx, ecx);
1038 __ j(zero, &add_arguments_object, Label::kNear);
1039 __ lea(ecx, Operand(ecx, times_2, FixedArray::kHeaderSize));
1040 __ bind(&add_arguments_object);
1041 __ add(ecx, Immediate(Heap::kStrictArgumentsObjectSize));
1044 __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
1047 __ mov(edi, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
1048 __ mov(edi, FieldOperand(edi, GlobalObject::kNativeContextOffset));
1050 __ mov(edi, Operand(edi, offset));
1052 __ mov(FieldOperand(eax, JSObject::kMapOffset), edi);
1053 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
1055 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
1060 __ mov(ecx, Operand(esp, 1 * kPointerSize));
1061 __ AssertSmi(ecx);
1062 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
1068 __ test(ecx, ecx);
1069 __ j(zero, &done, Label::kNear);
1072 __ mov(edx, Operand(esp, 2 * kPointerSize));
1076 __ lea(edi, Operand(eax, Heap::kStrictArgumentsObjectSize));
1077 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
1078 __ mov(FieldOperand(edi, FixedArray::kMapOffset),
1081 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx);
1083 __ SmiUntag(ecx);
1087 __ bind(&loop);
1088 __ mov(ebx, Operand(edx, -1 * kPointerSize)); // Skip receiver.
1089 __ mov(FieldOperand(edi, FixedArray::kHeaderSize), ebx);
1090 __ add(edi, Immediate(kPointerSize));
1091 __ sub(edx, Immediate(kPointerSize));
1092 __ dec(ecx);
1093 __ j(not_zero, &loop);
1096 __ bind(&done);
1097 __ ret(3 * kPointerSize);
1100 __ bind(&runtime);
1101 __ TailCallRuntime(Runtime::kNewStrictArguments, 3, 1);
1110 __ TailCallRuntime(Runtime::kRegExpExecRT, 4, 1);
1133 __ mov(ebx, Operand::StaticVariable(address_of_regexp_stack_memory_size));
1134 __ test(ebx, ebx);
1135 __ j(zero, &runtime);
1138 __ mov(eax, Operand(esp, kJSRegExpOffset));
1140 __ JumpIfSmi(eax, &runtime);
1141 __ CmpObjectType(eax, JS_REGEXP_TYPE, ecx);
1142 __ j(not_equal, &runtime);
1145 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
1147 __ test(ecx, Immediate(kSmiTagMask));
1148 __ Check(not_zero, kUnexpectedTypeForRegExpDataFixedArrayExpected);
1149 __ CmpObjectType(ecx, FIXED_ARRAY_TYPE, ebx);
1150 __ Check(equal, kUnexpectedTypeForRegExpDataFixedArrayExpected);
1155 __ mov(ebx, FieldOperand(ecx, JSRegExp::kDataTagOffset));
1156 __ cmp(ebx, Immediate(Smi::FromInt(JSRegExp::IRREGEXP)));
1157 __ j(not_equal, &runtime);
1161 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
1168 __ cmp(edx, Isolate::kJSRegexpStaticOffsetsVectorSize - 2);
1169 __ j(above, &runtime);
1172 __ Move(edi, Immediate(0));
1173 __ mov(eax, Operand(esp, kSubjectOffset));
1174 __ JumpIfSmi(eax, &runtime);
1175 __ mov(edx, eax); // Make a copy of the original subject string.
1176 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1177 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
1209 __ and_(ebx, kIsNotStringMask |
1214 __ j(zero, &seq_two_byte_string); // Go to (9).
1218 __ and_(ebx, Immediate(kIsNotStringMask |
1221 __ j(zero, &seq_one_byte_string, Label::kNear); // Go to (6).
1230 __ cmp(ebx, Immediate(kExternalStringTag));
1231 __ j(greater_equal, ¬_seq_nor_cons); // Go to (7).
1235 __ cmp(FieldOperand(eax, ConsString::kSecondOffset), factory->empty_string());
1236 __ j(not_equal, &runtime);
1237 __ mov(eax, FieldOperand(eax, ConsString::kFirstOffset));
1238 __ bind(&check_underlying);
1239 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1240 __ mov(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
1243 __ test_b(ebx, kStringRepresentationMask | kStringEncodingMask);
1245 __ j(zero, &seq_two_byte_string); // Go to (9).
1247 __ test_b(ebx, kStringRepresentationMask);
1251 __ j(not_zero, &external_string); // Go to (8).
1257 __ bind(&seq_one_byte_string);
1261 __ mov(ebx, Operand(esp, kPreviousIndexOffset));
1262 __ JumpIfNotSmi(ebx, &runtime);
1263 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1264 __ j(above_equal, &runtime);
1265 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataOneByteCodeOffset));
1266 __ Move(ecx, Immediate(1)); // Type is one byte.
1269 __ bind(&check_code);
1274 __ JumpIfSmi(edx, &runtime);
1282 __ IncrementCounter(counters->regexp_entry_native(), 1);
1286 __ EnterApiExitFrame(kRegExpExecuteArguments);
1289 __ mov(Operand(esp, 8 * kPointerSize),
1293 __ mov(Operand(esp, 7 * kPointerSize), Immediate(1));
1296 __ mov(esi, Operand::StaticVariable(address_of_regexp_stack_memory_address));
1297 __ add(esi, Operand::StaticVariable(address_of_regexp_stack_memory_size));
1298 __ mov(Operand(esp, 6 * kPointerSize), esi);
1302 __ mov(Operand(esp, 5 * kPointerSize), Immediate(0));
1305 __ mov(Operand(esp, 4 * kPointerSize),
1310 __ SmiUntag(ebx);
1311 __ mov(Operand(esp, 1 * kPointerSize), ebx);
1318 __ mov(esi, Operand(ebp, kSubjectOffset + kPointerSize));
1319 __ mov(Operand(esp, 0 * kPointerSize), esi);
1330 __ mov(esi, FieldOperand(esi, String::kLengthOffset));
1331 __ add(esi, edi); // Calculate input end wrt offset.
1332 __ SmiUntag(edi);
1333 __ add(ebx, edi); // Calculate input start wrt offset.
1338 __ test(ecx, ecx);
1339 __ j(zero, &setup_two_byte, Label::kNear);
1340 __ SmiUntag(esi);
1341 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqOneByteString::kHeaderSize));
1342 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Argument 4.
1343 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqOneByteString::kHeaderSize));
1344 __ mov(Operand(esp, 2 * kPointerSize), ecx); // Argument 3.
1345 __ jmp(&setup_rest, Label::kNear);
1347 __ bind(&setup_two_byte);
1350 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqTwoByteString::kHeaderSize));
1351 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Argument 4.
1352 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
1353 __ mov(Operand(esp, 2 * kPointerSize), ecx); // Argument 3.
1355 __ bind(&setup_rest);
1358 __ add(edx, Immediate(Code::kHeaderSize - kHeapObjectTag));
1359 __ call(edx);
1362 __ LeaveApiExitFrame(true);
1366 __ cmp(eax, 1);
1369 __ j(equal, &success);
1371 __ cmp(eax, NativeRegExpMacroAssembler::FAILURE);
1372 __ j(equal, &failure);
1373 __ cmp(eax, NativeRegExpMacroAssembler::EXCEPTION);
1375 __ j(not_equal, &runtime);
1382 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
1383 __ mov(eax, Operand::StaticVariable(pending_exception));
1384 __ cmp(edx, eax);
1385 __ j(equal, &runtime);
1389 __ mov(Operand::StaticVariable(pending_exception), edx);
1393 __ cmp(eax, factory->termination_exception());
1395 __ j(equal, &throw_termination_exception, Label::kNear);
1398 __ Throw(eax);
1400 __ bind(&throw_termination_exception);
1401 __ ThrowUncatchable(eax);
1403 __ bind(&failure);
1405 __ mov(eax, factory->null_value());
1406 __ ret(4 * kPointerSize);
1409 __ bind(&success);
1410 __ mov(eax, Operand(esp, kJSRegExpOffset));
1411 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
1412 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
1416 __ add(edx, Immediate(2)); // edx was a smi.
1421 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
1422 __ JumpIfSmi(eax, &runtime);
1423 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
1424 __ j(not_equal, &runtime);
1426 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
1427 __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset));
1428 __ cmp(eax, factory->fixed_array_map());
1429 __ j(not_equal, &runtime);
1432 __ mov(eax, FieldOperand(ebx, FixedArray::kLengthOffset));
1433 __ SmiUntag(eax);
1434 __ sub(eax, Immediate(RegExpImpl::kLastMatchOverhead));
1435 __ cmp(edx, eax);
1436 __ j(greater, &runtime);
1441 __ SmiTag(edx); // Number of capture registers to smi.
1442 __ mov(FieldOperand(ebx, RegExpImpl::kLastCaptureCountOffset), edx);
1443 __ SmiUntag(edx); // Number of capture registers back from smi.
1445 __ mov(eax, Operand(esp, kSubjectOffset));
1446 __ mov(ecx, eax);
1447 __ mov(FieldOperand(ebx, RegExpImpl::kLastSubjectOffset), eax);
1448 __ RecordWriteField(ebx,
1453 __ mov(eax, ecx);
1454 __ mov(FieldOperand(ebx, RegExpImpl::kLastInputOffset), eax);
1455 __ RecordWriteField(ebx,
1464 __ mov(ecx, Immediate(address_of_static_offsets_vector));
1472 __ bind(&next_capture);
1473 __ sub(edx, Immediate(1));
1474 __ j(negative, &done, Label::kNear);
1476 __ mov(edi, Operand(ecx, edx, times_int_size, 0));
1477 __ SmiTag(edi);
1479 __ mov(FieldOperand(ebx,
1484 __ jmp(&next_capture);
1485 __ bind(&done);
1488 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
1489 __ ret(4 * kPointerSize);
1492 __ bind(&runtime);
1493 __ TailCallRuntime(Runtime::kRegExpExecRT, 4, 1);
1497 __ bind(¬_seq_nor_cons);
1499 __ j(greater, ¬_long_external, Label::kNear); // Go to (10).
1502 __ bind(&external_string);
1504 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1505 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
1509 __ test_b(ebx, kIsIndirectStringMask);
1510 __ Assert(zero, kExternalStringExpectedButNotFound);
1512 __ mov(eax, FieldOperand(eax, ExternalString::kResourceDataOffset));
1515 __ sub(eax, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
1518 __ test_b(ebx, kStringEncodingMask);
1519 __ j(not_zero, &seq_one_byte_string); // Goto (6).
1525 __ bind(&seq_two_byte_string);
1529 __ mov(ebx, Operand(esp, kPreviousIndexOffset));
1530 __ JumpIfNotSmi(ebx, &runtime);
1531 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1532 __ j(above_equal, &runtime);
1533 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataUC16CodeOffset));
1534 __ Move(ecx, Immediate(0)); // Type is two byte.
1535 __ jmp(&check_code); // Go to (E).
1538 __ bind(¬_long_external);
1541 __ test(ebx, Immediate(kIsNotStringMask | kShortExternalStringTag));
1542 __ j(not_zero, &runtime);
1546 __ mov(edi, FieldOperand(eax, SlicedString::kOffsetOffset));
1547 __ mov(eax, FieldOperand(eax, SlicedString::kParentOffset));
1548 __ jmp(&check_underlying); // Go to (5a).
1565 __ JumpIfNotSmi(input, fail);
1567 __ JumpIfSmi(input, &ok);
1568 __ cmp(FieldOperand(input, HeapObject::kMapOffset),
1570 __ j(not_equal, fail);
1574 __ bind(&ok);
1582 __ JumpIfSmi(object, label);
1583 __ mov(scratch, FieldOperand(object, HeapObject::kMapOffset));
1584 __ movzx_b(scratch, FieldOperand(scratch, Map::kInstanceTypeOffset));
1586 __ test(scratch, Immediate(kIsNotStringMask | kIsNotInternalizedMask));
1587 __ j(not_zero, label);
1601 __ mov(ecx, edx);
1602 __ or_(ecx, eax);
1603 __ JumpIfNotSmi(ecx, &non_smi, Label::kNear);
1604 __ sub(edx, eax); // Return on the result of the subtraction.
1605 __ j(no_overflow, &smi_done, Label::kNear);
1606 __ not_(edx); // Correct sign in case of overflow. edx is never 0 here.
1607 __ bind(&smi_done);
1608 __ mov(eax, edx);
1609 __ ret(0);
1610 __ bind(&non_smi);
1620 __ cmp(eax, edx);
1621 __ j(not_equal, ¬_identical);
1627 __ cmp(edx, isolate()->factory()->undefined_value());
1628 __ j(not_equal, &check_for_nan, Label::kNear);
1629 __ Move(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc))));
1630 __ ret(0);
1631 __ bind(&check_for_nan);
1636 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
1638 __ j(equal, &generic_heap_number_comparison, Label::kNear);
1641 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1642 __ j(above_equal, ¬_identical);
1644 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
1645 __ ret(0);
1648 __ bind(¬_identical);
1664 __ mov(ecx, Immediate(kSmiTagMask));
1665 __ and_(ecx, eax);
1666 __ test(ecx, edx);
1667 __ j(not_zero, ¬_smis, Label::kNear);
1673 __ sub(ecx, Immediate(0x01));
1674 __ mov(ebx, edx);
1675 __ xor_(ebx, eax);
1676 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
1677 __ xor_(ebx, eax);
1681 __ cmp(FieldOperand(ebx, HeapObject::kMapOffset),
1684 __ j(equal, &slow, Label::kNear);
1686 __ mov(eax, ebx);
1687 __ ret(0);
1689 __ bind(¬_smis);
1698 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1699 __ j(below, &first_non_object, Label::kNear);
1704 __ bind(&return_not_equal);
1705 __ ret(0);
1707 __ bind(&first_non_object);
1709 __ CmpInstanceType(ecx, ODDBALL_TYPE);
1710 __ j(equal, &return_not_equal);
1712 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ecx);
1713 __ j(above_equal, &return_not_equal);
1716 __ CmpInstanceType(ecx, ODDBALL_TYPE);
1717 __ j(equal, &return_not_equal);
1720 __ bind(&slow);
1726 __ bind(&generic_heap_number_comparison);
1729 __ ucomisd(xmm0, xmm1);
1731 __ j(parity_even, &unordered, Label::kNear);
1733 __ mov(eax, 0); // equal
1734 __ mov(ecx, Immediate(Smi::FromInt(1)));
1735 __ cmov(above, eax, ecx);
1736 __ mov(ecx, Immediate(Smi::FromInt(-1)));
1737 __ cmov(below, eax, ecx);
1738 __ ret(0);
1742 __ bind(&unordered);
1745 __ mov(eax, Immediate(Smi::FromInt(1)));
1747 __ mov(eax, Immediate(Smi::FromInt(-1)));
1749 __ ret(0);
1752 __ bind(&non_number_comparison);
1763 __ ret(0);
1766 __ bind(&check_for_strings);
1768 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx,
1779 __ Abort(kUnexpectedFallThroughFromStringComparison);
1782 __ bind(&check_unequal_objects);
1794 __ lea(ecx, Operand(eax, edx, times_1, 0));
1795 __ test(ecx, Immediate(kSmiTagMask));
1796 __ j(not_zero, ¬_both_objects, Label::kNear);
1797 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1798 __ j(below, ¬_both_objects, Label::kNear);
1799 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ebx);
1800 __ j(below, ¬_both_objects, Label::kNear);
1804 __ test_b(FieldOperand(ecx, Map::kBitFieldOffset),
1806 __ j(zero, &return_unequal, Label::kNear);
1807 __ test_b(FieldOperand(ebx, Map::kBitFieldOffset),
1809 __ j(zero, &return_unequal, Label::kNear);
1812 __ Move(eax, Immediate(EQUAL));
1813 __ bind(&return_unequal);
1816 __ ret(0); // rax, rdx were pushed
1817 __ bind(¬_both_objects);
1821 __ pop(ecx);
1822 __ push(edx);
1823 __ push(eax);
1831 __ push(Immediate(Smi::FromInt(NegativeComparisonResult(cc))));
1835 __ push(ecx);
1839 __ InvokeBuiltin(builtin, JUMP_FUNCTION);
1841 __ bind(&miss);
1858 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1863 __ cmp(ecx, edi);
1864 __ j(equal, &done, Label::kFar);
1865 __ cmp(ecx, Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate)));
1866 __ j(equal, &done, Label::kFar);
1874 __ cmp(FieldOperand(ecx, 0), Immediate(allocation_site_map));
1875 __ j(not_equal, &miss);
1878 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, ecx);
1879 __ cmp(edi, ecx);
1880 __ j(not_equal, &megamorphic);
1881 __ jmp(&done, Label::kFar);
1884 __ bind(&miss);
1888 __ cmp(ecx, Immediate(TypeFeedbackVector::UninitializedSentinel(isolate)));
1889 __ j(equal, &initialize);
1892 __ bind(&megamorphic);
1893 __ mov(
1896 __ jmp(&done, Label::kFar);
1900 __ bind(&initialize);
1903 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, ecx);
1904 __ cmp(edi, ecx);
1905 __ j(not_equal, ¬_array_function);
1914 __ SmiTag(eax);
1915 __ push(eax);
1916 __ push(edi);
1917 __ push(edx);
1918 __ push(ebx);
1921 __ CallStub(&create_stub);
1923 __ pop(ebx);
1924 __ pop(edx);
1925 __ pop(edi);
1926 __ pop(eax);
1927 __ SmiUntag(eax);
1929 __ jmp(&done);
1931 __ bind(¬_array_function);
1934 __ mov(FieldOperand(ebx, edx, times_half_pointer_size,
1938 __ push(edi);
1939 __ push(ebx);
1940 __ push(edx);
1941 __ RecordWriteArray(ebx, edi, edx, kDontSaveFPRegs,
1943 __ pop(edx);
1944 __ pop(ebx);
1945 __ pop(edi);
1947 __ bind(&done);
1953 __ mov(ecx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
1954 __ test_b(FieldOperand(ecx, SharedFunctionInfo::kStrictModeByteOffset),
1956 __ j(not_equal, cont);
1959 __ test_b(FieldOperand(ecx, SharedFunctionInfo::kNativeByteOffset),
1961 __ j(not_equal, cont);
1970 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
1971 __ j(not_equal, non_function);
1972 __ pop(ecx);
1973 __ push(edi); // put proxy as additional argument under return address
1974 __ push(ecx);
1975 __ Move(eax, Immediate(argc + 1));
1976 __ Move(ebx, Immediate(0));
1977 __ GetBuiltinEntry(edx, Builtins::CALL_FUNCTION_PROXY);
1980 __ jmp(adaptor, RelocInfo::CODE_TARGET);
1985 __ bind(non_function);
1986 __ mov(Operand(esp, (argc + 1) * kPointerSize), edi);
1987 __ Move(eax, Immediate(argc));
1988 __ Move(ebx, Immediate(0));
1989 __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
1991 __ jmp(adaptor, RelocInfo::CODE_TARGET);
1998 __ push(edi);
1999 __ push(eax);
2000 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
2001 __ pop(edi);
2003 __ mov(Operand(esp, (argc + 1) * kPointerSize), eax);
2004 __ jmp(cont);
2016 __ JumpIfSmi(edi, &non_function);
2019 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
2020 __ j(not_equal, &slow);
2032 __ mov(eax, Operand(esp, (argc + 1) * kPointerSize));
2035 __ JumpIfSmi(eax, &wrap);
2037 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
2038 __ j(below, &wrap);
2040 __ jmp(&wrap);
2043 __ bind(&cont);
2046 __ InvokeFunction(edi, actual, JUMP_FUNCTION, NullCallWrapper());
2050 __ bind(&slow);
2056 __ bind(&wrap);
2076 __ JumpIfSmi(edi, &non_function_call);
2078 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
2079 __ j(not_equal, &slow);
2088 __ mov(ebx, FieldOperand(ebx, edx, times_half_pointer_size,
2093 __ mov(ebx, FieldOperand(ebx, edx, times_half_pointer_size,
2097 __ cmp(FieldOperand(ebx, 0), Immediate(allocation_site_map));
2098 __ j(equal, &feedback_register_initialized);
2099 __ mov(ebx, isolate()->factory()->undefined_value());
2100 __ bind(&feedback_register_initialized);
2103 __ AssertUndefinedOrAllocationSite(ebx);
2108 __ mov(jmp_reg, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
2109 __ mov(jmp_reg, FieldOperand(jmp_reg,
2111 __ lea(jmp_reg, FieldOperand(jmp_reg, Code::kHeaderSize));
2112 __ jmp(jmp_reg);
2118 __ bind(&slow);
2119 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
2120 __ j(not_equal, &non_function_call);
2121 __ GetBuiltinEntry(edx, Builtins::CALL_FUNCTION_PROXY_AS_CONSTRUCTOR);
2122 __ jmp(&do_call);
2124 __ bind(&non_function_call);
2125 __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR);
2126 __ bind(&do_call);
2128 __ Move(ebx, Immediate(0));
2131 __ jmp(arguments_adaptor, RelocInfo::CODE_TARGET);
2136 __ mov(vector, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
2137 __ mov(vector, FieldOperand(vector, JSFunction::kSharedFunctionInfoOffset));
2138 __ mov(vector, FieldOperand(vector,
2152 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, ecx);
2153 __ cmp(edi, ecx);
2154 __ j(not_equal, &miss);
2156 __ mov(eax, arg_count());
2157 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
2162 __ cmp(FieldOperand(ecx, HeapObject::kMapOffset),
2164 __ j(not_equal, &miss);
2166 __ mov(ebx, ecx);
2168 __ TailCallStub(&stub);
2170 __ bind(&miss);
2180 __ int3();
2197 __ cmp(edi, FieldOperand(ebx, edx, times_half_pointer_size,
2199 __ j(not_equal, &extra_checks_or_miss);
2201 __ bind(&have_js_function);
2206 __ mov(eax, Operand(esp, (argc + 1) * kPointerSize));
2208 __ JumpIfSmi(eax, &wrap);
2210 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
2211 __ j(below, &wrap);
2213 __ bind(&cont);
2216 __ InvokeFunction(edi, actual, JUMP_FUNCTION, NullCallWrapper());
2218 __ bind(&slow);
2222 __ bind(&wrap);
2226 __ bind(&extra_checks_or_miss);
2229 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
2231 __ cmp(ecx, Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate)));
2232 __ j(equal, &slow_start);
2233 __ cmp(ecx, Immediate(TypeFeedbackVector::UninitializedSentinel(isolate)));
2234 __ j(equal, &miss);
2239 __ AssertNotSmi(ecx);
2240 __ CmpObjectType(ecx, JS_FUNCTION_TYPE, ecx);
2241 __ j(not_equal, &miss);
2242 __ mov(FieldOperand(ebx, edx, times_half_pointer_size,
2245 __ jmp(&slow_start);
2249 __ bind(&miss);
2253 __ bind(&slow_start);
2256 __ JumpIfSmi(edi, &non_function);
2259 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
2260 __ j(not_equal, &slow);
2261 __ jmp(&have_js_function);
2264 __ int3();
2270 __ mov(ecx, Operand(esp, (arg_count() + 1) * kPointerSize));
2276 __ push(ecx);
2277 __ push(edi);
2278 __ push(ebx);
2279 __ push(edx);
2287 __ CallExternalReference(miss, 4);
2290 __ mov(edi, eax);
2336 __ EnterExitFrame(save_doubles());
2348 __ CheckStackAlignment();
2352 __ mov(Operand(esp, 0 * kPointerSize), edi); // argc.
2353 __ mov(Operand(esp, 1 * kPointerSize), esi); // argv.
2354 __ mov(Operand(esp, 2 * kPointerSize),
2356 __ call(ebx);
2363 __ cmp(eax, isolate()->factory()->the_hole_value());
2364 __ j(not_equal, &okay, Label::kNear);
2365 __ int3();
2366 __ bind(&okay);
2371 __ cmp(eax, isolate()->factory()->exception());
2372 __ j(equal, &exception_returned);
2380 __ push(edx);
2381 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2383 __ cmp(edx, Operand::StaticVariable(pending_exception_address));
2385 __ j(equal, &okay, Label::kNear);
2386 __ int3();
2387 __ bind(&okay);
2388 __ pop(edx);
2392 __ LeaveExitFrame(save_doubles());
2393 __ ret(0);
2396 __ bind(&exception_returned);
2399 __ mov(eax, Operand::StaticVariable(pending_exception_address));
2402 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2403 __ mov(Operand::StaticVariable(pending_exception_address), edx);
2408 __ cmp(eax, isolate()->factory()->termination_exception());
2409 __ j(equal, &throw_termination_exception);
2412 __ Throw(eax);
2414 __ bind(&throw_termination_exception);
2415 __ ThrowUncatchable(eax);
2426 __ push(ebp);
2427 __ mov(ebp, esp);
2431 __ push(Immediate(Smi::FromInt(marker))); // context slot
2432 __ push(Immediate(Smi::FromInt(marker))); // function slot
2434 __ push(edi);
2435 __ push(esi);
2436 __ push(ebx);
2440 __ push(Operand::StaticVariable(c_entry_fp));
2444 __ cmp(Operand::StaticVariable(js_entry_sp), Immediate(0));
2445 __ j(not_equal, ¬_outermost_js, Label::kNear);
2446 __ mov(Operand::StaticVariable(js_entry_sp), ebp);
2447 __ push(Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
2448 __ jmp(&invoke, Label::kNear);
2449 __ bind(¬_outermost_js);
2450 __ push(Immediate(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
2454 __ jmp(&invoke);
2455 __ bind(&handler_entry);
2461 __ mov(Operand::StaticVariable(pending_exception), eax);
2462 __ mov(eax, Immediate(isolate()->factory()->exception()));
2463 __ jmp(&exit);
2467 __ bind(&invoke);
2468 __ PushTryHandler(StackHandler::JS_ENTRY, 0);
2471 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2472 __ mov(Operand::StaticVariable(pending_exception), edx);
2475 __ push(Immediate(0)); // receiver
2484 __ mov(edx, Immediate(construct_entry));
2487 __ mov(edx, Immediate(entry));
2489 __ mov(edx, Operand(edx, 0)); // deref address
2490 __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
2491 __ call(edx);
2494 __ PopTryHandler();
2496 __ bind(&exit);
2498 __ pop(ebx);
2499 __ cmp(ebx, Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
2500 __ j(not_equal, ¬_outermost_js_2);
2501 __ mov(Operand::StaticVariable(js_entry_sp), Immediate(0));
2502 __ bind(¬_outermost_js_2);
2505 __ pop(Operand::StaticVariable(ExternalReference(
2509 __ pop(ebx);
2510 __ pop(esi);
2511 __ pop(edi);
2512 __ add(esp, Immediate(2 * kPointerSize)); // remove markers
2515 __ pop(ebp);
2516 __ ret(0);
2561 __ mov(object, Operand(esp, 2 * kPointerSize));
2562 __ mov(function, Operand(esp, 1 * kPointerSize));
2566 __ JumpIfSmi(object, ¬_js_object);
2567 __ IsObjectJSObjectType(object, map, scratch, ¬_js_object);
2574 __ CompareRoot(function, scratch, Heap::kInstanceofCacheFunctionRootIndex);
2575 __ j(not_equal, &miss, Label::kNear);
2576 __ CompareRoot(map, scratch, Heap::kInstanceofCacheMapRootIndex);
2577 __ j(not_equal, &miss, Label::kNear);
2578 __ LoadRoot(eax, Heap::kInstanceofCacheAnswerRootIndex);
2579 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2580 __ bind(&miss);
2584 __ TryGetFunctionPrototype(function, prototype, scratch, &slow, true);
2587 __ JumpIfSmi(prototype, &slow);
2588 __ IsObjectJSObjectType(prototype, scratch, scratch, &slow);
2593 __ StoreRoot(map, scratch, Heap::kInstanceofCacheMapRootIndex);
2594 __ StoreRoot(function, scratch, Heap::kInstanceofCacheFunctionRootIndex);
2600 __ mov(scratch, Operand(esp, 0 * kPointerSize));
2601 __ sub(scratch, Operand(esp, 1 * kPointerSize));
2603 __ cmpb(Operand(scratch, 0), kCmpEdiOperandByte1);
2604 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheCmp1);
2605 __ cmpb(Operand(scratch, 1), kCmpEdiOperandByte2);
2606 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheCmp2);
2608 __ mov(scratch, Operand(scratch, kDeltaToCmpImmediate));
2609 __ mov(Operand(scratch, 0), map);
2614 __ mov(scratch, FieldOperand(map, Map::kPrototypeOffset));
2616 __ bind(&loop);
2617 __ cmp(scratch, prototype);
2618 __ j(equal, &is_instance, Label::kNear);
2620 __ cmp(scratch, Immediate(factory->null_value()));
2621 __ j(equal, &is_not_instance, Label::kNear);
2622 __ mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
2623 __ mov(scratch, FieldOperand(scratch, Map::kPrototypeOffset));
2624 __ jmp(&loop);
2626 __ bind(&is_instance);
2628 __ mov(eax, Immediate(0));
2629 __ StoreRoot(eax, scratch, Heap::kInstanceofCacheAnswerRootIndex);
2631 __ mov(eax, factory->true_value());
2635 __ mov(eax, factory->true_value());
2636 __ mov(scratch, Operand(esp, 0 * kPointerSize));
2637 __ sub(scratch, Operand(esp, 1 * kPointerSize));
2639 __ cmpb(Operand(scratch, kDeltaToMov), kMovEaxImmediateByte);
2640 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheMov);
2642 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
2644 __ Move(eax, Immediate(0));
2647 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2649 __ bind(&is_not_instance);
2651 __ mov(eax, Immediate(Smi::FromInt(1)));
2652 __ StoreRoot(eax, scratch, Heap::kInstanceofCacheAnswerRootIndex);
2654 __ mov(eax, factory->false_value());
2658 __ mov(eax, factory->false_value());
2659 __ mov(scratch, Operand(esp, 0 * kPointerSize));
2660 __ sub(scratch, Operand(esp, 1 * kPointerSize));
2662 __ cmpb(Operand(scratch, kDeltaToMov), kMovEaxImmediateByte);
2663 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheMov);
2665 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
2667 __ Move(eax, Immediate(Smi::FromInt(1)));
2670 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2673 __ bind(¬_js_object);
2676 __ JumpIfSmi(function, &slow, Label::kNear);
2677 __ CmpObjectType(function, JS_FUNCTION_TYPE, scratch);
2678 __ j(not_equal, &slow, Label::kNear);
2681 __ cmp(object, factory->null_value());
2682 __ j(not_equal, &object_not_null, Label::kNear);
2684 __ mov(eax, factory->false_value());
2686 __ Move(eax, Immediate(Smi::FromInt(1)));
2688 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2690 __ bind(&object_not_null);
2692 __ JumpIfNotSmi(object, &object_not_null_or_smi, Label::kNear);
2694 __ mov(eax, factory->false_value());
2696 __ Move(eax, Immediate(Smi::FromInt(1)));
2698 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2700 __ bind(&object_not_null_or_smi);
2703 __ j(NegateCondition(is_string), &slow, Label::kNear);
2705 __ mov(eax, factory->false_value());
2707 __ Move(eax, Immediate(Smi::FromInt(1)));
2709 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2712 __ bind(&slow);
2717 __ pop(scratch);
2718 __ push(object);
2719 __ push(function);
2720 __ push(scratch);
2722 __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
2727 __ push(object);
2728 __ push(function);
2729 __ InvokeBuiltin(Builtins::INSTANCE_OF, CALL_FUNCTION);
2732 __ test(eax, eax);
2733 __ j(zero, &true_value, Label::kNear);
2734 __ mov(eax, factory->false_value());
2735 __ jmp(&done, Label::kNear);
2736 __ bind(&true_value);
2737 __ mov(eax, factory->true_value());
2738 __ bind(&done);
2739 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2750 __ JumpIfSmi(object_, receiver_not_string_);
2753 __ mov(result_, FieldOperand(object_, HeapObject::kMapOffset));
2754 __ movzx_b(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
2756 __ test(result_, Immediate(kIsNotStringMask));
2757 __ j(not_zero, receiver_not_string_);
2761 __ JumpIfNotSmi(index_, &index_not_smi_);
2762 __ bind(&got_smi_index_);
2765 __ cmp(index_, FieldOperand(object_, String::kLengthOffset));
2766 __ j(above_equal, index_out_of_range_);
2768 __ SmiUntag(index_);
2774 __ SmiTag(result_);
2775 __ bind(&exit_);
2782 __ Abort(kUnexpectedFallthroughToCharCodeAtSlowCase);
2785 __ bind(&index_not_smi_);
2787 __ CheckMap(index_,
2792 __ push(object_);
2793 __ push(index_); // Consumed by runtime conversion function.
2795 __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
2799 __ CallRuntime(Runtime::kNumberToSmi, 1);
2804 __ mov(index_, eax);
2806 __ pop(object_);
2808 __ mov(result_, FieldOperand(object_, HeapObject::kMapOffset));
2809 __ movzx_b(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
2813 __ JumpIfNotSmi(index_, index_out_of_range_);
2815 __ jmp(&got_smi_index_);
2820 __ bind(&call_runtime_);
2822 __ push(object_);
2823 __ SmiTag(index_);
2824 __ push(index_);
2825 __ CallRuntime(Runtime::kStringCharCodeAtRT, 2);
2827 __ mov(result_, eax);
2830 __ jmp(&exit_);
2832 __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
2844 __ test(code_,
2847 __ j(not_zero, &slow_case_);
2850 __ Move(result_, Immediate(factory->single_character_string_cache()));
2855 __ mov(result_, FieldOperand(result_,
2858 __ cmp(result_, factory->undefined_value());
2859 __ j(equal, &slow_case_);
2860 __ bind(&exit_);
2867 __ Abort(kUnexpectedFallthroughToCharFromCodeSlowCase);
2869 __ bind(&slow_case_);
2871 __ push(code_);
2872 __ CallRuntime(Runtime::kCharFromCode, 1);
2874 __ mov(result_, eax);
2877 __ jmp(&exit_);
2879 __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
2895 __ test(count, count);
2896 __ j(zero, &done);
2900 __ shl(count, 1);
2904 __ bind(&loop);
2905 __ mov_b(scratch, Operand(src, 0));
2906 __ mov_b(Operand(dest, 0), scratch);
2907 __ inc(src);
2908 __ inc(dest);
2909 __ dec(count);
2910 __ j(not_zero, &loop);
2912 __ bind(&done);
2926 __ mov(eax, Operand(esp, 3 * kPointerSize));
2928 __ JumpIfSmi(eax, &runtime);
2930 __ j(NegateCondition(is_string), &runtime);
2936 __ mov(ecx, Operand(esp, 1 * kPointerSize)); // To index.
2937 __ JumpIfNotSmi(ecx, &runtime);
2938 __ mov(edx, Operand(esp, 2 * kPointerSize)); // From index.
2939 __ JumpIfNotSmi(edx, &runtime);
2940 __ sub(ecx, edx);
2941 __ cmp(ecx, FieldOperand(eax, String::kLengthOffset));
2944 __ j(below, ¬_original_string, Label::kNear);
2946 __ j(above, &runtime);
2949 __ IncrementCounter(counters->sub_string_native(), 1);
2950 __ ret(3 * kPointerSize);
2951 __ bind(¬_original_string);
2954 __ cmp(ecx, Immediate(Smi::FromInt(1)));
2955 __ j(equal, &single_char);
2967 __ test(ebx, Immediate(kIsIndirectStringMask));
2968 __ j(zero, &seq_or_external_string, Label::kNear);
2971 __ test(ebx, Immediate(kSlicedNotConsMask));
2972 __ j(not_zero, &sliced_string, Label::kNear);
2975 __ cmp(FieldOperand(eax, ConsString::kSecondOffset),
2977 __ j(not_equal, &runtime);
2978 __ mov(edi, FieldOperand(eax, ConsString::kFirstOffset));
2980 __ mov(ebx, FieldOperand(edi, HeapObject::kMapOffset));
2981 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
2982 __ jmp(&underlying_unpacked, Label::kNear);
2984 __ bind(&sliced_string);
2986 __ add(edx, FieldOperand(eax, SlicedString::kOffsetOffset));
2987 __ mov(edi, FieldOperand(eax, SlicedString::kParentOffset));
2989 __ mov(ebx, FieldOperand(edi, HeapObject::kMapOffset));
2990 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
2991 __ jmp(&underlying_unpacked, Label::kNear);
2993 __ bind(&seq_or_external_string);
2995 __ mov(edi, eax);
2997 __ bind(&underlying_unpacked);
3005 __ cmp(ecx, Immediate(Smi::FromInt(SlicedString::kMinLength)));
3007 __ j(less, ©_routine);
3016 __ test(ebx, Immediate(kStringEncodingMask));
3017 __ j(zero, &two_byte_slice, Label::kNear);
3018 __ AllocateOneByteSlicedString(eax, ebx, no_reg, &runtime);
3019 __ jmp(&set_slice_header, Label::kNear);
3020 __ bind(&two_byte_slice);
3021 __ AllocateTwoByteSlicedString(eax, ebx, no_reg, &runtime);
3022 __ bind(&set_slice_header);
3023 __ mov(FieldOperand(eax, SlicedString::kLengthOffset), ecx);
3024 __ mov(FieldOperand(eax, SlicedString::kHashFieldOffset),
3026 __ mov(FieldOperand(eax, SlicedString::kParentOffset), edi);
3027 __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx);
3028 __ IncrementCounter(counters->sub_string_native(), 1);
3029 __ ret(3 * kPointerSize);
3031 __ bind(©_routine);
3043 __ test_b(ebx, kExternalStringTag);
3044 __ j(zero, &sequential_string);
3049 __ test_b(ebx, kShortExternalStringMask);
3050 __ j(not_zero, &runtime);
3051 __ mov(edi, FieldOperand(edi, ExternalString::kResourceDataOffset));
3054 __ sub(edi, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
3056 __ bind(&sequential_string);
3058 __ push(edx);
3059 __ push(edi);
3060 __ SmiUntag(ecx);
3062 __ test_b(ebx, kStringEncodingMask);
3063 __ j(zero, &two_byte_sequential);
3066 __ AllocateOneByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
3071 __ mov(edi, eax);
3072 __ add(edi, Immediate(SeqOneByteString::kHeaderSize - kHeapObjectTag));
3074 __ pop(edx);
3075 __ pop(ebx);
3076 __ SmiUntag(ebx);
3077 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqOneByteString::kHeaderSize));
3085 __ IncrementCounter(counters->sub_string_native(), 1);
3086 __ ret(3 * kPointerSize);
3088 __ bind(&two_byte_sequential);
3090 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
3095 __ mov(edi, eax);
3096 __ add(edi,
3099 __ pop(edx);
3100 __ pop(ebx);
3105 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqTwoByteString::kHeaderSize));
3113 __ IncrementCounter(counters->sub_string_native(), 1);
3114 __ ret(3 * kPointerSize);
3117 __ bind(&runtime_drop_two);
3118 __ Drop(2);
3121 __ bind(&runtime);
3122 __ TailCallRuntime(Runtime::kSubString, 3, 1);
3124 __ bind(&single_char);
3132 __ ret(3 * kPointerSize);
3146 __ mov(length, FieldOperand(left, String::kLengthOffset));
3147 __ cmp(length, FieldOperand(right, String::kLengthOffset));
3148 __ j(equal, &check_zero_length, Label::kNear);
3149 __ bind(&strings_not_equal);
3150 __ Move(eax, Immediate(Smi::FromInt(NOT_EQUAL)));
3151 __ ret(0);
3155 __ bind(&check_zero_length);
3157 __ test(length, length);
3158 __ j(not_zero, &compare_chars, Label::kNear);
3159 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3160 __ ret(0);
3163 __ bind(&compare_chars);
3168 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3169 __ ret(0);
3177 __ IncrementCounter(counters->string_compare_native(), 1);
3181 __ mov(scratch1, FieldOperand(left, String::kLengthOffset));
3182 __ mov(scratch3, scratch1);
3183 __ sub(scratch3, FieldOperand(right, String::kLengthOffset));
3187 __ j(less_equal, &left_shorter, Label::kNear);
3189 __ sub(scratch1, length_delta);
3190 __ bind(&left_shorter);
3196 __ test(min_length, min_length);
3197 __ j(zero, &compare_lengths, Label::kNear);
3205 __ bind(&compare_lengths);
3206 __ test(length_delta, length_delta);
3208 __ j(not_zero, &length_not_equal, Label::kNear);
3213 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3214 __ ret(0);
3218 __ bind(&length_not_equal);
3219 __ j(greater, &result_greater, Label::kNear);
3220 __ jmp(&result_less, Label::kNear);
3221 __ bind(&result_not_equal);
3222 __ j(above, &result_greater, Label::kNear);
3223 __ bind(&result_less);
3226 __ Move(eax, Immediate(Smi::FromInt(LESS)));
3227 __ ret(0);
3230 __ bind(&result_greater);
3231 __ Move(eax, Immediate(Smi::FromInt(GREATER)));
3232 __ ret(0);
3243 __ SmiUntag(length);
3244 __ lea(left,
3246 __ lea(right,
3248 __ neg(length);
3253 __ bind(&loop);
3254 __ mov_b(scratch, Operand(left, index, times_1, 0));
3255 __ cmpb(scratch, Operand(right, index, times_1, 0));
3256 __ j(not_equal, chars_not_equal, chars_not_equal_near);
3257 __ inc(index);
3258 __ j(not_zero, &loop);
3270 __ mov(edx, Operand(esp, 2 * kPointerSize)); // left
3271 __ mov(eax, Operand(esp, 1 * kPointerSize)); // right
3274 __ cmp(edx, eax);
3275 __ j(not_equal, ¬_same, Label::kNear);
3278 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3279 __ IncrementCounter(isolate()->counters()->string_compare_native(), 1);
3280 __ ret(2 * kPointerSize);
3282 __ bind(¬_same);
3285 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx, &runtime);
3289 __ pop(ecx);
3290 __ add(esp, Immediate(2 * kPointerSize));
3291 __ push(ecx);
3297 __ bind(&runtime);
3298 __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
3312 __ mov(ecx, handle(isolate()->heap()->undefined_value()));
3316 __ test(ecx, Immediate(kSmiTagMask));
3317 __ Assert(not_equal, kExpectedAllocationSite);
3318 __ cmp(FieldOperand(ecx, HeapObject::kMapOffset),
3320 __ Assert(equal, kExpectedAllocationSite);
3326 __ TailCallStub(&stub);
3333 __ mov(ecx, edx);
3334 __ or_(ecx, eax);
3335 __ JumpIfNotSmi(ecx, &miss, Label::kNear);
3339 __ sub(eax, edx);
3342 __ sub(edx, eax);
3343 __ j(no_overflow, &done, Label::kNear);
3345 __ not_(edx);
3346 __ bind(&done);
3347 __ mov(eax, edx);
3349 __ ret(0);
3351 __ bind(&miss);
3364 __ JumpIfNotSmi(edx, &miss);
3367 __ JumpIfNotSmi(eax, &miss);
3372 __ JumpIfSmi(eax, &right_smi, Label::kNear);
3373 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
3375 __ j(not_equal, &maybe_undefined1, Label::kNear);
3376 __ movsd(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
3377 __ jmp(&left, Label::kNear);
3378 __ bind(&right_smi);
3379 __ mov(ecx, eax); // Can't clobber eax because we can still jump away.
3380 __ SmiUntag(ecx);
3381 __ Cvtsi2sd(xmm1, ecx);
3383 __ bind(&left);
3384 __ JumpIfSmi(edx, &left_smi, Label::kNear);
3385 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
3387 __ j(not_equal, &maybe_undefined2, Label::kNear);
3388 __ movsd(xmm0, FieldOperand(edx, HeapNumber::kValueOffset));
3389 __ jmp(&done);
3390 __ bind(&left_smi);
3391 __ mov(ecx, edx); // Can't clobber edx because we can still jump away.
3392 __ SmiUntag(ecx);
3393 __ Cvtsi2sd(xmm0, ecx);
3395 __ bind(&done);
3397 __ ucomisd(xmm0, xmm1);
3400 __ j(parity_even, &unordered, Label::kNear);
3404 __ mov(eax, 0); // equal
3405 __ mov(ecx, Immediate(Smi::FromInt(1)));
3406 __ cmov(above, eax, ecx);
3407 __ mov(ecx, Immediate(Smi::FromInt(-1)));
3408 __ cmov(below, eax, ecx);
3409 __ ret(0);
3411 __ bind(&unordered);
3412 __ bind(&generic_stub);
3415 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
3417 __ bind(&maybe_undefined1);
3419 __ cmp(eax, Immediate(isolate()->factory()->undefined_value()));
3420 __ j(not_equal, &miss);
3421 __ JumpIfSmi(edx, &unordered);
3422 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
3423 __ j(not_equal, &maybe_undefined2, Label::kNear);
3424 __ jmp(&unordered);
3427 __ bind(&maybe_undefined2);
3429 __ cmp(edx, Immediate(isolate()->factory()->undefined_value()));
3430 __ j(equal, &unordered);
3433 __ bind(&miss);
3450 __ mov(tmp1, left);
3452 __ and_(tmp1, right);
3453 __ JumpIfSmi(tmp1, &miss, Label::kNear);
3456 __ mov(tmp1, FieldOperand(left, HeapObject::kMapOffset));
3457 __ mov(tmp2, FieldOperand(right, HeapObject::kMapOffset));
3458 __ movzx_b(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
3459 __ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
3461 __ or_(tmp1, tmp2);
3462 __ test(tmp1, Immediate(kIsNotStringMask | kIsNotInternalizedMask));
3463 __ j(not_zero, &miss, Label::kNear);
3467 __ cmp(left, right);
3471 __ j(not_equal, &done, Label::kNear);
3474 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3475 __ bind(&done);
3476 __ ret(0);
3478 __ bind(&miss);
3495 __ mov(tmp1, left);
3497 __ and_(tmp1, right);
3498 __ JumpIfSmi(tmp1, &miss, Label::kNear);
3502 __ mov(tmp1, FieldOperand(left, HeapObject::kMapOffset));
3503 __ mov(tmp2, FieldOperand(right, HeapObject::kMapOffset));
3504 __ movzx_b(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
3505 __ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
3507 __ JumpIfNotUniqueNameInstanceType(tmp1, &miss, Label::kNear);
3508 __ JumpIfNotUniqueNameInstanceType(tmp2, &miss, Label::kNear);
3512 __ cmp(left, right);
3516 __ j(not_equal, &done, Label::kNear);
3519 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3520 __ bind(&done);
3521 __ ret(0);
3523 __ bind(&miss);
3542 __ mov(tmp1, left);
3544 __ and_(tmp1, right);
3545 __ JumpIfSmi(tmp1, &miss);
3549 __ mov(tmp1, FieldOperand(left, HeapObject::kMapOffset));
3550 __ mov(tmp2, FieldOperand(right, HeapObject::kMapOffset));
3551 __ movzx_b(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
3552 __ movzx_b(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
3553 __ mov(tmp3, tmp1);
3555 __ or_(tmp3, tmp2);
3556 __ test(tmp3, Immediate(kIsNotStringMask));
3557 __ j(not_zero, &miss);
3561 __ cmp(left, right);
3562 __ j(not_equal, ¬_same, Label::kNear);
3565 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3566 __ ret(0);
3569 __ bind(¬_same);
3578 __ or_(tmp1, tmp2);
3579 __ test(tmp1, Immediate(kIsNotInternalizedMask));
3580 __ j(not_zero, &do_compare, Label::kNear);
3584 __ ret(0);
3585 __ bind(&do_compare);
3590 __ JumpIfNotBothSequentialOneByteStrings(left, right, tmp1, tmp2, &runtime);
3602 __ bind(&runtime);
3603 __ pop(tmp1); // Return address.
3604 __ push(left);
3605 __ push(right);
3606 __ push(tmp1);
3608 __ TailCallRuntime(Runtime::kStringEquals, 2, 1);
3610 __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
3613 __ bind(&miss);
3621 __ mov(ecx, edx);
3622 __ and_(ecx, eax);
3623 __ JumpIfSmi(ecx, &miss, Label::kNear);
3625 __ CmpObjectType(eax, JS_OBJECT_TYPE, ecx);
3626 __ j(not_equal, &miss, Label::kNear);
3627 __ CmpObjectType(edx, JS_OBJECT_TYPE, ecx);
3628 __ j(not_equal, &miss, Label::kNear);
3631 __ sub(eax, edx);
3632 __ ret(0);
3634 __ bind(&miss);
3641 __ mov(ecx, edx);
3642 __ and_(ecx, eax);
3643 __ JumpIfSmi(ecx, &miss, Label::kNear);
3645 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
3646 __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
3647 __ cmp(ecx, known_map_);
3648 __ j(not_equal, &miss, Label::kNear);
3649 __ cmp(ebx, known_map_);
3650 __ j(not_equal, &miss, Label::kNear);
3652 __ sub(eax, edx);
3653 __ ret(0);
3655 __ bind(&miss);
3666 __ push(edx); // Preserve edx and eax.
3667 __ push(eax);
3668 __ push(edx); // And also use them as the arguments.
3669 __ push(eax);
3670 __ push(Immediate(Smi::FromInt(op())));
3671 __ CallExternalReference(miss, 3);
3673 __ lea(edi, FieldOperand(eax, Code::kHeaderSize));
3674 __ pop(eax);
3675 __ pop(edx);
3679 __ jmp(edi);
3705 __ mov(index, FieldOperand(properties, kCapacityOffset));
3706 __ dec(index);
3707 __ and_(index,
3713 __ lea(index, Operand(index, index, times_2, 0)); // index *= 3.
3717 __ mov(entity_name, Operand(properties, index, times_half_pointer_size,
3719 __ cmp(entity_name, masm->isolate()->factory()->undefined_value());
3720 __ j(equal, done);
3723 __ cmp(entity_name, Handle<Name>(name));
3724 __ j(equal, miss);
3728 __ cmp(entity_name, masm->isolate()->factory()->the_hole_value());
3729 __ j(equal, &good, Label::kNear);
3732 __ mov(entity_name, FieldOperand(entity_name, HeapObject::kMapOffset));
3733 __ JumpIfNotUniqueNameInstanceType(
3735 __ bind(&good);
3740 __ push(Immediate(Handle<Object>(name)));
3741 __ push(Immediate(name->Hash()));
3742 __ CallStub(&stub);
3743 __ test(r0, r0);
3744 __ j(not_zero, miss);
3745 __ jmp(done);
3765 __ AssertName(name);
3767 __ mov(r1, FieldOperand(elements, kCapacityOffset));
3768 __ shr(r1, kSmiTagSize); // convert smi to int
3769 __ dec(r1);
3776 __ mov(r0, FieldOperand(name, Name::kHashFieldOffset));
3777 __ shr(r0, Name::kHashShift);
3779 __ add(r0, Immediate(NameDictionary::GetProbeOffset(i)));
3781 __ and_(r0, r1);
3785 __ lea(r0, Operand(r0, r0, times_2, 0)); // r0 = r0 * 3
3788 __ cmp(name, Operand(elements,
3792 __ j(equal, done);
3797 __ push(name);
3798 __ mov(r0, FieldOperand(name, Name::kHashFieldOffset));
3799 __ shr(r0, Name::kHashShift);
3800 __ push(r0);
3801 __ CallStub(&stub);
3803 __ test(r1, r1);
3804 __ j(zero, miss);
3805 __ jmp(done);
3828 __ mov(scratch, FieldOperand(dictionary(), kCapacityOffset));
3829 __ dec(scratch);
3830 __ SmiUntag(scratch);
3831 __ push(scratch);
3840 __ mov(scratch, Operand(esp, 2 * kPointerSize));
3842 __ add(scratch, Immediate(NameDictionary::GetProbeOffset(i)));
3844 __ and_(scratch, Operand(esp, 0));
3848 __ lea(index(), Operand(scratch, scratch, times_2, 0)); // index *= 3.
3852 __ mov(scratch, Operand(dictionary(), index(), times_pointer_size,
3854 __ cmp(scratch, isolate()->factory()->undefined_value());
3855 __ j(equal, ¬_in_dictionary);
3858 __ cmp(scratch, Operand(esp, 3 * kPointerSize));
3859 __ j(equal, &in_dictionary);
3867 __ mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
3868 __ JumpIfNotUniqueNameInstanceType(
3874 __ bind(&maybe_in_dictionary);
3879 __ mov(result(), Immediate(0));
3880 __ Drop(1);
3881 __ ret(2 * kPointerSize);
3884 __ bind(&in_dictionary);
3885 __ mov(result(), Immediate(1));
3886 __ Drop(1);
3887 __ ret(2 * kPointerSize);
3889 __ bind(¬_in_dictionary);
3890 __ mov(result(), Immediate(0));
3891 __ Drop(1);
3892 __ ret(2 * kPointerSize);
3917 __ jmp(&skip_to_incremental_noncompacting, Label::kNear);
3918 __ jmp(&skip_to_incremental_compacting, Label::kFar);
3921 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
3924 __ ret(0);
3927 __ bind(&skip_to_incremental_noncompacting);
3930 __ bind(&skip_to_incremental_compacting);
3946 __ mov(regs_.scratch0(), Operand(regs_.address(), 0));
3947 __ JumpIfNotInNewSpace(regs_.scratch0(), // Value.
3951 __ CheckPageFlag(regs_.object(),
3965 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
3968 __ bind(&dont_need_remembered_set);
3977 __ ret(0);
3984 __ PrepareCallCFunction(argument_count, regs_.scratch0());
3985 __ mov(Operand(esp, 0 * kPointerSize), regs_.object());
3986 __ mov(Operand(esp, 1 * kPointerSize), regs_.address()); // Slot.
3987 __ mov(Operand(esp, 2 * kPointerSize),
3991 __ CallCFunction(
4005 __ mov(regs_.scratch0(), Immediate(~Page::kPageAlignmentMask));
4006 __ and_(regs_.scratch0(), regs_.object());
4007 __ mov(regs_.scratch1(),
4010 __ sub(regs_.scratch1(), Immediate(1));
4011 __ mov(Operand(regs_.scratch0(),
4014 __ j(negative, &need_incremental);
4018 __ JumpIfBlack(regs_.object(),
4026 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
4029 __ ret(0);
4032 __ bind(&object_is_black);
4035 __ mov(regs_.scratch0(), Operand(regs_.address(), 0));
4040 __ CheckPageFlag(regs_.scratch0(), // Contains value.
4047 __ CheckPageFlag(regs_.object(),
4054 __ jmp(&need_incremental);
4056 __ bind(&ensure_not_white);
4061 __ push(regs_.object());
4062 __ EnsureNotWhite(regs_.scratch0(), // The value.
4067 __ pop(regs_.object());
4071 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
4074 __ ret(0);
4077 __ bind(&need_incremental_pop_object);
4078 __ pop(regs_.object());
4080 __ bind(&need_incremental);
4104 __ mov(edx, Operand(esp, 1 * kPointerSize));
4105 __ mov(ebx, Operand(esp, 2 * kPointerSize));
4106 __ mov(edi, FieldOperand(ebx, JSObject::kMapOffset));
4108 __ CheckFastElements(edi, &double_elements);
4111 __ JumpIfSmi(eax, &smi_element);
4112 __ CheckFastSmiElements(edi, &fast_elements, Label::kNear);
4117 __ bind(&slow_elements);
4118 __ pop(edi); // Pop return address and remember to put back later for tail
4120 __ push(ebx);
4121 __ push(ecx);
4122 __ push(eax);
4123 __ mov(ebx, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
4124 __ push(FieldOperand(ebx, JSFunction::kLiteralsOffset));
4125 __ push(edx);
4126 __ push(edi); // Return return address so that tail call returns to right
4128 __ TailCallRuntime(Runtime::kStoreArrayLiteralElement, 5, 1);
4130 __ bind(&slow_elements_from_double);
4131 __ pop(edx);
4132 __ jmp(&slow_elements);
4135 __ bind(&fast_elements);
4136 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
4137 __ lea(ecx, FieldOperand(ebx, ecx, times_half_pointer_size,
4139 __ mov(Operand(ecx, 0), eax);
4141 __ RecordWrite(ebx, ecx, eax,
4145 __ ret(0);
4149 __ bind(&smi_element);
4150 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
4151 __ mov(FieldOperand(ebx, ecx, times_half_pointer_size,
4153 __ ret(0);
4156 __ bind(&double_elements);
4158 __ push(edx);
4159 __ mov(edx, FieldOperand(ebx, JSObject::kElementsOffset));
4160 __ StoreNumberToDoubleElements(eax,
4166 __ pop(edx);
4167 __ ret(0);
4173 __ call(ces.GetCode(), RelocInfo::CODE_TARGET);
4176 __ mov(ebx, MemOperand(ebp, parameter_count_offset));
4178 __ pop(ecx);
4181 __ lea(esp, MemOperand(esp, ebx, times_pointer_size, additional_offset));
4182 __ jmp(ecx); // Return to IC Miss stub, continuation still on stack.
4189 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
4196 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
4211 __ push(eax);
4212 __ push(ecx);
4213 __ push(edx);
4216 __ lea(eax, Operand(esp, (kNumSavedRegisters + 1) * kPointerSize));
4217 __ push(eax);
4221 __ mov(eax, Operand(esp, (kNumSavedRegisters + 1) * kPointerSize));
4222 __ sub(eax, Immediate(Assembler::kCallInstructionLength));
4223 __ push(eax);
4227 __ call(FUNCTION_ADDR(isolate()->function_entry_hook()),
4229 __ add(esp, Immediate(2 * kPointerSize));
4232 __ pop(edx);
4233 __ pop(ecx);
4234 __ pop(eax);
4236 __ ret(0);
4247 __ TailCallStub(&stub);
4254 __ cmp(edx, kind);
4255 __ j(not_equal, &next);
4257 __ TailCallStub(&stub);
4258 __ bind(&next);
4262 __ Abort(kUnexpectedElementsKindInArrayConstructor);
4287 __ test_b(edx, 1);
4288 __ j(not_zero, &normal_sequence);
4292 __ mov(ecx, Operand(esp, kPointerSize));
4293 __ test(ecx, ecx);
4294 __ j(zero, &normal_sequence);
4303 __ TailCallStub(&stub_holey);
4305 __ bind(&normal_sequence);
4309 __ TailCallStub(&stub);
4313 __ inc(edx);
4318 __ cmp(FieldOperand(ebx, 0), Immediate(allocation_site_map));
4319 __ Assert(equal, kExpectedAllocationSite);
4326 __ add(FieldOperand(ebx, AllocationSite::kTransitionInfoOffset),
4329 __ bind(&normal_sequence);
4335 __ cmp(edx, kind);
4336 __ j(not_equal, &next);
4338 __ TailCallStub(&stub);
4339 __ bind(&next);
4343 __ Abort(kUnexpectedElementsKindInArrayConstructor);
4396 __ test(eax, eax);
4397 __ j(not_zero, ¬_zero_case);
4400 __ bind(¬_zero_case);
4401 __ cmp(eax, 1);
4402 __ j(greater, ¬_one_case);
4405 __ bind(¬_one_case);
4432 __ mov(ecx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
4434 __ test(ecx, Immediate(kSmiTagMask));
4435 __ Assert(not_zero, kUnexpectedInitialMapForArrayFunction);
4436 __ CmpObjectType(ecx, MAP_TYPE, ecx);
4437 __ Assert(equal, kUnexpectedInitialMapForArrayFunction);
4440 __ AssertUndefinedOrAllocationSite(ebx);
4446 __ cmp(ebx, isolate()->factory()->undefined_value());
4447 __ j(equal, &no_info);
4450 __ mov(edx, FieldOperand(ebx, AllocationSite::kTransitionInfoOffset));
4451 __ SmiUntag(edx);
4453 __ and_(edx, Immediate(AllocationSite::ElementsKindBits::kMask));
4456 __ bind(&no_info);
4466 __ test(eax, eax);
4467 __ j(not_zero, ¬_zero_case);
4469 __ TailCallStub(&stub0);
4471 __ bind(¬_zero_case);
4472 __ cmp(eax, 1);
4473 __ j(greater, ¬_one_case);
4478 __ mov(ecx, Operand(esp, kPointerSize));
4479 __ test(ecx, ecx);
4480 __ j(zero, &normal_sequence);
4484 __ TailCallStub(&stub1_holey);
4487 __ bind(&normal_sequence);
4489 __ TailCallStub(&stub1);
4491 __ bind(¬_one_case);
4493 __ TailCallStub(&stubN);
4510 __ mov(ecx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
4512 __ test(ecx, Immediate(kSmiTagMask));
4513 __ Assert(not_zero, kUnexpectedInitialMapForArrayFunction);
4514 __ CmpObjectType(ecx, MAP_TYPE, ecx);
4515 __ Assert(equal, kUnexpectedInitialMapForArrayFunction);
4519 __ mov(ecx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
4523 __ mov(ecx, FieldOperand(ecx, Map::kBitField2Offset));
4525 __ DecodeField<Map::ElementsKindBits>(ecx);
4529 __ cmp(ecx, Immediate(FAST_ELEMENTS));
4530 __ j(equal, &done);
4531 __ cmp(ecx, Immediate(FAST_HOLEY_ELEMENTS));
4532 __ Assert(equal,
4534 __ bind(&done);
4538 __ cmp(ecx, Immediate(FAST_ELEMENTS));
4539 __ j(equal, &fast_elements_case);
4542 __ bind(&fast_elements_case);
4584 __ pop(return_address);
4587 __ push(context);
4589 __ mov(context, FieldOperand(callee, JSFunction::kContextOffset));
4592 __ push(callee);
4595 __ push(call_data);
4600 __ push(Immediate(isolate()->factory()->undefined_value()));
4602 __ push(Immediate(isolate()->factory()->undefined_value()));
4605 __ push(scratch);
4607 __ push(scratch);
4610 __ push(Immediate(reinterpret_cast<int>(isolate())));
4612 __ push(holder);
4614 __ mov(scratch, esp);
4617 __ push(return_address);
4629 __ PrepareCallApiFunction(kApiArgc + kApiStackSpace);
4632 __ mov(ApiParameterOperand(2), scratch);
4633 __ add(scratch, Immediate((argc + FCA::kArgsLength - 1) * kPointerSize));
4635 __ mov(ApiParameterOperand(3), scratch);
4637 __ Move(ApiParameterOperand(4), Immediate(argc));
4639 __ Move(ApiParameterOperand(5), Immediate(0));
4642 __ lea(scratch, ApiParameterOperand(2));
4643 __ mov(ApiParameterOperand(0), scratch);
4658 __ CallApiFunctionAndReturn(api_function_address,
4688 __ lea(scratch, Operand(esp, 1 * kPointerSize));
4690 __ PrepareCallApiFunction(kApiArgc);
4691 __ mov(ApiParameterOperand(0), scratch); // name.
4692 __ add(scratch, Immediate(kPointerSize));
4693 __ mov(ApiParameterOperand(1), scratch); // arguments pointer.
4698 __ CallApiFunctionAndReturn(api_function_address,
4707 #undef __