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 3 // found in the LICENSE file. 4 5 #include "src/v8.h" 6 7 #if V8_TARGET_ARCH_X64 8 9 #include "src/codegen.h" 10 #include "src/macro-assembler.h" 11 12 namespace v8 { 13 namespace internal { 14 15 // ------------------------------------------------------------------------- 16 // Platform-specific RuntimeCallHelper functions. 17 18 void StubRuntimeCallHelper::BeforeCall(MacroAssembler* masm) const { 19 masm->EnterFrame(StackFrame::INTERNAL); 20 DCHECK(!masm->has_frame()); 21 masm->set_has_frame(true); 22 } 23 24 25 void StubRuntimeCallHelper::AfterCall(MacroAssembler* masm) const { 26 masm->LeaveFrame(StackFrame::INTERNAL); 27 DCHECK(masm->has_frame()); 28 masm->set_has_frame(false); 29 } 30 31 32 #define __ masm. 33 34 35 UnaryMathFunction CreateExpFunction() { 36 if (!FLAG_fast_math) return &std::exp; 37 size_t actual_size; 38 byte* buffer = 39 static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true)); 40 if (buffer == NULL) return &std::exp; 41 ExternalReference::InitializeMathExpData(); 42 43 MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size)); 44 // xmm0: raw double input. 45 XMMRegister input = xmm0; 46 XMMRegister result = xmm1; 47 __ pushq(rax); 48 __ pushq(rbx); 49 50 MathExpGenerator::EmitMathExp(&masm, input, result, xmm2, rax, rbx); 51 52 __ popq(rbx); 53 __ popq(rax); 54 __ movsd(xmm0, result); 55 __ Ret(); 56 57 CodeDesc desc; 58 masm.GetCode(&desc); 59 DCHECK(!RelocInfo::RequiresRelocation(desc)); 60 61 CpuFeatures::FlushICache(buffer, actual_size); 62 base::OS::ProtectCode(buffer, actual_size); 63 return FUNCTION_CAST<UnaryMathFunction>(buffer); 64 } 65 66 67 UnaryMathFunction CreateSqrtFunction() { 68 size_t actual_size; 69 // Allocate buffer in executable space. 70 byte* buffer = 71 static_cast<byte*>(base::OS::Allocate(1 * KB, &actual_size, true)); 72 if (buffer == NULL) return &std::sqrt; 73 74 MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size)); 75 // xmm0: raw double input. 76 // Move double input into registers. 77 __ sqrtsd(xmm0, xmm0); 78 __ Ret(); 79 80 CodeDesc desc; 81 masm.GetCode(&desc); 82 DCHECK(!RelocInfo::RequiresRelocation(desc)); 83 84 CpuFeatures::FlushICache(buffer, actual_size); 85 base::OS::ProtectCode(buffer, actual_size); 86 return FUNCTION_CAST<UnaryMathFunction>(buffer); 87 } 88 89 90 #ifdef _WIN64 91 typedef double (*ModuloFunction)(double, double); 92 // Define custom fmod implementation. 93 ModuloFunction CreateModuloFunction() { 94 size_t actual_size; 95 byte* buffer = static_cast<byte*>( 96 base::OS::Allocate(Assembler::kMinimalBufferSize, &actual_size, true)); 97 CHECK(buffer); 98 Assembler masm(NULL, buffer, static_cast<int>(actual_size)); 99 // Generated code is put into a fixed, unmovable, buffer, and not into 100 // the V8 heap. We can't, and don't, refer to any relocatable addresses 101 // (e.g. the JavaScript nan-object). 102 103 // Windows 64 ABI passes double arguments in xmm0, xmm1 and 104 // returns result in xmm0. 105 // Argument backing space is allocated on the stack above 106 // the return address. 107 108 // Compute x mod y. 109 // Load y and x (use argument backing store as temporary storage). 110 __ movsd(Operand(rsp, kRegisterSize * 2), xmm1); 111 __ movsd(Operand(rsp, kRegisterSize), xmm0); 112 __ fld_d(Operand(rsp, kRegisterSize * 2)); 113 __ fld_d(Operand(rsp, kRegisterSize)); 114 115 // Clear exception flags before operation. 116 { 117 Label no_exceptions; 118 __ fwait(); 119 __ fnstsw_ax(); 120 // Clear if Illegal Operand or Zero Division exceptions are set. 121 __ testb(rax, Immediate(5)); 122 __ j(zero, &no_exceptions); 123 __ fnclex(); 124 __ bind(&no_exceptions); 125 } 126 127 // Compute st(0) % st(1) 128 { 129 Label partial_remainder_loop; 130 __ bind(&partial_remainder_loop); 131 __ fprem(); 132 __ fwait(); 133 __ fnstsw_ax(); 134 __ testl(rax, Immediate(0x400 /* C2 */)); 135 // If C2 is set, computation only has partial result. Loop to 136 // continue computation. 137 __ j(not_zero, &partial_remainder_loop); 138 } 139 140 Label valid_result; 141 Label return_result; 142 // If Invalid Operand or Zero Division exceptions are set, 143 // return NaN. 144 __ testb(rax, Immediate(5)); 145 __ j(zero, &valid_result); 146 __ fstp(0); // Drop result in st(0). 147 int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000); 148 __ movq(rcx, kNaNValue); 149 __ movq(Operand(rsp, kRegisterSize), rcx); 150 __ movsd(xmm0, Operand(rsp, kRegisterSize)); 151 __ jmp(&return_result); 152 153 // If result is valid, return that. 154 __ bind(&valid_result); 155 __ fstp_d(Operand(rsp, kRegisterSize)); 156 __ movsd(xmm0, Operand(rsp, kRegisterSize)); 157 158 // Clean up FPU stack and exceptions and return xmm0 159 __ bind(&return_result); 160 __ fstp(0); // Unload y. 161 162 Label clear_exceptions; 163 __ testb(rax, Immediate(0x3f /* Any Exception*/)); 164 __ j(not_zero, &clear_exceptions); 165 __ ret(0); 166 __ bind(&clear_exceptions); 167 __ fnclex(); 168 __ ret(0); 169 170 CodeDesc desc; 171 masm.GetCode(&desc); 172 base::OS::ProtectCode(buffer, actual_size); 173 // Call the function from C++ through this pointer. 174 return FUNCTION_CAST<ModuloFunction>(buffer); 175 } 176 177 #endif 178 179 #undef __ 180 181 // ------------------------------------------------------------------------- 182 // Code generators 183 184 #define __ ACCESS_MASM(masm) 185 186 void ElementsTransitionGenerator::GenerateMapChangeElementsTransition( 187 MacroAssembler* masm, 188 Register receiver, 189 Register key, 190 Register value, 191 Register target_map, 192 AllocationSiteMode mode, 193 Label* allocation_memento_found) { 194 // Return address is on the stack. 195 Register scratch = rdi; 196 DCHECK(!AreAliased(receiver, key, value, target_map, scratch)); 197 198 if (mode == TRACK_ALLOCATION_SITE) { 199 DCHECK(allocation_memento_found != NULL); 200 __ JumpIfJSArrayHasAllocationMemento( 201 receiver, scratch, allocation_memento_found); 202 } 203 204 // Set transitioned map. 205 __ movp(FieldOperand(receiver, HeapObject::kMapOffset), target_map); 206 __ RecordWriteField(receiver, 207 HeapObject::kMapOffset, 208 target_map, 209 scratch, 210 kDontSaveFPRegs, 211 EMIT_REMEMBERED_SET, 212 OMIT_SMI_CHECK); 213 } 214 215 216 void ElementsTransitionGenerator::GenerateSmiToDouble( 217 MacroAssembler* masm, 218 Register receiver, 219 Register key, 220 Register value, 221 Register target_map, 222 AllocationSiteMode mode, 223 Label* fail) { 224 // Return address is on the stack. 225 DCHECK(receiver.is(rdx)); 226 DCHECK(key.is(rcx)); 227 DCHECK(value.is(rax)); 228 DCHECK(target_map.is(rbx)); 229 230 // The fail label is not actually used since we do not allocate. 231 Label allocated, new_backing_store, only_change_map, done; 232 233 if (mode == TRACK_ALLOCATION_SITE) { 234 __ JumpIfJSArrayHasAllocationMemento(rdx, rdi, fail); 235 } 236 237 // Check for empty arrays, which only require a map transition and no changes 238 // to the backing store. 239 __ movp(r8, FieldOperand(rdx, JSObject::kElementsOffset)); 240 __ CompareRoot(r8, Heap::kEmptyFixedArrayRootIndex); 241 __ j(equal, &only_change_map); 242 243 __ SmiToInteger32(r9, FieldOperand(r8, FixedDoubleArray::kLengthOffset)); 244 if (kPointerSize == kDoubleSize) { 245 // Check backing store for COW-ness. For COW arrays we have to 246 // allocate a new backing store. 247 __ CompareRoot(FieldOperand(r8, HeapObject::kMapOffset), 248 Heap::kFixedCOWArrayMapRootIndex); 249 __ j(equal, &new_backing_store); 250 } else { 251 // For x32 port we have to allocate a new backing store as SMI size is 252 // not equal with double size. 253 DCHECK(kDoubleSize == 2 * kPointerSize); 254 __ jmp(&new_backing_store); 255 } 256 257 // Check if the backing store is in new-space. If not, we need to allocate 258 // a new one since the old one is in pointer-space. 259 // If in new space, we can reuse the old backing store because it is 260 // the same size. 261 __ JumpIfNotInNewSpace(r8, rdi, &new_backing_store); 262 263 __ movp(r14, r8); // Destination array equals source array. 264 265 // r8 : source FixedArray 266 // r9 : elements array length 267 // r14: destination FixedDoubleArray 268 // Set backing store's map 269 __ LoadRoot(rdi, Heap::kFixedDoubleArrayMapRootIndex); 270 __ movp(FieldOperand(r14, HeapObject::kMapOffset), rdi); 271 272 __ bind(&allocated); 273 // Set transitioned map. 274 __ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx); 275 __ RecordWriteField(rdx, 276 HeapObject::kMapOffset, 277 rbx, 278 rdi, 279 kDontSaveFPRegs, 280 EMIT_REMEMBERED_SET, 281 OMIT_SMI_CHECK); 282 283 // Convert smis to doubles and holes to hole NaNs. The Array's length 284 // remains unchanged. 285 STATIC_ASSERT(FixedDoubleArray::kLengthOffset == FixedArray::kLengthOffset); 286 STATIC_ASSERT(FixedDoubleArray::kHeaderSize == FixedArray::kHeaderSize); 287 288 Label loop, entry, convert_hole; 289 __ movq(r15, bit_cast<int64_t, uint64_t>(kHoleNanInt64)); 290 // r15: the-hole NaN 291 __ jmp(&entry); 292 293 // Allocate new backing store. 294 __ bind(&new_backing_store); 295 __ leap(rdi, Operand(r9, times_8, FixedArray::kHeaderSize)); 296 __ Allocate(rdi, r14, r11, r15, fail, TAG_OBJECT); 297 // Set backing store's map 298 __ LoadRoot(rdi, Heap::kFixedDoubleArrayMapRootIndex); 299 __ movp(FieldOperand(r14, HeapObject::kMapOffset), rdi); 300 // Set receiver's backing store. 301 __ movp(FieldOperand(rdx, JSObject::kElementsOffset), r14); 302 __ movp(r11, r14); 303 __ RecordWriteField(rdx, 304 JSObject::kElementsOffset, 305 r11, 306 r15, 307 kDontSaveFPRegs, 308 EMIT_REMEMBERED_SET, 309 OMIT_SMI_CHECK); 310 // Set backing store's length. 311 __ Integer32ToSmi(r11, r9); 312 __ movp(FieldOperand(r14, FixedDoubleArray::kLengthOffset), r11); 313 __ jmp(&allocated); 314 315 __ bind(&only_change_map); 316 // Set transitioned map. 317 __ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx); 318 __ RecordWriteField(rdx, 319 HeapObject::kMapOffset, 320 rbx, 321 rdi, 322 kDontSaveFPRegs, 323 OMIT_REMEMBERED_SET, 324 OMIT_SMI_CHECK); 325 __ jmp(&done); 326 327 // Conversion loop. 328 __ bind(&loop); 329 __ movp(rbx, 330 FieldOperand(r8, r9, times_pointer_size, FixedArray::kHeaderSize)); 331 // r9 : current element's index 332 // rbx: current element (smi-tagged) 333 __ JumpIfNotSmi(rbx, &convert_hole); 334 __ SmiToInteger32(rbx, rbx); 335 __ Cvtlsi2sd(xmm0, rbx); 336 __ movsd(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize), 337 xmm0); 338 __ jmp(&entry); 339 __ bind(&convert_hole); 340 341 if (FLAG_debug_code) { 342 __ CompareRoot(rbx, Heap::kTheHoleValueRootIndex); 343 __ Assert(equal, kObjectFoundInSmiOnlyArray); 344 } 345 346 __ movq(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize), r15); 347 __ bind(&entry); 348 __ decp(r9); 349 __ j(not_sign, &loop); 350 351 __ bind(&done); 352 } 353 354 355 void ElementsTransitionGenerator::GenerateDoubleToObject( 356 MacroAssembler* masm, 357 Register receiver, 358 Register key, 359 Register value, 360 Register target_map, 361 AllocationSiteMode mode, 362 Label* fail) { 363 // Return address is on the stack. 364 DCHECK(receiver.is(rdx)); 365 DCHECK(key.is(rcx)); 366 DCHECK(value.is(rax)); 367 DCHECK(target_map.is(rbx)); 368 369 Label loop, entry, convert_hole, gc_required, only_change_map; 370 371 if (mode == TRACK_ALLOCATION_SITE) { 372 __ JumpIfJSArrayHasAllocationMemento(rdx, rdi, fail); 373 } 374 375 // Check for empty arrays, which only require a map transition and no changes 376 // to the backing store. 377 __ movp(r8, FieldOperand(rdx, JSObject::kElementsOffset)); 378 __ CompareRoot(r8, Heap::kEmptyFixedArrayRootIndex); 379 __ j(equal, &only_change_map); 380 381 __ Push(rax); 382 383 __ movp(r8, FieldOperand(rdx, JSObject::kElementsOffset)); 384 __ SmiToInteger32(r9, FieldOperand(r8, FixedDoubleArray::kLengthOffset)); 385 // r8 : source FixedDoubleArray 386 // r9 : number of elements 387 __ leap(rdi, Operand(r9, times_pointer_size, FixedArray::kHeaderSize)); 388 __ Allocate(rdi, r11, r14, r15, &gc_required, TAG_OBJECT); 389 // r11: destination FixedArray 390 __ LoadRoot(rdi, Heap::kFixedArrayMapRootIndex); 391 __ movp(FieldOperand(r11, HeapObject::kMapOffset), rdi); 392 __ Integer32ToSmi(r14, r9); 393 __ movp(FieldOperand(r11, FixedArray::kLengthOffset), r14); 394 395 // Prepare for conversion loop. 396 __ movq(rsi, bit_cast<int64_t, uint64_t>(kHoleNanInt64)); 397 __ LoadRoot(rdi, Heap::kTheHoleValueRootIndex); 398 // rsi: the-hole NaN 399 // rdi: pointer to the-hole 400 __ jmp(&entry); 401 402 // Call into runtime if GC is required. 403 __ bind(&gc_required); 404 __ Pop(rax); 405 __ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset)); 406 __ jmp(fail); 407 408 // Box doubles into heap numbers. 409 __ bind(&loop); 410 __ movq(r14, FieldOperand(r8, 411 r9, 412 times_8, 413 FixedDoubleArray::kHeaderSize)); 414 // r9 : current element's index 415 // r14: current element 416 __ cmpq(r14, rsi); 417 __ j(equal, &convert_hole); 418 419 // Non-hole double, copy value into a heap number. 420 __ AllocateHeapNumber(rax, r15, &gc_required); 421 // rax: new heap number 422 __ movq(FieldOperand(rax, HeapNumber::kValueOffset), r14); 423 __ movp(FieldOperand(r11, 424 r9, 425 times_pointer_size, 426 FixedArray::kHeaderSize), 427 rax); 428 __ movp(r15, r9); 429 __ RecordWriteArray(r11, 430 rax, 431 r15, 432 kDontSaveFPRegs, 433 EMIT_REMEMBERED_SET, 434 OMIT_SMI_CHECK); 435 __ jmp(&entry, Label::kNear); 436 437 // Replace the-hole NaN with the-hole pointer. 438 __ bind(&convert_hole); 439 __ movp(FieldOperand(r11, 440 r9, 441 times_pointer_size, 442 FixedArray::kHeaderSize), 443 rdi); 444 445 __ bind(&entry); 446 __ decp(r9); 447 __ j(not_sign, &loop); 448 449 // Replace receiver's backing store with newly created and filled FixedArray. 450 __ movp(FieldOperand(rdx, JSObject::kElementsOffset), r11); 451 __ RecordWriteField(rdx, 452 JSObject::kElementsOffset, 453 r11, 454 r15, 455 kDontSaveFPRegs, 456 EMIT_REMEMBERED_SET, 457 OMIT_SMI_CHECK); 458 __ Pop(rax); 459 __ movp(rsi, Operand(rbp, StandardFrameConstants::kContextOffset)); 460 461 __ bind(&only_change_map); 462 // Set transitioned map. 463 __ movp(FieldOperand(rdx, HeapObject::kMapOffset), rbx); 464 __ RecordWriteField(rdx, 465 HeapObject::kMapOffset, 466 rbx, 467 rdi, 468 kDontSaveFPRegs, 469 OMIT_REMEMBERED_SET, 470 OMIT_SMI_CHECK); 471 } 472 473 474 void StringCharLoadGenerator::Generate(MacroAssembler* masm, 475 Register string, 476 Register index, 477 Register result, 478 Label* call_runtime) { 479 // Fetch the instance type of the receiver into result register. 480 __ movp(result, FieldOperand(string, HeapObject::kMapOffset)); 481 __ movzxbl(result, FieldOperand(result, Map::kInstanceTypeOffset)); 482 483 // We need special handling for indirect strings. 484 Label check_sequential; 485 __ testb(result, Immediate(kIsIndirectStringMask)); 486 __ j(zero, &check_sequential, Label::kNear); 487 488 // Dispatch on the indirect string shape: slice or cons. 489 Label cons_string; 490 __ testb(result, Immediate(kSlicedNotConsMask)); 491 __ j(zero, &cons_string, Label::kNear); 492 493 // Handle slices. 494 Label indirect_string_loaded; 495 __ SmiToInteger32(result, FieldOperand(string, SlicedString::kOffsetOffset)); 496 __ addp(index, result); 497 __ movp(string, FieldOperand(string, SlicedString::kParentOffset)); 498 __ jmp(&indirect_string_loaded, Label::kNear); 499 500 // Handle cons strings. 501 // Check whether the right hand side is the empty string (i.e. if 502 // this is really a flat string in a cons string). If that is not 503 // the case we would rather go to the runtime system now to flatten 504 // the string. 505 __ bind(&cons_string); 506 __ CompareRoot(FieldOperand(string, ConsString::kSecondOffset), 507 Heap::kempty_stringRootIndex); 508 __ j(not_equal, call_runtime); 509 __ movp(string, FieldOperand(string, ConsString::kFirstOffset)); 510 511 __ bind(&indirect_string_loaded); 512 __ movp(result, FieldOperand(string, HeapObject::kMapOffset)); 513 __ movzxbl(result, FieldOperand(result, Map::kInstanceTypeOffset)); 514 515 // Distinguish sequential and external strings. Only these two string 516 // representations can reach here (slices and flat cons strings have been 517 // reduced to the underlying sequential or external string). 518 Label seq_string; 519 __ bind(&check_sequential); 520 STATIC_ASSERT(kSeqStringTag == 0); 521 __ testb(result, Immediate(kStringRepresentationMask)); 522 __ j(zero, &seq_string, Label::kNear); 523 524 // Handle external strings. 525 Label one_byte_external, done; 526 if (FLAG_debug_code) { 527 // Assert that we do not have a cons or slice (indirect strings) here. 528 // Sequential strings have already been ruled out. 529 __ testb(result, Immediate(kIsIndirectStringMask)); 530 __ Assert(zero, kExternalStringExpectedButNotFound); 531 } 532 // Rule out short external strings. 533 STATIC_ASSERT(kShortExternalStringTag != 0); 534 __ testb(result, Immediate(kShortExternalStringTag)); 535 __ j(not_zero, call_runtime); 536 // Check encoding. 537 STATIC_ASSERT(kTwoByteStringTag == 0); 538 __ testb(result, Immediate(kStringEncodingMask)); 539 __ movp(result, FieldOperand(string, ExternalString::kResourceDataOffset)); 540 __ j(not_equal, &one_byte_external, Label::kNear); 541 // Two-byte string. 542 __ movzxwl(result, Operand(result, index, times_2, 0)); 543 __ jmp(&done, Label::kNear); 544 __ bind(&one_byte_external); 545 // One-byte string. 546 __ movzxbl(result, Operand(result, index, times_1, 0)); 547 __ jmp(&done, Label::kNear); 548 549 // Dispatch on the encoding: one-byte or two-byte. 550 Label one_byte; 551 __ bind(&seq_string); 552 STATIC_ASSERT((kStringEncodingMask & kOneByteStringTag) != 0); 553 STATIC_ASSERT((kStringEncodingMask & kTwoByteStringTag) == 0); 554 __ testb(result, Immediate(kStringEncodingMask)); 555 __ j(not_zero, &one_byte, Label::kNear); 556 557 // Two-byte string. 558 // Load the two-byte character code into the result register. 559 STATIC_ASSERT(kSmiTag == 0 && kSmiTagSize == 1); 560 __ movzxwl(result, FieldOperand(string, 561 index, 562 times_2, 563 SeqTwoByteString::kHeaderSize)); 564 __ jmp(&done, Label::kNear); 565 566 // One-byte string. 567 // Load the byte into the result register. 568 __ bind(&one_byte); 569 __ movzxbl(result, FieldOperand(string, 570 index, 571 times_1, 572 SeqOneByteString::kHeaderSize)); 573 __ bind(&done); 574 } 575 576 577 void MathExpGenerator::EmitMathExp(MacroAssembler* masm, 578 XMMRegister input, 579 XMMRegister result, 580 XMMRegister double_scratch, 581 Register temp1, 582 Register temp2) { 583 DCHECK(!input.is(result)); 584 DCHECK(!input.is(double_scratch)); 585 DCHECK(!result.is(double_scratch)); 586 DCHECK(!temp1.is(temp2)); 587 DCHECK(ExternalReference::math_exp_constants(0).address() != NULL); 588 DCHECK(!masm->serializer_enabled()); // External references not serializable. 589 590 Label done; 591 592 __ Move(kScratchRegister, ExternalReference::math_exp_constants(0)); 593 __ movsd(double_scratch, Operand(kScratchRegister, 0 * kDoubleSize)); 594 __ xorpd(result, result); 595 __ ucomisd(double_scratch, input); 596 __ j(above_equal, &done); 597 __ ucomisd(input, Operand(kScratchRegister, 1 * kDoubleSize)); 598 __ movsd(result, Operand(kScratchRegister, 2 * kDoubleSize)); 599 __ j(above_equal, &done); 600 __ movsd(double_scratch, Operand(kScratchRegister, 3 * kDoubleSize)); 601 __ movsd(result, Operand(kScratchRegister, 4 * kDoubleSize)); 602 __ mulsd(double_scratch, input); 603 __ addsd(double_scratch, result); 604 __ movq(temp2, double_scratch); 605 __ subsd(double_scratch, result); 606 __ movsd(result, Operand(kScratchRegister, 6 * kDoubleSize)); 607 __ leaq(temp1, Operand(temp2, 0x1ff800)); 608 __ andq(temp2, Immediate(0x7ff)); 609 __ shrq(temp1, Immediate(11)); 610 __ mulsd(double_scratch, Operand(kScratchRegister, 5 * kDoubleSize)); 611 __ Move(kScratchRegister, ExternalReference::math_exp_log_table()); 612 __ shlq(temp1, Immediate(52)); 613 __ orq(temp1, Operand(kScratchRegister, temp2, times_8, 0)); 614 __ Move(kScratchRegister, ExternalReference::math_exp_constants(0)); 615 __ subsd(double_scratch, input); 616 __ movsd(input, double_scratch); 617 __ subsd(result, double_scratch); 618 __ mulsd(input, double_scratch); 619 __ mulsd(result, input); 620 __ movq(input, temp1); 621 __ mulsd(result, Operand(kScratchRegister, 7 * kDoubleSize)); 622 __ subsd(result, double_scratch); 623 __ addsd(result, Operand(kScratchRegister, 8 * kDoubleSize)); 624 __ mulsd(result, input); 625 626 __ bind(&done); 627 } 628 629 #undef __ 630 631 632 CodeAgingHelper::CodeAgingHelper() { 633 DCHECK(young_sequence_.length() == kNoCodeAgeSequenceLength); 634 // The sequence of instructions that is patched out for aging code is the 635 // following boilerplate stack-building prologue that is found both in 636 // FUNCTION and OPTIMIZED_FUNCTION code: 637 CodePatcher patcher(young_sequence_.start(), young_sequence_.length()); 638 patcher.masm()->pushq(rbp); 639 patcher.masm()->movp(rbp, rsp); 640 patcher.masm()->Push(rsi); 641 patcher.masm()->Push(rdi); 642 } 643 644 645 #ifdef DEBUG 646 bool CodeAgingHelper::IsOld(byte* candidate) const { 647 return *candidate == kCallOpcode; 648 } 649 #endif 650 651 652 bool Code::IsYoungSequence(Isolate* isolate, byte* sequence) { 653 bool result = isolate->code_aging_helper()->IsYoung(sequence); 654 DCHECK(result || isolate->code_aging_helper()->IsOld(sequence)); 655 return result; 656 } 657 658 659 void Code::GetCodeAgeAndParity(Isolate* isolate, byte* sequence, Age* age, 660 MarkingParity* parity) { 661 if (IsYoungSequence(isolate, sequence)) { 662 *age = kNoAgeCodeAge; 663 *parity = NO_MARKING_PARITY; 664 } else { 665 sequence++; // Skip the kCallOpcode byte 666 Address target_address = sequence + *reinterpret_cast<int*>(sequence) + 667 Assembler::kCallTargetAddressOffset; 668 Code* stub = GetCodeFromTargetAddress(target_address); 669 GetCodeAgeAndParity(stub, age, parity); 670 } 671 } 672 673 674 void Code::PatchPlatformCodeAge(Isolate* isolate, 675 byte* sequence, 676 Code::Age age, 677 MarkingParity parity) { 678 uint32_t young_length = isolate->code_aging_helper()->young_sequence_length(); 679 if (age == kNoAgeCodeAge) { 680 isolate->code_aging_helper()->CopyYoungSequenceTo(sequence); 681 CpuFeatures::FlushICache(sequence, young_length); 682 } else { 683 Code* stub = GetCodeAgeStub(isolate, age, parity); 684 CodePatcher patcher(sequence, young_length); 685 patcher.masm()->call(stub->instruction_start()); 686 patcher.masm()->Nop( 687 kNoCodeAgeSequenceLength - Assembler::kShortCallInstructionLength); 688 } 689 } 690 691 692 Operand StackArgumentsAccessor::GetArgumentOperand(int index) { 693 DCHECK(index >= 0); 694 int receiver = (receiver_mode_ == ARGUMENTS_CONTAIN_RECEIVER) ? 1 : 0; 695 int displacement_to_last_argument = base_reg_.is(rsp) ? 696 kPCOnStackSize : kFPOnStackSize + kPCOnStackSize; 697 displacement_to_last_argument += extra_displacement_to_last_argument_; 698 if (argument_count_reg_.is(no_reg)) { 699 // argument[0] is at base_reg_ + displacement_to_last_argument + 700 // (argument_count_immediate_ + receiver - 1) * kPointerSize. 701 DCHECK(argument_count_immediate_ + receiver > 0); 702 return Operand(base_reg_, displacement_to_last_argument + 703 (argument_count_immediate_ + receiver - 1 - index) * kPointerSize); 704 } else { 705 // argument[0] is at base_reg_ + displacement_to_last_argument + 706 // argument_count_reg_ * times_pointer_size + (receiver - 1) * kPointerSize. 707 return Operand(base_reg_, argument_count_reg_, times_pointer_size, 708 displacement_to_last_argument + (receiver - 1 - index) * kPointerSize); 709 } 710 } 711 712 713 } } // namespace v8::internal 714 715 #endif // V8_TARGET_ARCH_X64 716
