~registry/dolphin-emu/triforce

nextPC = PPCAnalyst::Flatten(em_address, &size, &js.st, &js.gpa, &js.fpa, broken_block, code_buf, blockSize, merged_addresses, capacity_of_merged_addresses, size_of_merged_addresses);

454

}

455

456

PPCAnalyst::CodeOp *ops = code_buf->codebuffer;

457

458

const u8 *start = AlignCode4(); // TODO: Test if this or AlignCode16 make a difference from GetCodePtr

459

b->checkedEntry = start;

460

b->runCount = 0;

461

462

// Downcount flag check. The last block decremented downcounter, and the flag should still be available.

463

FixupBranch skip = J_CC(CC_NBE);

464

MOV(32, M(&PC), Imm32(js.blockStart));

465

JMP(asm_routines.doTiming, true); // downcount hit zero - go doTiming.

466

SetJumpTarget(skip);

467

468

const u8 *normalEntry = GetCodePtr();

469

b->normalEntry = normalEntry;

470

471

if (ImHereDebug)

472

ABI_CallFunction((void *)&ImHere); //Used to get a trace of the last few blocks before a crash, sometimes VERY useful

473

474

// Conditionally add profiling code.

475

if (Profiler::g_ProfileBlocks) {

476

ADD(32, M(&b->runCount), Imm8(1));

477

#ifdef _WIN32

478

b->ticCounter = 0;

479

b->ticStart = 0;

480

b->ticStop = 0;

481

#else

482

//TODO

483

#endif

484

// get start tic

485

PROFILER_QUERY_PERFORMANCE_COUNTER(&b->ticStart);

486

}

487

#if defined(_DEBUG) || defined(DEBUGFAST) || defined(NAN_CHECK)

488

// should help logged stack-traces become more accurate

489

MOV(32, M(&PC), Imm32(js.blockStart));

490

#endif

491

492

// Start up the register allocators

493

// They use the information in gpa/fpa to preload commonly used registers.

494

gpr.Start(js.gpa);

495

fpr.Start(js.fpa);

496

497

js.downcountAmount = 0;

498

if (!Core::g_CoreStartupParameter.bEnableDebugging)

499

{

500

for (int i = 0; i < size_of_merged_addresses; ++i)

501

{

502

const u32 address = merged_addresses[i];

503

js.downcountAmount += PatchEngine::GetSpeedhackCycles(address);

504

}

505

}

506

507

js.skipnext = false;

508

js.blockSize = size;

509

js.compilerPC = nextPC;

510

// Translate instructions

511

for (int i = 0; i < (int)size; i++)

512

