mirror of
https://github.com/FEX-Emu/FEX.git
synced 2026-10-12 13:00:41 +02:00
Ryan Houdek
ed3af580c5
It has been a long time coming that FEX no longer needed to leak IR implementation details to the frontend, this was legacy due to IR CI and various other problems. Now that the last bits of IR leaking has been removed, move everything that we can internally to the implementation. We still have a couple of minor details in the exposed IR.h to the frontend, but these are limited to a few enums and some thunking struct information rather than all the implementation details. No functional change with this, just moving headers around.
131 lines
3.4 KiB
C++
131 lines
3.4 KiB
C++
// SPDX-License-Identifier: MIT
|
|
/*
|
|
$info$
|
|
tags: ir|opts
|
|
$end_info$
|
|
*/
|
|
|
|
#include "Interface/IR/IREmitter.h"
|
|
#include "Interface/IR/PassManager.h"
|
|
|
|
#include <FEXCore/IR/IR.h>
|
|
#include <FEXCore/Utils/Profiler.h>
|
|
|
|
#include <memory>
|
|
|
|
namespace FEXCore::IR {
|
|
|
|
class DeadCodeElimination final : public FEXCore::IR::Pass {
|
|
bool Run(IREmitter *IREmit) override;
|
|
|
|
private:
|
|
void markUsed(OrderedNodeWrapper *CodeOp, IROp_Header *IROp);
|
|
};
|
|
|
|
bool DeadCodeElimination::Run(IREmitter *IREmit) {
|
|
FEXCORE_PROFILE_SCOPED("PassManager::DCE");
|
|
auto CurrentIR = IREmit->ViewIR();
|
|
bool Changed = false;
|
|
|
|
for (auto [BlockNode, BlockHeader] : CurrentIR.GetBlocks()) {
|
|
|
|
// Reverse iteration is not yet working with the iterators
|
|
auto BlockIROp = BlockHeader->CW<FEXCore::IR::IROp_CodeBlock>();
|
|
|
|
// We grab these nodes this way so we can iterate easily
|
|
auto CodeBegin = CurrentIR.at(BlockIROp->Begin);
|
|
auto CodeLast = CurrentIR.at(BlockIROp->Last);
|
|
|
|
while (1) {
|
|
auto [CodeNode, IROp] = CodeLast();
|
|
|
|
bool HasSideEffects = IR::HasSideEffects(IROp->Op);
|
|
|
|
switch (IROp->Op) {
|
|
case OP_SYSCALL:
|
|
case OP_INLINESYSCALL: {
|
|
FEXCore::IR::SyscallFlags Flags{};
|
|
if (IROp->Op == OP_SYSCALL) {
|
|
auto Op = IROp->C<IR::IROp_Syscall>();
|
|
Flags = Op->Flags;
|
|
}
|
|
else {
|
|
auto Op = IROp->C<IR::IROp_InlineSyscall>();
|
|
Flags = Op->Flags;
|
|
}
|
|
|
|
if ((Flags & FEXCore::IR::SyscallFlags::NOSIDEEFFECTS) == FEXCore::IR::SyscallFlags::NOSIDEEFFECTS) {
|
|
HasSideEffects = false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case OP_ATOMICFETCHADD:
|
|
case OP_ATOMICFETCHSUB:
|
|
case OP_ATOMICFETCHAND:
|
|
case OP_ATOMICFETCHCLR:
|
|
case OP_ATOMICFETCHOR:
|
|
case OP_ATOMICFETCHXOR:
|
|
case OP_ATOMICFETCHNEG: {
|
|
// If the result of the atomic fetch is completely unused, convert it to a non-fetching atomic operation.
|
|
if (CodeNode->GetUses() == 0) {
|
|
switch (IROp->Op) {
|
|
case OP_ATOMICFETCHADD:
|
|
IROp->Op = OP_ATOMICADD;
|
|
break;
|
|
case OP_ATOMICFETCHSUB:
|
|
IROp->Op = OP_ATOMICSUB;
|
|
break;
|
|
case OP_ATOMICFETCHAND:
|
|
IROp->Op = OP_ATOMICAND;
|
|
break;
|
|
case OP_ATOMICFETCHCLR:
|
|
IROp->Op = OP_ATOMICCLR;
|
|
break;
|
|
case OP_ATOMICFETCHOR:
|
|
IROp->Op = OP_ATOMICOR;
|
|
break;
|
|
case OP_ATOMICFETCHXOR:
|
|
IROp->Op = OP_ATOMICXOR;
|
|
break;
|
|
case OP_ATOMICFETCHNEG:
|
|
IROp->Op = OP_ATOMICNEG;
|
|
break;
|
|
default: FEX_UNREACHABLE;
|
|
}
|
|
Changed = true;
|
|
}
|
|
break;
|
|
}
|
|
default: break;
|
|
}
|
|
|
|
// Skip over anything that has side effects
|
|
// Use count tracking can't safely remove anything with side effects
|
|
if (!HasSideEffects) {
|
|
if (CodeNode->GetUses() == 0) {
|
|
Changed = true;
|
|
IREmit->Remove(CodeNode);
|
|
}
|
|
}
|
|
|
|
if (CodeLast == CodeBegin) {
|
|
break;
|
|
}
|
|
--CodeLast;
|
|
}
|
|
}
|
|
|
|
return Changed;
|
|
}
|
|
|
|
void DeadCodeElimination::markUsed(OrderedNodeWrapper *CodeOp, IROp_Header *IROp) {
|
|
|
|
}
|
|
|
|
fextl::unique_ptr<FEXCore::IR::Pass> CreatePassDeadCodeElimination() {
|
|
return fextl::make_unique<DeadCodeElimination>();
|
|
}
|
|
|
|
}
|