diff options
Diffstat (limited to 'src/3rdparty/v8/src/arm/macro-assembler-arm.h')
| -rw-r--r-- | src/3rdparty/v8/src/arm/macro-assembler-arm.h | 128 |
1 files changed, 85 insertions, 43 deletions
diff --git a/src/3rdparty/v8/src/arm/macro-assembler-arm.h b/src/3rdparty/v8/src/arm/macro-assembler-arm.h index 5a5469f..0ff8579 100644 --- a/src/3rdparty/v8/src/arm/macro-assembler-arm.h +++ b/src/3rdparty/v8/src/arm/macro-assembler-arm.h @@ -68,6 +68,13 @@ enum AllocationFlags { 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 { @@ -95,6 +102,11 @@ bool AreAliased(Register reg1, #endif +enum TargetAddressStorageMode { + CAN_INLINE_TARGET_ADDRESS, + NEVER_INLINE_TARGET_ADDRESS +}; + // MacroAssembler implements a collection of frequently used macros. class MacroAssembler: public Assembler { public: @@ -110,18 +122,22 @@ class MacroAssembler: public Assembler { void Jump(Handle<Code> code, RelocInfo::Mode rmode, Condition cond = al); static int CallSize(Register target, Condition cond = al); void Call(Register target, Condition cond = al); - static int CallSize(Address target, - RelocInfo::Mode rmode, - Condition cond = al); - void Call(Address target, RelocInfo::Mode rmode, Condition cond = al); - static int CallSize(Handle<Code> code, - RelocInfo::Mode rmode = RelocInfo::CODE_TARGET, - unsigned ast_id = kNoASTId, - 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> code, + RelocInfo::Mode rmode = RelocInfo::CODE_TARGET, + TypeFeedbackId ast_id = TypeFeedbackId::None(), + Condition cond = al); void Call(Handle<Code> code, RelocInfo::Mode rmode = RelocInfo::CODE_TARGET, - unsigned ast_id = kNoASTId, - Condition cond = al); + 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 @@ -153,7 +169,7 @@ class MacroAssembler: public Assembler { int lsb, int width, Condition cond = al); - void Bfc(Register dst, 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); @@ -482,6 +498,7 @@ class MacroAssembler: public Assembler { void Vmov(const DwVfpRegister dst, const double imm, + const Register scratch = no_reg, const Condition cond = al); // Enter exit frame. @@ -499,8 +516,8 @@ class MacroAssembler: public Assembler { void LoadContext(Register dst, int context_chain_length); // Conditionally load the cached Array transitioned map of type - // transitioned_kind from the global context if the map in register - // map_in_out is the cached Array map in the global context of + // 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, @@ -512,7 +529,8 @@ class MacroAssembler: public Assembler { // Load the initial map for new Arrays from a JSFunction. void LoadInitialArrayMap(Register function_in, Register scratch, - Register map_out); + Register map_out, + bool can_have_holes); void LoadGlobalFunction(int index, Register function); @@ -728,7 +746,8 @@ class MacroAssembler: public Assembler { Register scratch1, Register scratch2, Register heap_number_map, - Label* gc_required); + Label* gc_required, + TaggingMode tagging_mode = TAG_RESULT); void AllocateHeapNumberWithValue(Register result, DwVfpRegister value, Register scratch1, @@ -802,9 +821,9 @@ class MacroAssembler: public Assembler { // 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 CheckFastSmiOnlyElements(Register map, - Register scratch, - Label* fail); + 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 @@ -813,6 +832,7 @@ class MacroAssembler: public Assembler { void StoreNumberToDoubleElements(Register value_reg, Register key_reg, Register receiver_reg, + // All regs below here overwritten. Register elements_reg, Register scratch1, Register scratch2, @@ -830,6 +850,13 @@ class MacroAssembler: public Assembler { 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> 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 @@ -866,12 +893,15 @@ class MacroAssembler: public Assembler { // 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. + // Returns a condition that will be enabled if the object was a string + // and the passed-in condition passed. If the passed-in condition failed + // then flags remain unchanged. Condition IsObjectStringType(Register obj, - Register type) { - ldr(type, FieldMemOperand(obj, HeapObject::kMapOffset)); - ldrb(type, FieldMemOperand(type, Map::kInstanceTypeOffset)); - tst(type, Operand(kIsNotStringMask)); + Register type, + Condition cond = al) { + ldr(type, FieldMemOperand(obj, HeapObject::kMapOffset), cond); + ldrb(type, FieldMemOperand(type, Map::kInstanceTypeOffset), cond); + tst(type, Operand(kIsNotStringMask), cond); ASSERT_EQ(0, kStringTag); return eq; } @@ -928,21 +958,22 @@ class MacroAssembler: public Assembler { DwVfpRegister double_scratch, Label *not_int32); - // Truncates a double using a specific rounding mode. + // 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 exact_conversion is true, the z flag is also cleared if the conversion - // was inexact, i.e. if the double value could not be converted exactly - // to a 32bit integer. + // 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, - SwVfpRegister result, + Register result, DwVfpRegister double_input, - Register scratch1, - Register scratch2, + Register scratch, + DwVfpRegister double_scratch, CheckForInexactConversion check = kDontCheckForInexactConversion); // Helper for EmitECMATruncate. - // This will truncate a floating-point value outside of the singed 32bit + // 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'. @@ -1174,7 +1205,7 @@ class MacroAssembler: public Assembler { // Souce and destination can be the same register. void UntagAndJumpIfNotSmi(Register dst, Register src, Label* non_smi_case); - // Jump the register contains a smi. + // Jump if the register contains a smi. inline void JumpIfSmi(Register value, Label* smi_label) { tst(value, Operand(kSmiTagMask)); b(eq, smi_label); @@ -1189,17 +1220,18 @@ class MacroAssembler: public Assembler { // 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. Used in debug code. - void AbortIfSmi(Register object); - void AbortIfNotSmi(Register object); + // 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. Used in debug code. - void AbortIfNotString(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. - void AbortIfNotRootValue(Register src, - Heap::RootListIndex root_value_index, - const char* message); + // 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 @@ -1261,6 +1293,16 @@ class MacroAssembler: public Assembler { void LoadInstanceDescriptors(Register map, Register descriptors); + void EnumLength(Register dst, Register map); + void NumberOfOwnDescriptors(Register dst, Register map); + + template<typename Field> + 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); @@ -1368,12 +1410,12 @@ inline MemOperand ContextOperand(Register context, int index) { inline MemOperand GlobalObjectOperand() { - return ContextOperand(cp, Context::GLOBAL_INDEX); + return ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX); } static inline MemOperand QmlGlobalObjectOperand() { - return ContextOperand(cp, Context::QML_GLOBAL_INDEX); + return ContextOperand(cp, Context::QML_GLOBAL_OBJECT_INDEX); } |