Lines Matching refs:__
91 #define __ ACCESS_MASM(masm)
108 __ Push(descriptor.GetEnvironmentParameterRegister(i));
110 __ CallExternalReference(miss, param_count);
113 __ Ret();
118 __ PushCallerSaved(save_doubles() ? kSaveFPRegs : kDontSaveFPRegs);
120 __ PrepareCallCFunction(argument_count);
121 __ LoadAddress(arg_reg_1,
125 __ CallCFunction(
128 __ PopCallerSaved(save_doubles() ? kSaveFPRegs : kDontSaveFPRegs);
129 __ ret(0);
178 __ pushq(scratch1);
179 __ pushq(save_reg);
182 __ movl(scratch1, mantissa_operand);
183 __ movsd(xmm0, mantissa_operand);
184 __ movl(rcx, exponent_operand);
185 if (stash_exponent_copy) __ pushq(rcx);
187 __ andl(rcx, Immediate(HeapNumber::kExponentMask));
188 __ shrl(rcx, Immediate(HeapNumber::kExponentShift));
189 __ leal(result_reg, MemOperand(rcx, -HeapNumber::kExponentBias));
190 __ cmpl(result_reg, Immediate(HeapNumber::kMantissaBits));
191 __ j(below, &process_64_bits);
195 __ subl(rcx, Immediate(delta));
196 __ xorl(result_reg, result_reg);
197 __ cmpl(rcx, Immediate(31));
198 __ j(above, &done);
199 __ shll_cl(scratch1);
200 __ jmp(&check_negative);
202 __ bind(&process_64_bits);
203 __ cvttsd2siq(result_reg, xmm0);
204 __ jmp(&done, Label::kNear);
207 __ bind(&check_negative);
208 __ movl(result_reg, scratch1);
209 __ negl(result_reg);
211 __ cmpl(MemOperand(rsp, 0), Immediate(0));
213 __ cmpl(exponent_operand, Immediate(0));
215 __ cmovl(greater, result_reg, scratch1);
218 __ bind(&done);
220 __ addp(rsp, Immediate(kDoubleSize));
224 __ movl(final_result_reg, result_reg);
226 __ popq(save_reg);
227 __ popq(scratch1);
228 __ ret(0);
236 __ LoadRoot(rcx, Heap::kHeapNumberMapRootIndex);
237 __ JumpIfSmi(rdx, &load_smi_rdx);
238 __ cmpp(FieldOperand(rdx, HeapObject::kMapOffset), rcx);
239 __ j(not_equal, not_numbers); // Argument in rdx is not a number.
240 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
242 __ JumpIfSmi(rax, &load_smi_rax);
244 __ bind(&load_nonsmi_rax);
245 __ cmpp(FieldOperand(rax, HeapObject::kMapOffset), rcx);
246 __ j(not_equal, not_numbers);
247 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
248 __ jmp(&done);
250 __ bind(&load_smi_rdx);
251 __ SmiToInteger32(kScratchRegister, rdx);
252 __ Cvtlsi2sd(xmm0, kScratchRegister);
253 __ JumpIfNotSmi(rax, &load_nonsmi_rax);
255 __ bind(&load_smi_rax);
256 __ SmiToInteger32(kScratchRegister, rax);
257 __ Cvtlsi2sd(xmm1, kScratchRegister);
258 __ bind(&done);
275 __ movp(scratch, Immediate(1));
276 __ Cvtlsi2sd(double_result, scratch);
284 __ movp(base, args.GetArgumentOperand(0));
285 __ movp(exponent, args.GetArgumentOperand(1));
286 __ JumpIfSmi(base, &base_is_smi, Label::kNear);
287 __ CompareRoot(FieldOperand(base, HeapObject::kMapOffset),
289 __ j(not_equal, &call_runtime);
291 __ movsd(double_base, FieldOperand(base, HeapNumber::kValueOffset));
292 __ jmp(&unpack_exponent, Label::kNear);
294 __ bind(&base_is_smi);
295 __ SmiToInteger32(base, base);
296 __ Cvtlsi2sd(double_base, base);
297 __ bind(&unpack_exponent);
299 __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
300 __ SmiToInteger32(exponent, exponent);
301 __ jmp(&int_exponent);
303 __ bind(&exponent_not_smi);
304 __ CompareRoot(FieldOperand(exponent, HeapObject::kMapOffset),
306 __ j(not_equal, &call_runtime);
307 __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
309 __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
310 __ SmiToInteger32(exponent, exponent);
311 __ jmp(&int_exponent);
313 __ bind(&exponent_not_smi);
314 __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
320 __ DoubleToI(exponent, double_exponent, double_scratch,
324 __ jmp(&int_exponent);
326 __ bind(&try_arithmetic_simplification);
327 __ cvttsd2si(exponent, double_exponent);
329 __ cmpl(exponent, Immediate(0x1));
330 __ j(overflow, &call_runtime);
339 __ movq(scratch, V8_UINT64_C(0x3FE0000000000000));
340 __ movq(double_scratch, scratch);
342 __ ucomisd(double_scratch, double_exponent);
343 __ j(not_equal, ¬_plus_half, Label::kNear);
349 __ movq(scratch, V8_UINT64_C(0xFFF0000000000000));
350 __ movq(double_scratch, scratch);
351 __ ucomisd(double_scratch, double_base);
354 __ j(not_equal, &continue_sqrt, Label::kNear);
355 __ j(carry, &continue_sqrt, Label::kNear);
358 __ xorps(double_result, double_result);
359 __ subsd(double_result, double_scratch);
360 __ jmp(&done);
362 __ bind(&continue_sqrt);
364 __ xorps(double_scratch, double_scratch);
365 __ addsd(double_scratch, double_base); // Convert -0 to 0.
366 __ sqrtsd(double_result, double_scratch);
367 __ jmp(&done);
370 __ bind(¬_plus_half);
372 __ subsd(double_scratch, double_result);
374 __ ucomisd(double_scratch, double_exponent);
375 __ j(not_equal, &fast_power, Label::kNear);
381 __ movq(scratch, V8_UINT64_C(0xFFF0000000000000));
382 __ movq(double_scratch, scratch);
383 __ ucomisd(double_scratch, double_base);
386 __ j(not_equal, &continue_rsqrt, Label::kNear);
387 __ j(carry, &continue_rsqrt, Label::kNear);
390 __ xorps(double_result, double_result);
391 __ jmp(&done);
393 __ bind(&continue_rsqrt);
395 __ xorps(double_exponent, double_exponent);
396 __ addsd(double_exponent, double_base); // Convert -0 to +0.
397 __ sqrtsd(double_exponent, double_exponent);
398 __ divsd(double_result, double_exponent);
399 __ jmp(&done);
404 __ bind(&fast_power);
405 __ fnclex(); // Clear flags to catch exceptions later.
407 __ subp(rsp, Immediate(kDoubleSize));
408 __ movsd(Operand(rsp, 0), double_exponent);
409 __ fld_d(Operand(rsp, 0)); // E
410 __ movsd(Operand(rsp, 0), double_base);
411 __ fld_d(Operand(rsp, 0)); // B, E
416 __ fyl2x(); // X
417 __ fld(0); // X, X
418 __ frndint(); // rnd(X), X
419 __ fsub(1); // rnd(X), X-rnd(X)
420 __ fxch(1); // X - rnd(X), rnd(X)
422 __ f2xm1(); // 2^(X-rnd(X)) - 1, rnd(X)
423 __ fld1(); // 1, 2^(X-rnd(X)) - 1, rnd(X)
424 __ faddp(1); // 2^(X-rnd(X)), rnd(X)
426 __ fscale(); // 2^X, rnd(X)
427 __ fstp(1);
429 __ fnstsw_ax();
430 __ testb(rax, Immediate(0x5F)); // Check for all but precision exception.
431 __ j(not_zero, &fast_power_failed, Label::kNear);
432 __ fstp_d(Operand(rsp, 0));
433 __ movsd(double_result, Operand(rsp, 0));
434 __ addp(rsp, Immediate(kDoubleSize));
435 __ jmp(&done);
437 __ bind(&fast_power_failed);
438 __ fninit();
439 __ addp(rsp, Immediate(kDoubleSize));
440 __ jmp(&call_runtime);
444 __ bind(&int_exponent);
447 __ movp(scratch, exponent); // Back up exponent.
448 __ movsd(double_scratch, double_base); // Back up base.
449 __ movsd(double_scratch2, double_result); // Load double_exponent with 1.
453 __ testl(scratch, scratch);
454 __ j(positive, &no_neg, Label::kNear);
455 __ negl(scratch);
456 __ bind(&no_neg);
458 __ j(zero, &while_false, Label::kNear);
459 __ shrl(scratch, Immediate(1));
462 __ j(above, &while_true, Label::kNear);
463 __ movsd(double_result, double_scratch);
464 __ j(zero, &while_false, Label::kNear);
466 __ bind(&while_true);
467 __ shrl(scratch, Immediate(1));
468 __ mulsd(double_scratch, double_scratch);
469 __ j(above, &while_true, Label::kNear);
470 __ mulsd(double_result, double_scratch);
471 __ j(not_zero, &while_true);
473 __ bind(&while_false);
475 __ testl(exponent, exponent);
476 __ j(greater, &done);
477 __ divsd(double_scratch2, double_result);
478 __ movsd(double_result, double_scratch2);
481 __ xorps(double_scratch2, double_scratch2);
482 __ ucomisd(double_scratch2, double_result);
486 __ j(not_equal, &done);
487 __ Cvtlsi2sd(double_exponent, exponent);
493 __ bind(&call_runtime);
494 __ TailCallRuntime(Runtime::kMathPowRT, 2, 1);
498 __ bind(&done);
499 __ AllocateHeapNumber(rax, rcx, &call_runtime);
500 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), double_result);
501 __ IncrementCounter(counters->math_pow(), 1);
502 __ ret(2 * kPointerSize);
504 __ bind(&call_runtime);
506 __ movsd(xmm0, double_base);
510 __ PrepareCallCFunction(2);
511 __ CallCFunction(
515 __ movsd(double_result, xmm0);
517 __ bind(&done);
518 __ IncrementCounter(counters->math_pow(), 1);
519 __ ret(0);
530 __ bind(&miss);
543 __ JumpIfNotSmi(rdx, &slow);
550 __ movp(rbx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
551 __ Cmp(Operand(rbx, StandardFrameConstants::kContextOffset),
553 __ j(equal, &adaptor);
558 __ cmpp(rdx, rax);
559 __ j(above_equal, &slow);
562 __ SmiSub(rax, rax, rdx);
563 __ SmiToInteger32(rax, rax);
565 __ movp(rax, args.GetArgumentOperand(0));
566 __ Ret();
571 __ bind(&adaptor);
572 __ movp(rcx, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
573 __ cmpp(rdx, rcx);
574 __ j(above_equal, &slow);
577 __ SmiSub(rcx, rcx, rdx);
578 __ SmiToInteger32(rcx, rcx);
581 __ movp(rax, adaptor_args.GetArgumentOperand(0));
582 __ Ret();
586 __ bind(&slow);
587 __ PopReturnAddressTo(rbx);
588 __ Push(rdx);
589 __ PushReturnAddressFrom(rbx);
590 __ TailCallRuntime(Runtime::kGetArgumentsProperty, 1, 1);
607 __ SmiToInteger64(rbx, args.GetArgumentOperand(2));
613 __ movp(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
614 __ movp(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
615 __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
616 __ j(equal, &adaptor_frame);
619 __ movp(rcx, rbx);
620 __ jmp(&try_allocate, Label::kNear);
623 __ bind(&adaptor_frame);
624 __ SmiToInteger64(rcx,
627 __ leap(rdx, Operand(rdx, rcx, times_pointer_size,
629 __ movp(args.GetArgumentOperand(1), rdx);
634 __ cmpp(rbx, rcx);
635 __ j(less_equal, &try_allocate, Label::kNear);
636 __ movp(rbx, rcx);
638 __ bind(&try_allocate);
645 __ xorp(r8, r8);
646 __ testp(rbx, rbx);
647 __ j(zero, &no_parameter_map, Label::kNear);
648 __ leap(r8, Operand(rbx, times_pointer_size, kParameterMapHeaderSize));
649 __ bind(&no_parameter_map);
652 __ leap(r8, Operand(r8, rcx, times_pointer_size, FixedArray::kHeaderSize));
655 __ addp(r8, Immediate(Heap::kSloppyArgumentsObjectSize));
658 __ Allocate(r8, rax, rdx, rdi, &runtime, TAG_OBJECT);
664 __ movp(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
665 __ movp(rdi, FieldOperand(rdi, GlobalObject::kNativeContextOffset));
666 __ testp(rbx, rbx);
667 __ j(not_zero, &has_mapped_parameters, Label::kNear);
670 __ movp(rdi, Operand(rdi, Context::SlotOffset(kIndex)));
671 __ jmp(&instantiate, Label::kNear);
674 __ bind(&has_mapped_parameters);
675 __ movp(rdi, Operand(rdi, Context::SlotOffset(kAliasedIndex)));
676 __ bind(&instantiate);
682 __ movp(FieldOperand(rax, JSObject::kMapOffset), rdi);
683 __ LoadRoot(kScratchRegister, Heap::kEmptyFixedArrayRootIndex);
684 __ movp(FieldOperand(rax, JSObject::kPropertiesOffset), kScratchRegister);
685 __ movp(FieldOperand(rax, JSObject::kElementsOffset), kScratchRegister);
689 __ movp(rdx, args.GetArgumentOperand(0));
690 __ AssertNotSmi(rdx);
691 __ movp(FieldOperand(rax, JSObject::kHeaderSize +
698 __ Integer32ToSmi(rcx, rcx);
699 __ movp(FieldOperand(rax, JSObject::kHeaderSize +
706 __ leap(rdi, Operand(rax, Heap::kSloppyArgumentsObjectSize));
707 __ movp(FieldOperand(rax, JSObject::kElementsOffset), rdi);
716 __ testp(rbx, rbx);
717 __ j(zero, &skip_parameter_map);
719 __ LoadRoot(kScratchRegister, Heap::kSloppyArgumentsElementsMapRootIndex);
721 __ movp(FieldOperand(rdi, FixedArray::kMapOffset), kScratchRegister);
722 __ Integer64PlusConstantToSmi(r9, rbx, 2);
723 __ movp(FieldOperand(rdi, FixedArray::kLengthOffset), r9);
724 __ movp(FieldOperand(rdi, FixedArray::kHeaderSize + 0 * kPointerSize), rsi);
725 __ leap(r9, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
726 __ movp(FieldOperand(rdi, FixedArray::kHeaderSize + 1 * kPointerSize), r9);
739 __ Integer32ToSmi(r9, rbx);
740 __ Move(r8, Smi::FromInt(Context::MIN_CONTEXT_SLOTS));
741 __ addp(r8, args.GetArgumentOperand(2));
742 __ subp(r8, r9);
743 __ Move(r11, factory->the_hole_value());
744 __ movp(rdx, rdi);
745 __ leap(rdi, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
751 __ jmp(¶meters_test, Label::kNear);
753 __ bind(¶meters_loop);
754 __ SmiSubConstant(r9, r9, Smi::FromInt(1));
755 __ SmiToInteger64(kScratchRegister, r9);
756 __ movp(FieldOperand(rdx, kScratchRegister,
760 __ movp(FieldOperand(rdi, kScratchRegister,
764 __ SmiAddConstant(r8, r8, Smi::FromInt(1));
765 __ bind(¶meters_test);
766 __ SmiTest(r9);
767 __ j(not_zero, ¶meters_loop, Label::kNear);
769 __ bind(&skip_parameter_map);
774 __ Move(FieldOperand(rdi, FixedArray::kMapOffset),
776 __ movp(FieldOperand(rdi, FixedArray::kLengthOffset), rcx);
779 __ movp(r8, rbx);
780 __ movp(rdx, args.GetArgumentOperand(1));
782 __ SmiToInteger64(rcx, rcx);
783 __ leap(kScratchRegister, Operand(r8, times_pointer_size, 0));
784 __ subp(rdx, kScratchRegister);
785 __ jmp(&arguments_test, Label::kNear);
787 __ bind(&arguments_loop);
788 __ subp(rdx, Immediate(kPointerSize));
789 __ movp(r9, Operand(rdx, 0));
790 __ movp(FieldOperand(rdi, r8,
794 __ addp(r8, Immediate(1));
796 __ bind(&arguments_test);
797 __ cmpp(r8, rcx);
798 __ j(less, &arguments_loop, Label::kNear);
801 __ ret(3 * kPointerSize);
805 __ bind(&runtime);
806 __ Integer32ToSmi(rcx, rcx);
807 __ movp(args.GetArgumentOperand(2), rcx); // Patch argument count.
808 __ TailCallRuntime(Runtime::kNewSloppyArguments, 3, 1);
820 __ movp(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
821 __ movp(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
822 __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
823 __ j(not_equal, &runtime);
827 __ movp(rcx, Operand(rdx, ArgumentsAdaptorFrameConstants::kLengthOffset));
828 __ movp(args.GetArgumentOperand(2), rcx);
829 __ SmiToInteger64(rcx, rcx);
830 __ leap(rdx, Operand(rdx, rcx, times_pointer_size,
832 __ movp(args.GetArgumentOperand(1), rdx);
834 __ bind(&runtime);
835 __ TailCallRuntime(Runtime::kNewSloppyArguments, 3, 1);
850 __ JumpUnlessNonNegativeSmi(key, &slow);
853 __ PopReturnAddressTo(scratch);
854 __ Push(receiver); // receiver
855 __ Push(key); // key
856 __ PushReturnAddressFrom(scratch);
859 __ TailCallExternalReference(
864 __ bind(&slow);
878 __ movp(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
879 __ movp(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
880 __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
881 __ j(equal, &adaptor_frame);
885 __ movp(rcx, args.GetArgumentOperand(2));
886 __ SmiToInteger64(rcx, rcx);
887 __ jmp(&try_allocate);
890 __ bind(&adaptor_frame);
891 __ movp(rcx, Operand(rdx, ArgumentsAdaptorFrameConstants::kLengthOffset));
892 __ movp(args.GetArgumentOperand(2), rcx);
893 __ SmiToInteger64(rcx, rcx);
894 __ leap(rdx, Operand(rdx, rcx, times_pointer_size,
896 __ movp(args.GetArgumentOperand(1), rdx);
901 __ bind(&try_allocate);
902 __ testp(rcx, rcx);
903 __ j(zero, &add_arguments_object, Label::kNear);
904 __ leap(rcx, Operand(rcx, times_pointer_size, FixedArray::kHeaderSize));
905 __ bind(&add_arguments_object);
906 __ addp(rcx, Immediate(Heap::kStrictArgumentsObjectSize));
909 __ Allocate(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT);
912 __ movp(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
913 __ movp(rdi, FieldOperand(rdi, GlobalObject::kNativeContextOffset));
915 __ movp(rdi, Operand(rdi, offset));
917 __ movp(FieldOperand(rax, JSObject::kMapOffset), rdi);
918 __ LoadRoot(kScratchRegister, Heap::kEmptyFixedArrayRootIndex);
919 __ movp(FieldOperand(rax, JSObject::kPropertiesOffset), kScratchRegister);
920 __ movp(FieldOperand(rax, JSObject::kElementsOffset), kScratchRegister);
924 __ movp(rcx, args.GetArgumentOperand(2));
925 __ movp(FieldOperand(rax, JSObject::kHeaderSize +
931 __ testp(rcx, rcx);
932 __ j(zero, &done);
935 __ movp(rdx, args.GetArgumentOperand(1));
939 __ leap(rdi, Operand(rax, Heap::kStrictArgumentsObjectSize));
940 __ movp(FieldOperand(rax, JSObject::kElementsOffset), rdi);
941 __ LoadRoot(kScratchRegister, Heap::kFixedArrayMapRootIndex);
942 __ movp(FieldOperand(rdi, FixedArray::kMapOffset), kScratchRegister);
945 __ movp(FieldOperand(rdi, FixedArray::kLengthOffset), rcx);
947 __ SmiToInteger64(rcx, rcx);
951 __ bind(&loop);
952 __ movp(rbx, Operand(rdx, -1 * kPointerSize)); // Skip receiver.
953 __ movp(FieldOperand(rdi, FixedArray::kHeaderSize), rbx);
954 __ addp(rdi, Immediate(kPointerSize));
955 __ subp(rdx, Immediate(kPointerSize));
956 __ decp(rcx);
957 __ j(not_zero, &loop);
960 __ bind(&done);
961 __ ret(3 * kPointerSize);
964 __ bind(&runtime);
965 __ TailCallRuntime(Runtime::kNewStrictArguments, 3, 1);
974 __ TailCallRuntime(Runtime::kRegExpExecRT, 4, 1);
1000 __ Load(kScratchRegister, address_of_regexp_stack_memory_size);
1001 __ testp(kScratchRegister, kScratchRegister);
1002 __ j(zero, &runtime);
1005 __ movp(rax, args.GetArgumentOperand(JS_REG_EXP_OBJECT_ARGUMENT_INDEX));
1006 __ JumpIfSmi(rax, &runtime);
1007 __ CmpObjectType(rax, JS_REGEXP_TYPE, kScratchRegister);
1008 __ j(not_equal, &runtime);
1011 __ movp(rax, FieldOperand(rax, JSRegExp::kDataOffset));
1014 __ Check(NegateCondition(is_smi),
1016 __ CmpObjectType(rax, FIXED_ARRAY_TYPE, kScratchRegister);
1017 __ Check(equal, kUnexpectedTypeForRegExpDataFixedArrayExpected);
1022 __ SmiToInteger32(rbx, FieldOperand(rax, JSRegExp::kDataTagOffset));
1023 __ cmpl(rbx, Immediate(JSRegExp::IRREGEXP));
1024 __ j(not_equal, &runtime);
1028 __ SmiToInteger32(rdx,
1033 __ cmpl(rdx, Immediate(Isolate::kJSRegexpStaticOffsetsVectorSize / 2 - 1));
1034 __ j(above, &runtime);
1037 __ Set(r14, 0);
1038 __ movp(rdi, args.GetArgumentOperand(SUBJECT_STRING_ARGUMENT_INDEX));
1039 __ JumpIfSmi(rdi, &runtime);
1040 __ movp(r15, rdi); // Make a copy of the original subject string.
1041 __ movp(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
1042 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
1072 __ andb(rbx, Immediate(kIsNotStringMask |
1077 __ j(zero, &seq_two_byte_string); // Go to (9).
1081 __ andb(rbx, Immediate(kIsNotStringMask |
1084 __ j(zero, &seq_one_byte_string, Label::kNear); // Go to (6).
1093 __ cmpp(rbx, Immediate(kExternalStringTag));
1094 __ j(greater_equal, ¬_seq_nor_cons); // Go to (7).
1098 __ CompareRoot(FieldOperand(rdi, ConsString::kSecondOffset),
1100 __ j(not_equal, &runtime);
1101 __ movp(rdi, FieldOperand(rdi, ConsString::kFirstOffset));
1102 __ bind(&check_underlying);
1103 __ movp(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
1104 __ movp(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
1107 __ testb(rbx, Immediate(kStringRepresentationMask | kStringEncodingMask));
1109 __ j(zero, &seq_two_byte_string); // Go to (9).
1111 __ testb(rbx, Immediate(kStringRepresentationMask));
1115 __ j(not_zero, &external_string); // Go to (8)
1118 __ bind(&seq_one_byte_string);
1120 __ movp(r11, FieldOperand(rax, JSRegExp::kDataOneByteCodeOffset));
1121 __ Set(rcx, 1); // Type is one byte.
1124 __ bind(&check_code);
1129 __ JumpIfSmi(r11, &runtime);
1140 __ movp(rbx, args.GetArgumentOperand(PREVIOUS_INDEX_ARGUMENT_INDEX));
1141 __ JumpIfNotSmi(rbx, &runtime);
1142 __ SmiCompare(rbx, FieldOperand(r15, String::kLengthOffset));
1143 __ j(above_equal, &runtime);
1144 __ SmiToInteger64(rbx, rbx);
1152 __ IncrementCounter(counters->regexp_entry_native(), 1);
1158 __ EnterApiExitFrame(argument_slots_on_stack);
1161 __ LoadAddress(kScratchRegister,
1163 __ movq(Operand(rsp, (argument_slots_on_stack - 1) * kRegisterSize),
1167 __ movq(Operand(rsp, (argument_slots_on_stack - 2) * kRegisterSize),
1171 __ Move(kScratchRegister, address_of_regexp_stack_memory_address);
1172 __ movp(r9, Operand(kScratchRegister, 0));
1173 __ Move(kScratchRegister, address_of_regexp_stack_memory_size);
1174 __ addp(r9, Operand(kScratchRegister, 0));
1175 __ movq(Operand(rsp, (argument_slots_on_stack - 3) * kRegisterSize), r9);
1181 __ movq(Operand(rsp, (argument_slots_on_stack - 4) * kRegisterSize),
1184 __ Set(r9, 0);
1188 __ LoadAddress(
1192 __ movq(Operand(rsp, (argument_slots_on_stack - 5) * kRegisterSize), r8);
1203 __ movp(arg_reg_2, rbx);
1210 __ addp(rbx, r14);
1211 __ SmiToInteger32(arg_reg_3, FieldOperand(r15, String::kLengthOffset));
1212 __ addp(r14, arg_reg_3); // Using arg3 as scratch.
1217 __ testb(rcx, rcx); // Last use of rcx as encoding of subject string.
1218 __ j(zero, &setup_two_byte, Label::kNear);
1219 __ leap(arg_reg_4,
1221 __ leap(arg_reg_3,
1223 __ jmp(&setup_rest, Label::kNear);
1224 __ bind(&setup_two_byte);
1225 __ leap(arg_reg_4,
1227 __ leap(arg_reg_3,
1229 __ bind(&setup_rest);
1236 __ movp(arg_reg_1, r15);
1239 __ addp(r11, Immediate(Code::kHeaderSize - kHeapObjectTag));
1240 __ call(r11);
1242 __ LeaveApiExitFrame(true);
1247 __ cmpl(rax, Immediate(1));
1250 __ j(equal, &success, Label::kNear);
1251 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::EXCEPTION));
1252 __ j(equal, &exception);
1253 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::FAILURE));
1256 __ j(not_equal, &runtime);
1259 __ LoadRoot(rax, Heap::kNullValueRootIndex);
1260 __ ret(REG_EXP_EXEC_ARGUMENT_COUNT * kPointerSize);
1263 __ bind(&success);
1264 __ movp(rax, args.GetArgumentOperand(JS_REG_EXP_OBJECT_ARGUMENT_INDEX));
1265 __ movp(rcx, FieldOperand(rax, JSRegExp::kDataOffset));
1266 __ SmiToInteger32(rax,
1269 __ leal(rdx, Operand(rax, rax, times_1, 2));
1273 __ movp(r15, args.GetArgumentOperand(LAST_MATCH_INFO_ARGUMENT_INDEX));
1274 __ JumpIfSmi(r15, &runtime);
1275 __ CmpObjectType(r15, JS_ARRAY_TYPE, kScratchRegister);
1276 __ j(not_equal, &runtime);
1278 __ movp(rbx, FieldOperand(r15, JSArray::kElementsOffset));
1279 __ movp(rax, FieldOperand(rbx, HeapObject::kMapOffset));
1280 __ CompareRoot(rax, Heap::kFixedArrayMapRootIndex);
1281 __ j(not_equal, &runtime);
1285 __ SmiToInteger32(rax, FieldOperand(rbx, FixedArray::kLengthOffset));
1286 __ subl(rax, Immediate(RegExpImpl::kLastMatchOverhead));
1287 __ cmpl(rdx, rax);
1288 __ j(greater, &runtime);
1293 __ Integer32ToSmi(kScratchRegister, rdx);
1294 __ movp(FieldOperand(rbx, RegExpImpl::kLastCaptureCountOffset),
1297 __ movp(rax, args.GetArgumentOperand(SUBJECT_STRING_ARGUMENT_INDEX));
1298 __ movp(FieldOperand(rbx, RegExpImpl::kLastSubjectOffset), rax);
1299 __ movp(rcx, rax);
1300 __ RecordWriteField(rbx,
1305 __ movp(rax, rcx);
1306 __ movp(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
1307 __ RecordWriteField(rbx,
1314 __ LoadAddress(
1323 __ bind(&next_capture);
1324 __ subp(rdx, Immediate(1));
1325 __ j(negative, &done, Label::kNear);
1327 __ movl(rdi, Operand(rcx, rdx, times_int_size, 0));
1328 __ Integer32ToSmi(rdi, rdi);
1330 __ movp(FieldOperand(rbx,
1335 __ jmp(&next_capture);
1336 __ bind(&done);
1339 __ movp(rax, r15);
1340 __ ret(REG_EXP_EXEC_ARGUMENT_COUNT * kPointerSize);
1342 __ bind(&exception);
1351 __ movp(rax, pending_exception_operand);
1352 __ LoadRoot(rdx, Heap::kTheHoleValueRootIndex);
1353 __ cmpp(rax, rdx);
1354 __ j(equal, &runtime);
1355 __ movp(pending_exception_operand, rdx);
1357 __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
1359 __ j(equal, &termination_exception, Label::kNear);
1360 __ Throw(rax);
1362 __ bind(&termination_exception);
1363 __ ThrowUncatchable(rax);
1366 __ bind(&runtime);
1367 __ TailCallRuntime(Runtime::kRegExpExecRT, 4, 1);
1371 __ bind(¬_seq_nor_cons);
1373 __ j(greater, ¬_long_external, Label::kNear); // Go to (10).
1376 __ bind(&external_string);
1377 __ movp(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
1378 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
1382 __ testb(rbx, Immediate(kIsIndirectStringMask));
1383 __ Assert(zero, kExternalStringExpectedButNotFound);
1385 __ movp(rdi, FieldOperand(rdi, ExternalString::kResourceDataOffset));
1388 __ subp(rdi, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
1391 __ testb(rbx, Immediate(kStringEncodingMask));
1392 __ j(not_zero, &seq_one_byte_string); // Goto (6).
1397 __ bind(&seq_two_byte_string);
1398 __ movp(r11, FieldOperand(rax, JSRegExp::kDataUC16CodeOffset));
1399 __ Set(rcx, 0); // Type is two byte.
1400 __ jmp(&check_code); // Go to (E).
1403 __ bind(¬_long_external);
1406 __ testb(rbx, Immediate(kIsNotStringMask | kShortExternalStringMask));
1407 __ j(not_zero, &runtime);
1411 __ SmiToInteger32(r14, FieldOperand(rdi, SlicedString::kOffsetOffset));
1412 __ movp(rdi, FieldOperand(rdi, SlicedString::kParentOffset));
1413 __ jmp(&check_underlying);
1430 __ JumpIfNotSmi(input, fail);
1432 __ JumpIfSmi(input, &ok);
1433 __ CompareMap(input, masm->isolate()->factory()->heap_number_map());
1434 __ j(not_equal, fail);
1438 __ bind(&ok);
1446 __ JumpIfSmi(object, label);
1447 __ movp(scratch, FieldOperand(object, HeapObject::kMapOffset));
1448 __ movzxbp(scratch,
1451 __ testb(scratch, Immediate(kIsNotStringMask | kIsNotInternalizedMask));
1452 __ j(not_zero, label);
1467 __ JumpIfNotBothSmi(rax, rdx, &non_smi);
1468 __ subp(rdx, rax);
1469 __ j(no_overflow, &smi_done);
1470 __ notp(rdx); // Correct sign in case of overflow. rdx cannot be 0 here.
1471 __ bind(&smi_done);
1472 __ movp(rax, rdx);
1473 __ ret(0);
1474 __ bind(&non_smi);
1484 __ cmpp(rax, rdx);
1485 __ j(not_equal, ¬_identical, Label::kNear);
1491 __ CompareRoot(rdx, Heap::kUndefinedValueRootIndex);
1492 __ j(not_equal, &check_for_nan, Label::kNear);
1493 __ Set(rax, NegativeComparisonResult(cc));
1494 __ ret(0);
1495 __ bind(&check_for_nan);
1502 __ Cmp(FieldOperand(rdx, HeapObject::kMapOffset),
1504 __ j(equal, &heap_number, Label::kNear);
1507 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
1508 __ j(above_equal, ¬_identical, Label::kNear);
1510 __ Set(rax, EQUAL);
1511 __ ret(0);
1513 __ bind(&heap_number);
1518 __ Set(rax, EQUAL);
1519 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
1520 __ ucomisd(xmm0, xmm0);
1521 __ setcc(parity_even, rax);
1524 __ negp(rax);
1526 __ ret(0);
1528 __ bind(¬_identical);
1543 __ SelectNonSmi(rbx, rax, rdx, ¬_smis);
1546 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
1549 __ j(equal, &slow);
1551 __ movp(rax, rbx);
1552 __ ret(0);
1554 __ bind(¬_smis);
1564 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
1565 __ j(below, &first_non_object, Label::kNear);
1569 __ bind(&return_not_equal);
1570 __ ret(0);
1572 __ bind(&first_non_object);
1574 __ CmpInstanceType(rcx, ODDBALL_TYPE);
1575 __ j(equal, &return_not_equal);
1577 __ CmpObjectType(rdx, FIRST_SPEC_OBJECT_TYPE, rcx);
1578 __ j(above_equal, &return_not_equal);
1581 __ CmpInstanceType(rcx, ODDBALL_TYPE);
1582 __ j(equal, &return_not_equal);
1586 __ bind(&slow);
1593 __ xorl(rax, rax);
1594 __ xorl(rcx, rcx);
1595 __ ucomisd(xmm0, xmm1);
1598 __ j(parity_even, &unordered, Label::kNear);
1600 __ setcc(above, rax);
1601 __ setcc(below, rcx);
1602 __ subp(rax, rcx);
1603 __ ret(0);
1607 __ bind(&unordered);
1610 __ Set(rax, 1);
1612 __ Set(rax, -1);
1614 __ ret(0);
1617 __ bind(&non_number_comparison);
1630 __ ret(0);
1633 __ bind(&check_for_strings);
1635 __ JumpIfNotBothSequentialOneByteStrings(rdx, rax, rcx, rbx,
1647 __ Abort(kUnexpectedFallThroughFromStringComparison);
1650 __ bind(&check_unequal_objects);
1661 __ leap(rcx, Operand(rax, rdx, times_1, 0));
1662 __ testb(rcx, Immediate(kSmiTagMask));
1663 __ j(not_zero, ¬_both_objects, Label::kNear);
1664 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
1665 __ j(below, ¬_both_objects, Label::kNear);
1666 __ CmpObjectType(rdx, FIRST_SPEC_OBJECT_TYPE, rcx);
1667 __ j(below, ¬_both_objects, Label::kNear);
1668 __ testb(FieldOperand(rbx, Map::kBitFieldOffset),
1670 __ j(zero, &return_unequal, Label::kNear);
1671 __ testb(FieldOperand(rcx, Map::kBitFieldOffset),
1673 __ j(zero, &return_unequal, Label::kNear);
1676 __ Set(rax, EQUAL);
1677 __ bind(&return_unequal);
1680 __ ret(0);
1681 __ bind(¬_both_objects);
1685 __ PopReturnAddressTo(rcx);
1686 __ Push(rdx);
1687 __ Push(rax);
1695 __ Push(Smi::FromInt(NegativeComparisonResult(cc)));
1698 __ PushReturnAddressFrom(rcx);
1702 __ InvokeBuiltin(builtin, JUMP_FUNCTION);
1704 __ bind(&miss);
1722 __ SmiToInteger32(rdx, rdx);
1723 __ movp(rcx, FieldOperand(rbx, rdx, times_pointer_size,
1728 __ cmpp(rcx, rdi);
1729 __ j(equal, &done);
1730 __ Cmp(rcx, TypeFeedbackVector::MegamorphicSentinel(isolate));
1731 __ j(equal, &done);
1740 __ Cmp(FieldOperand(rcx, 0), allocation_site_map);
1741 __ j(not_equal, &miss);
1744 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, rcx);
1745 __ cmpp(rdi, rcx);
1746 __ j(not_equal, &megamorphic);
1747 __ jmp(&done);
1750 __ bind(&miss);
1754 __ Cmp(rcx, TypeFeedbackVector::UninitializedSentinel(isolate));
1755 __ j(equal, &initialize);
1758 __ bind(&megamorphic);
1759 __ Move(FieldOperand(rbx, rdx, times_pointer_size, FixedArray::kHeaderSize),
1761 __ jmp(&done);
1765 __ bind(&initialize);
1769 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, rcx);
1770 __ cmpp(rdi, rcx);
1771 __ j(not_equal, ¬_array_function);
1777 __ Integer32ToSmi(rax, rax);
1778 __ Push(rax);
1779 __ Push(rdi);
1780 __ Integer32ToSmi(rdx, rdx);
1781 __ Push(rdx);
1782 __ Push(rbx);
1785 __ CallStub(&create_stub);
1787 __ Pop(rbx);
1788 __ Pop(rdx);
1789 __ Pop(rdi);
1790 __ Pop(rax);
1791 __ SmiToInteger32(rax, rax);
1793 __ jmp(&done_no_smi_convert);
1795 __ bind(¬_array_function);
1798 __ movp(FieldOperand(rbx, rdx, times_pointer_size, FixedArray::kHeaderSize),
1802 __ Push(rdi);
1803 __ Push(rbx);
1804 __ Push(rdx);
1805 __ RecordWriteArray(rbx, rdi, rdx, kDontSaveFPRegs,
1807 __ Pop(rdx);
1808 __ Pop(rbx);
1809 __ Pop(rdi);
1811 __ bind(&done);
1812 __ Integer32ToSmi(rdx, rdx);
1814 __ bind(&done_no_smi_convert);
1820 __ movp(rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
1821 __ testb(FieldOperand(rcx, SharedFunctionInfo::kStrictModeByteOffset),
1823 __ j(not_equal, cont);
1827 __ testb(FieldOperand(rcx, SharedFunctionInfo::kNativeByteOffset),
1829 __ j(not_equal, cont);
1839 __ CmpInstanceType(rcx, JS_FUNCTION_PROXY_TYPE);
1840 __ j(not_equal, non_function);
1841 __ PopReturnAddressTo(rcx);
1842 __ Push(rdi); // put proxy as additional argument under return address
1843 __ PushReturnAddressFrom(rcx);
1844 __ Set(rax, argc + 1);
1845 __ Set(rbx, 0);
1846 __ GetBuiltinEntry(rdx, Builtins::CALL_FUNCTION_PROXY);
1850 __ jmp(adaptor, RelocInfo::CODE_TARGET);
1855 __ bind(non_function);
1856 __ movp(args->GetReceiverOperand(), rdi);
1857 __ Set(rax, argc);
1858 __ Set(rbx, 0);
1859 __ GetBuiltinEntry(rdx, Builtins::CALL_NON_FUNCTION);
1862 __ Jump(adaptor, RelocInfo::CODE_TARGET);
1871 __ Push(rdi);
1872 __ Push(rax);
1873 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1874 __ Pop(rdi);
1876 __ movp(args->GetReceiverOperand(), rax);
1877 __ jmp(cont);
1893 __ JumpIfSmi(rdi, &non_function);
1896 __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
1897 __ j(not_equal, &slow);
1909 __ movp(rax, args.GetReceiverOperand());
1912 __ JumpIfSmi(rax, &wrap);
1914 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
1915 __ j(below, &wrap);
1917 __ jmp(&wrap);
1920 __ bind(&cont);
1923 __ InvokeFunction(rdi, actual, JUMP_FUNCTION, NullCallWrapper());
1927 __ bind(&slow);
1932 __ bind(&wrap);
1952 __ JumpIfSmi(rdi, &non_function_call);
1954 __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
1955 __ j(not_equal, &slow);
1960 __ SmiToInteger32(rdx, rdx);
1965 __ movp(rbx, FieldOperand(rbx, rdx, times_pointer_size,
1970 __ movp(rbx, FieldOperand(rbx, rdx, times_pointer_size,
1972 __ CompareRoot(FieldOperand(rbx, 0), Heap::kAllocationSiteMapRootIndex);
1973 __ j(equal, &feedback_register_initialized);
1974 __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);
1975 __ bind(&feedback_register_initialized);
1978 __ AssertUndefinedOrAllocationSite(rbx);
1983 __ movp(jmp_reg, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
1984 __ movp(jmp_reg, FieldOperand(jmp_reg,
1986 __ leap(jmp_reg, FieldOperand(jmp_reg, Code::kHeaderSize));
1987 __ jmp(jmp_reg);
1993 __ bind(&slow);
1994 __ CmpInstanceType(rcx, JS_FUNCTION_PROXY_TYPE);
1995 __ j(not_equal, &non_function_call);
1996 __ GetBuiltinEntry(rdx, Builtins::CALL_FUNCTION_PROXY_AS_CONSTRUCTOR);
1997 __ jmp(&do_call);
1999 __ bind(&non_function_call);
2000 __ GetBuiltinEntry(rdx, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR);
2001 __ bind(&do_call);
2003 __ Set(rbx, 0);
2004 __ Jump(isolate()->builtins()->ArgumentsAdaptorTrampoline(),
2010 __ movp(vector, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
2011 __ movp(vector, FieldOperand(vector, JSFunction::kSharedFunctionInfoOffset));
2012 __ movp(vector, FieldOperand(vector,
2025 __ SmiToInteger32(rdx, rdx);
2027 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, rcx);
2028 __ cmpp(rdi, rcx);
2029 __ j(not_equal, &miss);
2031 __ movp(rax, Immediate(arg_count()));
2032 __ movp(rcx, FieldOperand(rbx, rdx, times_pointer_size,
2036 __ Cmp(FieldOperand(rcx, HeapObject::kMapOffset),
2038 __ j(not_equal, &miss);
2040 __ movp(rbx, rcx);
2042 __ TailCallStub(&stub);
2044 __ bind(&miss);
2054 __ int3();
2072 __ SmiToInteger32(rdx, rdx);
2073 __ cmpp(rdi, FieldOperand(rbx, rdx, times_pointer_size,
2075 __ j(not_equal, &extra_checks_or_miss);
2077 __ bind(&have_js_function);
2082 __ movp(rax, args.GetReceiverOperand());
2084 __ JumpIfSmi(rax, &wrap);
2086 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
2087 __ j(below, &wrap);
2089 __ bind(&cont);
2092 __ InvokeFunction(rdi, actual, JUMP_FUNCTION, NullCallWrapper());
2094 __ bind(&slow);
2098 __ bind(&wrap);
2102 __ bind(&extra_checks_or_miss);
2105 __ movp(rcx, FieldOperand(rbx, rdx, times_pointer_size,
2107 __ Cmp(rcx, TypeFeedbackVector::MegamorphicSentinel(isolate));
2108 __ j(equal, &slow_start);
2109 __ Cmp(rcx, TypeFeedbackVector::UninitializedSentinel(isolate));
2110 __ j(equal, &miss);
2115 __ AssertNotSmi(rcx);
2116 __ CmpObjectType(rcx, JS_FUNCTION_TYPE, rcx);
2117 __ j(not_equal, &miss);
2118 __ Move(FieldOperand(rbx, rdx, times_pointer_size, FixedArray::kHeaderSize),
2120 __ jmp(&slow_start);
2124 __ bind(&miss);
2128 __ bind(&slow_start);
2130 __ JumpIfSmi(rdi, &non_function);
2132 __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
2133 __ j(not_equal, &slow);
2134 __ jmp(&have_js_function);
2137 __ int3();
2143 __ movp(rcx, Operand(rsp, (arg_count() + 1) * kPointerSize));
2149 __ Push(rcx);
2150 __ Push(rdi);
2151 __ Push(rbx);
2152 __ Integer32ToSmi(rdx, rdx);
2153 __ Push(rdx);
2161 __ CallExternalReference(miss, 4);
2164 __ movp(rdi, rax);
2213 __ EnterExitFrame(arg_stack_space, save_doubles());
2227 __ CheckStackAlignment();
2238 __ movp(rcx, r14); // argc.
2239 __ movp(rdx, r15); // argv.
2240 __ Move(r8, ExternalReference::isolate_address(isolate()));
2244 __ leap(rcx, StackSpaceOperand(2));
2246 __ movp(rdx, r14); // argc.
2247 __ movp(r8, r15); // argv.
2248 __ Move(r9, ExternalReference::isolate_address(isolate()));
2253 __ movp(rdi, r14); // argc.
2254 __ movp(rsi, r15); // argv.
2255 __ Move(rdx, ExternalReference::isolate_address(isolate()));
2257 __ call(rbx);
2267 __ movq(rax, Operand(rsp, 6 * kRegisterSize));
2268 __ movq(rdx, Operand(rsp, 7 * kRegisterSize));
2276 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
2277 __ j(not_equal, &okay, Label::kNear);
2278 __ int3();
2279 __ bind(&okay);
2284 __ CompareRoot(rax, Heap::kExceptionRootIndex);
2285 __ j(equal, &exception_returned);
2294 __ LoadRoot(r14, Heap::kTheHoleValueRootIndex);
2297 __ cmpp(r14, pending_exception_operand);
2298 __ j(equal, &okay, Label::kNear);
2299 __ int3();
2300 __ bind(&okay);
2304 __ LeaveExitFrame(save_doubles());
2305 __ ret(0);
2308 __ bind(&exception_returned);
2313 __ movp(rax, pending_exception_operand);
2316 __ LoadRoot(rdx, Heap::kTheHoleValueRootIndex);
2317 __ movp(pending_exception_operand, rdx);
2322 __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
2323 __ j(equal, &throw_termination_exception);
2326 __ Throw(rax);
2328 __ bind(&throw_termination_exception);
2329 __ ThrowUncatchable(rax);
2342 __ pushq(rbp);
2343 __ movp(rbp, rsp);
2350 __ Move(kScratchRegister, Smi::FromInt(marker), Assembler::RelocInfoNone());
2351 __ Push(kScratchRegister); // context slot
2352 __ Push(kScratchRegister); // function slot
2354 __ pushq(r12);
2355 __ pushq(r13);
2356 __ pushq(r14);
2357 __ pushq(r15);
2359 __ pushq(rdi); // Only callee save in Win64 ABI, argument in AMD64 ABI.
2360 __ pushq(rsi); // Only callee save in Win64 ABI, argument in AMD64 ABI.
2362 __ pushq(rbx);
2366 __ subp(rsp, Immediate(EntryFrameConstants::kXMMRegistersBlockSize));
2367 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 0), xmm6);
2368 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 1), xmm7);
2369 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 2), xmm8);
2370 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 3), xmm9);
2371 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 4), xmm10);
2372 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 5), xmm11);
2373 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 6), xmm12);
2374 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 7), xmm13);
2375 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 8), xmm14);
2376 __ movdqu(Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 9), xmm15);
2381 __ InitializeSmiConstantRegister();
2382 __ InitializeRootRegister();
2389 __ Push(c_entry_fp_operand);
2394 __ Load(rax, js_entry_sp);
2395 __ testp(rax, rax);
2396 __ j(not_zero, ¬_outermost_js);
2397 __ Push(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
2398 __ movp(rax, rbp);
2399 __ Store(js_entry_sp, rax);
2401 __ jmp(&cont);
2402 __ bind(¬_outermost_js);
2403 __ Push(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME));
2404 __ bind(&cont);
2408 __ jmp(&invoke);
2409 __ bind(&handler_entry);
2415 __ Store(pending_exception, rax);
2416 __ LoadRoot(rax, Heap::kExceptionRootIndex);
2417 __ jmp(&exit);
2421 __ bind(&invoke);
2422 __ PushTryHandler(StackHandler::JS_ENTRY, 0);
2425 __ LoadRoot(rax, Heap::kTheHoleValueRootIndex);
2426 __ Store(pending_exception, rax);
2429 __ Push(Immediate(0)); // receiver
2439 __ Load(rax, construct_entry);
2442 __ Load(rax, entry);
2444 __ leap(kScratchRegister, FieldOperand(rax, Code::kHeaderSize));
2445 __ call(kScratchRegister);
2448 __ PopTryHandler();
2450 __ bind(&exit);
2452 __ Pop(rbx);
2453 __ Cmp(rbx, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
2454 __ j(not_equal, ¬_outermost_js_2);
2455 __ Move(kScratchRegister, js_entry_sp);
2456 __ movp(Operand(kScratchRegister, 0), Immediate(0));
2457 __ bind(¬_outermost_js_2);
2461 __ Pop(c_entry_fp_operand);
2467 __ movdqu(xmm6, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 0));
2468 __ movdqu(xmm7, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 1));
2469 __ movdqu(xmm8, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 2));
2470 __ movdqu(xmm9, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 3));
2471 __ movdqu(xmm10, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 4));
2472 __ movdqu(xmm11, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 5));
2473 __ movdqu(xmm12, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 6));
2474 __ movdqu(xmm13, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 7));
2475 __ movdqu(xmm14, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 8));
2476 __ movdqu(xmm15, Operand(rsp, EntryFrameConstants::kXMMRegisterSize * 9));
2477 __ addp(rsp, Immediate(EntryFrameConstants::kXMMRegistersBlockSize));
2480 __ popq(rbx);
2483 __ popq(rsi);
2484 __ popq(rdi);
2486 __ popq(r15);
2487 __ popq(r14);
2488 __ popq(r13);
2489 __ popq(r12);
2490 __ addp(rsp, Immediate(2 * kPointerSize)); // remove markers
2493 __ popq(rbp);
2494 __ ret(0);
2529 // __ j(not_equal, &cache_miss);
2530 // __ LoadRoot(ToRegister(instr->result()), Heap::kTheHoleValueRootIndex);
2546 __ movp(object, args.GetArgumentOperand(0));
2547 __ movp(function, args.GetArgumentOperand(1));
2549 __ JumpIfSmi(object, &slow);
2552 __ CmpObjectType(object, FIRST_SPEC_OBJECT_TYPE, map);
2553 __ j(below, &slow);
2554 __ CmpInstanceType(map, LAST_SPEC_OBJECT_TYPE);
2555 __ j(above, &slow);
2562 __ CompareRoot(function, Heap::kInstanceofCacheFunctionRootIndex);
2563 __ j(not_equal, &miss, Label::kNear);
2564 __ CompareRoot(map, Heap::kInstanceofCacheMapRootIndex);
2565 __ j(not_equal, &miss, Label::kNear);
2566 __ LoadRoot(rax, Heap::kInstanceofCacheAnswerRootIndex);
2567 __ ret((HasArgsInRegisters() ? 0 : 2) * kPointerSize);
2568 __ bind(&miss);
2572 __ TryGetFunctionPrototype(function, prototype, &slow, true);
2575 __ JumpIfSmi(prototype, &slow);
2576 __ CmpObjectType(prototype, FIRST_SPEC_OBJECT_TYPE, kScratchRegister);
2577 __ j(below, &slow);
2578 __ CmpInstanceType(kScratchRegister, LAST_SPEC_OBJECT_TYPE);
2579 __ j(above, &slow);
2584 __ StoreRoot(function, Heap::kInstanceofCacheFunctionRootIndex);
2585 __ StoreRoot(map, Heap::kInstanceofCacheMapRootIndex);
2591 __ movq(kScratchRegister, StackOperandForReturnAddress(0));
2592 __ subp(kScratchRegister, args.GetArgumentOperand(2));
2594 __ movl(scratch, Immediate(kWordBeforeMapCheckValue));
2595 __ cmpl(Operand(kScratchRegister, kOffsetToMapCheckValue - 4), scratch);
2596 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheCheck);
2598 __ movp(kScratchRegister,
2600 __ movp(Operand(kScratchRegister, 0), map);
2604 __ movp(scratch, FieldOperand(map, Map::kPrototypeOffset));
2606 __ LoadRoot(kScratchRegister, Heap::kNullValueRootIndex);
2607 __ bind(&loop);
2608 __ cmpp(scratch, prototype);
2609 __ j(equal, &is_instance, Label::kNear);
2610 __ cmpp(scratch, kScratchRegister);
2613 __ j(equal, &is_not_instance, Label::kNear);
2614 __ movp(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
2615 __ movp(scratch, FieldOperand(scratch, Map::kPrototypeOffset));
2616 __ jmp(&loop);
2618 __ bind(&is_instance);
2620 __ xorl(rax, rax);
2623 __ StoreRoot(rax, Heap::kInstanceofCacheAnswerRootIndex);
2625 __ LoadRoot(rax, Heap::kTrueValueRootIndex);
2633 __ movl(rax, Immediate(true_offset));
2634 __ movq(kScratchRegister, StackOperandForReturnAddress(0));
2635 __ subp(kScratchRegister, args.GetArgumentOperand(2));
2636 __ movb(Operand(kScratchRegister, kOffsetToResultValue), rax);
2638 __ movl(rax, Immediate(kWordBeforeResultValue));
2639 __ cmpl(Operand(kScratchRegister, kOffsetToResultValue - 4), rax);
2640 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheMov);
2643 __ Set(rax, 0);
2646 __ ret(((HasArgsInRegisters() ? 0 : 2) + extra_argument_offset) *
2649 __ bind(&is_not_instance);
2652 __ StoreRoot(kScratchRegister, Heap::kInstanceofCacheAnswerRootIndex);
2654 __ LoadRoot(rax, Heap::kFalseValueRootIndex);
2662 __ movl(rax, Immediate(false_offset));
2663 __ movq(kScratchRegister, StackOperandForReturnAddress(0));
2664 __ subp(kScratchRegister, args.GetArgumentOperand(2));
2665 __ movb(Operand(kScratchRegister, kOffsetToResultValue), rax);
2667 __ movl(rax, Immediate(kWordBeforeResultValue));
2668 __ cmpl(Operand(kScratchRegister, kOffsetToResultValue - 4), rax);
2669 __ Assert(equal, kInstanceofStubUnexpectedCallSiteCacheMov);
2672 __ ret(((HasArgsInRegisters() ? 0 : 2) + extra_argument_offset) *
2676 __ bind(&slow);
2682 __ PopReturnAddressTo(rcx);
2683 __ Pop(rax);
2684 __ PushReturnAddressFrom(rcx);
2686 __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
2691 __ Push(object);
2692 __ Push(function);
2693 __ InvokeBuiltin(Builtins::INSTANCE_OF, CALL_FUNCTION);
2696 __ testq(rax, rax);
2697 __ j(zero, &true_value, Label::kNear);
2698 __ LoadRoot(rax, Heap::kFalseValueRootIndex);
2699 __ jmp(&done, Label::kNear);
2700 __ bind(&true_value);
2701 __ LoadRoot(rax, Heap::kTrueValueRootIndex);
2702 __ bind(&done);
2703 __ ret(((HasArgsInRegisters() ? 0 : 2) + extra_argument_offset) *
2714 __ JumpIfSmi(object_, receiver_not_string_);
2717 __ movp(result_, FieldOperand(object_, HeapObject::kMapOffset));
2718 __ movzxbl(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
2720 __ testb(result_, Immediate(kIsNotStringMask));
2721 __ j(not_zero, receiver_not_string_);
2724 __ JumpIfNotSmi(index_, &index_not_smi_);
2725 __ bind(&got_smi_index_);
2728 __ SmiCompare(index_, FieldOperand(object_, String::kLengthOffset));
2729 __ j(above_equal, index_out_of_range_);
2731 __ SmiToInteger32(index_, index_);
2736 __ Integer32ToSmi(result_, result_);
2737 __ bind(&exit_);
2744 __ Abort(kUnexpectedFallthroughToCharCodeAtSlowCase);
2748 __ bind(&index_not_smi_);
2750 __ CheckMap(index_,
2755 __ Push(object_);
2756 __ Push(index_); // Consumed by runtime conversion function.
2758 __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
2762 __ CallRuntime(Runtime::kNumberToSmi, 1);
2767 __ movp(index_, rax);
2769 __ Pop(object_);
2771 __ movp(result_, FieldOperand(object_, HeapObject::kMapOffset));
2772 __ movzxbl(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
2775 __ JumpIfNotSmi(index_, index_out_of_range_);
2777 __ jmp(&got_smi_index_);
2782 __ bind(&call_runtime_);
2784 __ Push(object_);
2785 __ Integer32ToSmi(index_, index_);
2786 __ Push(index_);
2787 __ CallRuntime(Runtime::kStringCharCodeAtRT, 2);
2789 __ movp(result_, rax);
2792 __ jmp(&exit_);
2794 __ Abort(kUnexpectedFallthroughFromCharCodeAtSlowCase);
2803 __ JumpIfNotSmi(code_, &slow_case_);
2804 __ SmiCompare(code_, Smi::FromInt(String::kMaxOneByteCharCode));
2805 __ j(above, &slow_case_);
2807 __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
2809 __ movp(result_, FieldOperand(result_, index.reg, index.scale,
2811 __ CompareRoot(result_, Heap::kUndefinedValueRootIndex);
2812 __ j(equal, &slow_case_);
2813 __ bind(&exit_);
2820 __ Abort(kUnexpectedFallthroughToCharFromCodeSlowCase);
2822 __ bind(&slow_case_);
2824 __ Push(code_);
2825 __ CallRuntime(Runtime::kCharFromCode, 1);
2827 __ movp(result_, rax);
2830 __ jmp(&exit_);
2832 __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
2843 __ testl(count, count);
2844 __ j(zero, &done, Label::kNear);
2849 __ addl(count, count);
2854 __ bind(&loop);
2855 __ movb(kScratchRegister, Operand(src, 0));
2856 __ movb(Operand(dest, 0), kScratchRegister);
2857 __ incp(src);
2858 __ incp(dest);
2859 __ decl(count);
2860 __ j(not_zero, &loop);
2862 __ bind(&done);
2886 __ movp(rax, args.GetArgumentOperand(STRING_ARGUMENT_INDEX));
2888 __ testl(rax, Immediate(kSmiTagMask));
2889 __ j(zero, &runtime);
2891 __ j(NegateCondition(is_string), &runtime);
2896 __ movp(rcx, args.GetArgumentOperand(TO_ARGUMENT_INDEX));
2897 __ movp(rdx, args.GetArgumentOperand(FROM_ARGUMENT_INDEX));
2898 __ JumpUnlessBothNonNegativeSmi(rcx, rdx, &runtime);
2900 __ SmiSub(rcx, rcx, rdx); // Overflow doesn't happen.
2901 __ cmpp(rcx, FieldOperand(rax, String::kLengthOffset));
2904 __ j(below, ¬_original_string, Label::kNear);
2906 __ j(above, &runtime);
2909 __ IncrementCounter(counters->sub_string_native(), 1);
2910 __ ret(SUB_STRING_ARGUMENT_COUNT * kPointerSize);
2911 __ bind(¬_original_string);
2914 __ SmiCompare(rcx, Smi::FromInt(1));
2915 __ j(equal, &single_char);
2917 __ SmiToInteger32(rcx, rcx);
2929 __ testb(rbx, Immediate(kIsIndirectStringMask));
2930 __ j(zero, &seq_or_external_string, Label::kNear);
2932 __ testb(rbx, Immediate(kSlicedNotConsMask));
2933 __ j(not_zero, &sliced_string, Label::kNear);
2936 __ CompareRoot(FieldOperand(rax, ConsString::kSecondOffset),
2938 __ j(not_equal, &runtime);
2939 __ movp(rdi, FieldOperand(rax, ConsString::kFirstOffset));
2941 __ movp(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2942 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2943 __ jmp(&underlying_unpacked, Label::kNear);
2945 __ bind(&sliced_string);
2947 __ addp(rdx, FieldOperand(rax, SlicedString::kOffsetOffset));
2948 __ movp(rdi, FieldOperand(rax, SlicedString::kParentOffset));
2950 __ movp(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2951 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2952 __ jmp(&underlying_unpacked, Label::kNear);
2954 __ bind(&seq_or_external_string);
2956 __ movp(rdi, rax);
2958 __ bind(&underlying_unpacked);
2968 __ cmpp(rcx, Immediate(SlicedString::kMinLength));
2970 __ j(less, ©_routine);
2979 __ testb(rbx, Immediate(kStringEncodingMask));
2980 __ j(zero, &two_byte_slice, Label::kNear);
2981 __ AllocateOneByteSlicedString(rax, rbx, r14, &runtime);
2982 __ jmp(&set_slice_header, Label::kNear);
2983 __ bind(&two_byte_slice);
2984 __ AllocateTwoByteSlicedString(rax, rbx, r14, &runtime);
2985 __ bind(&set_slice_header);
2986 __ Integer32ToSmi(rcx, rcx);
2987 __ movp(FieldOperand(rax, SlicedString::kLengthOffset), rcx);
2988 __ movp(FieldOperand(rax, SlicedString::kHashFieldOffset),
2990 __ movp(FieldOperand(rax, SlicedString::kParentOffset), rdi);
2991 __ movp(FieldOperand(rax, SlicedString::kOffsetOffset), rdx);
2992 __ IncrementCounter(counters->sub_string_native(), 1);
2993 __ ret(3 * kPointerSize);
2995 __ bind(©_routine);
3007 __ testb(rbx, Immediate(kExternalStringTag));
3008 __ j(zero, &sequential_string);
3013 __ testb(rbx, Immediate(kShortExternalStringMask));
3014 __ j(not_zero, &runtime);
3015 __ movp(rdi, FieldOperand(rdi, ExternalString::kResourceDataOffset));
3018 __ subp(rdi, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
3020 __ bind(&sequential_string);
3022 __ testb(rbx, Immediate(kStringEncodingMask));
3023 __ j(zero, &two_byte_sequential);
3026 __ AllocateOneByteString(rax, rcx, r11, r14, r15, &runtime);
3032 __ leap(r14, Operand(rdi, smi_as_index.reg, smi_as_index.scale,
3036 __ leap(rdi, FieldOperand(rax, SeqOneByteString::kHeaderSize));
3044 __ IncrementCounter(counters->sub_string_native(), 1);
3045 __ ret(SUB_STRING_ARGUMENT_COUNT * kPointerSize);
3047 __ bind(&two_byte_sequential);
3049 __ AllocateTwoByteString(rax, rcx, r11, r14, r15, &runtime);
3055 __ leap(r14, Operand(rdi, smi_as_index.reg, smi_as_index.scale,
3059 __ leap(rdi, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
3067 __ IncrementCounter(counters->sub_string_native(), 1);
3068 __ ret(SUB_STRING_ARGUMENT_COUNT * kPointerSize);
3071 __ bind(&runtime);
3072 __ TailCallRuntime(Runtime::kSubString, 3, 1);
3074 __ bind(&single_char);
3082 __ ret(SUB_STRING_ARGUMENT_COUNT * kPointerSize);
3096 __ movp(length, FieldOperand(left, String::kLengthOffset));
3097 __ SmiCompare(length, FieldOperand(right, String::kLengthOffset));
3098 __ j(equal, &check_zero_length, Label::kNear);
3099 __ Move(rax, Smi::FromInt(NOT_EQUAL));
3100 __ ret(0);
3104 __ bind(&check_zero_length);
3106 __ SmiTest(length);
3107 __ j(not_zero, &compare_chars, Label::kNear);
3108 __ Move(rax, Smi::FromInt(EQUAL));
3109 __ ret(0);
3112 __ bind(&compare_chars);
3118 __ Move(rax, Smi::FromInt(EQUAL));
3119 __ ret(0);
3122 __ bind(&strings_not_equal);
3123 __ Move(rax, Smi::FromInt(NOT_EQUAL));
3124 __ ret(0);
3136 __ movp(scratch1, FieldOperand(left, String::kLengthOffset));
3137 __ movp(scratch4, scratch1);
3138 __ SmiSub(scratch4,
3144 __ j(less, &left_shorter, Label::kNear);
3148 __ SmiSub(scratch1, scratch1, length_difference);
3149 __ bind(&left_shorter);
3155 __ SmiTest(min_length);
3156 __ j(zero, &compare_lengths, Label::kNear);
3168 __ bind(&compare_lengths);
3169 __ SmiTest(length_difference);
3171 __ j(not_zero, &length_not_equal, Label::kNear);
3174 __ Move(rax, Smi::FromInt(EQUAL));
3175 __ ret(0);
3179 __ bind(&length_not_equal);
3180 __ j(greater, &result_greater, Label::kNear);
3181 __ jmp(&result_less, Label::kNear);
3182 __ bind(&result_not_equal);
3184 __ j(above, &result_greater, Label::kNear);
3185 __ bind(&result_less);
3188 __ Move(rax, Smi::FromInt(LESS));
3189 __ ret(0);
3192 __ bind(&result_greater);
3193 __ Move(rax, Smi::FromInt(GREATER));
3194 __ ret(0);
3204 __ SmiToInteger32(length, length);
3205 __ leap(left,
3207 __ leap(right,
3209 __ negq(length);
3214 __ bind(&loop);
3215 __ movb(scratch, Operand(left, index, times_1, 0));
3216 __ cmpb(scratch, Operand(right, index, times_1, 0));
3217 __ j(not_equal, chars_not_equal, near_jump);
3218 __ incq(index);
3219 __ j(not_zero, &loop);
3232 __ movp(rdx, args.GetArgumentOperand(0)); // left
3233 __ movp(rax, args.GetArgumentOperand(1)); // right
3237 __ cmpp(rdx, rax);
3238 __ j(not_equal, ¬_same, Label::kNear);
3239 __ Move(rax, Smi::FromInt(EQUAL));
3241 __ IncrementCounter(counters->string_compare_native(), 1);
3242 __ ret(2 * kPointerSize);
3244 __ bind(¬_same);
3247 __ JumpIfNotBothSequentialOneByteStrings(rdx, rax, rcx, rbx, &runtime);
3250 __ IncrementCounter(counters->string_compare_native(), 1);
3252 __ PopReturnAddressTo(rcx);
3253 __ addp(rsp, Immediate(2 * kPointerSize));
3254 __ PushReturnAddressFrom(rcx);
3260 __ bind(&runtime);
3261 __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
3275 __ Move(rcx, handle(isolate()->heap()->undefined_value()));
3279 __ testb(rcx, Immediate(kSmiTagMask));
3280 __ Assert(not_equal, kExpectedAllocationSite);
3281 __ Cmp(FieldOperand(rcx, HeapObject::kMapOffset),
3283 __ Assert(equal, kExpectedAllocationSite);
3289 __ TailCallStub(&stub);
3296 __ JumpIfNotBothSmi(rdx, rax, &miss, Label::kNear);
3300 __ subp(rax, rdx);
3303 __ subp(rdx, rax);
3304 __ j(no_overflow, &done, Label::kNear);
3306 __ notp(rdx);
3307 __ bind(&done);
3308 __ movp(rax, rdx);
3310 __ ret(0);
3312 __ bind(&miss);
3325 __ JumpIfNotSmi(rdx, &miss);
3328 __ JumpIfNotSmi(rax, &miss);
3333 __ JumpIfSmi(rax, &right_smi, Label::kNear);
3334 __ CompareMap(rax, isolate()->factory()->heap_number_map());
3335 __ j(not_equal, &maybe_undefined1, Label::kNear);
3336 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
3337 __ jmp(&left, Label::kNear);
3338 __ bind(&right_smi);
3339 __ SmiToInteger32(rcx, rax); // Can't clobber rax yet.
3340 __ Cvtlsi2sd(xmm1, rcx);
3342 __ bind(&left);
3343 __ JumpIfSmi(rdx, &left_smi, Label::kNear);
3344 __ CompareMap(rdx, isolate()->factory()->heap_number_map());
3345 __ j(not_equal, &maybe_undefined2, Label::kNear);
3346 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
3347 __ jmp(&done);
3348 __ bind(&left_smi);
3349 __ SmiToInteger32(rcx, rdx); // Can't clobber rdx yet.
3350 __ Cvtlsi2sd(xmm0, rcx);
3352 __ bind(&done);
3354 __ ucomisd(xmm0, xmm1);
3357 __ j(parity_even, &unordered, Label::kNear);
3361 __ movl(rax, Immediate(0));
3362 __ movl(rcx, Immediate(0));
3363 __ setcc(above, rax); // Add one to zero if carry clear and not equal.
3364 __ sbbp(rax, rcx); // Subtract one if below (aka. carry set).
3365 __ ret(0);
3367 __ bind(&unordered);
3368 __ bind(&generic_stub);
3371 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
3373 __ bind(&maybe_undefined1);
3375 __ Cmp(rax, isolate()->factory()->undefined_value());
3376 __ j(not_equal, &miss);
3377 __ JumpIfSmi(rdx, &unordered);
3378 __ CmpObjectType(rdx, HEAP_NUMBER_TYPE, rcx);
3379 __ j(not_equal, &maybe_undefined2, Label::kNear);
3380 __ jmp(&unordered);
3383 __ bind(&maybe_undefined2);
3385 __ Cmp(rdx, isolate()->factory()->undefined_value());
3386 __ j(equal, &unordered);
3389 __ bind(&miss);
3407 __ j(cond, &miss, Label::kNear);
3410 __ movp(tmp1, FieldOperand(left, HeapObject::kMapOffset));
3411 __ movp(tmp2, FieldOperand(right, HeapObject::kMapOffset));
3412 __ movzxbp(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
3413 __ movzxbp(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
3415 __ orp(tmp1, tmp2);
3416 __ testb(tmp1, Immediate(kIsNotStringMask | kIsNotInternalizedMask));
3417 __ j(not_zero, &miss, Label::kNear);
3421 __ cmpp(left, right);
3425 __ j(not_equal, &done, Label::kNear);
3428 __ Move(rax, Smi::FromInt(EQUAL));
3429 __ bind(&done);
3430 __ ret(0);
3432 __ bind(&miss);
3450 __ j(cond, &miss, Label::kNear);
3454 __ movp(tmp1, FieldOperand(left, HeapObject::kMapOffset));
3455 __ movp(tmp2, FieldOperand(right, HeapObject::kMapOffset));
3456 __ movzxbp(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
3457 __ movzxbp(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
3459 __ JumpIfNotUniqueNameInstanceType(tmp1, &miss, Label::kNear);
3460 __ JumpIfNotUniqueNameInstanceType(tmp2, &miss, Label::kNear);
3464 __ cmpp(left, right);
3468 __ j(not_equal, &done, Label::kNear);
3471 __ Move(rax, Smi::FromInt(EQUAL));
3472 __ bind(&done);
3473 __ ret(0);
3475 __ bind(&miss);
3495 __ j(cond, &miss);
3499 __ movp(tmp1, FieldOperand(left, HeapObject::kMapOffset));
3500 __ movp(tmp2, FieldOperand(right, HeapObject::kMapOffset));
3501 __ movzxbp(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
3502 __ movzxbp(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
3503 __ movp(tmp3, tmp1);
3505 __ orp(tmp3, tmp2);
3506 __ testb(tmp3, Immediate(kIsNotStringMask));
3507 __ j(not_zero, &miss);
3511 __ cmpp(left, right);
3512 __ j(not_equal, ¬_same, Label::kNear);
3515 __ Move(rax, Smi::FromInt(EQUAL));
3516 __ ret(0);
3519 __ bind(¬_same);
3527 __ orp(tmp1, tmp2);
3528 __ testb(tmp1, Immediate(kIsNotInternalizedMask));
3529 __ j(not_zero, &do_compare, Label::kNear);
3533 __ ret(0);
3534 __ bind(&do_compare);
3539 __ JumpIfNotBothSequentialOneByteStrings(left, right, tmp1, tmp2, &runtime);
3551 __ bind(&runtime);
3552 __ PopReturnAddressTo(tmp1);
3553 __ Push(left);
3554 __ Push(right);
3555 __ PushReturnAddressFrom(tmp1);
3557 __ TailCallRuntime(Runtime::kStringEquals, 2, 1);
3559 __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
3562 __ bind(&miss);
3571 __ j(either_smi, &miss, Label::kNear);
3573 __ CmpObjectType(rax, JS_OBJECT_TYPE, rcx);
3574 __ j(not_equal, &miss, Label::kNear);
3575 __ CmpObjectType(rdx, JS_OBJECT_TYPE, rcx);
3576 __ j(not_equal, &miss, Label::kNear);
3579 __ subp(rax, rdx);
3580 __ ret(0);
3582 __ bind(&miss);
3590 __ j(either_smi, &miss, Label::kNear);
3592 __ movp(rcx, FieldOperand(rax, HeapObject::kMapOffset));
3593 __ movp(rbx, FieldOperand(rdx, HeapObject::kMapOffset));
3594 __ Cmp(rcx, known_map_);
3595 __ j(not_equal, &miss, Label::kNear);
3596 __ Cmp(rbx, known_map_);
3597 __ j(not_equal, &miss, Label::kNear);
3599 __ subp(rax, rdx);
3600 __ ret(0);
3602 __ bind(&miss);
3614 __ Push(rdx);
3615 __ Push(rax);
3616 __ Push(rdx);
3617 __ Push(rax);
3618 __ Push(Smi::FromInt(op()));
3619 __ CallExternalReference(miss, 3);
3622 __ leap(rdi, FieldOperand(rax, Code::kHeaderSize));
3623 __ Pop(rax);
3624 __ Pop(rdx);
3628 __ jmp(rdi);
3649 __ SmiToInteger32(index, FieldOperand(properties, kCapacityOffset));
3650 __ decl(index);
3651 __ andp(index,
3656 __ leap(index, Operand(index, index, times_2, 0)); // index *= 3.
3661 __ movp(entity_name, Operand(properties,
3665 __ Cmp(entity_name, masm->isolate()->factory()->undefined_value());
3666 __ j(equal, done);
3669 __ Cmp(entity_name, Handle<Name>(name));
3670 __ j(equal, miss);
3674 __ CompareRoot(entity_name, Heap::kTheHoleValueRootIndex);
3675 __ j(equal, &good, Label::kNear);
3678 __ movp(entity_name, FieldOperand(entity_name, HeapObject::kMapOffset));
3679 __ JumpIfNotUniqueNameInstanceType(
3681 __ bind(&good);
3686 __ Push(Handle<Object>(name));
3687 __ Push(Immediate(name->Hash()));
3688 __ CallStub(&stub);
3689 __ testp(r0, r0);
3690 __ j(not_zero, miss);
3691 __ jmp(done);
3711 __ AssertName(name);
3713 __ SmiToInteger32(r0, FieldOperand(elements, kCapacityOffset));
3714 __ decl(r0);
3718 __ movl(r1, FieldOperand(name, Name::kHashFieldOffset));
3719 __ shrl(r1, Immediate(Name::kHashShift));
3721 __ addl(r1, Immediate(NameDictionary::GetProbeOffset(i)));
3723 __ andp(r1, r0);
3727 __ leap(r1, Operand(r1, r1, times_2, 0)); // r1 = r1 * 3
3730 __ cmpp(name, Operand(elements, r1, times_pointer_size,
3732 __ j(equal, done);
3737 __ Push(name);
3738 __ movl(r0, FieldOperand(name, Name::kHashFieldOffset));
3739 __ shrl(r0, Immediate(Name::kHashShift));
3740 __ Push(r0);
3741 __ CallStub(&stub);
3743 __ testp(r0, r0);
3744 __ j(zero, miss);
3745 __ jmp(done);
3768 __ SmiToInteger32(scratch, FieldOperand(dictionary(), kCapacityOffset));
3769 __ decl(scratch);
3770 __ Push(scratch);
3781 __ movp(scratch, args.GetArgumentOperand(1));
3783 __ addl(scratch, Immediate(NameDictionary::GetProbeOffset(i)));
3785 __ andp(scratch, Operand(rsp, 0));
3789 __ leap(index(), Operand(scratch, scratch, times_2, 0)); // index *= 3.
3792 __ movp(scratch, Operand(dictionary(), index(), times_pointer_size,
3795 __ Cmp(scratch, isolate()->factory()->undefined_value());
3796 __ j(equal, ¬_in_dictionary);
3799 __ cmpp(scratch, args.GetArgumentOperand(0));
3800 __ j(equal, &in_dictionary);
3808 __ movp(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
3809 __ JumpIfNotUniqueNameInstanceType(
3815 __ bind(&maybe_in_dictionary);
3820 __ movp(scratch, Immediate(0));
3821 __ Drop(1);
3822 __ ret(2 * kPointerSize);
3825 __ bind(&in_dictionary);
3826 __ movp(scratch, Immediate(1));
3827 __ Drop(1);
3828 __ ret(2 * kPointerSize);
3830 __ bind(¬_in_dictionary);
3831 __ movp(scratch, Immediate(0));
3832 __ Drop(1);
3833 __ ret(2 * kPointerSize);
3859 __ jmp(&skip_to_incremental_noncompacting, Label::kNear);
3860 __ jmp(&skip_to_incremental_compacting, Label::kFar);
3863 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
3866 __ ret(0);
3869 __ bind(&skip_to_incremental_noncompacting);
3872 __ bind(&skip_to_incremental_compacting);
3888 __ movp(regs_.scratch0(), Operand(regs_.address(), 0));
3889 __ JumpIfNotInNewSpace(regs_.scratch0(),
3893 __ CheckPageFlag(regs_.object(),
3905 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
3908 __ bind(&dont_need_remembered_set);
3915 __ ret(0);
3925 __ Move(address, regs_.address());
3926 __ Move(arg_reg_1, regs_.object());
3928 __ Move(arg_reg_2, address);
3929 __ LoadAddress(arg_reg_3,
3934 __ PrepareCallCFunction(argument_count);
3935 __ CallCFunction(
3950 __ movp(regs_.scratch0(), Immediate(~Page::kPageAlignmentMask));
3951 __ andp(regs_.scratch0(), regs_.object());
3952 __ movp(regs_.scratch1(),
3955 __ subp(regs_.scratch1(), Immediate(1));
3956 __ movp(Operand(regs_.scratch0(),
3959 __ j(negative, &need_incremental);
3963 __ JumpIfBlack(regs_.object(),
3971 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
3974 __ ret(0);
3977 __ bind(&on_black);
3980 __ movp(regs_.scratch0(), Operand(regs_.address(), 0));
3985 __ CheckPageFlag(regs_.scratch0(), // Contains value.
3992 __ CheckPageFlag(regs_.object(),
3998 __ bind(&ensure_not_white);
4003 __ Push(regs_.object());
4004 __ EnsureNotWhite(regs_.scratch0(), // The value.
4009 __ Pop(regs_.object());
4013 __ RememberedSetHelper(object(), address(), value(), save_fp_regs_mode(),
4016 __ ret(0);
4019 __ bind(&need_incremental_pop_object);
4020 __ Pop(regs_.object());
4022 __ bind(&need_incremental);
4046 __ movp(rdx, args.GetArgumentOperand(1));
4047 __ movp(rbx, args.GetArgumentOperand(0));
4048 __ movp(rdi, FieldOperand(rbx, JSObject::kMapOffset));
4050 __ CheckFastElements(rdi, &double_elements);
4053 __ JumpIfSmi(rax, &smi_element);
4054 __ CheckFastSmiElements(rdi, &fast_elements);
4059 __ bind(&slow_elements);
4060 __ PopReturnAddressTo(rdi);
4061 __ Push(rbx);
4062 __ Push(rcx);
4063 __ Push(rax);
4064 __ movp(rbx, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
4065 __ Push(FieldOperand(rbx, JSFunction::kLiteralsOffset));
4066 __ Push(rdx);
4067 __ PushReturnAddressFrom(rdi);
4068 __ TailCallRuntime(Runtime::kStoreArrayLiteralElement, 5, 1);
4071 __ bind(&fast_elements);
4072 __ SmiToInteger32(kScratchRegister, rcx);
4073 __ movp(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
4074 __ leap(rcx, FieldOperand(rbx, kScratchRegister, times_pointer_size,
4076 __ movp(Operand(rcx, 0), rax);
4078 __ RecordWrite(rbx, rcx, rax,
4082 __ ret(0);
4086 __ bind(&smi_element);
4087 __ SmiToInteger32(kScratchRegister, rcx);
4088 __ movp(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
4089 __ movp(FieldOperand(rbx, kScratchRegister, times_pointer_size,
4091 __ ret(0);
4094 __ bind(&double_elements);
4096 __ movp(r9, FieldOperand(rbx, JSObject::kElementsOffset));
4097 __ SmiToInteger32(r11, rcx);
4098 __ StoreNumberToDoubleElements(rax,
4103 __ ret(0);
4109 __ Call(ces.GetCode(), RelocInfo::CODE_TARGET);
4112 __ movp(rbx, MemOperand(rbp, parameter_count_offset));
4114 __ PopReturnAddressTo(rcx);
4117 __ leap(rsp, MemOperand(rsp, rbx, times_pointer_size, additional_offset));
4118 __ jmp(rcx); // Return to IC Miss stub, continuation still on stack.
4125 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
4132 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
4148 __ pushq(arg_reg_1);
4149 __ pushq(arg_reg_2);
4152 __ leap(arg_reg_2,
4156 __ movp(arg_reg_1, Operand(rsp, kNumSavedRegisters * kRegisterSize));
4157 __ subp(arg_reg_1, Immediate(Assembler::kShortCallInstructionLength));
4163 __ Move(rax, FUNCTION_ADDR(isolate()->function_entry_hook()),
4169 __ PrepareCallCFunction(kArgumentCount);
4170 __ CallCFunction(rax, kArgumentCount);
4174 __ popq(arg_reg_2);
4175 __ popq(arg_reg_1);
4177 __ Ret();
4186 __ TailCallStub(&stub);
4193 __ cmpl(rdx, Immediate(kind));
4194 __ j(not_equal, &next);
4196 __ TailCallStub(&stub);
4197 __ bind(&next);
4201 __ Abort(kUnexpectedElementsKindInArrayConstructor);
4230 __ testb(rdx, Immediate(1));
4231 __ j(not_zero, &normal_sequence);
4236 __ movp(rcx, args.GetArgumentOperand(0));
4237 __ testp(rcx, rcx);
4238 __ j(zero, &normal_sequence);
4247 __ TailCallStub(&stub_holey);
4249 __ bind(&normal_sequence);
4253 __ TailCallStub(&stub);
4257 __ incl(rdx);
4262 __ Cmp(FieldOperand(rbx, 0), allocation_site_map);
4263 __ Assert(equal, kExpectedAllocationSite);
4270 __ SmiAddConstant(FieldOperand(rbx, AllocationSite::kTransitionInfoOffset),
4273 __ bind(&normal_sequence);
4279 __ cmpl(rdx, Immediate(kind));
4280 __ j(not_equal, &next);
4282 __ TailCallStub(&stub);
4283 __ bind(&next);
4287 __ Abort(kUnexpectedElementsKindInArrayConstructor);
4340 __ testp(rax, rax);
4341 __ j(not_zero, ¬_zero_case);
4344 __ bind(¬_zero_case);
4345 __ cmpl(rax, Immediate(1));
4346 __ j(greater, ¬_one_case);
4349 __ bind(¬_one_case);
4376 __ movp(rcx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset));
4380 __ Check(not_smi, kUnexpectedInitialMapForArrayFunction);
4381 __ CmpObjectType(rcx, MAP_TYPE, rcx);
4382 __ Check(equal, kUnexpectedInitialMapForArrayFunction);
4385 __ AssertUndefinedOrAllocationSite(rbx);
4391 __ CompareRoot(rbx, Heap::kUndefinedValueRootIndex);
4392 __ j(equal, &no_info);
4395 __ movp(rdx, FieldOperand(rbx, AllocationSite::kTransitionInfoOffset));
4396 __ SmiToInteger32(rdx, rdx);
4398 __ andp(rdx, Immediate(AllocationSite::ElementsKindBits::kMask));
4401 __ bind(&no_info);
4411 __ testp(rax, rax);
4412 __ j(not_zero, ¬_zero_case);
4414 __ TailCallStub(&stub0);
4416 __ bind(¬_zero_case);
4417 __ cmpl(rax, Immediate(1));
4418 __ j(greater, ¬_one_case);
4424 __ movp(rcx, args.GetArgumentOperand(0));
4425 __ testp(rcx, rcx);
4426 __ j(zero, &normal_sequence);
4430 __ TailCallStub(&stub1_holey);
4433 __ bind(&normal_sequence);
4435 __ TailCallStub(&stub1);
4437 __ bind(¬_one_case);
4439 __ TailCallStub(&stubN);
4456 __ movp(rcx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset));
4460 __ Check(not_smi, kUnexpectedInitialMapForArrayFunction);
4461 __ CmpObjectType(rcx, MAP_TYPE, rcx);
4462 __ Check(equal, kUnexpectedInitialMapForArrayFunction);
4466 __ movp(rcx, FieldOperand(rdi, JSFunction::kPrototypeOrInitialMapOffset));
4470 __ movzxbp(rcx, FieldOperand(rcx, Map::kBitField2Offset));
4472 __ DecodeField<Map::ElementsKindBits>(rcx);
4476 __ cmpl(rcx, Immediate(FAST_ELEMENTS));
4477 __ j(equal, &done);
4478 __ cmpl(rcx, Immediate(FAST_HOLEY_ELEMENTS));
4479 __ Assert(equal,
4481 __ bind(&done);
4485 __ cmpl(rcx, Immediate(FAST_ELEMENTS));
4486 __ j(equal, &fast_elements_case);
4489 __ bind(&fast_elements_case);
4531 __ PopReturnAddressTo(return_address);
4534 __ Push(context);
4536 __ movp(context, FieldOperand(callee, JSFunction::kContextOffset));
4539 __ Push(callee);
4542 __ Push(call_data);
4545 __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
4548 __ Push(scratch);
4550 __ Push(scratch);
4552 __ Move(scratch,
4554 __ Push(scratch);
4556 __ Push(holder);
4558 __ movp(scratch, rsp);
4560 __ PushReturnAddressFrom(return_address);
4566 __ PrepareCallApiFunction(kApiStackSpace);
4569 __ movp(StackSpaceOperand(0), scratch);
4570 __ addp(scratch, Immediate((argc + FCA::kArgsLength - 1) * kPointerSize));
4571 __ movp(StackSpaceOperand(1), scratch); // FunctionCallbackInfo::values_.
4572 __ Set(StackSpaceOperand(2), argc); // FunctionCallbackInfo::length_.
4574 __ Set(StackSpaceOperand(3), 0);
4589 __ leap(arguments_arg, StackSpaceOperand(0));
4602 __ CallApiFunctionAndReturn(
4640 __ leap(name_arg, Operand(rsp, kPCOnStackSize));
4642 __ PrepareCallApiFunction(kArgStackSpace);
4643 __ leap(scratch, Operand(name_arg, 1 * kPointerSize));
4646 __ movp(StackSpaceOperand(0), scratch);
4650 __ leap(accessor_info_arg, StackSpaceOperand(0));
4665 __ CallApiFunctionAndReturn(api_function_address,
4674 #undef __