Lines Matching defs:rbx
66 __ AllocateInNewSpace(JSFunction::kSize, rax, rbx, rcx, &gc, TAG_OBJECT);
84 __ LoadRoot(rbx, Heap::kEmptyFixedArrayRootIndex);
87 __ movq(FieldOperand(rax, JSObject::kPropertiesOffset), rbx);
88 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rbx);
92 __ movq(FieldOperand(rax, JSFunction::kLiteralsOffset), rbx);
122 rax, rbx, rcx, &gc, TAG_OBJECT);
133 __ Set(rbx, 0); // Set to NULL.
136 __ movq(Operand(rax, Context::SlotOffset(Context::EXTENSION_INDEX)), rbx);
139 __ movq(rbx, Operand(rsi, Context::SlotOffset(Context::GLOBAL_INDEX)));
140 __ movq(Operand(rax, Context::SlotOffset(Context::GLOBAL_INDEX)), rbx);
143 __ LoadRoot(rbx, Heap::kUndefinedValueRootIndex);
145 __ movq(Operand(rax, Context::SlotOffset(i)), rbx);
168 rax, rbx, rcx, &gc, TAG_OBJECT);
174 __ movq(rbx, Operand(rsp, 2 * kPointerSize));
200 __ movq(ContextOperand(rax, Context::EXTENSION_INDEX), rbx);
203 __ movq(rbx, ContextOperand(rsi, Context::GLOBAL_INDEX));
204 __ movq(ContextOperand(rax, Context::GLOBAL_INDEX), rbx);
207 __ LoadRoot(rbx, Heap::kTheHoleValueRootIndex);
209 __ movq(ContextOperand(rax, i + Context::MIN_CONTEXT_SLOTS), rbx);
243 __ AllocateInNewSpace(size, rax, rbx, rdx, fail, TAG_OBJECT);
248 __ movq(rbx, FieldOperand(rcx, i));
249 __ movq(FieldOperand(rax, i), rbx);
263 __ movq(rbx, FieldOperand(rcx, i));
264 __ movq(FieldOperand(rdx, i), rbx);
270 __ movq(rbx, FieldOperand(rcx, i));
271 __ movq(FieldOperand(rdx, i), rbx);
306 __ movq(rbx, FieldOperand(rcx, JSArray::kElementsOffset));
307 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
315 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
386 __ AllocateInNewSpace(size, rax, rbx, rdx, &slow_case, TAG_OBJECT);
388 __ movq(rbx, FieldOperand(rcx, i));
389 __ movq(FieldOperand(rax, i), rbx);
599 // Overwrites the contents of rdi, rbx and rcx. Result cannot be rdi or rbx.
605 ASSERT(!result.is(rdi) && !result.is(rbx));
608 Register double_exponent = rbx;
809 __ AllocateHeapNumber(rcx, rbx, &slow_allocate_heapnumber);
1046 right = rbx;
1047 __ movq(rbx, rax);
1055 right = rbx;
1056 __ movq(rbx, rax);
1106 __ movq(rax, rbx);
1110 __ AllocateHeapNumber(rcx, rbx, slow);
1140 FloatingPointHelper::NumbersToSmis(masm, left, right, rbx, rdi, rcx,
1212 __ movl(rbx, rax); // rbx holds result value (uint32 value as int64).
1230 __ cvtqsi2sd(xmm0, rbx);
1238 __ Integer32ToSmi(rdx, rbx);
1462 __ AllocateHeapNumber(rbx, rcx, alloc_failure);
1465 __ movq(rdx, rbx);
1479 __ AllocateHeapNumber(rbx, rcx, alloc_failure);
1482 __ movq(rax, rbx);
1522 // Then load the bits of the double into rbx.
1527 __ movq(rbx, xmm1);
1535 __ LoadRoot(rbx, Heap::kHeapNumberMapRootIndex);
1536 __ cmpq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
1539 // bits into rbx.
1541 __ movq(rbx, FieldOperand(rax, HeapNumber::kValueOffset));
1542 __ movq(rdx, rbx);
1546 __ movq(rbx, xmm1);
1551 // rbx = bits of double value.
1560 __ xorl(rdx, rbx);
1574 // rbx = bits of double value.
1607 __ cmpq(rbx, Operand(rcx, 0));
1632 __ movq(Operand(rcx, 0), rbx);
1702 // rbx: Bits of input double. Must be preserved.
1715 __ movq(rdi, rbx);
1815 IntegerConvert(masm, rcx, rax); // Uses rdi, rcx and rbx.
1819 IntegerConvert(masm, rdx, rdx); // Uses rdi, rcx and rbx.
2272 __ movq(rbx, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2273 __ Cmp(Operand(rbx, StandardFrameConstants::kContextOffset),
2285 __ lea(rbx, Operand(rbp, index.reg, index.scale, 0));
2287 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2294 __ movq(rcx, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2300 __ lea(rbx, Operand(rbx, index.reg, index.scale, 0));
2302 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2308 __ pop(rbx); // Return address.
2310 __ push(rbx);
2322 // rbx: the mapped parameter count (untagged)
2327 __ SmiToInteger64(rbx, Operand(rsp, 1 * kPointerSize));
2328 // rbx = parameter count (untagged)
2339 __ movq(rcx, rbx);
2351 // rbx = parameter count (untagged)
2353 // Compute the mapped parameter count = min(rbx, rcx) in rbx.
2354 __ cmpq(rbx, rcx);
2356 __ movq(rbx, rcx);
2366 __ testq(rbx, rbx);
2368 __ lea(r8, Operand(rbx, times_pointer_size, kParameterMapHeaderSize));
2386 __ testq(rbx, rbx);
2399 // rbx = mapped parameter count (untagged)
2430 // rbx = mapped parameter count (untagged)
2436 __ testq(rbx, rbx);
2440 // rbx contains the untagged argument count. Add 2 and tag to write.
2442 __ Integer64PlusConstantToSmi(r9, rbx, 2);
2445 __ lea(r9, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
2459 __ Integer32ToSmi(r9, rbx);
2465 __ lea(rdi, Operand(rdi, rbx, times_pointer_size, kParameterMapHeaderSize));
2499 __ movq(r8, rbx);
2596 __ AllocateInNewSpace(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT);
2607 __ movq(rbx, FieldOperand(rdi, i));
2608 __ movq(FieldOperand(rax, i), rbx);
2641 __ movq(rbx, Operand(rdx, -1 * kPointerSize)); // Skip receiver.
2642 __ movq(FieldOperand(rdi, FixedArray::kHeaderSize), rbx);
2706 __ SmiToInteger32(rbx, FieldOperand(rax, JSRegExp::kDataTagOffset));
2707 __ cmpl(rbx, Immediate(JSRegExp::IRREGEXP));
2725 Condition is_string = masm->IsObjectStringType(rdi, rbx, rbx);
2733 __ movq(rbx, Operand(rsp, kPreviousIndexOffset));
2734 __ JumpIfNotSmi(rbx, &runtime);
2735 __ SmiCompare(rbx, FieldOperand(rdi, String::kLengthOffset));
2746 __ movq(rbx, FieldOperand(rdi, JSArray::kElementsOffset));
2747 __ movq(rdi, FieldOperand(rbx, HeapObject::kMapOffset));
2748 __ CompareRoot(FieldOperand(rbx, HeapObject::kMapOffset),
2754 __ SmiToInteger32(rdi, FieldOperand(rbx, FixedArray::kLengthOffset));
2767 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2768 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
2770 __ andb(rbx, Immediate(kIsNotStringMask |
2779 __ andb(rbx, Immediate(kIsNotStringMask |
2784 // rbx: whether subject is a string and if yes, its string representation
2796 __ cmpq(rbx, Immediate(kExternalStringTag));
2802 __ testb(rbx, Immediate(kIsNotStringMask | kShortExternalStringMask));
2819 // rbx: map of first part of cons string or map of parent of sliced string.
2822 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
2823 __ testb(FieldOperand(rbx, Map::kInstanceTypeOffset),
2828 __ testb(FieldOperand(rbx, Map::kInstanceTypeOffset),
2856 __ SmiToInteger64(rbx, Operand(rsp, kPreviousIndexOffset));
2859 // rbx: previous index
2916 // rbx: previous index
2923 __ movq(arg2, rbx);
2930 __ addq(rbx, r14);
2934 // rbx: start index of the input
2940 __ lea(arg3, FieldOperand(rdi, rbx, times_1, SeqAsciiString::kHeaderSize));
2944 __ lea(arg3, FieldOperand(rdi, rbx, times_2, SeqTwoByteString::kHeaderSize));
2988 __ movq(rbx, FieldOperand(rax, JSArray::kElementsOffset));
2990 // rbx: last_match_info backing store (FixedArray)
2994 __ movq(FieldOperand(rbx, RegExpImpl::kLastCaptureCountOffset),
2998 __ movq(FieldOperand(rbx, RegExpImpl::kLastSubjectOffset), rax);
2999 __ RecordWriteField(rbx,
3005 __ movq(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
3006 __ RecordWriteField(rbx,
3016 // rbx: last_match_info backing store (FixedArray)
3029 __ movq(FieldOperand(rbx,
3049 masm->ExternalOperand(pending_exception_address, rbx);
3066 // rbx: scratch
3068 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
3069 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
3073 __ testb(rbx, Immediate(kIsIndirectStringMask));
3081 __ testb(rbx, Immediate(kStringEncodingMask));
3098 __ SmiToInteger32(rbx, r8);
3099 __ cmpl(rbx, Immediate(kMaxInlineLength));
3104 // Allocate RegExpResult followed by FixedArray with size in rbx.
3109 rbx, // In: Number of elements.
3116 // rbx: Number of array elements as int32.
3144 // rbx: Number of elements in array as int32.
3150 __ Integer32ToSmi(rdx, rbx);
3157 // rbx: Number of elements in array that remains to be filled, as int32.
3161 __ testl(rbx, rbx);
3164 __ subl(rbx, Immediate(1));
3165 __ movq(Operand(rcx, rbx, times_pointer_size, 0), rdx);
3273 __ movq(rbx, Operand(rsp, kPointerSize));
3276 GenerateLookupNumberStringCache(masm, rbx, rax, r8, r9, false, &runtime);
3393 __ SelectNonSmi(rbx, rax, rdx, ¬_smis);
3396 __ Cmp(FieldOperand(rbx, HeapObject::kMapOffset),
3400 // Return non-equal. ebx (the lower half of rbx) is not zero.
3401 __ movq(rax, rbx);
3486 rdx, rax, rcx, rbx, &check_unequal_objects);
3494 rbx);
3500 rbx,
3523 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
3527 __ testb(FieldOperand(rbx, Map::kBitFieldOffset),
3596 // rbx : cache cell for call target
3602 __ movq(rcx, FieldOperand(rbx, JSGlobalPropertyCell::kValueOffset));
3617 __ Move(FieldOperand(rbx, JSGlobalPropertyCell::kValueOffset),
3623 __ movq(FieldOperand(rbx, JSGlobalPropertyCell::kValueOffset), rdi);
3632 // rbx : cache cell for call target
3647 __ movq(rbx, GlobalObjectOperand());
3648 __ movq(rbx, FieldOperand(rbx, GlobalObject::kGlobalReceiverOffset));
3649 __ movq(Operand(rsp, (argc_ + 1) * kPointerSize), rbx);
3688 __ Set(rbx, 0);
3702 __ Set(rbx, 0);
3713 // rbx : cache cell for call target
3728 __ movq(rbx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
3729 __ movq(rbx, FieldOperand(rbx, SharedFunctionInfo::kConstructStubOffset));
3730 __ lea(rbx, FieldOperand(rbx, Code::kHeaderSize));
3731 __ jmp(rbx);
3747 __ Set(rbx, 0);
3795 // rbx: pointer to C function (C callee-saved).
3861 __ call(rbx);
3930 // rbx: pointer to C function (C callee-saved)
3954 // rbx: pointer to builtin function (C callee-saved).
4041 __ push(rbx);
4120 __ pop(rbx);
4121 __ Cmp(rbx, Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME));
4133 __ pop(rbx);
4212 __ TryGetFunctionPrototype(rdx, rbx, &slow, true);
4215 __ JumpIfSmi(rbx, &slow);
4216 __ CmpObjectType(rbx, FIRST_SPEC_OBJECT_TYPE, kScratchRegister);
4224 // rbx is function prototype.
4248 __ cmpq(rcx, rbx);
4534 GenerateConvertArgument(masm, 2 * kPointerSize, rax, rbx, rcx, rdi,
4539 GenerateConvertArgument(masm, 1 * kPointerSize, rdx, rbx, rcx, rdi,
4558 __ movq(rbx, FieldOperand(rax, String::kLengthOffset));
4559 __ SmiTest(rbx);
4568 // rbx: length of first string
4588 __ SmiAdd(rbx, rbx, rcx);
4591 __ SmiCompare(rbx, Smi::FromInt(2));
4595 __ JumpIfBothInstanceTypesAreNotSequentialAscii(r8, r9, rbx, rcx,
4599 __ movzxbq(rbx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4606 masm, rbx, rcx, r14, r11, rdi, r15, &make_two_character_string);
4613 // rbx - first byte: first character
4614 // rbx - second byte: *maybe* second character
4615 // Make sure that the second byte of rbx contains the second character.
4618 __ orl(rbx, rcx);
4620 __ movw(FieldOperand(rax, SeqAsciiString::kHeaderSize), rbx);
4626 __ SmiCompare(rbx, Smi::FromInt(ConsString::kMinLength));
4630 __ SmiCompare(rbx, Smi::FromInt(String::kMaxLength));
4636 // rbx: length of resulting flat string
4652 __ movq(FieldOperand(rcx, ConsString::kLengthOffset), rbx);
4682 // rbx: length of resulting flat string as smi
4731 __ SmiToInteger32(rbx, rbx);
4737 __ AllocateAsciiString(rax, rbx, rdi, r8, r9, &call_runtime);
4740 __ lea(rbx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4742 // rbx: first character of result
4744 StringHelper::GenerateCopyCharacters(masm, rbx, rcx, r14, true);
4745 // rbx: next character of result
4748 StringHelper::GenerateCopyCharacters(masm, rbx, rdx, r15, true);
4754 __ AllocateTwoByteString(rax, rbx, rdi, r8, r9, &call_runtime);
4757 __ lea(rbx, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
4759 // rbx: first character of result
4761 StringHelper::GenerateCopyCharacters(masm, rbx, rcx, r14, false);
4762 // rbx: next character of result
4765 StringHelper::GenerateCopyCharacters(masm, rbx, rdx, r15, false);
5109 Condition is_string = masm->IsObjectStringType(rax, rbx, rbx);
5113 // rbx: instance type
5138 // rbx: instance type
5141 __ JumpIfInstanceTypeIsNotSequentialAscii(rbx, rbx, &runtime);
5145 __ movzxbq(rbx, FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize));
5152 masm, rbx, rdi, r9, r11, r14, r15, &make_two_character_string);
5158 __ movzxwq(rbx, FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize));
5160 __ movw(FieldOperand(rax, SeqAsciiString::kHeaderSize), rbx);
5166 // rbx: instance type
5175 __ testb(rbx, Immediate(kIsIndirectStringMask));
5178 __ testb(rbx, Immediate(kSlicedNotConsMask));
5187 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
5188 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
5196 __ movq(rbx, FieldOperand(rdi, HeapObject::kMapOffset));
5197 __ movzxbl(rbx, FieldOperand(rbx, Map::kInstanceTypeOffset));
5209 // rbx: instance type of underlying subject string
5225 __ testb(rbx, Immediate(kStringEncodingMask));
5227 __ AllocateAsciiSlicedString(rax, rbx, r14, &runtime);
5230 __ AllocateTwoByteSlicedString(rax, rbx, r14, &runtime);
5245 // rbx: instance type of underlying subject string
5253 __ testb(rbx, Immediate(kExternalStringTag));
5259 __ testb(rbx, Immediate(kShortExternalStringMask));
5268 __ testb(rbx, Immediate(kStringEncodingMask));
5485 __ JumpIfNotBothSequentialAsciiStrings(rdx, rax, rcx, rbx, &runtime);
5493 GenerateCompareFlatAsciiStrings(masm, rdx, rax, rcx, rbx, rdi, r8);
5591 Register tmp2 = rbx;
5636 Register tmp2 = rbx;
5738 __ movq(rbx, FieldOperand(rdx, HeapObject::kMapOffset));
5741 __ Cmp(rbx, known_map_);
5998 { REG(rbx), REG(rax), REG(rdi), EMIT_REMEMBERED_SET },
6000 { REG(rbx), REG(rcx), REG(rdx), EMIT_REMEMBERED_SET },
6002 { REG(rbx), REG(rcx), REG(rdx), OMIT_REMEMBERED_SET },
6005 { REG(rdx), REG(rcx), REG(rbx), EMIT_REMEMBERED_SET },
6008 { REG(rbx), REG(rcx), REG(rdx), EMIT_REMEMBERED_SET },
6010 { REG(rbx), REG(r8), REG(r9), EMIT_REMEMBERED_SET },
6012 { REG(rbx), REG(rdx), REG(rcx), EMIT_REMEMBERED_SET},
6014 { REG(rdi), REG(rbx), REG(rcx), EMIT_REMEMBERED_SET},
6015 { REG(rdx), REG(rdi), REG(rbx), EMIT_REMEMBERED_SET},
6019 { REG(rdx), REG(rbx), REG(rdi), EMIT_REMEMBERED_SET},
6020 { REG(rdx), REG(rbx), REG(rdi), OMIT_REMEMBERED_SET},
6027 { REG(rbx), REG(rax), REG(rcx), EMIT_REMEMBERED_SET},
6280 // -- rbx : array literal
6305 __ push(rbx);
6308 __ movq(rbx, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
6309 __ push(FieldOperand(rbx, JSFunction::kLiteralsOffset));
6318 __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
6319 __ lea(rcx, FieldOperand(rbx, kScratchRegister, times_pointer_size,
6323 __ RecordWrite(rbx, rcx, rax,
6333 __ movq(rbx, FieldOperand(rbx, JSObject::kElementsOffset));
6334 __ movq(FieldOperand(rbx, kScratchRegister, times_pointer_size,
6341 __ movq(r9, FieldOperand(rbx, JSObject::kElementsOffset));