Lines Matching full:ebx
52 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
54 __ cmp(ebx, Immediate(factory->heap_number_map()));
70 __ AllocateInNewSpace(JSFunction::kSize, eax, ebx, ecx, &gc, TAG_OBJECT);
89 __ mov(ebx, Immediate(factory->empty_fixed_array()));
90 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ebx);
91 __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx);
96 __ mov(FieldOperand(eax, JSFunction::kLiteralsOffset), ebx);
126 eax, ebx, ecx, &gc, TAG_OBJECT);
139 __ Set(ebx, Immediate(0)); // Set to NULL.
142 __ mov(Operand(eax, Context::SlotOffset(Context::EXTENSION_INDEX)), ebx);
145 __ mov(ebx, Operand(esi, Context::SlotOffset(Context::GLOBAL_INDEX)));
146 __ mov(Operand(eax, Context::SlotOffset(Context::GLOBAL_INDEX)), ebx);
149 __ mov(ebx, factory->undefined_value());
151 __ mov(Operand(eax, Context::SlotOffset(i)), ebx);
174 eax, ebx, ecx, &gc, TAG_OBJECT);
180 __ mov(ebx, Operand(esp, 2 * kPointerSize));
208 __ mov(ContextOperand(eax, Context::EXTENSION_INDEX), ebx);
211 __ mov(ebx, ContextOperand(esi, Context::GLOBAL_INDEX));
212 __ mov(ContextOperand(eax, Context::GLOBAL_INDEX), ebx);
219 __ mov(ebx, factory->the_hole_value());
221 __ mov(ContextOperand(eax, i + Context::MIN_CONTEXT_SLOTS), ebx);
256 __ AllocateInNewSpace(size, eax, ebx, edx, fail, TAG_OBJECT);
261 __ mov(ebx, FieldOperand(ecx, i));
262 __ mov(FieldOperand(eax, i), ebx);
276 __ mov(ebx, FieldOperand(ecx, i));
277 __ mov(FieldOperand(edx, i), ebx);
283 __ mov(ebx, FieldOperand(ecx, i));
284 __ mov(FieldOperand(edx, i), ebx);
322 __ mov(ebx, FieldOperand(ecx, JSArray::kElementsOffset));
323 __ CheckMap(ebx, factory->fixed_cow_array_map(),
330 __ CheckMap(ebx, factory->fixed_array_map(),
403 __ AllocateInNewSpace(size, eax, ebx, edx, &slow_case, TAG_OBJECT);
405 __ mov(ebx, FieldOperand(ecx, i));
406 __ mov(FieldOperand(eax, i), ebx);
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));
676 Register scratch = ebx;
982 __ AllocateHeapNumber(eax, ebx, ecx, &slow_allocate_heapnumber);
1029 __ mov(ebx, eax);
1039 __ push(ebx);
1044 // IntegerConvert uses ebx and edi as scratch registers.
1223 // dividend in eax and edx free for the division. Use eax, ebx for those.
1229 right = ebx;
1230 __ mov(ebx, eax);
1360 __ mov(ebx, right);
1457 // Right was clobbered but a copy is in ebx.
1458 __ mov(right, ebx);
1461 // Left was clobbered but a copy is in edi. Right is in ebx for
1462 // division. They should be in eax, ebx for jump to not_smi.
1479 __ AllocateHeapNumber(eax, ecx, ebx, slow);
1521 // Right was clobbered but a copy is in ebx.
1522 __ mov(right, ebx);
1525 // Left was clobbered but a copy is in edi. Right is in ebx for
1533 __ AllocateHeapNumber(ecx, ebx, no_reg, slow);
1536 FloatingPointHelper::LoadSSE2Smis(masm, ebx);
1546 FloatingPointHelper::LoadFloatSmis(masm, ebx);
1582 // Operands are in eax, ebx at this point.
1584 __ mov(eax, ebx);
1719 FloatingPointHelper::CheckFloatOperands(masm, ¬_floats, ebx);
1798 __ mov(ebx, eax); // ebx: result
1818 __ cvtsi2sd(xmm0, ebx);
1821 __ mov(Operand(esp, 1 * kPointerSize), ebx);
1943 FloatingPointHelper::CheckFloatOperands(masm, ¬_floats, ebx);
2012 __ mov(ebx, eax); // ebx: result
2032 __ cvtsi2sd(xmm0, ebx);
2035 __ mov(Operand(esp, 1 * kPointerSize), ebx);
2147 FloatingPointHelper::CheckFloatOperands(masm, ¬_floats, ebx);
2211 __ mov(ebx, eax); // ebx: result
2231 __ cvtsi2sd(xmm0, ebx);
2234 __ mov(Operand(esp, 1 * kPointerSize), ebx);
2338 __ AllocateHeapNumber(ebx, ecx, no_reg, alloc_failure);
2341 __ mov(edx, ebx);
2355 __ AllocateHeapNumber(ebx, ecx, no_reg, alloc_failure);
2358 __ mov(eax, ebx);
2399 // Then load the low and high words of the double into ebx, edx.
2407 __ pop(ebx);
2411 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2413 __ cmp(ebx, Immediate(factory->heap_number_map()));
2416 // low and high words into ebx, edx.
2419 __ mov(ebx, FieldOperand(eax, HeapNumber::kMantissaOffset));
2430 __ movd(ebx, xmm1);
2434 // ebx = low 32 bits of double value
2438 __ mov(ecx, ebx);
2451 // ebx = low 32 bits of double value.
2483 __ cmp(ebx, Operand(ecx, 0));
2514 __ mov(Operand(ecx, 0), ebx);
2584 // Input value is on FP stack, and also in ebx/edx.
2704 __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
2705 __ cmp(ebx, factory->heap_number_map());
2730 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2731 __ cmp(ebx, factory->heap_number_map());
3216 __ mov(ebx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
3217 __ mov(ecx, Operand(ebx, StandardFrameConstants::kContextOffset));
3230 __ lea(ebx, Operand(ebp, eax, times_2, 0));
3232 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
3239 __ mov(ecx, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3246 __ lea(ebx, Operand(ebx, ecx, times_2, 0));
3248 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
3254 __ pop(ebx); // Return address.
3256 __ push(ebx);
3292 // ebx = parameter count (tagged)
3293 __ mov(ebx, Operand(esp, 1 * kPointerSize));
3306 __ mov(ecx, ebx);
3316 // ebx = parameter count (tagged)
3320 // Compute the mapped parameter count = min(ebx, ecx) in ebx.
3321 __ cmp(ebx, ecx);
3323 __ mov(ebx, ecx);
3328 __ push(ebx);
3335 __ test(ebx, ebx);
3337 __ lea(ebx, Operand(ebx, times_2, kParameterMapHeaderSize));
3341 __ lea(ebx, Operand(ebx, ecx, times_2, FixedArray::kHeaderSize));
3344 __ add(ebx, Immediate(Heap::kArgumentsObjectSize));
3347 __ AllocateInNewSpace(ebx, eax, edx, edi, &runtime, TAG_OBJECT);
3358 __ mov(ebx, Operand(esp, 0 * kPointerSize));
3359 __ test(ebx, ebx);
3371 // ebx = mapped parameter count (tagged)
3403 // ebx = mapped parameter count (tagged)
3414 __ test(ebx, ebx);
3419 __ lea(eax, Operand(ebx, reinterpret_cast<intptr_t>(Smi::FromInt(2))));
3422 __ lea(eax, Operand(edi, ebx, times_2, kParameterMapHeaderSize));
3436 __ mov(ebx, Immediate(Smi::FromInt(Context::MIN_CONTEXT_SLOTS)));
3437 __ add(ebx, Operand(esp, 4 * kPointerSize));
3438 __ sub(ebx, eax);
3443 // ebx = mapping index (tagged)
3456 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
3458 __ add(ebx, Immediate(Smi::FromInt(1)));
3478 __ mov(ebx, Operand(esp, 1 * kPointerSize));
3480 __ sub(edx, ebx); // Is there a smarter way to do negative scaling?
3481 __ sub(edx, ebx);
3487 __ mov(FieldOperand(edi, ebx, times_2, FixedArray::kHeaderSize), eax);
3488 __ add(ebx, Immediate(Smi::FromInt(1)));
3491 __ cmp(ebx, ecx);
3496 __ pop(ebx); // Parameter count.
3545 __ AllocateInNewSpace(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
3556 __ mov(ebx, FieldOperand(edi, i));
3557 __ mov(FieldOperand(eax, i), ebx);
3589 __ mov(ebx, Operand(edx, -1 * kPointerSize)); // Skip receiver.
3590 __ mov(FieldOperand(edi, FixedArray::kHeaderSize), ebx);
3634 __ mov(ebx, Operand::StaticVariable(address_of_regexp_stack_memory_size));
3635 __ test(ebx, ebx);
3649 __ CmpObjectType(ecx, FIXED_ARRAY_TYPE, ebx);
3655 __ mov(ebx, FieldOperand(ecx, JSRegExp::kDataTagOffset));
3656 __ cmp(ebx, Immediate(Smi::FromInt(JSRegExp::IRREGEXP)));
3676 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
3678 // Get the length of the string to ebx.
3679 __ mov(ebx, FieldOperand(eax, String::kLengthOffset));
3681 // ebx: Length of subject string as a smi
3688 __ cmp(eax, ebx);
3696 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
3699 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
3700 __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset));
3706 __ mov(eax, FieldOperand(ebx, FixedArray::kLengthOffset));
3718 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
3719 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
3721 __ and_(ebx, kIsNotStringMask |
3730 __ and_(ebx, Immediate(kIsNotStringMask |
3735 // ebx: whether subject is a string and if yes, its string representation
3747 __ cmp(ebx, Immediate(kExternalStringTag));
3753 __ test(ebx, Immediate(kIsNotStringMask | kShortExternalStringTag));
3768 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
3770 // ebx: map of first part of cons string or map of parent of sliced string.
3772 __ test_b(FieldOperand(ebx, Map::kInstanceTypeOffset),
3777 __ test_b(FieldOperand(ebx, Map::kInstanceTypeOffset),
3805 __ mov(ebx, Operand(esp, kPreviousIndexOffset));
3806 __ SmiUntag(ebx); // Previous index from smi.
3809 // ebx: previous index
3838 __ mov(Operand(esp, 1 * kPointerSize), ebx);
3850 // ebx: previous index
3860 __ add(ebx, edi); // Calculate input start wrt offset.
3862 // ebx: start index of the input string
3870 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqAsciiString::kHeaderSize));
3879 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
3946 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
3948 // ebx: last_match_info backing store (FixedArray)
3952 __ mov(FieldOperand(ebx, RegExpImpl::kLastCaptureCountOffset), edx);
3956 __ mov(FieldOperand(ebx, RegExpImpl::kLastSubjectOffset), eax);
3957 __ RecordWriteField(ebx,
3963 __ mov(FieldOperand(ebx, RegExpImpl::kLastInputOffset), eax);
3964 __ RecordWriteField(ebx,
3975 // ebx: last_match_info backing store (FixedArray)
3988 __ mov(FieldOperand(ebx,
4002 // ebx: scratch
4004 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
4005 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
4009 __ test_b(ebx, kIsIndirectStringMask);
4017 __ test_b(ebx, kStringEncodingMask);
4032 __ mov(ebx, Operand(esp, kPointerSize * 3));
4033 __ JumpIfNotSmi(ebx, &slowcase);
4034 __ cmp(ebx, Immediate(Smi::FromInt(kMaxInlineLength)));
4039 // Allocate RegExpResult followed by FixedArray with size in ebx.
4044 ebx, // In: Number of elements (times 2, being a smi)
4059 __ lea(ebx, Operand(eax, JSRegExpResult::kSize));
4061 __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx);
4076 // ebx: FixedArray.
4080 __ mov(FieldOperand(ebx, HeapObject::kMapOffset),
4083 __ mov(FieldOperand(ebx, FixedArray::kLengthOffset), ecx);
4087 __ lea(ebx, FieldOperand(ebx, FixedArray::kHeaderSize));
4091 // ebx: Start of elements in FixedArray.
4098 __ mov(Operand(ebx, ecx, times_pointer_size, 0), edx);
4208 __ mov(ebx, Operand(esp, kPointerSize));
4211 GenerateLookupNumberStringCache(masm, ebx, eax, ecx, edx, false, &runtime);
4351 __ mov(ebx, edx);
4352 __ xor_(ebx, eax);
4353 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
4354 __ xor_(ebx, eax);
4355 // if eax was smi, ebx is now edx, else eax.
4358 __ cmp(FieldOperand(ebx, HeapObject::kMapOffset),
4362 // Return non-equal (ebx is not zero)
4363 __ mov(eax, ebx);
4422 masm, &non_number_comparison, ebx);
4476 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx,
4485 ebx);
4491 ebx,
4515 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ebx);
4523 __ test_b(FieldOperand(ebx, Map::kBitFieldOffset),
4586 // ebx : cache cell for call target
4592 __ mov(ecx, FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset));
4607 __ mov(FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset),
4613 __ mov(FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset), edi);
4621 // ebx : cache cell for call target
4680 __ mov(FieldOperand(ebx, JSGlobalPropertyCell::kValueOffset),
4690 __ Set(ebx, Immediate(0));
4703 __ Set(ebx, Immediate(0));
4713 // ebx : cache cell for call target
4728 __ mov(ebx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
4729 __ mov(ebx, FieldOperand(ebx, SharedFunctionInfo::kConstructStubOffset));
4730 __ lea(ebx, FieldOperand(ebx, Code::kHeaderSize));
4731 __ jmp(ebx);
4747 __ Set(ebx, Immediate(0));
4796 // ebx: pointer to C function (C callee-saved)
4830 __ call(ebx);
4909 // ebx: pointer to C function (C callee-saved)
4923 // ebx: pointer to builtin function (C callee-saved)
4996 __ push(ebx);
5062 __ pop(ebx);
5063 __ cmp(ebx, Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
5074 __ pop(ebx);
5107 Register map = ebx; // Map of the object.
5520 __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, ebx);
5525 __ CmpObjectType(edx, FIRST_NONSTRING_TYPE, ebx);
5532 GenerateConvertArgument(masm, 2 * kPointerSize, eax, ebx, ecx, edi,
5537 GenerateConvertArgument(masm, 1 * kPointerSize, edx, ebx, ecx, edi,
5557 __ mov(ebx, FieldOperand(eax, String::kLengthOffset));
5559 __ test(ebx, ebx);
5568 // ebx: length of first string as a smi
5574 __ add(ebx, ecx);
5580 __ cmp(ebx, Immediate(Smi::FromInt(2)));
5584 __ JumpIfNotBothSequentialAsciiStrings(eax, edx, ebx, ecx, &call_runtime);
5587 __ movzx_b(ebx, FieldOperand(eax, SeqAsciiString::kHeaderSize));
5594 masm, ebx, ecx, eax, edx, edi,
5605 __ movzx_b(ebx, FieldOperand(eax, SeqAsciiString::kHeaderSize));
5610 // Pack both characters in ebx.
5612 __ or_(ebx, ecx);
5614 __ mov_w(FieldOperand(eax, SeqAsciiString::kHeaderSize), ebx);
5620 __ cmp(ebx, Immediate(Smi::FromInt(ConsString::kMinLength)));
5640 if (FLAG_debug_code) __ AbortIfNotSmi(ebx);
5641 __ mov(FieldOperand(ecx, ConsString::kLengthOffset), ebx);
5672 // ebx: length of resulting flat string as a smi
5727 // ebx: length of resulting flat string as a smi
5728 __ SmiUntag(ebx);
5729 __ AllocateAsciiString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
5744 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
5755 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
5761 // ebx: length of resulting flat string as a smi
5765 __ SmiUntag(ebx);
5766 __ AllocateTwoByteString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
5781 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
5792 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
6151 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
6155 // ebx: instance type
6172 // ebx: instance type
6181 __ test(ebx, Immediate(kIsIndirectStringMask));
6185 __ test(ebx, Immediate(kSlicedNotConsMask));
6194 __ mov(ebx, FieldOperand(edi, HeapObject::kMapOffset));
6195 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
6203 __ mov(ebx, FieldOperand(edi, HeapObject::kMapOffset));
6204 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
6216 // ebx: instance type of underlying subject string
6230 __ test(ebx, Immediate(kStringEncodingMask));
6232 __ AllocateAsciiSlicedString(eax, ebx, no_reg, &runtime);
6235 __ AllocateTwoByteSlicedString(eax, ebx, no_reg, &runtime);
6249 // ebx: instance type of underlying subject string
6257 __ test_b(ebx, kExternalStringTag);
6263 __ test_b(ebx, kShortExternalStringMask);
6276 __ test_b(ebx, kStringEncodingMask);
6280 __ AllocateAsciiString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
6290 __ pop(ebx);
6291 __ SmiUntag(ebx);
6292 __ lea(esi, FieldOperand(esi, ebx, times_1, SeqAsciiString::kHeaderSize));
6299 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, true);
6306 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
6317 __ pop(ebx);
6322 __ lea(esi, FieldOperand(esi, ebx, times_1, SeqTwoByteString::kHeaderSize));
6329 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, false);
6493 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx, &runtime);
6500 GenerateCompareFlatAsciiStrings(masm, edx, eax, ecx, ebx, edi);
6609 Register tmp2 = ebx;
6656 Register tmp2 = ebx;
6763 __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
6766 __ cmp(ebx, known_map_);
7031 { REG(ebx), REG(eax), REG(edi), EMIT_REMEMBERED_SET },
7033 { REG(ebx), REG(ecx), REG(edx), EMIT_REMEMBERED_SET },
7034 { REG(ebx), REG(edi), REG(edx), OMIT_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 },
7044 { REG(ebx), REG(edi), 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},
7049 { REG(edx), REG(edi), REG(ebx), EMIT_REMEMBERED_SET},
7053 { REG(edx), REG(ebx), REG(edi), EMIT_REMEMBERED_SET},
7054 { REG(edx), REG(ebx), REG(edi), OMIT_REMEMBERED_SET},
7059 { REG(ebx), REG(eax), REG(ecx), EMIT_REMEMBERED_SET},
7307 // -- ebx : array literal
7333 __ push(ebx);
7336 __ mov(ebx, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
7337 __ push(FieldOperand(ebx, JSFunction::kLiteralsOffset));
7349 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
7350 __ lea(ecx, FieldOperand(ebx, ecx, times_half_pointer_size,
7354 __ RecordWrite(ebx, ecx, eax,
7363 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
7364 __ mov(FieldOperand(ebx, ecx, times_half_pointer_size,
7372 __ mov(edx, FieldOperand(ebx, JSObject::kElementsOffset));
