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.
28 #ifndef V8_X64_MACRO_ASSEMBLER_X64_H_
29 #define V8_X64_MACRO_ASSEMBLER_X64_H_
31 #include "assembler.h"
33 #include "v8globals.h"
38 // Flags used for the AllocateInNewSpace functions.
39 enum AllocationFlags {
41 NO_ALLOCATION_FLAGS = 0,
42 // Return the pointer to the allocated already tagged as a heap object.
44 // The content of the result register already contains the allocation top in
46 RESULT_CONTAINS_TOP = 1 << 1
50 // Default scratch register used by MacroAssembler (and other code that needs
51 // a spare register). The register isn't callee save, and not used by the
52 // function calling convention.
53 const Register kScratchRegister = { 10 }; // r10.
54 const Register kSmiConstantRegister = { 12 }; // r12 (callee save).
55 const Register kRootRegister = { 13 }; // r13 (callee save).
56 // Value of smi in kSmiConstantRegister.
57 const int kSmiConstantRegisterValue = 1;
58 // Actual value of root register is offset from the root array's start
59 // to take advantage of negitive 8-bit displacement values.
60 const int kRootRegisterBias = 128;
62 // Convenience for platform-independent signatures.
63 typedef Operand MemOperand;
65 enum RememberedSetAction { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET };
66 enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK };
68 bool AreAliased(Register r1, Register r2, Register r3, Register r4);
70 // Forward declaration.
74 SmiIndex(Register index_register, ScaleFactor scale)
75 : reg(index_register),
82 // MacroAssembler implements a collection of frequently used macros.
83 class MacroAssembler: public Assembler {
85 // The isolate parameter can be NULL if the macro assembler should
86 // not use isolate-dependent functionality. In this case, it's the
87 // responsibility of the caller to never invoke such function on the
89 MacroAssembler(Isolate* isolate, void* buffer, int size);
91 // Prevent the use of the RootArray during the lifetime of this
93 class NoRootArrayScope BASE_EMBEDDED {
95 explicit NoRootArrayScope(MacroAssembler* assembler)
96 : variable_(&assembler->root_array_available_),
97 old_value_(assembler->root_array_available_) {
98 assembler->root_array_available_ = false;
100 ~NoRootArrayScope() {
101 *variable_ = old_value_;
108 // Operand pointing to an external reference.
109 // May emit code to set up the scratch register. The operand is
110 // only guaranteed to be correct as long as the scratch register
112 // If the operand is used more than once, use a scratch register
113 // that is guaranteed not to be clobbered.
114 Operand ExternalOperand(ExternalReference reference,
115 Register scratch = kScratchRegister);
116 // Loads and stores the value of an external reference.
117 // Special case code for load and store to take advantage of
118 // load_rax/store_rax if possible/necessary.
119 // For other operations, just use:
120 // Operand operand = ExternalOperand(extref);
121 // operation(operand, ..);
122 void Load(Register destination, ExternalReference source);
123 void Store(ExternalReference destination, Register source);
124 // Loads the address of the external reference into the destination
126 void LoadAddress(Register destination, ExternalReference source);
127 // Returns the size of the code generated by LoadAddress.
128 // Used by CallSize(ExternalReference) to find the size of a call.
129 int LoadAddressSize(ExternalReference source);
130 // Pushes the address of the external reference onto the stack.
131 void PushAddress(ExternalReference source);
133 // Operations on roots in the root-array.
134 void LoadRoot(Register destination, Heap::RootListIndex index);
135 void StoreRoot(Register source, Heap::RootListIndex index);
136 // Load a root value where the index (or part of it) is variable.
137 // The variable_offset register is added to the fixed_offset value
138 // to get the index into the root-array.
139 void LoadRootIndexed(Register destination,
140 Register variable_offset,
142 void CompareRoot(Register with, Heap::RootListIndex index);
143 void CompareRoot(const Operand& with, Heap::RootListIndex index);
144 void PushRoot(Heap::RootListIndex index);
146 // These functions do not arrange the registers in any particular order so
147 // they are not useful for calls that can cause a GC. The caller can
148 // exclude up to 3 registers that do not need to be saved and restored.
149 void PushCallerSaved(SaveFPRegsMode fp_mode,
150 Register exclusion1 = no_reg,
151 Register exclusion2 = no_reg,
152 Register exclusion3 = no_reg);
153 void PopCallerSaved(SaveFPRegsMode fp_mode,
154 Register exclusion1 = no_reg,
155 Register exclusion2 = no_reg,
156 Register exclusion3 = no_reg);
158 // ---------------------------------------------------------------------------
162 enum RememberedSetFinalAction {
167 // Record in the remembered set the fact that we have a pointer to new space
168 // at the address pointed to by the addr register. Only works if addr is not
170 void RememberedSetHelper(Register object, // Used for debug code.
173 SaveFPRegsMode save_fp,
174 RememberedSetFinalAction and_then);
176 void CheckPageFlag(Register object,
180 Label* condition_met,
181 Label::Distance condition_met_distance = Label::kFar);
183 // Check if object is in new space. Jumps if the object is not in new space.
184 // The register scratch can be object itself, but scratch will be clobbered.
185 void JumpIfNotInNewSpace(Register object,
188 Label::Distance distance = Label::kFar) {
189 InNewSpace(object, scratch, not_equal, branch, distance);
192 // Check if object is in new space. Jumps if the object is in new space.
193 // The register scratch can be object itself, but it will be clobbered.
194 void JumpIfInNewSpace(Register object,
197 Label::Distance distance = Label::kFar) {
198 InNewSpace(object, scratch, equal, branch, distance);
201 // Check if an object has the black incremental marking color. Also uses rcx!
202 void JumpIfBlack(Register object,
206 Label::Distance on_black_distance = Label::kFar);
208 // Detects conservatively whether an object is data-only, i.e. it does need to
209 // be scanned by the garbage collector.
210 void JumpIfDataObject(Register value,
212 Label* not_data_object,
213 Label::Distance not_data_object_distance);
215 // Checks the color of an object. If the object is already grey or black
216 // then we just fall through, since it is already live. If it is white and
217 // we can determine that it doesn't need to be scanned, then we just mark it
218 // black and fall through. For the rest we jump to the label so the
219 // incremental marker can fix its assumptions.
220 void EnsureNotWhite(Register object,
223 Label* object_is_white_and_not_data,
224 Label::Distance distance);
226 // Notify the garbage collector that we wrote a pointer into an object.
227 // |object| is the object being stored into, |value| is the object being
228 // stored. value and scratch registers are clobbered by the operation.
229 // The offset is the offset from the start of the object, not the offset from
230 // the tagged HeapObject pointer. For use with FieldOperand(reg, off).
231 void RecordWriteField(
236 SaveFPRegsMode save_fp,
237 RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
238 SmiCheck smi_check = INLINE_SMI_CHECK);
240 // As above, but the offset has the tag presubtracted. For use with
241 // Operand(reg, off).
242 void RecordWriteContextSlot(
247 SaveFPRegsMode save_fp,
248 RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
249 SmiCheck smi_check = INLINE_SMI_CHECK) {
250 RecordWriteField(context,
251 offset + kHeapObjectTag,
255 remembered_set_action,
259 // Notify the garbage collector that we wrote a pointer into a fixed array.
260 // |array| is the array being stored into, |value| is the
261 // object being stored. |index| is the array index represented as a non-smi.
262 // All registers are clobbered by the operation RecordWriteArray
263 // filters out smis so it does not update the write barrier if the
265 void RecordWriteArray(
269 SaveFPRegsMode save_fp,
270 RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
271 SmiCheck smi_check = INLINE_SMI_CHECK);
273 // For page containing |object| mark region covering |address|
274 // dirty. |object| is the object being stored into, |value| is the
275 // object being stored. The address and value registers are clobbered by the
276 // operation. RecordWrite filters out smis so it does not update
277 // the write barrier if the value is a smi.
282 SaveFPRegsMode save_fp,
283 RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
284 SmiCheck smi_check = INLINE_SMI_CHECK);
286 #ifdef ENABLE_DEBUGGER_SUPPORT
287 // ---------------------------------------------------------------------------
293 // Enter specific kind of exit frame; either in normal or
294 // debug mode. Expects the number of arguments in register rax and
295 // sets up the number of arguments in register rdi and the pointer
296 // to the first argument in register rsi.
298 // Allocates arg_stack_space * kPointerSize memory (not GCed) on the stack
299 // accessible via StackSpaceOperand.
300 void EnterExitFrame(int arg_stack_space = 0, bool save_doubles = false);
302 // Enter specific kind of exit frame. Allocates arg_stack_space * kPointerSize
303 // memory (not GCed) on the stack accessible via StackSpaceOperand.
304 void EnterApiExitFrame(int arg_stack_space);
306 // Leave the current exit frame. Expects/provides the return value in
307 // register rax:rdx (untouched) and the pointer to the first
308 // argument in register rsi.
309 void LeaveExitFrame(bool save_doubles = false);
311 // Leave the current exit frame. Expects/provides the return value in
312 // register rax (untouched).
313 void LeaveApiExitFrame();
315 // Push and pop the registers that can hold pointers.
316 void PushSafepointRegisters() { Pushad(); }
317 void PopSafepointRegisters() { Popad(); }
318 // Store the value in register src in the safepoint register stack
319 // slot for register dst.
320 void StoreToSafepointRegisterSlot(Register dst, Register src);
321 void LoadFromSafepointRegisterSlot(Register dst, Register src);
323 void InitializeRootRegister() {
324 ExternalReference roots_array_start =
325 ExternalReference::roots_array_start(isolate());
326 movq(kRootRegister, roots_array_start);
327 addq(kRootRegister, Immediate(kRootRegisterBias));
330 // ---------------------------------------------------------------------------
331 // JavaScript invokes
333 // Set up call kind marking in rcx. The method takes rcx as an
334 // explicit first parameter to make the code more readable at the
336 void SetCallKind(Register dst, CallKind kind);
338 // Invoke the JavaScript function code by either calling or jumping.
339 void InvokeCode(Register code,
340 const ParameterCount& expected,
341 const ParameterCount& actual,
343 const CallWrapper& call_wrapper,
346 void InvokeCode(Handle<Code> code,
347 const ParameterCount& expected,
348 const ParameterCount& actual,
349 RelocInfo::Mode rmode,
351 const CallWrapper& call_wrapper,
354 // Invoke the JavaScript function in the given register. Changes the
355 // current context to the context in the function before invoking.
356 void InvokeFunction(Register function,
357 const ParameterCount& actual,
359 const CallWrapper& call_wrapper,
362 void InvokeFunction(Handle<JSFunction> function,
363 const ParameterCount& actual,
365 const CallWrapper& call_wrapper,
368 // Invoke specified builtin JavaScript function. Adds an entry to
369 // the unresolved list if the name does not resolve.
370 void InvokeBuiltin(Builtins::JavaScript id,
372 const CallWrapper& call_wrapper = NullCallWrapper());
374 // Store the function for the given builtin in the target register.
375 void GetBuiltinFunction(Register target, Builtins::JavaScript id);
377 // Store the code object for the given builtin in the target register.
378 void GetBuiltinEntry(Register target, Builtins::JavaScript id);
381 // ---------------------------------------------------------------------------
382 // Smi tagging, untagging and operations on tagged smis.
384 void InitializeSmiConstantRegister() {
385 movq(kSmiConstantRegister,
386 reinterpret_cast<uint64_t>(Smi::FromInt(kSmiConstantRegisterValue)),
390 // Conversions between tagged smi values and non-tagged integer values.
392 // Tag an integer value. The result must be known to be a valid smi value.
393 // Only uses the low 32 bits of the src register. Sets the N and Z flags
394 // based on the value of the resulting smi.
395 void Integer32ToSmi(Register dst, Register src);
397 // Stores an integer32 value into a memory field that already holds a smi.
398 void Integer32ToSmiField(const Operand& dst, Register src);
400 // Adds constant to src and tags the result as a smi.
401 // Result must be a valid smi.
402 void Integer64PlusConstantToSmi(Register dst, Register src, int constant);
404 // Convert smi to 32-bit integer. I.e., not sign extended into
405 // high 32 bits of destination.
406 void SmiToInteger32(Register dst, Register src);
407 void SmiToInteger32(Register dst, const Operand& src);
409 // Convert smi to 64-bit integer (sign extended if necessary).
410 void SmiToInteger64(Register dst, Register src);
411 void SmiToInteger64(Register dst, const Operand& src);
413 // Multiply a positive smi's integer value by a power of two.
414 // Provides result as 64-bit integer value.
415 void PositiveSmiTimesPowerOfTwoToInteger64(Register dst,
419 // Divide a positive smi's integer value by a power of two.
420 // Provides result as 32-bit integer value.
421 void PositiveSmiDivPowerOfTwoToInteger32(Register dst,
425 // Perform the logical or of two smi values and return a smi value.
426 // If either argument is not a smi, jump to on_not_smis and retain
427 // the original values of source registers. The destination register
428 // may be changed if it's not one of the source registers.
429 void SmiOrIfSmis(Register dst,
433 Label::Distance near_jump = Label::kFar);
436 // Simple comparison of smis. Both sides must be known smis to use these,
437 // otherwise use Cmp.
438 void SmiCompare(Register smi1, Register smi2);
439 void SmiCompare(Register dst, Smi* src);
440 void SmiCompare(Register dst, const Operand& src);
441 void SmiCompare(const Operand& dst, Register src);
442 void SmiCompare(const Operand& dst, Smi* src);
443 // Compare the int32 in src register to the value of the smi stored at dst.
444 void SmiCompareInteger32(const Operand& dst, Register src);
445 // Sets sign and zero flags depending on value of smi in register.
446 void SmiTest(Register src);
448 // Functions performing a check on a known or potential smi. Returns
449 // a condition that is satisfied if the check is successful.
451 // Is the value a tagged smi.
452 Condition CheckSmi(Register src);
453 Condition CheckSmi(const Operand& src);
455 // Is the value a non-negative tagged smi.
456 Condition CheckNonNegativeSmi(Register src);
458 // Are both values tagged smis.
459 Condition CheckBothSmi(Register first, Register second);
461 // Are both values non-negative tagged smis.
462 Condition CheckBothNonNegativeSmi(Register first, Register second);
464 // Are either value a tagged smi.
465 Condition CheckEitherSmi(Register first,
467 Register scratch = kScratchRegister);
469 // Is the value the minimum smi value (since we are using
470 // two's complement numbers, negating the value is known to yield
472 Condition CheckIsMinSmi(Register src);
474 // Checks whether an 32-bit integer value is a valid for conversion
476 Condition CheckInteger32ValidSmiValue(Register src);
478 // Checks whether an 32-bit unsigned integer value is a valid for
479 // conversion to a smi.
480 Condition CheckUInteger32ValidSmiValue(Register src);
482 // Check whether src is a Smi, and set dst to zero if it is a smi,
483 // and to one if it isn't.
484 void CheckSmiToIndicator(Register dst, Register src);
485 void CheckSmiToIndicator(Register dst, const Operand& src);
487 // Test-and-jump functions. Typically combines a check function
488 // above with a conditional jump.
490 // Jump if the value cannot be represented by a smi.
491 void JumpIfNotValidSmiValue(Register src, Label* on_invalid,
492 Label::Distance near_jump = Label::kFar);
494 // Jump if the unsigned integer value cannot be represented by a smi.
495 void JumpIfUIntNotValidSmiValue(Register src, Label* on_invalid,
496 Label::Distance near_jump = Label::kFar);
498 // Jump to label if the value is a tagged smi.
499 void JumpIfSmi(Register src,
501 Label::Distance near_jump = Label::kFar);
503 // Jump to label if the value is not a tagged smi.
504 void JumpIfNotSmi(Register src,
506 Label::Distance near_jump = Label::kFar);
508 // Jump to label if the value is not a non-negative tagged smi.
509 void JumpUnlessNonNegativeSmi(Register src,
511 Label::Distance near_jump = Label::kFar);
513 // Jump to label if the value, which must be a tagged smi, has value equal
515 void JumpIfSmiEqualsConstant(Register src,
518 Label::Distance near_jump = Label::kFar);
520 // Jump if either or both register are not smi values.
521 void JumpIfNotBothSmi(Register src1,
523 Label* on_not_both_smi,
524 Label::Distance near_jump = Label::kFar);
526 // Jump if either or both register are not non-negative smi values.
527 void JumpUnlessBothNonNegativeSmi(Register src1, Register src2,
528 Label* on_not_both_smi,
529 Label::Distance near_jump = Label::kFar);
531 // Operations on tagged smi values.
533 // Smis represent a subset of integers. The subset is always equivalent to
534 // a two's complement interpretation of a fixed number of bits.
536 // Optimistically adds an integer constant to a supposed smi.
537 // If the src is not a smi, or the result is not a smi, jump to
539 void SmiTryAddConstant(Register dst,
542 Label* on_not_smi_result,
543 Label::Distance near_jump = Label::kFar);
545 // Add an integer constant to a tagged smi, giving a tagged smi as result.
546 // No overflow testing on the result is done.
547 void SmiAddConstant(Register dst, Register src, Smi* constant);
549 // Add an integer constant to a tagged smi, giving a tagged smi as result.
550 // No overflow testing on the result is done.
551 void SmiAddConstant(const Operand& dst, Smi* constant);
553 // Add an integer constant to a tagged smi, giving a tagged smi as result,
554 // or jumping to a label if the result cannot be represented by a smi.
555 void SmiAddConstant(Register dst,
558 Label* on_not_smi_result,
559 Label::Distance near_jump = Label::kFar);
561 // Subtract an integer constant from a tagged smi, giving a tagged smi as
562 // result. No testing on the result is done. Sets the N and Z flags
563 // based on the value of the resulting integer.
564 void SmiSubConstant(Register dst, Register src, Smi* constant);
566 // Subtract an integer constant from a tagged smi, giving a tagged smi as
567 // result, or jumping to a label if the result cannot be represented by a smi.
568 void SmiSubConstant(Register dst,
571 Label* on_not_smi_result,
572 Label::Distance near_jump = Label::kFar);
574 // Negating a smi can give a negative zero or too large positive value.
575 // NOTICE: This operation jumps on success, not failure!
576 void SmiNeg(Register dst,
578 Label* on_smi_result,
579 Label::Distance near_jump = Label::kFar);
581 // Adds smi values and return the result as a smi.
582 // If dst is src1, then src1 will be destroyed, even if
583 // the operation is unsuccessful.
584 void SmiAdd(Register dst,
587 Label* on_not_smi_result,
588 Label::Distance near_jump = Label::kFar);
589 void SmiAdd(Register dst,
592 Label* on_not_smi_result,
593 Label::Distance near_jump = Label::kFar);
595 void SmiAdd(Register dst,
599 // Subtracts smi values and return the result as a smi.
600 // If dst is src1, then src1 will be destroyed, even if
601 // the operation is unsuccessful.
602 void SmiSub(Register dst,
605 Label* on_not_smi_result,
606 Label::Distance near_jump = Label::kFar);
608 void SmiSub(Register dst,
612 void SmiSub(Register dst,
615 Label* on_not_smi_result,
616 Label::Distance near_jump = Label::kFar);
618 void SmiSub(Register dst,
620 const Operand& src2);
622 // Multiplies smi values and return the result as a smi,
624 // If dst is src1, then src1 will be destroyed, even if
625 // the operation is unsuccessful.
626 void SmiMul(Register dst,
629 Label* on_not_smi_result,
630 Label::Distance near_jump = Label::kFar);
632 // Divides one smi by another and returns the quotient.
633 // Clobbers rax and rdx registers.
634 void SmiDiv(Register dst,
637 Label* on_not_smi_result,
638 Label::Distance near_jump = Label::kFar);
640 // Divides one smi by another and returns the remainder.
641 // Clobbers rax and rdx registers.
642 void SmiMod(Register dst,
645 Label* on_not_smi_result,
646 Label::Distance near_jump = Label::kFar);
648 // Bitwise operations.
649 void SmiNot(Register dst, Register src);
650 void SmiAnd(Register dst, Register src1, Register src2);
651 void SmiOr(Register dst, Register src1, Register src2);
652 void SmiXor(Register dst, Register src1, Register src2);
653 void SmiAndConstant(Register dst, Register src1, Smi* constant);
654 void SmiOrConstant(Register dst, Register src1, Smi* constant);
655 void SmiXorConstant(Register dst, Register src1, Smi* constant);
657 void SmiShiftLeftConstant(Register dst,
660 void SmiShiftLogicalRightConstant(Register dst,
663 Label* on_not_smi_result,
664 Label::Distance near_jump = Label::kFar);
665 void SmiShiftArithmeticRightConstant(Register dst,
669 // Shifts a smi value to the left, and returns the result if that is a smi.
670 // Uses and clobbers rcx, so dst may not be rcx.
671 void SmiShiftLeft(Register dst,
674 // Shifts a smi value to the right, shifting in zero bits at the top, and
675 // returns the unsigned intepretation of the result if that is a smi.
676 // Uses and clobbers rcx, so dst may not be rcx.
677 void SmiShiftLogicalRight(Register dst,
680 Label* on_not_smi_result,
681 Label::Distance near_jump = Label::kFar);
682 // Shifts a smi value to the right, sign extending the top, and
683 // returns the signed intepretation of the result. That will always
684 // be a valid smi value, since it's numerically smaller than the
686 // Uses and clobbers rcx, so dst may not be rcx.
687 void SmiShiftArithmeticRight(Register dst,
691 // Specialized operations
693 // Select the non-smi register of two registers where exactly one is a
694 // smi. If neither are smis, jump to the failure label.
695 void SelectNonSmi(Register dst,
699 Label::Distance near_jump = Label::kFar);
701 // Converts, if necessary, a smi to a combination of number and
702 // multiplier to be used as a scaled index.
703 // The src register contains a *positive* smi value. The shift is the
704 // power of two to multiply the index value by (e.g.
705 // to index by smi-value * kPointerSize, pass the smi and kPointerSizeLog2).
706 // The returned index register may be either src or dst, depending
707 // on what is most efficient. If src and dst are different registers,
708 // src is always unchanged.
709 SmiIndex SmiToIndex(Register dst, Register src, int shift);
711 // Converts a positive smi to a negative index.
712 SmiIndex SmiToNegativeIndex(Register dst, Register src, int shift);
714 // Add the value of a smi in memory to an int32 register.
715 // Sets flags as a normal add.
716 void AddSmiField(Register dst, const Operand& src);
718 // Basic Smi operations.
719 void Move(Register dst, Smi* source) {
720 LoadSmiConstant(dst, source);
723 void Move(const Operand& dst, Smi* source) {
724 Register constant = GetSmiConstant(source);
729 void Test(const Operand& dst, Smi* source);
732 // ---------------------------------------------------------------------------
735 // If object is a string, its map is loaded into object_map.
736 void JumpIfNotString(Register object,
739 Label::Distance near_jump = Label::kFar);
742 void JumpIfNotBothSequentialAsciiStrings(
743 Register first_object,
744 Register second_object,
747 Label* on_not_both_flat_ascii,
748 Label::Distance near_jump = Label::kFar);
750 // Check whether the instance type represents a flat ASCII string. Jump to the
751 // label if not. If the instance type can be scratched specify same register
752 // for both instance type and scratch.
753 void JumpIfInstanceTypeIsNotSequentialAscii(
754 Register instance_type,
756 Label*on_not_flat_ascii_string,
757 Label::Distance near_jump = Label::kFar);
759 void JumpIfBothInstanceTypesAreNotSequentialAscii(
760 Register first_object_instance_type,
761 Register second_object_instance_type,
765 Label::Distance near_jump = Label::kFar);
767 // ---------------------------------------------------------------------------
768 // Macro instructions.
770 // Load a register with a long value as efficiently as possible.
771 void Set(Register dst, int64_t x);
772 void Set(const Operand& dst, int64_t x);
774 // Move if the registers are not identical.
775 void Move(Register target, Register source);
777 // Bit-field support.
778 void TestBit(const Operand& dst, int bit_index);
781 void Move(Register dst, Handle<Object> source);
782 void Move(const Operand& dst, Handle<Object> source);
783 void Cmp(Register dst, Handle<Object> source);
784 void Cmp(const Operand& dst, Handle<Object> source);
785 void Cmp(Register dst, Smi* src);
786 void Cmp(const Operand& dst, Smi* src);
787 void Push(Handle<Object> source);
789 // Load a heap object and handle the case of new-space objects by
790 // indirecting via a global cell.
791 void LoadHeapObject(Register result, Handle<HeapObject> object);
792 void PushHeapObject(Handle<HeapObject> object);
794 void LoadObject(Register result, Handle<Object> object) {
795 if (object->IsHeapObject()) {
796 LoadHeapObject(result, Handle<HeapObject>::cast(object));
798 Move(result, object);
802 // Load a global cell into a register.
803 void LoadGlobalCell(Register dst, Handle<JSGlobalPropertyCell> cell);
805 // Emit code to discard a non-negative number of pointer-sized elements
806 // from the stack, clobbering only the rsp register.
807 void Drop(int stack_elements);
809 void Call(Label* target) { call(target); }
812 void Jump(Address destination, RelocInfo::Mode rmode);
813 void Jump(ExternalReference ext);
814 void Jump(Handle<Code> code_object, RelocInfo::Mode rmode);
816 void Call(Address destination, RelocInfo::Mode rmode);
817 void Call(ExternalReference ext);
818 void Call(Handle<Code> code_object,
819 RelocInfo::Mode rmode,
820 unsigned ast_id = kNoASTId);
822 // The size of the code generated for different call instructions.
823 int CallSize(Address destination, RelocInfo::Mode rmode) {
824 return kCallInstructionLength;
826 int CallSize(ExternalReference ext);
827 int CallSize(Handle<Code> code_object) {
828 // Code calls use 32-bit relative addressing.
829 return kShortCallInstructionLength;
831 int CallSize(Register target) {
832 // Opcode: REX_opt FF /2 m64
833 return (target.high_bit() != 0) ? 3 : 2;
835 int CallSize(const Operand& target) {
836 // Opcode: REX_opt FF /2 m64
837 return (target.requires_rex() ? 2 : 1) + target.operand_size();
840 // Emit call to the code we are currently generating.
842 Handle<Code> self(reinterpret_cast<Code**>(CodeObject().location()));
843 Call(self, RelocInfo::CODE_TARGET);
846 // Non-x64 instructions.
847 // Push/pop all general purpose registers.
848 // Does not push rsp/rbp nor any of the assembler's special purpose registers
849 // (kScratchRegister, kSmiConstantRegister, kRootRegister).
852 // Sets the stack as after performing Popad, without actually loading the
856 // Compare object type for heap object.
857 // Always use unsigned comparisons: above and below, not less and greater.
858 // Incoming register is heap_object and outgoing register is map.
859 // They may be the same register, and may be kScratchRegister.
860 void CmpObjectType(Register heap_object, InstanceType type, Register map);
862 // Compare instance type for map.
863 // Always use unsigned comparisons: above and below, not less and greater.
864 void CmpInstanceType(Register map, InstanceType type);
866 // Check if a map for a JSObject indicates that the object has fast elements.
867 // Jump to the specified label if it does not.
868 void CheckFastElements(Register map,
870 Label::Distance distance = Label::kFar);
872 // Check if a map for a JSObject indicates that the object can have both smi
873 // and HeapObject elements. Jump to the specified label if it does not.
874 void CheckFastObjectElements(Register map,
876 Label::Distance distance = Label::kFar);
878 // Check if a map for a JSObject indicates that the object has fast smi only
879 // elements. Jump to the specified label if it does not.
880 void CheckFastSmiOnlyElements(Register map,
882 Label::Distance distance = Label::kFar);
884 // Check to see if maybe_number can be stored as a double in
885 // FastDoubleElements. If it can, store it at the index specified by index in
886 // the FastDoubleElements array elements, otherwise jump to fail. Note that
887 // index must not be smi-tagged.
888 void StoreNumberToDoubleElements(Register maybe_number,
891 XMMRegister xmm_scratch,
894 // Compare an object's map with the specified map and its transitioned
895 // elements maps if mode is ALLOW_ELEMENT_TRANSITION_MAPS. FLAGS are set with
896 // result of map compare. If multiple map compares are required, the compare
897 // sequences branches to early_success.
898 void CompareMap(Register obj,
900 Label* early_success,
901 CompareMapMode mode = REQUIRE_EXACT_MAP);
903 // Check if the map of an object is equal to a specified map and branch to
904 // label if not. Skip the smi check if not required (object is known to be a
905 // heap object). If mode is ALLOW_ELEMENT_TRANSITION_MAPS, then also match
906 // against maps that are ElementsKind transition maps of the specified map.
907 void CheckMap(Register obj,
910 SmiCheckType smi_check_type,
911 CompareMapMode mode = REQUIRE_EXACT_MAP);
913 // Check if the map of an object is equal to a specified map and branch to a
914 // specified target if equal. Skip the smi check if not required (object is
915 // known to be a heap object)
916 void DispatchMap(Register obj,
918 Handle<Code> success,
919 SmiCheckType smi_check_type);
921 // Check if the object in register heap_object is a string. Afterwards the
922 // register map contains the object map and the register instance_type
923 // contains the instance_type. The registers map and instance_type can be the
924 // same in which case it contains the instance type afterwards. Either of the
925 // registers map and instance_type can be the same as heap_object.
926 Condition IsObjectStringType(Register heap_object,
928 Register instance_type);
930 // FCmp compares and pops the two values on top of the FPU stack.
931 // The flag results are similar to integer cmp, but requires unsigned
932 // jcc instructions (je, ja, jae, jb, jbe, je, and jz).
935 void ClampUint8(Register reg);
937 void ClampDoubleToUint8(XMMRegister input_reg,
938 XMMRegister temp_xmm_reg,
942 void LoadInstanceDescriptors(Register map, Register descriptors);
944 // Abort execution if argument is not a number. Used in debug code.
945 void AbortIfNotNumber(Register object);
947 // Abort execution if argument is a smi. Used in debug code.
948 void AbortIfSmi(Register object);
950 // Abort execution if argument is not a smi. Used in debug code.
951 void AbortIfNotSmi(Register object);
952 void AbortIfNotSmi(const Operand& object);
954 // Abort execution if a 64 bit register containing a 32 bit payload does not
955 // have zeros in the top 32 bits.
956 void AbortIfNotZeroExtended(Register reg);
958 // Abort execution if argument is a string. Used in debug code.
959 void AbortIfNotString(Register object);
961 // Abort execution if argument is not the root value with the given index.
962 void AbortIfNotRootValue(Register src,
963 Heap::RootListIndex root_value_index,
964 const char* message);
966 // ---------------------------------------------------------------------------
967 // Exception handling
969 // Push a new try handler and link it into try handler chain.
970 void PushTryHandler(StackHandler::Kind kind, int handler_index);
972 // Unlink the stack handler on top of the stack from the try handler chain.
973 void PopTryHandler();
975 // Activate the top handler in the try hander chain and pass the
977 void Throw(Register value);
979 // Propagate an uncatchable exception out of the current JS stack.
980 void ThrowUncatchable(Register value);
982 // ---------------------------------------------------------------------------
983 // Inline caching support
985 // Generate code for checking access rights - used for security checks
986 // on access to global objects across environments. The holder register
987 // is left untouched, but the scratch register and kScratchRegister,
988 // which must be different, are clobbered.
989 void CheckAccessGlobalProxy(Register holder_reg,
993 void GetNumberHash(Register r0, Register scratch);
995 void LoadFromNumberDictionary(Label* miss,
1004 // ---------------------------------------------------------------------------
1005 // Allocation support
1007 // Allocate an object in new space. If the new space is exhausted control
1008 // continues at the gc_required label. The allocated object is returned in
1009 // result and end of the new object is returned in result_end. The register
1010 // scratch can be passed as no_reg in which case an additional object
1011 // reference will be added to the reloc info. The returned pointers in result
1012 // and result_end have not yet been tagged as heap objects. If
1013 // result_contains_top_on_entry is true the content of result is known to be
1014 // the allocation top on entry (could be result_end from a previous call to
1015 // AllocateInNewSpace). If result_contains_top_on_entry is true scratch
1016 // should be no_reg as it is never used.
1017 void AllocateInNewSpace(int object_size,
1019 Register result_end,
1022 AllocationFlags flags);
1024 void AllocateInNewSpace(int header_size,
1025 ScaleFactor element_size,
1026 Register element_count,
1028 Register result_end,
1031 AllocationFlags flags);
1033 void AllocateInNewSpace(Register object_size,
1035 Register result_end,
1038 AllocationFlags flags);
1040 // Undo allocation in new space. The object passed and objects allocated after
1041 // it will no longer be allocated. Make sure that no pointers are left to the
1042 // object(s) no longer allocated as they would be invalid when allocation is
1044 void UndoAllocationInNewSpace(Register object);
1046 // Allocate a heap number in new space with undefined value. Returns
1047 // tagged pointer in result register, or jumps to gc_required if new
1049 void AllocateHeapNumber(Register result,
1051 Label* gc_required);
1053 // Allocate a sequential string. All the header fields of the string object
1055 void AllocateTwoByteString(Register result,
1060 Label* gc_required);
1061 void AllocateAsciiString(Register result,
1066 Label* gc_required);
1068 // Allocate a raw cons string object. Only the map field of the result is
1070 void AllocateTwoByteConsString(Register result,
1073 Label* gc_required);
1074 void AllocateAsciiConsString(Register result,
1077 Label* gc_required);
1079 // Allocate a raw sliced string object. Only the map field of the result is
1081 void AllocateTwoByteSlicedString(Register result,
1084 Label* gc_required);
1085 void AllocateAsciiSlicedString(Register result,
1088 Label* gc_required);
1090 // ---------------------------------------------------------------------------
1091 // Support functions.
1093 // Check if result is zero and op is negative.
1094 void NegativeZeroTest(Register result, Register op, Label* then_label);
1096 // Check if result is zero and op is negative in code using jump targets.
1097 void NegativeZeroTest(CodeGenerator* cgen,
1100 JumpTarget* then_target);
1102 // Check if result is zero and any of op1 and op2 are negative.
1103 // Register scratch is destroyed, and it must be different from op2.
1104 void NegativeZeroTest(Register result, Register op1, Register op2,
1105 Register scratch, Label* then_label);
1107 // Try to get function prototype of a function and puts the value in
1108 // the result register. Checks that the function really is a
1109 // function and jumps to the miss label if the fast checks fail. The
1110 // function register will be untouched; the other register may be
1112 void TryGetFunctionPrototype(Register function,
1115 bool miss_on_bound_function = false);
1117 // Generates code for reporting that an illegal operation has
1119 void IllegalOperation(int num_arguments);
1121 // Picks out an array index from the hash field.
1123 // hash - holds the index's hash. Clobbered.
1124 // index - holds the overwritten index on exit.
1125 void IndexFromHash(Register hash, Register index);
1127 // Find the function context up the context chain.
1128 void LoadContext(Register dst, int context_chain_length);
1130 // Conditionally load the cached Array transitioned map of type
1131 // transitioned_kind from the global context if the map in register
1132 // map_in_out is the cached Array map in the global context of
1134 void LoadTransitionedArrayMapConditional(
1135 ElementsKind expected_kind,
1136 ElementsKind transitioned_kind,
1137 Register map_in_out,
1139 Label* no_map_match);
1141 // Load the initial map for new Arrays from a JSFunction.
1142 void LoadInitialArrayMap(Register function_in,
1146 // Load the global function with the given index.
1147 void LoadGlobalFunction(int index, Register function);
1149 // Load the initial map from the global function. The registers
1150 // function and map can be the same.
1151 void LoadGlobalFunctionInitialMap(Register function, Register map);
1153 // ---------------------------------------------------------------------------
1156 // Call a code stub.
1157 void CallStub(CodeStub* stub, unsigned ast_id = kNoASTId);
1159 // Tail call a code stub (jump).
1160 void TailCallStub(CodeStub* stub);
1162 // Return from a code stub after popping its arguments.
1163 void StubReturn(int argc);
1165 // Call a runtime routine.
1166 void CallRuntime(const Runtime::Function* f, int num_arguments);
1168 // Call a runtime function and save the value of XMM registers.
1169 void CallRuntimeSaveDoubles(Runtime::FunctionId id);
1171 // Convenience function: Same as above, but takes the fid instead.
1172 void CallRuntime(Runtime::FunctionId id, int num_arguments);
1174 // Convenience function: call an external reference.
1175 void CallExternalReference(const ExternalReference& ext,
1178 // Tail call of a runtime routine (jump).
1179 // Like JumpToExternalReference, but also takes care of passing the number
1181 void TailCallExternalReference(const ExternalReference& ext,
1185 // Convenience function: tail call a runtime routine (jump).
1186 void TailCallRuntime(Runtime::FunctionId fid,
1190 // Jump to a runtime routine.
1191 void JumpToExternalReference(const ExternalReference& ext, int result_size);
1193 // Prepares stack to put arguments (aligns and so on). WIN64 calling
1194 // convention requires to put the pointer to the return value slot into
1195 // rcx (rcx must be preserverd until CallApiFunctionAndReturn). Saves
1196 // context (rsi). Clobbers rax. Allocates arg_stack_space * kPointerSize
1197 // inside the exit frame (not GCed) accessible via StackSpaceOperand.
1198 void PrepareCallApiFunction(int arg_stack_space);
1200 // Calls an API function. Allocates HandleScope, extracts returned value
1201 // from handle and propagates exceptions. Clobbers r14, r15, rbx and
1202 // caller-save registers. Restores context. On return removes
1203 // stack_space * kPointerSize (GCed).
1204 void CallApiFunctionAndReturn(Address function_address, int stack_space);
1206 // Before calling a C-function from generated code, align arguments on stack.
1207 // After aligning the frame, arguments must be stored in esp[0], esp[4],
1208 // etc., not pushed. The argument count assumes all arguments are word sized.
1209 // The number of slots reserved for arguments depends on platform. On Windows
1210 // stack slots are reserved for the arguments passed in registers. On other
1211 // platforms stack slots are only reserved for the arguments actually passed
1213 void PrepareCallCFunction(int num_arguments);
1215 // Calls a C function and cleans up the space for arguments allocated
1216 // by PrepareCallCFunction. The called function is not allowed to trigger a
1217 // garbage collection, since that might move the code and invalidate the
1218 // return address (unless this is somehow accounted for by the called
1220 void CallCFunction(ExternalReference function, int num_arguments);
1221 void CallCFunction(Register function, int num_arguments);
1223 // Calculate the number of stack slots to reserve for arguments when calling a
1225 int ArgumentStackSlotsForCFunctionCall(int num_arguments);
1227 // ---------------------------------------------------------------------------
1232 // Return and drop arguments from stack, where the number of arguments
1233 // may be bigger than 2^16 - 1. Requires a scratch register.
1234 void Ret(int bytes_dropped, Register scratch);
1236 Handle<Object> CodeObject() {
1237 ASSERT(!code_object_.is_null());
1238 return code_object_;
1241 // Copy length bytes from source to destination.
1242 // Uses scratch register internally (if you have a low-eight register
1243 // free, do use it, otherwise kScratchRegister will be used).
1244 // The min_length is a minimum limit on the value that length will have.
1245 // The algorithm has some special cases that might be omitted if the string
1246 // is known to always be long.
1247 void CopyBytes(Register destination,
1251 Register scratch = kScratchRegister);
1253 // Initialize fields with filler values. Fields starting at |start_offset|
1254 // not including end_offset are overwritten with the value in |filler|. At
1255 // the end the loop, |start_offset| takes the value of |end_offset|.
1256 void InitializeFieldsWithFiller(Register start_offset,
1257 Register end_offset,
1261 // ---------------------------------------------------------------------------
1262 // StatsCounter support
1264 void SetCounter(StatsCounter* counter, int value);
1265 void IncrementCounter(StatsCounter* counter, int value);
1266 void DecrementCounter(StatsCounter* counter, int value);
1269 // ---------------------------------------------------------------------------
1272 // Calls Abort(msg) if the condition cc is not satisfied.
1273 // Use --debug_code to enable.
1274 void Assert(Condition cc, const char* msg);
1276 void AssertFastElements(Register elements);
1278 // Like Assert(), but always enabled.
1279 void Check(Condition cc, const char* msg);
1281 // Print a message to stdout and abort execution.
1282 void Abort(const char* msg);
1284 // Check that the stack is aligned.
1285 void CheckStackAlignment();
1287 // Verify restrictions about code generated in stubs.
1288 void set_generating_stub(bool value) { generating_stub_ = value; }
1289 bool generating_stub() { return generating_stub_; }
1290 void set_allow_stub_calls(bool value) { allow_stub_calls_ = value; }
1291 bool allow_stub_calls() { return allow_stub_calls_; }
1292 void set_has_frame(bool value) { has_frame_ = value; }
1293 bool has_frame() { return has_frame_; }
1294 inline bool AllowThisStubCall(CodeStub* stub);
1296 static int SafepointRegisterStackIndex(Register reg) {
1297 return SafepointRegisterStackIndex(reg.code());
1300 // Activation support.
1301 void EnterFrame(StackFrame::Type type);
1302 void LeaveFrame(StackFrame::Type type);
1304 // Expects object in rax and returns map with validated enum cache
1305 // in rax. Assumes that any other register can be used as a scratch.
1306 void CheckEnumCache(Register null_value,
1307 Label* call_runtime);
1310 // Order general registers are pushed by Pushad.
1311 // rax, rcx, rdx, rbx, rsi, rdi, r8, r9, r11, r14, r15.
1312 static const int kSafepointPushRegisterIndices[Register::kNumRegisters];
1313 static const int kNumSafepointSavedRegisters = 11;
1314 static const int kSmiShift = kSmiTagSize + kSmiShiftSize;
1316 bool generating_stub_;
1317 bool allow_stub_calls_;
1319 bool root_array_available_;
1321 // Returns a register holding the smi value. The register MUST NOT be
1322 // modified. It may be the "smi 1 constant" register.
1323 Register GetSmiConstant(Smi* value);
1325 // Moves the smi value to the destination register.
1326 void LoadSmiConstant(Register dst, Smi* value);
1328 // This handle will be patched with the code object on installation.
1329 Handle<Object> code_object_;
1331 // Helper functions for generating invokes.
1332 void InvokePrologue(const ParameterCount& expected,
1333 const ParameterCount& actual,
1334 Handle<Code> code_constant,
1335 Register code_register,
1337 bool* definitely_mismatches,
1339 Label::Distance near_jump = Label::kFar,
1340 const CallWrapper& call_wrapper = NullCallWrapper(),
1341 CallKind call_kind = CALL_AS_METHOD);
1343 void EnterExitFramePrologue(bool save_rax);
1345 // Allocates arg_stack_space * kPointerSize memory (not GCed) on the stack
1346 // accessible via StackSpaceOperand.
1347 void EnterExitFrameEpilogue(int arg_stack_space, bool save_doubles);
1349 void LeaveExitFrameEpilogue();
1351 // Allocation support helpers.
1352 // Loads the top of new-space into the result register.
1353 // Otherwise the address of the new-space top is loaded into scratch (if
1354 // scratch is valid), and the new-space top is loaded into result.
1355 void LoadAllocationTopHelper(Register result,
1357 AllocationFlags flags);
1358 // Update allocation top with value in result_end register.
1359 // If scratch is valid, it contains the address of the allocation top.
1360 void UpdateAllocationTopHelper(Register result_end, Register scratch);
1362 // Helper for PopHandleScope. Allowed to perform a GC and returns
1363 // NULL if gc_allowed. Does not perform a GC if !gc_allowed, and
1364 // possibly returns a failure object indicating an allocation failure.
1365 Object* PopHandleScopeHelper(Register saved,
1369 // Helper for implementing JumpIfNotInNewSpace and JumpIfInNewSpace.
1370 void InNewSpace(Register object,
1374 Label::Distance distance = Label::kFar);
1376 // Helper for finding the mark bits for an address. Afterwards, the
1377 // bitmap register points at the word with the mark bits and the mask
1378 // the position of the first bit. Uses rcx as scratch and leaves addr_reg
1380 inline void GetMarkBits(Register addr_reg,
1381 Register bitmap_reg,
1384 // Helper for throwing exceptions. Compute a handler address and jump to
1385 // it. See the implementation for register usage.
1386 void JumpToHandlerEntry();
1388 // Compute memory operands for safepoint stack slots.
1389 Operand SafepointRegisterSlot(Register reg);
1390 static int SafepointRegisterStackIndex(int reg_code) {
1391 return kNumSafepointRegisters - kSafepointPushRegisterIndices[reg_code] - 1;
1394 // Needs access to SafepointRegisterStackIndex for optimized frame
1396 friend class OptimizedFrame;
1400 // The code patcher is used to patch (typically) small parts of code e.g. for
1401 // debugging and other types of instrumentation. When using the code patcher
1402 // the exact number of bytes specified must be emitted. Is not legal to emit
1403 // relocation information. If any of these constraints are violated it causes
1407 CodePatcher(byte* address, int size);
1408 virtual ~CodePatcher();
1410 // Macro assembler to emit code.
1411 MacroAssembler* masm() { return &masm_; }
1414 byte* address_; // The address of the code being patched.
1415 int size_; // Number of bytes of the expected patch size.
1416 MacroAssembler masm_; // Macro assembler used to generate the code.
1420 // -----------------------------------------------------------------------------
1421 // Static helper functions.
1423 // Generate an Operand for loading a field from an object.
1424 inline Operand FieldOperand(Register object, int offset) {
1425 return Operand(object, offset - kHeapObjectTag);
1429 // Generate an Operand for loading an indexed field from an object.
1430 inline Operand FieldOperand(Register object,
1434 return Operand(object, index, scale, offset - kHeapObjectTag);
1438 inline Operand ContextOperand(Register context, int index) {
1439 return Operand(context, Context::SlotOffset(index));
1443 inline Operand GlobalObjectOperand() {
1444 return ContextOperand(rsi, Context::GLOBAL_INDEX);
1448 // Provides access to exit frame stack space (not GCed).
1449 inline Operand StackSpaceOperand(int index) {
1451 const int kShaddowSpace = 4;
1452 return Operand(rsp, (index + kShaddowSpace) * kPointerSize);
1454 return Operand(rsp, index * kPointerSize);
1460 #ifdef GENERATED_CODE_COVERAGE
1461 extern void LogGeneratedCodeCoverage(const char* file_line);
1462 #define CODE_COVERAGE_STRINGIFY(x) #x
1463 #define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x)
1464 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
1465 #define ACCESS_MASM(masm) { \
1466 byte* x64_coverage_function = \
1467 reinterpret_cast<byte*>(FUNCTION_ADDR(LogGeneratedCodeCoverage)); \
1470 masm->push(Immediate(reinterpret_cast<int>(&__FILE_LINE__))); \
1471 masm->call(x64_coverage_function, RelocInfo::RUNTIME_ENTRY); \
1478 #define ACCESS_MASM(masm) masm->
1481 } } // namespace v8::internal
1483 #endif // V8_X64_MACRO_ASSEMBLER_X64_H_