Lines Matching defs:edx
168 // operand_1 in eax, operand_2 in edx; falls through on float
194 Register scratch_candidates[3] = { ebx, edx, edi };
309 __ JumpIfSmi(edx, &test_other, Label::kNear);
310 __ mov(scratch, FieldOperand(edx, HeapObject::kMapOffset));
313 __ j(not_equal, non_float); // argument in edx is not a number -> NaN
375 // The key is in edx and the parameter count is in eax.
376 DCHECK(edx.is(ArgumentsAccessReadDescriptor::index()));
386 __ JumpIfNotSmi(edx, &slow, Label::kNear);
398 __ cmp(edx, eax);
405 __ neg(edx);
406 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
414 __ cmp(edx, ecx);
421 __ neg(edx);
422 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
429 __ push(edx);
443 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
444 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
449 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
451 __ lea(edx, Operand(edx, ecx, times_2,
453 __ mov(Operand(esp, 2 * kPointerSize), edx);
474 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
475 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
485 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
486 __ lea(edx, Operand(edx, ecx, times_2,
488 __ mov(Operand(esp, 2 * kPointerSize), edx);
521 __ Allocate(ebx, eax, edx, edi, &runtime, TAG_OBJECT);
562 __ mov(edx, Operand(esp, 4 * kPointerSize));
563 __ AssertNotSmi(edx);
566 edx);
619 __ mov(edx, edi);
624 // edx = address of parameter map (tagged)
635 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
658 __ mov(edx, Operand(esp, 4 * kPointerSize));
659 __ sub(edx, ebx); // Is there a smarter way to do negative scaling?
660 __ sub(edx, ebx);
664 __ sub(edx, Immediate(kPointerSize));
665 __ mov(eax, Operand(edx, 0));
696 __ mov(edx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
697 __ mov(ecx, Operand(edx, StandardFrameConstants::kContextOffset));
707 __ mov(ecx, Operand(edx, ArgumentsAdaptorFrameConstants::kLengthOffset));
709 __ lea(edx, Operand(edx, ecx, times_2,
711 __ mov(Operand(esp, 2 * kPointerSize), edx);
724 __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
752 __ mov(edx, Operand(esp, 2 * kPointerSize));
768 __ mov(ebx, Operand(edx, -1 * kPointerSize)); // Skip receiver.
771 __ sub(edx, Immediate(kPointerSize));
841 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
844 // Multiplying by 2 comes for free since edx is smi-tagged.
848 __ cmp(edx, Isolate::kJSRegexpStaticOffsetsVectorSize - 2);
855 __ mov(edx, eax); // Make a copy of the original subject string.
860 // edx: subject string
934 // edx: original subject string
938 // Load previous index and check range before edx is overwritten. We have
939 // to use edx instead of eax here because it might have been only made to
943 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
945 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataOneByteCodeOffset));
950 // edx: irregexp code
954 __ JumpIfSmi(edx, &runtime);
958 // edx: code
1005 // edx: code
1038 __ add(edx, Immediate(Code::kHeaderSize - kHeapObjectTag));
1039 __ call(edx);
1062 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
1064 __ cmp(edx, eax);
1069 __ mov(Operand::StaticVariable(pending_exception), edx);
1092 __ mov(edx, FieldOperand(ecx, JSRegExp::kIrregexpCaptureCountOffset));
1096 __ add(edx, Immediate(2)); // edx was a smi.
1098 // edx: Number of capture registers
1115 __ cmp(edx, eax);
1119 // edx: number of capture registers
1121 __ SmiTag(edx); // Number of capture registers to smi.
1122 __ mov(FieldOperand(ebx, RegExpImpl::kLastCaptureCountOffset), edx);
1123 __ SmiUntag(edx); // Number of capture registers back from smi.
1142 // edx: number of capture registers
1147 __ sub(edx, Immediate(1));
1150 __ mov(edi, Operand(ecx, edx, times_int_size, 0));
1154 edx,
1196 // edx: original subject string
1200 // Load previous index and check range before edx is overwritten. We have
1201 // to use edx instead of eax here because it might have been only made to
1205 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
1207 __ mov(edx, FieldOperand(ecx, JSRegExp::kDataUC16CodeOffset));
1270 CheckInputType(masm, edx, left(), &miss);
1275 __ mov(ecx, edx);
1278 __ sub(edx, eax); // Return on the result of the subtraction.
1280 __ not_(edx); // Correct sign in case of overflow. edx is never 0 here.
1282 __ mov(eax, edx);
1294 __ cmp(eax, edx);
1301 __ cmp(edx, isolate()->factory()->undefined_value());
1310 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
1340 __ test(ecx, edx);
1348 __ mov(ebx, edx);
1350 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
1352 // if eax was smi, ebx is now edx, else eax.
1386 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ecx);
1404 FloatingPointHelper::LoadFloatOperand(masm, edx);
1444 BranchIfNotInternalizedString(masm, &check_for_strings, edx, ecx);
1454 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx,
1459 StringHelper::GenerateFlatOneByteStringEquals(masm, edx, eax, ecx, ebx);
1461 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
1480 __ lea(ecx, Operand(eax, edx, times_1, 0));
1485 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ebx);
1508 __ push(edx);
1538 // edx : slot in feedback vector (Smi)
1544 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1580 FieldOperand(ebx, edx, times_half_pointer_size, FixedArray::kHeaderSize),
1603 __ push(edx);
1610 __ pop(edx);
1620 __ mov(FieldOperand(ebx, edx, times_half_pointer_size,
1623 // We won't need edx or ebx anymore, just save edi
1626 __ push(edx);
1627 __ RecordWriteArray(ebx, edi, edx, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
1629 __ pop(edx);
1663 __ GetBuiltinEntry(edx, Builtins::CALL_FUNCTION_PROXY);
1675 __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
1756 // edx : (only if ebx is not the megamorphic symbol) slot in feedback
1773 // entry is at the feedback vector slot given by edx + 1.
1774 __ mov(ebx, FieldOperand(ebx, edx, times_half_pointer_size,
1779 __ mov(ebx, FieldOperand(ebx, edx, times_half_pointer_size,
1807 __ GetBuiltinEntry(edx, Builtins::CALL_FUNCTION_PROXY_AS_CONSTRUCTOR);
1811 __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR);
1831 // edx - slot id
1843 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1872 // edx - slot id
1883 __ cmp(edi, FieldOperand(ebx, edx, times_half_pointer_size,
1915 __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
1928 __ mov(FieldOperand(ebx, edx, times_half_pointer_size,
1965 __ push(edx);
2035 // Result returned in eax, or eax+edx if result size is 2.
2048 // Result is in eax or edx:eax - do not destroy these registers!
2071 __ push(edx);
2072 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2074 __ cmp(edx, Operand::StaticVariable(pending_exception_address));
2079 __ pop(edx);
2093 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2094 __ mov(Operand::StaticVariable(pending_exception_address), edx);
2162 __ mov(edx, Immediate(isolate()->factory()->the_hole_value()));
2163 __ mov(Operand::StaticVariable(pending_exception), edx);
2175 __ mov(edx, Immediate(construct_entry));
2178 __ mov(edx, Immediate(entry));
2180 __ mov(edx, Operand(edx, 0)); // deref address
2181 __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
2182 __ call(edx);
2234 Register function = edx; // Function (rhs).
2629 __ mov(edx, Operand(esp, 2 * kPointerSize)); // From index.
2630 __ JumpIfNotSmi(edx, &runtime);
2631 __ sub(ecx, edx);
2651 // edx: from index (smi)
2677 __ add(edx, FieldOperand(eax, SlicedString::kOffsetOffset));
2694 // edx: adjusted start index (smi)
2718 __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx);
2727 // edx: adjusted start index (smi)
2749 __ push(edx);
2757 __ AllocateOneByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2765 __ pop(edx);
2768 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqOneByteString::kHeaderSize));
2773 // edx: character of sub string start
2775 masm, edi, edx, ecx, ebx, String::ONE_BYTE_ENCODING);
2781 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2790 __ pop(edx);
2796 __ lea(edx, FieldOperand(edx, ebx, times_1, SeqTwoByteString::kHeaderSize));
2801 // edx: character of sub string start
2803 masm, edi, edx, ecx, ebx, String::TWO_BYTE_ENCODING);
2819 // edx: from index (smi)
2821 eax, edx, ecx, eax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
2961 __ mov(edx, Operand(esp, 2 * kPointerSize)); // left
2965 __ cmp(edx, eax);
2976 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx, &runtime);
2983 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
2995 // -- edx : left
3024 __ mov(ecx, edx);
3030 __ sub(eax, edx);
3033 __ sub(edx, eax);
3036 __ not_(edx);
3038 __ mov(eax, edx);
3055 __ JumpIfNotSmi(edx, &miss);
3063 __ mov(ecx, edx);
3070 __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
3084 __ JumpIfSmi(edx, &unordered);
3085 __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ecx);
3092 __ cmp(edx, Immediate(isolate()->factory()->undefined_value()));
3106 Register left = edx;
3151 Register left = edx;
3198 Register left = edx;
3284 __ mov(ecx, edx);
3290 __ CmpObjectType(edx, JS_OBJECT_TYPE, ecx);
3294 __ sub(eax, edx);
3304 __ mov(ecx, edx);
3309 __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
3315 __ sub(eax, edx);
3329 __ push(edx); // Preserve edx and eax.
3331 __ push(edx); // And also use them as the arguments.
3338 __ pop(edx);
3756 // clobbers ebx, edx, edi
3767 __ mov(edx, Operand(esp, 1 * kPointerSize));
3788 __ push(edx);
3794 __ pop(edx);
3819 __ push(edx);
3820 __ mov(edx, FieldOperand(ebx, JSObject::kElementsOffset));
3822 edx,
3827 __ pop(edx);
3874 __ push(edx);
3893 __ pop(edx);
3915 __ cmp(edx, kind);
3933 // edx - kind (if mode != DISABLE_ALLOCATION_SITES)
3948 __ test_b(edx, 1);
3974 __ inc(edx);
3996 __ cmp(edx, kind);
4111 __ mov(edx, FieldOperand(ebx, AllocationSite::kTransitionInfoOffset));
4112 __ SmiUntag(edx);
4114 __ and_(edx, Immediate(AllocationSite::ElementsKindBits::kMask));
4213 // -- edx : api_function_address
4226 Register api_function_address = edx;
4334 // -- edx : api_function_address
4336 DCHECK(edx.is(ApiGetterDescriptor::function_address()));
4345 Register api_function_address = edx;