Lines Matching defs:edx
173 // operand_1 in eax, operand_2 in edx; falls through on float
181 // either operand is not a number. Operands are in edx and eax.
205 Register scratch_candidates[3] = { ebx, edx, edi };
332 // Load operand in edx into xmm0, or branch to not_numbers.
333 __ JumpIfSmi(edx, &load_smi_edx, Label::kNear);
335 __ cmp(FieldOperand(edx, HeapObject::kMapOffset), factory->heap_number_map());
336 __ j(not_equal, not_numbers); // Argument in edx is not a number.
337 __ movsd(xmm0, FieldOperand(edx, HeapNumber::kValueOffset));
345 __ SmiUntag(edx); // Untag smi before converting to float.
346 __ Cvtsi2sd(xmm0, edx);
347 __ SmiTag(edx); // Retag smi for heap number overwriting test.
366 __ JumpIfSmi(edx, &test_other, Label::kNear);
367 __ mov(scratch, FieldOperand(edx, HeapObject::kMapOffset));
370 __ j(not_equal, non_float); // argument in edx is not a number -> NaN
387 const Register base = edx;
734 // The key is in edx and the parameter count is in eax.
735 DCHECK(edx.is(ArgumentsAccessReadDescriptor::index()));
745 __ JumpIfNotSmi(edx, &slow, Label::kNear);
757 __ cmp(edx, eax);
764 __ neg(edx);
765 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
773 __ cmp(edx, ecx);
780 __ neg(edx);
781 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
788 __ push(edx);
796 // edx : parameters pointer
802 DCHECK(edx.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
813 __ lea(edx,
819 __ push(edx); // Push parameters pointer.
828 // edx : parameters pointer
834 DCHECK(edx.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
852 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
853 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
854 __ lea(edx, Operand(edx, ecx, times_2,
947 // edx = address of receiver argument
953 __ push(edx);
984 __ mov(edx, edi);
989 // edx = address of parameter map (tagged)
1001 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
1025 __ mov(edx, Operand(esp, 1 * kPointerSize));
1026 __ sub(edx, ebx); // Is there a smarter way to do negative scaling?
1027 __ sub(edx, ebx);
1031 __ sub(edx, Immediate(kPointerSize));
1032 __ mov(eax, Operand(edx, 0));
1054 __ push(edx); // Push parameters pointer.
1063 // edx : parameters pointer
1069 DCHECK(edx.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
1080 __ lea(edx,
1133 __ mov(ebx, Operand(edx, -1 * kPointerSize)); // Skip receiver.
1136 __ sub(edx, Immediate(kPointerSize));
1148 __ push(edx); // Push parameters pointer.
1157 // edx : parameters pointer
1170 __ lea(edx,
1176 __ push(edx); // Push parameters pointer.
1239 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
1242 // Multiplying by 2 comes for free since edx is smi-tagged.
1246 __ cmp(edx, Isolate::kJSRegexpStaticOffsetsVectorSize - 2);
1253 __ mov(edx, eax); // Make a copy of the original subject string.
1258 // edx: subject string
1332 // edx: original subject string
1336 // Load previous index and check range before edx is overwritten. We have
1337 // to use edx instead of eax here because it might have been only made to
1341 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1343 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataOneByteCodeOffset));
1348 // edx: irregexp code
1352 __ JumpIfSmi(edx, &runtime);
1356 // edx: code
1403 // edx: code
1436 __ add(edx, Immediate(Code::kHeaderSize - kHeapObjectTag));
1437 __ call(edx);
1460 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
1462 __ cmp(edx, eax);
1477 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
1481 __ add(edx, Immediate(2)); // edx was a smi.
1483 // edx: Number of capture registers
1500 __ cmp(edx, eax);
1504 // edx: number of capture registers
1506 __ SmiTag(edx); // Number of capture registers to smi.
1507 __ mov(FieldOperand(ebx, RegExpImpl::kLastCaptureCountOffset), edx);
1508 __ SmiUntag(edx); // Number of capture registers back from smi.
1533 // edx: number of capture registers
1538 __ sub(edx, Immediate(1));
1541 __ mov(edi, Operand(ecx, edx, times_int_size, 0));
1545 edx,
1587 // edx: original subject string
1591 // Load previous index and check range before edx is overwritten. We have
1592 // to use edx instead of eax here because it might have been only made to
1596 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1598 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataUC16CodeOffset));
1661 CheckInputType(masm, edx, left(), &miss);
1666 __ mov(ecx, edx);
1669 __ sub(edx, eax); // Return on the result of the subtraction.
1671 __ not_(edx); // Correct sign in case of overflow. edx is never 0 here.
1673 __ mov(eax, edx);
1685 __ cmp(eax, edx);
1691 __ cmp(edx, isolate()->factory()->undefined_value());
1706 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
1750 __ test(ecx, edx);
1758 __ mov(ebx, edx);
1760 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
1762 // if eax was smi, ebx is now edx, else eax.
1796 __ CmpObjectType(edx, FIRST_JS_RECEIVER_TYPE, ecx);
1842 BranchIfNotInternalizedString(masm, &check_for_strings, edx, ecx);
1852 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx,
1857 StringHelper::GenerateFlatOneByteStringEquals(masm, edx, eax, ecx, ebx);
1859 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
1877 __ lea(ecx, Operand(eax, edx, times_1, 0));
1882 __ CmpObjectType(edx, FIRST_JS_RECEIVER_TYPE, ebx);
1905 __ push(edx);
1932 // edx : slot in feedback vector (Smi)
1942 __ push(edx);
1948 __ pop(edx);
1962 // edx : slot in feedback vector (Smi)
1968 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
2013 FieldOperand(ebx, edx, times_half_pointer_size, FixedArray::kHeaderSize),
2042 // edx : slot in feedback vector (Smi, for RecordCallTarget)
2056 __ mov(ebx, FieldOperand(ebx, edx, times_half_pointer_size,
2067 __ mov(edx, edi);
2077 __ mov(edx, edi);
2084 // edx - slot id
2092 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
2096 __ add(FieldOperand(ebx, edx, times_half_pointer_size,
2101 __ mov(edx, edi);
2111 // edx - slot id
2119 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
2144 __ add(FieldOperand(ebx, edx, times_half_pointer_size,
2184 FieldOperand(ebx, edx, times_half_pointer_size, FixedArray::kHeaderSize),
2214 __ mov(FieldOperand(ebx, edx, times_half_pointer_size,
2220 // edx - slot
2250 __ push(edx);
2324 // Result returned in eax, or eax+edx if result size is 2.
2337 // Result is in eax or edx:eax - do not destroy these registers!
2347 __ push(edx);
2348 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2352 __ cmp(edx, Operand::StaticVariable(pending_exception_address));
2357 __ pop(edx);
2407 __ mov(edx, Operand::StaticVariable(pending_handler_offset_address));
2408 __ lea(edi, FieldOperand(edi, edx, times_1, Code::kHeaderSize));
2464 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2465 __ mov(Operand::StaticVariable(pending_exception), edx);
2477 __ mov(edx, Immediate(construct_entry));
2480 __ mov(edx, Immediate(entry));
2482 __ mov(edx, Operand(edx, 0)); // deref address
2483 __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
2484 __ call(edx);
2514 Register const object = edx; // Object (lhs).
2833 __ mov(edx, Operand(esp, 2 * kPointerSize)); // From index.
2834 __ JumpIfNotSmi(edx, &runtime);
2835 __ sub(ecx, edx);
2855 // edx: from index (smi)
2881 __ add(edx, FieldOperand(eax, SlicedString::kOffsetOffset));
2898 // edx: adjusted start index (smi)
2922 __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx);
2931 // edx: adjusted start index (smi)
2953 __ push(edx);
2961 __ AllocateOneByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2969 __ pop(edx);
2972 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqOneByteString::kHeaderSize));
2977 // edx: character of sub string start
2979 masm, edi, edx, ecx, ebx, String::ONE_BYTE_ENCODING);
2985 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2994 __ pop(edx);
3000 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqTwoByteString::kHeaderSize));
3005 // edx: character of sub string start
3007 masm, edi, edx, ecx, ebx, String::TWO_BYTE_ENCODING);
3023 // edx: from index (smi)
3024 StringCharAtGenerator generator(eax, edx, ecx, eax, &runtime, &runtime,
3260 // -- edx : left string
3264 __ AssertString(edx);
3268 __ cmp(edx, eax);
3278 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx, &runtime);
3282 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
3289 __ Push(edx);
3298 // -- edx : left
3330 __ JumpIfSmi(edx, &miss, miss_distance);
3331 __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
3342 __ mov(edx, FieldOperand(edx, Oddball::kToNumberOffset));
3343 __ AssertSmi(edx);
3345 __ mov(eax, edx);
3346 __ pop(edx);
3348 __ sub(eax, edx);
3360 __ mov(ecx, edx);
3366 __ sub(eax, edx);
3369 __ sub(edx, eax);
3372 __ not_(edx);
3374 __ mov(eax, edx);
3391 __ JumpIfNotSmi(edx, &miss);
3411 __ JumpIfSmi(edx, &left_smi, Label::kNear);
3412 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
3415 __ movsd(xmm0, FieldOperand(edx, HeapNumber::kValueOffset));
3418 __ mov(ecx, edx); // Can't clobber edx because we can still jump away.
3448 __ JumpIfSmi(edx, &unordered);
3449 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
3456 __ cmp(edx, Immediate(isolate()->factory()->undefined_value()));
3470 Register left = edx;
3515 Register left = edx;
3562 Register left = edx;
3648 __ mov(ecx, edx);
3655 __ CmpObjectType(edx, FIRST_JS_RECEIVER_TYPE, ecx);
3659 __ sub(eax, edx);
3670 __ mov(ecx, edx);
3677 __ cmp(edi, FieldOperand(edx, HeapObject::kMapOffset));
3681 __ sub(eax, edx);
3687 __ Push(edx);
3703 __ push(edx); // Preserve edx and eax.
3705 __ push(edx); // And also use them as the arguments.
3712 __ pop(edx);
4272 Register receiver = LoadWithVectorDescriptor::ReceiverRegister(); // edx
4321 Register receiver = LoadWithVectorDescriptor::ReceiverRegister(); // edx
4525 Register receiver = VectorStoreICDescriptor::ReceiverRegister(); // edx
4695 Register receiver = VectorStoreICDescriptor::ReceiverRegister(); // edx
4770 __ push(edx);
4789 __ pop(edx);
4811 __ cmp(edx, kind);
4829 // edx - kind (if mode != DISABLE_ALLOCATION_SITES)
4844 __ test_b(edx, 1);
4870 __ inc(edx);
4892 __ cmp(edx, kind);
4981 // -- edx : Original constructor
5006 __ cmp(edx, edi);
5016 __ mov(edx, FieldOperand(ebx, AllocationSite::kTransitionInfoOffset));
5017 __ SmiUntag(edx);
5019 __ and_(edx, Immediate(AllocationSite::ElementsKindBits::kMask));
5043 __ Push(edx);
5172 Register cell_details_reg = edx;
5329 DCHECK(edx.is(function_address));
5482 // -- edx : api_function_address
5496 Register api_function_address = edx;
5643 // -- edx : api_function_address
5645 DCHECK(edx.is(ApiGetterDescriptor::function_address()));
5654 Register api_function_address = edx;
