Lines Matching refs:__
39 #define __ ACCESS_MASM(masm)
44 __ SmiTest(rax);
45 __ j(not_zero, &check_heap_number, Label::kNear);
46 __ Ret();
48 __ bind(&check_heap_number);
49 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
51 __ j(not_equal, &call_builtin, Label::kNear);
52 __ Ret();
54 __ bind(&call_builtin);
55 __ pop(rcx); // Pop return address.
56 __ push(rax);
57 __ push(rcx); // Push return address.
58 __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
66 __ AllocateInNewSpace(JSFunction::kSize, rax, rbx, rcx, &gc, TAG_OBJECT);
69 __ movq(rdx, Operand(rsp, 1 * kPointerSize));
77 __ movq(rcx, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX)));
78 __ movq(rcx, FieldOperand(rcx, GlobalObject::kGlobalContextOffset));
79 __ movq(rcx, Operand(rcx, Context::SlotOffset(map_index)));
80 __ movq(FieldOperand(rax, JSObject::kMapOffset), rcx);
84 __ LoadRoot(rbx, Heap::kEmptyFixedArrayRootIndex);
85 __ LoadRoot(rcx, Heap::kTheHoleValueRootIndex);
86 __ LoadRoot(rdi, Heap::kUndefinedValueRootIndex);
87 __ movq(FieldOperand(rax, JSObject::kPropertiesOffset), rbx);
88 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rbx);
89 __ movq(FieldOperand(rax, JSFunction::kPrototypeOrInitialMapOffset), rcx);
90 __ movq(FieldOperand(rax, JSFunction::kSharedFunctionInfoOffset), rdx);
91 __ movq(FieldOperand(rax, JSFunction::kContextOffset), rsi);
92 __ movq(FieldOperand(rax, JSFunction::kLiteralsOffset), rbx);
93 __ movq(FieldOperand(rax, JSFunction::kNextFunctionLinkOffset), rdi);
97 __ movq(rdx, FieldOperand(rdx, SharedFunctionInfo::kCodeOffset));
98 __ lea(rdx, FieldOperand(rdx, Code::kHeaderSize));
99 __ movq(FieldOperand(rax, JSFunction::kCodeEntryOffset), rdx);
103 __ ret(1 * kPointerSize);
106 __ bind(&gc);
107 __ pop(rcx); // Temporarily remove return address.
108 __ pop(rdx);
109 __ push(rsi);
110 __ push(rdx);
111 __ PushRoot(Heap::kFalseValueRootIndex);
112 __ push(rcx); // Restore return address.
113 __ TailCallRuntime(Runtime::kNewClosure, 3, 1);
121 __ AllocateInNewSpace((length * kPointerSize) + FixedArray::kHeaderSize,
125 __ movq(rcx, Operand(rsp, 1 * kPointerSize));
128 __ LoadRoot(kScratchRegister, Heap::kFunctionContextMapRootIndex);
129 __ movq(FieldOperand(rax, HeapObject::kMapOffset), kScratchRegister);
130 __ Move(FieldOperand(rax, FixedArray::kLengthOffset), Smi::FromInt(length));
133 __ Set(rbx, 0); // Set to NULL.
134 __ movq(Operand(rax, Context::SlotOffset(Context::CLOSURE_INDEX)), rcx);
135 __ movq(Operand(rax, Context::SlotOffset(Context::PREVIOUS_INDEX)), rsi);
136 __ movq(Operand(rax, Context::SlotOffset(Context::EXTENSION_INDEX)), rbx);
139 __ movq(rbx, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX)));
140 __ movq(Operand(rax, Context::SlotOffset(Context::GLOBAL_INDEX)), rbx);
143 __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);
145 __ movq(Operand(rax, Context::SlotOffset(i)), rbx);
149 __ movq(rsi, rax);
150 __ ret(1 * kPointerSize);
153 __ bind(&gc);
154 __ TailCallRuntime(Runtime::kNewFunctionContext, 1, 1);
167 __ AllocateInNewSpace(FixedArray::SizeFor(length),
171 __ movq(rcx, Operand(rsp, 1 * kPointerSize));
174 __ movq(rbx, Operand(rsp, 2 * kPointerSize));
177 __ LoadRoot(kScratchRegister, Heap::kBlockContextMapRootIndex);
178 __ movq(FieldOperand(rax, HeapObject::kMapOffset), kScratchRegister);
179 __ Move(FieldOperand(rax, FixedArray::kLengthOffset), Smi::FromInt(length));
186 __ JumpIfNotSmi(rcx, &after_sentinel, Label::kNear);
189 __ cmpq(rcx, Immediate(0));
190 __ Assert(equal, message);
192 __ movq(rcx, GlobalObjectOperand());
193 __ movq(rcx, FieldOperand(rcx, GlobalObject::kGlobalContextOffset));
194 __ movq(rcx, ContextOperand(rcx, Context::CLOSURE_INDEX));
195 __ bind(&after_sentinel);
198 __ movq(ContextOperand(rax, Context::CLOSURE_INDEX), rcx);
199 __ movq(ContextOperand(rax, Context::PREVIOUS_INDEX), rsi);
200 __ movq(ContextOperand(rax, Context::EXTENSION_INDEX), rbx);
203 __ movq(rbx, ContextOperand(rsi, Context::GLOBAL_INDEX));
204 __ movq(ContextOperand(rax, Context::GLOBAL_INDEX), rbx);
207 __ LoadRoot(rbx, Heap::kTheHoleValueRootIndex);
209 __ movq(ContextOperand(rax, i + Context::MIN_CONTEXT_SLOTS), rbx);
213 __ movq(rsi, rax);
214 __ ret(2 * kPointerSize);
217 __ bind(&gc);
218 __ TailCallRuntime(Runtime::kPushBlockContext, 2, 1);
243 __ AllocateInNewSpace(size, rax, rbx, rdx, fail, TAG_OBJECT);
248 __ movq(rbx, FieldOperand(rcx, i));
249 __ movq(FieldOperand(rax, i), rbx);
256 __ movq(rcx, FieldOperand(rcx, JSArray::kElementsOffset));
257 __ lea(rdx, Operand(rax, JSArray::kSize));
258 __ movq(FieldOperand(rax, JSArray::kElementsOffset), rdx);
263 __ movq(rbx, FieldOperand(rcx, i));
264 __ movq(FieldOperand(rdx, i), rbx);
270 __ movq(rbx, FieldOperand(rcx, i));
271 __ movq(FieldOperand(rdx, i), rbx);
274 __ movsd(xmm0, FieldOperand(rcx, i));
275 __ movsd(FieldOperand(rdx, i), xmm0);
292 __ movq(rcx, Operand(rsp, 3 * kPointerSize));
293 __ movq(rax, Operand(rsp, 2 * kPointerSize));
295 __ movq(rcx,
297 __ CompareRoot(rcx, Heap::kUndefinedValueRootIndex);
299 __ j(equal, &slow_case);
306 __ movq(rbx, FieldOperand(rcx, JSArray::kElementsOffset));
307 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
309 __ j(not_equal, &check_fast_elements);
312 __ ret(3 * kPointerSize);
314 __ bind(&check_fast_elements);
315 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
317 __ j(not_equal, &double_elements);
320 __ ret(3 * kPointerSize);
322 __ bind(&double_elements);
341 __ push(rcx);
342 __ movq(rcx, FieldOperand(rcx, JSArray::kElementsOffset));
343 __ CompareRoot(FieldOperand(rcx, HeapObject::kMapOffset),
345 __ Assert(equal, message);
346 __ pop(rcx);
350 __ ret(3 * kPointerSize);
352 __ bind(&slow_case);
353 __ TailCallRuntime(Runtime::kCreateArrayLiteralShallow, 3, 1);
368 __ movq(rcx, Operand(rsp, 4 * kPointerSize));
369 __ movq(rax, Operand(rsp, 3 * kPointerSize));
371 __ movq(rcx,
373 __ CompareRoot(rcx, Heap::kUndefinedValueRootIndex);
374 __ j(equal, &slow_case);
379 __ movq(rax, FieldOperand(rcx, HeapObject::kMapOffset));
380 __ movzxbq(rax, FieldOperand(rax, Map::kInstanceSizeOffset));
381 __ cmpq(rax, Immediate(size >> kPointerSizeLog2));
382 __ j(not_equal, &slow_case);
386 __ AllocateInNewSpace(size, rax, rbx, rdx, &slow_case, TAG_OBJECT);
388 __ movq(rbx, FieldOperand(rcx, i));
389 __ movq(FieldOperand(rax, i), rbx);
393 __ ret(4 * kPointerSize);
395 __ bind(&slow_case);
396 __ TailCallRuntime(Runtime::kCreateObjectLiteralShallow, 4, 1);
410 __ movq(argument, Operand(rsp, 1 * kPointerSize));
426 __ JumpIfNotSmi(argument, ¬_smi, Label::kNear);
429 __ movq(tos_, argument);
431 __ ret(1 * kPointerSize);
432 __ bind(¬_smi);
435 __ JumpIfSmi(argument, &patch, Label::kNear);
439 __ movq(map, FieldOperand(argument, HeapObject::kMapOffset));
442 __ testb(FieldOperand(map, Map::kBitFieldOffset),
446 __ j(zero, ¬_undetectable, Label::kNear);
447 __ Set(tos_, 0);
448 __ ret(1 * kPointerSize);
449 __ bind(¬_undetectable);
456 __ CmpInstanceType(map, FIRST_SPEC_OBJECT_TYPE);
457 __ j(below, ¬_js_object, Label::kNear);
460 __ Set(tos_, 1);
462 __ ret(1 * kPointerSize);
463 __ bind(¬_js_object);
469 __ CmpInstanceType(map, FIRST_NONSTRING_TYPE);
470 __ j(above_equal, ¬_string, Label::kNear);
471 __ movq(tos_, FieldOperand(argument, String::kLengthOffset));
472 __ ret(1 * kPointerSize); // the string length is OK as the return value
473 __ bind(¬_string);
479 __ CompareRoot(map, Heap::kHeapNumberMapRootIndex);
480 __ j(not_equal, ¬_heap_number, Label::kNear);
481 __ xorps(xmm0, xmm0);
482 __ ucomisd(xmm0, FieldOperand(argument, HeapNumber::kValueOffset));
483 __ j(zero, &false_result, Label::kNear);
486 __ Set(tos_, 1);
488 __ ret(1 * kPointerSize);
489 __ bind(&false_result);
490 __ Set(tos_, 0);
491 __ ret(1 * kPointerSize);
492 __ bind(¬_heap_number);
495 __ bind(&patch);
501 __ PushCallerSaved(save_doubles_);
503 __ PrepareCallCFunction(argument_count);
505 __ LoadAddress(rcx, ExternalReference::isolate_address());
507 __ LoadAddress(rdi, ExternalReference::isolate_address());
511 __ CallCFunction(
514 __ PopCallerSaved(save_doubles_);
515 __ ret(0);
527 __ CompareRoot(argument, value);
528 __ j(not_equal, &different_value, Label::kNear);
531 __ Set(tos_, 0);
535 __ Set(tos_, 1);
537 __ ret(1 * kPointerSize);
538 __ bind(&different_value);
544 __ pop(rcx); // Get return address, operand is now on top of stack.
545 __ Push(Smi::FromInt(tos_.code()));
546 __ Push(Smi::FromInt(types_.ToByte()));
547 __ push(rcx); // Push return address.
550 __ TailCallExternalReference(
612 __ movq(double_value, FieldOperand(source, HeapNumber::kValueOffset));
614 __ xorl(result, result);
615 __ movq(xmm0, double_value); // Save copy in xmm0 in case we need it there.
618 __ lea(double_exponent, Operand(double_value, double_value, times_1, 0));
619 __ shr(double_exponent, Immediate(64 - HeapNumber::kExponentBits));
620 __ subl(double_exponent, Immediate(HeapNumber::kExponentBias));
622 __ cmpl(double_exponent, Immediate(63));
623 __ j(above_equal, &exponent_63_plus, Label::kNear);
625 __ cvttsd2siq(result, xmm0);
626 __ jmp(&done, Label::kNear);
628 __ bind(&exponent_63_plus);
630 __ cmpl(double_exponent, Immediate(83));
633 __ j(above, &done, Label::kNear);
640 __ addq(double_value, double_value); // Move sign bit to carry.
641 __ sbbl(result, result); // And convert carry to -1 in result register.
643 __ addl(double_value, result);
648 __ xorl(double_value, result);
652 __ leal(rcx, Operand(double_exponent, -HeapNumber::kMantissaBits - 1));
653 __ shll_cl(double_value);
654 __ movl(result, double_value);
657 __ xorl(result, double_value);
658 __ leal(rcx, Operand(double_exponent, -HeapNumber::kMantissaBits - 1));
659 __ shll_cl(result);
662 __ bind(&done);
685 __ pop(rcx); // Save return address.
687 __ push(rax); // the operand
688 __ Push(Smi::FromInt(op_));
689 __ Push(Smi::FromInt(mode_));
690 __ Push(Smi::FromInt(operand_type_));
692 __ push(rcx); // Push return address.
696 __ TailCallExternalReference(
719 __ bind(&slow);
727 __ bind(&non_smi);
738 __ JumpIfNotSmi(rax, non_smi, non_smi_near);
739 __ SmiNeg(rax, rax, &done, Label::kNear);
740 __ jmp(slow, slow_near);
741 __ bind(&done);
742 __ ret(0);
749 __ JumpIfNotSmi(rax, non_smi, non_smi_near);
750 __ SmiNot(rax, rax);
751 __ ret(0);
773 __ bind(&non_smi);
775 __ bind(&slow);
777 __ bind(&call_builtin);
786 __ bind(&non_smi);
788 __ bind(&slow);
796 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
798 __ j(not_equal, slow);
802 __ Set(kScratchRegister, 0x01);
803 __ shl(kScratchRegister, Immediate(63));
804 __ xor_(FieldOperand(rax, HeapNumber::kValueOffset), kScratchRegister);
809 __ AllocateHeapNumber(rcx, rbx, &slow_allocate_heapnumber);
810 __ jmp(&heapnumber_allocated);
812 __ bind(&slow_allocate_heapnumber);
815 __ push(rax);
816 __ CallRuntime(Runtime::kNumberAlloc, 0);
817 __ movq(rcx, rax);
818 __ pop(rax);
820 __ bind(&heapnumber_allocated);
824 __ movq(rdx, FieldOperand(rax, HeapNumber::kValueOffset));
825 __ Set(kScratchRegister, 0x01);
826 __ shl(kScratchRegister, Immediate(63));
827 __ xor_(rdx, kScratchRegister); // Flip sign.
828 __ movq(FieldOperand(rcx, HeapNumber::kValueOffset), rdx);
829 __ movq(rax, rcx);
831 __ ret(0);
838 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
840 __ j(not_equal, slow);
846 __ notl(rax);
847 __ Integer32ToSmi(rax, rax);
848 __ ret(0);
870 __ bind(&non_smi);
872 __ bind(&slow);
880 __ bind(&non_smi);
882 __ bind(&slow);
889 __ pop(rcx); // pop return address
890 __ push(rax);
891 __ push(rcx); // push return address
894 __ InvokeBuiltin(Builtins::UNARY_MINUS, JUMP_FUNCTION);
897 __ InvokeBuiltin(Builtins::BIT_NOT, JUMP_FUNCTION);
920 __ pop(rcx); // Save return address.
921 __ push(rdx);
922 __ push(rax);
926 __ Push(Smi::FromInt(MinorKey()));
927 __ Push(Smi::FromInt(op_));
928 __ Push(Smi::FromInt(operands_type_));
930 __ push(rcx); // Push return address.
934 __ TailCallExternalReference(
1020 __ JumpIfNotBothSmi(left, right, ¬_smis);
1024 __ bind(&smi_values);
1030 __ SmiAdd(right, right, left, &use_fp_on_smis); // ADD is commutative.
1034 __ SmiSub(left, left, right, &use_fp_on_smis);
1035 __ movq(rax, left);
1040 __ SmiMul(right, right, left, &use_fp_on_smis); // MUL is commutative.
1047 __ movq(rbx, rax);
1048 __ movq(rcx, rdx);
1049 __ SmiDiv(rax, left, right, &use_fp_on_smis);
1056 __ movq(rbx, rax);
1057 __ movq(rcx, rdx);
1058 __ SmiMod(rax, left, right, &use_fp_on_smis);
1063 __ SmiOrIfSmis(right, right, left, ¬_smis); // BIT_OR is commutative.
1068 __ SmiXor(right, right, left); // BIT_XOR is commutative.
1073 __ SmiAnd(right, right, left); // BIT_AND is commutative.
1077 __ SmiShiftLeft(left, left, right);
1078 __ movq(rax, left);
1082 __ SmiShiftArithmeticRight(left, left, right);
1083 __ movq(rax, left);
1087 __ SmiShiftLogicalRight(left, left, right, &use_fp_on_smis);
1088 __ movq(rax, left);
1096 __ ret(0);
1102 __ bind(&use_fp_on_smis);
1105 __ movq(rdx, rcx);
1106 __ movq(rax, rbx);
1110 __ AllocateHeapNumber(rcx, rbx, slow);
1113 __ SmiToInteger32(left, left);
1114 __ cvtqsi2sd(xmm0, left);
1118 case Token::ADD: __ addsd(xmm0, xmm1); break;
1119 case Token::SUB: __ subsd(xmm0, xmm1); break;
1120 case Token::MUL: __ mulsd(xmm0, xmm1); break;
1121 case Token::DIV: __ divsd(xmm0, xmm1); break;
1125 __ movsd(FieldOperand(rcx, HeapNumber::kValueOffset), xmm0);
1126 __ movq(rax, rcx);
1127 __ ret(0);
1129 __ jmp(&fail);
1138 __ bind(¬_smis);
1142 __ jmp(&smi_values);
1143 __ bind(&fail);
1158 case Token::ADD: __ addsd(xmm0, xmm1); break;
1159 case Token::SUB: __ subsd(xmm0, xmm1); break;
1160 case Token::MUL: __ mulsd(xmm0, xmm1); break;
1161 case Token::DIV: __ divsd(xmm0, xmm1); break;
1165 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
1166 __ ret(0);
1171 __ jmp(allocation_failure);
1182 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
1186 case Token::BIT_OR: __ orl(rax, rcx); break;
1187 case Token::BIT_AND: __ andl(rax, rcx); break;
1188 case Token::BIT_XOR: __ xorl(rax, rcx); break;
1189 case Token::SAR: __ sarl_cl(rax); break;
1190 case Token::SHL: __ shll_cl(rax); break;
1192 __ shrl_cl(rax);
1195 __ testl(rax, rax);
1196 __ j(negative, &non_smi_shr_result);
1203 __ Integer32ToSmi(rax, rax);
1204 __ Ret();
1210 __ bind(&non_smi_shr_result);
1212 __ movl(rbx, rax); // rbx holds result value (uint32 value as int64).
1216 __ AllocateInNewSpace(HeapNumber::kSize,
1224 __ AbortIfNotRootValue(heap_number_map,
1228 __ movq(FieldOperand(rax, HeapObject::kMapOffset),
1230 __ cvtqsi2sd(xmm0, rbx);
1231 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
1232 __ Ret();
1234 __ bind(&allocation_failed);
1237 __ Integer32ToSmi(rax, rcx);
1238 __ Integer32ToSmi(rdx, rbx);
1239 __ jmp(allocation_failure);
1247 __ Abort("Unexpected fall-through in "
1262 __ JumpIfSmi(left, &left_not_string, Label::kNear);
1263 __ CmpObjectType(left, FIRST_NONSTRING_TYPE, rcx);
1264 __ j(above_equal, &left_not_string, Label::kNear);
1267 __ TailCallStub(&string_add_left_stub);
1270 __ bind(&left_not_string);
1271 __ JumpIfSmi(right, &call_runtime, Label::kNear);
1272 __ CmpObjectType(right, FIRST_NONSTRING_TYPE, rcx);
1273 __ j(above_equal, &call_runtime, Label::kNear);
1277 __ TailCallStub(&string_add_right_stub);
1280 __ bind(&call_runtime);
1288 __ InvokeBuiltin(Builtins::ADD, JUMP_FUNCTION);
1291 __ InvokeBuiltin(Builtins::SUB, JUMP_FUNCTION);
1294 __ InvokeBuiltin(Builtins::MUL, JUMP_FUNCTION);
1297 __ InvokeBuiltin(Builtins::DIV, JUMP_FUNCTION);
1300 __ InvokeBuiltin(Builtins::MOD, JUMP_FUNCTION);
1303 __ InvokeBuiltin(Builtins::BIT_OR, JUMP_FUNCTION);
1306 __ InvokeBuiltin(Builtins::BIT_AND, JUMP_FUNCTION);
1309 __ InvokeBuiltin(Builtins::BIT_XOR, JUMP_FUNCTION);
1312 __ InvokeBuiltin(Builtins::SAR, JUMP_FUNCTION);
1315 __ InvokeBuiltin(Builtins::SHL, JUMP_FUNCTION);
1318 __ InvokeBuiltin(Builtins::SHR, JUMP_FUNCTION);
1343 __ bind(&call_runtime);
1371 __ JumpIfSmi(left, &call_runtime);
1372 __ CmpObjectType(left, FIRST_NONSTRING_TYPE, rcx);
1373 __ j(above_equal, &call_runtime);
1376 __ JumpIfSmi(right, &call_runtime);
1377 __ CmpObjectType(right, FIRST_NONSTRING_TYPE, rcx);
1378 __ j(above_equal, &call_runtime);
1382 __ TailCallStub(&string_add_stub);
1384 __ bind(&call_runtime);
1400 __ CompareRoot(rdx, Heap::kUndefinedValueRootIndex);
1401 __ j(not_equal, &check, Label::kNear);
1403 __ xor_(rdx, rdx);
1405 __ LoadRoot(rdx, Heap::kNanValueRootIndex);
1407 __ jmp(&done, Label::kNear);
1408 __ bind(&check);
1409 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1410 __ j(not_equal, &done, Label::kNear);
1412 __ xor_(rax, rax);
1414 __ LoadRoot(rax, Heap::kNanValueRootIndex);
1416 __ bind(&done);
1426 __ bind(¬_number);
1429 __ bind(&gc_required);
1441 __ bind(&call_string_add_or_runtime);
1446 __ bind(&call_runtime);
1459 __ JumpIfNotSmi(rdx, &skip_allocation);
1462 __ AllocateHeapNumber(rbx, rcx, alloc_failure);
1465 __ movq(rdx, rbx);
1466 __ bind(&skip_allocation);
1468 __ movq(rax, rdx);
1474 __ JumpIfNotSmi(rax, &skip_allocation);
1479 __ AllocateHeapNumber(rbx, rcx, alloc_failure);
1482 __ movq(rax, rbx);
1483 __ bind(&skip_allocation);
1491 __ pop(rcx);
1492 __ push(rdx);
1493 __ push(rax);
1494 __ push(rcx);
1519 __ movq(rax, Operand(rsp, kPointerSize));
1520 __ JumpIfNotSmi(rax, &input_not_smi, Label::kNear);
1523 __ SmiToInteger32(rax, rax);
1524 __ subq(rsp, Immediate(kDoubleSize));
1525 __ cvtlsi2sd(xmm1, rax);
1526 __ movsd(Operand(rsp, 0), xmm1);
1527 __ movq(rbx, xmm1);
1528 __ movq(rdx, xmm1);
1529 __ fld_d(Operand(rsp, 0));
1530 __ addq(rsp, Immediate(kDoubleSize));
1531 __ jmp(&loaded, Label::kNear);
1533 __ bind(&input_not_smi);
1535 __ LoadRoot(rbx, Heap::kHeapNumberMapRootIndex);
1536 __ cmpq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
1537 __ j(not_equal, &runtime_call);
1540 __ fld_d(FieldOperand(rax, HeapNumber::kValueOffset));
1541 __ movq(rbx, FieldOperand(rax, HeapNumber::kValueOffset));
1542 __ movq(rdx, rbx);
1544 __ bind(&loaded);
1546 __ movq(rbx, xmm1);
1547 __ movq(rdx, xmm1);
1559 __ sar(rdx, Immediate(32));
1560 __ xorl(rdx, rbx);
1561 __ movl(rcx, rdx);
1562 __ movl(rax, rdx);
1563 __ movl(rdi, rdx);
1564 __ sarl(rdx, Immediate(8));
1565 __ sarl(rcx, Immediate(16));
1566 __ sarl(rax, Immediate(24));
1567 __ xorl(rcx, rdx);
1568 __ xorl(rax, rdi);
1569 __ xorl(rcx, rax);
1571 __ andl(rcx, Immediate(TranscendentalCache::SubCache::kCacheSize - 1));
1578 __ movq(rax, cache_array);
1581 __ movq(rax, Operand(rax, cache_array_index));
1584 __ testq(rax, rax);
1585 __ j(zero, &runtime_call_clear_stack); // Only clears stack if TAGGED.
1603 __ addl(rcx, rcx);
1604 __ lea(rcx, Operand(rax, rcx, times_8, 0));
1607 __ cmpq(rbx, Operand(rcx, 0));
1608 __ j(not_equal, &cache_miss, Label::kNear);
1611 __ IncrementCounter(counters->transcendental_cache_hit(), 1);
1612 __ movq(rax, Operand(rcx, 2 * kIntSize));
1614 __ fstp(0); // Clear FPU stack.
1615 __ ret(kPointerSize);
1617 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1618 __ Ret();
1621 __ bind(&cache_miss);
1622 __ IncrementCounter(counters->transcendental_cache_miss(), 1);
1625 __ AllocateHeapNumber(rax, rdi, &runtime_call_clear_stack);
1627 __ AllocateHeapNumber(rax, rdi, &skip_cache);
1628 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm1);
1629 __ fld_d(FieldOperand(rax, HeapNumber::kValueOffset));
1632 __ movq(Operand(rcx, 0), rbx);
1633 __ movq(Operand(rcx, 2 * kIntSize), rax);
1634 __ fstp_d(FieldOperand(rax, HeapNumber::kValueOffset));
1636 __ ret(kPointerSize);
1638 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1639 __ Ret();
1642 __ bind(&skip_cache);
1643 __ subq(rsp, Immediate(kDoubleSize));
1644 __ movsd(Operand(rsp, 0), xmm1);
1645 __ fld_d(Operand(rsp, 0));
1647 __ fstp_d(Operand(rsp, 0));
1648 __ movsd(xmm1, Operand(rsp, 0));
1649 __ addq(rsp, Immediate(kDoubleSize));
1655 __ Push(Smi::FromInt(2 * kDoubleSize));
1656 __ CallRuntimeSaveDoubles(Runtime::kAllocateInNewSpace);
1658 __ Ret();
1663 __ bind(&runtime_call_clear_stack);
1664 __ fstp(0);
1665 __ bind(&runtime_call);
1666 __ TailCallExternalReference(
1669 __ bind(&runtime_call_clear_stack);
1670 __ bind(&runtime_call);
1671 __ AllocateHeapNumber(rax, rdi, &skip_cache);
1672 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm1);
1675 __ push(rax);
1676 __ CallRuntime(RuntimeFunction(), 1);
1678 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1679 __ Ret();
1715 __ movq(rdi, rbx);
1717 __ shr(rdi, Immediate(HeapNumber::kMantissaBits));
1719 __ andl(rdi, Immediate((1 << HeapNumber::kExponentBits) - 1));
1721 __ cmpl(rdi, Immediate(supported_exponent_limit));
1722 __ j(below, &in_range);
1724 __ cmpl(rdi, Immediate(0x7ff));
1726 __ j(not_equal, &non_nan_result, Label::kNear);
1728 __ fstp(0);
1730 __ subq(rsp, Immediate(kPointerSize));
1731 __ movl(Operand(rsp, 4), Immediate(0x7ff80000));
1732 __ movl(Operand(rsp, 0), Immediate(0x00000000));
1733 __ fld_d(Operand(rsp, 0));
1734 __ addq(rsp, Immediate(kPointerSize));
1735 __ jmp(&done);
1737 __ bind(&non_nan_result);
1740 __ movq(rdi, rax); // Save rax before using fnstsw_ax.
1741 __ fldpi();
1742 __ fadd(0);
1743 __ fld(1);
1747 __ fwait();
1748 __ fnstsw_ax();
1750 __ testl(rax, Immediate(5)); // #IO and #ZD flags of FPU status word.
1751 __ j(zero, &no_exceptions);
1752 __ fnclex();
1753 __ bind(&no_exceptions);
1759 __ bind(&partial_remainder_loop);
1760 __ fprem1();
1761 __ fwait();
1762 __ fnstsw_ax();
1763 __ testl(rax, Immediate(0x400)); // Check C2 bit of FPU status word.
1766 __ j(not_zero, &partial_remainder_loop);
1769 __ fstp(2);
1771 __ fstp(0);
1773 __ movq(rax, rdi); // Restore rax, pointer to the new HeapNumber.
1774 __ bind(&in_range);
1777 __ fsin();
1780 __ fcos();
1785 __ fptan();
1786 __ fstp(0); // Pop FP register stack.
1791 __ bind(&done);
1794 __ fldln2();
1795 __ fxch();
1796 __ fyl2x();
1810 __ JumpIfNotSmi(rdx, &rdx_is_object);
1811 __ SmiToInteger32(rdx, rdx);
1812 __ JumpIfSmi(rax, &rax_is_smi);
1814 __ bind(&rax_is_object);
1816 __ jmp(&done);
1818 __ bind(&rdx_is_object);
1820 __ JumpIfNotSmi(rax, &rax_is_object);
1821 __ bind(&rax_is_smi);
1822 __ SmiToInteger32(rcx, rax);
1824 __ bind(&done);
1825 __ movl(rax, rdx);
1840 __ JumpIfNotSmi(rdx, &arg1_is_object);
1841 __ SmiToInteger32(r8, rdx);
1842 __ jmp(&load_arg2);
1845 __ bind(&check_undefined_arg1);
1846 __ CompareRoot(rdx, Heap::kUndefinedValueRootIndex);
1847 __ j(not_equal, conversion_failure);
1848 __ Set(r8, 0);
1849 __ jmp(&load_arg2);
1851 __ bind(&arg1_is_object);
1852 __ cmpq(FieldOperand(rdx, HeapObject::kMapOffset), heap_number_map);
1853 __ j(not_equal, &check_undefined_arg1);
1858 __ bind(&load_arg2);
1860 __ JumpIfNotSmi(rax, &arg2_is_object);
1861 __ SmiToInteger32(rcx, rax);
1862 __ jmp(&done);
1865 __ bind(&check_undefined_arg2);
1866 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1867 __ j(not_equal, conversion_failure);
1868 __ Set(rcx, 0);
1869 __ jmp(&done);
1871 __ bind(&arg2_is_object);
1872 __ cmpq(FieldOperand(rax, HeapObject::kMapOffset), heap_number_map);
1873 __ j(not_equal, &check_undefined_arg2);
1876 __ bind(&done);
1877 __ movl(rax, r8);
1882 __ SmiToInteger32(kScratchRegister, rdx);
1883 __ cvtlsi2sd(xmm0, kScratchRegister);
1884 __ SmiToInteger32(kScratchRegister, rax);
1885 __ cvtlsi2sd(xmm1, kScratchRegister);
1892 __ JumpIfSmi(rdx, &load_smi_rdx);
1893 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
1895 __ JumpIfSmi(rax, &load_smi_rax);
1896 __ bind(&load_nonsmi_rax);
1897 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1898 __ jmp(&done);
1900 __ bind(&load_smi_rdx);
1901 __ SmiToInteger32(kScratchRegister, rdx);
1902 __ cvtlsi2sd(xmm0, kScratchRegister);
1903 __ JumpIfNotSmi(rax, &load_nonsmi_rax);
1905 __ bind(&load_smi_rax);
1906 __ SmiToInteger32(kScratchRegister, rax);
1907 __ cvtlsi2sd(xmm1, kScratchRegister);
1909 __ bind(&done);
1917 __ LoadRoot(rcx, Heap::kHeapNumberMapRootIndex);
1918 __ JumpIfSmi(rdx, &load_smi_rdx);
1919 __ cmpq(FieldOperand(rdx, HeapObject::kMapOffset), rcx);
1920 __ j(not_equal, not_numbers); // Argument in rdx is not a number.
1921 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
1923 __ JumpIfSmi(rax, &load_smi_rax);
1925 __ bind(&load_nonsmi_rax);
1926 __ cmpq(FieldOperand(rax, HeapObject::kMapOffset), rcx);
1927 __ j(not_equal, not_numbers);
1928 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1929 __ jmp(&done);
1931 __ bind(&load_smi_rdx);
1932 __ SmiToInteger32(kScratchRegister, rdx);
1933 __ cvtlsi2sd(xmm0, kScratchRegister);
1934 __ JumpIfNotSmi(rax, &load_nonsmi_rax);
1936 __ bind(&load_smi_rax);
1937 __ SmiToInteger32(kScratchRegister, rax);
1938 __ cvtlsi2sd(xmm1, kScratchRegister);
1939 __ bind(&done);
1955 __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
1958 __ JumpIfSmi(first, &first_smi, Label::kNear);
1959 __ cmpq(FieldOperand(first, HeapObject::kMapOffset), heap_number_map);
1960 __ j(not_equal, on_not_smis);
1962 __ movsd(xmm0, FieldOperand(first, HeapNumber::kValueOffset));
1963 __ movq(scratch2, xmm0);
1964 __ cvttsd2siq(smi_result, xmm0);
1967 __ cvtlsi2sd(xmm1, smi_result);
1968 __ movq(kScratchRegister, xmm1);
1969 __ cmpq(scratch2, kScratchRegister);
1970 __ j(not_equal, on_not_smis);
1971 __ Integer32ToSmi(first, smi_result);
1973 __ JumpIfSmi(second, (on_success != NULL) ? on_success : &done);
1974 __ bind(&first_smi);
1977 __ AbortIfSmi(second);
1979 __ cmpq(FieldOperand(second, HeapObject::kMapOffset), heap_number_map);
1980 __ j(not_equal, on_not_smis);
1982 __ movsd(xmm0, FieldOperand(second, HeapNumber::kValueOffset));
1983 __ movq(scratch2, xmm0);
1984 __ cvttsd2siq(smi_result, xmm0);
1985 __ cvtlsi2sd(xmm1, smi_result);
1986 __ movq(kScratchRegister, xmm1);
1987 __ cmpq(scratch2, kScratchRegister);
1988 __ j(not_equal, on_not_smis);
1989 __ Integer32ToSmi(second, smi_result);
1991 __ jmp(on_success);
1993 __ bind(&done);
2015 __ movq(scratch, Immediate(1));
2016 __ cvtlsi2sd(double_result, scratch);
2023 __ movq(base, Operand(rsp, 2 * kPointerSize));
2024 __ movq(exponent, Operand(rsp, 1 * kPointerSize));
2025 __ JumpIfSmi(base, &base_is_smi, Label::kNear);
2026 __ CompareRoot(FieldOperand(base, HeapObject::kMapOffset),
2028 __ j(not_equal, &call_runtime);
2030 __ movsd(double_base, FieldOperand(base, HeapNumber::kValueOffset));
2031 __ jmp(&unpack_exponent, Label::kNear);
2033 __ bind(&base_is_smi);
2034 __ SmiToInteger32(base, base);
2035 __ cvtlsi2sd(double_base, base);
2036 __ bind(&unpack_exponent);
2038 __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
2039 __ SmiToInteger32(exponent, exponent);
2040 __ jmp(&int_exponent);
2042 __ bind(&exponent_not_smi);
2043 __ CompareRoot(FieldOperand(exponent, HeapObject::kMapOffset),
2045 __ j(not_equal, &call_runtime);
2046 __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
2048 __ JumpIfNotSmi(exponent, &exponent_not_smi, Label::kNear);
2049 __ SmiToInteger32(exponent, exponent);
2050 __ jmp(&int_exponent);
2052 __ bind(&exponent_not_smi);
2053 __ movsd(double_exponent, FieldOperand(exponent, HeapNumber::kValueOffset));
2059 __ cvttsd2si(exponent, double_exponent);
2061 __ cmpl(exponent, Immediate(0x80000000u));
2062 __ j(equal, &call_runtime);
2063 __ cvtlsi2sd(double_scratch, exponent);
2065 __ ucomisd(double_exponent, double_scratch);
2066 __ j(equal, &int_exponent);
2075 __ movq(scratch, V8_UINT64_C(0x3FE0000000000000), RelocInfo::NONE);
2076 __ movq(double_scratch, scratch);
2078 __ ucomisd(double_scratch, double_exponent);
2079 __ j(not_equal, ¬_plus_half, Label::kNear);
2085 __ movq(scratch, V8_UINT64_C(0xFFF0000000000000), RelocInfo::NONE);
2086 __ movq(double_scratch, scratch);
2087 __ ucomisd(double_scratch, double_base);
2090 __ j(not_equal, &continue_sqrt, Label::kNear);
2091 __ j(carry, &continue_sqrt, Label::kNear);
2094 __ xorps(double_result, double_result);
2095 __ subsd(double_result, double_scratch);
2096 __ jmp(&done);
2098 __ bind(&continue_sqrt);
2100 __ xorps(double_scratch, double_scratch);
2101 __ addsd(double_scratch, double_base); // Convert -0 to 0.
2102 __ sqrtsd(double_result, double_scratch);
2103 __ jmp(&done);
2106 __ bind(¬_plus_half);
2108 __ subsd(double_scratch, double_result);
2110 __ ucomisd(double_scratch, double_exponent);
2111 __ j(not_equal, &fast_power, Label::kNear);
2117 __ movq(scratch, V8_UINT64_C(0xFFF0000000000000), RelocInfo::NONE);
2118 __ movq(double_scratch, scratch);
2119 __ ucomisd(double_scratch, double_base);
2122 __ j(not_equal, &continue_rsqrt, Label::kNear);
2123 __ j(carry, &continue_rsqrt, Label::kNear);
2126 __ xorps(double_result, double_result);
2127 __ jmp(&done);
2129 __ bind(&continue_rsqrt);
2131 __ xorps(double_exponent, double_exponent);
2132 __ addsd(double_exponent, double_base); // Convert -0 to +0.
2133 __ sqrtsd(double_exponent, double_exponent);
2134 __ divsd(double_result, double_exponent);
2135 __ jmp(&done);
2140 __ bind(&fast_power);
2141 __ fnclex(); // Clear flags to catch exceptions later.
2143 __ subq(rsp, Immediate(kDoubleSize));
2144 __ movsd(Operand(rsp, 0), double_exponent);
2145 __ fld_d(Operand(rsp, 0)); // E
2146 __ movsd(Operand(rsp, 0), double_base);
2147 __ fld_d(Operand(rsp, 0)); // B, E
2152 __ fyl2x(); // X
2153 __ fld(0); // X, X
2154 __ frndint(); // rnd(X), X
2155 __ fsub(1); // rnd(X), X-rnd(X)
2156 __ fxch(1); // X - rnd(X), rnd(X)
2158 __ f2xm1(); // 2^(X-rnd(X)) - 1, rnd(X)
2159 __ fld1(); // 1, 2^(X-rnd(X)) - 1, rnd(X)
2160 __ faddp(1); // 1, 2^(X-rnd(X)), rnd(X)
2162 __ fscale(); // 2^X, rnd(X)
2163 __ fstp(1);
2165 __ fnstsw_ax();
2166 __ testb(rax, Immediate(0x5F)); // Check for all but precision exception.
2167 __ j(not_zero, &fast_power_failed, Label::kNear);
2168 __ fstp_d(Operand(rsp, 0));
2169 __ movsd(double_result, Operand(rsp, 0));
2170 __ addq(rsp, Immediate(kDoubleSize));
2171 __ jmp(&done);
2173 __ bind(&fast_power_failed);
2174 __ fninit();
2175 __ addq(rsp, Immediate(kDoubleSize));
2176 __ jmp(&call_runtime);
2180 __ bind(&int_exponent);
2183 __ movq(scratch, exponent); // Back up exponent.
2184 __ movsd(double_scratch, double_base); // Back up base.
2185 __ movsd(double_scratch2, double_result); // Load double_exponent with 1.
2189 __ testl(scratch, scratch);
2190 __ j(positive, &no_neg, Label::kNear);
2191 __ negl(scratch);
2192 __ bind(&no_neg);
2194 __ bind(&while_true);
2195 __ shrl(scratch, Immediate(1));
2196 __ j(not_carry, &no_multiply, Label::kNear);
2197 __ mulsd(double_result, double_scratch);
2198 __ bind(&no_multiply);
2200 __ mulsd(double_scratch, double_scratch);
2201 __ j(not_zero, &while_true);
2204 __ testl(exponent, exponent);
2205 __ j(greater, &done);
2206 __ divsd(double_scratch2, double_result);
2207 __ movsd(double_result, double_scratch2);
2210 __ xorps(double_scratch2, double_scratch2);
2211 __ ucomisd(double_scratch2, double_result);
2215 __ j(not_equal, &done);
2216 __ cvtlsi2sd(double_exponent, exponent);
2222 __ bind(&call_runtime);
2223 __ TailCallRuntime(Runtime::kMath_pow_cfunction, 2, 1);
2227 __ bind(&done);
2228 __ AllocateHeapNumber(rax, rcx, &call_runtime);
2229 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), double_result);
2230 __ IncrementCounter(counters->math_pow(), 1);
2231 __ ret(2 * kPointerSize);
2233 __ bind(&call_runtime);
2235 __ movsd(xmm0, double_base);
2239 __ PrepareCallCFunction(2);
2240 __ CallCFunction(
2244 __ movsd(double_result, xmm0);
2246 __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
2248 __ bind(&done);
2249 __ IncrementCounter(counters->math_pow(), 1);
2250 __ ret(0);
2265 __ JumpIfNotSmi(rdx, &slow);
2272 __ movq(rbx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2273 __ Cmp(Operand(rbx, StandardFrameConstants::kContextOffset),
2275 __ j(equal, &adaptor);
2280 __ cmpq(rdx, rax);
2281 __ j(above_equal, &slow);
2285 __ lea(rbx, Operand(rbp, index.reg, index.scale, 0));
2287 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2288 __ Ret();
2293 __ bind(&adaptor);
2294 __ movq(rcx, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2295 __ cmpq(rdx, rcx);
2296 __ j(above_equal, &slow);
2300 __ lea(rbx, Operand(rbx, index.reg, index.scale, 0));
2302 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2303 __ Ret();
2307 __ bind(&slow);
2308 __ pop(rbx); // Return address.
2309 __ push(rdx);
2310 __ push(rbx);
2311 __ TailCallRuntime(Runtime::kGetArgumentsProperty, 1, 1);
2327 __ SmiToInteger64(rbx, Operand(rsp, 1 * kPointerSize));
2333 __ movq(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2334 __ movq(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
2335 __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
2336 __ j(equal, &adaptor_frame);
2339 __ movq(rcx, rbx);
2340 __ jmp(&try_allocate, Label::kNear);
2343 __ bind(&adaptor_frame);
2344 __ SmiToInteger64(rcx,
2347 __ lea(rdx, Operand(rdx, rcx, times_pointer_size,
2349 __ movq(Operand(rsp, 2 * kPointerSize), rdx);
2354 __ cmpq(rbx, rcx);
2355 __ j(less_equal, &try_allocate, Label::kNear);
2356 __ movq(rbx, rcx);
2358 __ bind(&try_allocate);
2365 __ xor_(r8, r8);
2366 __ testq(rbx, rbx);
2367 __ j(zero, &no_parameter_map, Label::kNear);
2368 __ lea(r8, Operand(rbx, times_pointer_size, kParameterMapHeaderSize));
2369 __ bind(&no_parameter_map);
2372 __ lea(r8, Operand(r8, rcx, times_pointer_size, FixedArray::kHeaderSize));
2375 __ addq(r8, Immediate(Heap::kArgumentsObjectSize));
2378 __ AllocateInNewSpace(r8, rax, rdx, rdi, &runtime, TAG_OBJECT);
2384 __ movq(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX)));
2385 __ movq(rdi, FieldOperand(rdi, GlobalObject::kGlobalContextOffset));
2386 __ testq(rbx, rbx);
2387 __ j(not_zero, &has_mapped_parameters, Label::kNear);
2390 __ movq(rdi, Operand(rdi, Context::SlotOffset(kIndex)));
2391 __ jmp(©, Label::kNear);
2394 __ bind(&has_mapped_parameters);
2395 __ movq(rdi, Operand(rdi, Context::SlotOffset(kAliasedIndex)));
2396 __ bind(©);
2404 __ movq(rdx, FieldOperand(rdi, i));
2405 __ movq(FieldOperand(rax, i), rdx);
2410 __ movq(rdx, Operand(rsp, 3 * kPointerSize));
2411 __ movq(FieldOperand(rax, JSObject::kHeaderSize +
2418 __ Integer32ToSmi(rcx, rcx);
2419 __ movq(FieldOperand(rax, JSObject::kHeaderSize +
2426 __ lea(rdi, Operand(rax, Heap::kArgumentsObjectSize));
2427 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rdi);
2436 __ testq(rbx, rbx);
2437 __ j(zero, &skip_parameter_map);
2439 __ LoadRoot(kScratchRegister, Heap::kNonStrictArgumentsElementsMapRootIndex);
2441 __ movq(FieldOperand(rdi, FixedArray::kMapOffset), kScratchRegister);
2442 __ Integer64PlusConstantToSmi(r9, rbx, 2);
2443 __ movq(FieldOperand(rdi, FixedArray::kLengthOffset), r9);
2444 __ movq(FieldOperand(rdi, FixedArray::kHeaderSize + 0 * kPointerSize), rsi);
2445 __ lea(r9, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
2446 __ movq(FieldOperand(rdi, FixedArray::kHeaderSize + 1 * kPointerSize), r9);
2459 __ Integer32ToSmi(r9, rbx);
2460 __ Move(r8, Smi::FromInt(Context::MIN_CONTEXT_SLOTS));
2461 __ addq(r8, Operand(rsp, 1 * kPointerSize));
2462 __ subq(r8, r9);
2463 __ Move(r11, factory->the_hole_value());
2464 __ movq(rdx, rdi);
2465 __ lea(rdi, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
2471 __ jmp(¶meters_test, Label::kNear);
2473 __ bind(¶meters_loop);
2474 __ SmiSubConstant(r9, r9, Smi::FromInt(1));
2475 __ SmiToInteger64(kScratchRegister, r9);
2476 __ movq(FieldOperand(rdx, kScratchRegister,
2480 __ movq(FieldOperand(rdi, kScratchRegister,
2484 __ SmiAddConstant(r8, r8, Smi::FromInt(1));
2485 __ bind(¶meters_test);
2486 __ SmiTest(r9);
2487 __ j(not_zero, ¶meters_loop, Label::kNear);
2489 __ bind(&skip_parameter_map);
2494 __ Move(FieldOperand(rdi, FixedArray::kMapOffset),
2496 __ movq(FieldOperand(rdi, FixedArray::kLengthOffset), rcx);
2499 __ movq(r8, rbx);
2500 __ movq(rdx, Operand(rsp, 2 * kPointerSize));
2502 __ SmiToInteger64(rcx, rcx);
2503 __ lea(kScratchRegister, Operand(r8, times_pointer_size, 0));
2504 __ subq(rdx, kScratchRegister);
2505 __ jmp(&arguments_test, Label::kNear);
2507 __ bind(&arguments_loop);
2508 __ subq(rdx, Immediate(kPointerSize));
2509 __ movq(r9, Operand(rdx, 0));
2510 __ movq(FieldOperand(rdi, r8,
2514 __ addq(r8, Immediate(1));
2516 __ bind(&arguments_test);
2517 __ cmpq(r8, rcx);
2518 __ j(less, &arguments_loop, Label::kNear);
2521 __ ret(3 * kPointerSize);
2525 __ bind(&runtime);
2526 __ Integer32ToSmi(rcx, rcx);
2527 __ movq(Operand(rsp, 1 * kPointerSize), rcx); // Patch argument count.
2528 __ TailCallRuntime(Runtime::kNewStrictArgumentsFast, 3, 1);
2540 __ movq(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2541 __ movq(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
2542 __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
2543 __ j(not_equal, &runtime);
2546 __ movq(rcx, Operand(rdx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2547 __ movq(Operand(rsp, 1 * kPointerSize), rcx);
2548 __ SmiToInteger64(rcx, rcx);
2549 __ lea(rdx, Operand(rdx, rcx, times_pointer_size,
2551 __ movq(Operand(rsp, 2 * kPointerSize), rdx);
2553 __ bind(&runtime);
2554 __ TailCallRuntime(Runtime::kNewArgumentsFast, 3, 1);
2566 __ movq(rdx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2567 __ movq(rcx, Operand(rdx, StandardFrameConstants::kContextOffset));
2568 __ Cmp(rcx, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR));
2569 __ j(equal, &adaptor_frame);
2572 __ movq(rcx, Operand(rsp, 1 * kPointerSize));
2573 __ SmiToInteger64(rcx, rcx);
2574 __ jmp(&try_allocate);
2577 __ bind(&adaptor_frame);
2578 __ movq(rcx, Operand(rdx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2579 __ movq(Operand(rsp, 1 * kPointerSize), rcx);
2580 __ SmiToInteger64(rcx, rcx);
2581 __ lea(rdx, Operand(rdx, rcx, times_pointer_size,
2583 __ movq(Operand(rsp, 2 * kPointerSize), rdx);
2588 __ bind(&try_allocate);
2589 __ testq(rcx, rcx);
2590 __ j(zero, &add_arguments_object, Label::kNear);
2591 __ lea(rcx, Operand(rcx, times_pointer_size, FixedArray::kHeaderSize));
2592 __ bind(&add_arguments_object);
2593 __ addq(rcx, Immediate(Heap::kArgumentsObjectSizeStrict));
2596 __ AllocateInNewSpace(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT);
2599 __ movq(rdi, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX)));
2600 __ movq(rdi, FieldOperand(rdi, GlobalObject::kGlobalContextOffset));
2603 __ movq(rdi, Operand(rdi, offset));
2607 __ movq(rbx, FieldOperand(rdi, i));
2608 __ movq(FieldOperand(rax, i), rbx);
2613 __ movq(rcx, Operand(rsp, 1 * kPointerSize));
2614 __ movq(FieldOperand(rax, JSObject::kHeaderSize +
2620 __ testq(rcx, rcx);
2621 __ j(zero, &done);
2624 __ movq(rdx, Operand(rsp, 2 * kPointerSize));
2628 __ lea(rdi, Operand(rax, Heap::kArgumentsObjectSizeStrict));
2629 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rdi);
2630 __ LoadRoot(kScratchRegister, Heap::kFixedArrayMapRootIndex);
2631 __ movq(FieldOperand(rdi, FixedArray::kMapOffset), kScratchRegister);
2634 __ movq(FieldOperand(rdi, FixedArray::kLengthOffset), rcx);
2636 __ SmiToInteger64(rcx, rcx);
2640 __ bind(&loop);
2641 __ movq(rbx, Operand(rdx, -1 * kPointerSize)); // Skip receiver.
2642 __ movq(FieldOperand(rdi, FixedArray::kHeaderSize), rbx);
2643 __ addq(rdi, Immediate(kPointerSize));
2644 __ subq(rdx, Immediate(kPointerSize));
2645 __ decq(rcx);
2646 __ j(not_zero, &loop);
2649 __ bind(&done);
2650 __ ret(3 * kPointerSize);
2653 __ bind(&runtime);
2654 __ TailCallRuntime(Runtime::kNewStrictArgumentsFast, 3, 1);
2663 __ TailCallRuntime(Runtime::kRegExpExec, 4, 1);
2685 __ Load(kScratchRegister, address_of_regexp_stack_memory_size);
2686 __ testq(kScratchRegister, kScratchRegister);
2687 __ j(zero, &runtime);
2690 __ movq(rax, Operand(rsp, kJSRegExpOffset));
2691 __ JumpIfSmi(rax, &runtime);
2692 __ CmpObjectType(rax, JS_REGEXP_TYPE, kScratchRegister);
2693 __ j(not_equal, &runtime);
2695 __ movq(rax, FieldOperand(rax, JSRegExp::kDataOffset));
2698 __ Check(NegateCondition(is_smi),
2700 __ CmpObjectType(rax, FIXED_ARRAY_TYPE, kScratchRegister);
2701 __ Check(equal, "Unexpected type for RegExp data, FixedArray expected");
2706 __ SmiToInteger32(rbx, FieldOperand(rax, JSRegExp::kDataTagOffset));
2707 __ cmpl(rbx, Immediate(JSRegExp::IRREGEXP));
2708 __ j(not_equal, &runtime);
2712 __ SmiToInteger32(rdx,
2715 __ leal(rdx, Operand(rdx, rdx, times_1, 2));
2717 __ cmpl(rdx, Immediate(OffsetsVector::kStaticOffsetsVectorSize));
2718 __ j(above, &runtime);
2723 __ movq(rdi, Operand(rsp, kSubjectOffset));
2724 __ JumpIfSmi(rdi, &runtime);
2726 __ j(NegateCondition(is_string), &runtime);
2733 __ movq(rbx, Operand(rsp, kPreviousIndexOffset));
2734 __ JumpIfNotSmi(rbx, &runtime);
2735 __ SmiCompare(rbx, FieldOperand(rdi, String::kLengthOffset));
2736 __ j(above_equal, &runtime);
2741 __ movq(rdi, Operand(rsp, kLastMatchInfoOffset));
2742 __ JumpIfSmi(rdi, &runtime);
2743 __ CmpObjectType(rdi, JS_ARRAY_TYPE, kScratchRegister);
2744 __ j(not_equal, &runtime);
2746 __ movq(rbx, FieldOperand(rdi, JSArray::kElementsOffset));
2747 __ movq(rdi, FieldOperand(rbx, HeapObject::kMapOffset));
2748 __ CompareRoot(FieldOperand(rbx, HeapObject::kMapOffset),
2750 __ j(not_equal, &runtime);
2754 __ SmiToInteger32(rdi, FieldOperand(rbx, FixedArray::kLengthOffset));
2755 __ addl(rdx, Immediate(RegExpImpl::kLastMatchOverhead));
2756 __ cmpl(rdx, rdi);
2757 __ j(greater, &runtime);
2760 __ Set(r14, 0);
2764 __ movq(rdi, Operand(rsp, kSubjectOffset));
2766 __ movq(r15, rdi);
2767 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2768 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2770 __ andb(rbx, Immediate(kIsNotStringMask |
2775 __ j(zero, &seq_two_byte_string, Label::kNear);
2779 __ andb(rbx, Immediate(kIsNotStringMask |
2782 __ j(zero, &seq_ascii_string, Label::kNear);
2796 __ cmpq(rbx, Immediate(kExternalStringTag));
2797 __ j(less, &cons_string, Label::kNear);
2798 __ j(equal, &external_string);
2802 __ testb(rbx, Immediate(kIsNotStringMask | kShortExternalStringMask));
2803 __ j(not_zero, &runtime);
2806 __ SmiToInteger32(r14, FieldOperand(rdi, SlicedString::kOffsetOffset));
2807 __ movq(rdi, FieldOperand(rdi, SlicedString::kParentOffset));
2811 __ jmp(&check_encoding, Label::kNear);
2813 __ bind(&cons_string);
2814 __ CompareRoot(FieldOperand(rdi, ConsString::kSecondOffset),
2816 __ j(not_equal, &runtime);
2817 __ movq(rdi, FieldOperand(rdi, ConsString::kFirstOffset));
2821 __ bind(&check_encoding);
2822 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2823 __ testb(FieldOperand(rbx, Map::kInstanceTypeOffset),
2826 __ j(zero, &seq_two_byte_string, Label::kNear);
2828 __ testb(FieldOperand(rbx, Map::kInstanceTypeOffset),
2830 __ j(not_zero, &external_string);
2832 __ bind(&seq_ascii_string);
2835 __ movq(r11, FieldOperand(rax, JSRegExp::kDataAsciiCodeOffset));
2836 __ Set(rcx, 1); // Type is ASCII.
2837 __ jmp(&check_code, Label::kNear);
2839 __ bind(&seq_two_byte_string);
2842 __ movq(r11, FieldOperand(rax, JSRegExp::kDataUC16CodeOffset));
2843 __ Set(rcx, 0); // Type is two byte.
2845 __ bind(&check_code);
2849 __ JumpIfSmi(r11, &runtime);
2856 __ SmiToInteger64(rbx, Operand(rsp, kPreviousIndexOffset));
2864 __ IncrementCounter(counters->regexp_entry_native(), 1);
2870 __ EnterApiExitFrame(argument_slots_on_stack);
2873 // __ movq(Operand(rsp, (argument_slots_on_stack - 1) * kPointerSize),
2875 __ LoadAddress(kScratchRegister, ExternalReference::isolate_address());
2876 __ movq(Operand(rsp, (argument_slots_on_stack - 1) * kPointerSize),
2880 __ movq(Operand(rsp, (argument_slots_on_stack - 2) * kPointerSize),
2884 __ movq(kScratchRegister, address_of_regexp_stack_memory_address);
2885 __ movq(r9, Operand(kScratchRegister, 0));
2886 __ movq(kScratchRegister, address_of_regexp_stack_memory_size);
2887 __ addq(r9, Operand(kScratchRegister, 0));
2890 __ movq(Operand(rsp, (argument_slots_on_stack - 3) * kPointerSize), r9);
2894 __ LoadAddress(r8,
2898 __ movq(Operand(rsp, (argument_slots_on_stack - 4) * kPointerSize), r8);
2923 __ movq(arg2, rbx);
2930 __ addq(rbx, r14);
2931 __ SmiToInteger32(arg3, FieldOperand(r15, String::kLengthOffset));
2932 __ addq(r14, arg3); // Using arg3 as scratch.
2937 __ testb(rcx, rcx); // Last use of rcx as encoding of subject string.
2938 __ j(zero, &setup_two_byte, Label::kNear);
2939 __ lea(arg4, FieldOperand(rdi, r14, times_1, SeqAsciiString::kHeaderSize));
2940 __ lea(arg3, FieldOperand(rdi, rbx, times_1, SeqAsciiString::kHeaderSize));
2941 __ jmp(&setup_rest, Label::kNear);
2942 __ bind(&setup_two_byte);
2943 __ lea(arg4, FieldOperand(rdi, r14, times_2, SeqTwoByteString::kHeaderSize));
2944 __ lea(arg3, FieldOperand(rdi, rbx, times_2, SeqTwoByteString::kHeaderSize));
2945 __ bind(&setup_rest);
2952 __ movq(arg1, r15);
2955 __ addq(r11, Immediate(Code::kHeaderSize - kHeapObjectTag));
2956 __ call(r11);
2958 __ LeaveApiExitFrame();
2963 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::SUCCESS));
2964 __ j(equal, &success, Label::kNear);
2965 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::EXCEPTION));
2966 __ j(equal, &exception);
2967 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::FAILURE));
2970 __ j(not_equal, &runtime);
2973 __ LoadRoot(rax, Heap::kNullValueRootIndex);
2974 __ ret(4 * kPointerSize);
2977 __ bind(&success);
2978 __ movq(rax, Operand(rsp, kJSRegExpOffset));
2979 __ movq(rcx, FieldOperand(rax, JSRegExp::kDataOffset));
2980 __ SmiToInteger32(rax,
2983 __ leal(rdx, Operand(rax, rax, times_1, 2));
2987 __ movq(rax, Operand(rsp, kLastMatchInfoOffset));
2988 __ movq(rbx, FieldOperand(rax, JSArray::kElementsOffset));
2993 __ Integer32ToSmi(kScratchRegister, rdx);
2994 __ movq(FieldOperand(rbx, RegExpImpl::kLastCaptureCountOffset),
2997 __ movq(rax, Operand(rsp, kSubjectOffset));
2998 __ movq(FieldOperand(rbx, RegExpImpl::kLastSubjectOffset), rax);
2999 __ RecordWriteField(rbx,
3004 __ movq(rax, Operand(rsp, kSubjectOffset));
3005 __ movq(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
3006 __ RecordWriteField(rbx,
3013 __ LoadAddress(rcx,
3022 __ bind(&next_capture);
3023 __ subq(rdx, Immediate(1));
3024 __ j(negative, &done, Label::kNear);
3026 __ movl(rdi, Operand(rcx, rdx, times_int_size, 0));
3027 __ Integer32ToSmi(rdi, rdi);
3029 __ movq(FieldOperand(rbx,
3034 __ jmp(&next_capture);
3035 __ bind(&done);
3038 __ movq(rax, Operand(rsp, kLastMatchInfoOffset));
3039 __ ret(4 * kPointerSize);
3041 __ bind(&exception);
3050 __ movq(rax, pending_exception_operand);
3051 __ LoadRoot(rdx, Heap::kTheHoleValueRootIndex);
3052 __ cmpq(rax, rdx);
3053 __ j(equal, &runtime);
3054 __ movq(pending_exception_operand, rdx);
3056 __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
3058 __ j(equal, &termination_exception, Label::kNear);
3059 __ Throw(rax);
3061 __ bind(&termination_exception);
3062 __ ThrowUncatchable(rax);
3067 __ bind(&external_string);
3068 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
3069 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
3073 __ testb(rbx, Immediate(kIsIndirectStringMask));
3074 __ Assert(zero, "external string expected, but not found");
3076 __ movq(rdi, FieldOperand(rdi, ExternalString::kResourceDataOffset));
3079 __ subq(rdi, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
3081 __ testb(rbx, Immediate(kStringEncodingMask));
3082 __ j(not_zero, &seq_ascii_string);
3083 __ jmp(&seq_two_byte_string);
3086 __ bind(&runtime);
3087 __ TailCallRuntime(Runtime::kRegExpExec, 4, 1);
3096 __ movq(r8, Operand(rsp, kPointerSize * 3));
3097 __ JumpIfNotSmi(r8, &slowcase);
3098 __ SmiToInteger32(rbx, r8);
3099 __ cmpl(rbx, Immediate(kMaxInlineLength));
3100 __ j(above, &slowcase);
3107 __ AllocateInNewSpace(JSRegExpResult::kSize + FixedArray::kHeaderSize,
3120 __ movq(rdx, ContextOperand(rsi, Context::GLOBAL_INDEX));
3121 __ movq(rdx, FieldOperand(rdx, GlobalObject::kGlobalContextOffset));
3122 __ movq(rdx, ContextOperand(rdx, Context::REGEXP_RESULT_MAP_INDEX));
3123 __ movq(FieldOperand(rax, HeapObject::kMapOffset), rdx);
3126 __ LoadRoot(kScratchRegister, Heap::kEmptyFixedArrayRootIndex);
3127 __ movq(FieldOperand(rax, JSObject::kPropertiesOffset), kScratchRegister);
3130 __ lea(rcx, Operand(rax, JSRegExpResult::kSize));
3131 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rcx);
3134 __ movq(r8, Operand(rsp, kPointerSize * 1));
3135 __ movq(FieldOperand(rax, JSRegExpResult::kInputOffset), r8);
3136 __ movq(r8, Operand(rsp, kPointerSize * 2));
3137 __ movq(FieldOperand(rax, JSRegExpResult::kIndexOffset), r8);
3138 __ movq(r8, Operand(rsp, kPointerSize * 3));
3139 __ movq(FieldOperand(rax, JSArray::kLengthOffset), r8);
3147 __ LoadRoot(kScratchRegister, Heap::kFixedArrayMapRootIndex);
3148 __ movq(FieldOperand(rcx, HeapObject::kMapOffset), kScratchRegister);
3150 __ Integer32ToSmi(rdx, rbx);
3151 __ movq(FieldOperand(rcx, FixedArray::kLengthOffset), rdx);
3153 __ LoadRoot(rdx, Heap::kTheHoleValueRootIndex);
3154 __ lea(rcx, FieldOperand(rcx, FixedArray::kHeaderSize));
3161 __ testl(rbx, rbx);
3162 __ bind(&loop);
3163 __ j(less_equal, &done); // Jump if rcx is negative or zero.
3164 __ subl(rbx, Immediate(1));
3165 __ movq(Operand(rcx, rbx, times_pointer_size, 0), rdx);
3166 __ jmp(&loop);
3168 __ bind(&done);
3169 __ ret(3 * kPointerSize);
3171 __ bind(&slowcase);
3172 __ TailCallRuntime(Runtime::kRegExpConstructResult, 3, 1);
3189 __ LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
3193 __ SmiToInteger32(
3195 __ shrl(mask, Immediate(1));
3196 __ subq(mask, Immediate(1)); // Make mask.
3206 __ JumpIfSmi(object, &is_smi);
3207 __ CheckMap(object,
3213 __ movl(scratch, FieldOperand(object, HeapNumber::kValueOffset + 4));
3214 __ xor_(scratch, FieldOperand(object, HeapNumber::kValueOffset));
3219 __ movq(probe,
3224 __ JumpIfSmi(probe, not_found);
3225 __ movsd(xmm0, FieldOperand(object, HeapNumber::kValueOffset));
3226 __ movsd(xmm1, FieldOperand(probe, HeapNumber::kValueOffset));
3227 __ ucomisd(xmm0, xmm1);
3228 __ j(parity_even, not_found); // Bail out if NaN is involved.
3229 __ j(not_equal, not_found); // The cache did not contain this value.
3230 __ jmp(&load_result_from_cache);
3233 __ bind(&is_smi);
3234 __ SmiToInteger32(scratch, object);
3239 __ cmpq(object,
3244 __ j(not_equal, not_found);
3247 __ bind(&load_result_from_cache);
3248 __ movq(result,
3254 __ IncrementCounter(counters->number_to_string_native(), 1);
3261 __ and_(hash, mask);
3266 __ shl(hash, Immediate(kPointerSizeLog2 + 1));
3273 __ movq(rbx, Operand(rsp, kPointerSize));
3277 __ ret(1 * kPointerSize);
3279 __ bind(&runtime);
3281 __ TailCallRuntime(Runtime::kNumberToStringSkipCache, 1, 1);
3302 __ JumpIfNotBothSmi(rax, rdx, &non_smi);
3303 __ subq(rdx, rax);
3304 __ j(no_overflow, &smi_done);
3305 __ not_(rdx); // Correct sign in case of overflow. rdx cannot be 0 here.
3306 __ bind(&smi_done);
3307 __ movq(rax, rdx);
3308 __ ret(0);
3309 __ bind(&non_smi);
3312 __ JumpIfNotSmi(rdx, &ok);
3313 __ JumpIfNotSmi(rax, &ok);
3314 __ Abort("CompareStub: smi operands");
3315 __ bind(&ok);
3326 __ cmpq(rax, rdx);
3327 __ j(not_equal, ¬_identical, Label::kNear);
3333 __ CompareRoot(rdx, Heap::kUndefinedValueRootIndex);
3334 __ j(not_equal, &check_for_nan, Label::kNear);
3335 __ Set(rax, NegativeComparisonResult(cc_));
3336 __ ret(0);
3337 __ bind(&check_for_nan);
3346 __ Set(rax, EQUAL);
3347 __ ret(0);
3351 __ Cmp(FieldOperand(rdx, HeapObject::kMapOffset),
3353 __ j(equal, &heap_number, Label::kNear);
3356 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
3357 __ j(above_equal, ¬_identical, Label::kNear);
3359 __ Set(rax, EQUAL);
3360 __ ret(0);
3362 __ bind(&heap_number);
3367 __ Set(rax, EQUAL);
3368 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
3369 __ ucomisd(xmm0, xmm0);
3370 __ setcc(parity_even, rax);
3373 __ neg(rax);
3375 __ ret(0);
3378 __ bind(¬_identical);
3393 __ SelectNonSmi(rbx, rax, rdx, ¬_smis);
3396 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
3399 __ j(equal, &slow);
3401 __ movq(rax, rbx);
3402 __ ret(0);
3404 __ bind(¬_smis);
3414 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
3415 __ j(below, &first_non_object, Label::kNear);
3419 __ bind(&return_not_equal);
3420 __ ret(0);
3422 __ bind(&first_non_object);
3424 __ CmpInstanceType(rcx, ODDBALL_TYPE);
3425 __ j(equal, &return_not_equal);
3427 __ CmpObjectType(rdx, FIRST_SPEC_OBJECT_TYPE, rcx);
3428 __ j(above_equal, &return_not_equal);
3431 __ CmpInstanceType(rcx, ODDBALL_TYPE);
3432 __ j(equal, &return_not_equal);
3436 __ bind(&slow);
3444 __ xorl(rax, rax);
3445 __ xorl(rcx, rcx);
3446 __ ucomisd(xmm0, xmm1);
3449 __ j(parity_even, &unordered, Label::kNear);
3451 __ setcc(above, rax);
3452 __ setcc(below, rcx);
3453 __ subq(rax, rcx);
3454 __ ret(0);
3458 __ bind(&unordered);
3461 __ Set(rax, 1);
3463 __ Set(rax, -1);
3465 __ ret(0);
3468 __ bind(&non_number_comparison);
3480 __ ret(0);
3483 __ bind(&check_for_strings);
3485 __ JumpIfNotBothSequentialAsciiStrings(
3506 __ Abort("Unexpected fall-through from string comparison");
3509 __ bind(&check_unequal_objects);
3520 __ lea(rcx, Operand(rax, rdx, times_1, 0));
3521 __ testb(rcx, Immediate(kSmiTagMask));
3522 __ j(not_zero, ¬_both_objects, Label::kNear);
3523 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
3524 __ j(below, ¬_both_objects, Label::kNear);
3525 __ CmpObjectType(rdx, FIRST_SPEC_OBJECT_TYPE, rcx);
3526 __ j(below, ¬_both_objects, Label::kNear);
3527 __ testb(FieldOperand(rbx, Map::kBitFieldOffset),
3529 __ j(zero, &return_unequal, Label::kNear);
3530 __ testb(FieldOperand(rcx, Map::kBitFieldOffset),
3532 __ j(zero, &return_unequal, Label::kNear);
3535 __ Set(rax, EQUAL);
3536 __ bind(&return_unequal);
3539 __ ret(0);
3540 __ bind(¬_both_objects);
3544 __ pop(rcx);
3545 __ push(rdx);
3546 __ push(rax);
3554 __ Push(Smi::FromInt(NegativeComparisonResult(cc_)));
3558 __ push(rcx);
3562 __ InvokeBuiltin(builtin, JUMP_FUNCTION);
3570 __ JumpIfSmi(object, label);
3571 __ movq(scratch, FieldOperand(object, HeapObject::kMapOffset));
3572 __ movzxbq(scratch,
3577 __ testb(scratch, Immediate(kIsSymbolMask));
3578 __ j(zero, label);
3583 __ TailCallRuntime(Runtime::kStackGuard, 0, 1);
3588 __ TailCallRuntime(Runtime::kInterrupt, 0, 1);
3602 __ movq(rcx, FieldOperand(rbx, JSGlobalPropertyCell::kValueOffset));
3606 __ cmpq(rcx, rdi);
3607 __ j(equal, &done, Label::kNear);
3608 __ Cmp(rcx, TypeFeedbackCells::MegamorphicSentinel(isolate));
3609 __ j(equal, &done, Label::kNear);
3613 __ Cmp(rcx, TypeFeedbackCells::UninitializedSentinel(isolate));
3614 __ j(equal, &initialize, Label::kNear);
3617 __ Move(FieldOperand(rbx, JSGlobalPropertyCell::kValueOffset),
3619 __ jmp(&done, Label::kNear);
3622 __ bind(&initialize);
3623 __ movq(FieldOperand(rbx, JSGlobalPropertyCell::kValueOffset), rdi);
3626 __ bind(&done);
3642 __ movq(rax, Operand(rsp, (argc_ + 1) * kPointerSize));
3644 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
3645 __ j(not_equal, &call, Label::kNear);
3647 __ movq(rbx, GlobalObjectOperand());
3648 __ movq(rbx, FieldOperand(rbx, GlobalObject::kGlobalReceiverOffset));
3649 __ movq(Operand(rsp, (argc_ + 1) * kPointerSize), rbx);
3650 __ bind(&call);
3654 __ JumpIfSmi(rdi, &non_function);
3656 __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
3657 __ j(not_equal, &slow);
3664 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
3665 __ j(equal, &call_as_function);
3666 __ InvokeFunction(rdi,
3671 __ bind(&call_as_function);
3673 __ InvokeFunction(rdi,
3680 __ bind(&slow);
3682 __ CmpInstanceType(rcx, JS_FUNCTION_PROXY_TYPE);
3683 __ j(not_equal, &non_function);
3684 __ pop(rcx);
3685 __ push(rdi); // put proxy as additional argument under return address
3686 __ push(rcx);
3687 __ Set(rax, argc_ + 1);
3688 __ Set(rbx, 0);
3689 __ SetCallKind(rcx, CALL_AS_METHOD);
3690 __ GetBuiltinEntry(rdx, Builtins::CALL_FUNCTION_PROXY);
3694 __ jmp(adaptor, RelocInfo::CODE_TARGET);
3699 __ bind(&non_function);
3700 __ movq(Operand(rsp, (argc_ + 1) * kPointerSize), rdi);
3701 __ Set(rax, argc_);
3702 __ Set(rbx, 0);
3703 __ SetCallKind(rcx, CALL_AS_METHOD);
3704 __ GetBuiltinEntry(rdx, Builtins::CALL_NON_FUNCTION);
3707 __ Jump(adaptor, RelocInfo::CODE_TARGET);
3718 __ JumpIfSmi(rdi, &non_function_call);
3720 __ CmpObjectType(rdi, JS_FUNCTION_TYPE, rcx);
3721 __ j(not_equal, &slow);
3728 __ movq(rbx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
3729 __ movq(rbx, FieldOperand(rbx, SharedFunctionInfo::kConstructStubOffset));
3730 __ lea(rbx, FieldOperand(rbx, Code::kHeaderSize));
3731 __ jmp(rbx);
3737 __ bind(&slow);
3738 __ CmpInstanceType(rcx, JS_FUNCTION_PROXY_TYPE);
3739 __ j(not_equal, &non_function_call);
3740 __ GetBuiltinEntry(rdx, Builtins::CALL_FUNCTION_PROXY_AS_CONSTRUCTOR);
3741 __ jmp(&do_call);
3743 __ bind(&non_function_call);
3744 __ GetBuiltinEntry(rdx, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR);
3745 __ bind(&do_call);
3747 __ Set(rbx, 0);
3748 __ SetCallKind(rcx, CALL_AS_METHOD);
3749 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
3809 __ CheckStackAlignment();
3818 __ movq(rcx, rax);
3820 __ movq(rdi, rax);
3822 __ movq(kScratchRegister,
3825 __ call(kScratchRegister);
3832 __ incl(scope_depth_operand);
3839 __ movq(StackSpaceOperand(0), r14); // argc.
3840 __ movq(StackSpaceOperand(1), r15); // argv.
3844 __ lea(rcx, StackSpaceOperand(0));
3845 __ LoadAddress(rdx, ExternalReference::isolate_address());
3849 __ lea(rcx, StackSpaceOperand(2));
3851 __ lea(rdx, StackSpaceOperand(0));
3852 __ LoadAddress(r8, ExternalReference::isolate_address());
3857 __ movq(rdi, r14); // argc.
3858 __ movq(rsi, r15); // argv.
3859 __ movq(rdx, ExternalReference::isolate_address());
3861 __ call(rbx);
3866 __ decl(scope_depth_operand);
3879 __ movq(rax, Operand(rsp, 6 * kPointerSize));
3880 __ movq(rdx, Operand(rsp, 7 * kPointerSize));
3883 __ lea(rcx, Operand(rax, 1));
3885 __ testl(rcx, Immediate(kFailureTagMask));
3886 __ j(zero, &failure_returned);
3889 __ LeaveExitFrame(save_doubles_);
3890 __ ret(0);
3893 __ bind(&failure_returned);
3898 __ testl(rax, Immediate(((1 << kFailureTypeTagSize) - 1) << kFailureTagSize));
3899 __ j(zero, &retry, Label::kNear);
3902 __ movq(kScratchRegister, Failure::OutOfMemoryException(), RelocInfo::NONE);
3903 __ cmpq(rax, kScratchRegister);
3904 __ j(equal, throw_out_of_memory_exception);
3911 __ movq(rax, pending_exception_operand);
3912 __ LoadRoot(rdx, Heap::kTheHoleValueRootIndex);
3913 __ movq(pending_exception_operand, rdx);
3917 __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
3918 __ j(equal, throw_termination_exception);
3921 __ jmp(throw_normal_exception);
3924 __ bind(&retry);
3946 __ EnterExitFrame(arg_stack_space, save_doubles_);
3982 __ movq(rax, failure, RelocInfo::NONE);
3990 __ bind(&throw_out_of_memory_exception);
3995 __ Set(rax, static_cast<int64_t>(false));
3996 __ Store(external_caught, rax);
4001 __ movq(rax, Failure::OutOfMemoryException(), RelocInfo::NONE);
4002 __ Store(pending_exception, rax);
4005 __ bind(&throw_termination_exception);
4006 __ ThrowUncatchable(rax);
4008 __ bind(&throw_normal_exception);
4009 __ Throw(rax);
4019 __ push(rbp);
4020 __ movq(rbp, rsp);
4027 __ movq(kScratchRegister,
4030 __ push(kScratchRegister); // context slot
4031 __ push(kScratchRegister); // function slot
4033 __ push(r12);
4034 __ push(r13);
4035 __ push(r14);
4036 __ push(r15);
4038 __ push(rdi); // Only callee save in Win64 ABI, argument in AMD64 ABI.
4039 __ push(rsi); // Only callee save in Win64 ABI, argument in AMD64 ABI.
4041 __ push(rbx);
4047 __ InitializeSmiConstantRegister();
4048 __ InitializeRootRegister();
4057 __ push(c_entry_fp_operand);
4062 __ Load(rax, js_entry_sp);
4063 __ testq(rax, rax);
4064 __ j(not_zero, ¬_outermost_js);
4065 __ Push(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
4066 __ movq(rax, rbp);
4067 __ Store(js_entry_sp, rax);
4069 __ jmp(&cont);
4070 __ bind(¬_outermost_js);
4071 __ Push(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME));
4072 __ bind(&cont);
4076 __ jmp(&invoke);
4077 __ bind(&handler_entry);
4083 __ Store(pending_exception, rax);
4084 __ movq(rax, Failure::Exception(), RelocInfo::NONE);
4085 __ jmp(&exit);
4089 __ bind(&invoke);
4090 __ PushTryHandler(StackHandler::JS_ENTRY, 0);
4093 __ LoadRoot(rax, Heap::kTheHoleValueRootIndex);
4094 __ Store(pending_exception, rax);
4097 __ push(Immediate(0)); // receiver
4107 __ Load(rax, construct_entry);
4110 __ Load(rax, entry);
4112 __ lea(kScratchRegister, FieldOperand(rax, Code::kHeaderSize));
4113 __ call(kScratchRegister);
4116 __ PopTryHandler();
4118 __ bind(&exit);
4120 __ pop(rbx);
4121 __ Cmp(rbx, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
4122 __ j(not_equal, ¬_outermost_js_2);
4123 __ movq(kScratchRegister, js_entry_sp);
4124 __ movq(Operand(kScratchRegister, 0), Immediate(0));
4125 __ bind(¬_outermost_js_2);
4129 __ pop(c_entry_fp_operand);
4133 __ pop(rbx);
4136 __ pop(rsi);
4137 __ pop(rdi);
4139 __ pop(r15);
4140 __ pop(r14);
4141 __ pop(r13);
4142 __ pop(r12);
4143 __ addq(rsp, Immediate(2 * kPointerSize)); // remove markers
4146 __ pop(rbp);
4147 __ ret(0);
4174 // __ j(not_equal, &cache_miss);
4175 // __ LoadRoot(ToRegister(instr->result()), Heap::kTheHoleValueRootIndex);
4185 __ movq(rax, Operand(rsp, 2 * kPointerSize + extra_stack_space));
4186 __ JumpIfSmi(rax, &slow);
4189 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rax);
4190 __ j(below, &slow);
4191 __ CmpInstanceType(rax, LAST_SPEC_OBJECT_TYPE);
4192 __ j(above, &slow);
4195 __ movq(rdx, Operand(rsp, 1 * kPointerSize + extra_stack_space));
4203 __ CompareRoot(rdx, Heap::kInstanceofCacheFunctionRootIndex);
4204 __ j(not_equal, &miss, Label::kNear);
4205 __ CompareRoot(rax, Heap::kInstanceofCacheMapRootIndex);
4206 __ j(not_equal, &miss, Label::kNear);
4207 __ LoadRoot(rax, Heap::kInstanceofCacheAnswerRootIndex);
4208 __ ret(2 * kPointerSize);
4209 __ bind(&miss);
4212 __ TryGetFunctionPrototype(rdx, rbx, &slow, true);
4215 __ JumpIfSmi(rbx, &slow);
4216 __ CmpObjectType(rbx, FIRST_SPEC_OBJECT_TYPE, kScratchRegister);
4217 __ j(below, &slow);
4218 __ CmpInstanceType(kScratchRegister, LAST_SPEC_OBJECT_TYPE);
4219 __ j(above, &slow);
4226 __ StoreRoot(rdx, Heap::kInstanceofCacheFunctionRootIndex);
4227 __ StoreRoot(rax, Heap::kInstanceofCacheMapRootIndex);
4230 __ movq(kScratchRegister, Operand(rsp, 0 * kPointerSize));
4231 __ subq(kScratchRegister, Operand(rsp, 1 * kPointerSize));
4233 __ movl(rdi, Immediate(kWordBeforeMapCheckValue));
4234 __ cmpl(Operand(kScratchRegister, kOffsetToMapCheckValue - 4), rdi);
4235 __ Assert(equal, "InstanceofStub unexpected call site cache (check).");
4237 __ movq(kScratchRegister,
4239 __ movq(Operand(kScratchRegister, 0), rax);
4242 __ movq(rcx, FieldOperand(rax, Map::kPrototypeOffset));
4246 __ LoadRoot(kScratchRegister, Heap::kNullValueRootIndex);
4247 __ bind(&loop);
4248 __ cmpq(rcx, rbx);
4249 __ j(equal, &is_instance, Label::kNear);
4250 __ cmpq(rcx, kScratchRegister);
4253 __ j(equal, &is_not_instance, Label::kNear);
4254 __ movq(rcx, FieldOperand(rcx, HeapObject::kMapOffset));
4255 __ movq(rcx, FieldOperand(rcx, Map::kPrototypeOffset));
4256 __ jmp(&loop);
4258 __ bind(&is_instance);
4260 __ xorl(rax, rax);
4263 __ StoreRoot(rax, Heap::kInstanceofCacheAnswerRootIndex);
4270 __ movl(rax, Immediate(true_offset));
4271 __ movq(kScratchRegister, Operand(rsp, 0 * kPointerSize));
4272 __ subq(kScratchRegister, Operand(rsp, 1 * kPointerSize));
4273 __ movb(Operand(kScratchRegister, kOffsetToResultValue), rax);
4275 __ movl(rax, Immediate(kWordBeforeResultValue));
4276 __ cmpl(Operand(kScratchRegister, kOffsetToResultValue - 4), rax);
4277 __ Assert(equal, "InstanceofStub unexpected call site cache (mov).");
4279 __ Set(rax, 0);
4281 __ ret(2 * kPointerSize + extra_stack_space);
4283 __ bind(&is_not_instance);
4286 __ StoreRoot(kScratchRegister, Heap::kInstanceofCacheAnswerRootIndex);
4293 __ movl(rax, Immediate(false_offset));
4294 __ movq(kScratchRegister, Operand(rsp, 0 * kPointerSize));
4295 __ subq(kScratchRegister, Operand(rsp, 1 * kPointerSize));
4296 __ movb(Operand(kScratchRegister, kOffsetToResultValue), rax);
4298 __ movl(rax, Immediate(kWordBeforeResultValue));
4299 __ cmpl(Operand(kScratchRegister, kOffsetToResultValue - 4), rax);
4300 __ Assert(equal, "InstanceofStub unexpected call site cache (mov)");
4303 __ ret(2 * kPointerSize + extra_stack_space);
4306 __ bind(&slow);
4309 __ pop(rcx);
4310 __ pop(rax);
4311 __ push(rcx);
4313 __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
4372 __ JumpIfSmi(object_, receiver_not_string_);
4375 __ movq(result_, FieldOperand(object_, HeapObject::kMapOffset));
4376 __ movzxbl(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
4378 __ testb(result_, Immediate(kIsNotStringMask));
4379 __ j(not_zero, receiver_not_string_);
4382 __ JumpIfNotSmi(index_, &index_not_smi_);
4383 __ bind(&got_smi_index_);
4386 __ SmiCompare(index_, FieldOperand(object_, String::kLengthOffset));
4387 __ j(above_equal, index_out_of_range_);
4389 __ SmiToInteger32(index_, index_);
4394 __ Integer32ToSmi(result_, result_);
4395 __ bind(&exit_);
4402 __ Abort("Unexpected fallthrough to CharCodeAt slow case");
4406 __ bind(&index_not_smi_);
4408 __ CheckMap(index_,
4413 __ push(object_);
4414 __ push(index_); // Consumed by runtime conversion function.
4416 __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
4420 __ CallRuntime(Runtime::kNumberToSmi, 1);
4425 __ movq(index_, rax);
4427 __ pop(object_);
4429 __ movq(result_, FieldOperand(object_, HeapObject::kMapOffset));
4430 __ movzxbl(result_, FieldOperand(result_, Map::kInstanceTypeOffset));
4433 __ JumpIfNotSmi(index_, index_out_of_range_);
4435 __ jmp(&got_smi_index_);
4440 __ bind(&call_runtime_);
4442 __ push(object_);
4443 __ Integer32ToSmi(index_, index_);
4444 __ push(index_);
4445 __ CallRuntime(Runtime::kStringCharCodeAt, 2);
4447 __ movq(result_, rax);
4450 __ jmp(&exit_);
4452 __ Abort("Unexpected fallthrough from CharCodeAt slow case");
4461 __ JumpIfNotSmi(code_, &slow_case_);
4462 __ SmiCompare(code_, Smi::FromInt(String::kMaxAsciiCharCode));
4463 __ j(above, &slow_case_);
4465 __ LoadRoot(result_, Heap::kSingleCharacterStringCacheRootIndex);
4467 __ movq(result_, FieldOperand(result_, index.reg, index.scale,
4469 __ CompareRoot(result_, Heap::kUndefinedValueRootIndex);
4470 __ j(equal, &slow_case_);
4471 __ bind(&exit_);
4478 __ Abort("Unexpected fallthrough to CharFromCode slow case");
4480 __ bind(&slow_case_);
4482 __ push(code_);
4483 __ CallRuntime(Runtime::kCharFromCode, 1);
4485 __ movq(result_, rax);
4488 __ jmp(&exit_);
4490 __ Abort("Unexpected fallthrough from CharFromCode slow case");
4516 __ movq(rax, Operand(rsp, 2 * kPointerSize)); // First argument (left).
4517 __ movq(rdx, Operand(rsp, 1 * kPointerSize)); // Second argument (right).
4521 __ JumpIfSmi(rax, &call_runtime);
4522 __ CmpObjectType(rax, FIRST_NONSTRING_TYPE, r8);
4523 __ j(above_equal, &call_runtime);
4526 __ JumpIfSmi(rdx, &call_runtime);
4527 __ CmpObjectType(rdx, FIRST_NONSTRING_TYPE, r9);
4528 __ j(above_equal, &call_runtime);
4550 __ movq(rcx, FieldOperand(rdx, String::kLengthOffset));
4551 __ SmiTest(rcx);
4552 __ j(not_zero, &second_not_zero_length, Label::kNear);
4555 __ IncrementCounter(counters->string_add_native(), 1);
4556 __ ret(2 * kPointerSize);
4557 __ bind(&second_not_zero_length);
4558 __ movq(rbx, FieldOperand(rax, String::kLengthOffset));
4559 __ SmiTest(rbx);
4560 __ j(not_zero, &both_not_zero_length, Label::kNear);
4562 __ movq(rax, rdx);
4563 __ IncrementCounter(counters->string_add_native(), 1);
4564 __ ret(2 * kPointerSize);
4574 __ bind(&both_not_zero_length);
4579 __ movq(r8, FieldOperand(rax, HeapObject::kMapOffset));
4580 __ movq(r9, FieldOperand(rdx, HeapObject::kMapOffset));
4583 __ movzxbl(r8, FieldOperand(r8, Map::kInstanceTypeOffset));
4584 __ movzxbl(r9, FieldOperand(r9, Map::kInstanceTypeOffset));
4588 __ SmiAdd(rbx, rbx, rcx);
4591 __ SmiCompare(rbx, Smi::FromInt(2));
4592 __ j(not_equal, &longer_than_two);
4595 __ JumpIfBothInstanceTypesAreNotSequentialAscii(r8, r9, rbx, rcx,
4599 __ movzxbq(rbx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4600 __ movzxbq(rcx, FieldOperand(rdx, SeqAsciiString::kHeaderSize));
4607 __ IncrementCounter(counters->string_add_native(), 1);
4608 __ ret(2 * kPointerSize);
4610 __ bind(&make_two_character_string);
4611 __ Set(rdi, 2);
4612 __ AllocateAsciiString(rax, rdi, r8, r9, r11, &call_runtime);
4616 __ movzxbq(rcx, FieldOperand(rdx, SeqAsciiString::kHeaderSize));
4617 __ shll(rcx, Immediate(kBitsPerByte));
4618 __ orl(rbx, rcx);
4620 __ movw(FieldOperand(rax, SeqAsciiString::kHeaderSize), rbx);
4621 __ IncrementCounter(counters->string_add_native(), 1);
4622 __ ret(2 * kPointerSize);
4624 __ bind(&longer_than_two);
4626 __ SmiCompare(rbx, Smi::FromInt(ConsString::kMinLength));
4627 __ j(below, &string_add_flat_result);
4630 __ SmiCompare(rbx, Smi::FromInt(String::kMaxLength));
4631 __ j(above, &call_runtime);
4641 __ movl(rcx, r8);
4642 __ and_(rcx, r9);
4645 __ testl(rcx, Immediate(kStringEncodingMask));
4646 __ j(zero, &non_ascii);
4647 __ bind(&ascii_data);
4649 __ AllocateAsciiConsString(rcx, rdi, no_reg, &call_runtime);
4650 __ bind(&allocated);
4652 __ movq(FieldOperand(rcx, ConsString::kLengthOffset), rbx);
4653 __ movq(FieldOperand(rcx, ConsString::kHashFieldOffset),
4655 __ movq(FieldOperand(rcx, ConsString::kFirstOffset), rax);
4656 __ movq(FieldOperand(rcx, ConsString::kSecondOffset), rdx);
4657 __ movq(rax, rcx);
4658 __ IncrementCounter(counters->string_add_native(), 1);
4659 __ ret(2 * kPointerSize);
4660 __ bind(&non_ascii);
4666 __ testb(rcx, Immediate(kAsciiDataHintMask));
4667 __ j(not_zero, &ascii_data);
4668 __ xor_(r8, r9);
4670 __ andb(r8, Immediate(kAsciiStringTag | kAsciiDataHintTag));
4671 __ cmpb(r8, Immediate(kAsciiStringTag | kAsciiDataHintTag));
4672 __ j(equal, &ascii_data);
4674 __ AllocateTwoByteConsString(rcx, rdi, no_reg, &call_runtime);
4675 __ jmp(&allocated);
4688 __ bind(&string_add_flat_result);
4690 __ SmiToInteger32(r14, FieldOperand(rax, SeqString::kLengthOffset));
4693 __ testb(r8, Immediate(kStringRepresentationMask));
4694 __ j(zero, &first_is_sequential, Label::kNear);
4697 __ testb(r8, Immediate(kShortExternalStringMask));
4698 __ j(not_zero, &call_runtime);
4699 __ movq(rcx, FieldOperand(rax, ExternalString::kResourceDataOffset));
4700 __ jmp(&first_prepared, Label::kNear);
4701 __ bind(&first_is_sequential);
4703 __ lea(rcx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4704 __ bind(&first_prepared);
4707 __ xorl(r8, r9);
4708 __ testb(r8, Immediate(kStringEncodingMask));
4709 __ j(not_zero, &call_runtime);
4711 __ SmiToInteger32(r15, FieldOperand(rdx, SeqString::kLengthOffset));
4714 __ testb(r9, Immediate(kStringRepresentationMask));
4715 __ j(zero, &second_is_sequential, Label::kNear);
4718 __ testb(r9, Immediate(kShortExternalStringMask));
4719 __ j(not_zero, &call_runtime);
4720 __ movq(rdx, FieldOperand(rdx, ExternalString::kResourceDataOffset));
4721 __ jmp(&second_prepared, Label::kNear);
4722 __ bind(&second_is_sequential);
4724 __ lea(rdx, FieldOperand(rdx, SeqAsciiString::kHeaderSize));
4725 __ bind(&second_prepared);
4731 __ SmiToInteger32(rbx, rbx);
4732 __ testb(r9, Immediate(kStringEncodingMask));
4733 __ j(zero, &non_ascii_string_add_flat_result);
4735 __ bind(&make_flat_ascii_string);
4737 __ AllocateAsciiString(rax, rbx, rdi, r8, r9, &call_runtime);
4740 __ lea(rbx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4749 __ IncrementCounter(counters->string_add_native(), 1);
4750 __ ret(2 * kPointerSize);
4752 __ bind(&non_ascii_string_add_flat_result);
4754 __ AllocateTwoByteString(rax, rbx, rdi, r8, r9, &call_runtime);
4757 __ lea(rbx, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
4766 __ IncrementCounter(counters->string_add_native(), 1);
4767 __ ret(2 * kPointerSize);
4770 __ bind(&call_runtime);
4771 __ TailCallRuntime(Runtime::kStringAdd, 2, 1);
4774 __ bind(&call_builtin);
4775 __ InvokeBuiltin(builtin_id, JUMP_FUNCTION);
4789 __ JumpIfSmi(arg, ¬_string);
4790 __ CmpObjectType(arg, FIRST_NONSTRING_TYPE, scratch1);
4791 __ j(below, &done);
4795 __ bind(¬_string);
4804 __ movq(arg, scratch1);
4805 __ movq(Operand(rsp, stack_offset), arg);
4806 __ jmp(&done);
4809 __ bind(¬_cached);
4810 __ JumpIfSmi(arg, slow);
4811 __ CmpObjectType(arg, JS_VALUE_TYPE, scratch1); // map -> scratch1.
4812 __ j(not_equal, slow);
4813 __ testb(FieldOperand(scratch1, Map::kBitField2Offset),
4815 __ j(zero, slow);
4816 __ movq(arg, FieldOperand(arg, JSValue::kValueOffset));
4817 __ movq(Operand(rsp, stack_offset), arg);
4819 __ bind(&done);
4829 __ bind(&loop);
4833 __ movb(kScratchRegister, Operand(src, 0));
4834 __ movb(Operand(dest, 0), kScratchRegister);
4835 __ incq(src);
4836 __ incq(dest);
4838 __ movzxwl(kScratchRegister, Operand(src, 0));
4839 __ movw(Operand(dest, 0), kScratchRegister);
4840 __ addq(src, Immediate(2));
4841 __ addq(dest, Immediate(2));
4843 __ decl(count);
4844 __ j(not_zero, &loop);
4863 __ testl(count, count);
4864 __ j(zero, &done, Label::kNear);
4869 __ addl(count, count);
4874 __ testl(count, Immediate(~7));
4875 __ j(zero, &last_bytes, Label::kNear);
4878 __ movl(kScratchRegister, count);
4879 __ shr(count, Immediate(3)); // Number of doublewords to copy.
4880 __ repmovsq();
4883 __ movl(count, kScratchRegister);
4884 __ and_(count, Immediate(7));
4887 __ bind(&last_bytes);
4888 __ testl(count, count);
4889 __ j(zero, &done, Label::kNear);
4893 __ bind(&loop);
4894 __ movb(kScratchRegister, Operand(src, 0));
4895 __ movb(Operand(dest, 0), kScratchRegister);
4896 __ incq(src);
4897 __ incq(dest);
4898 __ decl(count);
4899 __ j(not_zero, &loop);
4901 __ bind(&done);
4918 __ leal(scratch, Operand(c1, -'0'));
4919 __ cmpl(scratch, Immediate(static_cast<int>('9' - '0')));
4920 __ j(above, ¬_array_index, Label::kNear);
4921 __ leal(scratch, Operand(c2, -'0'));
4922 __ cmpl(scratch, Immediate(static_cast<int>('9' - '0')));
4923 __ j(below_equal, not_found);
4925 __ bind(¬_array_index);
4934 __ shl(c2, Immediate(kBitsPerByte));
4935 __ orl(chars, c2);
4942 __ LoadRoot(symbol_table, Heap::kSymbolTableRootIndex);
4946 __ SmiToInteger32(mask,
4948 __ decl(mask);
4967 __ movl(scratch, hash);
4969 __ addl(scratch, Immediate(SymbolTable::GetProbeOffset(i)));
4971 __ andl(scratch, mask);
4975 __ movq(candidate,
4983 __ CmpObjectType(candidate, ODDBALL_TYPE, map);
4984 __ j(not_equal, &is_string, Label::kNear);
4986 __ CompareRoot(candidate, Heap::kUndefinedValueRootIndex);
4987 __ j(equal, not_found);
4990 __ LoadRoot(kScratchRegister, Heap::kTheHoleValueRootIndex);
4991 __ cmpq(kScratchRegister, candidate);
4992 __ Assert(equal, "oddball in symbol table is not undefined or the hole");
4994 __ jmp(&next_probe[i]);
4996 __ bind(&is_string);
4999 __ SmiCompare(FieldOperand(candidate, String::kLengthOffset),
5001 __ j(not_equal, &next_probe[i]);
5008 __ movzxbl(temp, FieldOperand(map, Map::kInstanceTypeOffset));
5009 __ JumpIfInstanceTypeIsNotSequentialAscii(
5013 __ movl(temp, FieldOperand(candidate, SeqAsciiString::kHeaderSize));
5014 __ andl(temp, Immediate(0x0000ffff));
5015 __ cmpl(chars, temp);
5016 __ j(equal, &found_in_symbol_table);
5017 __ bind(&next_probe[i]);
5021 __ jmp(not_found);
5025 __ bind(&found_in_symbol_table);
5027 __ movq(rax, result);
5037 __ LoadRoot(scratch, Heap::kHashSeedRootIndex);
5038 __ SmiToInteger32(scratch, scratch);
5039 __ addl(scratch, character);
5040 __ movl(hash, scratch);
5041 __ shll(scratch, Immediate(10));
5042 __ addl(hash, scratch);
5044 __ movl(scratch, hash);
5045 __ shrl(scratch, Immediate(6));
5046 __ xorl(hash, scratch);
5055 __ addl(hash, character);
5057 __ movl(scratch, hash);
5058 __ shll(scratch, Immediate(10));
5059 __ addl(hash, scratch);
5061 __ movl(scratch, hash);
5062 __ shrl(scratch, Immediate(6));
5063 __ xorl(hash, scratch);
5071 __ leal(hash, Operand(hash, hash, times_8, 0));
5073 __ movl(scratch, hash);
5074 __ shrl(scratch, Immediate(11));
5075 __ xorl(hash, scratch);
5077 __ movl(scratch, hash);
5078 __ shll(scratch, Immediate(15));
5079 __ addl(hash, scratch);
5081 __ andl(hash, Immediate(String::kHashBitMask));
5085 __ j(not_zero, &hash_not_zero);
5086 __ Set(hash, StringHasher::kZeroHash);
5087 __ bind(&hash_not_zero);
5105 __ movq(rax, Operand(rsp, kStringOffset));
5107 __ testl(rax, Immediate(kSmiTagMask));
5108 __ j(zero, &runtime);
5110 __ j(NegateCondition(is_string), &runtime);
5116 __ movq(rcx, Operand(rsp, kToOffset));
5117 __ movq(rdx, Operand(rsp, kFromOffset));
5118 __ JumpUnlessBothNonNegativeSmi(rcx, rdx, &runtime);
5120 __ SmiSub(rcx, rcx, rdx); // Overflow doesn't happen.
5121 __ cmpq(FieldOperand(rax, String::kLengthOffset), rcx);
5123 __ j(not_equal, ¬_original_string, Label::kNear);
5125 __ IncrementCounter(counters->sub_string_native(), 1);
5126 __ ret(kArgumentsSize);
5127 __ bind(¬_original_string);
5131 __ SmiToInteger32(rcx, rcx);
5132 __ cmpl(rcx, Immediate(2));
5133 __ j(greater, &result_longer_than_two);
5134 __ j(less, &runtime);
5141 __ JumpIfInstanceTypeIsNotSequentialAscii(rbx, rbx, &runtime);
5144 __ SmiToInteger32(rdx, rdx); // From index is no longer smi.
5145 __ movzxbq(rbx, FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize));
5146 __ movzxbq(rdi,
5153 __ IncrementCounter(counters->sub_string_native(), 1);
5154 __ ret(3 * kPointerSize);
5156 __ bind(&make_two_character_string);
5158 __ movzxwq(rbx, FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize));
5159 __ AllocateAsciiString(rax, rcx, r11, r14, r15, &runtime);
5160 __ movw(FieldOperand(rax, SeqAsciiString::kHeaderSize), rbx);
5161 __ IncrementCounter(counters->sub_string_native(), 1);
5162 __ ret(3 * kPointerSize);
5164 __ bind(&result_longer_than_two);
5175 __ testb(rbx, Immediate(kIsIndirectStringMask));
5176 __ j(zero, &seq_or_external_string, Label::kNear);
5178 __ testb(rbx, Immediate(kSlicedNotConsMask));
5179 __ j(not_zero, &sliced_string, Label::kNear);
5182 __ CompareRoot(FieldOperand(rax, ConsString::kSecondOffset),
5184 __ j(not_equal, &runtime);
5185 __ movq(rdi, FieldOperand(rax, ConsString::kFirstOffset));
5187 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
5188 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
5189 __ jmp(&underlying_unpacked, Label::kNear);
5191 __ bind(&sliced_string);
5193 __ addq(rdx, FieldOperand(rax, SlicedString::kOffsetOffset));
5194 __ movq(rdi, FieldOperand(rax, SlicedString::kParentOffset));
5196 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
5197 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
5198 __ jmp(&underlying_unpacked, Label::kNear);
5200 __ bind(&seq_or_external_string);
5202 __ movq(rdi, rax);
5204 __ bind(&underlying_unpacked);
5214 __ cmpq(rcx, Immediate(SlicedString::kMinLength));
5216 __ j(less, ©_routine);
5225 __ testb(rbx, Immediate(kStringEncodingMask));
5226 __ j(zero, &two_byte_slice, Label::kNear);
5227 __ AllocateAsciiSlicedString(rax, rbx, r14, &runtime);
5228 __ jmp(&set_slice_header, Label::kNear);
5229 __ bind(&two_byte_slice);
5230 __ AllocateTwoByteSlicedString(rax, rbx, r14, &runtime);
5231 __ bind(&set_slice_header);
5232 __ Integer32ToSmi(rcx, rcx);
5233 __ movq(FieldOperand(rax, SlicedString::kLengthOffset), rcx);
5234 __ movq(FieldOperand(rax, SlicedString::kHashFieldOffset),
5236 __ movq(FieldOperand(rax, SlicedString::kParentOffset), rdi);
5237 __ movq(FieldOperand(rax, SlicedString::kOffsetOffset), rdx);
5238 __ IncrementCounter(counters->sub_string_native(), 1);
5239 __ ret(kArgumentsSize);
5241 __ bind(©_routine);
5253 __ testb(rbx, Immediate(kExternalStringTag));
5254 __ j(zero, &sequential_string);
5259 __ testb(rbx, Immediate(kShortExternalStringMask));
5260 __ j(not_zero, &runtime);
5261 __ movq(rdi, FieldOperand(rdi, ExternalString::kResourceDataOffset));
5264 __ subq(rdi, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5266 __ bind(&sequential_string);
5268 __ testb(rbx, Immediate(kStringEncodingMask));
5269 __ j(zero, &two_byte_sequential);
5272 __ AllocateAsciiString(rax, rcx, r11, r14, r15, &runtime);
5276 __ movq(r14, rsi); // esi used by following code.
5279 __ lea(rsi, Operand(rdi, smi_as_index.reg, smi_as_index.scale,
5283 __ lea(rdi, FieldOperand(rax, SeqAsciiString::kHeaderSize));
5291 __ movq(rsi, r14); // Restore rsi.
5292 __ IncrementCounter(counters->sub_string_native(), 1);
5293 __ ret(kArgumentsSize);
5295 __ bind(&two_byte_sequential);
5297 __ AllocateTwoByteString(rax, rcx, r11, r14, r15, &runtime);
5301 __ movq(r14, rsi); // esi used by following code.
5304 __ lea(rsi, Operand(rdi, smi_as_index.reg, smi_as_index.scale,
5308 __ lea(rdi, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
5316 __ movq(rsi, r14); // Restore esi.
5317 __ IncrementCounter(counters->sub_string_native(), 1);
5318 __ ret(kArgumentsSize);
5321 __ bind(&runtime);
5322 __ TailCallRuntime(Runtime::kSubString, 3, 1);
5335 __ movq(length, FieldOperand(left, String::kLengthOffset));
5336 __ SmiCompare(length, FieldOperand(right, String::kLengthOffset));
5337 __ j(equal, &check_zero_length, Label::kNear);
5338 __ Move(rax, Smi::FromInt(NOT_EQUAL));
5339 __ ret(0);
5343 __ bind(&check_zero_length);
5345 __ SmiTest(length);
5346 __ j(not_zero, &compare_chars, Label::kNear);
5347 __ Move(rax, Smi::FromInt(EQUAL));
5348 __ ret(0);
5351 __ bind(&compare_chars);
5357 __ Move(rax, Smi::FromInt(EQUAL));
5358 __ ret(0);
5361 __ bind(&strings_not_equal);
5362 __ Move(rax, Smi::FromInt(NOT_EQUAL));
5363 __ ret(0);
5379 __ movq(scratch1, FieldOperand(left, String::kLengthOffset));
5380 __ movq(scratch4, scratch1);
5381 __ SmiSub(scratch4,
5387 __ j(less, &left_shorter, Label::kNear);
5391 __ SmiSub(scratch1, scratch1, length_difference);
5392 __ bind(&left_shorter);
5398 __ SmiTest(min_length);
5399 __ j(zero, &compare_lengths, Label::kNear);
5408 __ bind(&compare_lengths);
5409 __ SmiTest(length_difference);
5410 __ j(not_zero, &result_not_equal, Label::kNear);
5413 __ Move(rax, Smi::FromInt(EQUAL));
5414 __ ret(0);
5417 __ bind(&result_not_equal);
5419 __ j(greater, &result_greater, Label::kNear);
5422 __ Move(rax, Smi::FromInt(LESS));
5423 __ ret(0);
5426 __ bind(&result_greater);
5427 __ Move(rax, Smi::FromInt(GREATER));
5428 __ ret(0);
5443 __ SmiToInteger32(length, length);
5444 __ lea(left,
5446 __ lea(right,
5448 __ neg(length);
5453 __ bind(&loop);
5454 __ movb(scratch, Operand(left, index, times_1, 0));
5455 __ cmpb(scratch, Operand(right, index, times_1, 0));
5456 __ j(not_equal, chars_not_equal, near_jump);
5457 __ incq(index);
5458 __ j(not_zero, &loop);
5470 __ movq(rdx, Operand(rsp, 2 * kPointerSize)); // left
5471 __ movq(rax, Operand(rsp, 1 * kPointerSize)); // right
5475 __ cmpq(rdx, rax);
5476 __ j(not_equal, ¬_same, Label::kNear);
5477 __ Move(rax, Smi::FromInt(EQUAL));
5479 __ IncrementCounter(counters->string_compare_native(), 1);
5480 __ ret(2 * kPointerSize);
5482 __ bind(¬_same);
5485 __ JumpIfNotBothSequentialAsciiStrings(rdx, rax, rcx, rbx, &runtime);
5488 __ IncrementCounter(counters->string_compare_native(), 1);
5490 __ pop(rcx);
5491 __ addq(rsp, Immediate(2 * kPointerSize));
5492 __ push(rcx);
5497 __ bind(&runtime);
5498 __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
5505 __ JumpIfNotBothSmi(rdx, rax, &miss, Label::kNear);
5509 __ subq(rax, rdx);
5512 __ subq(rdx, rax);
5513 __ j(no_overflow, &done, Label::kNear);
5515 __ SmiNot(rdx, rdx);
5516 __ bind(&done);
5517 __ movq(rax, rdx);
5519 __ ret(0);
5521 __ bind(&miss);
5533 __ j(either_smi, &generic_stub, Label::kNear);
5535 __ CmpObjectType(rax, HEAP_NUMBER_TYPE, rcx);
5536 __ j(not_equal, &maybe_undefined1, Label::kNear);
5537 __ CmpObjectType(rdx, HEAP_NUMBER_TYPE, rcx);
5538 __ j(not_equal, &maybe_undefined2, Label::kNear);
5541 __ movsd(xmm0, FieldOperand(rdx, HeapNumber::kValueOffset));
5542 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
5545 __ ucomisd(xmm0, xmm1);
5548 __ j(parity_even, &unordered, Label::kNear);
5552 __ movl(rax, Immediate(0));
5553 __ movl(rcx, Immediate(0));
5554 __ setcc(above, rax); // Add one to zero if carry clear and not equal.
5555 __ sbbq(rax, rcx); // Subtract one if below (aka. carry set).
5556 __ ret(0);
5558 __ bind(&unordered);
5560 __ bind(&generic_stub);
5561 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET);
5563 __ bind(&maybe_undefined1);
5565 __ Cmp(rax, masm->isolate()->factory()->undefined_value());
5566 __ j(not_equal, &miss);
5567 __ CmpObjectType(rdx, HEAP_NUMBER_TYPE, rcx);
5568 __ j(not_equal, &maybe_undefined2, Label::kNear);
5569 __ jmp(&unordered);
5572 __ bind(&maybe_undefined2);
5574 __ Cmp(rdx, masm->isolate()->factory()->undefined_value());
5575 __ j(equal, &unordered);
5578 __ bind(&miss);
5596 __ j(cond, &miss, Label::kNear);
5599 __ movq(tmp1, FieldOperand(left, HeapObject::kMapOffset));
5600 __ movq(tmp2, FieldOperand(right, HeapObject::kMapOffset));
5601 __ movzxbq(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
5602 __ movzxbq(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
5604 __ and_(tmp1, tmp2);
5605 __ testb(tmp1, Immediate(kIsSymbolMask));
5606 __ j(zero, &miss, Label::kNear);
5610 __ cmpq(left, right);
5614 __ j(not_equal, &done, Label::kNear);
5617 __ Move(rax, Smi::FromInt(EQUAL));
5618 __ bind(&done);
5619 __ ret(0);
5621 __ bind(&miss);
5641 __ j(cond, &miss);
5645 __ movq(tmp1, FieldOperand(left, HeapObject::kMapOffset));
5646 __ movq(tmp2, FieldOperand(right, HeapObject::kMapOffset));
5647 __ movzxbq(tmp1, FieldOperand(tmp1, Map::kInstanceTypeOffset));
5648 __ movzxbq(tmp2, FieldOperand(tmp2, Map::kInstanceTypeOffset));
5649 __ movq(tmp3, tmp1);
5651 __ or_(tmp3, tmp2);
5652 __ testb(tmp3, Immediate(kIsNotStringMask));
5653 __ j(not_zero, &miss);
5657 __ cmpq(left, right);
5658 __ j(not_equal, ¬_same, Label::kNear);
5661 __ Move(rax, Smi::FromInt(EQUAL));
5662 __ ret(0);
5665 __ bind(¬_same);
5672 __ and_(tmp1, tmp2);
5673 __ testb(tmp1, Immediate(kIsSymbolMask));
5674 __ j(zero, &do_compare, Label::kNear);
5678 __ ret(0);
5679 __ bind(&do_compare);
5684 __ JumpIfNotBothSequentialAsciiStrings(left, right, tmp1, tmp2, &runtime);
5696 __ bind(&runtime);
5697 __ pop(tmp1); // Return address.
5698 __ push(left);
5699 __ push(right);
5700 __ push(tmp1);
5702 __ TailCallRuntime(Runtime::kStringEquals, 2, 1);
5704 __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
5707 __ bind(&miss);
5716 __ j(either_smi, &miss, Label::kNear);
5718 __ CmpObjectType(rax, JS_OBJECT_TYPE, rcx);
5719 __ j(not_equal, &miss, Label::kNear);
5720 __ CmpObjectType(rdx, JS_OBJECT_TYPE, rcx);
5721 __ j(not_equal, &miss, Label::kNear);
5724 __ subq(rax, rdx);
5725 __ ret(0);
5727 __ bind(&miss);
5735 __ j(either_smi, &miss, Label::kNear);
5737 __ movq(rcx, FieldOperand(rax, HeapObject::kMapOffset));
5738 __ movq(rbx, FieldOperand(rdx, HeapObject::kMapOffset));
5739 __ Cmp(rcx, known_map_);
5740 __ j(not_equal, &miss, Label::kNear);
5741 __ Cmp(rbx, known_map_);
5742 __ j(not_equal, &miss, Label::kNear);
5744 __ subq(rax, rdx);
5745 __ ret(0);
5747 __ bind(&miss);
5759 __ push(rdx);
5760 __ push(rax);
5761 __ push(rdx);
5762 __ push(rax);
5763 __ Push(Smi::FromInt(op_));
5764 __ CallExternalReference(miss, 3);
5767 __ lea(rdi, FieldOperand(rax, Code::kHeaderSize));
5768 __ pop(rax);
5769 __ pop(rdx);
5773 __ jmp(rdi);
5793 __ SmiToInteger32(index, FieldOperand(properties, kCapacityOffset));
5794 __ decl(index);
5795 __ and_(index,
5800 __ lea(index, Operand(index, index, times_2, 0)); // index *= 3.
5805 __ movq(entity_name, Operand(properties,
5809 __ Cmp(entity_name, masm->isolate()->factory()->undefined_value());
5810 __ j(equal, done);
5813 __ Cmp(entity_name, Handle<String>(name));
5814 __ j(equal, miss);
5818 __ CompareRoot(entity_name, Heap::kTheHoleValueRootIndex);
5819 __ j(equal, &the_hole, Label::kNear);
5822 __ movq(entity_name, FieldOperand(entity_name, HeapObject::kMapOffset));
5823 __ testb(FieldOperand(entity_name, Map::kInstanceTypeOffset),
5825 __ j(zero, miss);
5827 __ bind(&the_hole);
5834 __ Push(Handle<Object>(name));
5835 __ push(Immediate(name->Hash()));
5836 __ CallStub(&stub);
5837 __ testq(r0, r0);
5838 __ j(not_zero, miss);
5839 __ jmp(done);
5860 if (FLAG_debug_code) __ AbortIfNotString(name);
5862 __ SmiToInteger32(r0, FieldOperand(elements, kCapacityOffset));
5863 __ decl(r0);
5867 __ movl(r1, FieldOperand(name, String::kHashFieldOffset));
5868 __ shrl(r1, Immediate(String::kHashShift));
5870 __ addl(r1, Immediate(StringDictionary::GetProbeOffset(i)));
5872 __ and_(r1, r0);
5876 __ lea(r1, Operand(r1, r1, times_2, 0)); // r1 = r1 * 3
5879 __ cmpq(name, Operand(elements, r1, times_pointer_size,
5881 __ j(equal, done);
5888 __ push(name);
5889 __ movl(r0, FieldOperand(name, String::kHashFieldOffset));
5890 __ shrl(r0, Immediate(String::kHashShift));
5891 __ push(r0);
5892 __ CallStub(&stub);
5894 __ testq(r0, r0);
5895 __ j(zero, miss);
5896 __ jmp(done);
5919 __ SmiToInteger32(scratch, FieldOperand(dictionary_, kCapacityOffset));
5920 __ decl(scratch);
5921 __ push(scratch);
5930 __ movq(scratch, Operand(rsp, 2 * kPointerSize));
5932 __ addl(scratch, Immediate(StringDictionary::GetProbeOffset(i)));
5934 __ and_(scratch, Operand(rsp, 0));
5938 __ lea(index_, Operand(scratch, scratch, times_2, 0)); // index *= 3.
5941 __ movq(scratch, Operand(dictionary_,
5946 __ Cmp(scratch, masm->isolate()->factory()->undefined_value());
5947 __ j(equal, ¬_in_dictionary);
5950 __ cmpq(scratch, Operand(rsp, 3 * kPointerSize));
5951 __ j(equal, &in_dictionary);
5959 __ movq(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
5960 __ testb(FieldOperand(scratch, Map::kInstanceTypeOffset),
5962 __ j(zero, &maybe_in_dictionary);
5966 __ bind(&maybe_in_dictionary);
5971 __ movq(scratch, Immediate(0));
5972 __ Drop(1);
5973 __ ret(2 * kPointerSize);
5976 __ bind(&in_dictionary);
5977 __ movq(scratch, Immediate(1));
5978 __ Drop(1);
5979 __ ret(2 * kPointerSize);
5981 __ bind(¬_in_dictionary);
5982 __ movq(scratch, Immediate(0));
5983 __ Drop(1);
5984 __ ret(2 * kPointerSize);
6085 __ jmp(&skip_to_incremental_noncompacting, Label::kNear);
6086 __ jmp(&skip_to_incremental_compacting, Label::kFar);
6089 __ RememberedSetHelper(object_,
6095 __ ret(0);
6098 __ bind(&skip_to_incremental_noncompacting);
6101 __ bind(&skip_to_incremental_compacting);
6117 __ movq(regs_.scratch0(), Operand(regs_.address(), 0));
6118 __ JumpIfNotInNewSpace(regs_.scratch0(),
6122 __ CheckPageFlag(regs_.object(),
6134 __ RememberedSetHelper(object_,
6140 __ bind(&dont_need_remembered_set);
6147 __ ret(0);
6166 __ Move(address, regs_.address());
6167 __ Move(arg1, regs_.object());
6170 __ Move(arg2, address);
6173 __ movq(arg2, Operand(address, 0));
6175 __ LoadAddress(arg3, ExternalReference::isolate_address());
6179 __ PrepareCallCFunction(argument_count);
6181 __ CallCFunction(
6187 __ CallCFunction(
6206 __ JumpIfBlack(regs_.object(),
6214 __ RememberedSetHelper(object_,
6220 __ ret(0);
6223 __ bind(&on_black);
6226 __ movq(regs_.scratch0(), Operand(regs_.address(), 0));
6231 __ CheckPageFlag(regs_.scratch0(), // Contains value.
6238 __ CheckPageFlag(regs_.object(),
6244 __ bind(&ensure_not_white);
6249 __ push(regs_.object());
6250 __ EnsureNotWhite(regs_.scratch0(), // The value.
6255 __ pop(regs_.object());
6259 __ RememberedSetHelper(object_,
6265 __ ret(0);
6268 __ bind(&need_incremental_pop_object);
6269 __ pop(regs_.object());
6271 __ bind(&need_incremental);
6293 __ CheckFastElements(rdi, &double_elements);
6296 __ JumpIfSmi(rax, &smi_element);
6297 __ CheckFastSmiOnlyElements(rdi, &fast_elements);
6302 __ bind(&slow_elements);
6303 __ pop(rdi); // Pop return address and remember to put back later for tail
6305 __ push(rbx);
6306 __ push(rcx);
6307 __ push(rax);
6308 __ movq(rbx, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
6309 __ push(FieldOperand(rbx, JSFunction::kLiteralsOffset));
6310 __ push(rdx);
6311 __ push(rdi); // Return return address so that tail call returns to right
6313 __ TailCallRuntime(Runtime::kStoreArrayLiteralElement, 5, 1);
6316 __ bind(&fast_elements);
6317 __ SmiToInteger32(kScratchRegister, rcx);
6318 __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
6319 __ lea(rcx, FieldOperand(rbx, kScratchRegister, times_pointer_size,
6321 __ movq(Operand(rcx, 0), rax);
6323 __ RecordWrite(rbx, rcx, rax,
6327 __ ret(0);
6331 __ bind(&smi_element);
6332 __ SmiToInteger32(kScratchRegister, rcx);
6333 __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
6334 __ movq(FieldOperand(rbx, kScratchRegister, times_pointer_size,
6336 __ ret(0);
6339 __ bind(&double_elements);
6341 __ movq(r9, FieldOperand(rbx, JSObject::kElementsOffset));
6342 __ SmiToInteger32(r11, rcx);
6343 __ StoreNumberToDoubleElements(rax,
6348 __ ret(0);
6351 #undef __