OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #if V8_TARGET_ARCH_ARM | 5 #if V8_TARGET_ARCH_ARM |
6 | 6 |
7 #include "src/code-stubs.h" | 7 #include "src/code-stubs.h" |
8 #include "src/api-arguments.h" | 8 #include "src/api-arguments.h" |
9 #include "src/base/bits.h" | 9 #include "src/base/bits.h" |
10 #include "src/bootstrapper.h" | 10 #include "src/bootstrapper.h" |
(...skipping 3039 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3050 __ add(sp, sp, r1); | 3050 __ add(sp, sp, r1); |
3051 __ Ret(); | 3051 __ Ret(); |
3052 } | 3052 } |
3053 | 3053 |
3054 void CallICTrampolineStub::Generate(MacroAssembler* masm) { | 3054 void CallICTrampolineStub::Generate(MacroAssembler* masm) { |
3055 __ EmitLoadTypeFeedbackVector(r2); | 3055 __ EmitLoadTypeFeedbackVector(r2); |
3056 CallICStub stub(isolate(), state()); | 3056 CallICStub stub(isolate(), state()); |
3057 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); | 3057 __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET); |
3058 } | 3058 } |
3059 | 3059 |
3060 | |
3061 static void HandleArrayCases(MacroAssembler* masm, Register feedback, | |
3062 Register receiver_map, Register scratch1, | |
3063 Register scratch2, bool is_polymorphic, | |
3064 Label* miss) { | |
3065 // feedback initially contains the feedback array | |
3066 Label next_loop, prepare_next; | |
3067 Label start_polymorphic; | |
3068 | |
3069 Register cached_map = scratch1; | |
3070 | |
3071 __ ldr(cached_map, | |
3072 FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(0))); | |
3073 __ ldr(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); | |
3074 __ cmp(receiver_map, cached_map); | |
3075 __ b(ne, &start_polymorphic); | |
3076 // found, now call handler. | |
3077 Register handler = feedback; | |
3078 __ ldr(handler, FieldMemOperand(feedback, FixedArray::OffsetOfElementAt(1))); | |
3079 __ add(pc, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); | |
3080 | |
3081 | |
3082 Register length = scratch2; | |
3083 __ bind(&start_polymorphic); | |
3084 __ ldr(length, FieldMemOperand(feedback, FixedArray::kLengthOffset)); | |
3085 if (!is_polymorphic) { | |
3086 // If the IC could be monomorphic we have to make sure we don't go past the | |
3087 // end of the feedback array. | |
3088 __ cmp(length, Operand(Smi::FromInt(2))); | |
3089 __ b(eq, miss); | |
3090 } | |
3091 | |
3092 Register too_far = length; | |
3093 Register pointer_reg = feedback; | |
3094 | |
3095 // +-----+------+------+-----+-----+ ... ----+ | |
3096 // | map | len | wm0 | h0 | wm1 | hN | | |
3097 // +-----+------+------+-----+-----+ ... ----+ | |
3098 // 0 1 2 len-1 | |
3099 // ^ ^ | |
3100 // | | | |
3101 // pointer_reg too_far | |
3102 // aka feedback scratch2 | |
3103 // also need receiver_map | |
3104 // use cached_map (scratch1) to look in the weak map values. | |
3105 __ add(too_far, feedback, Operand::PointerOffsetFromSmiKey(length)); | |
3106 __ add(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag)); | |
3107 __ add(pointer_reg, feedback, | |
3108 Operand(FixedArray::OffsetOfElementAt(2) - kHeapObjectTag)); | |
3109 | |
3110 __ bind(&next_loop); | |
3111 __ ldr(cached_map, MemOperand(pointer_reg)); | |
3112 __ ldr(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); | |
3113 __ cmp(receiver_map, cached_map); | |
3114 __ b(ne, &prepare_next); | |
3115 __ ldr(handler, MemOperand(pointer_reg, kPointerSize)); | |
3116 __ add(pc, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); | |
3117 | |
3118 __ bind(&prepare_next); | |
3119 __ add(pointer_reg, pointer_reg, Operand(kPointerSize * 2)); | |
3120 __ cmp(pointer_reg, too_far); | |
3121 __ b(lt, &next_loop); | |
3122 | |
3123 // We exhausted our array of map handler pairs. | |
3124 __ jmp(miss); | |
3125 } | |
3126 | |
3127 | |
3128 static void HandleMonomorphicCase(MacroAssembler* masm, Register receiver, | |
3129 Register receiver_map, Register feedback, | |
3130 Register vector, Register slot, | |
3131 Register scratch, Label* compare_map, | |
3132 Label* load_smi_map, Label* try_array) { | |
3133 __ JumpIfSmi(receiver, load_smi_map); | |
3134 __ ldr(receiver_map, FieldMemOperand(receiver, HeapObject::kMapOffset)); | |
3135 __ bind(compare_map); | |
3136 Register cached_map = scratch; | |
3137 // Move the weak map into the weak_cell register. | |
3138 __ ldr(cached_map, FieldMemOperand(feedback, WeakCell::kValueOffset)); | |
3139 __ cmp(cached_map, receiver_map); | |
3140 __ b(ne, try_array); | |
3141 Register handler = feedback; | |
3142 __ add(handler, vector, Operand::PointerOffsetFromSmiKey(slot)); | |
3143 __ ldr(handler, | |
3144 FieldMemOperand(handler, FixedArray::kHeaderSize + kPointerSize)); | |
3145 __ add(pc, handler, Operand(Code::kHeaderSize - kHeapObjectTag)); | |
3146 } | |
3147 | |
3148 void KeyedStoreICTrampolineStub::Generate(MacroAssembler* masm) { | |
3149 __ EmitLoadTypeFeedbackVector(StoreWithVectorDescriptor::VectorRegister()); | |
3150 KeyedStoreICStub stub(isolate(), state()); | |
3151 stub.GenerateForTrampoline(masm); | |
3152 } | |
3153 | |
3154 void KeyedStoreICStub::Generate(MacroAssembler* masm) { | |
3155 GenerateImpl(masm, false); | |
3156 } | |
3157 | |
3158 void KeyedStoreICStub::GenerateForTrampoline(MacroAssembler* masm) { | |
3159 GenerateImpl(masm, true); | |
3160 } | |
3161 | |
3162 | |
3163 static void HandlePolymorphicStoreCase(MacroAssembler* masm, Register feedback, | |
3164 Register receiver_map, Register scratch1, | |
3165 Register scratch2, Label* miss) { | |
3166 // feedback initially contains the feedback array | |
3167 Label next_loop, prepare_next; | |
3168 Label start_polymorphic; | |
3169 Label transition_call; | |
3170 | |
3171 Register cached_map = scratch1; | |
3172 Register too_far = scratch2; | |
3173 Register pointer_reg = feedback; | |
3174 __ ldr(too_far, FieldMemOperand(feedback, FixedArray::kLengthOffset)); | |
3175 | |
3176 // +-----+------+------+-----+-----+-----+ ... ----+ | |
3177 // | map | len | wm0 | wt0 | h0 | wm1 | hN | | |
3178 // +-----+------+------+-----+-----+ ----+ ... ----+ | |
3179 // 0 1 2 len-1 | |
3180 // ^ ^ | |
3181 // | | | |
3182 // pointer_reg too_far | |
3183 // aka feedback scratch2 | |
3184 // also need receiver_map | |
3185 // use cached_map (scratch1) to look in the weak map values. | |
3186 __ add(too_far, feedback, Operand::PointerOffsetFromSmiKey(too_far)); | |
3187 __ add(too_far, too_far, Operand(FixedArray::kHeaderSize - kHeapObjectTag)); | |
3188 __ add(pointer_reg, feedback, | |
3189 Operand(FixedArray::OffsetOfElementAt(0) - kHeapObjectTag)); | |
3190 | |
3191 __ bind(&next_loop); | |
3192 __ ldr(cached_map, MemOperand(pointer_reg)); | |
3193 __ ldr(cached_map, FieldMemOperand(cached_map, WeakCell::kValueOffset)); | |
3194 __ cmp(receiver_map, cached_map); | |
3195 __ b(ne, &prepare_next); | |
3196 // Is it a transitioning store? | |
3197 __ ldr(too_far, MemOperand(pointer_reg, kPointerSize)); | |
3198 __ CompareRoot(too_far, Heap::kUndefinedValueRootIndex); | |
3199 __ b(ne, &transition_call); | |
3200 __ ldr(pointer_reg, MemOperand(pointer_reg, kPointerSize * 2)); | |
3201 __ add(pc, pointer_reg, Operand(Code::kHeaderSize - kHeapObjectTag)); | |
3202 | |
3203 __ bind(&transition_call); | |
3204 __ ldr(too_far, FieldMemOperand(too_far, WeakCell::kValueOffset)); | |
3205 __ JumpIfSmi(too_far, miss); | |
3206 | |
3207 __ ldr(receiver_map, MemOperand(pointer_reg, kPointerSize * 2)); | |
3208 | |
3209 // Load the map into the correct register. | |
3210 DCHECK(feedback.is(StoreTransitionDescriptor::MapRegister())); | |
3211 __ mov(feedback, too_far); | |
3212 | |
3213 __ add(pc, receiver_map, Operand(Code::kHeaderSize - kHeapObjectTag)); | |
3214 | |
3215 __ bind(&prepare_next); | |
3216 __ add(pointer_reg, pointer_reg, Operand(kPointerSize * 3)); | |
3217 __ cmp(pointer_reg, too_far); | |
3218 __ b(lt, &next_loop); | |
3219 | |
3220 // We exhausted our array of map handler pairs. | |
3221 __ jmp(miss); | |
3222 } | |
3223 | |
3224 void KeyedStoreICStub::GenerateImpl(MacroAssembler* masm, bool in_frame) { | |
3225 Register receiver = StoreWithVectorDescriptor::ReceiverRegister(); // r1 | |
3226 Register key = StoreWithVectorDescriptor::NameRegister(); // r2 | |
3227 Register vector = StoreWithVectorDescriptor::VectorRegister(); // r3 | |
3228 Register slot = StoreWithVectorDescriptor::SlotRegister(); // r4 | |
3229 DCHECK(StoreWithVectorDescriptor::ValueRegister().is(r0)); // r0 | |
3230 Register feedback = r5; | |
3231 Register receiver_map = r6; | |
3232 Register scratch1 = r9; | |
3233 | |
3234 __ add(feedback, vector, Operand::PointerOffsetFromSmiKey(slot)); | |
3235 __ ldr(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize)); | |
3236 | |
3237 // Try to quickly handle the monomorphic case without knowing for sure | |
3238 // if we have a weak cell in feedback. We do know it's safe to look | |
3239 // at WeakCell::kValueOffset. | |
3240 Label try_array, load_smi_map, compare_map; | |
3241 Label not_array, miss; | |
3242 HandleMonomorphicCase(masm, receiver, receiver_map, feedback, vector, slot, | |
3243 scratch1, &compare_map, &load_smi_map, &try_array); | |
3244 | |
3245 __ bind(&try_array); | |
3246 // Is it a fixed array? | |
3247 __ ldr(scratch1, FieldMemOperand(feedback, HeapObject::kMapOffset)); | |
3248 __ CompareRoot(scratch1, Heap::kFixedArrayMapRootIndex); | |
3249 __ b(ne, ¬_array); | |
3250 | |
3251 // We have a polymorphic element handler. | |
3252 Label polymorphic, try_poly_name; | |
3253 __ bind(&polymorphic); | |
3254 | |
3255 // We are using register r8, which is used for the embedded constant pool | |
3256 // when FLAG_enable_embedded_constant_pool is true. | |
3257 DCHECK(!FLAG_enable_embedded_constant_pool); | |
3258 Register scratch2 = r8; | |
3259 | |
3260 HandlePolymorphicStoreCase(masm, feedback, receiver_map, scratch1, scratch2, | |
3261 &miss); | |
3262 | |
3263 __ bind(¬_array); | |
3264 // Is it generic? | |
3265 __ CompareRoot(feedback, Heap::kmegamorphic_symbolRootIndex); | |
3266 __ b(ne, &try_poly_name); | |
3267 Handle<Code> megamorphic_stub = | |
3268 KeyedStoreIC::ChooseMegamorphicStub(masm->isolate(), GetExtraICState()); | |
3269 __ Jump(megamorphic_stub, RelocInfo::CODE_TARGET); | |
3270 | |
3271 __ bind(&try_poly_name); | |
3272 // We might have a name in feedback, and a fixed array in the next slot. | |
3273 __ cmp(key, feedback); | |
3274 __ b(ne, &miss); | |
3275 // If the name comparison succeeded, we know we have a fixed array with | |
3276 // at least one map/handler pair. | |
3277 __ add(feedback, vector, Operand::PointerOffsetFromSmiKey(slot)); | |
3278 __ ldr(feedback, | |
3279 FieldMemOperand(feedback, FixedArray::kHeaderSize + kPointerSize)); | |
3280 HandleArrayCases(masm, feedback, receiver_map, scratch1, scratch2, false, | |
3281 &miss); | |
3282 | |
3283 __ bind(&miss); | |
3284 KeyedStoreIC::GenerateMiss(masm); | |
3285 | |
3286 __ bind(&load_smi_map); | |
3287 __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex); | |
3288 __ jmp(&compare_map); | |
3289 } | |
3290 | |
3291 | |
3292 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { | 3060 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { |
3293 if (masm->isolate()->function_entry_hook() != NULL) { | 3061 if (masm->isolate()->function_entry_hook() != NULL) { |
3294 ProfileEntryHookStub stub(masm->isolate()); | 3062 ProfileEntryHookStub stub(masm->isolate()); |
3295 PredictableCodeSizeScope predictable(masm); | 3063 PredictableCodeSizeScope predictable(masm); |
3296 predictable.ExpectSize(masm->CallStubSize(&stub) + | 3064 predictable.ExpectSize(masm->CallStubSize(&stub) + |
3297 2 * Assembler::kInstrSize); | 3065 2 * Assembler::kInstrSize); |
3298 __ push(lr); | 3066 __ push(lr); |
3299 __ CallStub(&stub); | 3067 __ CallStub(&stub); |
3300 __ pop(lr); | 3068 __ pop(lr); |
3301 } | 3069 } |
(...skipping 1259 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4561 CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, | 4329 CallApiFunctionAndReturn(masm, api_function_address, thunk_ref, |
4562 kStackUnwindSpace, NULL, return_value_operand, NULL); | 4330 kStackUnwindSpace, NULL, return_value_operand, NULL); |
4563 } | 4331 } |
4564 | 4332 |
4565 #undef __ | 4333 #undef __ |
4566 | 4334 |
4567 } // namespace internal | 4335 } // namespace internal |
4568 } // namespace v8 | 4336 } // namespace v8 |
4569 | 4337 |
4570 #endif // V8_TARGET_ARCH_ARM | 4338 #endif // V8_TARGET_ARCH_ARM |
OLD | NEW |