Changeset 85271 in webkit
- Timestamp:
- Apr 28, 2011 5:30:34 PM (13 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 12 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r85265 r85271 1 2011-04-28 Gavin Barraclough <barraclough@apple.com> 2 3 Reviewed by Oliver Hunt. 4 5 https://bugs.webkit.org/show_bug.cgi?id=59763 6 DFG JIT - Unify FPRReg & FPRegisterID 7 8 (Following on from GPRReg/RegisterID unification). 9 10 * dfg/DFGFPRInfo.h: 11 (JSC::DFG::FPRInfo::toRegister): 12 (JSC::DFG::FPRInfo::debugName): 13 * dfg/DFGGPRInfo.h: 14 * dfg/DFGJITCodeGenerator.cpp: 15 (JSC::DFG::JITCodeGenerator::fillDouble): 16 (JSC::DFG::JITCodeGenerator::checkConsistency): 17 * dfg/DFGJITCodeGenerator.h: 18 (JSC::DFG::JITCodeGenerator::boxDouble): 19 (JSC::DFG::JITCodeGenerator::unboxDouble): 20 (JSC::DFG::JITCodeGenerator::flushRegisters): 21 (JSC::DFG::JITCodeGenerator::isFlushed): 22 (JSC::DFG::JITCodeGenerator::setupTwoStubArgs): 23 (JSC::DFG::JITCodeGenerator::setupStubArguments): 24 (JSC::DFG::JITCodeGenerator::callOperation): 25 (JSC::DFG::GPRResult::lockedResult): 26 (JSC::DFG::FPRResult::lockedResult): 27 * dfg/DFGJITCompiler.cpp: 28 (JSC::DFG::JITCompiler::fillNumericToDouble): 29 (JSC::DFG::JITCompiler::jumpFromSpeculativeToNonSpeculative): 30 (JSC::DFG::JITCompiler::compileFunction): 31 * dfg/DFGJITCompiler.h: 32 * dfg/DFGNode.h: 33 * dfg/DFGNonSpeculativeJIT.cpp: 34 (JSC::DFG::EntryLocation::EntryLocation): 35 (JSC::DFG::NonSpeculativeJIT::valueToNumber): 36 (JSC::DFG::NonSpeculativeJIT::valueToInt32): 37 (JSC::DFG::NonSpeculativeJIT::numberToInt32): 38 (JSC::DFG::NonSpeculativeJIT::compile): 39 * dfg/DFGNonSpeculativeJIT.h: 40 (JSC::DFG::NonSpeculativeJIT::silentSpillAllRegisters): 41 (JSC::DFG::NonSpeculativeJIT::silentFillAllRegisters): 42 * dfg/DFGRegisterBank.h: 43 (JSC::DFG::RegisterBank::iterator::regID): 44 (JSC::DFG::RegisterBank::iterator::debugName): 45 * dfg/DFGSpeculativeJIT.cpp: 46 (JSC::DFG::SpeculationCheck::SpeculationCheck): 47 (JSC::DFG::SpeculativeJIT::compile): 48 * dfg/DFGSpeculativeJIT.h: 49 1 50 2011-04-28 David Kilzer <ddkilzer@apple.com> 2 51 -
trunk/Source/JavaScriptCore/dfg/DFGFPRInfo.h
r85249 r85271 34 34 namespace JSC { namespace DFG { 35 35 36 // Abstracted sequential numbering of available machine registers (as opposed to GPRReg, 37 // which are non-sequential, and not abstracted from the register numbering used by the underlying processor). 38 enum FPRReg { fpr0, fpr1, fpr2, fpr3, fpr4, fpr5, numberOfFPRs, InvalidFPRReg = 0xFFFFFFFF }; 36 typedef MacroAssembler::FPRegisterID FPRReg; 37 #define InvalidFPRReg ((FPRReg)-1) 39 38 40 inline FPRReg next(FPRReg& reg) 41 { 42 ASSERT(reg < numberOfFPRs); 43 return reg = static_cast<FPRReg>(reg + 1); 44 } 45 46 class FPRBankInfo { 39 class FPRInfo { 47 40 public: 48 41 typedef FPRReg RegisterType; 49 42 static const unsigned numberOfRegisters = 6; 50 43 44 // Temporary registers. 45 static const FPRReg fpRegT0 = X86Registers::xmm0; 46 static const FPRReg fpRegT1 = X86Registers::xmm1; 47 static const FPRReg fpRegT2 = X86Registers::xmm2; 48 static const FPRReg fpRegT3 = X86Registers::xmm3; 49 static const FPRReg fpRegT4 = X86Registers::xmm4; 50 static const FPRReg fpRegT5 = X86Registers::xmm5; 51 // These constants provide the names for the general purpose argument & return value registers. 52 static const FPRReg argumentFPR0 = X86Registers::xmm0; // fpRegT0 53 static const FPRReg argumentFPR1 = X86Registers::xmm1; // fpRegT1 54 static const FPRReg argumentFPR2 = X86Registers::xmm2; // fpRegT2 55 static const FPRReg argumentFPR3 = X86Registers::xmm3; // fpRegT3 56 static const FPRReg returnValueFPR = X86Registers::xmm0; // fpRegT0 57 58 // FPRReg mapping is direct, the machine regsiter numbers can 59 // be used directly as indices into the FPR RegisterBank. 60 COMPILE_ASSERT(X86Registers::xmm0 == 0, xmm0_is_0); 61 COMPILE_ASSERT(X86Registers::xmm1 == 1, xmm1_is_1); 62 COMPILE_ASSERT(X86Registers::xmm2 == 2, xmm2_is_2); 63 COMPILE_ASSERT(X86Registers::xmm3 == 3, xmm3_is_3); 64 COMPILE_ASSERT(X86Registers::xmm4 == 4, xmm4_is_4); 65 COMPILE_ASSERT(X86Registers::xmm5 == 5, xmm5_is_5); 51 66 static FPRReg toRegister(unsigned index) 52 67 { 53 68 return (FPRReg)index; 54 69 } 55 56 70 static unsigned toIndex(FPRReg reg) 57 71 { 58 72 return (unsigned)reg; 59 73 } 74 75 #ifndef NDEBUG 76 static const char* debugName(FPRReg reg) 77 { 78 ASSERT(reg != InvalidFPRReg); 79 ASSERT(reg < 16); 80 static const char* nameForRegister[16] = { 81 "xmm0", "xmm1", "xmm2", "xmm3", 82 "xmm4", "xmm5", "xmm6", "xmm7", 83 "xmm8", "xmm9", "xmm10", "xmm11", 84 "xmm12", "xmm13", "xmm14", "xmm15" 85 }; 86 return nameForRegister[reg]; 87 } 88 #endif 60 89 }; 61 90 62 typedef RegisterBank<FPR BankInfo>::iterator fpr_iterator;91 typedef RegisterBank<FPRInfo>::iterator fpr_iterator; 63 92 64 93 } } // namespace JSC::DFG -
trunk/Source/JavaScriptCore/dfg/DFGGPRInfo.h
r85249 r85271 58 58 static const GPRReg regT8 = X86Registers::r10; 59 59 // These constants provide the names for the general purpose argument & return value registers. 60 static const GPRReg argument Register0 = X86Registers::edi; // regT461 static const GPRReg argument Register1 = X86Registers::esi; // regT562 static const GPRReg argument Register2 = X86Registers::edx; // regT163 static const GPRReg argument Register3 = X86Registers::ecx; // regT264 static const GPRReg returnValue Register= X86Registers::eax; // regT065 static const GPRReg returnValue Register2 = X86Registers::edx; // regT160 static const GPRReg argumentGPR0 = X86Registers::edi; // regT4 61 static const GPRReg argumentGPR1 = X86Registers::esi; // regT5 62 static const GPRReg argumentGPR2 = X86Registers::edx; // regT1 63 static const GPRReg argumentGPR3 = X86Registers::ecx; // regT2 64 static const GPRReg returnValueGPR = X86Registers::eax; // regT0 65 static const GPRReg returnValueGPR2 = X86Registers::edx; // regT1 66 66 67 67 static GPRReg toRegister(unsigned index) -
trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.cpp
r85249 r85271 124 124 FPRReg fpr = fprAllocate(); 125 125 m_jit.move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), gpr); 126 m_jit.movePtrToDouble(gpr, JITCompiler::fprToRegisterID(fpr));126 m_jit.movePtrToDouble(gpr, fpr); 127 127 unlock(gpr); 128 128 … … 163 163 GPRReg tempGpr = allocate(); // FIXME: can we skip this allocation on the last use of the virtual register? 164 164 165 JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);166 167 165 JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister); 168 166 … … 172 170 m_jit.move(jsValueGpr, tempGpr); 173 171 m_jit.addPtr(GPRInfo::tagTypeNumberRegister, tempGpr); 174 m_jit.movePtrToDouble(tempGpr, fp Reg);172 m_jit.movePtrToDouble(tempGpr, fpr); 175 173 JITCompiler::Jump hasUnboxedDouble = m_jit.jump(); 176 174 177 175 // Finally, handle integers. 178 176 isInteger.link(&m_jit); 179 m_jit.convertInt32ToDouble(jsValueGpr, fp Reg);177 m_jit.convertInt32ToDouble(jsValueGpr, fpr); 180 178 hasUnboxedDouble.link(&m_jit); 181 179 … … 193 191 GPRReg gpr = info.gpr(); 194 192 m_gprs.lock(gpr); 195 GPRReg reg = gpr; 196 JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr); 197 198 m_jit.convertInt32ToDouble(reg, fpReg); 193 194 m_jit.convertInt32ToDouble(gpr, fpr); 199 195 200 196 m_gprs.release(gpr); … … 396 392 } 397 393 } 398 for ( FPRReg i = fpr0; i < numberOfFPRs; next(i)) {399 if ( m_fprs.isLocked(i)) {400 fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: fpr % d is locked.\n", i);394 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 395 if (iter.isLocked()) { 396 fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: fpr %s is locked.\n", iter.debugName()); 401 397 failed = true; 402 398 } 403 399 } 404 400 405 VirtualRegister fprContents[numberOfFPRs];406 407 for (unsigned i = 0; i < numberOfFPRs; ++i)408 fprContents[i] = InvalidVirtualRegister;409 401 for (unsigned i = 0; i < m_generationInfo.size(); ++i) { 410 402 VirtualRegister virtualRegister = (VirtualRegister)i; … … 432 424 FPRReg fpr = info.fpr(); 433 425 ASSERT(fpr != InvalidFPRReg); 434 fprContents[fpr] = virtualRegister; 426 if (m_fprs.name(fpr) != virtualRegister) { 427 fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (fpr %s).\n", virtualRegister, FPRInfo::debugName(fpr)); 428 failed = true; 429 } 435 430 break; 436 431 } … … 444 439 445 440 GenerationInfo& info = m_generationInfo[virtualRegister]; 446 if (iter. gpr() != info.gpr()) {441 if (iter.regID() != info.gpr()) { 447 442 fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister); 448 443 failed = true; 449 444 } 450 445 } 451 for (FPRReg i = fpr0; i < numberOfFPRs; next(i)) { 452 if (m_fprs.name(i) != fprContents[i]) { 453 fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %d (%d != %d).\n", i, m_fprs.name(i), fprContents[i]); 446 447 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 448 VirtualRegister virtualRegister = iter.name(); 449 if (virtualRegister == InvalidVirtualRegister) 450 continue; 451 452 GenerationInfo& info = m_generationInfo[virtualRegister]; 453 if (iter.regID() != info.fpr()) { 454 fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %s (virtual register %d).\n", iter.debugName(), virtualRegister); 454 455 failed = true; 455 456 } -
trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.h
r85249 r85271 53 53 typedef MacroAssembler::TrustedImm32 TrustedImm32; 54 54 typedef MacroAssembler::Imm32 Imm32; 55 typedef MacroAssembler::FPRegisterID FPRegisterID;56 55 57 56 // These constants are used to set priorities for spill order for … … 158 157 GPRReg boxDouble(FPRReg fpr, GPRReg gpr) 159 158 { 160 JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr); 161 m_jit.moveDoubleToPtr(fpReg, gpr); 159 m_jit.moveDoubleToPtr(fpr, gpr); 162 160 m_jit.subPtr(GPRInfo::tagTypeNumberRegister, gpr); 163 161 return gpr; … … 165 163 FPRReg unboxDouble(GPRReg gpr, FPRReg fpr) 166 164 { 167 JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);168 165 m_jit.addPtr(GPRInfo::tagTypeNumberRegister, gpr); 169 m_jit.movePtrToDouble(gpr, fp Reg);166 m_jit.movePtrToDouble(gpr, fpr); 170 167 return fpr; 171 168 } … … 257 254 } 258 255 } 259 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 260 VirtualRegister name = m_fprs.name(fpr); 261 if (name != InvalidVirtualRegister) { 262 spill(name); 263 m_fprs.release(fpr); 256 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 257 if (iter.name() != InvalidVirtualRegister) { 258 spill(iter.name()); 259 iter.release(); 264 260 } 265 261 } … … 275 271 return false; 276 272 } 277 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 278 VirtualRegister name = m_fprs.name(fpr); 279 if (name != InvalidVirtualRegister) 273 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 274 if (iter.name() != InvalidVirtualRegister) 280 275 return false; 281 276 } … … 486 481 if (srcB != destA) { 487 482 // Handle the easy cases - two simple moves. 488 m_jit.moveDouble( JITCompiler::fprToRegisterID(srcA), JITCompiler::fprToRegisterID(destA));489 m_jit.moveDouble( JITCompiler::fprToRegisterID(srcB), JITCompiler::fprToRegisterID(destB));483 m_jit.moveDouble(srcA, destA); 484 m_jit.moveDouble(srcB, destB); 490 485 return; 491 486 } … … 493 488 if (srcA != destB) { 494 489 // Handle the non-swap case - just put srcB in place first. 495 m_jit.moveDouble( JITCompiler::fprToRegisterID(srcB), JITCompiler::fprToRegisterID(destB));496 m_jit.moveDouble( JITCompiler::fprToRegisterID(srcA), JITCompiler::fprToRegisterID(destA));490 m_jit.moveDouble(srcB, destB); 491 m_jit.moveDouble(srcA, destA); 497 492 return; 498 493 } … … 501 496 // Need to swap; pick a temporary register. 502 497 FPRReg temp; 503 if (destA != JITCompiler::argumentFPR3 && destA != JITCompiler::argumentFPR3)504 temp = JITCompiler::argumentFPR3;505 else if (destA != JITCompiler::argumentFPR2 && destA != JITCompiler::argumentFPR2)506 temp = JITCompiler::argumentFPR2;498 if (destA != FPRInfo::argumentFPR3 && destA != FPRInfo::argumentFPR3) 499 temp = FPRInfo::argumentFPR3; 500 else if (destA != FPRInfo::argumentFPR2 && destA != FPRInfo::argumentFPR2) 501 temp = FPRInfo::argumentFPR2; 507 502 else { 508 ASSERT(destA != JITCompiler::argumentFPR1 && destA != JITCompiler::argumentFPR1);509 temp = JITCompiler::argumentFPR1;510 } 511 m_jit.moveDouble( JITCompiler::fprToRegisterID(destA), JITCompiler::fprToRegisterID(temp));512 m_jit.moveDouble( JITCompiler::fprToRegisterID(destB), JITCompiler::fprToRegisterID(destA));513 m_jit.moveDouble( JITCompiler::fprToRegisterID(temp), JITCompiler::fprToRegisterID(destB));503 ASSERT(destA != FPRInfo::argumentFPR1 && destA != FPRInfo::argumentFPR1); 504 temp = FPRInfo::argumentFPR1; 505 } 506 m_jit.moveDouble(destA, temp); 507 m_jit.moveDouble(destB, destA); 508 m_jit.moveDouble(temp, destB); 514 509 } 515 510 void setupStubArguments(GPRReg arg1, GPRReg arg2) 516 511 { 517 setupTwoStubArgs<GPRInfo::argument Register1, GPRInfo::argumentRegister2>(arg1, arg2);512 setupTwoStubArgs<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2); 518 513 } 519 514 void setupStubArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3) … … 521 516 // If neither of arg2/arg3 are in our way, then we can move arg1 into place. 522 517 // Then we can use setupTwoStubArgs to fix arg2/arg3. 523 if (arg2 != GPRInfo::argument Register1 && arg3 != GPRInfo::argumentRegister1) {524 m_jit.move(arg1, GPRInfo::argument Register1);525 setupTwoStubArgs<GPRInfo::argument Register2, GPRInfo::argumentRegister3>(arg2, arg3);518 if (arg2 != GPRInfo::argumentGPR1 && arg3 != GPRInfo::argumentGPR1) { 519 m_jit.move(arg1, GPRInfo::argumentGPR1); 520 setupTwoStubArgs<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3); 526 521 return; 527 522 } … … 529 524 // If neither of arg1/arg3 are in our way, then we can move arg2 into place. 530 525 // Then we can use setupTwoStubArgs to fix arg1/arg3. 531 if (arg1 != GPRInfo::argument Register2 && arg3 != GPRInfo::argumentRegister2) {532 m_jit.move(arg2, GPRInfo::argument Register2);533 setupTwoStubArgs<GPRInfo::argument Register1, GPRInfo::argumentRegister3>(arg1, arg3);526 if (arg1 != GPRInfo::argumentGPR2 && arg3 != GPRInfo::argumentGPR2) { 527 m_jit.move(arg2, GPRInfo::argumentGPR2); 528 setupTwoStubArgs<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3); 534 529 return; 535 530 } … … 537 532 // If neither of arg1/arg2 are in our way, then we can move arg3 into place. 538 533 // Then we can use setupTwoStubArgs to fix arg1/arg2. 539 if (arg1 != GPRInfo::argument Register3 && arg2 != GPRInfo::argumentRegister3) {540 m_jit.move(arg3, GPRInfo::argument Register3);541 setupTwoStubArgs<GPRInfo::argument Register1, GPRInfo::argumentRegister2>(arg1, arg2);534 if (arg1 != GPRInfo::argumentGPR3 && arg2 != GPRInfo::argumentGPR3) { 535 m_jit.move(arg3, GPRInfo::argumentGPR3); 536 setupTwoStubArgs<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2); 542 537 return; 543 538 } … … 548 543 549 544 // First, ensure arg1 is in place. 550 if (arg1 != GPRInfo::argument Register1) {551 m_jit.swap(arg1, GPRInfo::argument Register1);552 553 // If arg1 wasn't in argument Register1, one of arg2/arg3 must be.554 ASSERT(arg2 == GPRInfo::argument Register1 || arg3 == GPRInfo::argumentRegister1);555 // If arg2 was in argument Register1 it no longer is (due to the swap).545 if (arg1 != GPRInfo::argumentGPR1) { 546 m_jit.swap(arg1, GPRInfo::argumentGPR1); 547 548 // If arg1 wasn't in argumentGPR1, one of arg2/arg3 must be. 549 ASSERT(arg2 == GPRInfo::argumentGPR1 || arg3 == GPRInfo::argumentGPR1); 550 // If arg2 was in argumentGPR1 it no longer is (due to the swap). 556 551 // Otherwise arg3 must have been. Mark him as moved. 557 if (arg2 == GPRInfo::argument Register1)552 if (arg2 == GPRInfo::argumentGPR1) 558 553 arg2 = arg1; 559 554 else … … 562 557 563 558 // Either arg2 & arg3 need swapping, or we're all done. 564 ASSERT((arg2 == GPRInfo::argument Register2 || arg3 == GPRInfo::argumentRegister3)565 || (arg2 == GPRInfo::argument Register3 || arg3 == GPRInfo::argumentRegister2));566 567 if (arg2 != GPRInfo::argument Register2)568 m_jit.swap(GPRInfo::argument Register2, GPRInfo::argumentRegister3);559 ASSERT((arg2 == GPRInfo::argumentGPR2 || arg3 == GPRInfo::argumentGPR3) 560 || (arg2 == GPRInfo::argumentGPR3 || arg3 == GPRInfo::argumentGPR2)); 561 562 if (arg2 != GPRInfo::argumentGPR2) 563 m_jit.swap(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3); 569 564 } 570 565 … … 574 569 ASSERT(isFlushed()); 575 570 576 m_jit.move(arg1, GPRInfo::argument Register1);577 m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argument Register2);578 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);571 m_jit.move(arg1, GPRInfo::argumentGPR1); 572 m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argumentGPR2); 573 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 579 574 580 575 appendCallWithExceptionCheck(operation); 581 m_jit.move(GPRInfo::returnValue Register, result);576 m_jit.move(GPRInfo::returnValueGPR, result); 582 577 } 583 578 void callOperation(J_DFGOperation_EJI operation, GPRReg result, GPRReg arg1, Identifier* identifier) … … 589 584 ASSERT(isFlushed()); 590 585 591 m_jit.move(arg1, GPRInfo::argument Register1);592 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);586 m_jit.move(arg1, GPRInfo::argumentGPR1); 587 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 593 588 594 589 appendCallWithExceptionCheck(operation); 595 m_jit.move(GPRInfo::returnValue Register, result);590 m_jit.move(GPRInfo::returnValueGPR, result); 596 591 } 597 592 void callOperation(Z_DFGOperation_EJ operation, GPRReg result, GPRReg arg1) … … 599 594 ASSERT(isFlushed()); 600 595 601 m_jit.move(arg1, GPRInfo::argument Register1);602 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);596 m_jit.move(arg1, GPRInfo::argumentGPR1); 597 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 603 598 604 599 appendCallWithExceptionCheck(operation); 605 m_jit.move(GPRInfo::returnValue Register, result);600 m_jit.move(GPRInfo::returnValueGPR, result); 606 601 } 607 602 void callOperation(Z_DFGOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2) … … 610 605 611 606 setupStubArguments(arg1, arg2); 612 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);607 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 613 608 614 609 appendCallWithExceptionCheck(operation); 615 m_jit.move(GPRInfo::returnValue Register, result);610 m_jit.move(GPRInfo::returnValueGPR, result); 616 611 } 617 612 void callOperation(J_DFGOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2) … … 620 615 621 616 setupStubArguments(arg1, arg2); 622 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);617 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 623 618 624 619 appendCallWithExceptionCheck(operation); 625 m_jit.move(GPRInfo::returnValue Register, result);620 m_jit.move(GPRInfo::returnValueGPR, result); 626 621 } 627 622 void callOperation(V_DFGOperation_EJJP operation, GPRReg arg1, GPRReg arg2, void* pointer) … … 630 625 631 626 setupStubArguments(arg1, arg2); 632 m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argument Register3);633 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);627 m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argumentGPR3); 628 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 634 629 635 630 appendCallWithExceptionCheck(operation); … … 644 639 645 640 setupStubArguments(arg1, arg2, arg3); 646 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);641 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 647 642 648 643 appendCallWithExceptionCheck(operation); … … 652 647 ASSERT(isFlushed()); 653 648 654 setupTwoStubArgs< JITCompiler::argumentFPR0, JITCompiler::argumentFPR1>(arg1, arg2);649 setupTwoStubArgs<FPRInfo::argumentFPR0, FPRInfo::argumentFPR1>(arg1, arg2); 655 650 656 651 m_jit.appendCall(operation); 657 m_jit.moveDouble( JITCompiler::fpReturnValueRegister, JITCompiler::fprToRegisterID(result));652 m_jit.moveDouble(FPRInfo::returnValueFPR, result); 658 653 } 659 654 … … 705 700 Vector<GenerationInfo, 32> m_generationInfo; 706 701 RegisterBank<GPRInfo> m_gprs; 707 RegisterBank<FPR BankInfo> m_fprs;702 RegisterBank<FPRInfo> m_fprs; 708 703 709 704 Vector<MacroAssembler::Label> m_blockHeads; … … 809 804 } 810 805 811 MacroAssembler::FPRegisterID gpr()812 {813 return JITCompiler::fprToRegisterID(fpr());814 }815 816 806 private: 817 807 JITCodeGenerator* m_jit; … … 914 904 } 915 905 916 MacroAssembler::FPRegisterID gpr()917 {918 ASSERT(m_fpr != InvalidFPRReg);919 return JITCompiler::fprToRegisterID(m_fpr);920 }921 922 906 protected: 923 907 FPRTemporary(JITCodeGenerator* jit, FPRReg lockedFPR) … … 947 931 static GPRReg lockedResult(JITCodeGenerator* jit) 948 932 { 949 jit->lock(GPRInfo::returnValue Register);950 return GPRInfo::returnValue Register;933 jit->lock(GPRInfo::returnValueGPR); 934 return GPRInfo::returnValueGPR; 951 935 } 952 936 }; … … 962 946 static FPRReg lockedResult(JITCodeGenerator* jit) 963 947 { 964 jit->lock( JITCompiler::returnValueFPR);965 return JITCompiler::returnValueFPR;948 jit->lock(FPRInfo::returnValueFPR); 949 return FPRInfo::returnValueFPR; 966 950 } 967 951 }; -
trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp
r85249 r85271 48 48 ASSERT(node.op == DoubleConstant); 49 49 move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), temporary); 50 movePtrToDouble(temporary, fpr ToRegisterID(fpr));50 movePtrToDouble(temporary, fpr); 51 51 } else { 52 52 loadPtr(addressFor(node.virtualRegister()), temporary); … … 54 54 jitAssertIsJSDouble(temporary); 55 55 addPtr(GPRInfo::tagTypeNumberRegister, temporary); 56 movePtrToDouble(temporary, fpr ToRegisterID(fpr));56 movePtrToDouble(temporary, fpr); 57 57 Jump hasUnboxedDouble = jump(); 58 58 isInteger.link(this); 59 convertInt32ToDouble(temporary, fpr ToRegisterID(fpr));59 convertInt32ToDouble(temporary, fpr); 60 60 hasUnboxedDouble.link(this); 61 61 } … … 143 143 144 144 // Spill all FPRs in use by the speculative path. 145 for ( FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {146 NodeIndex nodeIndex = check.m_fprInfo[ fpr];145 for (unsigned index = 0; index < FPRInfo::numberOfRegisters; ++index) { 146 NodeIndex nodeIndex = check.m_fprInfo[index]; 147 147 if (nodeIndex == NoNode) 148 148 continue; … … 150 150 VirtualRegister virtualRegister = graph()[nodeIndex].virtualRegister(); 151 151 152 moveDoubleToPtr( fprToRegisterID(fpr), GPRInfo::regT0);152 moveDoubleToPtr(FPRInfo::toRegister(index), GPRInfo::regT0); 153 153 subPtr(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0); 154 154 storePtr(GPRInfo::regT0, addressFor(virtualRegister)); … … 156 156 157 157 // Fill all FPRs in use by the non-speculative path. 158 for ( FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {159 NodeIndex nodeIndex = entry.m_fprInfo[ fpr];158 for (unsigned index = 0; index < FPRInfo::numberOfRegisters; ++index) { 159 NodeIndex nodeIndex = entry.m_fprInfo[index]; 160 160 if (nodeIndex == NoNode) 161 161 continue; 162 162 163 fillNumericToDouble(nodeIndex, fpr, GPRInfo::regT0);163 fillNumericToDouble(nodeIndex, FPRInfo::toRegister(index), GPRInfo::regT0); 164 164 } 165 165 … … 314 314 // of the call out from JIT code that threw the exception; this is still 315 315 // available on the stack, just below the stack pointer! 316 move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);317 peek(GPRInfo::argument Register1, -1);316 move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 317 peek(GPRInfo::argumentGPR1, -1); 318 318 m_calls.append(CallRecord(call(), lookupExceptionHandler)); 319 // lookupExceptionHandler leaves the handler CallFrame* in the returnValue Register,320 // and the address of the handler in returnValue Register2.321 jump(GPRInfo::returnValue Register2);319 // lookupExceptionHandler leaves the handler CallFrame* in the returnValueGPR, 320 // and the address of the handler in returnValueGPR2. 321 jump(GPRInfo::returnValueGPR2); 322 322 } 323 323 … … 326 326 // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions). 327 327 registerFileCheck.link(this); 328 move(stackPointerRegister, GPRInfo::argument Register0);328 move(stackPointerRegister, GPRInfo::argumentGPR0); 329 329 poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*)); 330 330 Call callRegisterFileCheck = call(); … … 340 340 emitPutToCallFrameHeader(GPRInfo::regT2, RegisterFile::ReturnPC); 341 341 branch32(Equal, GPRInfo::regT1, Imm32(m_codeBlock->m_numParameters)).linkTo(fromArityCheck, this); 342 move(stackPointerRegister, GPRInfo::argument Register0);342 move(stackPointerRegister, GPRInfo::argumentGPR0); 343 343 poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*)); 344 344 Call callArityCheck = call(); -
trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h
r85249 r85271 109 109 110 110 #if CPU(X86_64) 111 // Temporary registers.112 static const FPRegisterID fpRegT0 = X86Registers::xmm0;113 static const FPRegisterID fpRegT1 = X86Registers::xmm1;114 static const FPRegisterID fpRegT2 = X86Registers::xmm2;115 static const FPRegisterID fpRegT3 = X86Registers::xmm3;116 static const FPRegisterID fpRegT4 = X86Registers::xmm4;117 static const FPRegisterID fpRegT5 = X86Registers::xmm5;118 119 // These constants provide both FPRegisterID & FPRReg style names for the120 // floating point argument & return value register.121 static const FPRReg argumentFPR0 = fpr0;122 static const FPRReg argumentFPR1 = fpr1;123 static const FPRReg argumentFPR2 = fpr2;124 static const FPRReg argumentFPR3 = fpr3;125 static const FPRegisterID fpArgumentRegister0 = fpRegT0;126 static const FPRegisterID fpArgumentRegister1 = fpRegT1;127 static const FPRegisterID fpArgumentRegister2 = fpRegT2;128 static const FPRegisterID fpArgumentRegister3 = fpRegT3;129 static const FPRReg returnValueFPR = fpr0;130 static const FPRegisterID fpReturnValueRegister = fpRegT0;131 132 133 111 void preserveReturnAddressAfterCall(GPRReg reg) 134 112 { … … 179 157 { 180 158 return Address(GPRInfo::callFrameRegister, virtualRegister * sizeof(Register) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)); 181 }182 183 static FPRegisterID fprToRegisterID(FPRReg reg)184 {185 ASSERT(reg < numberOfFPRs);186 static const FPRegisterID idForRegister[numberOfFPRs] = { fpRegT0, fpRegT1, fpRegT2, fpRegT3, fpRegT4, fpRegT5 };187 return idForRegister[reg];188 159 } 189 160 -
trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.cpp
r85249 r85271 47 47 m_gprInfo[iter.index()].nodeIndex = NoNode; 48 48 } 49 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 50 VirtualRegister virtualRegister = jit->m_fprs.name(fpr); 51 if (virtualRegister != InvalidVirtualRegister) { 52 GenerationInfo& info = jit->m_generationInfo[virtualRegister]; 49 for (fpr_iterator iter = jit->m_fprs.begin(); iter != jit->m_fprs.end(); ++iter) { 50 if (iter.name() != InvalidVirtualRegister) { 51 GenerationInfo& info = jit->m_generationInfo[iter.name()]; 53 52 ASSERT(info.registerFormat() == DataFormatDouble); 54 m_fprInfo[ fpr] = info.nodeIndex();53 m_fprInfo[iter.index()] = info.nodeIndex(); 55 54 } else 56 m_fprInfo[ fpr] = NoNode;55 m_fprInfo[iter.index()] = NoNode; 57 56 } 58 57 } … … 62 61 GPRReg jsValueGpr = operand.gpr(); 63 62 GPRReg tempGpr = allocate(); // FIXME: can we skip this allocation on the last use of the virtual register? 64 65 JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);66 63 67 64 JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister); … … 71 68 m_jit.move(jsValueGpr, tempGpr); 72 69 m_jit.addPtr(GPRInfo::tagTypeNumberRegister, tempGpr); 73 m_jit.movePtrToDouble(tempGpr, fp Reg);70 m_jit.movePtrToDouble(tempGpr, fpr); 74 71 JITCompiler::Jump hasUnboxedDouble = m_jit.jump(); 75 72 … … 77 74 nonNumeric.link(&m_jit); 78 75 silentSpillAllRegisters(fpr, jsValueGpr); 79 m_jit.move(jsValueGpr, GPRInfo::argument Register1);80 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);76 m_jit.move(jsValueGpr, GPRInfo::argumentGPR1); 77 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 81 78 appendCallWithExceptionCheck(dfgConvertJSValueToNumber); 82 m_jit.moveDouble( JITCompiler::fpReturnValueRegister, fpReg);79 m_jit.moveDouble(FPRInfo::returnValueFPR, fpr); 83 80 silentFillAllRegisters(fpr); 84 81 JITCompiler::Jump hasCalledToNumber = m_jit.jump(); … … 86 83 // Finally, handle integers. 87 84 isInteger.link(&m_jit); 88 m_jit.convertInt32ToDouble(jsValueGpr, fp Reg);85 m_jit.convertInt32ToDouble(jsValueGpr, fpr); 89 86 hasUnboxedDouble.link(&m_jit); 90 87 hasCalledToNumber.link(&m_jit); … … 101 98 // First handle non-integers 102 99 silentSpillAllRegisters(result, jsValueGpr); 103 m_jit.move(jsValueGpr, GPRInfo::argument Register1);104 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argument Register0);100 m_jit.move(jsValueGpr, GPRInfo::argumentGPR1); 101 m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0); 105 102 appendCallWithExceptionCheck(dfgConvertJSValueToInt32); 106 m_jit.zeroExtend32ToPtr(GPRInfo::returnValue Register, result);103 m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, result); 107 104 silentFillAllRegisters(result); 108 105 JITCompiler::Jump hasCalledToInt32 = m_jit.jump(); … … 116 113 void NonSpeculativeJIT::numberToInt32(FPRReg fpr, GPRReg gpr) 117 114 { 118 JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr); 119 120 JITCompiler::Jump truncatedToInteger = m_jit.branchTruncateDoubleToInt32(fpReg, gpr, JITCompiler::BranchIfTruncateSuccessful); 115 JITCompiler::Jump truncatedToInteger = m_jit.branchTruncateDoubleToInt32(fpr, gpr, JITCompiler::BranchIfTruncateSuccessful); 121 116 122 117 silentSpillAllRegisters(gpr); 123 118 124 m_jit.moveDouble(fp Reg, JITCompiler::fpArgumentRegister0);119 m_jit.moveDouble(fpr, FPRInfo::argumentFPR0); 125 120 appendCallWithExceptionCheck(toInt32); 126 m_jit.zeroExtend32ToPtr(GPRInfo::returnValue Register, gpr);121 m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, gpr); 127 122 128 123 silentFillAllRegisters(gpr); … … 275 270 IntegerOperand op1(this, node.child1); 276 271 FPRTemporary result(this); 277 m_jit.convertInt32ToDouble(op1.gpr(), result. gpr());272 m_jit.convertInt32ToDouble(op1.gpr(), result.fpr()); 278 273 279 274 MacroAssembler::Jump positive = m_jit.branch32(MacroAssembler::GreaterThanOrEqual, op1.gpr(), TrustedImm32(0)); 280 m_jit.addDouble(JITCompiler::AbsoluteAddress(&twoToThe32), result. gpr());275 m_jit.addDouble(JITCompiler::AbsoluteAddress(&twoToThe32), result.fpr()); 281 276 positive.link(&m_jit); 282 277 … … 288 283 IntegerOperand op1(this, node.child1); 289 284 FPRTemporary result(this); 290 m_jit.convertInt32ToDouble(op1.gpr(), result. gpr());285 m_jit.convertInt32ToDouble(op1.gpr(), result.fpr()); 291 286 doubleResult(result.fpr(), m_compileIndex); 292 287 break; … … 330 325 IntegerOperand op1(this, node.child1); 331 326 FPRTemporary result(this); 332 m_jit.convertInt32ToDouble(op1.gpr(), result. gpr());327 m_jit.convertInt32ToDouble(op1.gpr(), result.fpr()); 333 328 doubleResult(result.fpr(), m_compileIndex); 334 329 break; … … 338 333 DoubleOperand op1(this, node.child1); 339 334 FPRTemporary result(this, op1); 340 m_jit.moveDouble(op1. gpr(), result.gpr());335 m_jit.moveDouble(op1.fpr(), result.fpr()); 341 336 doubleResult(result.fpr(), m_compileIndex); 342 337 break; … … 369 364 FPRTemporary result(this, op1, op2); 370 365 371 MacroAssembler::FPRegisterID reg1 = op1.gpr();372 MacroAssembler::FPRegisterID reg2 = op2.gpr();373 m_jit.addDouble(reg1, reg2, result. gpr());366 FPRReg reg1 = op1.fpr(); 367 FPRReg reg2 = op2.fpr(); 368 m_jit.addDouble(reg1, reg2, result.fpr()); 374 369 375 370 doubleResult(result.fpr(), m_compileIndex); … … 382 377 FPRTemporary result(this, op1); 383 378 384 MacroAssembler::FPRegisterID reg1 = op1.gpr();385 MacroAssembler::FPRegisterID reg2 = op2.gpr();386 m_jit.subDouble(reg1, reg2, result. gpr());379 FPRReg reg1 = op1.fpr(); 380 FPRReg reg2 = op2.fpr(); 381 m_jit.subDouble(reg1, reg2, result.fpr()); 387 382 388 383 doubleResult(result.fpr(), m_compileIndex); … … 395 390 FPRTemporary result(this, op1, op2); 396 391 397 MacroAssembler::FPRegisterID reg1 = op1.gpr();398 MacroAssembler::FPRegisterID reg2 = op2.gpr();399 m_jit.mulDouble(reg1, reg2, result. gpr());392 FPRReg reg1 = op1.fpr(); 393 FPRReg reg2 = op2.fpr(); 394 m_jit.mulDouble(reg1, reg2, result.fpr()); 400 395 401 396 doubleResult(result.fpr(), m_compileIndex); … … 408 403 FPRTemporary result(this, op1); 409 404 410 MacroAssembler::FPRegisterID reg1 = op1.gpr();411 MacroAssembler::FPRegisterID reg2 = op2.gpr();412 m_jit.divDouble(reg1, reg2, result. gpr());405 FPRReg reg1 = op1.fpr(); 406 FPRReg reg2 = op2.fpr(); 407 m_jit.divDouble(reg1, reg2, result.fpr()); 413 408 414 409 doubleResult(result.fpr(), m_compileIndex); … … 622 617 case Return: { 623 618 ASSERT(GPRInfo::callFrameRegister != GPRInfo::regT1); 624 ASSERT(GPRInfo::regT1 != GPRInfo::returnValue Register);625 ASSERT(GPRInfo::returnValue Register!= GPRInfo::callFrameRegister);619 ASSERT(GPRInfo::regT1 != GPRInfo::returnValueGPR); 620 ASSERT(GPRInfo::returnValueGPR != GPRInfo::callFrameRegister); 626 621 627 622 #if DFG_SUCCESS_STATS … … 630 625 #endif 631 626 632 // Return the result in returnValue Register.627 // Return the result in returnValueGPR. 633 628 JSValueOperand op1(this, node.child1); 634 m_jit.move(op1.gpr(), GPRInfo::returnValue Register);629 m_jit.move(op1.gpr(), GPRInfo::returnValueGPR); 635 630 636 631 // Grab the return address. -
trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.h
r85249 r85271 55 55 }; 56 56 RegisterInfo m_gprInfo[GPRInfo::numberOfRegisters]; 57 NodeIndex m_fprInfo[ numberOfFPRs];57 NodeIndex m_fprInfo[FPRInfo::numberOfRegisters]; 58 58 }; 59 59 … … 100 100 101 101 DataFormat registerFormat = info.registerFormat(); 102 GPRReg reg = info.gpr();103 102 104 103 if (registerFormat == DataFormatInteger) { 105 m_jit.orPtr(GPRInfo::tagTypeNumberRegister, reg);106 m_jit.storePtr( reg, JITCompiler::addressFor(spillMe));104 m_jit.orPtr(GPRInfo::tagTypeNumberRegister, info.gpr()); 105 m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe)); 107 106 } else { 108 107 ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell); 109 m_jit.storePtr( reg, JITCompiler::addressFor(spillMe));108 m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe)); 110 109 } 111 110 } … … 132 131 ASSERT(info.registerFormat() != DataFormatNone && info.registerFormat() != DataFormatDouble); 133 132 DataFormat registerFormat = info.registerFormat(); 134 GPRReg reg = info.gpr();135 133 136 134 if (registerFormat == DataFormatInteger) { 137 135 if (node.isConstant()) { 138 136 ASSERT(isInt32Constant(nodeIndex)); 139 m_jit.move(Imm32(valueOfInt32Constant(nodeIndex)), reg);137 m_jit.move(Imm32(valueOfInt32Constant(nodeIndex)), info.gpr()); 140 138 } else 141 m_jit.load32(JITCompiler::addressFor(spillMe), reg);139 m_jit.load32(JITCompiler::addressFor(spillMe), info.gpr()); 142 140 return; 143 141 } 144 142 145 143 if (node.isConstant()) 146 m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), reg);144 m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr()); 147 145 else { 148 146 ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell); 149 m_jit.loadPtr(JITCompiler::addressFor(spillMe), reg);147 m_jit.loadPtr(JITCompiler::addressFor(spillMe), info.gpr()); 150 148 } 151 149 } … … 160 158 ASSERT(info.registerFormat() == DataFormatDouble); 161 159 162 if (node.isConstant()) { 163 GPRReg reg = info.gpr(); 164 m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), reg); 165 } else { 160 if (node.isConstant()) 161 m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr()); 162 else { 166 163 m_jit.loadPtr(JITCompiler::addressFor(spillMe), canTrample); 167 164 unboxDouble(canTrample, info.fpr()); … … 179 176 silentSpillGPR(iter.name(), exclude); 180 177 } 181 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 182 VirtualRegister name = m_fprs.name(fpr); 183 if (name != InvalidVirtualRegister) 184 silentSpillFPR(name, canTrample); 178 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 179 if (iter.name() != InvalidVirtualRegister) 180 silentSpillFPR(iter.name(), canTrample); 185 181 } 186 182 } … … 195 191 silentSpillGPR(iter.name()); 196 192 } 197 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 198 VirtualRegister name = m_fprs.name(fpr); 199 if (name != InvalidVirtualRegister) 200 silentSpillFPR(name, canTrample, exclude); 193 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 194 if (iter.name() != InvalidVirtualRegister) 195 silentSpillFPR(iter.name(), canTrample, exclude); 201 196 } 202 197 } … … 207 202 canTrample = GPRInfo::regT1; 208 203 209 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 210 VirtualRegister name = m_fprs.name(fpr); 211 if (name != InvalidVirtualRegister) 212 silentFillFPR(name, canTrample); 204 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 205 if (iter.name() != InvalidVirtualRegister) 206 silentFillFPR(iter.name(), canTrample); 213 207 } 214 208 for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) { … … 221 215 GPRReg canTrample = GPRInfo::regT0; 222 216 223 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 224 VirtualRegister name = m_fprs.name(fpr); 225 if (name != InvalidVirtualRegister) { 226 #ifndef NDEBUG 227 ASSERT(fpr != exclude); 228 #else 229 UNUSED_PARAM(exclude); 230 #endif 231 silentFillFPR(name, canTrample, exclude); 217 for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) { 218 if (iter.name() != InvalidVirtualRegister) { 219 ASSERT_UNUSED(exclude, iter.regID() != exclude); 220 silentFillFPR(iter.name(), canTrample, exclude); 232 221 } 233 222 } -
trunk/Source/JavaScriptCore/dfg/DFGRegisterBank.h
r85249 r85271 226 226 } 227 227 228 RegID gpr() const228 RegID regID() const 229 229 { 230 230 return BankInfo::toRegister(m_index); … … 234 234 const char* debugName() const 235 235 { 236 return BankInfo::debugName( gpr());236 return BankInfo::debugName(regID()); 237 237 } 238 238 #endif -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
r85249 r85271 152 152 m_gprInfo[iter.index()].nodeIndex = NoNode; 153 153 } 154 for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) { 155 VirtualRegister virtualRegister = jit->m_fprs.name(fpr); 156 if (virtualRegister != InvalidVirtualRegister) { 157 GenerationInfo& info = jit->m_generationInfo[virtualRegister]; 154 for (fpr_iterator iter = jit->m_fprs.begin(); iter != jit->m_fprs.end(); ++iter) { 155 if (iter.name() != InvalidVirtualRegister) { 156 GenerationInfo& info = jit->m_generationInfo[iter.name()]; 158 157 ASSERT(info.registerFormat() == DataFormatDouble); 159 m_fprInfo[ fpr] = info.nodeIndex();158 m_fprInfo[iter.index()] = info.nodeIndex(); 160 159 } else 161 m_fprInfo[ fpr] = NoNode;160 m_fprInfo[iter.index()] = NoNode; 162 161 } 163 162 } … … 432 431 GPRTemporary result(this); 433 432 434 GPRReg reg = op2.gpr(); 435 speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, reg, Imm32(imm1), result.gpr())); 433 speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op2.gpr(), Imm32(imm1), result.gpr())); 436 434 437 435 integerResult(result.gpr(), m_compileIndex); … … 444 442 GPRTemporary result(this); 445 443 446 GPRReg reg = op1.gpr(); 447 speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, reg, Imm32(imm2), result.gpr())); 444 speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr())); 448 445 449 446 integerResult(result.gpr(), m_compileIndex); … … 477 474 GPRTemporary result(this); 478 475 479 GPRReg reg = op1.gpr(); 480 speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, reg, Imm32(imm2), result.gpr())); 476 speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr())); 481 477 482 478 integerResult(result.gpr(), m_compileIndex); … … 488 484 GPRTemporary result(this); 489 485 490 GPRReg reg1 = op1.gpr(); 491 GPRReg reg2 = op2.gpr(); 492 speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, reg1, reg2, result.gpr())); 486 speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), op2.gpr(), result.gpr())); 493 487 494 488 integerResult(result.gpr(), m_compileIndex); … … 776 770 case Return: { 777 771 ASSERT(GPRInfo::callFrameRegister != GPRInfo::regT1); 778 ASSERT(GPRInfo::regT1 != GPRInfo::returnValue Register);779 ASSERT(GPRInfo::returnValue Register!= GPRInfo::callFrameRegister);772 ASSERT(GPRInfo::regT1 != GPRInfo::returnValueGPR); 773 ASSERT(GPRInfo::returnValueGPR != GPRInfo::callFrameRegister); 780 774 781 775 #if DFG_SUCCESS_STATS … … 784 778 #endif 785 779 786 // Return the result in returnValue Register.780 // Return the result in returnValueGPR. 787 781 JSValueOperand op1(this, node.child1); 788 m_jit.move(op1.gpr(), GPRInfo::returnValue Register);782 m_jit.move(op1.gpr(), GPRInfo::returnValueGPR); 789 783 790 784 // Grab the return address. -
trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
r85249 r85271 87 87 }; 88 88 RegisterInfo m_gprInfo[GPRInfo::numberOfRegisters]; 89 NodeIndex m_fprInfo[ numberOfFPRs];89 NodeIndex m_fprInfo[FPRInfo::numberOfRegisters]; 90 90 }; 91 91 typedef SegmentedVector<SpeculationCheck, 16> SpeculationCheckVector;
Note: See TracChangeset
for help on using the changeset viewer.