Lines Matching defs:rbx
55 static Register registers[] = { rax, rbx, rcx };
66 static Register registers[] = { rax, rbx, rcx, rdx };
77 static Register registers[] = { rbx };
129 static Register registers[] = { rax, rbx };
144 // rbx -- type info cell with elements kind
145 static Register registers[] = { rdi, rbx };
263 static Register registers[] = { rax, rbx, rcx, rdx };
304 __ Allocate(JSFunction::kSize, rax, rbx, rcx, &gc, TAG_OBJECT);
317 __ movq(rbx, Operand(rcx, Context::SlotOffset(map_index)));
318 __ movq(FieldOperand(rax, JSObject::kMapOffset), rbx);
322 __ LoadRoot(rbx, Heap::kEmptyFixedArrayRootIndex);
325 __ movq(FieldOperand(rax, JSObject::kPropertiesOffset), rbx);
326 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rbx);
330 __ movq(FieldOperand(rax, JSFunction::kLiteralsOffset), rbx);
338 __ movq(rbx,
340 __ testq(rbx, rbx);
357 // rcx holds native context, rbx points to fixed array of 3-element entries
362 __ movq(rdx, FieldOperand(rbx, SharedFunctionInfo::kFirstCodeSlot));
363 __ cmpq(rcx, FieldOperand(rbx, SharedFunctionInfo::kFirstContextSlot));
369 __ movq(rdx, FieldOperand(rbx, FixedArray::kLengthOffset));
376 __ cmpq(rcx, FieldOperand(rbx,
382 __ movq(rdx, FieldOperand(rbx,
410 rbx,
437 rax, rbx, rcx, &gc, TAG_OBJECT);
448 __ Set(rbx, 0); // Set to NULL.
451 __ movq(Operand(rax, Context::SlotOffset(Context::EXTENSION_INDEX)), rbx);
454 __ movq(rbx, Operand(rsi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
455 __ movq(Operand(rax, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)), rbx);
458 __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);
460 __ movq(Operand(rax, Context::SlotOffset(i)), rbx);
483 rax, rbx, rcx, &gc, TAG_OBJECT);
489 __ movq(rbx, Operand(rsp, 2 * kPointerSize));
514 __ movq(ContextOperand(rax, Context::EXTENSION_INDEX), rbx);
517 __ movq(rbx, ContextOperand(rsi, Context::GLOBAL_OBJECT_INDEX));
518 __ movq(ContextOperand(rax, Context::GLOBAL_OBJECT_INDEX), rbx);
521 __ LoadRoot(rbx, Heap::kTheHoleValueRootIndex);
523 __ movq(ContextOperand(rax, i + Context::MIN_CONTEXT_SLOTS), rbx);
615 Register scratch_candidates[3] = { rbx, rdx, rdi };
754 __ movq(rbx, rax);
756 __ SmiDiv(rax, rcx, rbx, &use_fp_on_smis);
761 __ movq(rbx, rax);
763 __ SmiMod(rax, rcx, rbx, &use_fp_on_smis);
811 __ movq(rax, rbx);
815 __ AllocateHeapNumber(rcx, rbx, slow);
856 FloatingPointHelper::NumbersToSmis(masm, left, right, rbx, rdi, rcx,
936 __ movl(rbx, rax); // rbx holds result value (uint32 value as int64).
948 __ cvtqsi2sd(xmm0, rbx);
956 __ Integer32ToSmi(rdx, rbx);
1211 __ AllocateHeapNumber(rbx, rcx, alloc_failure);
1214 __ movq(rdx, rbx);
1228 __ AllocateHeapNumber(rbx, rcx, alloc_failure);
1231 __ movq(rax, rbx);
1269 // Then load the bits of the double into rbx.
1274 __ movq(rbx, xmm1);
1282 __ LoadRoot(rbx, Heap::kHeapNumberMapRootIndex);
1283 __ cmpq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
1286 // bits into rbx.
1288 __ movq(rbx, FieldOperand(rax, HeapNumber::kValueOffset));
1289 __ movq(rdx, rbx);
1293 __ movq(rbx, xmm1);
1298 // rbx = bits of double value.
1307 __ xorl(rdx, rbx);
1321 // rbx = bits of double value.
1355 __ cmpq(rbx, Operand(rcx, 0));
1380 __ movq(Operand(rcx, 0), rbx);
1450 // rbx: Bits of input double. Must be preserved.
1463 __ movq(rdi, rbx);
2114 Register scratch = rbx;
2178 __ movq(rbx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2179 __ Cmp(Operand(rbx, StandardFrameConstants::kContextOffset),
2191 __ lea(rbx, Operand(rbp, index.reg, index.scale, 0));
2193 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2200 __ movq(rcx, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2206 __ lea(rbx, Operand(rbx, index.reg, index.scale, 0));
2208 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2214 __ PopReturnAddressTo(rbx);
2216 __ PushReturnAddressFrom(rbx);
2228 // rbx: the mapped parameter count (untagged)
2233 __ SmiToInteger64(rbx, Operand(rsp, 1 * kPointerSize));
2234 // rbx = parameter count (untagged)
2245 __ movq(rcx, rbx);
2257 // rbx = parameter count (untagged)
2259 // Compute the mapped parameter count = min(rbx, rcx) in rbx.
2260 __ cmpq(rbx, rcx);
2262 __ movq(rbx, rcx);
2272 __ testq(rbx, rbx);
2274 __ lea(r8, Operand(rbx, times_pointer_size, kParameterMapHeaderSize));
2292 __ testq(rbx, rbx);
2305 // rbx = mapped parameter count (untagged)
2336 // rbx = mapped parameter count (untagged)
2342 __ testq(rbx, rbx);
2346 // rbx contains the untagged argument count. Add 2 and tag to write.
2348 __ Integer64PlusConstantToSmi(r9, rbx, 2);
2351 __ lea(r9, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
2365 __ Integer32ToSmi(r9, rbx);
2371 __ lea(rdi, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
2405 __ movq(r8, rbx);
2502 __ Allocate(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT);
2513 __ movq(rbx, FieldOperand(rdi, i));
2514 __ movq(FieldOperand(rax, i), rbx);
2547 __ movq(rbx, Operand(rdx, -1 * kPointerSize)); // Skip receiver.
2548 __ movq(FieldOperand(rdi, FixedArray::kHeaderSize), rbx);
2613 __ SmiToInteger32(rbx, FieldOperand(rax, JSRegExp::kDataTagOffset));
2614 __ cmpl(rbx, Immediate(JSRegExp::IRREGEXP));
2632 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2633 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2663 __ andb(rbx, Immediate(kIsNotStringMask |
2672 __ andb(rbx, Immediate(kIsNotStringMask |
2684 __ cmpq(rbx, Immediate(kExternalStringTag));
2694 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2695 __ movq(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2698 __ testb(rbx, Immediate(kStringRepresentationMask | kStringEncodingMask));
2702 __ testb(rbx, Immediate(kStringRepresentationMask));
2731 __ movq(rbx, Operand(rsp, kPreviousIndexOffset));
2732 __ JumpIfNotSmi(rbx, &runtime);
2733 __ SmiCompare(rbx, FieldOperand(r15, String::kLengthOffset));
2735 __ SmiToInteger64(rbx, rbx);
2738 // rbx: previous index
2787 // rbx: previous index
2794 __ movq(arg_reg_2, rbx);
2801 __ addq(rbx, r14);
2805 // rbx: start index of the input
2813 FieldOperand(rdi, rbx, times_1, SeqOneByteString::kHeaderSize));
2819 FieldOperand(rdi, rbx, times_2, SeqTwoByteString::kHeaderSize));
2869 __ movq(rbx, FieldOperand(r15, JSArray::kElementsOffset));
2870 __ movq(rax, FieldOperand(rbx, HeapObject::kMapOffset));
2876 __ SmiToInteger32(rax, FieldOperand(rbx, FixedArray::kLengthOffset));
2881 // rbx: last_match_info backing store (FixedArray)
2885 __ movq(FieldOperand(rbx, RegExpImpl::kLastCaptureCountOffset),
2889 __ movq(FieldOperand(rbx, RegExpImpl::kLastSubjectOffset), rax);
2891 __ RecordWriteField(rbx,
2897 __ movq(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
2898 __ RecordWriteField(rbx,
2908 // rbx: last_match_info backing store (FixedArray)
2921 __ movq(FieldOperand(rbx,
2941 masm->ExternalOperand(pending_exception_address, rbx);
2968 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2969 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2973 __ testb(rbx, Immediate(kIsIndirectStringMask));
2982 __ testb(rbx, Immediate(kStringEncodingMask));
2997 __ testb(rbx, Immediate(kIsNotStringMask | kShortExternalStringMask));
3015 __ SmiToInteger32(rbx, r8);
3016 __ cmpl(rbx, Immediate(kMaxInlineLength));
3021 // Allocate RegExpResult followed by FixedArray with size in rbx.
3026 rbx, // In: Number of elements.
3033 // rbx: Number of array elements as int32.
3061 // rbx: Number of elements in array as int32.
3067 __ Integer32ToSmi(rdx, rbx);
3074 // rbx: Number of elements in array that remains to be filled, as int32.
3078 __ testl(rbx, rbx);
3081 __ subl(rbx, Immediate(1));
3082 __ movq(Operand(rcx, rbx, times_pointer_size, 0), rdx);
3186 __ movq(rbx, Operand(rsp, kPointerSize));
3189 GenerateLookupNumberStringCache(masm, rbx, rax, r8, r9, &runtime);
3325 __ SelectNonSmi(rbx, rax, rdx, ¬_smis);
3328 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
3332 // Return non-equal. ebx (the lower half of rbx) is not zero.
3333 __ movq(rax, rbx);
3418 rdx, rax, rcx, rbx, &check_unequal_objects);
3426 rbx);
3432 rbx,
3455 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
3459 __ testb(FieldOperand(rbx, Map::kBitFieldOffset),
3514 // rbx : cache cell for call target
3520 __ movq(rcx, FieldOperand(rbx, Cell::kValueOffset));
3554 __ Move(FieldOperand(rbx, Cell::kValueOffset),
3574 __ push(rbx);
3579 __ pop(rbx);
3587 __ movq(FieldOperand(rbx, Cell::kValueOffset), rdi);
3595 // rbx : cache cell for call target
3654 __ Move(FieldOperand(rbx, Cell::kValueOffset),
3664 __ Set(rbx, 0);
3678 __ Set(rbx, 0);
3689 // rbx : cache cell for call target
3725 __ Set(rbx, 0);
3789 // rbx: pointer to C function (C callee-saved).
3851 __ call(rbx);
3925 // rbx: pointer to C function (C callee-saved)
3951 // rbx: pointer to builtin function (C callee-saved).
4044 __ push(rbx);
4136 __ pop(rbx);
4137 __ Cmp(rbx, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
4164 __ pop(rbx);
4243 __ TryGetFunctionPrototype(rdx, rbx, &slow, true);
4246 __ JumpIfSmi(rbx, &slow);
4247 __ CmpObjectType(rbx, FIRST_SPEC_OBJECT_TYPE, kScratchRegister);
4255 // rbx is function prototype.
4279 __ cmpq(rcx, rbx);
4511 GenerateConvertArgument(masm, 2 * kPointerSize, rax, rbx, rcx, rdi,
4516 GenerateConvertArgument(masm, 1 * kPointerSize, rdx, rbx, rcx, rdi,
4534 __ movq(rbx, FieldOperand(rax, String::kLengthOffset));
4535 __ SmiTest(rbx);
4544 // rbx: length of first string
4564 __ SmiAdd(rbx, rbx, rcx);
4567 __ SmiCompare(rbx, Smi::FromInt(2));
4571 __ JumpIfBothInstanceTypesAreNotSequentialAscii(r8, r9, rbx, rcx,
4575 __ movzxbq(rbx, FieldOperand(rax, SeqOneByteString::kHeaderSize));
4582 masm, rbx, rcx, r14, r11, rdi, r15, &make_two_character_string);
4589 // rbx - first byte: first character
4590 // rbx - second byte: *maybe* second character
4591 // Make sure that the second byte of rbx contains the second character.
4594 __ orl(rbx, rcx);
4596 __ movw(FieldOperand(rax, SeqOneByteString::kHeaderSize), rbx);
4602 __ SmiCompare(rbx, Smi::FromInt(ConsString::kMinLength));
4606 __ SmiCompare(rbx, Smi::FromInt(String::kMaxLength));
4612 // rbx: length of resulting flat string
4628 __ movq(FieldOperand(rcx, ConsString::kLengthOffset), rbx);
4635 __ Load(rbx, high_promotion_mode);
4636 __ testb(rbx, Immediate(1));
4643 rbx,
4649 rbx,
4684 // rbx: length of resulting flat string as smi
4733 __ SmiToInteger32(rbx, rbx);
4739 __ AllocateAsciiString(rax, rbx, rdi, r8, r9, &call_runtime);
4742 __ lea(rbx, FieldOperand(rax, SeqOneByteString::kHeaderSize));
4744 // rbx: first character of result
4746 StringHelper::GenerateCopyCharacters(masm, rbx, rcx, r14, true);
4747 // rbx: next character of result
4750 StringHelper::GenerateCopyCharacters(masm, rbx, rdx, r15, true);
4756 __ AllocateTwoByteString(rax, rbx, rdi, r8, r9, &call_runtime);
4759 __ lea(rbx, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
4761 // rbx: first character of result
4763 StringHelper::GenerateCopyCharacters(masm, rbx, rcx, r14, false);
4764 // rbx: next character of result
4767 StringHelper::GenerateCopyCharacters(masm, rbx, rdx, r15, false);
5149 Condition is_string = masm->IsObjectStringType(rax, rbx, rbx);
5153 // rbx: instance type
5179 // rbx: instance type
5188 __ testb(rbx, Immediate(kIsIndirectStringMask));
5191 __ testb(rbx, Immediate(kSlicedNotConsMask));
5200 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
5201 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
5209 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
5210 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
5222 // rbx: instance type of underlying subject string
5238 __ testb(rbx, Immediate(kStringEncodingMask));
5240 __ AllocateAsciiSlicedString(rax, rbx, r14, &runtime);
5243 __ AllocateTwoByteSlicedString(rax, rbx, r14, &runtime);
5258 // rbx: instance type of underlying subject string
5266 __ testb(rbx, Immediate(kExternalStringTag));
5272 __ testb(rbx, Immediate(kShortExternalStringMask));
5281 __ testb(rbx, Immediate(kStringEncodingMask));
5339 // rbx: instance type
5515 __ JumpIfNotBothSequentialAsciiStrings(rdx, rax, rcx, rbx, &runtime);
5523 GenerateCompareFlatAsciiStrings(masm, rdx, rax, rcx, rbx, rdi, r8);
5641 Register tmp2 = rbx;
5684 Register tmp2 = rbx;
5729 Register tmp2 = rbx;
5832 __ movq(rbx, FieldOperand(rdx, HeapObject::kMapOffset));
5835 __ Cmp(rbx, known_map_);
6083 { REG(rbx), REG(rax), REG(rdi), EMIT_REMEMBERED_SET },
6085 { REG(rbx), REG(rcx), REG(rdx), EMIT_REMEMBERED_SET },
6087 { REG(rbx), REG(rcx), REG(rdx), OMIT_REMEMBERED_SET },
6090 { REG(rdx), REG(rcx), REG(rbx), EMIT_REMEMBERED_SET },
6093 { REG(rbx), REG(rcx), REG(rdx), EMIT_REMEMBERED_SET },
6095 { REG(rbx), REG(r8), REG(r9), EMIT_REMEMBERED_SET },
6097 { REG(rbx), REG(rdx), REG(rcx), EMIT_REMEMBERED_SET},
6099 { REG(rdi), REG(rbx), REG(rcx), EMIT_REMEMBERED_SET},
6100 { REG(rdx), REG(rdi), REG(rbx), EMIT_REMEMBERED_SET},
6104 { REG(rdx), REG(rbx), REG(rdi), EMIT_REMEMBERED_SET},
6105 { REG(rdx), REG(rbx), REG(rdi), OMIT_REMEMBERED_SET},
6112 { REG(rbx), REG(rax), REG(rcx), EMIT_REMEMBERED_SET},
6115 { REG(rcx), REG(rdx), REG(rbx), EMIT_REMEMBERED_SET},
6117 { REG(rcx), REG(rax), REG(rbx), EMIT_REMEMBERED_SET},
6378 // clobbers rbx, rdx, rdi
6389 __ movq(rbx, Operand(rsp, 2 * kPointerSize));
6390 __ movq(rdi, FieldOperand(rbx, JSObject::kMapOffset));
6403 __ push(rbx);
6406 __ movq(rbx, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
6407 __ push(FieldOperand(rbx, JSFunction::kLiteralsOffset));
6415 __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
6416 __ lea(rcx, FieldOperand(rbx, kScratchRegister, times_pointer_size,
6420 __ RecordWrite(rbx, rcx, rax,
6430 __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
6431 __ movq(FieldOperand(rbx, kScratchRegister, times_pointer_size,
6438 __ movq(r9, FieldOperand(rbx, JSObject::kElementsOffset));
6454 __ movq(rbx, MemOperand(rbp, parameter_count_offset));
6460 __ lea(rsp, MemOperand(rsp, rbx, times_pointer_size, additional_offset));
6533 // rbx - type info cell
6563 __ Cmp(rbx, undefined_sentinel);
6565 __ movq(rcx, FieldOperand(rbx, Cell::kValueOffset));
6639 // -- rbx : type info cell
6661 // We should either have undefined in rbx or a valid cell
6664 __ Cmp(rbx, undefined_sentinel);
6666 __ Cmp(FieldOperand(rbx, 0), cell_map);
6673 __ Cmp(rbx, undefined_sentinel);
6675 __ movq(rdx, FieldOperand(rbx, Cell::kValueOffset));
6757 // -- rbx : type info cell
