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 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #if V8_TARGET_ARCH_IA32 | 7 #if V8_TARGET_ARCH_IA32 |
8 | 8 |
9 #include "src/base/bits.h" | 9 #include "src/base/bits.h" |
10 #include "src/bootstrapper.h" | 10 #include "src/bootstrapper.h" |
(...skipping 2247 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2258 CallFunctionNoFeedback(masm, | 2258 CallFunctionNoFeedback(masm, |
2259 arg_count(), | 2259 arg_count(), |
2260 true, | 2260 true, |
2261 CallAsMethod()); | 2261 CallAsMethod()); |
2262 | 2262 |
2263 // Unreachable. | 2263 // Unreachable. |
2264 __ int3(); | 2264 __ int3(); |
2265 } | 2265 } |
2266 | 2266 |
2267 | 2267 |
2268 void CallIC_RoundStub::Generate(MacroAssembler* masm) { | |
2269 Register function = edi; | |
2270 Register vector = ebx; | |
2271 Register slot = edx; | |
2272 | |
2273 Register temp = eax; | |
2274 XMMRegister xmm_temp1 = xmm0; | |
2275 XMMRegister xmm_temp2 = xmm1; | |
2276 Label tail, miss; | |
2277 | |
2278 // Ensure nobody has snuck in another function. | |
2279 __ BranchIfNotBuiltin(function, temp, kMathRound, &miss); | |
2280 | |
2281 if (arg_count() > 0) { | |
2282 ExternalReference minus_one_half = | |
2283 ExternalReference::address_of_minus_one_half(); | |
2284 | |
2285 __ mov(temp, Operand(esp, arg_count() * kPointerSize)); | |
2286 Handle<Map> map = isolate()->factory()->heap_number_map(); | |
2287 __ CheckMap(temp, map, &tail, DO_SMI_CHECK); | |
2288 | |
2289 // If the number is positive, it doesn't round to -0 | |
2290 __ movsd(xmm_temp1, FieldOperand(eax, HeapNumber::kValueOffset)); | |
2291 | |
2292 // If the number is >0, it doesn't round to -0 | |
2293 __ xorps(xmm_temp2, xmm_temp2); | |
2294 __ ucomisd(xmm_temp1, xmm_temp2); | |
2295 __ j(above, &tail, Label::kNear); | |
2296 | |
2297 // If the number is <-.5, it doesn't round to -0 | |
2298 __ movsd(xmm_temp2, Operand::StaticVariable(minus_one_half)); | |
2299 __ ucomisd(xmm_temp1, xmm_temp2); | |
2300 __ j(below, &tail, Label::kNear); | |
2301 | |
2302 // The only positive result remaining is 0, it doesn't round to -0.. | |
2303 __ movmskpd(temp, xmm_temp1); | |
2304 __ test(temp, Immediate(1)); | |
2305 __ j(zero, &tail, Label::kNear); | |
2306 | |
2307 __ mov(FieldOperand(vector, slot, times_half_pointer_size, | |
2308 FixedArray::kHeaderSize + kPointerSize), | |
2309 Immediate(Smi::FromInt(kHasReturnedMinusZeroSentinel))); | |
2310 } | |
2311 | |
2312 __ bind(&tail); | |
2313 CallFunctionNoFeedback(masm, arg_count(), true, CallAsMethod()); | |
2314 | |
2315 // Unreachable. | |
2316 __ int3(); | |
2317 | |
2318 __ bind(&miss); | |
2319 GenerateMiss(masm); | |
2320 __ jmp(&tail); | |
2321 } | |
2322 | |
2323 | |
2324 void CallIC_FloorStub::Generate(MacroAssembler* masm) { | |
2325 Register function = edi; | |
2326 Register vector = ebx; | |
2327 Register slot = edx; | |
2328 | |
2329 Register temp = eax; | |
2330 Label tail, miss; | |
2331 | |
2332 // Ensure nobody has snuck in another function. | |
2333 __ BranchIfNotBuiltin(function, temp, kMathFloor, &miss); | |
2334 | |
2335 if (arg_count() > 0) { | |
2336 __ mov(temp, Operand(esp, arg_count() * kPointerSize)); | |
2337 Handle<Map> map = isolate()->factory()->heap_number_map(); | |
2338 __ CheckMap(temp, map, &tail, DO_SMI_CHECK); | |
2339 | |
2340 // The only number that floors to -0 is -0. | |
2341 __ cmp(FieldOperand(temp, HeapNumber::kExponentOffset), | |
2342 Immediate(0x80000000)); | |
2343 __ j(not_equal, &tail); | |
2344 | |
2345 __ cmp(FieldOperand(temp, HeapNumber::kMantissaOffset), Immediate(0)); | |
2346 __ j(not_equal, &tail); | |
2347 | |
2348 __ mov(FieldOperand(vector, slot, times_half_pointer_size, | |
2349 FixedArray::kHeaderSize + kPointerSize), | |
2350 Immediate(Smi::FromInt(kHasReturnedMinusZeroSentinel))); | |
2351 } | |
2352 | |
2353 __ bind(&tail); | |
2354 CallFunctionNoFeedback(masm, arg_count(), true, CallAsMethod()); | |
2355 | |
2356 // Unreachable. | |
2357 __ int3(); | |
2358 | |
2359 __ bind(&miss); | |
2360 GenerateMiss(masm); | |
2361 __ jmp(&tail); | |
2362 } | |
2363 | |
2364 | |
2365 void CallIC_CeilStub::Generate(MacroAssembler* masm) { | |
2366 Register function = edi; | |
2367 Register vector = ebx; | |
2368 Register slot = edx; | |
2369 | |
2370 Register temp = eax; | |
2371 XMMRegister xmm_temp1 = xmm0; | |
2372 XMMRegister xmm_temp2 = xmm1; | |
2373 Label tail, miss; | |
2374 | |
2375 // Ensure nobody has snuck in another function. | |
2376 __ BranchIfNotBuiltin(function, temp, kMathCeil, &miss); | |
2377 | |
2378 if (arg_count() > 0) { | |
2379 ExternalReference minus_one = ExternalReference::address_of_minus_one(); | |
2380 | |
2381 __ mov(temp, Operand(esp, arg_count() * kPointerSize)); | |
2382 Handle<Map> map = isolate()->factory()->heap_number_map(); | |
2383 __ CheckMap(temp, map, &tail, DO_SMI_CHECK); | |
2384 | |
2385 __ movsd(xmm_temp1, FieldOperand(eax, HeapNumber::kValueOffset)); | |
2386 | |
2387 // If the number is >0, it doesn't round to -0 | |
2388 __ xorps(xmm_temp2, xmm_temp2); | |
2389 __ ucomisd(xmm_temp1, xmm_temp2); | |
2390 __ j(greater, &tail, Label::kNear); | |
2391 | |
2392 // If the number is <=-1, it doesn't round to -0 | |
2393 __ movsd(xmm_temp2, Operand::StaticVariable(minus_one)); | |
2394 __ ucomisd(xmm_temp1, xmm_temp2); | |
2395 __ j(less_equal, &tail, Label::kNear); | |
2396 | |
2397 // The only positive result remaining is 0, it doesn't round to -0.. | |
2398 __ movmskpd(temp, xmm_temp1); | |
2399 __ test(temp, Immediate(1)); | |
2400 __ j(zero, &tail, Label::kNear); | |
2401 | |
2402 __ mov(FieldOperand(vector, slot, times_half_pointer_size, | |
2403 FixedArray::kHeaderSize + kPointerSize), | |
2404 Immediate(Smi::FromInt(kHasReturnedMinusZeroSentinel))); | |
2405 } | |
2406 | |
2407 __ bind(&tail); | |
2408 CallFunctionNoFeedback(masm, arg_count(), true, CallAsMethod()); | |
2409 | |
2410 // Unreachable. | |
2411 __ int3(); | |
2412 | |
2413 __ bind(&miss); | |
2414 GenerateMiss(masm); | |
2415 __ jmp(&tail); | |
2416 } | |
2417 | |
2418 | |
2419 void CallICStub::Generate(MacroAssembler* masm) { | 2268 void CallICStub::Generate(MacroAssembler* masm) { |
2420 // edi - function | 2269 // edi - function |
2421 // edx - slot id | 2270 // edx - slot id |
2422 // ebx - vector | 2271 // ebx - vector |
2423 Isolate* isolate = masm->isolate(); | 2272 Isolate* isolate = masm->isolate(); |
2424 const int with_types_offset = | 2273 const int with_types_offset = |
2425 FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex); | 2274 FixedArray::OffsetOfElementAt(TypeFeedbackVector::kWithTypesIndex); |
2426 const int generic_offset = | 2275 const int generic_offset = |
2427 FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex); | 2276 FixedArray::OffsetOfElementAt(TypeFeedbackVector::kGenericCountIndex); |
2428 Label extra_checks_or_miss, slow_start; | 2277 Label extra_checks_or_miss, slow_start; |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2517 // Goto miss case if we do not have a function. | 2366 // Goto miss case if we do not have a function. |
2518 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx); | 2367 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx); |
2519 __ j(not_equal, &miss); | 2368 __ j(not_equal, &miss); |
2520 | 2369 |
2521 // Make sure the function is not the Array() function, which requires special | 2370 // Make sure the function is not the Array() function, which requires special |
2522 // behavior on MISS. | 2371 // behavior on MISS. |
2523 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, ecx); | 2372 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, ecx); |
2524 __ cmp(edi, ecx); | 2373 __ cmp(edi, ecx); |
2525 __ j(equal, &miss); | 2374 __ j(equal, &miss); |
2526 | 2375 |
2527 // Make sure that the function is not Math.floor, Math.round or Math.ceil | |
2528 // which have special CallICs to handle -0.0. | |
2529 __ mov(eax, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset)); | |
2530 __ mov(eax, FieldOperand(eax, SharedFunctionInfo::kFunctionDataOffset)); | |
2531 __ cmp(eax, Immediate(Smi::FromInt(0))); | |
2532 __ j(not_equal, &miss); | |
2533 | |
2534 // Update stats. | 2376 // Update stats. |
2535 __ add(FieldOperand(ebx, with_types_offset), Immediate(Smi::FromInt(1))); | 2377 __ add(FieldOperand(ebx, with_types_offset), Immediate(Smi::FromInt(1))); |
2536 | 2378 |
2537 // Store the function. Use a stub since we need a frame for allocation. | 2379 // Store the function. Use a stub since we need a frame for allocation. |
2538 // ebx - vector | 2380 // ebx - vector |
2539 // edx - slot | 2381 // edx - slot |
2540 // edi - function | 2382 // edi - function |
2541 { | 2383 { |
2542 FrameScope scope(masm, StackFrame::INTERNAL); | 2384 FrameScope scope(masm, StackFrame::INTERNAL); |
2543 CreateWeakCellStub create_stub(isolate); | 2385 CreateWeakCellStub create_stub(isolate); |
(...skipping 2255 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4799 } | 4641 } |
4800 | 4642 |
4801 | 4643 |
4802 void CallIC_ArrayTrampolineStub::Generate(MacroAssembler* masm) { | 4644 void CallIC_ArrayTrampolineStub::Generate(MacroAssembler* masm) { |
4803 EmitLoadTypeFeedbackVector(masm, ebx); | 4645 EmitLoadTypeFeedbackVector(masm, ebx); |
4804 CallIC_ArrayStub stub(isolate(), state()); | 4646 CallIC_ArrayStub stub(isolate(), state()); |
4805 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | 4647 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); |
4806 } | 4648 } |
4807 | 4649 |
4808 | 4650 |
4809 void CallIC_RoundTrampolineStub::Generate(MacroAssembler* masm) { | |
4810 EmitLoadTypeFeedbackVector(masm, ebx); | |
4811 CallIC_RoundStub stub(isolate(), state()); | |
4812 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | |
4813 } | |
4814 | |
4815 | |
4816 void CallIC_FloorTrampolineStub::Generate(MacroAssembler* masm) { | |
4817 EmitLoadTypeFeedbackVector(masm, ebx); | |
4818 CallIC_FloorStub stub(isolate(), state()); | |
4819 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | |
4820 } | |
4821 | |
4822 | |
4823 void CallIC_CeilTrampolineStub::Generate(MacroAssembler* masm) { | |
4824 EmitLoadTypeFeedbackVector(masm, ebx); | |
4825 CallIC_CeilStub stub(isolate(), state()); | |
4826 __ jmp(stub.GetCode(), RelocInfo::CODE_TARGET); | |
4827 } | |
4828 | |
4829 | |
4830 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { | 4651 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) { |
4831 if (masm->isolate()->function_entry_hook() != NULL) { | 4652 if (masm->isolate()->function_entry_hook() != NULL) { |
4832 ProfileEntryHookStub stub(masm->isolate()); | 4653 ProfileEntryHookStub stub(masm->isolate()); |
4833 masm->CallStub(&stub); | 4654 masm->CallStub(&stub); |
4834 } | 4655 } |
4835 } | 4656 } |
4836 | 4657 |
4837 | 4658 |
4838 void ProfileEntryHookStub::Generate(MacroAssembler* masm) { | 4659 void ProfileEntryHookStub::Generate(MacroAssembler* masm) { |
4839 // Save volatile registers. | 4660 // Save volatile registers. |
(...skipping 746 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5586 ApiParameterOperand(2), kStackSpace, nullptr, | 5407 ApiParameterOperand(2), kStackSpace, nullptr, |
5587 Operand(ebp, 7 * kPointerSize), NULL); | 5408 Operand(ebp, 7 * kPointerSize), NULL); |
5588 } | 5409 } |
5589 | 5410 |
5590 | 5411 |
5591 #undef __ | 5412 #undef __ |
5592 | 5413 |
5593 } } // namespace v8::internal | 5414 } } // namespace v8::internal |
5594 | 5415 |
5595 #endif // V8_TARGET_ARCH_IA32 | 5416 #endif // V8_TARGET_ARCH_IA32 |
OLD | NEW |