Lines Matching defs:edx
169 // operand_1 in eax, operand_2 in edx; falls through on float
195 Register scratch_candidates[3] = { ebx, edx, edi };
310 __ JumpIfSmi(edx, &test_other, Label::kNear);
311 __ mov(scratch, FieldOperand(edx, HeapObject::kMapOffset));
314 __ j(not_equal, non_float); // argument in edx is not a number -> NaN
328 const Register base = edx;
435 // The key is in edx and the parameter count is in eax.
436 DCHECK(edx.is(ArgumentsAccessReadDescriptor::index()));
446 __ JumpIfNotSmi(edx, &slow, Label::kNear);
458 __ cmp(edx, eax);
465 __ neg(edx);
466 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
474 __ cmp(edx, ecx);
481 __ neg(edx);
482 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
489 __ push(edx);
497 // edx : parameters pointer
503 DCHECK(edx.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
514 __ lea(edx,
520 __ push(edx); // Push parameters pointer.
529 // edx : parameters pointer
535 DCHECK(edx.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
553 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
554 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
555 __ lea(edx, Operand(edx, ecx, times_2,
648 // edx = address of receiver argument
654 __ push(edx);
685 __ mov(edx, edi);
690 // edx = address of parameter map (tagged)
702 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
726 __ mov(edx, Operand(esp, 1 * kPointerSize));
727 __ sub(edx, ebx); // Is there a smarter way to do negative scaling?
728 __ sub(edx, ebx);
732 __ sub(edx, Immediate(kPointerSize));
733 __ mov(eax, Operand(edx, 0));
755 __ push(edx); // Push parameters pointer.
764 // edx : parameters pointer
770 DCHECK(edx.is(ArgumentsAccessNewDescriptor::parameter_pointer()));
781 __ lea(edx,
834 __ mov(ebx, Operand(edx, -1 * kPointerSize)); // Skip receiver.
837 __ sub(edx, Immediate(kPointerSize));
849 __ push(edx); // Push parameters pointer.
858 // edx : parameters pointer
871 __ lea(edx,
877 __ push(edx); // Push parameters pointer.
940 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
943 // Multiplying by 2 comes for free since edx is smi-tagged.
947 __ cmp(edx, Isolate::kJSRegexpStaticOffsetsVectorSize - 2);
954 __ mov(edx, eax); // Make a copy of the original subject string.
959 // edx: subject string
1033 // edx: original subject string
1037 // Load previous index and check range before edx is overwritten. We have
1038 // to use edx instead of eax here because it might have been only made to
1042 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1044 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataOneByteCodeOffset));
1049 // edx: irregexp code
1053 __ JumpIfSmi(edx, &runtime);
1057 // edx: code
1104 // edx: code
1137 __ add(edx, Immediate(Code::kHeaderSize - kHeapObjectTag));
1138 __ call(edx);
1161 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
1163 __ cmp(edx, eax);
1178 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
1182 __ add(edx, Immediate(2)); // edx was a smi.
1184 // edx: Number of capture registers
1201 __ cmp(edx, eax);
1205 // edx: number of capture registers
1207 __ SmiTag(edx); // Number of capture registers to smi.
1208 __ mov(FieldOperand(ebx, RegExpImpl::kLastCaptureCountOffset), edx);
1209 __ SmiUntag(edx); // Number of capture registers back from smi.
1228 // edx: number of capture registers
1233 __ sub(edx, Immediate(1));
1236 __ mov(edi, Operand(ecx, edx, times_int_size, 0));
1240 edx,
1282 // edx: original subject string
1286 // Load previous index and check range before edx is overwritten. We have
1287 // to use edx instead of eax here because it might have been only made to
1291 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1293 edx, FieldOperand(ecx, JSRegExp::kDataUC16CodeOffset));
1356 CheckInputType(masm, edx, left(), &miss);
1361 __ mov(ecx, edx);
1364 __ sub(edx, eax); // Return on the result of the subtraction.
1366 __ not_(edx); // Correct sign in case of overflow. edx is never 0 here.
1368 __ mov(eax, edx);
1380 __ cmp(eax, edx);
1386 __ cmp(edx, isolate()->factory()->undefined_value());
1401 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
1445 __ test(ecx, edx);
1453 __ mov(ebx, edx);
1455 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
1457 // if eax was smi, ebx is now edx, else eax.
1491 __ CmpObjectType(edx, FIRST_JS_RECEIVER_TYPE, ecx);
1509 FloatingPointHelper::LoadFloatOperand(masm, edx);
1549 BranchIfNotInternalizedString(masm, &check_for_strings, edx, ecx);
1559 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx,
1564 StringHelper::GenerateFlatOneByteStringEquals(masm, edx, eax, ecx, ebx);
1566 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
1584 __ lea(ecx, Operand(eax, edx, times_1, 0));
1589 __ CmpObjectType(edx, FIRST_JS_RECEIVER_TYPE, ebx);
1612 __ push(edx);
1639 // edx : slot in feedback vector (Smi)
1649 __ push(edx);
1655 __ pop(edx);
1669 // edx : slot in feedback vector (Smi)
1675 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1720 FieldOperand(ebx, edx, times_half_pointer_size, FixedArray::kHeaderSize),
1749 // edx : slot in feedback vector (Smi, for RecordCallTarget)
1763 __ mov(ebx, FieldOperand(ebx, edx, times_half_pointer_size,
1774 __ mov(edx, edi);
1784 __ mov(edx, edi);
1791 // edx - slot id
1799 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1803 __ add(FieldOperand(ebx, edx, times_half_pointer_size,
1808 __ mov(edx, edi);
1818 // edx - slot id
1826 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1851 __ add(FieldOperand(ebx, edx, times_half_pointer_size,
1891 FieldOperand(ebx, edx, times_half_pointer_size, FixedArray::kHeaderSize),
1921 __ mov(FieldOperand(ebx, edx, times_half_pointer_size,
1927 // edx - slot
1957 __ push(edx);
2036 // Result returned in eax, or eax+edx if result size is 2.
2049 // Result is in eax or edx:eax - do not destroy these registers!
2059 __ push(edx);
2060 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2064 __ cmp(edx, Operand::StaticVariable(pending_exception_address));
2069 __ pop(edx);
2119 __ mov(edx, Operand::StaticVariable(pending_handler_offset_address));
2120 __ lea(edi, FieldOperand(edi, edx, times_1, Code::kHeaderSize));
2176 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2177 __ mov(Operand::StaticVariable(pending_exception), edx);
2189 __ mov(edx, Immediate(construct_entry));
2192 __ mov(edx, Immediate(entry));
2194 __ mov(edx, Operand(edx, 0)); // deref address
2195 __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
2196 __ call(edx);
2226 Register const object = edx; // Object (lhs).
2543 __ mov(edx, Operand(esp, 2 * kPointerSize)); // From index.
2544 __ JumpIfNotSmi(edx, &runtime);
2545 __ sub(ecx, edx);
2565 // edx: from index (smi)
2591 __ add(edx, FieldOperand(eax, SlicedString::kOffsetOffset));
2608 // edx: adjusted start index (smi)
2632 __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx);
2641 // edx
2663 __ push(edx);
2671 __ AllocateOneByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2679 __ pop(edx);
2682 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqOneByteString::kHeaderSize));
2687 // edx: character of sub string start
2689 masm, edi, edx, ecx, ebx, String::ONE_BYTE_ENCODING);
2695 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2704 __ pop(edx);
2710 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqTwoByteString::kHeaderSize));
2715 // edx: character of sub string start
2717 masm, edi, edx, ecx, ebx, String::TWO_BYTE_ENCODING);
2733 // edx: from index (smi)
2734 StringCharAtGenerator generator(eax, edx, ecx, eax, &runtime, &runtime,
2970 // -- edx : left string
2974 __ AssertString(edx);
2978 __ cmp(edx, eax);
2988 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx, &runtime);
2992 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
2999 __ Push(edx);
3008 // -- edx : left
3040 __ JumpIfSmi(edx, &miss, miss_distance);
3041 __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
3052 __ mov(edx, FieldOperand(edx, Oddball::kToNumberOffset));
3053 __ AssertSmi(edx);
3054 __ xchg(eax, edx);
3056 __ sub(eax, edx);
3068 __ mov(ecx, edx);
3074 __ sub(eax, edx);
3077 __ sub(edx, eax);
3080 __ not_(edx);
3082 __ mov(eax, edx);
3099 __ JumpIfNotSmi(edx, &miss);
3113 __ JumpIfSmi(edx, &generic_stub, Label::kNear);
3114 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
3128 __ JumpIfSmi(edx, &unordered);
3129 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
3136 __ cmp(edx, Immediate(isolate()->factory()->undefined_value()));
3150 Register left = edx;
3195 Register left = edx;
3242 Register left = edx;
3328 __ mov(ecx, edx);
3335 __ CmpObjectType(edx, FIRST_JS_RECEIVER_TYPE, ecx);
3339 __ sub(eax, edx);
3350 __ mov(ecx, edx);
3357 __ cmp(edi, FieldOperand(edx, HeapObject::kMapOffset));
3361 __ sub(eax, edx);
3367 __ Push(edx);
3383 __ push(edx); // Preserve edx and eax.
3385 __ push(edx); // And also use them as the arguments.
3392 __ pop(edx);
3952 Register receiver = LoadWithVectorDescriptor::ReceiverRegister(); // edx
4001 Register receiver = LoadWithVectorDescriptor::ReceiverRegister(); // edx
4205 Register receiver = VectorStoreICDescriptor::ReceiverRegister(); // edx
4375 Register receiver = VectorStoreICDescriptor::ReceiverRegister(); // edx
4450 __ push(edx);
4469 __ pop(edx);
4491 __ cmp(edx, kind);
4509 // edx - kind (if mode != DISABLE_ALLOCATION_SITES)
4524 __ test_b(edx, 1);
4550 __ inc(edx);
4572 __ cmp(edx, kind);
4661 // -- edx : Original constructor
4686 __ cmp(edx, edi);
4696 __ mov(edx, FieldOperand(ebx, AllocationSite::kTransitionInfoOffset));
4697 __ SmiUntag(edx);
4699 __ and_(edx, Immediate(AllocationSite::ElementsKindBits::kMask));
4723 __ Push(edx);
4852 Register cell_details_reg = edx;
5009 DCHECK(edx.is(function_address));
5162 // -- edx : api_function_address
5176 Register api_function_address = edx;
5323 // -- edx : api_function_address
5325 DCHECK(edx.is(ApiGetterDescriptor::function_address()));
5334 Register api_function_address = edx;
