// Copyright 2012 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following // disclaimer in the documentation and/or other materials provided // with the distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef V8_ARM_MACRO_ASSEMBLER_ARM_H_ #define V8_ARM_MACRO_ASSEMBLER_ARM_H_ #include "assembler.h" #include "frames.h" #include "v8globals.h" namespace v8 { namespace internal { // ---------------------------------------------------------------------------- // Static helper functions // Generate a MemOperand for loading a field from an object. inline MemOperand FieldMemOperand(Register object, int offset) { return MemOperand(object, offset - kHeapObjectTag); } inline Operand SmiUntagOperand(Register object) { return Operand(object, ASR, kSmiTagSize); } // Give alias names to registers const Register cp = { 8 }; // JavaScript context pointer const Register kRootRegister = { 10 }; // Roots array pointer. // Flags used for the AllocateInNewSpace functions. enum AllocationFlags { // No special flags. NO_ALLOCATION_FLAGS = 0, // Return the pointer to the allocated already tagged as a heap object. TAG_OBJECT = 1 << 0, // The content of the result register already contains the allocation top in // new space. RESULT_CONTAINS_TOP = 1 << 1, // Specify that the requested size of the space to allocate is specified in // words instead of bytes. SIZE_IN_WORDS = 1 << 2 }; // Flags used for AllocateHeapNumber enum TaggingMode { // Tag the result. TAG_RESULT, // Don't tag DONT_TAG_RESULT }; // Flags used for the ObjectToDoubleVFPRegister function. enum ObjectToDoubleFlags { // No special flags. NO_OBJECT_TO_DOUBLE_FLAGS = 0, // Object is known to be a non smi. OBJECT_NOT_SMI = 1 << 0, // Don't load NaNs or infinities, branch to the non number case instead. AVOID_NANS_AND_INFINITIES = 1 << 1 }; enum RememberedSetAction { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET }; enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK }; enum LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved }; #ifdef DEBUG bool AreAliased(Register reg1, Register reg2, Register reg3 = no_reg, Register reg4 = no_reg, Register reg5 = no_reg, Register reg6 = no_reg); #endif enum TargetAddressStorageMode { CAN_INLINE_TARGET_ADDRESS, NEVER_INLINE_TARGET_ADDRESS }; // MacroAssembler implements a collection of frequently used macros. class MacroAssembler: public Assembler { public: // The isolate parameter can be NULL if the macro assembler should // not use isolate-dependent functionality. In this case, it's the // responsibility of the caller to never invoke such function on the // macro assembler. MacroAssembler(Isolate* isolate, void* buffer, int size); // Jump, Call, and Ret pseudo instructions implementing inter-working. void Jump(Register target, Condition cond = al); void Jump(Address target, RelocInfo::Mode rmode, Condition cond = al); void Jump(Handle code, RelocInfo::Mode rmode, Condition cond = al); static int CallSize(Register target, Condition cond = al); void Call(Register target, Condition cond = al); int CallSize(Address target, RelocInfo::Mode rmode, Condition cond = al); static int CallSizeNotPredictableCodeSize(Address target, RelocInfo::Mode rmode, Condition cond = al); void Call(Address target, RelocInfo::Mode rmode, Condition cond = al, TargetAddressStorageMode mode = CAN_INLINE_TARGET_ADDRESS); int CallSize(Handle code, RelocInfo::Mode rmode = RelocInfo::CODE_TARGET, TypeFeedbackId ast_id = TypeFeedbackId::None(), Condition cond = al); void Call(Handle code, RelocInfo::Mode rmode = RelocInfo::CODE_TARGET, TypeFeedbackId ast_id = TypeFeedbackId::None(), Condition cond = al, TargetAddressStorageMode mode = CAN_INLINE_TARGET_ADDRESS); void Ret(Condition cond = al); // Emit code to discard a non-negative number of pointer-sized elements // from the stack, clobbering only the sp register. void Drop(int count, Condition cond = al); void Ret(int drop, Condition cond = al); // Swap two registers. If the scratch register is omitted then a slightly // less efficient form using xor instead of mov is emitted. void Swap(Register reg1, Register reg2, Register scratch = no_reg, Condition cond = al); void And(Register dst, Register src1, const Operand& src2, Condition cond = al); void Ubfx(Register dst, Register src, int lsb, int width, Condition cond = al); void Sbfx(Register dst, Register src, int lsb, int width, Condition cond = al); // The scratch register is not used for ARMv7. // scratch can be the same register as src (in which case it is trashed), but // not the same as dst. void Bfi(Register dst, Register src, Register scratch, int lsb, int width, Condition cond = al); void Bfc(Register dst, Register src, int lsb, int width, Condition cond = al); void Usat(Register dst, int satpos, const Operand& src, Condition cond = al); void Call(Label* target); // Register move. May do nothing if the registers are identical. void Move(Register dst, Handle value); void Move(Register dst, Register src, Condition cond = al); void Move(DoubleRegister dst, DoubleRegister src); // Load an object from the root table. void LoadRoot(Register destination, Heap::RootListIndex index, Condition cond = al); // Store an object to the root table. void StoreRoot(Register source, Heap::RootListIndex index, Condition cond = al); void LoadHeapObject(Register dst, Handle object); void LoadObject(Register result, Handle object) { if (object->IsHeapObject()) { LoadHeapObject(result, Handle::cast(object)); } else { Move(result, object); } } // --------------------------------------------------------------------------- // GC Support void IncrementalMarkingRecordWriteHelper(Register object, Register value, Register address); enum RememberedSetFinalAction { kReturnAtEnd, kFallThroughAtEnd }; // Record in the remembered set the fact that we have a pointer to new space // at the address pointed to by the addr register. Only works if addr is not // in new space. void RememberedSetHelper(Register object, // Used for debug code. Register addr, Register scratch, SaveFPRegsMode save_fp, RememberedSetFinalAction and_then); void CheckPageFlag(Register object, Register scratch, int mask, Condition cc, Label* condition_met); // Check if object is in new space. Jumps if the object is not in new space. // The register scratch can be object itself, but scratch will be clobbered. void JumpIfNotInNewSpace(Register object, Register scratch, Label* branch) { InNewSpace(object, scratch, ne, branch); } // Check if object is in new space. Jumps if the object is in new space. // The register scratch can be object itself, but it will be clobbered. void JumpIfInNewSpace(Register object, Register scratch, Label* branch) { InNewSpace(object, scratch, eq, branch); } // Check if an object has a given incremental marking color. void HasColor(Register object, Register scratch0, Register scratch1, Label* has_color, int first_bit, int second_bit); void JumpIfBlack(Register object, Register scratch0, Register scratch1, Label* on_black); // Checks the color of an object. If the object is already grey or black // then we just fall through, since it is already live. If it is white and // we can determine that it doesn't need to be scanned, then we just mark it // black and fall through. For the rest we jump to the label so the // incremental marker can fix its assumptions. void EnsureNotWhite(Register object, Register scratch1, Register scratch2, Register scratch3, Label* object_is_white_and_not_data); // Detects conservatively whether an object is data-only, i.e. it does need to // be scanned by the garbage collector. void JumpIfDataObject(Register value, Register scratch, Label* not_data_object); // Notify the garbage collector that we wrote a pointer into an object. // |object| is the object being stored into, |value| is the object being // stored. value and scratch registers are clobbered by the operation. // The offset is the offset from the start of the object, not the offset from // the tagged HeapObject pointer. For use with FieldOperand(reg, off). void RecordWriteField( Register object, int offset, Register value, Register scratch, LinkRegisterStatus lr_status, SaveFPRegsMode save_fp, RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET, SmiCheck smi_check = INLINE_SMI_CHECK); // As above, but the offset has the tag presubtracted. For use with // MemOperand(reg, off). inline void RecordWriteContextSlot( Register context, int offset, Register value, Register scratch, LinkRegisterStatus lr_status, SaveFPRegsMode save_fp, RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET, SmiCheck smi_check = INLINE_SMI_CHECK) { RecordWriteField(context, offset + kHeapObjectTag, value, scratch, lr_status, save_fp, remembered_set_action, smi_check); } // For a given |object| notify the garbage collector that the slot |address| // has been written. |value| is the object being stored. The value and // address registers are clobbered by the operation. void RecordWrite( Register object, Register address, Register value, LinkRegisterStatus lr_status, SaveFPRegsMode save_fp, RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET, SmiCheck smi_check = INLINE_SMI_CHECK); // Push a handle. void Push(Handle handle); // Push two registers. Pushes leftmost register first (to highest address). void Push(Register src1, Register src2, Condition cond = al) { ASSERT(!src1.is(src2)); if (src1.code() > src2.code()) { stm(db_w, sp, src1.bit() | src2.bit(), cond); } else { str(src1, MemOperand(sp, 4, NegPreIndex), cond); str(src2, MemOperand(sp, 4, NegPreIndex), cond); } } // Push three registers. Pushes leftmost register first (to highest address). void Push(Register src1, Register src2, Register src3, Condition cond = al) { ASSERT(!src1.is(src2)); ASSERT(!src2.is(src3)); ASSERT(!src1.is(src3)); if (src1.code() > src2.code()) { if (src2.code() > src3.code()) { stm(db_w, sp, src1.bit() | src2.bit() | src3.bit(), cond); } else { stm(db_w, sp, src1.bit() | src2.bit(), cond); str(src3, MemOperand(sp, 4, NegPreIndex), cond); } } else { str(src1, MemOperand(sp, 4, NegPreIndex), cond); Push(src2, src3, cond); } } // Push four registers. Pushes leftmost register first (to highest address). void Push(Register src1, Register src2, Register src3, Register src4, Condition cond = al) { ASSERT(!src1.is(src2)); ASSERT(!src2.is(src3)); ASSERT(!src1.is(src3)); ASSERT(!src1.is(src4)); ASSERT(!src2.is(src4)); ASSERT(!src3.is(src4)); if (src1.code() > src2.code()) { if (src2.code() > src3.code()) { if (src3.code() > src4.code()) { stm(db_w, sp, src1.bit() | src2.bit() | src3.bit() | src4.bit(), cond); } else { stm(db_w, sp, src1.bit() | src2.bit() | src3.bit(), cond); str(src4, MemOperand(sp, 4, NegPreIndex), cond); } } else { stm(db_w, sp, src1.bit() | src2.bit(), cond); Push(src3, src4, cond); } } else { str(src1, MemOperand(sp, 4, NegPreIndex), cond); Push(src2, src3, src4, cond); } } // Pop two registers. Pops rightmost register first (from lower address). void Pop(Register src1, Register src2, Condition cond = al) { ASSERT(!src1.is(src2)); if (src1.code() > src2.code()) { ldm(ia_w, sp, src1.bit() | src2.bit(), cond); } else { ldr(src2, MemOperand(sp, 4, PostIndex), cond); ldr(src1, MemOperand(sp, 4, PostIndex), cond); } } // Pop three registers. Pops rightmost register first (from lower address). void Pop(Register src1, Register src2, Register src3, Condition cond = al) { ASSERT(!src1.is(src2)); ASSERT(!src2.is(src3)); ASSERT(!src1.is(src3)); if (src1.code() > src2.code()) { if (src2.code() > src3.code()) { ldm(ia_w, sp, src1.bit() | src2.bit() | src3.bit(), cond); } else { ldr(src3, MemOperand(sp, 4, PostIndex), cond); ldm(ia_w, sp, src1.bit() | src2.bit(), cond); } } else { Pop(src2, src3, cond); str(src1, MemOperand(sp, 4, PostIndex), cond); } } // Pop four registers. Pops rightmost register first (from lower address). void Pop(Register src1, Register src2, Register src3, Register src4, Condition cond = al) { ASSERT(!src1.is(src2)); ASSERT(!src2.is(src3)); ASSERT(!src1.is(src3)); ASSERT(!src1.is(src4)); ASSERT(!src2.is(src4)); ASSERT(!src3.is(src4)); if (src1.code() > src2.code()) { if (src2.code() > src3.code()) { if (src3.code() > src4.code()) { ldm(ia_w, sp, src1.bit() | src2.bit() | src3.bit() | src4.bit(), cond); } else { ldr(src4, MemOperand(sp, 4, PostIndex), cond); ldm(ia_w, sp, src1.bit() | src2.bit() | src3.bit(), cond); } } else { Pop(src3, src4, cond); ldm(ia_w, sp, src1.bit() | src2.bit(), cond); } } else { Pop(src2, src3, src4, cond); ldr(src1, MemOperand(sp, 4, PostIndex), cond); } } // Push and pop the registers that can hold pointers, as defined by the // RegList constant kSafepointSavedRegisters. void PushSafepointRegisters(); void PopSafepointRegisters(); void PushSafepointRegistersAndDoubles(); void PopSafepointRegistersAndDoubles(); // Store value in register src in the safepoint stack slot for // register dst. void StoreToSafepointRegisterSlot(Register src, Register dst); void StoreToSafepointRegistersAndDoublesSlot(Register src, Register dst); // Load the value of the src register from its safepoint stack slot // into register dst. void LoadFromSafepointRegisterSlot(Register dst, Register src); // Load two consecutive registers with two consecutive memory locations. void Ldrd(Register dst1, Register dst2, const MemOperand& src, Condition cond = al); // Store two consecutive registers to two consecutive memory locations. void Strd(Register src1, Register src2, const MemOperand& dst, Condition cond = al); // Clear specified FPSCR bits. void ClearFPSCRBits(const uint32_t bits_to_clear, const Register scratch, const Condition cond = al); // Compare double values and move the result to the normal condition flags. void VFPCompareAndSetFlags(const DwVfpRegister src1, const DwVfpRegister src2, const Condition cond = al); void VFPCompareAndSetFlags(const DwVfpRegister src1, const double src2, const Condition cond = al); // Compare double values and then load the fpscr flags to a register. void VFPCompareAndLoadFlags(const DwVfpRegister src1, const DwVfpRegister src2, const Register fpscr_flags, const Condition cond = al); void VFPCompareAndLoadFlags(const DwVfpRegister src1, const double src2, const Register fpscr_flags, const Condition cond = al); void Vmov(const DwVfpRegister dst, const double imm, const Register scratch = no_reg, const Condition cond = al); // Enter exit frame. // stack_space - extra stack space, used for alignment before call to C. void EnterExitFrame(bool save_doubles, int stack_space = 0); // Leave the current exit frame. Expects the return value in r0. // Expect the number of values, pushed prior to the exit frame, to // remove in a register (or no_reg, if there is nothing to remove). void LeaveExitFrame(bool save_doubles, Register argument_count); // Get the actual activation frame alignment for target environment. static int ActivationFrameAlignment(); void LoadContext(Register dst, int context_chain_length); // Conditionally load the cached Array transitioned map of type // transitioned_kind from the native context if the map in register // map_in_out is the cached Array map in the native context of // expected_kind. void LoadTransitionedArrayMapConditional( ElementsKind expected_kind, ElementsKind transitioned_kind, Register map_in_out, Register scratch, Label* no_map_match); // Load the initial map for new Arrays from a JSFunction. void LoadInitialArrayMap(Register function_in, Register scratch, Register map_out, bool can_have_holes); void LoadGlobalFunction(int index, Register function); // Load the initial map from the global function. The registers // function and map can be the same, function is then overwritten. void LoadGlobalFunctionInitialMap(Register function, Register map, Register scratch); void InitializeRootRegister() { ExternalReference roots_array_start = ExternalReference::roots_array_start(isolate()); mov(kRootRegister, Operand(roots_array_start)); } // --------------------------------------------------------------------------- // JavaScript invokes // Set up call kind marking in ecx. The method takes ecx as an // explicit first parameter to make the code more readable at the // call sites. void SetCallKind(Register dst, CallKind kind); // Invoke the JavaScript function code by either calling or jumping. void InvokeCode(Register code, const ParameterCount& expected, const ParameterCount& actual, InvokeFlag flag, const CallWrapper& call_wrapper, CallKind call_kind); void InvokeCode(Handle code, const ParameterCount& expected, const ParameterCount& actual, RelocInfo::Mode rmode, InvokeFlag flag, CallKind call_kind); // Invoke the JavaScript function in the given register. Changes the // current context to the context in the function before invoking. void InvokeFunction(Register function, const ParameterCount& actual, InvokeFlag flag, const CallWrapper& call_wrapper, CallKind call_kind); void InvokeFunction(Handle function, const ParameterCount& actual, InvokeFlag flag, const CallWrapper& call_wrapper, CallKind call_kind); void IsObjectJSObjectType(Register heap_object, Register map, Register scratch, Label* fail); void IsInstanceJSObjectType(Register map, Register scratch, Label* fail); void IsObjectJSStringType(Register object, Register scratch, Label* fail); #ifdef ENABLE_DEBUGGER_SUPPORT // --------------------------------------------------------------------------- // Debugger Support void DebugBreak(); #endif // --------------------------------------------------------------------------- // Exception handling // Push a new try handler and link into try handler chain. void PushTryHandler(StackHandler::Kind kind, int handler_index); // Unlink the stack handler on top of the stack from the try handler chain. // Must preserve the result register. void PopTryHandler(); // Passes thrown value to the handler of top of the try handler chain. void Throw(Register value); // Propagates an uncatchable exception to the top of the current JS stack's // handler chain. void ThrowUncatchable(Register value); // --------------------------------------------------------------------------- // Inline caching support // Generate code for checking access rights - used for security checks // on access to global objects across environments. The holder register // is left untouched, whereas both scratch registers are clobbered. void CheckAccessGlobalProxy(Register holder_reg, Register scratch, Label* miss); void GetNumberHash(Register t0, Register scratch); void LoadFromNumberDictionary(Label* miss, Register elements, Register key, Register result, Register t0, Register t1, Register t2); inline void MarkCode(NopMarkerTypes type) { nop(type); } // Check if the given instruction is a 'type' marker. // i.e. check if is is a mov r, r (referenced as nop(type)) // These instructions are generated to mark special location in the code, // like some special IC code. static inline bool IsMarkedCode(Instr instr, int type) { ASSERT((FIRST_IC_MARKER <= type) && (type < LAST_CODE_MARKER)); return IsNop(instr, type); } static inline int GetCodeMarker(Instr instr) { int dst_reg_offset = 12; int dst_mask = 0xf << dst_reg_offset; int src_mask = 0xf; int dst_reg = (instr & dst_mask) >> dst_reg_offset; int src_reg = instr & src_mask; uint32_t non_register_mask = ~(dst_mask | src_mask); uint32_t mov_mask = al | 13 << 21; // Return if we have a mov rn rn, else return -1. int type = ((instr & non_register_mask) == mov_mask) && (dst_reg == src_reg) && (FIRST_IC_MARKER <= dst_reg) && (dst_reg < LAST_CODE_MARKER) ? src_reg : -1; ASSERT((type == -1) || ((FIRST_IC_MARKER <= type) && (type < LAST_CODE_MARKER))); return type; } // --------------------------------------------------------------------------- // Allocation support // Allocate an object in new space. The object_size is specified // either in bytes or in words if the allocation flag SIZE_IN_WORDS // is passed. If the new space is exhausted control continues at the // gc_required label. The allocated object is returned in result. If // the flag tag_allocated_object is true the result is tagged as as // a heap object. All registers are clobbered also when control // continues at the gc_required label. void AllocateInNewSpace(int object_size, Register result, Register scratch1, Register scratch2, Label* gc_required, AllocationFlags flags); void AllocateInNewSpace(Register object_size, Register result, Register scratch1, Register scratch2, Label* gc_required, AllocationFlags flags); // Undo allocation in new space. The object passed and objects allocated after // it will no longer be allocated. The caller must make sure that no pointers // are left to the object(s) no longer allocated as they would be invalid when // allocation is undone. void UndoAllocationInNewSpace(Register object, Register scratch); void AllocateTwoByteString(Register result, Register length, Register scratch1, Register scratch2, Register scratch3, Label* gc_required); void AllocateAsciiString(Register result, Register length, Register scratch1, Register scratch2, Register scratch3, Label* gc_required); void AllocateTwoByteConsString(Register result, Register length, Register scratch1, Register scratch2, Label* gc_required); void AllocateAsciiConsString(Register result, Register length, Register scratch1, Register scratch2, Label* gc_required); void AllocateTwoByteSlicedString(Register result, Register length, Register scratch1, Register scratch2, Label* gc_required); void AllocateAsciiSlicedString(Register result, Register length, Register scratch1, Register scratch2, Label* gc_required); // Allocates a heap number or jumps to the gc_required label if the young // space is full and a scavenge is needed. All registers are clobbered also // when control continues at the gc_required label. void AllocateHeapNumber(Register result, Register scratch1, Register scratch2, Register heap_number_map, Label* gc_required, TaggingMode tagging_mode = TAG_RESULT); void AllocateHeapNumberWithValue(Register result, DwVfpRegister value, Register scratch1, Register scratch2, Register heap_number_map, Label* gc_required); // Copies a fixed number of fields of heap objects from src to dst. void CopyFields(Register dst, Register src, RegList temps, int field_count); // Copies a number of bytes from src to dst. All registers are clobbered. On // exit src and dst will point to the place just after where the last byte was // read or written and length will be zero. void CopyBytes(Register src, Register dst, Register length, Register scratch); // Initialize fields with filler values. Fields starting at |start_offset| // not including end_offset are overwritten with the value in |filler|. At // the end the loop, |start_offset| takes the value of |end_offset|. void InitializeFieldsWithFiller(Register start_offset, Register end_offset, Register filler); // --------------------------------------------------------------------------- // Support functions. // Try to get function prototype of a function and puts the value in // the result register. Checks that the function really is a // function and jumps to the miss label if the fast checks fail. The // function register will be untouched; the other registers may be // clobbered. void TryGetFunctionPrototype(Register function, Register result, Register scratch, Label* miss, bool miss_on_bound_function = false); // Compare object type for heap object. heap_object contains a non-Smi // whose object type should be compared with the given type. This both // sets the flags and leaves the object type in the type_reg register. // It leaves the map in the map register (unless the type_reg and map register // are the same register). It leaves the heap object in the heap_object // register unless the heap_object register is the same register as one of the // other registers. void CompareObjectType(Register heap_object, Register map, Register type_reg, InstanceType type); // Compare instance type in a map. map contains a valid map object whose // object type should be compared with the given type. This both // sets the flags and leaves the object type in the type_reg register. void CompareInstanceType(Register map, Register type_reg, InstanceType type); // Check if a map for a JSObject indicates that the object has fast elements. // Jump to the specified label if it does not. void CheckFastElements(Register map, Register scratch, Label* fail); // Check if a map for a JSObject indicates that the object can have both smi // and HeapObject elements. Jump to the specified label if it does not. void CheckFastObjectElements(Register map, Register scratch, Label* fail); // Check if a map for a JSObject indicates that the object has fast smi only // elements. Jump to the specified label if it does not. void CheckFastSmiElements(Register map, Register scratch, Label* fail); // Check to see if maybe_number can be stored as a double in // FastDoubleElements. If it can, store it at the index specified by key in // the FastDoubleElements array elements. Otherwise jump to fail, in which // case scratch2, scratch3 and scratch4 are unmodified. void StoreNumberToDoubleElements(Register value_reg, Register key_reg, Register receiver_reg, // All regs below here overwritten. Register elements_reg, Register scratch1, Register scratch2, Register scratch3, Register scratch4, Label* fail); // Compare an object's map with the specified map and its transitioned // elements maps if mode is ALLOW_ELEMENT_TRANSITION_MAPS. Condition flags are // set with result of map compare. If multiple map compares are required, the // compare sequences branches to early_success. void CompareMap(Register obj, Register scratch, Handle map, Label* early_success, CompareMapMode mode = REQUIRE_EXACT_MAP); // As above, but the map of the object is already loaded into the register // which is preserved by the code generated. void CompareMap(Register obj_map, Handle map, Label* early_success, CompareMapMode mode = REQUIRE_EXACT_MAP); // Check if the map of an object is equal to a specified map and branch to // label if not. Skip the smi check if not required (object is known to be a // heap object). If mode is ALLOW_ELEMENT_TRANSITION_MAPS, then also match // against maps that are ElementsKind transition maps of the specified map. void CheckMap(Register obj, Register scratch, Handle map, Label* fail, SmiCheckType smi_check_type, CompareMapMode mode = REQUIRE_EXACT_MAP); void CheckMap(Register obj, Register scratch, Heap::RootListIndex index, Label* fail, SmiCheckType smi_check_type); // Check if the map of an object is equal to a specified map and branch to a // specified target if equal. Skip the smi check if not required (object is // known to be a heap object) void DispatchMap(Register obj, Register scratch, Handle map, Handle success, SmiCheckType smi_check_type); // Compare the object in a register to a value from the root list. // Uses the ip register as scratch. void CompareRoot(Register obj, Heap::RootListIndex index); // Load and check the instance type of an object for being a string. // Loads the type into the second argument register. // Returns a condition that will be enabled if the object was a string. Condition IsObjectStringType(Register obj, Register type) { ldr(type, FieldMemOperand(obj, HeapObject::kMapOffset)); ldrb(type, FieldMemOperand(type, Map::kInstanceTypeOffset)); tst(type, Operand(kIsNotStringMask)); ASSERT_EQ(0, kStringTag); return eq; } // Generates code for reporting that an illegal operation has // occurred. void IllegalOperation(int num_arguments); // Picks out an array index from the hash field. // Register use: // hash - holds the index's hash. Clobbered. // index - holds the overwritten index on exit. void IndexFromHash(Register hash, Register index); // Get the number of least significant bits from a register void GetLeastBitsFromSmi(Register dst, Register src, int num_least_bits); void GetLeastBitsFromInt32(Register dst, Register src, int mun_least_bits); // Uses VFP instructions to Convert a Smi to a double. void IntegerToDoubleConversionWithVFP3(Register inReg, Register outHighReg, Register outLowReg); // Load the value of a number object into a VFP double register. If the object // is not a number a jump to the label not_number is performed and the VFP // double register is unchanged. void ObjectToDoubleVFPRegister( Register object, DwVfpRegister value, Register scratch1, Register scratch2, Register heap_number_map, SwVfpRegister scratch3, Label* not_number, ObjectToDoubleFlags flags = NO_OBJECT_TO_DOUBLE_FLAGS); // Load the value of a smi object into a VFP double register. The register // scratch1 can be the same register as smi in which case smi will hold the // untagged value afterwards. void SmiToDoubleVFPRegister(Register smi, DwVfpRegister value, Register scratch1, SwVfpRegister scratch2); // Convert the HeapNumber pointed to by source to a 32bits signed integer // dest. If the HeapNumber does not fit into a 32bits signed integer branch // to not_int32 label. If VFP3 is available double_scratch is used but not // scratch2. void ConvertToInt32(Register source, Register dest, Register scratch, Register scratch2, DwVfpRegister double_scratch, Label *not_int32); // Truncates a double using a specific rounding mode, and writes the value // to the result register. // Clears the z flag (ne condition) if an overflow occurs. // If kCheckForInexactConversion is passed, the z flag is also cleared if the // conversion was inexact, i.e. if the double value could not be converted // exactly to a 32-bit integer. void EmitVFPTruncate(VFPRoundingMode rounding_mode, Register result, DwVfpRegister double_input, Register scratch, DwVfpRegister double_scratch, CheckForInexactConversion check = kDontCheckForInexactConversion); // Helper for EmitECMATruncate. // This will truncate a floating-point value outside of the signed 32bit // integer range to a 32bit signed integer. // Expects the double value loaded in input_high and input_low. // Exits with the answer in 'result'. // Note that this code does not work for values in the 32bit range! void EmitOutOfInt32RangeTruncate(Register result, Register input_high, Register input_low, Register scratch); // Performs a truncating conversion of a floating point number as used by // the JS bitwise operations. See ECMA-262 9.5: ToInt32. // Exits with 'result' holding the answer and all other registers clobbered. void EmitECMATruncate(Register result, DwVfpRegister double_input, SwVfpRegister single_scratch, Register scratch, Register scratch2, Register scratch3); // Count leading zeros in a 32 bit word. On ARM5 and later it uses the clz // instruction. On pre-ARM5 hardware this routine gives the wrong answer // for 0 (31 instead of 32). Source and scratch can be the same in which case // the source is clobbered. Source and zeros can also be the same in which // case scratch should be a different register. void CountLeadingZeros(Register zeros, Register source, Register scratch); // --------------------------------------------------------------------------- // Runtime calls // Call a code stub. void CallStub(CodeStub* stub, Condition cond = al); // Call a code stub. void TailCallStub(CodeStub* stub, Condition cond = al); // Call a runtime routine. void CallRuntime(const Runtime::Function* f, int num_arguments); void CallRuntimeSaveDoubles(Runtime::FunctionId id); // Convenience function: Same as above, but takes the fid instead. void CallRuntime(Runtime::FunctionId fid, int num_arguments); // Convenience function: call an external reference. void CallExternalReference(const ExternalReference& ext, int num_arguments); // Tail call of a runtime routine (jump). // Like JumpToExternalReference, but also takes care of passing the number // of parameters. void TailCallExternalReference(const ExternalReference& ext, int num_arguments, int result_size); // Convenience function: tail call a runtime routine (jump). void TailCallRuntime(Runtime::FunctionId fid, int num_arguments, int result_size); int CalculateStackPassedWords(int num_reg_arguments, int num_double_arguments); // Before calling a C-function from generated code, align arguments on stack. // After aligning the frame, non-register arguments must be stored in // sp[0], sp[4], etc., not pushed. The argument count assumes all arguments // are word sized. If double arguments are used, this function assumes that // all double arguments are stored before core registers; otherwise the // correct alignment of the double values is not guaranteed. // Some compilers/platforms require the stack to be aligned when calling // C++ code. // Needs a scratch register to do some arithmetic. This register will be // trashed. void PrepareCallCFunction(int num_reg_arguments, int num_double_registers, Register scratch); void PrepareCallCFunction(int num_reg_arguments, Register scratch); // There are two ways of passing double arguments on ARM, depending on // whether soft or hard floating point ABI is used. These functions // abstract parameter passing for the three different ways we call // C functions from generated code. void SetCallCDoubleArguments(DoubleRegister dreg); void SetCallCDoubleArguments(DoubleRegister dreg1, DoubleRegister dreg2); void SetCallCDoubleArguments(DoubleRegister dreg, Register reg); // Calls a C function and cleans up the space for arguments allocated // by PrepareCallCFunction. The called function is not allowed to trigger a // garbage collection, since that might move the code and invalidate the // return address (unless this is somehow accounted for by the called // function). void CallCFunction(ExternalReference function, int num_arguments); void CallCFunction(Register function, int num_arguments); void CallCFunction(ExternalReference function, int num_reg_arguments, int num_double_arguments); void CallCFunction(Register function, int num_reg_arguments, int num_double_arguments); void GetCFunctionDoubleResult(const DoubleRegister dst); // Calls an API function. Allocates HandleScope, extracts returned value // from handle and propagates exceptions. Restores context. stack_space // - space to be unwound on exit (includes the call JS arguments space and // the additional space allocated for the fast call). void CallApiFunctionAndReturn(ExternalReference function, int stack_space); // Jump to a runtime routine. void JumpToExternalReference(const ExternalReference& builtin); // Invoke specified builtin JavaScript function. Adds an entry to // the unresolved list if the name does not resolve. void InvokeBuiltin(Builtins::JavaScript id, InvokeFlag flag, const CallWrapper& call_wrapper = NullCallWrapper()); // Store the code object for the given builtin in the target register and // setup the function in r1. void GetBuiltinEntry(Register target, Builtins::JavaScript id); // Store the function for the given builtin in the target register. void GetBuiltinFunction(Register target, Builtins::JavaScript id); Handle CodeObject() { ASSERT(!code_object_.is_null()); return code_object_; } // --------------------------------------------------------------------------- // StatsCounter support void SetCounter(StatsCounter* counter, int value, Register scratch1, Register scratch2); void IncrementCounter(StatsCounter* counter, int value, Register scratch1, Register scratch2); void DecrementCounter(StatsCounter* counter, int value, Register scratch1, Register scratch2); // --------------------------------------------------------------------------- // Debugging // Calls Abort(msg) if the condition cond is not satisfied. // Use --debug_code to enable. void Assert(Condition cond, const char* msg); void AssertRegisterIsRoot(Register reg, Heap::RootListIndex index); void AssertFastElements(Register elements); // Like Assert(), but always enabled. void Check(Condition cond, const char* msg); // Print a message to stdout and abort execution. void Abort(const char* msg); // Verify restrictions about code generated in stubs. void set_generating_stub(bool value) { generating_stub_ = value; } bool generating_stub() { return generating_stub_; } void set_allow_stub_calls(bool value) { allow_stub_calls_ = value; } bool allow_stub_calls() { return allow_stub_calls_; } void set_has_frame(bool value) { has_frame_ = value; } bool has_frame() { return has_frame_; } inline bool AllowThisStubCall(CodeStub* stub); // EABI variant for double arguments in use. bool use_eabi_hardfloat() { #if USE_EABI_HARDFLOAT return true; #else return false; #endif } // --------------------------------------------------------------------------- // Number utilities // Check whether the value of reg is a power of two and not zero. If not // control continues at the label not_power_of_two. If reg is a power of two // the register scratch contains the value of (reg - 1) when control falls // through. void JumpIfNotPowerOfTwoOrZero(Register reg, Register scratch, Label* not_power_of_two_or_zero); // Check whether the value of reg is a power of two and not zero. // Control falls through if it is, with scratch containing the mask // value (reg - 1). // Otherwise control jumps to the 'zero_and_neg' label if the value of reg is // zero or negative, or jumps to the 'not_power_of_two' label if the value is // strictly positive but not a power of two. void JumpIfNotPowerOfTwoOrZeroAndNeg(Register reg, Register scratch, Label* zero_and_neg, Label* not_power_of_two); // --------------------------------------------------------------------------- // Smi utilities void SmiTag(Register reg, SBit s = LeaveCC) { add(reg, reg, Operand(reg), s); } void SmiTag(Register dst, Register src, SBit s = LeaveCC) { add(dst, src, Operand(src), s); } // Try to convert int32 to smi. If the value is to large, preserve // the original value and jump to not_a_smi. Destroys scratch and // sets flags. void TrySmiTag(Register reg, Label* not_a_smi, Register scratch) { mov(scratch, reg); SmiTag(scratch, SetCC); b(vs, not_a_smi); mov(reg, scratch); } void SmiUntag(Register reg, SBit s = LeaveCC) { mov(reg, Operand(reg, ASR, kSmiTagSize), s); } void SmiUntag(Register dst, Register src, SBit s = LeaveCC) { mov(dst, Operand(src, ASR, kSmiTagSize), s); } // Untag the source value into destination and jump if source is a smi. // Souce and destination can be the same register. void UntagAndJumpIfSmi(Register dst, Register src, Label* smi_case); // Untag the source value into destination and jump if source is not a smi. // Souce and destination can be the same register. void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case); // Jump the register contains a smi. inline void JumpIfSmi(Register value, Label* smi_label) { tst(value, Operand(kSmiTagMask)); b(eq, smi_label); } // Jump if either of the registers contain a non-smi. inline void JumpIfNotSmi(Register value, Label* not_smi_label) { tst(value, Operand(kSmiTagMask)); b(ne, not_smi_label); } // Jump if either of the registers contain a non-smi. void JumpIfNotBothSmi(Register reg1, Register reg2, Label* on_not_both_smi); // Jump if either of the registers contain a smi. void JumpIfEitherSmi(Register reg1, Register reg2, Label* on_either_smi); // Abort execution if argument is a smi, enabled via --debug-code. void AssertNotSmi(Register object); void AssertSmi(Register object); // Abort execution if argument is a string, enabled via --debug-code. void AssertString(Register object); // Abort execution if argument is not the root value with the given index, // enabled via --debug-code. void AssertRootValue(Register src, Heap::RootListIndex root_value_index, const char* message); // --------------------------------------------------------------------------- // HeapNumber utilities void JumpIfNotHeapNumber(Register object, Register heap_number_map, Register scratch, Label* on_not_heap_number); // --------------------------------------------------------------------------- // String utilities // Checks if both objects are sequential ASCII strings and jumps to label // if either is not. Assumes that neither object is a smi. void JumpIfNonSmisNotBothSequentialAsciiStrings(Register object1, Register object2, Register scratch1, Register scratch2, Label* failure); // Checks if both objects are sequential ASCII strings and jumps to label // if either is not. void JumpIfNotBothSequentialAsciiStrings(Register first, Register second, Register scratch1, Register scratch2, Label* not_flat_ascii_strings); // Checks if both instance types are sequential ASCII strings and jumps to // label if either is not. void JumpIfBothInstanceTypesAreNotSequentialAscii( Register first_object_instance_type, Register second_object_instance_type, Register scratch1, Register scratch2, Label* failure); // Check if instance type is sequential ASCII string and jump to label if // it is not. void JumpIfInstanceTypeIsNotSequentialAscii(Register type, Register scratch, Label* failure); // --------------------------------------------------------------------------- // Patching helpers. // Get the location of a relocated constant (its address in the constant pool) // from its load site. void GetRelocatedValueLocation(Register ldr_location, Register result); void ClampUint8(Register output_reg, Register input_reg); void ClampDoubleToUint8(Register result_reg, DoubleRegister input_reg, DoubleRegister temp_double_reg); void LoadInstanceDescriptors(Register map, Register descriptors); void EnumLength(Register dst, Register map); void NumberOfOwnDescriptors(Register dst, Register map); template void DecodeField(Register reg) { static const int shift = Field::kShift; static const int mask = (Field::kMask >> shift) << kSmiTagSize; mov(reg, Operand(reg, LSR, shift)); and_(reg, reg, Operand(mask)); } // Activation support. void EnterFrame(StackFrame::Type type); void LeaveFrame(StackFrame::Type type); // Expects object in r0 and returns map with validated enum cache // in r0. Assumes that any other register can be used as a scratch. void CheckEnumCache(Register null_value, Label* call_runtime); private: void CallCFunctionHelper(Register function, int num_reg_arguments, int num_double_arguments); void Jump(intptr_t target, RelocInfo::Mode rmode, Condition cond = al); // Helper functions for generating invokes. void InvokePrologue(const ParameterCount& expected, const ParameterCount& actual, Handle code_constant, Register code_reg, Label* done, bool* definitely_mismatches, InvokeFlag flag, const CallWrapper& call_wrapper, CallKind call_kind); void InitializeNewString(Register string, Register length, Heap::RootListIndex map_index, Register scratch1, Register scratch2); // Helper for implementing JumpIfNotInNewSpace and JumpIfInNewSpace. void InNewSpace(Register object, Register scratch, Condition cond, // eq for new space, ne otherwise. Label* branch); // Helper for finding the mark bits for an address. Afterwards, the // bitmap register points at the word with the mark bits and the mask // the position of the first bit. Leaves addr_reg unchanged. inline void GetMarkBits(Register addr_reg, Register bitmap_reg, Register mask_reg); // Helper for throwing exceptions. Compute a handler address and jump to // it. See the implementation for register usage. void JumpToHandlerEntry(); // Compute memory operands for safepoint stack slots. static int SafepointRegisterStackIndex(int reg_code); MemOperand SafepointRegisterSlot(Register reg); MemOperand SafepointRegistersAndDoublesSlot(Register reg); bool generating_stub_; bool allow_stub_calls_; bool has_frame_; // This handle will be patched with the code object on installation. Handle code_object_; // Needs access to SafepointRegisterStackIndex for optimized frame // traversal. friend class OptimizedFrame; }; // The code patcher is used to patch (typically) small parts of code e.g. for // debugging and other types of instrumentation. When using the code patcher // the exact number of bytes specified must be emitted. It is not legal to emit // relocation information. If any of these constraints are violated it causes // an assertion to fail. class CodePatcher { public: CodePatcher(byte* address, int instructions); virtual ~CodePatcher(); // Macro assembler to emit code. MacroAssembler* masm() { return &masm_; } // Emit an instruction directly. void Emit(Instr instr); // Emit an address directly. void Emit(Address addr); // Emit the condition part of an instruction leaving the rest of the current // instruction unchanged. void EmitCondition(Condition cond); private: byte* address_; // The address of the code being patched. int instructions_; // Number of instructions of the expected patch size. int size_; // Number of bytes of the expected patch size. MacroAssembler masm_; // Macro assembler used to generate the code. }; // ----------------------------------------------------------------------------- // Static helper functions. inline MemOperand ContextOperand(Register context, int index) { return MemOperand(context, Context::SlotOffset(index)); } inline MemOperand GlobalObjectOperand() { return ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX); } #ifdef GENERATED_CODE_COVERAGE #define CODE_COVERAGE_STRINGIFY(x) #x #define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x) #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__) #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm-> #else #define ACCESS_MASM(masm) masm-> #endif } } // namespace v8::internal #endif // V8_ARM_MACRO_ASSEMBLER_ARM_H_