{

513

js.compilerPC = ops[i].address;

514

js.op = &ops[i];

515

js.instructionNumber = i;

516

const GekkoOPInfo *opinfo = ops[i].opinfo;

517

js.downcountAmount += (opinfo->numCyclesMinusOne + 1);

518

519

if (i == (int)size - 1)

520

{

521

// WARNING - cmp->branch merging will screw this up.

522

js.isLastInstruction = true;

523

js.next_inst = 0;

524

if (Profiler::g_ProfileBlocks) {

525

// CAUTION!!! push on stack regs you use, do your stuff, then pop

526

PROFILER_VPUSH;

527

// get end tic

528

PROFILER_QUERY_PERFORMANCE_COUNTER(&b->ticStop);

529

// tic counter += (end tic - start tic)

530

PROFILER_ADD_DIFF_LARGE_INTEGER(&b->ticCounter, &b->ticStop, &b->ticStart);

531

PROFILER_VPOP;

532

}

533

}

534

else

535

{

536

// help peephole optimizations

537

js.next_inst = ops[i + 1].inst;

538

js.next_compilerPC = ops[i + 1].address;

539

}

540

541

if (jo.optimizeGatherPipe && js.fifoBytesThisBlock >= 32)

542

{

543

js.fifoBytesThisBlock -= 32;

544

MOV(32, M(&PC), Imm32(jit->js.compilerPC)); // Helps external systems know which instruction triggered the write

545

u32 registersInUse = RegistersInUse();

546

ABI_PushRegistersAndAdjustStack(registersInUse, false);

547

ABI_CallFunction((void *)&GPFifo::CheckGatherPipe);

548

ABI_PopRegistersAndAdjustStack(registersInUse, false);

549

}

550

551

u32 function = HLE::GetFunctionIndex(ops[i].address);

552

if (function != 0)

553

{

554

int type = HLE::GetFunctionTypeByIndex(function);

555

if (type == HLE::HLE_HOOK_START || type == HLE::HLE_HOOK_REPLACE)

556

{

557

int flags = HLE::GetFunctionFlagsByIndex(function);

558

if (HLE::IsEnabled(flags))

559

{

560

HLEFunction(function);

561

if (type == HLE::HLE_HOOK_REPLACE)

562

{

563

MOV(32, R(EAX), M(&NPC));

564

js.downcountAmount += js.st.numCycles;

565

WriteExitDestInEAX();

566

break;

567

}

568

}

569

}

570

}

571

572

if (!ops[i].skip)

573

{

574

if ((opinfo->flags & FL_USE_FPU) && !js.firstFPInstructionFound)

575

{

576

gpr.Flush(FLUSH_ALL);

577

fpr.Flush(FLUSH_ALL);

578

579

//This instruction uses FPU - needs to add FP exception bailout

580

TEST(32, M(&PowerPC::ppcState.msr), Imm32(1 << 13)); // Test FP enabled bit

581

FixupBranch b1 = J_CC(CC_NZ, true);

582

583

// If a FPU exception occurs, the exception handler will read

584

// from PC. Update PC with the latest value in case that happens.

585

MOV(32, M(&PC), Imm32(ops[i].address));

586

OR(32, M((void *)&PowerPC::ppcState.Exceptions), Imm32(EXCEPTION_FPU_UNAVAILABLE));

587

WriteExceptionExit();

588

589

SetJumpTarget(b1);

590

591

js.firstFPInstructionFound = true;

592

}

593

594

// Add an external exception check if the instruction writes to the FIFO.

595

if (jit->js.fifoWriteAddresses.find(ops[i].address) != jit->js.fifoWriteAddresses.end())

596

{

597

gpr.Flush(FLUSH_ALL);

598

fpr.Flush(FLUSH_ALL);

599

600

601

FixupBranch clearInt = J_CC(CC_NZ, true);

602

TEST(32, M((void *)&PowerPC::ppcState.Exceptions), Imm32(EXCEPTION_EXTERNAL_INT));

603

FixupBranch noExtException = J_CC(CC_Z, true);

604

TEST(32, M((void *)&PowerPC::ppcState.msr), Imm32(0x0008000));

605

FixupBranch noExtIntEnable = J_CC(CC_Z, true);

606

TEST(32, M((void *)&ProcessorInterface::m_InterruptCause), Imm32(ProcessorInterface::INT_CAUSE_CP | ProcessorInterface::INT_CAUSE_PE_TOKEN | ProcessorInterface::INT_CAUSE_PE_FINISH));

607

FixupBranch noCPInt = J_CC(CC_Z, true);

608

609

MOV(32, M(&PC), Imm32(ops[i].address));

610

WriteExternalExceptionExit();

611

612

SetJumpTarget(noCPInt);

613

SetJumpTarget(noExtIntEnable);

614

SetJumpTarget(noExtException);

615

SetJumpTarget(clearInt);

616

}

617

618

if (Core::g_CoreStartupParameter.bEnableDebugging && breakpoints.IsAddressBreakPoint(ops[i].address) && GetState() != CPU_STEPPING)

619

{

620

gpr.Flush(FLUSH_ALL);

621

fpr.Flush(FLUSH_ALL);

622

623

MOV(32, M(&PC), Imm32(ops[i].address));

624

ABI_CallFunction(reinterpret_cast<void *>(&PowerPC::CheckBreakPoints));

625

TEST(32, M((void*)PowerPC::GetStatePtr()), Imm32(0xFFFFFFFF));

626

FixupBranch noBreakpoint = J_CC(CC_Z);

627

628

WriteExit(ops[i].address, 0);

629

SetJumpTarget(noBreakpoint);

630

}

631

632

Jit64Tables::CompileInstruction(ops[i]);

633

634

if (js.memcheck && (opinfo->flags & FL_LOADSTORE))

635

{

636

// In case we are about to jump to the dispatcher, flush regs

637

gpr.Flush(FLUSH_ALL);

638

fpr.Flush(FLUSH_ALL);

639

640

TEST(32, M((void *)&PowerPC::ppcState.Exceptions), Imm32(EXCEPTION_DSI));

641

FixupBranch noMemException = J_CC(CC_Z, true);

642

643

// If a memory exception occurs, the exception handler will read

644

// from PC. Update PC with the latest value in case that happens.

645

MOV(32, M(&PC), Imm32(ops[i].address));

646

WriteExceptionExit();

647

SetJumpTarget(noMemException);

648

}

649

650

if (opinfo->flags & FL_LOADSTORE)

651

++jit->js.numLoadStoreInst;

652

653

if (opinfo->flags & FL_USE_FPU)

654

++jit->js.numFloatingPointInst;

655

}

656

657

#if defined(_DEBUG) || defined(DEBUGFAST)

658

if (gpr.SanityCheck() || fpr.SanityCheck())

659

{

660

char ppcInst[256];

661

DisassembleGekko(ops[i].inst.hex, em_address, ppcInst, 256);

662

//NOTICE_LOG(DYNA_REC, "Unflushed register: %s", ppcInst);

663

}

664

#endif

665

if (js.skipnext) {

666

js.skipnext = false;

667

i++; // Skip next instruction

668

}

669

670

if (js.cancel)

671

break;

672

}

