Lines Matching defs:ecx
59 static Register registers[] = { eax, ebx, ecx };
70 static Register registers[] = { eax, ebx, ecx, edx };
91 static Register registers[] = { edx, ecx };
122 static Register registers[] = { edx, ecx, eax };
256 static Register registers[] = { edx, ecx, eax };
267 static Register registers[] = { eax, ebx, ecx, edx };
308 __ Allocate(JSFunction::kSize, eax, ebx, ecx, &gc, TAG_OBJECT);
319 __ mov(ecx, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
320 __ mov(ecx, FieldOperand(ecx, GlobalObject::kNativeContextOffset));
321 __ mov(ebx, Operand(ecx, Context::SlotOffset(map_index)));
360 // ecx holds native context, ebx points to fixed array of 3-element entries
366 __ cmp(ecx, FieldOperand(ebx, SharedFunctionInfo::kFirstContextSlot));
378 __ cmp(ecx, CodeGenerator::FixedArrayElementOperand(ebx, edx, 0));
393 __ mov(edx, ContextOperand(ecx, Context::OPTIMIZED_FUNCTIONS_LIST));
398 __ mov(ContextOperand(ecx, Context::OPTIMIZED_FUNCTIONS_LIST), eax);
403 ecx,
419 __ pop(ecx); // Temporarily remove return address.
424 __ push(ecx); // Restore return address.
434 eax, ebx, ecx, &gc, TAG_OBJECT);
437 __ mov(ecx, Operand(esp, 1 * kPointerSize));
448 __ mov(Operand(eax, Context::SlotOffset(Context::CLOSURE_INDEX)), ecx);
481 __ Allocate(FixedArray::SizeFor(length), eax, ebx, ecx, &gc, TAG_OBJECT);
484 __ mov(ecx, Operand(esp, 1 * kPointerSize));
501 __ JumpIfNotSmi(ecx, &after_sentinel, Label::kNear);
503 __ cmp(ecx, 0);
506 __ mov(ecx, GlobalObjectOperand());
507 __ mov(ecx, FieldOperand(ecx, GlobalObject::kNativeContextOffset));
508 __ mov(ecx, ContextOperand(ecx, Context::CLOSURE_INDEX));
512 __ mov(ContextOperand(eax, Context::CLOSURE_INDEX), ecx);
557 __ PrepareCallCFunction(argument_count, ecx);
609 // and ecx.
666 // Since we must use ecx for shifts below, use some other register (eax)
667 // to calculate the result if ecx is the requested return register.
668 Register result_reg = final_result_reg.is(ecx) ? eax : final_result_reg;
669 // Save ecx if it isn't the return register and therefore volatile, or if it
672 Register save_reg = final_result_reg.is(ecx) ? eax : ecx;
683 __ mov(ecx, exponent_operand);
684 if (stash_exponent_copy) __ push(ecx);
686 __ and_(ecx, HeapNumber::kExponentMask);
687 __ shr(ecx, HeapNumber::kExponentShift);
688 __ lea(result_reg, MemOperand(ecx, -HeapNumber::kExponentBias));
697 __ sub(ecx, Immediate(delta));
699 __ cmp(ecx, Immediate(31));
722 __ sub(ecx, Immediate(delta));
723 __ neg(ecx);
735 __ test(ecx, Immediate(32));
773 ASSERT(final_result_reg.is(ecx));
784 // Result is in ecx. Trashes ebx, xmm0, and xmm1.
790 masm, conversion_failure, xmm0, ecx, ebx, xmm1);
800 __ pop(ecx); // Save return address.
806 __ push(ecx); // Push return address.
821 __ pop(ecx); // Save return address.
825 __ push(ecx); // Push return address.
838 __ pop(ecx);
841 __ push(ecx);
866 Register combined = ecx;
872 ASSERT(!left.is(ecx) && !right.is(ecx));
873 __ mov(ecx, right);
892 // Move the right operand into ecx for the shift operation, use eax
894 ASSERT(!left.is(ecx) && !right.is(ecx));
895 __ mov(ecx, right);
930 __ SmiUntag(ecx);
944 __ SmiUntag(ecx);
955 __ SmiUntag(ecx);
1107 __ AllocateHeapNumber(eax, ecx, ebx, slow);
1161 __ AllocateHeapNumber(ecx, ebx, no_reg, slow);
1172 __ movdbl(FieldOperand(ecx, HeapNumber::kValueOffset), xmm0);
1182 __ fstp_d(FieldOperand(ecx, HeapNumber::kValueOffset));
1184 __ mov(eax, ecx);
1203 // Right operand is saved in ecx and eax was destroyed by the smi
1205 __ mov(eax, ecx);
1325 __ CmpObjectType(left, FIRST_NONSTRING_TYPE, ecx);
1330 __ CmpObjectType(right, FIRST_NONSTRING_TYPE, ecx);
1381 masm, ¬_int32, xmm0, ebx, ecx, xmm2);
1383 masm, ¬_int32, xmm1, edi, ecx, xmm2);
1402 masm, ¬_int32, xmm0, ecx, ecx, xmm2);
1412 ecx,
1460 case Token::BIT_OR: __ or_(eax, ecx); break;
1461 case Token::BIT_AND: __ and_(eax, ecx); break;
1462 case Token::BIT_XOR: __ xor_(eax, ecx); break;
1498 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1619 masm, ¬_floats, xmm0, ecx, ecx, xmm2);
1623 masm, ¬_floats, xmm1, ecx, ecx, xmm2);
1640 ecx,
1684 case Token::BIT_OR: __ or_(eax, ecx); break;
1685 case Token::BIT_AND: __ and_(eax, ecx); break;
1686 case Token::BIT_XOR: __ xor_(eax, ecx); break;
1722 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1833 ecx,
1872 case Token::BIT_OR: __ or_(eax, ecx); break;
1873 case Token::BIT_AND: __ and_(eax, ecx); break;
1874 case Token::BIT_XOR: __ xor_(eax, ecx); break;
1910 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1976 __ CmpObjectType(left, FIRST_NONSTRING_TYPE, ecx);
1987 __ CmpObjectType(right, FIRST_NONSTRING_TYPE, ecx);
2011 __ AllocateHeapNumber(ebx, ecx, no_reg, alloc_failure);
2028 __ AllocateHeapNumber(ebx, ecx, no_reg, alloc_failure);
2040 __ pop(ecx);
2043 __ push(ecx);
2112 __ mov(ecx, ebx);
2113 __ xor_(ecx, edx);
2114 __ mov(eax, ecx);
2116 __ xor_(ecx, eax);
2117 __ mov(eax, ecx);
2119 __ xor_(ecx, eax);
2121 __ and_(ecx,
2127 // ecx = TranscendentalCache::hash(double value).
2152 // Find the address of the ecx'th entry in the cache, i.e., &eax[ecx*12].
2153 __ lea(ecx, Operand(ecx, ecx, times_2, 0));
2154 __ lea(ecx, Operand(eax, ecx, times_4, 0));
2157 __ cmp(ebx, Operand(ecx, 0));
2159 __ cmp(edx, Operand(ecx, kIntSize));
2164 __ mov(eax, Operand(ecx, 2 * kIntSize));
2190 __ mov(Operand(ecx, 0), ebx);
2191 __ mov(Operand(ecx, kIntSize), edx);
2192 __ mov(Operand(ecx, 2 * kIntSize), eax);
2358 // Output: eax, ecx are left and right integers for a bit op.
2394 // Get the untagged integer version of the edx heap number in ecx.
2399 DoubleToIStub stub(edx, ecx, HeapNumber::kValueOffset - kHeapObjectTag,
2403 __ mov(edx, ecx);
2416 __ mov(ecx, eax);
2423 __ mov(ecx, Immediate(0));
2430 // Get the untagged integer version of the eax heap number in ecx.
2436 DoubleToIStub stub(eax, ecx, HeapNumber::kValueOffset - kHeapObjectTag,
2639 const Register scratch = ecx;
2904 // -- ecx : name
2911 __ cmp(ecx, Immediate(masm->isolate()->factory()->prototype_string()));
2924 // -- ecx : name
2931 __ cmp(ecx, Immediate(masm->isolate()->factory()->length_string()));
2946 // -- ecx : name
2963 __ cmp(ecx, Immediate(masm->isolate()->factory()->length_string()));
3023 __ mov(ecx, Operand(ebx, StandardFrameConstants::kContextOffset));
3024 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3045 __ mov(ecx, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3046 __ cmp(edx, ecx);
3052 __ lea(ebx, Operand(ebx, ecx, times_2, 0));
3076 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
3077 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3081 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3082 __ mov(Operand(esp, 1 * kPointerSize), ecx);
3083 __ lea(edx, Operand(edx, ecx, times_2,
3109 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
3110 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3114 __ mov(ecx, ebx);
3119 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3120 __ lea(edx, Operand(edx, ecx, times_2,
3125 // ecx = argument count (tagged)
3128 // Compute the mapped parameter count = min(ebx, ecx) in ebx.
3129 __ cmp(ebx, ecx);
3131 __ mov(ebx, ecx);
3149 __ lea(ebx, Operand(ebx, ecx, times_2, FixedArray::kHeaderSize));
3158 // ecx = argument count (tagged)
3180 // ecx = argument count (tagged)
3202 ecx);
3212 // ecx = argument count (tagged)
3242 __ push(ecx);
3247 __ mov(ecx, isolate->factory()->the_hole_value());
3252 // ecx = the hole value
3265 __ mov(FieldOperand(edi, eax, times_2, FixedArray::kHeaderSize), ecx);
3270 __ pop(ecx);
3274 // ecx = argument count (tagged)
3283 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx);
3299 __ cmp(ebx, ecx);
3312 __ mov(Operand(esp, 1 * kPointerSize), ecx); // Patch argument count.
3328 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
3329 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3333 __ mov(ecx, Operand(esp, 1 * kPointerSize));
3338 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3339 __ mov(Operand(esp, 1 * kPointerSize), ecx);
3340 __ lea(edx, Operand(edx, ecx, times_2,
3348 __ test(ecx, ecx);
3350 __ lea(ecx, Operand(ecx, times_2, FixedArray::kHeaderSize));
3352 __ add(ecx, Immediate(Heap::kArgumentsObjectSizeStrict));
3355 __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
3372 __ mov(ecx, Operand(esp, 1 * kPointerSize));
3375 ecx);
3379 __ test(ecx, ecx);
3392 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), ecx);
3394 __ SmiUntag(ecx);
3403 __ dec(ecx);
3453 __ CmpObjectType(eax, JS_REGEXP_TYPE, ecx);
3457 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
3459 __ test(ecx, Immediate(kSmiTagMask));
3461 __ CmpObjectType(ecx, FIXED_ARRAY_TYPE, ebx);
3465 // ecx: RegExp data (FixedArray)
3467 __ mov(ebx, FieldOperand(ecx, JSRegExp::kDataTagOffset));
3471 // ecx: RegExp data (FixedArray)
3473 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
3494 // ecx: RegExp data (FixedArray)
3567 // ecx: RegExp data (FixedArray)
3577 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataAsciiCodeOffset));
3578 __ Set(ecx, Immediate(1)); // Type is one byte.
3591 // ecx: encoding of subject string (1 if ASCII, 0 if two_byte);
3636 // ecx: encoding of subject string (1 if ASCII 0 if two_byte);
3650 __ test(ecx, ecx);
3653 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqOneByteString::kHeaderSize));
3654 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Argument 4.
3655 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqOneByteString::kHeaderSize));
3656 __ mov(Operand(esp, 2 * kPointerSize), ecx); // Argument 3.
3662 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqTwoByteString::kHeaderSize));
3663 __ mov(Operand(esp, 3 * kPointerSize), ecx); // Argument 4.
3664 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
3665 __ mov(Operand(esp, 2 * kPointerSize), ecx); // Argument 3.
3723 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
3724 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
3758 __ mov(ecx, eax);
3765 __ mov(eax, ecx);
3776 __ mov(ecx, Immediate(address_of_static_offsets_vector));
3779 // ecx: offsets vector
3788 __ mov(edi, Operand(ecx, edx, times_int_size, 0));
3835 // ecx: RegExp data (FixedArray)
3845 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataUC16CodeOffset));
3846 __ Set(ecx, Immediate(0)); // Type is two byte.
3884 ecx, // Out: End of allocation.
3896 __ mov(ecx, Immediate(factory->empty_fixed_array()));
3900 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ecx);
3905 __ mov(ecx, Operand(esp, kPointerSize * 1));
3906 __ mov(FieldOperand(eax, JSRegExpResult::kInputOffset), ecx);
3907 __ mov(ecx, Operand(esp, kPointerSize * 2));
3908 __ mov(FieldOperand(eax, JSRegExpResult::kIndexOffset), ecx);
3909 __ mov(ecx, Operand(esp, kPointerSize * 3));
3910 __ mov(FieldOperand(eax, JSArray::kLengthOffset), ecx);
3915 // ecx: Number of elements in array, as smi.
3921 __ mov(FieldOperand(ebx, FixedArray::kLengthOffset), ecx);
3923 __ SmiUntag(ecx);
3928 // ecx: Number of elements to fill.
3932 __ test(ecx, ecx);
3934 __ j(less_equal, &done, Label::kNear); // Jump if ecx is negative or zero.
3935 __ sub(ecx, Immediate(1));
3936 __ mov(Operand(ebx, ecx, times_pointer_size, 0), edx);
4038 GenerateLookupNumberStringCache(masm, ebx, eax, ecx, edx, &runtime);
4097 __ mov(ecx, edx);
4098 __ or_(ecx, eax);
4099 __ JumpIfNotSmi(ecx, &non_smi, Label::kNear);
4137 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
4160 __ mov(ecx, Immediate(kSmiTagMask));
4161 __ and_(ecx, eax);
4162 __ test(ecx, edx);
4168 // ecx still holds eax & kSmiTag, which is either zero or one.
4169 __ sub(ecx, Immediate(0x01));
4172 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
4194 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
4205 __ CmpInstanceType(ecx, ODDBALL_TYPE);
4208 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ecx);
4212 __ CmpInstanceType(ecx, ODDBALL_TYPE);
4234 __ mov(ecx, Immediate(Smi::FromInt(1)));
4235 __ cmov(above, eax, ecx);
4236 __ mov(ecx, Immediate(Smi::FromInt(-1)));
4237 __ cmov(below, eax, ecx);
4283 BranchIfNotInternalizedString(masm, &check_for_strings, eax, ecx);
4284 BranchIfNotInternalizedString(masm, &check_for_strings, edx, ecx);
4294 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx,
4302 ecx,
4308 ecx,
4328 __ lea(ecx, Operand(eax, edx, times_1, 0));
4329 __ test(ecx, Immediate(kSmiTagMask));
4331 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
4338 __ test_b(FieldOperand(ecx, Map::kBitFieldOffset),
4355 __ pop(ecx);
4369 __ push(ecx);
4399 // Load the cache state into ecx.
4400 __ mov(ecx, FieldOperand(ebx, Cell::kValueOffset));
4404 __ cmp(ecx, edi);
4406 __ cmp(ecx, Immediate(TypeFeedbackCells::MegamorphicSentinel(isolate)));
4412 // AllocationSite. Do a map check on the object in ecx.
4416 __ cmp(FieldOperand(ecx, 0), Immediate(allocation_site_map));
4420 __ LoadGlobalContext(ecx);
4422 __ cmp(edi, Operand(ecx,
4431 __ cmp(ecx, Immediate(TypeFeedbackCells::UninitializedSentinel(isolate)));
4443 __ LoadGlobalContext(ecx);
4445 __ cmp(edi, Operand(ecx,
4495 __ mov(ecx, GlobalObjectOperand());
4496 __ mov(ecx, FieldOperand(ecx, GlobalObject::kGlobalReceiverOffset));
4497 __ mov(Operand(esp, (argc_ + 1) * kPointerSize), ecx);
4504 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
4541 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
4543 __ pop(ecx);
4545 __ push(ecx);
4548 __ SetCallKind(ecx, CALL_AS_FUNCTION);
4561 __ SetCallKind(ecx, CALL_AS_METHOD);
4577 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
4585 Register jmp_reg = ecx;
4594 // ecx: object map
4597 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
4609 __ SetCallKind(ecx, CALL_AS_METHOD);
4732 __ lea(ecx, Operand(eax, 1));
4733 // Lower 2 bits of ecx are 0 iff eax has failure tag.
4734 __ test(ecx, Immediate(kFailureTagMask));
4768 JumpIfOOM(masm, eax, ecx, throw_out_of_memory_exception);
4774 JumpIfOOM(masm, eax, ecx, throw_out_of_memory_exception);
4858 JumpIfOOM(masm, eax, ecx, &already_have_failure);
5001 Register scratch = ecx;
5351 GenerateConvertArgument(masm, 2 * kPointerSize, eax, ebx, ecx, edi,
5356 GenerateConvertArgument(masm, 1 * kPointerSize, edx, ebx, ecx, edi,
5366 __ mov(ecx, FieldOperand(edx, String::kLengthOffset));
5368 __ test(ecx, ecx);
5387 // ecx: length of second string as a smi
5392 __ add(ebx, ecx);
5402 __ JumpIfNotBothSequentialAsciiStrings(eax, edx, ebx, ecx, &call_runtime);
5406 __ movzx_b(ecx, FieldOperand(edx, SeqOneByteString::kHeaderSize));
5412 masm, ebx, ecx, eax, edx, edi,
5424 __ movzx_b(ecx, FieldOperand(edx, SeqOneByteString::kHeaderSize));
5429 __ shl(ecx, kBitsPerByte);
5430 __ or_(ebx, ecx);
5445 __ movzx_b(ecx, FieldOperand(edi, Map::kInstanceTypeOffset));
5448 __ and_(ecx, edi);
5451 __ test(ecx, Immediate(kStringEncodingMask));
5455 __ AllocateAsciiConsString(ecx, edi, no_reg, &call_runtime);
5459 __ mov(FieldOperand(ecx, ConsString::kLengthOffset), ebx);
5460 __ mov(FieldOperand(ecx, ConsString::kHashFieldOffset),
5469 __ mov(FieldOperand(ecx, ConsString::kFirstOffset), eax);
5470 __ RecordWriteField(ecx,
5475 __ mov(FieldOperand(ecx, ConsString::kSecondOffset), edx);
5476 __ RecordWriteField(ecx,
5484 __ mov(FieldOperand(ecx, ConsString::kFirstOffset), eax);
5485 __ mov(FieldOperand(ecx, ConsString::kSecondOffset), edx);
5489 __ mov(eax, ecx);
5495 // ecx: first instance type AND second instance type.
5497 __ test(ecx, Immediate(kOneByteDataHintMask));
5499 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
5500 __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
5501 __ xor_(edi, ecx);
5507 __ AllocateTwoByteConsString(ecx, edi, no_reg, &call_runtime);
5520 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
5521 __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
5522 // ecx: instance type of first string
5524 __ test_b(ecx, kStringRepresentationMask);
5528 __ test_b(ecx, kShortExternalStringMask);
5541 __ xor_(ecx, edi);
5542 __ test_b(ecx, kStringEncodingMask);
5572 __ AllocateAsciiString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
5574 __ mov(ecx, eax);
5576 __ add(ecx, Immediate(SeqOneByteString::kHeaderSize - kHeapObjectTag));
5584 // ecx: first character of result
5587 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
5595 // ecx: next character of result
5598 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
5609 __ AllocateTwoByteString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
5611 __ mov(ecx, eax);
5613 __ add(ecx, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5621 // ecx: first character of result
5624 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
5632 // ecx: next character of result
5635 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
5645 GenerateRegisterArgsPop(masm, ecx);
5660 GenerateRegisterArgsPop(masm, ecx);
5769 ASSERT(count.is(ecx)); // rep movs count
6028 __ mov(ecx, Operand(esp, 1 * kPointerSize)); // To index.
6029 __ JumpIfNotSmi(ecx, &runtime);
6032 __ sub(ecx, edx);
6033 __ cmp(ecx, FieldOperand(eax, String::kLengthOffset));
6046 __ cmp(ecx, Immediate(Smi::FromInt(1)));
6051 // ecx: sub string length (smi)
6096 // ecx: length (smi)
6097 __ cmp(ecx, Immediate(Smi::FromInt(SlicedString::kMinLength)));
6115 __ mov(FieldOperand(eax, SlicedString::kLengthOffset), ecx);
6129 // ecx: length (smi)
6152 __ SmiUntag(ecx);
6158 __ AllocateAsciiString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
6161 // ecx: result string length
6173 // ecx: result length
6177 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, true);
6184 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
6187 // ecx: result string length
6203 // ecx: result length
6207 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, false);
6223 // ecx: sub string length (smi)
6226 eax, edx, ecx, eax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
6388 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx, &runtime);
6392 __ pop(ecx);
6394 __ push(ecx);
6395 GenerateCompareFlatAsciiStrings(masm, edx, eax, ecx, ebx, edi);
6407 __ mov(ecx, edx);
6408 __ or_(ecx, eax);
6409 __ JumpIfNotSmi(ecx, &miss, Label::kNear);
6459 __ mov(ecx, eax); // Can't clobber eax because we can still jump away.
6460 __ SmiUntag(ecx);
6461 __ cvtsi2sd(xmm1, ecx);
6471 __ mov(ecx, edx); // Can't clobber edx because we can still jump away.
6472 __ SmiUntag(ecx);
6473 __ cvtsi2sd(xmm0, ecx);
6485 __ mov(ecx, Immediate(Smi::FromInt(1)));
6486 __ cmov(above, eax, ecx);
6487 __ mov(ecx, Immediate(Smi::FromInt(-1)));
6488 __ cmov(below, eax, ecx);
6491 __ mov(ecx, edx);
6492 __ and_(ecx, eax);
6493 __ JumpIfSmi(ecx, &generic_stub, Label::kNear);
6514 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
6537 Register tmp1 = ecx;
6582 Register tmp1 = ecx;
6629 Register tmp1 = ecx;
6713 __ mov(ecx, edx);
6714 __ and_(ecx, eax);
6715 __ JumpIfSmi(ecx, &miss, Label::kNear);
6717 __ CmpObjectType(eax, JS_OBJECT_TYPE, ecx);
6719 __ CmpObjectType(edx, JS_OBJECT_TYPE, ecx);
6733 __ mov(ecx, edx);
6734 __ and_(ecx, eax);
6735 __ JumpIfSmi(ecx, &miss, Label::kNear);
6737 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
6739 __ cmp(ecx, known_map_);
6999 { REG(ebx), REG(ecx), REG(edx), EMIT_REMEMBERED_SET },
7002 { REG(ebx), REG(ecx), REG(edx), OMIT_REMEMBERED_SET },
7005 { REG(edx), REG(ecx), REG(ebx), EMIT_REMEMBERED_SET },
7008 { REG(ebx), REG(ecx), REG(edx), EMIT_REMEMBERED_SET },
7012 { REG(ebx), REG(edx), REG(ecx), EMIT_REMEMBERED_SET},
7014 { REG(edi), REG(ebx), REG(ecx), EMIT_REMEMBERED_SET},
7025 { REG(ebx), REG(eax), REG(ecx), EMIT_REMEMBERED_SET},
7027 { REG(ecx), REG(edx), REG(ebx), EMIT_REMEMBERED_SET},
7029 { REG(ecx), REG(eax), REG(ebx), EMIT_REMEMBERED_SET},
7286 // -- ecx : element index as smi
7318 __ push(ecx);
7334 __ lea(ecx, FieldOperand(ebx, ecx, times_half_pointer_size,
7336 __ mov(Operand(ecx, 0), eax);
7338 __ RecordWrite(ebx, ecx, eax,
7348 __ mov(FieldOperand(ebx, ecx, times_half_pointer_size,
7359 ecx,
7376 __ pop(ecx);
7381 __ jmp(ecx); // Return to IC Miss stub, continuation still on stack.
7401 __ push(ecx);
7420 // Restore ecx.
7422 __ pop(ecx);
7472 __ mov(ecx, Operand(esp, kPointerSize));
7473 __ test(ecx, ecx);
7481 __ mov(ecx, FieldOperand(ebx, Cell::kValueOffset));
7485 __ cmp(FieldOperand(ecx, 0), Immediate(allocation_site_map));
7490 __ mov(FieldOperand(ecx, AllocationSite::kTransitionInfoOffset), edx);
7569 __ mov(ecx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
7571 __ test(ecx, Immediate(kSmiTagMask));
7573 __ CmpObjectType(ecx, MAP_TYPE, ecx);
7650 __ mov(ecx, Operand(esp, kPointerSize));
7651 __ test(ecx, ecx);
7683 __ mov(ecx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
7685 __ test(ecx, Immediate(kSmiTagMask));
7687 __ CmpObjectType(ecx, MAP_TYPE, ecx);
7692 __ mov(ecx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
7696 __ mov(ecx, FieldOperand(ecx, Map::kBitField2Offset));
7698 __ and_(ecx, Map::kElementsKindMask);
7699 __ shr(ecx, Map::kElementsKindShift);
7703 __ cmp(ecx, Immediate(FAST_ELEMENTS));
7705 __ cmp(ecx, Immediate(FAST_HOLEY_ELEMENTS));
7712 __ cmp(ecx, Immediate(FAST_ELEMENTS));
