Lines Matching full:ebx
49 static Register registers[] = { ebx };
81 static Register registers[] = { eax, ebx, ecx };
92 static Register registers[] = { eax, ebx, ecx, edx };
103 static Register registers[] = { ebx };
179 static Register registers[] = { eax, ebx };
194 // ebx -- type info cell with elements kind
195 static Register registers_variable_args[] = { edi, ebx, eax };
196 static Register registers_no_args[] = { edi, ebx };
325 static Register registers[] = { eax, ebx, ecx, edx };
388 eax, ebx, ecx, &gc, TAG_OBJECT);
401 __ Set(ebx, Immediate(0)); // Set to NULL.
404 __ mov(Operand(eax, Context::SlotOffset(Context::EXTENSION_INDEX)), ebx);
407 __ mov(ebx, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
408 __ mov(Operand(eax, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)), ebx);
411 __ mov(ebx, factory->undefined_value());
413 __ mov(Operand(eax, Context::SlotOffset(i)), ebx);
435 __ Allocate(FixedArray::SizeFor(length), eax, ebx, ecx, &gc, TAG_OBJECT);
441 __ mov(ebx, Operand(esp, 2 * kPointerSize));
468 __ mov(ContextOperand(eax, Context::EXTENSION_INDEX), ebx);
471 __ mov(ebx, ContextOperand(esi, Context::GLOBAL_OBJECT_INDEX));
472 __ mov(ContextOperand(eax, Context::GLOBAL_OBJECT_INDEX), ebx);
479 __ mov(ebx, factory->the_hole_value());
481 __ mov(ContextOperand(eax, i + Context::MIN_CONTEXT_SLOTS), ebx);
576 Register scratch_candidates[3] = { ebx, edx, edi };
723 // Then load the low and high words of the double into ebx, edx.
731 __ pop(ebx);
735 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
737 __ cmp(ebx, Immediate(factory->heap_number_map()));
740 // low and high words into ebx, edx.
743 __ mov(ebx, FieldOperand(eax, HeapNumber::kMantissaOffset));
755 __ movd(ebx, xmm1);
759 // ebx = low 32 bits of double value
763 __ mov(ecx, ebx);
776 // ebx = low 32 bits of double value.
808 __ cmp(ebx, Operand(ecx, 0));
841 __ mov(Operand(ecx, 0), ebx);
913 // Input value is on FP stack, and also in ebx/edx.
1361 StubCompiler::GenerateLoadFunctionPrototype(masm, edx, eax, ebx, &miss);
1381 StubCompiler::GenerateLoadStringLength(masm, edx, eax, ebx, &miss);
1405 Register scratch = ebx;
1467 __ mov(ebx, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
1468 __ mov(ecx, Operand(ebx, StandardFrameConstants::kContextOffset));
1481 __ lea(ebx, Operand(ebp, eax, times_2, 0));
1483 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
1490 __ mov(ecx, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
1497 __ lea(ebx, Operand(ebx, ecx, times_2, 0));
1499 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
1505 __ pop(ebx); // Return address.
1507 __ push(ebx);
1545 // ebx = parameter count (tagged)
1546 __ mov(ebx, Operand(esp, 1 * kPointerSize));
1559 __ mov(ecx, ebx);
1569 // ebx = parameter count (tagged)
1573 // Compute the mapped parameter count = min(ebx, ecx) in ebx.
1574 __ cmp(ebx, ecx);
1576 __ mov(ebx, ecx);
1581 __ push(ebx);
1588 __ test(ebx, ebx);
1590 __ lea(ebx, Operand(ebx, times_2, kParameterMapHeaderSize));
1594 __ lea(ebx, Operand(ebx, ecx, times_2, FixedArray::kHeaderSize));
1597 __ add(ebx, Immediate(Heap::kArgumentsObjectSize));
1600 __ Allocate(ebx, eax, edx, edi, &runtime, TAG_OBJECT);
1611 __ mov(ebx, Operand(esp, 0 * kPointerSize));
1612 __ test(ebx, ebx);
1624 // ebx = mapped parameter count (tagged)
1656 // ebx = mapped parameter count (tagged)
1667 __ test(ebx, ebx);
1672 __ lea(eax, Operand(ebx, reinterpret_cast<intptr_t>(Smi::FromInt(2))));
1675 __ lea(eax, Operand(edi, ebx, times_2, kParameterMapHeaderSize));
1689 __ mov(ebx, Immediate(Smi::FromInt(Context::MIN_CONTEXT_SLOTS)));
1690 __ add(ebx, Operand(esp, 4 * kPointerSize));
1691 __ sub(ebx, eax);
1696 // ebx = mapping index (tagged)
1709 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
1711 __ add(ebx, Immediate(Smi::FromInt(1)));
1731 __ mov(ebx, Operand(esp, 1 * kPointerSize));
1733 __ sub(edx, ebx); // Is there a smarter way to do negative scaling?
1734 __ sub(edx, ebx);
1740 __ mov(FieldOperand(edi, ebx, times_2, FixedArray::kHeaderSize), eax);
1741 __ add(ebx, Immediate(Smi::FromInt(1)));
1744 __ cmp(ebx, ecx);
1749 __ pop(ebx); // Parameter count.
1800 __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
1811 __ mov(ebx, FieldOperand(edi, i));
1812 __ mov(FieldOperand(eax, i), ebx);
1844 __ mov(ebx, Operand(edx, -1 * kPointerSize)); // Skip receiver.
1845 __ mov(FieldOperand(edi, FixedArray::kHeaderSize), ebx);
1890 __ mov(ebx, Operand::StaticVariable(address_of_regexp_stack_memory_size));
1891 __ test(ebx, ebx);
1906 __ CmpObjectType(ecx, FIXED_ARRAY_TYPE, ebx);
1912 __ mov(ebx, FieldOperand(ecx, JSRegExp::kDataTagOffset));
1913 __ cmp(ebx, Immediate(Smi::FromInt(JSRegExp::IRREGEXP)));
1933 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1934 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
1938 // ebx: subject string instance type
1966 __ and_(ebx, kIsNotStringMask |
1975 __ and_(ebx, Immediate(kIsNotStringMask |
1987 __ cmp(ebx, Immediate(kExternalStringTag));
1996 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1997 __ mov(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
2000 __ test_b(ebx, kStringRepresentationMask | kStringEncodingMask);
2004 __ test_b(ebx, kStringRepresentationMask);
2018 __ mov(ebx, Operand(esp, kPreviousIndexOffset));
2019 __ JumpIfNotSmi(ebx, &runtime);
2020 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
2034 // ebx: previous index (smi)
2067 __ SmiUntag(ebx);
2068 __ mov(Operand(esp, 1 * kPointerSize), ebx);
2080 // ebx: previous index
2090 __ add(ebx, edi); // Calculate input start wrt offset.
2092 // ebx: start index of the input string
2100 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqOneByteString::kHeaderSize));
2109 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
2180 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
2183 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
2184 __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset));
2189 __ mov(eax, FieldOperand(ebx, FixedArray::kLengthOffset));
2195 // ebx: last_match_info backing store (FixedArray)
2199 ebx, RegExpImpl::kLastCaptureCountOffset), edx);
2204 __ mov(FieldOperand(ebx, RegExpImpl::kLastSubjectOffset), eax);
2205 __ RecordWriteField(ebx,
2211 __ mov(FieldOperand(ebx, RegExpImpl::kLastInputOffset), eax);
2212 __ RecordWriteField(ebx,
2223 // ebx: last_match_info backing store (FixedArray)
2236 __ mov(FieldOperand(ebx,
2261 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2262 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
2266 __ test_b(ebx, kIsIndirectStringMask);
2275 __ test_b(ebx, kStringEncodingMask);
2286 __ mov(ebx, Operand(esp, kPreviousIndexOffset));
2287 __ JumpIfNotSmi(ebx, &runtime);
2288 __ cmp(ebx, FieldOperand(edx, String::kLengthOffset));
2298 __ test(ebx, Immediate(kIsNotStringMask | kShortExternalStringTag));
2314 __ mov(ebx, Operand(esp, kPointerSize * 3));
2315 __ JumpIfNotSmi(ebx, &slowcase);
2316 __ cmp(ebx, Immediate(Smi::FromInt(kMaxInlineLength)));
2321 // Allocate RegExpResult followed by FixedArray with size in ebx.
2326 ebx, // In: Number of elements as a smi
2342 __ lea(ebx, Operand(eax, JSRegExpResult::kSize));
2344 __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx);
2359 // ebx: FixedArray.
2363 __ mov(FieldOperand(ebx, HeapObject::kMapOffset),
2366 __ mov(FieldOperand(ebx, FixedArray::kLengthOffset), ecx);
2370 __ lea(ebx, FieldOperand(ebx, FixedArray::kHeaderSize));
2374 // ebx: Start of elements in FixedArray.
2381 __ mov(Operand(ebx, ecx, times_pointer_size, 0), edx);
2515 __ mov(ebx, edx);
2516 __ xor_(ebx, eax);
2517 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
2518 __ xor_(ebx, eax);
2519 // if eax was smi, ebx is now edx, else eax.
2522 __ cmp(FieldOperand(ebx, HeapObject::kMapOffset),
2526 // Return non-equal (ebx is not zero)
2527 __ mov(eax, ebx);
2586 masm, &non_number_comparison, ebx);
2639 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx,
2648 ebx);
2654 ebx,
2678 __ CmpObjectType(edx, FIRST_SPEC_OBJECT_TYPE, ebx);
2686 __ test_b(FieldOperand(ebx, Map::kBitFieldOffset),
2730 // ebx : cache cell for call target
2736 __ mov(ecx, FieldOperand(ebx, Cell::kValueOffset));
2771 __ mov(FieldOperand(ebx, Cell::kValueOffset),
2793 __ push(ebx);
2798 __ pop(ebx);
2806 __ mov(FieldOperand(ebx, Cell::kValueOffset), edi);
2814 // ebx : cache cell for call target
2873 __ mov(FieldOperand(ebx, Cell::kValueOffset),
2883 __ Set(ebx, Immediate(0));
2896 __ Set(ebx, Immediate(0));
2906 // ebx : cache cell for call target
2942 __ Set(ebx, Immediate(0));
3011 // ebx: pointer to C function (C callee-saved)
3047 __ call(ebx);
3130 // ebx: pointer to C function (C callee-saved)
3146 // ebx: pointer to builtin function (C callee-saved)
3224 __ push(ebx);
3288 __ pop(ebx);
3289 __ cmp(ebx, Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
3300 __ pop(ebx);
3333 Register map = ebx; // Map of the object.
3677 __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, ebx);
3682 __ CmpObjectType(edx, FIRST_NONSTRING_TYPE, ebx);
3686 GenerateConvertArgument(masm, 2 * kPointerSize, eax, ebx, ecx, edi,
3691 GenerateConvertArgument(masm, 1 * kPointerSize, edx, ebx, ecx, edi,
3710 __ mov(ebx, FieldOperand(eax, String::kLengthOffset));
3712 __ test(ebx, ebx);
3721 // ebx: length of first string as a smi
3727 __ add(ebx, ecx);
3733 __ cmp(ebx, Immediate(Smi::FromInt(2)));
3737 __ JumpIfNotBothSequentialAsciiStrings(eax, edx, ebx, ecx, &call_runtime);
3740 __ movzx_b(ebx, FieldOperand(eax, SeqOneByteString::kHeaderSize));
3747 masm, ebx, ecx, eax, edx, edi,
3758 __ movzx_b(ebx, FieldOperand(eax, SeqOneByteString::kHeaderSize));
3763 // Pack both characters in ebx.
3765 __ or_(ebx, ecx);
3767 __ mov_w(FieldOperand(eax, SeqOneByteString::kHeaderSize), ebx);
3773 __ cmp(ebx, Immediate(Smi::FromInt(ConsString::kMinLength)));
3793 __ AssertSmi(ebx);
3794 __ mov(FieldOperand(ecx, ConsString::kLengthOffset), ebx);
3808 ebx,
3814 ebx,
3850 // ebx: length of resulting flat string as a smi
3905 // ebx: length of resulting flat string as a smi
3906 __ SmiUntag(ebx);
3907 __ AllocateAsciiString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
3922 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
3933 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, true);
3939 // ebx: length of resulting flat string as a smi
3943 __ SmiUntag(ebx);
3944 __ AllocateTwoByteString(eax, ebx, ecx, edx, edi, &call_runtime_drop_two);
3959 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
3970 StringHelper::GenerateCopyCharacters(masm, ecx, edx, edi, ebx, false);
4315 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
4319 // ebx: instance type
4344 // ebx: instance type
4353 __ test(ebx, Immediate(kIsIndirectStringMask));
4357 __ test(ebx, Immediate(kSlicedNotConsMask));
4366 __ mov(ebx, FieldOperand(edi, HeapObject::kMapOffset));
4367 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
4375 __ mov(ebx, FieldOperand(edi, HeapObject::kMapOffset));
4376 __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
4388 // ebx: instance type of underlying subject string
4402 __ test(ebx, Immediate(kStringEncodingMask));
4404 __ AllocateAsciiSlicedString(eax, ebx, no_reg, &runtime);
4407 __ AllocateTwoByteSlicedString(eax, ebx, no_reg, &runtime);
4421 // ebx: instance type of underlying subject string
4429 __ test_b(ebx, kExternalStringTag);
4435 __ test_b(ebx, kShortExternalStringMask);
4448 __ test_b(ebx, kStringEncodingMask);
4452 __ AllocateAsciiString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
4462 __ pop(ebx);
4463 __ SmiUntag(ebx);
4464 __ lea(esi, FieldOperand(esi, ebx, times_1, SeqOneByteString::kHeaderSize));
4471 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, true);
4478 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
4489 __ pop(ebx);
4494 __ lea(esi, FieldOperand(esi, ebx, times_1, SeqTwoByteString::kHeaderSize));
4501 StringHelper::GenerateCopyCharactersREP(masm, edi, esi, ecx, ebx, false);
4516 // ebx: instance type
4682 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx, &runtime);
4689 GenerateCompareFlatAsciiStrings(masm, edx, eax, ecx, ebx, edi);
4832 Register tmp2 = ebx;
4877 Register tmp2 = ebx;
4924 Register tmp2 = ebx;
5032 __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
5035 __ cmp(ebx, known_map_);
5505 // clobbers ebx, edx, edi
5517 __ mov(ebx, Operand(esp, 2 * kPointerSize));
5518 __ mov(edi, FieldOperand(ebx, JSObject::kMapOffset));
5532 __ push(ebx);
5535 __ mov(ebx, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
5536 __ push(FieldOperand(ebx, JSFunction::kLiteralsOffset));
5548 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
5549 __ lea(ecx, FieldOperand(ebx, ecx, times_half_pointer_size,
5553 __ RecordWrite(ebx, ecx, eax,
5562 __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
5563 __ mov(FieldOperand(ebx, ecx, times_half_pointer_size,
5571 __ mov(edx, FieldOperand(ebx, JSObject::kElementsOffset));
5589 __ mov(ebx, MemOperand(ebp, parameter_count_offset));
5595 __ lea(esp, MemOperand(esp, ebx, times_pointer_size, additional_offset));
5689 // ebx - type info cell (if mode != DISABLE_ALLOCATION_SITES)
5732 __ mov(ecx, FieldOperand(ebx, Cell::kValueOffset));
5845 // -- ebx : type info cell
5866 // We should either have undefined in ebx or a valid cell
5869 __ cmp(ebx, Immediate(undefined_sentinel));
5871 __ cmp(FieldOperand(ebx, 0), Immediate(cell_map));
5879 __ cmp(ebx, Immediate(undefined_sentinel));
5881 __ mov(edx, FieldOperand(ebx, Cell::kValueOffset));
5937 // -- ebx : type info cell
