1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 #if defined(V8_TARGET_ARCH_IA32)
32 #include "bootstrapper.h"
36 #include "serialize.h"
41 // -------------------------------------------------------------------------
42 // MacroAssembler implementation.
44 MacroAssembler::MacroAssembler(Isolate* arg_isolate, void* buffer, int size)
45 : Assembler(arg_isolate, buffer, size),
46 generating_stub_(false),
47 allow_stub_calls_(true),
49 if (isolate() != NULL) {
50 code_object_ = Handle<Object>(isolate()->heap()->undefined_value(),
56 void MacroAssembler::InNewSpace(
61 Label::Distance condition_met_distance) {
62 ASSERT(cc == equal || cc == not_equal);
63 if (scratch.is(object)) {
64 and_(scratch, Immediate(~Page::kPageAlignmentMask));
66 mov(scratch, Immediate(~Page::kPageAlignmentMask));
67 and_(scratch, object);
69 // Check that we can use a test_b.
70 ASSERT(MemoryChunk::IN_FROM_SPACE < 8);
71 ASSERT(MemoryChunk::IN_TO_SPACE < 8);
72 int mask = (1 << MemoryChunk::IN_FROM_SPACE)
73 | (1 << MemoryChunk::IN_TO_SPACE);
74 // If non-zero, the page belongs to new-space.
75 test_b(Operand(scratch, MemoryChunk::kFlagsOffset),
76 static_cast<uint8_t>(mask));
77 j(cc, condition_met, condition_met_distance);
81 void MacroAssembler::RememberedSetHelper(
82 Register object, // Only used for debug checks.
85 SaveFPRegsMode save_fp,
86 MacroAssembler::RememberedSetFinalAction and_then) {
88 if (emit_debug_code()) {
90 JumpIfNotInNewSpace(object, scratch, &ok, Label::kNear);
94 // Load store buffer top.
95 ExternalReference store_buffer =
96 ExternalReference::store_buffer_top(isolate());
97 mov(scratch, Operand::StaticVariable(store_buffer));
98 // Store pointer to buffer.
99 mov(Operand(scratch, 0), addr);
100 // Increment buffer top.
101 add(scratch, Immediate(kPointerSize));
102 // Write back new top of buffer.
103 mov(Operand::StaticVariable(store_buffer), scratch);
104 // Call stub on end of buffer.
105 // Check for end of buffer.
106 test(scratch, Immediate(StoreBuffer::kStoreBufferOverflowBit));
107 if (and_then == kReturnAtEnd) {
108 Label buffer_overflowed;
109 j(not_equal, &buffer_overflowed, Label::kNear);
111 bind(&buffer_overflowed);
113 ASSERT(and_then == kFallThroughAtEnd);
114 j(equal, &done, Label::kNear);
116 StoreBufferOverflowStub store_buffer_overflow =
117 StoreBufferOverflowStub(save_fp);
118 CallStub(&store_buffer_overflow);
119 if (and_then == kReturnAtEnd) {
122 ASSERT(and_then == kFallThroughAtEnd);
128 void MacroAssembler::ClampDoubleToUint8(XMMRegister input_reg,
129 XMMRegister scratch_reg,
130 Register result_reg) {
133 pxor(scratch_reg, scratch_reg);
134 cvtsd2si(result_reg, input_reg);
135 test(result_reg, Immediate(0xFFFFFF00));
136 j(zero, &done, Label::kNear);
137 cmp(result_reg, Immediate(0x80000000));
138 j(equal, &conv_failure, Label::kNear);
139 mov(result_reg, Immediate(0));
140 setcc(above, result_reg);
141 sub(result_reg, Immediate(1));
142 and_(result_reg, Immediate(255));
143 jmp(&done, Label::kNear);
145 Set(result_reg, Immediate(0));
146 ucomisd(input_reg, scratch_reg);
147 j(below, &done, Label::kNear);
148 Set(result_reg, Immediate(255));
153 void MacroAssembler::ClampUint8(Register reg) {
155 test(reg, Immediate(0xFFFFFF00));
156 j(zero, &done, Label::kNear);
157 setcc(negative, reg); // 1 if negative, 0 if positive.
158 dec_b(reg); // 0 if negative, 255 if positive.
163 static double kUint32Bias =
164 static_cast<double>(static_cast<uint32_t>(0xFFFFFFFF)) + 1;
167 void MacroAssembler::LoadUint32(XMMRegister dst,
169 XMMRegister scratch) {
171 cmp(src, Immediate(0));
173 Operand(reinterpret_cast<int32_t>(&kUint32Bias), RelocInfo::NONE));
175 j(not_sign, &done, Label::kNear);
181 void MacroAssembler::RecordWriteArray(Register object,
184 SaveFPRegsMode save_fp,
185 RememberedSetAction remembered_set_action,
186 SmiCheck smi_check) {
187 // First, check if a write barrier is even needed. The tests below
188 // catch stores of Smis.
191 // Skip barrier if writing a smi.
192 if (smi_check == INLINE_SMI_CHECK) {
193 ASSERT_EQ(0, kSmiTag);
194 test(value, Immediate(kSmiTagMask));
198 // Array access: calculate the destination address in the same manner as
199 // KeyedStoreIC::GenerateGeneric. Multiply a smi by 2 to get an offset
200 // into an array of words.
201 Register dst = index;
202 lea(dst, Operand(object, index, times_half_pointer_size,
203 FixedArray::kHeaderSize - kHeapObjectTag));
206 object, dst, value, save_fp, remembered_set_action, OMIT_SMI_CHECK);
210 // Clobber clobbered input registers when running with the debug-code flag
211 // turned on to provoke errors.
212 if (emit_debug_code()) {
213 mov(value, Immediate(BitCast<int32_t>(kZapValue)));
214 mov(index, Immediate(BitCast<int32_t>(kZapValue)));
219 void MacroAssembler::RecordWriteField(
224 SaveFPRegsMode save_fp,
225 RememberedSetAction remembered_set_action,
226 SmiCheck smi_check) {
227 // First, check if a write barrier is even needed. The tests below
228 // catch stores of Smis.
231 // Skip barrier if writing a smi.
232 if (smi_check == INLINE_SMI_CHECK) {
233 JumpIfSmi(value, &done, Label::kNear);
236 // Although the object register is tagged, the offset is relative to the start
237 // of the object, so so offset must be a multiple of kPointerSize.
238 ASSERT(IsAligned(offset, kPointerSize));
240 lea(dst, FieldOperand(object, offset));
241 if (emit_debug_code()) {
243 test_b(dst, (1 << kPointerSizeLog2) - 1);
244 j(zero, &ok, Label::kNear);
250 object, dst, value, save_fp, remembered_set_action, OMIT_SMI_CHECK);
254 // Clobber clobbered input registers when running with the debug-code flag
255 // turned on to provoke errors.
256 if (emit_debug_code()) {
257 mov(value, Immediate(BitCast<int32_t>(kZapValue)));
258 mov(dst, Immediate(BitCast<int32_t>(kZapValue)));
263 void MacroAssembler::RecordWriteForMap(
268 SaveFPRegsMode save_fp) {
271 Register address = scratch1;
272 Register value = scratch2;
273 if (emit_debug_code()) {
275 lea(address, FieldOperand(object, HeapObject::kMapOffset));
276 test_b(address, (1 << kPointerSizeLog2) - 1);
277 j(zero, &ok, Label::kNear);
282 ASSERT(!object.is(value));
283 ASSERT(!object.is(address));
284 ASSERT(!value.is(address));
285 AssertNotSmi(object);
287 if (!FLAG_incremental_marking) {
291 // A single check of the map's pages interesting flag suffices, since it is
292 // only set during incremental collection, and then it's also guaranteed that
293 // the from object's page's interesting flag is also set. This optimization
294 // relies on the fact that maps can never be in new space.
295 ASSERT(!isolate()->heap()->InNewSpace(*map));
296 CheckPageFlagForMap(map,
297 MemoryChunk::kPointersToHereAreInterestingMask,
302 // Delay the initialization of |address| and |value| for the stub until it's
303 // known that the will be needed. Up until this point their values are not
304 // needed since they are embedded in the operands of instructions that need
306 lea(address, FieldOperand(object, HeapObject::kMapOffset));
307 mov(value, Immediate(map));
308 RecordWriteStub stub(object, value, address, OMIT_REMEMBERED_SET, save_fp);
313 // Clobber clobbered input registers when running with the debug-code flag
314 // turned on to provoke errors.
315 if (emit_debug_code()) {
316 mov(value, Immediate(BitCast<int32_t>(kZapValue)));
317 mov(scratch1, Immediate(BitCast<int32_t>(kZapValue)));
318 mov(scratch2, Immediate(BitCast<int32_t>(kZapValue)));
323 void MacroAssembler::RecordWrite(Register object,
326 SaveFPRegsMode fp_mode,
327 RememberedSetAction remembered_set_action,
328 SmiCheck smi_check) {
329 ASSERT(!object.is(value));
330 ASSERT(!object.is(address));
331 ASSERT(!value.is(address));
332 AssertNotSmi(object);
334 if (remembered_set_action == OMIT_REMEMBERED_SET &&
335 !FLAG_incremental_marking) {
339 if (emit_debug_code()) {
341 cmp(value, Operand(address, 0));
342 j(equal, &ok, Label::kNear);
347 // First, check if a write barrier is even needed. The tests below
348 // catch stores of Smis and stores into young gen.
351 if (smi_check == INLINE_SMI_CHECK) {
352 // Skip barrier if writing a smi.
353 JumpIfSmi(value, &done, Label::kNear);
357 value, // Used as scratch.
358 MemoryChunk::kPointersToHereAreInterestingMask,
362 CheckPageFlag(object,
363 value, // Used as scratch.
364 MemoryChunk::kPointersFromHereAreInterestingMask,
369 RecordWriteStub stub(object, value, address, remembered_set_action, fp_mode);
374 // Clobber clobbered registers when running with the debug-code flag
375 // turned on to provoke errors.
376 if (emit_debug_code()) {
377 mov(address, Immediate(BitCast<int32_t>(kZapValue)));
378 mov(value, Immediate(BitCast<int32_t>(kZapValue)));
383 #ifdef ENABLE_DEBUGGER_SUPPORT
384 void MacroAssembler::DebugBreak() {
385 Set(eax, Immediate(0));
386 mov(ebx, Immediate(ExternalReference(Runtime::kDebugBreak, isolate())));
388 call(ces.GetCode(), RelocInfo::DEBUG_BREAK);
393 void MacroAssembler::Set(Register dst, const Immediate& x) {
395 xor_(dst, dst); // Shorter than mov.
402 void MacroAssembler::Set(const Operand& dst, const Immediate& x) {
407 bool MacroAssembler::IsUnsafeImmediate(const Immediate& x) {
408 static const int kMaxImmediateBits = 17;
409 if (x.rmode_ != RelocInfo::NONE) return false;
410 return !is_intn(x.x_, kMaxImmediateBits);
414 void MacroAssembler::SafeSet(Register dst, const Immediate& x) {
415 if (IsUnsafeImmediate(x) && jit_cookie() != 0) {
416 Set(dst, Immediate(x.x_ ^ jit_cookie()));
417 xor_(dst, jit_cookie());
424 void MacroAssembler::SafePush(const Immediate& x) {
425 if (IsUnsafeImmediate(x) && jit_cookie() != 0) {
426 push(Immediate(x.x_ ^ jit_cookie()));
427 xor_(Operand(esp, 0), Immediate(jit_cookie()));
434 void MacroAssembler::CompareRoot(Register with, Heap::RootListIndex index) {
435 // see ROOT_ACCESSOR macro in factory.h
436 Handle<Object> value(&isolate()->heap()->roots_array_start()[index]);
441 void MacroAssembler::CompareRoot(const Operand& with,
442 Heap::RootListIndex index) {
443 // see ROOT_ACCESSOR macro in factory.h
444 Handle<Object> value(&isolate()->heap()->roots_array_start()[index]);
449 void MacroAssembler::CmpObjectType(Register heap_object,
452 mov(map, FieldOperand(heap_object, HeapObject::kMapOffset));
453 CmpInstanceType(map, type);
457 void MacroAssembler::CmpInstanceType(Register map, InstanceType type) {
458 cmpb(FieldOperand(map, Map::kInstanceTypeOffset),
459 static_cast<int8_t>(type));
463 void MacroAssembler::CheckFastElements(Register map,
465 Label::Distance distance) {
466 STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
467 STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
468 STATIC_ASSERT(FAST_ELEMENTS == 2);
469 STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
470 cmpb(FieldOperand(map, Map::kBitField2Offset),
471 Map::kMaximumBitField2FastHoleyElementValue);
472 j(above, fail, distance);
476 void MacroAssembler::CheckFastObjectElements(Register map,
478 Label::Distance distance) {
479 STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
480 STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
481 STATIC_ASSERT(FAST_ELEMENTS == 2);
482 STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
483 cmpb(FieldOperand(map, Map::kBitField2Offset),
484 Map::kMaximumBitField2FastHoleySmiElementValue);
485 j(below_equal, fail, distance);
486 cmpb(FieldOperand(map, Map::kBitField2Offset),
487 Map::kMaximumBitField2FastHoleyElementValue);
488 j(above, fail, distance);
492 void MacroAssembler::CheckFastSmiElements(Register map,
494 Label::Distance distance) {
495 STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
496 STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
497 cmpb(FieldOperand(map, Map::kBitField2Offset),
498 Map::kMaximumBitField2FastHoleySmiElementValue);
499 j(above, fail, distance);
503 void MacroAssembler::StoreNumberToDoubleElements(
504 Register maybe_number,
508 XMMRegister scratch2,
510 bool specialize_for_processor) {
511 Label smi_value, done, maybe_nan, not_nan, is_nan, have_double_value;
512 JumpIfSmi(maybe_number, &smi_value, Label::kNear);
514 CheckMap(maybe_number,
515 isolate()->factory()->heap_number_map(),
519 // Double value, canonicalize NaN.
520 uint32_t offset = HeapNumber::kValueOffset + sizeof(kHoleNanLower32);
521 cmp(FieldOperand(maybe_number, offset),
522 Immediate(kNaNOrInfinityLowerBoundUpper32));
523 j(greater_equal, &maybe_nan, Label::kNear);
526 ExternalReference canonical_nan_reference =
527 ExternalReference::address_of_canonical_non_hole_nan();
528 if (CpuFeatures::IsSupported(SSE2) && specialize_for_processor) {
529 CpuFeatures::Scope use_sse2(SSE2);
530 movdbl(scratch2, FieldOperand(maybe_number, HeapNumber::kValueOffset));
531 bind(&have_double_value);
532 movdbl(FieldOperand(elements, key, times_4, FixedDoubleArray::kHeaderSize),
535 fld_d(FieldOperand(maybe_number, HeapNumber::kValueOffset));
536 bind(&have_double_value);
537 fstp_d(FieldOperand(elements, key, times_4, FixedDoubleArray::kHeaderSize));
542 // Could be NaN or Infinity. If fraction is not zero, it's NaN, otherwise
543 // it's an Infinity, and the non-NaN code path applies.
544 j(greater, &is_nan, Label::kNear);
545 cmp(FieldOperand(maybe_number, HeapNumber::kValueOffset), Immediate(0));
548 if (CpuFeatures::IsSupported(SSE2) && specialize_for_processor) {
549 CpuFeatures::Scope use_sse2(SSE2);
550 movdbl(scratch2, Operand::StaticVariable(canonical_nan_reference));
552 fld_d(Operand::StaticVariable(canonical_nan_reference));
554 jmp(&have_double_value, Label::kNear);
557 // Value is a smi. Convert to a double and store.
558 // Preserve original value.
559 mov(scratch1, maybe_number);
561 if (CpuFeatures::IsSupported(SSE2) && specialize_for_processor) {
562 CpuFeatures::Scope fscope(SSE2);
563 cvtsi2sd(scratch2, scratch1);
564 movdbl(FieldOperand(elements, key, times_4, FixedDoubleArray::kHeaderSize),
568 fild_s(Operand(esp, 0));
570 fstp_d(FieldOperand(elements, key, times_4, FixedDoubleArray::kHeaderSize));
576 void MacroAssembler::CompareMap(Register obj,
578 Label* early_success,
579 CompareMapMode mode) {
580 cmp(FieldOperand(obj, HeapObject::kMapOffset), map);
581 if (mode == ALLOW_ELEMENT_TRANSITION_MAPS) {
582 ElementsKind kind = map->elements_kind();
583 if (IsFastElementsKind(kind)) {
584 bool packed = IsFastPackedElementsKind(kind);
585 Map* current_map = *map;
586 while (CanTransitionToMoreGeneralFastElementsKind(kind, packed)) {
587 kind = GetNextMoreGeneralFastElementsKind(kind, packed);
588 current_map = current_map->LookupElementsTransitionMap(kind);
589 if (!current_map) break;
590 j(equal, early_success, Label::kNear);
591 cmp(FieldOperand(obj, HeapObject::kMapOffset),
592 Handle<Map>(current_map));
599 void MacroAssembler::CheckMap(Register obj,
602 SmiCheckType smi_check_type,
603 CompareMapMode mode) {
604 if (smi_check_type == DO_SMI_CHECK) {
605 JumpIfSmi(obj, fail);
609 CompareMap(obj, map, &success, mode);
615 void MacroAssembler::DispatchMap(Register obj,
617 Handle<Code> success,
618 SmiCheckType smi_check_type) {
620 if (smi_check_type == DO_SMI_CHECK) {
621 JumpIfSmi(obj, &fail);
623 cmp(FieldOperand(obj, HeapObject::kMapOffset), Immediate(map));
630 Condition MacroAssembler::IsObjectStringType(Register heap_object,
632 Register instance_type) {
633 mov(map, FieldOperand(heap_object, HeapObject::kMapOffset));
634 movzx_b(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
635 STATIC_ASSERT(kNotStringTag != 0);
636 test(instance_type, Immediate(kIsNotStringMask));
641 void MacroAssembler::IsObjectJSObjectType(Register heap_object,
645 mov(map, FieldOperand(heap_object, HeapObject::kMapOffset));
646 IsInstanceJSObjectType(map, scratch, fail);
650 void MacroAssembler::IsInstanceJSObjectType(Register map,
653 movzx_b(scratch, FieldOperand(map, Map::kInstanceTypeOffset));
654 sub(scratch, Immediate(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
656 LAST_NONCALLABLE_SPEC_OBJECT_TYPE - FIRST_NONCALLABLE_SPEC_OBJECT_TYPE);
661 void MacroAssembler::FCmp() {
662 if (CpuFeatures::IsSupported(CMOV)) {
675 void MacroAssembler::AssertNumber(Register object) {
676 if (emit_debug_code()) {
678 JumpIfSmi(object, &ok);
679 cmp(FieldOperand(object, HeapObject::kMapOffset),
680 isolate()->factory()->heap_number_map());
681 Check(equal, "Operand not a number");
687 void MacroAssembler::AssertSmi(Register object) {
688 if (emit_debug_code()) {
689 test(object, Immediate(kSmiTagMask));
690 Check(equal, "Operand is not a smi");
695 void MacroAssembler::AssertString(Register object) {
696 if (emit_debug_code()) {
697 test(object, Immediate(kSmiTagMask));
698 Check(not_equal, "Operand is a smi and not a string");
700 mov(object, FieldOperand(object, HeapObject::kMapOffset));
701 CmpInstanceType(object, FIRST_NONSTRING_TYPE);
703 Check(below, "Operand is not a string");
708 void MacroAssembler::AssertNotSmi(Register object) {
709 if (emit_debug_code()) {
710 test(object, Immediate(kSmiTagMask));
711 Check(not_equal, "Operand is a smi");
716 void MacroAssembler::EnterFrame(StackFrame::Type type) {
720 push(Immediate(Smi::FromInt(type)));
721 push(Immediate(CodeObject()));
722 if (emit_debug_code()) {
723 cmp(Operand(esp, 0), Immediate(isolate()->factory()->undefined_value()));
724 Check(not_equal, "code object not properly patched");
729 void MacroAssembler::LeaveFrame(StackFrame::Type type) {
730 if (emit_debug_code()) {
731 cmp(Operand(ebp, StandardFrameConstants::kMarkerOffset),
732 Immediate(Smi::FromInt(type)));
733 Check(equal, "stack frame types must match");
739 void MacroAssembler::EnterExitFramePrologue() {
740 // Set up the frame structure on the stack.
741 ASSERT(ExitFrameConstants::kCallerSPDisplacement == +2 * kPointerSize);
742 ASSERT(ExitFrameConstants::kCallerPCOffset == +1 * kPointerSize);
743 ASSERT(ExitFrameConstants::kCallerFPOffset == 0 * kPointerSize);
747 // Reserve room for entry stack pointer and push the code object.
748 ASSERT(ExitFrameConstants::kSPOffset == -1 * kPointerSize);
749 push(Immediate(0)); // Saved entry sp, patched before call.
750 push(Immediate(CodeObject())); // Accessed from ExitFrame::code_slot.
752 // Save the frame pointer and the context in top.
753 ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress,
755 ExternalReference context_address(Isolate::kContextAddress,
757 mov(Operand::StaticVariable(c_entry_fp_address), ebp);
758 mov(Operand::StaticVariable(context_address), esi);
762 void MacroAssembler::EnterExitFrameEpilogue(int argc, bool save_doubles) {
763 // Optionally save all XMM registers.
765 CpuFeatures::Scope scope(SSE2);
766 int space = XMMRegister::kNumRegisters * kDoubleSize + argc * kPointerSize;
767 sub(esp, Immediate(space));
768 const int offset = -2 * kPointerSize;
769 for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
770 XMMRegister reg = XMMRegister::from_code(i);
771 movdbl(Operand(ebp, offset - ((i + 1) * kDoubleSize)), reg);
774 sub(esp, Immediate(argc * kPointerSize));
777 // Get the required frame alignment for the OS.
778 const int kFrameAlignment = OS::ActivationFrameAlignment();
779 if (kFrameAlignment > 0) {
780 ASSERT(IsPowerOf2(kFrameAlignment));
781 and_(esp, -kFrameAlignment);
784 // Patch the saved entry sp.
785 mov(Operand(ebp, ExitFrameConstants::kSPOffset), esp);
789 void MacroAssembler::EnterExitFrame(bool save_doubles) {
790 EnterExitFramePrologue();
792 // Set up argc and argv in callee-saved registers.
793 int offset = StandardFrameConstants::kCallerSPOffset - kPointerSize;
795 lea(esi, Operand(ebp, eax, times_4, offset));
797 // Reserve space for argc, argv and isolate.
798 EnterExitFrameEpilogue(3, save_doubles);
802 void MacroAssembler::EnterApiExitFrame(int argc) {
803 EnterExitFramePrologue();
804 EnterExitFrameEpilogue(argc, false);
808 void MacroAssembler::LeaveExitFrame(bool save_doubles) {
809 // Optionally restore all XMM registers.
811 CpuFeatures::Scope scope(SSE2);
812 const int offset = -2 * kPointerSize;
813 for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
814 XMMRegister reg = XMMRegister::from_code(i);
815 movdbl(reg, Operand(ebp, offset - ((i + 1) * kDoubleSize)));
819 // Get the return address from the stack and restore the frame pointer.
820 mov(ecx, Operand(ebp, 1 * kPointerSize));
821 mov(ebp, Operand(ebp, 0 * kPointerSize));
823 // Pop the arguments and the receiver from the caller stack.
824 lea(esp, Operand(esi, 1 * kPointerSize));
826 // Push the return address to get ready to return.
829 LeaveExitFrameEpilogue();
832 void MacroAssembler::LeaveExitFrameEpilogue() {
833 // Restore current context from top and clear it in debug mode.
834 ExternalReference context_address(Isolate::kContextAddress, isolate());
835 mov(esi, Operand::StaticVariable(context_address));
837 mov(Operand::StaticVariable(context_address), Immediate(0));
840 // Clear the top frame.
841 ExternalReference c_entry_fp_address(Isolate::kCEntryFPAddress,
843 mov(Operand::StaticVariable(c_entry_fp_address), Immediate(0));
847 void MacroAssembler::LeaveApiExitFrame() {
851 LeaveExitFrameEpilogue();
855 void MacroAssembler::PushTryHandler(StackHandler::Kind kind,
857 // Adjust this code if not the case.
858 STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
859 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
860 STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
861 STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
862 STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
863 STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
865 // We will build up the handler from the bottom by pushing on the stack.
866 // First push the frame pointer and context.
867 if (kind == StackHandler::JS_ENTRY) {
868 // The frame pointer does not point to a JS frame so we save NULL for
869 // ebp. We expect the code throwing an exception to check ebp before
870 // dereferencing it to restore the context.
871 push(Immediate(0)); // NULL frame pointer.
872 push(Immediate(Smi::FromInt(0))); // No context.
877 // Push the state and the code object.
879 StackHandler::IndexField::encode(handler_index) |
880 StackHandler::KindField::encode(kind);
881 push(Immediate(state));
884 // Link the current handler as the next handler.
885 ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
886 push(Operand::StaticVariable(handler_address));
887 // Set this new handler as the current one.
888 mov(Operand::StaticVariable(handler_address), esp);
892 void MacroAssembler::PopTryHandler() {
893 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
894 ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
895 pop(Operand::StaticVariable(handler_address));
896 add(esp, Immediate(StackHandlerConstants::kSize - kPointerSize));
900 void MacroAssembler::JumpToHandlerEntry() {
901 // Compute the handler entry address and jump to it. The handler table is
902 // a fixed array of (smi-tagged) code offsets.
903 // eax = exception, edi = code object, edx = state.
904 mov(ebx, FieldOperand(edi, Code::kHandlerTableOffset));
905 shr(edx, StackHandler::kKindWidth);
906 mov(edx, FieldOperand(ebx, edx, times_4, FixedArray::kHeaderSize));
908 lea(edi, FieldOperand(edi, edx, times_1, Code::kHeaderSize));
913 void MacroAssembler::Throw(Register value) {
914 // Adjust this code if not the case.
915 STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
916 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
917 STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
918 STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
919 STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
920 STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
922 // The exception is expected in eax.
923 if (!value.is(eax)) {
926 // Drop the stack pointer to the top of the top handler.
927 ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
928 mov(esp, Operand::StaticVariable(handler_address));
929 // Restore the next handler.
930 pop(Operand::StaticVariable(handler_address));
932 // Remove the code object and state, compute the handler address in edi.
933 pop(edi); // Code object.
934 pop(edx); // Index and state.
936 // Restore the context and frame pointer.
937 pop(esi); // Context.
938 pop(ebp); // Frame pointer.
940 // If the handler is a JS frame, restore the context to the frame.
941 // (kind == ENTRY) == (ebp == 0) == (esi == 0), so we could test either
945 j(zero, &skip, Label::kNear);
946 mov(Operand(ebp, StandardFrameConstants::kContextOffset), esi);
949 JumpToHandlerEntry();
953 void MacroAssembler::ThrowUncatchable(Register value) {
954 // Adjust this code if not the case.
955 STATIC_ASSERT(StackHandlerConstants::kSize == 5 * kPointerSize);
956 STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
957 STATIC_ASSERT(StackHandlerConstants::kCodeOffset == 1 * kPointerSize);
958 STATIC_ASSERT(StackHandlerConstants::kStateOffset == 2 * kPointerSize);
959 STATIC_ASSERT(StackHandlerConstants::kContextOffset == 3 * kPointerSize);
960 STATIC_ASSERT(StackHandlerConstants::kFPOffset == 4 * kPointerSize);
962 // The exception is expected in eax.
963 if (!value.is(eax)) {
966 // Drop the stack pointer to the top of the top stack handler.
967 ExternalReference handler_address(Isolate::kHandlerAddress, isolate());
968 mov(esp, Operand::StaticVariable(handler_address));
970 // Unwind the handlers until the top ENTRY handler is found.
971 Label fetch_next, check_kind;
972 jmp(&check_kind, Label::kNear);
974 mov(esp, Operand(esp, StackHandlerConstants::kNextOffset));
977 STATIC_ASSERT(StackHandler::JS_ENTRY == 0);
978 test(Operand(esp, StackHandlerConstants::kStateOffset),
979 Immediate(StackHandler::KindField::kMask));
980 j(not_zero, &fetch_next);
982 // Set the top handler address to next handler past the top ENTRY handler.
983 pop(Operand::StaticVariable(handler_address));
985 // Remove the code object and state, compute the handler address in edi.
986 pop(edi); // Code object.
987 pop(edx); // Index and state.
989 // Clear the context pointer and frame pointer (0 was saved in the handler).
993 JumpToHandlerEntry();
997 void MacroAssembler::CheckAccessGlobalProxy(Register holder_reg,
1000 Label same_contexts;
1002 ASSERT(!holder_reg.is(scratch));
1004 // Load current lexical context from the stack frame.
1005 mov(scratch, Operand(ebp, StandardFrameConstants::kContextOffset));
1007 // When generating debug code, make sure the lexical context is set.
1008 if (emit_debug_code()) {
1009 cmp(scratch, Immediate(0));
1010 Check(not_equal, "we should not have an empty lexical context");
1012 // Load the native context of the current context.
1014 Context::kHeaderSize + Context::GLOBAL_OBJECT_INDEX * kPointerSize;
1015 mov(scratch, FieldOperand(scratch, offset));
1016 mov(scratch, FieldOperand(scratch, GlobalObject::kNativeContextOffset));
1018 // Check the context is a native context.
1019 if (emit_debug_code()) {
1021 // Read the first word and compare to native_context_map.
1022 mov(scratch, FieldOperand(scratch, HeapObject::kMapOffset));
1023 cmp(scratch, isolate()->factory()->native_context_map());
1024 Check(equal, "JSGlobalObject::native_context should be a native context.");
1028 // Check if both contexts are the same.
1029 cmp(scratch, FieldOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
1030 j(equal, &same_contexts);
1032 // Compare security tokens, save holder_reg on the stack so we can use it
1033 // as a temporary register.
1035 // TODO(119): avoid push(holder_reg)/pop(holder_reg)
1037 // Check that the security token in the calling global object is
1038 // compatible with the security token in the receiving global
1041 FieldOperand(holder_reg, JSGlobalProxy::kNativeContextOffset));
1043 // Check the context is a native context.
1044 if (emit_debug_code()) {
1045 cmp(holder_reg, isolate()->factory()->null_value());
1046 Check(not_equal, "JSGlobalProxy::context() should not be null.");
1049 // Read the first word and compare to native_context_map(),
1050 mov(holder_reg, FieldOperand(holder_reg, HeapObject::kMapOffset));
1051 cmp(holder_reg, isolate()->factory()->native_context_map());
1052 Check(equal, "JSGlobalObject::native_context should be a native context.");
1056 int token_offset = Context::kHeaderSize +
1057 Context::SECURITY_TOKEN_INDEX * kPointerSize;
1058 mov(scratch, FieldOperand(scratch, token_offset));
1059 cmp(scratch, FieldOperand(holder_reg, token_offset));
1063 bind(&same_contexts);
1067 // Compute the hash code from the untagged key. This must be kept in sync
1068 // with ComputeIntegerHash in utils.h.
1070 // Note: r0 will contain hash code
1071 void MacroAssembler::GetNumberHash(Register r0, Register scratch) {
1072 // Xor original key with a seed.
1073 if (Serializer::enabled()) {
1074 ExternalReference roots_array_start =
1075 ExternalReference::roots_array_start(isolate());
1076 mov(scratch, Immediate(Heap::kHashSeedRootIndex));
1078 Operand::StaticArray(scratch, times_pointer_size, roots_array_start));
1082 int32_t seed = isolate()->heap()->HashSeed();
1083 xor_(r0, Immediate(seed));
1086 // hash = ~hash + (hash << 15);
1091 // hash = hash ^ (hash >> 12);
1095 // hash = hash + (hash << 2);
1096 lea(r0, Operand(r0, r0, times_4, 0));
1097 // hash = hash ^ (hash >> 4);
1101 // hash = hash * 2057;
1103 // hash = hash ^ (hash >> 16);
1111 void MacroAssembler::LoadFromNumberDictionary(Label* miss,
1120 // elements - holds the slow-case elements of the receiver and is unchanged.
1122 // key - holds the smi key on entry and is unchanged.
1124 // Scratch registers:
1126 // r0 - holds the untagged key on entry and holds the hash once computed.
1128 // r1 - used to hold the capacity mask of the dictionary
1130 // r2 - used for the index into the dictionary.
1132 // result - holds the result on exit if the load succeeds and we fall through.
1136 GetNumberHash(r0, r1);
1138 // Compute capacity mask.
1139 mov(r1, FieldOperand(elements, SeededNumberDictionary::kCapacityOffset));
1140 shr(r1, kSmiTagSize); // convert smi to int
1143 // Generate an unrolled loop that performs a few probes before giving up.
1144 const int kProbes = 4;
1145 for (int i = 0; i < kProbes; i++) {
1146 // Use r2 for index calculations and keep the hash intact in r0.
1148 // Compute the masked index: (hash + i + i * i) & mask.
1150 add(r2, Immediate(SeededNumberDictionary::GetProbeOffset(i)));
1154 // Scale the index by multiplying by the entry size.
1155 ASSERT(SeededNumberDictionary::kEntrySize == 3);
1156 lea(r2, Operand(r2, r2, times_2, 0)); // r2 = r2 * 3
1158 // Check if the key matches.
1159 cmp(key, FieldOperand(elements,
1162 SeededNumberDictionary::kElementsStartOffset));
1163 if (i != (kProbes - 1)) {
1171 // Check that the value is a normal propety.
1172 const int kDetailsOffset =
1173 SeededNumberDictionary::kElementsStartOffset + 2 * kPointerSize;
1174 ASSERT_EQ(NORMAL, 0);
1175 test(FieldOperand(elements, r2, times_pointer_size, kDetailsOffset),
1176 Immediate(PropertyDetails::TypeField::kMask << kSmiTagSize));
1179 // Get the value at the masked, scaled index.
1180 const int kValueOffset =
1181 SeededNumberDictionary::kElementsStartOffset + kPointerSize;
1182 mov(result, FieldOperand(elements, r2, times_pointer_size, kValueOffset));
1186 void MacroAssembler::LoadAllocationTopHelper(Register result,
1188 AllocationFlags flags) {
1189 ExternalReference new_space_allocation_top =
1190 ExternalReference::new_space_allocation_top_address(isolate());
1192 // Just return if allocation top is already known.
1193 if ((flags & RESULT_CONTAINS_TOP) != 0) {
1194 // No use of scratch if allocation top is provided.
1195 ASSERT(scratch.is(no_reg));
1197 // Assert that result actually contains top on entry.
1198 cmp(result, Operand::StaticVariable(new_space_allocation_top));
1199 Check(equal, "Unexpected allocation top");
1204 // Move address of new object to result. Use scratch register if available.
1205 if (scratch.is(no_reg)) {
1206 mov(result, Operand::StaticVariable(new_space_allocation_top));
1208 mov(scratch, Immediate(new_space_allocation_top));
1209 mov(result, Operand(scratch, 0));
1214 void MacroAssembler::UpdateAllocationTopHelper(Register result_end,
1216 if (emit_debug_code()) {
1217 test(result_end, Immediate(kObjectAlignmentMask));
1218 Check(zero, "Unaligned allocation in new space");
1221 ExternalReference new_space_allocation_top =
1222 ExternalReference::new_space_allocation_top_address(isolate());
1224 // Update new top. Use scratch if available.
1225 if (scratch.is(no_reg)) {
1226 mov(Operand::StaticVariable(new_space_allocation_top), result_end);
1228 mov(Operand(scratch, 0), result_end);
1233 void MacroAssembler::AllocateInNewSpace(int object_size,
1235 Register result_end,
1238 AllocationFlags flags) {
1239 if (!FLAG_inline_new) {
1240 if (emit_debug_code()) {
1241 // Trash the registers to simulate an allocation failure.
1242 mov(result, Immediate(0x7091));
1243 if (result_end.is_valid()) {
1244 mov(result_end, Immediate(0x7191));
1246 if (scratch.is_valid()) {
1247 mov(scratch, Immediate(0x7291));
1253 ASSERT(!result.is(result_end));
1255 // Load address of new object into result.
1256 LoadAllocationTopHelper(result, scratch, flags);
1258 Register top_reg = result_end.is_valid() ? result_end : result;
1260 // Calculate new top and bail out if new space is exhausted.
1261 ExternalReference new_space_allocation_limit =
1262 ExternalReference::new_space_allocation_limit_address(isolate());
1264 if (!top_reg.is(result)) {
1265 mov(top_reg, result);
1267 add(top_reg, Immediate(object_size));
1268 j(carry, gc_required);
1269 cmp(top_reg, Operand::StaticVariable(new_space_allocation_limit));
1270 j(above, gc_required);
1272 // Update allocation top.
1273 UpdateAllocationTopHelper(top_reg, scratch);
1275 // Tag result if requested.
1276 if (top_reg.is(result)) {
1277 if ((flags & TAG_OBJECT) != 0) {
1278 sub(result, Immediate(object_size - kHeapObjectTag));
1280 sub(result, Immediate(object_size));
1282 } else if ((flags & TAG_OBJECT) != 0) {
1283 add(result, Immediate(kHeapObjectTag));
1288 void MacroAssembler::AllocateInNewSpace(int header_size,
1289 ScaleFactor element_size,
1290 Register element_count,
1292 Register result_end,
1295 AllocationFlags flags) {
1296 if (!FLAG_inline_new) {
1297 if (emit_debug_code()) {
1298 // Trash the registers to simulate an allocation failure.
1299 mov(result, Immediate(0x7091));
1300 mov(result_end, Immediate(0x7191));
1301 if (scratch.is_valid()) {
1302 mov(scratch, Immediate(0x7291));
1304 // Register element_count is not modified by the function.
1309 ASSERT(!result.is(result_end));
1311 // Load address of new object into result.
1312 LoadAllocationTopHelper(result, scratch, flags);
1314 // Calculate new top and bail out if new space is exhausted.
1315 ExternalReference new_space_allocation_limit =
1316 ExternalReference::new_space_allocation_limit_address(isolate());
1318 // We assume that element_count*element_size + header_size does not
1320 lea(result_end, Operand(element_count, element_size, header_size));
1321 add(result_end, result);
1322 j(carry, gc_required);
1323 cmp(result_end, Operand::StaticVariable(new_space_allocation_limit));
1324 j(above, gc_required);
1326 // Tag result if requested.
1327 if ((flags & TAG_OBJECT) != 0) {
1328 lea(result, Operand(result, kHeapObjectTag));
1331 // Update allocation top.
1332 UpdateAllocationTopHelper(result_end, scratch);
1336 void MacroAssembler::AllocateInNewSpace(Register object_size,
1338 Register result_end,
1341 AllocationFlags flags) {
1342 if (!FLAG_inline_new) {
1343 if (emit_debug_code()) {
1344 // Trash the registers to simulate an allocation failure.
1345 mov(result, Immediate(0x7091));
1346 mov(result_end, Immediate(0x7191));
1347 if (scratch.is_valid()) {
1348 mov(scratch, Immediate(0x7291));
1350 // object_size is left unchanged by this function.
1355 ASSERT(!result.is(result_end));
1357 // Load address of new object into result.
1358 LoadAllocationTopHelper(result, scratch, flags);
1360 // Calculate new top and bail out if new space is exhausted.
1361 ExternalReference new_space_allocation_limit =
1362 ExternalReference::new_space_allocation_limit_address(isolate());
1363 if (!object_size.is(result_end)) {
1364 mov(result_end, object_size);
1366 add(result_end, result);
1367 j(carry, gc_required);
1368 cmp(result_end, Operand::StaticVariable(new_space_allocation_limit));
1369 j(above, gc_required);
1371 // Tag result if requested.
1372 if ((flags & TAG_OBJECT) != 0) {
1373 lea(result, Operand(result, kHeapObjectTag));
1376 // Update allocation top.
1377 UpdateAllocationTopHelper(result_end, scratch);
1381 void MacroAssembler::UndoAllocationInNewSpace(Register object) {
1382 ExternalReference new_space_allocation_top =
1383 ExternalReference::new_space_allocation_top_address(isolate());
1385 // Make sure the object has no tag before resetting top.
1386 and_(object, Immediate(~kHeapObjectTagMask));
1388 cmp(object, Operand::StaticVariable(new_space_allocation_top));
1389 Check(below, "Undo allocation of non allocated memory");
1391 mov(Operand::StaticVariable(new_space_allocation_top), object);
1395 void MacroAssembler::AllocateHeapNumber(Register result,
1398 Label* gc_required) {
1399 // Allocate heap number in new space.
1400 AllocateInNewSpace(HeapNumber::kSize,
1408 mov(FieldOperand(result, HeapObject::kMapOffset),
1409 Immediate(isolate()->factory()->heap_number_map()));
1413 void MacroAssembler::AllocateTwoByteString(Register result,
1418 Label* gc_required) {
1419 // Calculate the number of bytes needed for the characters in the string while
1420 // observing object alignment.
1421 ASSERT((SeqTwoByteString::kHeaderSize & kObjectAlignmentMask) == 0);
1422 ASSERT(kShortSize == 2);
1423 // scratch1 = length * 2 + kObjectAlignmentMask.
1424 lea(scratch1, Operand(length, length, times_1, kObjectAlignmentMask));
1425 and_(scratch1, Immediate(~kObjectAlignmentMask));
1427 // Allocate two byte string in new space.
1428 AllocateInNewSpace(SeqTwoByteString::kHeaderSize,
1437 // Set the map, length and hash field.
1438 mov(FieldOperand(result, HeapObject::kMapOffset),
1439 Immediate(isolate()->factory()->string_map()));
1440 mov(scratch1, length);
1442 mov(FieldOperand(result, String::kLengthOffset), scratch1);
1443 mov(FieldOperand(result, String::kHashFieldOffset),
1444 Immediate(String::kEmptyHashField));
1448 void MacroAssembler::AllocateAsciiString(Register result,
1453 Label* gc_required) {
1454 // Calculate the number of bytes needed for the characters in the string while
1455 // observing object alignment.
1456 ASSERT((SeqAsciiString::kHeaderSize & kObjectAlignmentMask) == 0);
1457 mov(scratch1, length);
1458 ASSERT(kCharSize == 1);
1459 add(scratch1, Immediate(kObjectAlignmentMask));
1460 and_(scratch1, Immediate(~kObjectAlignmentMask));
1462 // Allocate ASCII string in new space.
1463 AllocateInNewSpace(SeqAsciiString::kHeaderSize,
1472 // Set the map, length and hash field.
1473 mov(FieldOperand(result, HeapObject::kMapOffset),
1474 Immediate(isolate()->factory()->ascii_string_map()));
1475 mov(scratch1, length);
1477 mov(FieldOperand(result, String::kLengthOffset), scratch1);
1478 mov(FieldOperand(result, String::kHashFieldOffset),
1479 Immediate(String::kEmptyHashField));
1483 void MacroAssembler::AllocateAsciiString(Register result,
1487 Label* gc_required) {
1490 // Allocate ASCII string in new space.
1491 AllocateInNewSpace(SeqAsciiString::SizeFor(length),
1498 // Set the map, length and hash field.
1499 mov(FieldOperand(result, HeapObject::kMapOffset),
1500 Immediate(isolate()->factory()->ascii_string_map()));
1501 mov(FieldOperand(result, String::kLengthOffset),
1502 Immediate(Smi::FromInt(length)));
1503 mov(FieldOperand(result, String::kHashFieldOffset),
1504 Immediate(String::kEmptyHashField));
1508 void MacroAssembler::AllocateTwoByteConsString(Register result,
1511 Label* gc_required) {
1512 // Allocate heap number in new space.
1513 AllocateInNewSpace(ConsString::kSize,
1520 // Set the map. The other fields are left uninitialized.
1521 mov(FieldOperand(result, HeapObject::kMapOffset),
1522 Immediate(isolate()->factory()->cons_string_map()));
1526 void MacroAssembler::AllocateAsciiConsString(Register result,
1529 Label* gc_required) {
1530 // Allocate heap number in new space.
1531 AllocateInNewSpace(ConsString::kSize,
1538 // Set the map. The other fields are left uninitialized.
1539 mov(FieldOperand(result, HeapObject::kMapOffset),
1540 Immediate(isolate()->factory()->cons_ascii_string_map()));
1544 void MacroAssembler::AllocateTwoByteSlicedString(Register result,
1547 Label* gc_required) {
1548 // Allocate heap number in new space.
1549 AllocateInNewSpace(SlicedString::kSize,
1556 // Set the map. The other fields are left uninitialized.
1557 mov(FieldOperand(result, HeapObject::kMapOffset),
1558 Immediate(isolate()->factory()->sliced_string_map()));
1562 void MacroAssembler::AllocateAsciiSlicedString(Register result,
1565 Label* gc_required) {
1566 // Allocate heap number in new space.
1567 AllocateInNewSpace(SlicedString::kSize,
1574 // Set the map. The other fields are left uninitialized.
1575 mov(FieldOperand(result, HeapObject::kMapOffset),
1576 Immediate(isolate()->factory()->sliced_ascii_string_map()));
1580 // Copy memory, byte-by-byte, from source to destination. Not optimized for
1581 // long or aligned copies. The contents of scratch and length are destroyed.
1582 // Source and destination are incremented by length.
1583 // Many variants of movsb, loop unrolling, word moves, and indexed operands
1584 // have been tried here already, and this is fastest.
1585 // A simpler loop is faster on small copies, but 30% slower on large ones.
1586 // The cld() instruction must have been emitted, to set the direction flag(),
1587 // before calling this function.
1588 void MacroAssembler::CopyBytes(Register source,
1589 Register destination,
1592 Label loop, done, short_string, short_loop;
1593 // Experimentation shows that the short string loop is faster if length < 10.
1594 cmp(length, Immediate(10));
1595 j(less_equal, &short_string);
1597 ASSERT(source.is(esi));
1598 ASSERT(destination.is(edi));
1599 ASSERT(length.is(ecx));
1601 // Because source is 4-byte aligned in our uses of this function,
1602 // we keep source aligned for the rep_movs call by copying the odd bytes
1603 // at the end of the ranges.
1604 mov(scratch, Operand(source, length, times_1, -4));
1605 mov(Operand(destination, length, times_1, -4), scratch);
1609 and_(scratch, Immediate(0x3));
1610 add(destination, scratch);
1613 bind(&short_string);
1614 test(length, length);
1618 mov_b(scratch, Operand(source, 0));
1619 mov_b(Operand(destination, 0), scratch);
1623 j(not_zero, &short_loop);
1629 void MacroAssembler::InitializeFieldsWithFiller(Register start_offset,
1630 Register end_offset,
1635 mov(Operand(start_offset, 0), filler);
1636 add(start_offset, Immediate(kPointerSize));
1638 cmp(start_offset, end_offset);
1643 void MacroAssembler::BooleanBitTest(Register object,
1646 bit_index += kSmiTagSize + kSmiShiftSize;
1647 ASSERT(IsPowerOf2(kBitsPerByte));
1648 int byte_index = bit_index / kBitsPerByte;
1649 int byte_bit_index = bit_index & (kBitsPerByte - 1);
1650 test_b(FieldOperand(object, field_offset + byte_index),
1651 static_cast<byte>(1 << byte_bit_index));
1656 void MacroAssembler::NegativeZeroTest(Register result,
1658 Label* then_label) {
1660 test(result, result);
1663 j(sign, then_label);
1668 void MacroAssembler::NegativeZeroTest(Register result,
1672 Label* then_label) {
1674 test(result, result);
1678 j(sign, then_label);
1683 void MacroAssembler::TryGetFunctionPrototype(Register function,
1687 bool miss_on_bound_function) {
1688 // Check that the receiver isn't a smi.
1689 JumpIfSmi(function, miss);
1691 // Check that the function really is a function.
1692 CmpObjectType(function, JS_FUNCTION_TYPE, result);
1695 if (miss_on_bound_function) {
1696 // If a bound function, go to miss label.
1698 FieldOperand(function, JSFunction::kSharedFunctionInfoOffset));
1699 BooleanBitTest(scratch, SharedFunctionInfo::kCompilerHintsOffset,
1700 SharedFunctionInfo::kBoundFunction);
1704 // Make sure that the function has an instance prototype.
1706 movzx_b(scratch, FieldOperand(result, Map::kBitFieldOffset));
1707 test(scratch, Immediate(1 << Map::kHasNonInstancePrototype));
1708 j(not_zero, &non_instance);
1710 // Get the prototype or initial map from the function.
1712 FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
1714 // If the prototype or initial map is the hole, don't return it and
1715 // simply miss the cache instead. This will allow us to allocate a
1716 // prototype object on-demand in the runtime system.
1717 cmp(result, Immediate(isolate()->factory()->the_hole_value()));
1720 // If the function does not have an initial map, we're done.
1722 CmpObjectType(result, MAP_TYPE, scratch);
1723 j(not_equal, &done);
1725 // Get the prototype from the initial map.
1726 mov(result, FieldOperand(result, Map::kPrototypeOffset));
1729 // Non-instance prototype: Fetch prototype from constructor field
1731 bind(&non_instance);
1732 mov(result, FieldOperand(result, Map::kConstructorOffset));
1739 void MacroAssembler::CallStub(CodeStub* stub, TypeFeedbackId ast_id) {
1740 ASSERT(AllowThisStubCall(stub)); // Calls are not allowed in some stubs.
1741 call(stub->GetCode(), RelocInfo::CODE_TARGET, ast_id);
1745 void MacroAssembler::TailCallStub(CodeStub* stub) {
1746 ASSERT(allow_stub_calls_ || stub->CompilingCallsToThisStubIsGCSafe());
1747 jmp(stub->GetCode(), RelocInfo::CODE_TARGET);
1751 void MacroAssembler::StubReturn(int argc) {
1752 ASSERT(argc >= 1 && generating_stub());
1753 ret((argc - 1) * kPointerSize);
1757 bool MacroAssembler::AllowThisStubCall(CodeStub* stub) {
1758 if (!has_frame_ && stub->SometimesSetsUpAFrame()) return false;
1759 return allow_stub_calls_ || stub->CompilingCallsToThisStubIsGCSafe();
1763 void MacroAssembler::IllegalOperation(int num_arguments) {
1764 if (num_arguments > 0) {
1765 add(esp, Immediate(num_arguments * kPointerSize));
1767 mov(eax, Immediate(isolate()->factory()->undefined_value()));
1771 void MacroAssembler::IndexFromHash(Register hash, Register index) {
1772 // The assert checks that the constants for the maximum number of digits
1773 // for an array index cached in the hash field and the number of bits
1774 // reserved for it does not conflict.
1775 ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) <
1776 (1 << String::kArrayIndexValueBits));
1777 // We want the smi-tagged index in key. kArrayIndexValueMask has zeros in
1778 // the low kHashShift bits.
1779 and_(hash, String::kArrayIndexValueMask);
1780 STATIC_ASSERT(String::kHashShift >= kSmiTagSize && kSmiTag == 0);
1781 if (String::kHashShift > kSmiTagSize) {
1782 shr(hash, String::kHashShift - kSmiTagSize);
1784 if (!index.is(hash)) {
1790 void MacroAssembler::CallRuntime(Runtime::FunctionId id, int num_arguments) {
1791 CallRuntime(Runtime::FunctionForId(id), num_arguments);
1795 void MacroAssembler::CallRuntimeSaveDoubles(Runtime::FunctionId id) {
1796 const Runtime::Function* function = Runtime::FunctionForId(id);
1797 Set(eax, Immediate(function->nargs));
1798 mov(ebx, Immediate(ExternalReference(function, isolate())));
1799 CEntryStub ces(1, kSaveFPRegs);
1804 void MacroAssembler::CallRuntime(const Runtime::Function* f,
1805 int num_arguments) {
1806 // If the expected number of arguments of the runtime function is
1807 // constant, we check that the actual number of arguments match the
1809 if (f->nargs >= 0 && f->nargs != num_arguments) {
1810 IllegalOperation(num_arguments);
1814 // TODO(1236192): Most runtime routines don't need the number of
1815 // arguments passed in because it is constant. At some point we
1816 // should remove this need and make the runtime routine entry code
1818 Set(eax, Immediate(num_arguments));
1819 mov(ebx, Immediate(ExternalReference(f, isolate())));
1825 void MacroAssembler::CallExternalReference(ExternalReference ref,
1826 int num_arguments) {
1827 mov(eax, Immediate(num_arguments));
1828 mov(ebx, Immediate(ref));
1835 void MacroAssembler::TailCallExternalReference(const ExternalReference& ext,
1838 // TODO(1236192): Most runtime routines don't need the number of
1839 // arguments passed in because it is constant. At some point we
1840 // should remove this need and make the runtime routine entry code
1842 Set(eax, Immediate(num_arguments));
1843 JumpToExternalReference(ext);
1847 void MacroAssembler::TailCallRuntime(Runtime::FunctionId fid,
1850 TailCallExternalReference(ExternalReference(fid, isolate()),
1856 // If true, a Handle<T> returned by value from a function with cdecl calling
1857 // convention will be returned directly as a value of location_ field in a
1859 // If false, it is returned as a pointer to a preallocated by caller memory
1860 // region. Pointer to this region should be passed to a function as an
1861 // implicit first argument.
1862 #if defined(USING_BSD_ABI) || defined(__MINGW32__) || defined(__CYGWIN__)
1863 static const bool kReturnHandlesDirectly = true;
1865 static const bool kReturnHandlesDirectly = false;
1869 Operand ApiParameterOperand(int index) {
1871 esp, (index + (kReturnHandlesDirectly ? 0 : 1)) * kPointerSize);
1875 void MacroAssembler::PrepareCallApiFunction(int argc) {
1876 if (kReturnHandlesDirectly) {
1877 EnterApiExitFrame(argc);
1878 // When handles are returned directly we don't have to allocate extra
1879 // space for and pass an out parameter.
1880 if (emit_debug_code()) {
1881 mov(esi, Immediate(BitCast<int32_t>(kZapValue)));
1884 // We allocate two additional slots: return value and pointer to it.
1885 EnterApiExitFrame(argc + 2);
1887 // The argument slots are filled as follows:
1889 // n + 1: output slot
1893 // 0: pointer to the output slot
1895 lea(esi, Operand(esp, (argc + 1) * kPointerSize));
1896 mov(Operand(esp, 0 * kPointerSize), esi);
1897 if (emit_debug_code()) {
1898 mov(Operand(esi, 0), Immediate(0));
1904 void MacroAssembler::CallApiFunctionAndReturn(Address function_address,
1906 ExternalReference next_address =
1907 ExternalReference::handle_scope_next_address();
1908 ExternalReference limit_address =
1909 ExternalReference::handle_scope_limit_address();
1910 ExternalReference level_address =
1911 ExternalReference::handle_scope_level_address();
1913 // Allocate HandleScope in callee-save registers.
1914 mov(ebx, Operand::StaticVariable(next_address));
1915 mov(edi, Operand::StaticVariable(limit_address));
1916 add(Operand::StaticVariable(level_address), Immediate(1));
1918 // Call the api function.
1919 call(function_address, RelocInfo::RUNTIME_ENTRY);
1921 if (!kReturnHandlesDirectly) {
1922 // PrepareCallApiFunction saved pointer to the output slot into
1923 // callee-save register esi.
1924 mov(eax, Operand(esi, 0));
1929 Label promote_scheduled_exception;
1930 Label delete_allocated_handles;
1931 Label leave_exit_frame;
1933 // Check if the result handle holds 0.
1935 j(zero, &empty_handle);
1936 // It was non-zero. Dereference to get the result value.
1937 mov(eax, Operand(eax, 0));
1939 // No more valid handles (the result handle was the last one). Restore
1940 // previous handle scope.
1941 mov(Operand::StaticVariable(next_address), ebx);
1942 sub(Operand::StaticVariable(level_address), Immediate(1));
1943 Assert(above_equal, "Invalid HandleScope level");
1944 cmp(edi, Operand::StaticVariable(limit_address));
1945 j(not_equal, &delete_allocated_handles);
1946 bind(&leave_exit_frame);
1948 // Check if the function scheduled an exception.
1949 ExternalReference scheduled_exception_address =
1950 ExternalReference::scheduled_exception_address(isolate());
1951 cmp(Operand::StaticVariable(scheduled_exception_address),
1952 Immediate(isolate()->factory()->the_hole_value()));
1953 j(not_equal, &promote_scheduled_exception);
1955 #if ENABLE_EXTRA_CHECKS
1956 // Check if the function returned a valid JavaScript value.
1958 Register return_value = eax;
1961 JumpIfSmi(return_value, &ok, Label::kNear);
1962 mov(map, FieldOperand(return_value, HeapObject::kMapOffset));
1964 CmpInstanceType(map, FIRST_NONSTRING_TYPE);
1965 j(below, &ok, Label::kNear);
1967 CmpInstanceType(map, FIRST_SPEC_OBJECT_TYPE);
1968 j(above_equal, &ok, Label::kNear);
1970 cmp(map, isolate()->factory()->heap_number_map());
1971 j(equal, &ok, Label::kNear);
1973 cmp(return_value, isolate()->factory()->undefined_value());
1974 j(equal, &ok, Label::kNear);
1976 cmp(return_value, isolate()->factory()->true_value());
1977 j(equal, &ok, Label::kNear);
1979 cmp(return_value, isolate()->factory()->false_value());
1980 j(equal, &ok, Label::kNear);
1982 cmp(return_value, isolate()->factory()->null_value());
1983 j(equal, &ok, Label::kNear);
1985 Abort("API call returned invalid object");
1990 LeaveApiExitFrame();
1991 ret(stack_space * kPointerSize);
1993 bind(&empty_handle);
1994 // It was zero; the result is undefined.
1995 mov(eax, isolate()->factory()->undefined_value());
1998 bind(&promote_scheduled_exception);
1999 TailCallRuntime(Runtime::kPromoteScheduledException, 0, 1);
2001 // HandleScope limit has changed. Delete allocated extensions.
2002 ExternalReference delete_extensions =
2003 ExternalReference::delete_handle_scope_extensions(isolate());
2004 bind(&delete_allocated_handles);
2005 mov(Operand::StaticVariable(limit_address), edi);
2007 mov(Operand(esp, 0), Immediate(ExternalReference::isolate_address()));
2008 mov(eax, Immediate(delete_extensions));
2011 jmp(&leave_exit_frame);
2015 void MacroAssembler::JumpToExternalReference(const ExternalReference& ext) {
2016 // Set the entry point and jump to the C entry runtime stub.
2017 mov(ebx, Immediate(ext));
2019 jmp(ces.GetCode(), RelocInfo::CODE_TARGET);
2023 void MacroAssembler::SetCallKind(Register dst, CallKind call_kind) {
2024 // This macro takes the dst register to make the code more readable
2025 // at the call sites. However, the dst register has to be ecx to
2026 // follow the calling convention which requires the call type to be
2028 ASSERT(dst.is(ecx));
2029 if (call_kind == CALL_AS_FUNCTION) {
2030 // Set to some non-zero smi by updating the least significant
2032 mov_b(dst, 1 << kSmiTagSize);
2034 // Set to smi zero by clearing the register.
2040 void MacroAssembler::InvokePrologue(const ParameterCount& expected,
2041 const ParameterCount& actual,
2042 Handle<Code> code_constant,
2043 const Operand& code_operand,
2045 bool* definitely_mismatches,
2047 Label::Distance done_near,
2048 const CallWrapper& call_wrapper,
2049 CallKind call_kind) {
2050 bool definitely_matches = false;
2051 *definitely_mismatches = false;
2053 if (expected.is_immediate()) {
2054 ASSERT(actual.is_immediate());
2055 if (expected.immediate() == actual.immediate()) {
2056 definitely_matches = true;
2058 mov(eax, actual.immediate());
2059 const int sentinel = SharedFunctionInfo::kDontAdaptArgumentsSentinel;
2060 if (expected.immediate() == sentinel) {
2061 // Don't worry about adapting arguments for builtins that
2062 // don't want that done. Skip adaption code by making it look
2063 // like we have a match between expected and actual number of
2065 definitely_matches = true;
2067 *definitely_mismatches = true;
2068 mov(ebx, expected.immediate());
2072 if (actual.is_immediate()) {
2073 // Expected is in register, actual is immediate. This is the
2074 // case when we invoke function values without going through the
2076 cmp(expected.reg(), actual.immediate());
2078 ASSERT(expected.reg().is(ebx));
2079 mov(eax, actual.immediate());
2080 } else if (!expected.reg().is(actual.reg())) {
2081 // Both expected and actual are in (different) registers. This
2082 // is the case when we invoke functions using call and apply.
2083 cmp(expected.reg(), actual.reg());
2085 ASSERT(actual.reg().is(eax));
2086 ASSERT(expected.reg().is(ebx));
2090 if (!definitely_matches) {
2091 Handle<Code> adaptor =
2092 isolate()->builtins()->ArgumentsAdaptorTrampoline();
2093 if (!code_constant.is_null()) {
2094 mov(edx, Immediate(code_constant));
2095 add(edx, Immediate(Code::kHeaderSize - kHeapObjectTag));
2096 } else if (!code_operand.is_reg(edx)) {
2097 mov(edx, code_operand);
2100 if (flag == CALL_FUNCTION) {
2101 call_wrapper.BeforeCall(CallSize(adaptor, RelocInfo::CODE_TARGET));
2102 SetCallKind(ecx, call_kind);
2103 call(adaptor, RelocInfo::CODE_TARGET);
2104 call_wrapper.AfterCall();
2105 if (!*definitely_mismatches) {
2106 jmp(done, done_near);
2109 SetCallKind(ecx, call_kind);
2110 jmp(adaptor, RelocInfo::CODE_TARGET);
2117 void MacroAssembler::InvokeCode(const Operand& code,
2118 const ParameterCount& expected,
2119 const ParameterCount& actual,
2121 const CallWrapper& call_wrapper,
2122 CallKind call_kind) {
2123 // You can't call a function without a valid frame.
2124 ASSERT(flag == JUMP_FUNCTION || has_frame());
2127 bool definitely_mismatches = false;
2128 InvokePrologue(expected, actual, Handle<Code>::null(), code,
2129 &done, &definitely_mismatches, flag, Label::kNear,
2130 call_wrapper, call_kind);
2131 if (!definitely_mismatches) {
2132 if (flag == CALL_FUNCTION) {
2133 call_wrapper.BeforeCall(CallSize(code));
2134 SetCallKind(ecx, call_kind);
2136 call_wrapper.AfterCall();
2138 ASSERT(flag == JUMP_FUNCTION);
2139 SetCallKind(ecx, call_kind);
2147 void MacroAssembler::InvokeCode(Handle<Code> code,
2148 const ParameterCount& expected,
2149 const ParameterCount& actual,
2150 RelocInfo::Mode rmode,
2152 const CallWrapper& call_wrapper,
2153 CallKind call_kind) {
2154 // You can't call a function without a valid frame.
2155 ASSERT(flag == JUMP_FUNCTION || has_frame());
2158 Operand dummy(eax, 0);
2159 bool definitely_mismatches = false;
2160 InvokePrologue(expected, actual, code, dummy, &done, &definitely_mismatches,
2161 flag, Label::kNear, call_wrapper, call_kind);
2162 if (!definitely_mismatches) {
2163 if (flag == CALL_FUNCTION) {
2164 call_wrapper.BeforeCall(CallSize(code, rmode));
2165 SetCallKind(ecx, call_kind);
2167 call_wrapper.AfterCall();
2169 ASSERT(flag == JUMP_FUNCTION);
2170 SetCallKind(ecx, call_kind);
2178 void MacroAssembler::InvokeFunction(Register fun,
2179 const ParameterCount& actual,
2181 const CallWrapper& call_wrapper,
2182 CallKind call_kind) {
2183 // You can't call a function without a valid frame.
2184 ASSERT(flag == JUMP_FUNCTION || has_frame());
2186 ASSERT(fun.is(edi));
2187 mov(edx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
2188 mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
2189 mov(ebx, FieldOperand(edx, SharedFunctionInfo::kFormalParameterCountOffset));
2192 ParameterCount expected(ebx);
2193 InvokeCode(FieldOperand(edi, JSFunction::kCodeEntryOffset),
2194 expected, actual, flag, call_wrapper, call_kind);
2198 void MacroAssembler::InvokeFunction(Handle<JSFunction> function,
2199 const ParameterCount& actual,
2201 const CallWrapper& call_wrapper,
2202 CallKind call_kind) {
2203 // You can't call a function without a valid frame.
2204 ASSERT(flag == JUMP_FUNCTION || has_frame());
2206 // Get the function and setup the context.
2207 LoadHeapObject(edi, function);
2208 mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
2210 ParameterCount expected(function->shared()->formal_parameter_count());
2211 // We call indirectly through the code field in the function to
2212 // allow recompilation to take effect without changing any of the
2214 InvokeCode(FieldOperand(edi, JSFunction::kCodeEntryOffset),
2215 expected, actual, flag, call_wrapper, call_kind);
2219 void MacroAssembler::InvokeBuiltin(Builtins::JavaScript id,
2221 const CallWrapper& call_wrapper) {
2222 // You can't call a builtin without a valid frame.
2223 ASSERT(flag == JUMP_FUNCTION || has_frame());
2225 // Rely on the assertion to check that the number of provided
2226 // arguments match the expected number of arguments. Fake a
2227 // parameter count to avoid emitting code to do the check.
2228 ParameterCount expected(0);
2229 GetBuiltinFunction(edi, id);
2230 InvokeCode(FieldOperand(edi, JSFunction::kCodeEntryOffset),
2231 expected, expected, flag, call_wrapper, CALL_AS_METHOD);
2235 void MacroAssembler::GetBuiltinFunction(Register target,
2236 Builtins::JavaScript id) {
2237 // Load the JavaScript builtin function from the builtins object.
2238 mov(target, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
2239 mov(target, FieldOperand(target, GlobalObject::kBuiltinsOffset));
2240 mov(target, FieldOperand(target,
2241 JSBuiltinsObject::OffsetOfFunctionWithId(id)));
2245 void MacroAssembler::GetBuiltinEntry(Register target, Builtins::JavaScript id) {
2246 ASSERT(!target.is(edi));
2247 // Load the JavaScript builtin function from the builtins object.
2248 GetBuiltinFunction(edi, id);
2249 // Load the code entry point from the function into the target register.
2250 mov(target, FieldOperand(edi, JSFunction::kCodeEntryOffset));
2254 void MacroAssembler::LoadContext(Register dst, int context_chain_length) {
2255 if (context_chain_length > 0) {
2256 // Move up the chain of contexts to the context containing the slot.
2257 mov(dst, Operand(esi, Context::SlotOffset(Context::PREVIOUS_INDEX)));
2258 for (int i = 1; i < context_chain_length; i++) {
2259 mov(dst, Operand(dst, Context::SlotOffset(Context::PREVIOUS_INDEX)));
2262 // Slot is in the current function context. Move it into the
2263 // destination register in case we store into it (the write barrier
2264 // cannot be allowed to destroy the context in esi).
2268 // We should not have found a with context by walking the context chain
2269 // (i.e., the static scope chain and runtime context chain do not agree).
2270 // A variable occurring in such a scope should have slot type LOOKUP and
2272 if (emit_debug_code()) {
2273 cmp(FieldOperand(dst, HeapObject::kMapOffset),
2274 isolate()->factory()->with_context_map());
2275 Check(not_equal, "Variable resolved to with context.");
2280 void MacroAssembler::LoadTransitionedArrayMapConditional(
2281 ElementsKind expected_kind,
2282 ElementsKind transitioned_kind,
2283 Register map_in_out,
2285 Label* no_map_match) {
2286 // Load the global or builtins object from the current context.
2287 mov(scratch, Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
2288 mov(scratch, FieldOperand(scratch, GlobalObject::kNativeContextOffset));
2290 // Check that the function's map is the same as the expected cached map.
2291 mov(scratch, Operand(scratch,
2292 Context::SlotOffset(Context::JS_ARRAY_MAPS_INDEX)));
2294 size_t offset = expected_kind * kPointerSize +
2295 FixedArrayBase::kHeaderSize;
2296 cmp(map_in_out, FieldOperand(scratch, offset));
2297 j(not_equal, no_map_match);
2299 // Use the transitioned cached map.
2300 offset = transitioned_kind * kPointerSize +
2301 FixedArrayBase::kHeaderSize;
2302 mov(map_in_out, FieldOperand(scratch, offset));
2306 void MacroAssembler::LoadInitialArrayMap(
2307 Register function_in, Register scratch,
2308 Register map_out, bool can_have_holes) {
2309 ASSERT(!function_in.is(map_out));
2311 mov(map_out, FieldOperand(function_in,
2312 JSFunction::kPrototypeOrInitialMapOffset));
2313 if (!FLAG_smi_only_arrays) {
2314 ElementsKind kind = can_have_holes ? FAST_HOLEY_ELEMENTS : FAST_ELEMENTS;
2315 LoadTransitionedArrayMapConditional(FAST_SMI_ELEMENTS,
2320 } else if (can_have_holes) {
2321 LoadTransitionedArrayMapConditional(FAST_SMI_ELEMENTS,
2322 FAST_HOLEY_SMI_ELEMENTS,
2331 void MacroAssembler::LoadGlobalFunction(int index, Register function) {
2332 // Load the global or builtins object from the current context.
2334 Operand(esi, Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX)));
2335 // Load the native context from the global or builtins object.
2336 mov(function, FieldOperand(function, GlobalObject::kNativeContextOffset));
2337 // Load the function from the native context.
2338 mov(function, Operand(function, Context::SlotOffset(index)));
2342 void MacroAssembler::LoadGlobalFunctionInitialMap(Register function,
2344 // Load the initial map. The global functions all have initial maps.
2345 mov(map, FieldOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
2346 if (emit_debug_code()) {
2348 CheckMap(map, isolate()->factory()->meta_map(), &fail, DO_SMI_CHECK);
2351 Abort("Global functions must have initial map");
2357 // Store the value in register src in the safepoint register stack
2358 // slot for register dst.
2359 void MacroAssembler::StoreToSafepointRegisterSlot(Register dst, Register src) {
2360 mov(SafepointRegisterSlot(dst), src);
2364 void MacroAssembler::StoreToSafepointRegisterSlot(Register dst, Immediate src) {
2365 mov(SafepointRegisterSlot(dst), src);
2369 void MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) {
2370 mov(dst, SafepointRegisterSlot(src));
2374 Operand MacroAssembler::SafepointRegisterSlot(Register reg) {
2375 return Operand(esp, SafepointRegisterStackIndex(reg.code()) * kPointerSize);
2379 int MacroAssembler::SafepointRegisterStackIndex(int reg_code) {
2380 // The registers are pushed starting with the lowest encoding,
2381 // which means that lowest encodings are furthest away from
2382 // the stack pointer.
2383 ASSERT(reg_code >= 0 && reg_code < kNumSafepointRegisters);
2384 return kNumSafepointRegisters - reg_code - 1;
2388 void MacroAssembler::LoadHeapObject(Register result,
2389 Handle<HeapObject> object) {
2390 if (isolate()->heap()->InNewSpace(*object)) {
2391 Handle<JSGlobalPropertyCell> cell =
2392 isolate()->factory()->NewJSGlobalPropertyCell(object);
2393 mov(result, Operand::Cell(cell));
2395 mov(result, object);
2400 void MacroAssembler::PushHeapObject(Handle<HeapObject> object) {
2401 if (isolate()->heap()->InNewSpace(*object)) {
2402 Handle<JSGlobalPropertyCell> cell =
2403 isolate()->factory()->NewJSGlobalPropertyCell(object);
2404 push(Operand::Cell(cell));
2411 void MacroAssembler::Ret() {
2416 void MacroAssembler::Ret(int bytes_dropped, Register scratch) {
2417 if (is_uint16(bytes_dropped)) {
2421 add(esp, Immediate(bytes_dropped));
2428 void MacroAssembler::Drop(int stack_elements) {
2429 if (stack_elements > 0) {
2430 add(esp, Immediate(stack_elements * kPointerSize));
2435 void MacroAssembler::Move(Register dst, Register src) {
2442 void MacroAssembler::SetCounter(StatsCounter* counter, int value) {
2443 if (FLAG_native_code_counters && counter->Enabled()) {
2444 mov(Operand::StaticVariable(ExternalReference(counter)), Immediate(value));
2449 void MacroAssembler::IncrementCounter(StatsCounter* counter, int value) {
2451 if (FLAG_native_code_counters && counter->Enabled()) {
2452 Operand operand = Operand::StaticVariable(ExternalReference(counter));
2456 add(operand, Immediate(value));
2462 void MacroAssembler::DecrementCounter(StatsCounter* counter, int value) {
2464 if (FLAG_native_code_counters && counter->Enabled()) {
2465 Operand operand = Operand::StaticVariable(ExternalReference(counter));
2469 sub(operand, Immediate(value));
2475 void MacroAssembler::IncrementCounter(Condition cc,
2476 StatsCounter* counter,
2479 if (FLAG_native_code_counters && counter->Enabled()) {
2481 j(NegateCondition(cc), &skip);
2483 IncrementCounter(counter, value);
2490 void MacroAssembler::DecrementCounter(Condition cc,
2491 StatsCounter* counter,
2494 if (FLAG_native_code_counters && counter->Enabled()) {
2496 j(NegateCondition(cc), &skip);
2498 DecrementCounter(counter, value);
2505 void MacroAssembler::Assert(Condition cc, const char* msg) {
2506 if (emit_debug_code()) Check(cc, msg);
2510 void MacroAssembler::AssertFastElements(Register elements) {
2511 if (emit_debug_code()) {
2512 Factory* factory = isolate()->factory();
2514 cmp(FieldOperand(elements, HeapObject::kMapOffset),
2515 Immediate(factory->fixed_array_map()));
2517 cmp(FieldOperand(elements, HeapObject::kMapOffset),
2518 Immediate(factory->fixed_double_array_map()));
2520 cmp(FieldOperand(elements, HeapObject::kMapOffset),
2521 Immediate(factory->fixed_cow_array_map()));
2523 Abort("JSObject with fast elements map has slow elements");
2529 void MacroAssembler::Check(Condition cc, const char* msg) {
2533 // will not return here
2538 void MacroAssembler::CheckStackAlignment() {
2539 int frame_alignment = OS::ActivationFrameAlignment();
2540 int frame_alignment_mask = frame_alignment - 1;
2541 if (frame_alignment > kPointerSize) {
2542 ASSERT(IsPowerOf2(frame_alignment));
2543 Label alignment_as_expected;
2544 test(esp, Immediate(frame_alignment_mask));
2545 j(zero, &alignment_as_expected);
2546 // Abort if stack is not aligned.
2548 bind(&alignment_as_expected);
2553 void MacroAssembler::Abort(const char* msg) {
2554 // We want to pass the msg string like a smi to avoid GC
2555 // problems, however msg is not guaranteed to be aligned
2556 // properly. Instead, we pass an aligned pointer that is
2557 // a proper v8 smi, but also pass the alignment difference
2558 // from the real pointer as a smi.
2559 intptr_t p1 = reinterpret_cast<intptr_t>(msg);
2560 intptr_t p0 = (p1 & ~kSmiTagMask) + kSmiTag;
2561 ASSERT(reinterpret_cast<Object*>(p0)->IsSmi());
2564 RecordComment("Abort message: ");
2570 push(Immediate(p0));
2571 push(Immediate(reinterpret_cast<intptr_t>(Smi::FromInt(p1 - p0))));
2572 // Disable stub call restrictions to always allow calls to abort.
2574 // We don't actually want to generate a pile of code for this, so just
2575 // claim there is a stack frame, without generating one.
2576 FrameScope scope(this, StackFrame::NONE);
2577 CallRuntime(Runtime::kAbort, 2);
2579 CallRuntime(Runtime::kAbort, 2);
2581 // will not return here
2586 void MacroAssembler::LoadInstanceDescriptors(Register map,
2587 Register descriptors) {
2588 mov(descriptors, FieldOperand(map, Map::kDescriptorsOffset));
2592 void MacroAssembler::NumberOfOwnDescriptors(Register dst, Register map) {
2593 mov(dst, FieldOperand(map, Map::kBitField3Offset));
2594 DecodeField<Map::NumberOfOwnDescriptorsBits>(dst);
2598 void MacroAssembler::LoadPowerOf2(XMMRegister dst,
2601 ASSERT(is_uintn(power + HeapNumber::kExponentBias,
2602 HeapNumber::kExponentBits));
2603 mov(scratch, Immediate(power + HeapNumber::kExponentBias));
2605 psllq(dst, HeapNumber::kMantissaBits);
2609 void MacroAssembler::JumpIfInstanceTypeIsNotSequentialAscii(
2610 Register instance_type,
2613 if (!scratch.is(instance_type)) {
2614 mov(scratch, instance_type);
2617 kIsNotStringMask | kStringRepresentationMask | kStringEncodingMask);
2618 cmp(scratch, kStringTag | kSeqStringTag | kAsciiStringTag);
2619 j(not_equal, failure);
2623 void MacroAssembler::JumpIfNotBothSequentialAsciiStrings(Register object1,
2628 // Check that both objects are not smis.
2629 STATIC_ASSERT(kSmiTag == 0);
2630 mov(scratch1, object1);
2631 and_(scratch1, object2);
2632 JumpIfSmi(scratch1, failure);
2634 // Load instance type for both strings.
2635 mov(scratch1, FieldOperand(object1, HeapObject::kMapOffset));
2636 mov(scratch2, FieldOperand(object2, HeapObject::kMapOffset));
2637 movzx_b(scratch1, FieldOperand(scratch1, Map::kInstanceTypeOffset));
2638 movzx_b(scratch2, FieldOperand(scratch2, Map::kInstanceTypeOffset));
2640 // Check that both are flat ASCII strings.
2641 const int kFlatAsciiStringMask =
2642 kIsNotStringMask | kStringRepresentationMask | kStringEncodingMask;
2643 const int kFlatAsciiStringTag = ASCII_STRING_TYPE;
2644 // Interleave bits from both instance types and compare them in one check.
2645 ASSERT_EQ(0, kFlatAsciiStringMask & (kFlatAsciiStringMask << 3));
2646 and_(scratch1, kFlatAsciiStringMask);
2647 and_(scratch2, kFlatAsciiStringMask);
2648 lea(scratch1, Operand(scratch1, scratch2, times_8, 0));
2649 cmp(scratch1, kFlatAsciiStringTag | (kFlatAsciiStringTag << 3));
2650 j(not_equal, failure);
2654 void MacroAssembler::PrepareCallCFunction(int num_arguments, Register scratch) {
2655 int frame_alignment = OS::ActivationFrameAlignment();
2656 if (frame_alignment != 0) {
2657 // Make stack end at alignment and make room for num_arguments words
2658 // and the original value of esp.
2660 sub(esp, Immediate((num_arguments + 1) * kPointerSize));
2661 ASSERT(IsPowerOf2(frame_alignment));
2662 and_(esp, -frame_alignment);
2663 mov(Operand(esp, num_arguments * kPointerSize), scratch);
2665 sub(esp, Immediate(num_arguments * kPointerSize));
2670 void MacroAssembler::CallCFunction(ExternalReference function,
2671 int num_arguments) {
2672 // Trashing eax is ok as it will be the return value.
2673 mov(eax, Immediate(function));
2674 CallCFunction(eax, num_arguments);
2678 void MacroAssembler::CallCFunction(Register function,
2679 int num_arguments) {
2680 ASSERT(has_frame());
2681 // Check stack alignment.
2682 if (emit_debug_code()) {
2683 CheckStackAlignment();
2687 if (OS::ActivationFrameAlignment() != 0) {
2688 mov(esp, Operand(esp, num_arguments * kPointerSize));
2690 add(esp, Immediate(num_arguments * kPointerSize));
2695 bool AreAliased(Register r1, Register r2, Register r3, Register r4) {
2696 if (r1.is(r2)) return true;
2697 if (r1.is(r3)) return true;
2698 if (r1.is(r4)) return true;
2699 if (r2.is(r3)) return true;
2700 if (r2.is(r4)) return true;
2701 if (r3.is(r4)) return true;
2706 CodePatcher::CodePatcher(byte* address, int size)
2707 : address_(address),
2709 masm_(NULL, address, size + Assembler::kGap) {
2710 // Create a new macro assembler pointing to the address of the code to patch.
2711 // The size is adjusted with kGap on order for the assembler to generate size
2712 // bytes of instructions without failing with buffer size constraints.
2713 ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
2717 CodePatcher::~CodePatcher() {
2718 // Indicate that code has changed.
2719 CPU::FlushICache(address_, size_);
2721 // Check that the code was patched as expected.
2722 ASSERT(masm_.pc_ == address_ + size_);
2723 ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
2727 void MacroAssembler::CheckPageFlag(
2732 Label* condition_met,
2733 Label::Distance condition_met_distance) {
2734 ASSERT(cc == zero || cc == not_zero);
2735 if (scratch.is(object)) {
2736 and_(scratch, Immediate(~Page::kPageAlignmentMask));
2738 mov(scratch, Immediate(~Page::kPageAlignmentMask));
2739 and_(scratch, object);
2741 if (mask < (1 << kBitsPerByte)) {
2742 test_b(Operand(scratch, MemoryChunk::kFlagsOffset),
2743 static_cast<uint8_t>(mask));
2745 test(Operand(scratch, MemoryChunk::kFlagsOffset), Immediate(mask));
2747 j(cc, condition_met, condition_met_distance);
2751 void MacroAssembler::CheckPageFlagForMap(
2755 Label* condition_met,
2756 Label::Distance condition_met_distance) {
2757 ASSERT(cc == zero || cc == not_zero);
2758 Page* page = Page::FromAddress(map->address());
2759 ExternalReference reference(ExternalReference::page_flags(page));
2760 // The inlined static address check of the page's flags relies
2761 // on maps never being compacted.
2762 ASSERT(!isolate()->heap()->mark_compact_collector()->
2763 IsOnEvacuationCandidate(*map));
2764 if (mask < (1 << kBitsPerByte)) {
2765 test_b(Operand::StaticVariable(reference), static_cast<uint8_t>(mask));
2767 test(Operand::StaticVariable(reference), Immediate(mask));
2769 j(cc, condition_met, condition_met_distance);
2773 void MacroAssembler::JumpIfBlack(Register object,
2777 Label::Distance on_black_near) {
2778 HasColor(object, scratch0, scratch1,
2779 on_black, on_black_near,
2780 1, 0); // kBlackBitPattern.
2781 ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
2785 void MacroAssembler::HasColor(Register object,
2786 Register bitmap_scratch,
2787 Register mask_scratch,
2789 Label::Distance has_color_distance,
2792 ASSERT(!AreAliased(object, bitmap_scratch, mask_scratch, ecx));
2794 GetMarkBits(object, bitmap_scratch, mask_scratch);
2796 Label other_color, word_boundary;
2797 test(mask_scratch, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
2798 j(first_bit == 1 ? zero : not_zero, &other_color, Label::kNear);
2799 add(mask_scratch, mask_scratch); // Shift left 1 by adding.
2800 j(zero, &word_boundary, Label::kNear);
2801 test(mask_scratch, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
2802 j(second_bit == 1 ? not_zero : zero, has_color, has_color_distance);
2803 jmp(&other_color, Label::kNear);
2805 bind(&word_boundary);
2806 test_b(Operand(bitmap_scratch, MemoryChunk::kHeaderSize + kPointerSize), 1);
2808 j(second_bit == 1 ? not_zero : zero, has_color, has_color_distance);
2813 void MacroAssembler::GetMarkBits(Register addr_reg,
2814 Register bitmap_reg,
2815 Register mask_reg) {
2816 ASSERT(!AreAliased(addr_reg, mask_reg, bitmap_reg, ecx));
2817 mov(bitmap_reg, Immediate(~Page::kPageAlignmentMask));
2818 and_(bitmap_reg, addr_reg);
2821 Bitmap::kBitsPerCellLog2 + kPointerSizeLog2 - Bitmap::kBytesPerCellLog2;
2824 (Page::kPageAlignmentMask >> shift) & ~(Bitmap::kBytesPerCell - 1));
2826 add(bitmap_reg, ecx);
2828 shr(ecx, kPointerSizeLog2);
2829 and_(ecx, (1 << Bitmap::kBitsPerCellLog2) - 1);
2830 mov(mask_reg, Immediate(1));
2835 void MacroAssembler::EnsureNotWhite(
2837 Register bitmap_scratch,
2838 Register mask_scratch,
2839 Label* value_is_white_and_not_data,
2840 Label::Distance distance) {
2841 ASSERT(!AreAliased(value, bitmap_scratch, mask_scratch, ecx));
2842 GetMarkBits(value, bitmap_scratch, mask_scratch);
2844 // If the value is black or grey we don't need to do anything.
2845 ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
2846 ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
2847 ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
2848 ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
2852 // Since both black and grey have a 1 in the first position and white does
2853 // not have a 1 there we only need to check one bit.
2854 test(mask_scratch, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
2855 j(not_zero, &done, Label::kNear);
2857 if (emit_debug_code()) {
2858 // Check for impossible bit pattern.
2861 // shl. May overflow making the check conservative.
2862 add(mask_scratch, mask_scratch);
2863 test(mask_scratch, Operand(bitmap_scratch, MemoryChunk::kHeaderSize));
2864 j(zero, &ok, Label::kNear);
2870 // Value is white. We check whether it is data that doesn't need scanning.
2871 // Currently only checks for HeapNumber and non-cons strings.
2872 Register map = ecx; // Holds map while checking type.
2873 Register length = ecx; // Holds length of object after checking type.
2874 Label not_heap_number;
2875 Label is_data_object;
2877 // Check for heap-number
2878 mov(map, FieldOperand(value, HeapObject::kMapOffset));
2879 cmp(map, FACTORY->heap_number_map());
2880 j(not_equal, ¬_heap_number, Label::kNear);
2881 mov(length, Immediate(HeapNumber::kSize));
2882 jmp(&is_data_object, Label::kNear);
2884 bind(¬_heap_number);
2885 // Check for strings.
2886 ASSERT(kIsIndirectStringTag == 1 && kIsIndirectStringMask == 1);
2887 ASSERT(kNotStringTag == 0x80 && kIsNotStringMask == 0x80);
2888 // If it's a string and it's not a cons string then it's an object containing
2890 Register instance_type = ecx;
2891 movzx_b(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
2892 test_b(instance_type, kIsIndirectStringMask | kIsNotStringMask);
2893 j(not_zero, value_is_white_and_not_data);
2894 // It's a non-indirect (non-cons and non-slice) string.
2895 // If it's external, the length is just ExternalString::kSize.
2896 // Otherwise it's String::kHeaderSize + string->length() * (1 or 2).
2898 // External strings are the only ones with the kExternalStringTag bit
2900 ASSERT_EQ(0, kSeqStringTag & kExternalStringTag);
2901 ASSERT_EQ(0, kConsStringTag & kExternalStringTag);
2902 test_b(instance_type, kExternalStringTag);
2903 j(zero, ¬_external, Label::kNear);
2904 mov(length, Immediate(ExternalString::kSize));
2905 jmp(&is_data_object, Label::kNear);
2907 bind(¬_external);
2908 // Sequential string, either ASCII or UC16.
2909 ASSERT(kAsciiStringTag == 0x04);
2910 and_(length, Immediate(kStringEncodingMask));
2911 xor_(length, Immediate(kStringEncodingMask));
2912 add(length, Immediate(0x04));
2913 // Value now either 4 (if ASCII) or 8 (if UC16), i.e., char-size shifted
2914 // by 2. If we multiply the string length as smi by this, it still
2915 // won't overflow a 32-bit value.
2916 ASSERT_EQ(SeqAsciiString::kMaxSize, SeqTwoByteString::kMaxSize);
2917 ASSERT(SeqAsciiString::kMaxSize <=
2918 static_cast<int>(0xffffffffu >> (2 + kSmiTagSize)));
2919 imul(length, FieldOperand(value, String::kLengthOffset));
2920 shr(length, 2 + kSmiTagSize + kSmiShiftSize);
2921 add(length, Immediate(SeqString::kHeaderSize + kObjectAlignmentMask));
2922 and_(length, Immediate(~kObjectAlignmentMask));
2924 bind(&is_data_object);
2925 // Value is a data object, and it is white. Mark it black. Since we know
2926 // that the object is white we can make it black by flipping one bit.
2927 or_(Operand(bitmap_scratch, MemoryChunk::kHeaderSize), mask_scratch);
2929 and_(bitmap_scratch, Immediate(~Page::kPageAlignmentMask));
2930 add(Operand(bitmap_scratch, MemoryChunk::kLiveBytesOffset),
2932 if (emit_debug_code()) {
2933 mov(length, Operand(bitmap_scratch, MemoryChunk::kLiveBytesOffset));
2934 cmp(length, Operand(bitmap_scratch, MemoryChunk::kSizeOffset));
2935 Check(less_equal, "Live Bytes Count overflow chunk size");
2942 void MacroAssembler::EnumLength(Register dst, Register map) {
2943 STATIC_ASSERT(Map::EnumLengthBits::kShift == 0);
2944 mov(dst, FieldOperand(map, Map::kBitField3Offset));
2945 and_(dst, Immediate(Smi::FromInt(Map::EnumLengthBits::kMask)));
2949 void MacroAssembler::CheckEnumCache(Label* call_runtime) {
2953 // Check if the enum length field is properly initialized, indicating that
2954 // there is an enum cache.
2955 mov(ebx, FieldOperand(ecx, HeapObject::kMapOffset));
2957 EnumLength(edx, ebx);
2958 cmp(edx, Immediate(Smi::FromInt(Map::kInvalidEnumCache)));
2959 j(equal, call_runtime);
2964 mov(ebx, FieldOperand(ecx, HeapObject::kMapOffset));
2966 // For all objects but the receiver, check that the cache is empty.
2967 EnumLength(edx, ebx);
2968 cmp(edx, Immediate(Smi::FromInt(0)));
2969 j(not_equal, call_runtime);
2973 // Check that there are no elements. Register rcx contains the current JS
2974 // object we've reached through the prototype chain.
2975 mov(ecx, FieldOperand(ecx, JSObject::kElementsOffset));
2976 cmp(ecx, isolate()->factory()->empty_fixed_array());
2977 j(not_equal, call_runtime);
2979 mov(ecx, FieldOperand(ebx, Map::kPrototypeOffset));
2980 cmp(ecx, isolate()->factory()->null_value());
2981 j(not_equal, &next);
2984 } } // namespace v8::internal
2986 #endif // V8_TARGET_ARCH_IA32