673

674

u32 function = HLE::GetFunctionIndex(js.blockStart);

675

if (function != 0)

676

{

677

int type = HLE::GetFunctionTypeByIndex(function);

678

if (type == HLE::HLE_HOOK_END)

679

{

680

int flags = HLE::GetFunctionFlagsByIndex(function);

681

if (HLE::IsEnabled(flags))

682

{

683

HLEFunction(function);

684

}

685

}

686

}

687

688

if (memory_exception)

689

{

690

// Address of instruction could not be translated

691

MOV(32, M(&NPC), Imm32(js.compilerPC));

692

693

OR(32, M((void *)&PowerPC::ppcState.Exceptions), Imm32(EXCEPTION_ISI));

694

695

// Remove the invalid instruction from the icache, forcing a recompile

696

#ifdef _M_IX86

697

MOV(32, M(jit->GetBlockCache()->GetICachePtr(js.compilerPC)), Imm32(JIT_ICACHE_INVALID_WORD));

698

#else

699

MOV(64, R(RAX), ImmPtr(jit->GetBlockCache()->GetICachePtr(js.compilerPC)));

700

MOV(32,MatR(RAX),Imm32(JIT_ICACHE_INVALID_WORD));

701

#endif

702

703

WriteExceptionExit();

704

}

705

706

if (broken_block)

707

{

708

gpr.Flush(FLUSH_ALL);

709

fpr.Flush(FLUSH_ALL);

710

WriteExit(nextPC, 0);

711

}

712

713

b->flags = js.block_flags;

714

b->codeSize = (u32)(GetCodePtr() - normalEntry);

715

b->originalSize = size;

716

717

#ifdef JIT_LOG_X86

718

LogGeneratedX86(size, code_buf, normalEntry, b);

719

#endif

720

721

return normalEntry;

722

}

723

724

u32 Jit64::RegistersInUse()

725

{

726

#ifdef _M_X64

727

u32 result = 0;

728

for (int i = 0; i < NUMXREGS; i++)

729

{

730

if (!gpr.IsFreeX(i))

731

result |= (1 << i);

732

if (!fpr.IsFreeX(i))

733

result |= (1 << (16 + i));

734

}

735

return result;

736

#else

737

// not needed

738

return 0;

739

#endif

740

}

Older »