Lines Matching defs:ecx
59 __ pop(ecx); // Pop return address.
61 __ push(ecx); // Push return address.
70 __ AllocateInNewSpace(JSFunction::kSize, eax, ebx, ecx, &gc, TAG_OBJECT);
81 __ mov(ecx, Operand(esi, Context::SlotOffset(Context::GLOBAL_INDEX)));
82 __ mov(ecx, FieldOperand(ecx, GlobalObject::kGlobalContextOffset));
83 __ mov(ecx, Operand(ecx, Context::SlotOffset(map_index)));
84 __ mov(FieldOperand(eax, JSObject::kMapOffset), ecx);
111 __ pop(ecx); // Temporarily remove return address.
116 __ push(ecx); // Restore return address.
126 eax, ebx, ecx, &gc, TAG_OBJECT);
129 __ mov(ecx, Operand(esp, 1 * kPointerSize));
140 __ mov(Operand(eax, Context::SlotOffset(Context::CLOSURE_INDEX)), ecx);
174 eax, ebx, ecx, &gc, TAG_OBJECT);
177 __ mov(ecx, Operand(esp, 1 * kPointerSize));
194 __ JumpIfNotSmi(ecx, &after_sentinel, Label::kNear);
197 __ cmp(ecx, 0);
200 __ mov(ecx, GlobalObjectOperand());
201 __ mov(ecx, FieldOperand(ecx, GlobalObject::kGlobalContextOffset));
202 __ mov(ecx, ContextOperand(ecx, Context::CLOSURE_INDEX));
206 __ mov(ContextOperand(eax, Context::CLOSURE_INDEX), ecx);
242 // ecx: boilerplate literal array.
261 __ mov(ebx, FieldOperand(ecx, i));
269 __ mov(ecx, FieldOperand(ecx, JSArray::kElementsOffset));
276 __ mov(ebx, FieldOperand(ecx, i));
283 __ mov(ebx, FieldOperand(ecx, i));
287 __ fld_d(FieldOperand(ecx, i));
304 // Load boilerplate object into ecx and check if we need to create a
306 __ mov(ecx, Operand(esp, 3 * kPointerSize));
311 __ mov(ecx, FieldOperand(ecx, eax, times_half_pointer_size,
314 __ cmp(ecx, factory->undefined_value());
319 // ecx is boilerplate object.
322 __ mov(ebx, FieldOperand(ecx, JSArray::kElementsOffset));
355 __ push(ecx);
356 __ mov(ecx, FieldOperand(ecx, JSArray::kElementsOffset));
357 __ cmp(FieldOperand(ecx, HeapObject::kMapOffset), expected_map);
359 __ pop(ecx);
379 // Load boilerplate object into ecx and check if we need to create a
382 __ mov(ecx, Operand(esp, 4 * kPointerSize));
387 __ mov(ecx, FieldOperand(ecx, eax, times_half_pointer_size,
390 __ cmp(ecx, factory->undefined_value());
396 __ mov(eax, FieldOperand(ecx, HeapObject::kMapOffset));
405 __ mov(ebx, FieldOperand(ecx, i));
535 __ PrepareCallCFunction(argument_count, ecx);
579 __ pop(ecx); // Get return address, operand is now on top of stack.
582 __ push(ecx); // Push return address.
630 // and ecx.
637 // are in eax and ecx. Checks that the original numbers were in the int32
668 // Trashes edi and ebx. Dest is ecx. Source cannot be ecx or one of the
674 ASSERT(!source.is(ecx) && !source.is(edi) && !source.is(ebx));
696 __ mov(ecx, Operand(esp, 0)); // Load low word of answer into ecx.
699 // Load ecx with zero. We use this either for the final shift or
701 __ xor_(ecx, ecx);
736 __ mov(ecx, FieldOperand(source, HeapNumber::kMantissaOffset));
739 __ shr(ecx, 32 - big_shift_distance);
740 __ or_(ecx, scratch2);
741 // We have the answer in ecx, but we may need to negate it.
744 __ neg(ecx);
750 // Zero in ecx.
757 // ecx already has a Smi zero.
762 __ mov(ecx, Immediate(30));
763 __ sub(ecx, scratch2);
766 // Here ecx is the shift, scratch is the exponent word.
786 // Now the unsigned answer is in scratch2. We need to move it to ecx and
789 __ xor_(ecx, ecx);
790 __ cmp(ecx, FieldOperand(source, HeapNumber::kExponentOffset));
792 __ mov(ecx, scratch2);
795 __ sub(ecx, scratch2);
835 __ pop(ecx); // Save return address.
842 __ push(ecx); // Push return address.
982 __ AllocateHeapNumber(eax, ebx, ecx, &slow_allocate_heapnumber);
995 __ mov(ecx, FieldOperand(edx, HeapNumber::kExponentOffset));
996 __ xor_(ecx, HeapNumber::kSignMask); // Flip sign.
997 __ mov(FieldOperand(eax, HeapNumber::kExponentOffset), ecx);
998 __ mov(ecx, FieldOperand(edx, HeapNumber::kMantissaOffset));
999 __ mov(FieldOperand(eax, HeapNumber::kMantissaOffset), ecx);
1011 // Convert the heap number in eax to an untagged integer in ecx.
1016 __ not_(ecx);
1017 __ cmp(ecx, 0xc0000000);
1022 __ lea(eax, Operand(ecx, times_2, kSmiTag));
1047 __ not_(ecx);
1053 __ cvtsi2sd(xmm0, ecx);
1056 __ push(ecx);
1058 __ pop(ecx);
1104 __ pop(ecx); // pop return address.
1106 __ push(ecx); // push return address
1121 __ pop(ecx); // Save return address.
1131 __ push(ecx); // Push return address.
1146 __ pop(ecx); // Save return address.
1154 __ push(ecx); // Push return address.
1238 Register combined = ecx;
1244 ASSERT(!left.is(ecx) && !right.is(ecx));
1245 __ mov(ecx, right);
1264 // Move the right operand into ecx for the shift operation, use eax
1266 ASSERT(!left.is(ecx) && !right.is(ecx));
1267 __ mov(ecx, right);
1302 __ SmiUntag(ecx);
1316 __ SmiUntag(ecx);
1327 __ SmiUntag(ecx);
1479 __ AllocateHeapNumber(eax, ecx, ebx, slow);
1533 __ AllocateHeapNumber(ecx, ebx, no_reg, slow);
1544 __ movdbl(FieldOperand(ecx, HeapNumber::kValueOffset), xmm0);
1554 __ fstp_d(FieldOperand(ecx, HeapNumber::kValueOffset));
1556 __ mov(eax, ecx);
1575 // Right operand is saved in ecx and eax was destroyed by the smi
1577 __ mov(eax, ecx);
1667 __ CmpObjectType(left, FIRST_NONSTRING_TYPE, ecx);
1672 __ CmpObjectType(right, FIRST_NONSTRING_TYPE, ecx);
1699 FloatingPointHelper::CheckSSE2OperandsAreInt32(masm, ¬_int32, ecx);
1709 __ cvttsd2si(ecx, Operand(xmm0));
1710 __ cvtsi2sd(xmm2, ecx);
1722 ecx,
1764 FloatingPointHelper::CheckSSE2OperandsAreInt32(masm, ¬_int32, ecx);
1772 case Token::BIT_OR: __ or_(eax, ecx); break;
1773 case Token::BIT_AND: __ and_(eax, ecx); break;
1774 case Token::BIT_XOR: __ xor_(eax, ecx); break;
1810 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1946 ecx,
1986 case Token::BIT_OR: __ or_(eax, ecx); break;
1987 case Token::BIT_AND: __ and_(eax, ecx); break;
1988 case Token::BIT_XOR: __ xor_(eax, ecx); break;
2024 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
2150 ecx,
2185 case Token::BIT_OR: __ or_(eax, ecx); break;
2186 case Token::BIT_AND: __ and_(eax, ecx); break;
2187 case Token::BIT_XOR: __ xor_(eax, ecx); break;
2223 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
2304 __ CmpObjectType(left, FIRST_NONSTRING_TYPE, ecx);
2314 __ CmpObjectType(right, FIRST_NONSTRING_TYPE, ecx);
2338 __ AllocateHeapNumber(ebx, ecx, no_reg, alloc_failure);
2355 __ AllocateHeapNumber(ebx, ecx, no_reg, alloc_failure);
2367 __ pop(ecx);
2370 __ push(ecx);
2438 __ mov(ecx, ebx);
2439 __ xor_(ecx, edx);
2440 __ mov(eax, ecx);
2442 __ xor_(ecx, eax);
2443 __ mov(eax, ecx);
2445 __ xor_(ecx, eax);
2447 __ and_(ecx,
2453 // ecx = TranscendentalCache::hash(double value).
2478 // Find the address of the ecx'th entry in the cache, i.e., &eax[ecx*12].
2479 __ lea(ecx, Operand(ecx, ecx, times_2, 0));
2480 __ lea(ecx, Operand(eax, ecx, times_4, 0));
2483 __ cmp(ebx, Operand(ecx, 0));
2485 __ cmp(edx, Operand(ecx, kIntSize));
2490 __ mov(eax, Operand(ecx, 2 * kIntSize));
2514 __ mov(Operand(ecx, 0), ebx);
2515 __ mov(Operand(ecx, kIntSize), edx);
2516 __ mov(Operand(ecx, 2 * kIntSize), eax);
2680 // Output: eax, ecx are left and right integers for a bit op.
2708 // Get the untagged integer version of the edx heap number in ecx.
2710 __ mov(edx, ecx);
2719 __ mov(ecx, eax);
2726 __ mov(ecx, Immediate(0));
2734 // Get the untagged integer version of the eax heap number in ecx.
2946 const Register scratch = ecx;
3217 __ mov(ecx, Operand(ebx, StandardFrameConstants::kContextOffset));
3218 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3239 __ mov(ecx, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3240 __ cmp(edx, ecx);
3246 __ lea(ebx, Operand(ebx, ecx, times_2, 0));
3270 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
3271 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3275 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3276 __ mov(Operand(esp, 1 * kPointerSize), ecx);
3277 __ lea(edx, Operand(edx, ecx, times_2,
3301 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
3302 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3306 __ mov(ecx, ebx);
3311 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3312 __ lea(edx, Operand(edx, ecx, times_2,
3317 // ecx = argument count (tagged)
3320 // Compute the mapped parameter count = min(ebx, ecx) in ebx.
3321 __ cmp(ebx, ecx);
3323 __ mov(ebx, ecx);
3341 __ lea(ebx, Operand(ebx, ecx, times_2, FixedArray::kHeaderSize));
3350 // ecx = argument count (tagged)
3372 // ecx = argument count (tagged)
3394 ecx);
3404 // ecx = argument count (tagged)
3434 __ push(ecx);
3439 __ mov(ecx, FACTORY->the_hole_value());
3444 // ecx = the hole value
3457 __ mov(FieldOperand(edi, eax, times_2, FixedArray::kHeaderSize), ecx);
3462 __ pop(ecx);
3466 // ecx = argument count (tagged)
3475 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx);
3491 __ cmp(ebx, ecx);
3504 __ mov(Operand(esp, 1 * kPointerSize), ecx); // Patch argument count.
3518 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
3519 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3523 __ mov(ecx, Operand(esp, 1 * kPointerSize));
3528 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3529 __ mov(Operand(esp, 1 * kPointerSize), ecx);
3530 __ lea(edx, Operand(edx, ecx, times_2,
3538 __ test(ecx, ecx);
3540 __ lea(ecx, Operand(ecx, times_2, FixedArray::kHeaderSize));
3542 __ add(ecx, Immediate(Heap::kArgumentsObjectSizeStrict));
3545 __ AllocateInNewSpace(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
3562 __ mov(ecx, Operand(esp, 1 * kPointerSize));
3565 ecx);
3569 __ test(ecx, ecx);
3582 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx);
3584 __ SmiUntag(ecx);
3593 __ dec(ecx);
3642 __ CmpObjectType(eax, JS_REGEXP_TYPE, ecx);
3645 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
3647 __ test(ecx, Immediate(kSmiTagMask));
3649 __ CmpObjectType(ecx, FIXED_ARRAY_TYPE, ebx);
3653 // ecx: RegExp data (FixedArray)
3655 __ mov(ebx, FieldOperand(ecx, JSRegExp::kDataTagOffset));
3659 // ecx: RegExp data (FixedArray)
3661 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
3671 // ecx: RegExp data (FixedArray)
3682 // ecx: RegExp data (FixedArray)
3691 // ecx: RegExp data (FixedArray)
3714 // ecx: RegExp data (FixedArray)
3783 // ecx: RegExp data (FixedArray)
3784 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataAsciiCodeOffset));
3785 __ Set(ecx, Immediate(1)); // Type is ASCII.
3790 // ecx: RegExp data (FixedArray)
3791 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataUC16CodeOffset));
3792 __ Set(ecx, Immediate(0)); // Type is two byte.
3802 // ecx: encoding of subject string (1 if ASCII, 0 if two_byte);
3811 // ecx: encoding of subject string (1 if ASCII 0 if two_byte);
3851 // ecx: encoding of subject string (1 if ASCII 0 if two_byte);
3865 __ test(ecx, ecx);
3868 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqAsciiString::kHeaderSize));
3869 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Argument 4.
3870 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqAsciiString::kHeaderSize));
3871 __ mov(Operand(esp, 2 * kPointerSize), ecx); // Argument 3.
3877 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqTwoByteString::kHeaderSize));
3878 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Argument 4.
3879 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
3880 __ mov(Operand(esp, 2 * kPointerSize), ecx); // Argument 3.
3936 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
3937 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
3973 __ mov(ecx, Immediate(address_of_static_offsets_vector));
3976 // ecx: offsets vector
3985 __ mov(edi, Operand(ecx, edx, times_int_size, 0));
4046 ecx, // Out: End of allocation.
4058 __ mov(ecx, Immediate(factory->empty_fixed_array()));
4062 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ecx);
4067 __ mov(ecx, Operand(esp, kPointerSize * 1));
4068 __ mov(FieldOperand(eax, JSRegExpResult::kInputOffset), ecx);
4069 __ mov(ecx, Operand(esp, kPointerSize * 2));
4070 __ mov(FieldOperand(eax, JSRegExpResult::kIndexOffset), ecx);
4071 __ mov(ecx, Operand(esp, kPointerSize * 3));
4072 __ mov(FieldOperand(eax, JSArray::kLengthOffset), ecx);
4077 // ecx: Number of elements in array, as smi.
4083 __ mov(FieldOperand(ebx, FixedArray::kLengthOffset), ecx);
4085 __ SmiUntag(ecx);
4090 // ecx: Number of elements to fill.
4094 __ test(ecx, ecx);
4096 __ j(less_equal, &done, Label::kNear); // Jump if ecx is negative or zero.
4097 __ sub(ecx, Immediate(1));
4098 __ mov(Operand(ebx, ecx, times_pointer_size, 0), edx);
4211 GenerateLookupNumberStringCache(masm, ebx, eax, ecx, edx, false, &runtime);
4235 __ mov(ecx, edx);
4236 __ or_(ecx, eax);
4237 __ JumpIfNotSmi(ecx, &non_smi, Label::kNear);
4246 __ mov(ecx, edx);
4247 __ or_(ecx, eax);
4248 __ test(ecx, Immediate(kSmiTagMask));
4286 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
4341 __ mov(ecx, Immediate(kSmiTagMask));
4342 __ and_(ecx, eax);
4343 __ test(ecx, edx);
4349 // ecx still holds eax & kSmiTag, which is either zero or one.
4350 __ sub(ecx, Immediate(0x01));
4353 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
4375 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
4386 __ CmpInstanceType(ecx, ODDBALL_TYPE);
4389 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ecx);
4393 __ CmpInstanceType(ecx, ODDBALL_TYPE);
4415 __ mov(ecx, Immediate(Smi::FromInt(1)));
4416 __ cmov(above, eax, ecx);
4417 __ mov(ecx, Immediate(Smi::FromInt(-1)));
4418 __ cmov(below, eax, ecx);
4465 BranchIfNonSymbol(masm, &check_for_strings, eax, ecx);
4466 BranchIfNonSymbol(masm, &check_for_strings, edx, ecx);
4476 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx,
4484 ecx,
4490 ecx,
4510 __ lea(ecx, Operand(eax, edx, times_1, 0));
4511 __ test(ecx, Immediate(kSmiTagMask));
4513 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
4520 __ test_b(FieldOperand(ecx, Map::kBitFieldOffset),
4537 __ pop(ecx);
4551 __ push(ecx);
4591 // Load the cache state into ecx.
4592 __ mov(ecx, FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset));
4596 __ cmp(ecx, edi);
4598 __ cmp(ecx, Immediate(TypeFeedbackCells::MegamorphicSentinel(isolate)));
4603 __ cmp(ecx, Immediate(TypeFeedbackCells::UninitializedSentinel(isolate)));
4638 __ mov(ecx, GlobalObjectOperand());
4639 __ mov(ecx, FieldOperand(ecx, GlobalObject::kGlobalReceiverOffset));
4640 __ mov(Operand(esp, (argc_ + 1) * kPointerSize), ecx);
4647 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
4684 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
4686 __ pop(ecx);
4688 __ push(ecx);
4691 __ SetCallKind(ecx, CALL_AS_FUNCTION);
4704 __ SetCallKind(ecx, CALL_AS_METHOD);
4720 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
4735 // ecx: object map
4738 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
4750 __ SetCallKind(ecx, CALL_AS_METHOD);
4850 __ lea(ecx, Operand(eax, 1));
4851 // Lower 2 bits of ecx are 0 iff eax has failure tag.
4852 __ test(ecx, Immediate(kFailureTagMask));
5110 Register scratch = ecx;
5532 GenerateConvertArgument(masm, 2 * kPointerSize, eax, ebx, ecx, edi,
5537 GenerateConvertArgument(masm, 1 * kPointerSize, edx, ebx, ecx, edi,
5548 __ mov(ecx, FieldOperand(edx, String::kLengthOffset));
5550 __ test(ecx, ecx);
5569 // ecx: length of second string as a smi
5574 __ add(ebx, ecx);
5584 __ JumpIfNotBothSequentialAsciiStrings(eax, edx, ebx, ecx, &call_runtime);
5588 __ movzx_b(ecx, FieldOperand(edx, SeqAsciiString::kHeaderSize));
5594 masm, ebx, ecx, eax, edx, edi,
5606 __ movzx_b(ecx, FieldOperand(edx, SeqAsciiString::kHeaderSize));
5611 __ shl(ecx, kBitsPerByte);
5612 __ or_(ebx, ecx);
5627 __ movzx_b(ecx, FieldOperand(edi, Map::kInstanceTypeOffset));
5630 __ and_(ecx, edi);
5633 __ test(ecx, Immediate(kStringEncodingMask));
5637 __ AllocateAsciiConsString(ecx, edi, no_reg, &call_runtime);
5641 __ mov(FieldOperand(ecx, ConsString::kLengthOffset), ebx);
5642 __ mov(FieldOperand(ecx, ConsString::kHashFieldOffset),
5644 __ mov(FieldOperand(ecx, ConsString::kFirstOffset), eax);
5645 __ mov(FieldOperand(ecx, ConsString::kSecondOffset), edx);
5646 __ mov(eax, ecx);
5652 // ecx: first instance type AND second instance type.
5654 __ test(ecx, Immediate(kAsciiDataHintMask));
5656 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
5657 __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
5658 __ xor_(edi, ecx);
5664 __ AllocateTwoByteConsString(ecx, edi, no_reg, &call_runtime);
5677 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
5678 __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
5679 // ecx: instance type of first string
5681 __ test_b(ecx, kStringRepresentationMask);
5685 __ test_b(ecx, kShortExternalStringMask);
5698 __ xor_(ecx, edi);
5699 __ test_b(ecx, kStringEncodingMask);
5729 __ AllocateAsciiString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
5731 __ mov(ecx, eax);
5733 __ add(ecx, Immediate(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5741 // ecx: first character of result
5744 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
5752 // ecx: next character of result
5755 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
5766 __ AllocateTwoByteString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
5768 __ mov(ecx, eax);
5770 __ add(ecx, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5778 // ecx: first character of result
5781 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
5789 // ecx: next character of result
5792 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
5890 ASSERT(count.is(ecx)); // rep movs count
6158 __ mov(ecx, Operand(esp, 1 * kPointerSize)); // To index.
6159 __ JumpIfNotSmi(ecx, &runtime);
6162 __ sub(ecx, edx);
6163 __ cmp(ecx, FieldOperand(eax, String::kLengthOffset));
6173 // ecx: sub string length (smi)
6218 // ecx: length (smi)
6219 __ cmp(ecx, Immediate(Smi::FromInt(SlicedString::kMinLength)));
6237 __ mov(FieldOperand(eax, SlicedString::kLengthOffset), ecx);
6251 // ecx: length (smi)
6274 __ SmiUntag(ecx);
6280 __ AllocateAsciiString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
6283 // ecx: result string length
6295 // ecx: result length
6299 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, true);
6306 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
6309 // ecx: result string length
6325 // ecx: result length
6329 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, false);
6493 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx, &runtime);
6497 __ pop(ecx);
6499 __ push(ecx);
6500 GenerateCompareFlatAsciiStrings(masm, edx, eax, ecx, ebx, edi);
6512 __ mov(ecx, edx);
6513 __ or_(ecx, eax);
6514 __ JumpIfNotSmi(ecx, &miss, Label::kNear);
6541 __ mov(ecx, edx);
6542 __ and_(ecx, eax);
6543 __ JumpIfSmi(ecx, &generic_stub, Label::kNear);
6545 __ CmpObjectType(eax, HEAP_NUMBER_TYPE, ecx);
6547 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
6569 __ mov(ecx, Immediate(Smi::FromInt(1)));
6570 __ cmov(above, eax, ecx);
6571 __ mov(ecx, Immediate(Smi::FromInt(-1)));
6572 __ cmov(below, eax, ecx);
6585 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
6608 Register tmp1 = ecx;
6655 Register tmp1 = ecx;
6738 __ mov(ecx, edx);
6739 __ and_(ecx, eax);
6740 __ JumpIfSmi(ecx, &miss, Label::kNear);
6742 __ CmpObjectType(eax, JS_OBJECT_TYPE, ecx);
6744 __ CmpObjectType(edx, JS_OBJECT_TYPE, ecx);
6758 __ mov(ecx, edx);
6759 __ and_(ecx, eax);
6760 __ JumpIfSmi(ecx, &miss, Label::kNear);
6762 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
6764 __ cmp(ecx, known_map_);
7033 { REG(ebx), REG(ecx), REG(edx), EMIT_REMEMBERED_SET },
7036 { REG(ebx), REG(ecx), REG(edx), OMIT_REMEMBERED_SET },
7039 { REG(edx), REG(ecx), REG(ebx), EMIT_REMEMBERED_SET },
7042 { REG(ebx), REG(ecx), REG(edx), EMIT_REMEMBERED_SET },
7046 { REG(ebx), REG(edx), REG(ecx), EMIT_REMEMBERED_SET},
7048 { REG(edi), REG(ebx), REG(ecx), EMIT_REMEMBERED_SET},
7059 { REG(ebx), REG(eax), REG(ecx), EMIT_REMEMBERED_SET},
7309 // -- ecx : element index as smi
7334 __ push(ecx);
7350 __ lea(ecx, FieldOperand(ebx, ecx, times_half_pointer_size,
7352 __ mov(Operand(ecx, 0), eax);
7354 __ RecordWrite(ebx, ecx, eax,
7364 __ mov(FieldOperand(ebx, ecx, times_half_pointer_size,
7375 ecx,
