suyu/src/shader_recompiler/frontend/ir/microinstruction.cpp

316 lines
9.1 KiB
C++
Raw Normal View History

2021-01-09 07:30:07 +01:00
// Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <algorithm>
2021-02-06 06:38:22 +01:00
#include <memory>
2021-01-09 07:30:07 +01:00
#include "shader_recompiler/exception.h"
#include "shader_recompiler/frontend/ir/microinstruction.h"
#include "shader_recompiler/frontend/ir/type.h"
namespace Shader::IR {
namespace {
void CheckPseudoInstruction(IR::Inst* inst, IR::Opcode opcode) {
2021-01-09 07:30:07 +01:00
if (inst && inst->Opcode() != opcode) {
throw LogicError("Invalid pseudo-instruction");
}
}
void SetPseudoInstruction(IR::Inst*& dest_inst, IR::Inst* pseudo_inst) {
2021-01-09 07:30:07 +01:00
if (dest_inst) {
throw LogicError("Only one of each type of pseudo-op allowed");
}
dest_inst = pseudo_inst;
}
void RemovePseudoInstruction(IR::Inst*& inst, IR::Opcode expected_opcode) {
2021-01-09 07:30:07 +01:00
if (inst->Opcode() != expected_opcode) {
throw LogicError("Undoing use of invalid pseudo-op");
}
inst = nullptr;
}
} // Anonymous namespace
2021-01-09 07:30:07 +01:00
Inst::Inst(IR::Opcode op_, u32 flags_) noexcept : op{op_}, flags{flags_} {
2021-02-06 06:38:22 +01:00
if (op == Opcode::Phi) {
std::construct_at(&phi_args);
} else {
std::construct_at(&args);
}
}
Inst::~Inst() {
if (op == Opcode::Phi) {
std::destroy_at(&phi_args);
} else {
std::destroy_at(&args);
}
}
2021-01-09 07:30:07 +01:00
bool Inst::MayHaveSideEffects() const noexcept {
switch (op) {
2021-02-03 01:07:00 +01:00
case Opcode::Branch:
case Opcode::BranchConditional:
case Opcode::LoopMerge:
case Opcode::SelectionMerge:
2021-02-03 01:07:00 +01:00
case Opcode::Return:
case Opcode::DemoteToHelperInvocation:
case Opcode::Prologue:
case Opcode::Epilogue:
2021-01-09 07:30:07 +01:00
case Opcode::SetAttribute:
case Opcode::SetAttributeIndexed:
case Opcode::SetFragColor:
case Opcode::SetFragDepth:
2021-01-09 07:30:07 +01:00
case Opcode::WriteGlobalU8:
case Opcode::WriteGlobalS8:
case Opcode::WriteGlobalU16:
case Opcode::WriteGlobalS16:
case Opcode::WriteGlobal32:
case Opcode::WriteGlobal64:
case Opcode::WriteGlobal128:
case Opcode::WriteStorageU8:
case Opcode::WriteStorageS8:
case Opcode::WriteStorageU16:
case Opcode::WriteStorageS16:
case Opcode::WriteStorage32:
case Opcode::WriteStorage64:
case Opcode::WriteStorage128:
case Opcode::WriteLocal:
case Opcode::WriteSharedU8:
case Opcode::WriteSharedU16:
case Opcode::WriteSharedU32:
case Opcode::WriteSharedU64:
case Opcode::WriteSharedU128:
2021-01-09 07:30:07 +01:00
return true;
default:
return false;
}
}
bool Inst::IsPseudoInstruction() const noexcept {
switch (op) {
case Opcode::GetZeroFromOp:
case Opcode::GetSignFromOp:
case Opcode::GetCarryFromOp:
case Opcode::GetOverflowFromOp:
case Opcode::GetSparseFromOp:
2021-03-25 16:31:37 +01:00
case Opcode::GetInBoundsFromOp:
2021-01-09 07:30:07 +01:00
return true;
default:
return false;
}
}
2021-02-06 06:38:22 +01:00
bool Inst::AreAllArgsImmediates() const {
if (op == Opcode::Phi) {
throw LogicError("Testing for all arguments are immediates on phi instruction");
}
return std::all_of(args.begin(), args.begin() + NumArgs(),
[](const IR::Value& value) { return value.IsImmediate(); });
}
2021-01-09 07:30:07 +01:00
Inst* Inst::GetAssociatedPseudoOperation(IR::Opcode opcode) {
if (!associated_insts) {
return nullptr;
}
2021-01-09 07:30:07 +01:00
switch (opcode) {
case Opcode::GetZeroFromOp:
CheckPseudoInstruction(associated_insts->zero_inst, Opcode::GetZeroFromOp);
return associated_insts->zero_inst;
2021-01-09 07:30:07 +01:00
case Opcode::GetSignFromOp:
CheckPseudoInstruction(associated_insts->sign_inst, Opcode::GetSignFromOp);
return associated_insts->sign_inst;
2021-01-09 07:30:07 +01:00
case Opcode::GetCarryFromOp:
CheckPseudoInstruction(associated_insts->carry_inst, Opcode::GetCarryFromOp);
return associated_insts->carry_inst;
2021-01-09 07:30:07 +01:00
case Opcode::GetOverflowFromOp:
CheckPseudoInstruction(associated_insts->overflow_inst, Opcode::GetOverflowFromOp);
return associated_insts->overflow_inst;
case Opcode::GetSparseFromOp:
CheckPseudoInstruction(associated_insts->sparse_inst, Opcode::GetSparseFromOp);
return associated_insts->sparse_inst;
2021-03-25 16:31:37 +01:00
case Opcode::GetInBoundsFromOp:
CheckPseudoInstruction(associated_insts->in_bounds_inst, Opcode::GetInBoundsFromOp);
return associated_insts->in_bounds_inst;
2021-01-09 07:30:07 +01:00
default:
throw InvalidArgument("{} is not a pseudo-instruction", opcode);
}
}
size_t Inst::NumArgs() const {
2021-02-06 06:38:22 +01:00
return op == Opcode::Phi ? phi_args.size() : NumArgsOf(op);
2021-01-09 07:30:07 +01:00
}
IR::Type Inst::Type() const {
return TypeOf(op);
}
Value Inst::Arg(size_t index) const {
2021-02-06 06:38:22 +01:00
if (op == Opcode::Phi) {
if (index >= phi_args.size()) {
throw InvalidArgument("Out of bounds argument index {} in phi instruction", index);
}
return phi_args[index].second;
} else {
if (index >= NumArgsOf(op)) {
throw InvalidArgument("Out of bounds argument index {} in opcode {}", index, op);
}
return args[index];
2021-01-09 07:30:07 +01:00
}
}
void Inst::SetArg(size_t index, Value value) {
2021-02-14 05:24:32 +01:00
if (index >= NumArgs()) {
2021-01-09 07:30:07 +01:00
throw InvalidArgument("Out of bounds argument index {} in opcode {}", index, op);
}
2021-02-14 05:24:32 +01:00
const IR::Value arg{Arg(index)};
if (!arg.IsImmediate()) {
UndoUse(arg);
2021-01-09 07:30:07 +01:00
}
if (!value.IsImmediate()) {
Use(value);
}
2021-02-14 05:24:32 +01:00
if (op == Opcode::Phi) {
phi_args[index].second = value;
} else {
args[index] = value;
}
2021-01-09 07:30:07 +01:00
}
2021-02-06 06:38:22 +01:00
Block* Inst::PhiBlock(size_t index) const {
if (op != Opcode::Phi) {
throw LogicError("{} is not a Phi instruction", op);
}
if (index >= phi_args.size()) {
throw InvalidArgument("Out of bounds argument index {} in phi instruction");
}
return phi_args[index].first;
2021-02-03 01:07:00 +01:00
}
void Inst::AddPhiOperand(Block* predecessor, const Value& value) {
if (!value.IsImmediate()) {
Use(value);
}
2021-02-06 06:38:22 +01:00
phi_args.emplace_back(predecessor, value);
2021-02-03 01:07:00 +01:00
}
2021-01-09 07:30:07 +01:00
void Inst::Invalidate() {
ClearArgs();
ReplaceOpcode(Opcode::Void);
2021-01-09 07:30:07 +01:00
}
void Inst::ClearArgs() {
2021-02-06 06:38:22 +01:00
if (op == Opcode::Phi) {
for (auto& pair : phi_args) {
IR::Value& value{pair.second};
if (!value.IsImmediate()) {
UndoUse(value);
}
2021-01-09 07:30:07 +01:00
}
2021-02-06 06:38:22 +01:00
phi_args.clear();
} else {
for (auto& value : args) {
if (!value.IsImmediate()) {
UndoUse(value);
}
value = {};
2021-02-03 01:07:00 +01:00
}
}
2021-01-09 07:30:07 +01:00
}
void Inst::ReplaceUsesWith(Value replacement) {
Invalidate();
ReplaceOpcode(Opcode::Identity);
2021-01-09 07:30:07 +01:00
if (!replacement.IsImmediate()) {
Use(replacement);
}
args[0] = replacement;
2021-01-09 07:30:07 +01:00
}
2021-02-19 22:10:18 +01:00
void Inst::ReplaceOpcode(IR::Opcode opcode) {
if (opcode == IR::Opcode::Phi) {
throw LogicError("Cannot transition into Phi");
}
if (op == Opcode::Phi) {
// Transition out of phi arguments into non-phi
std::destroy_at(&phi_args);
std::construct_at(&args);
}
2021-02-19 22:10:18 +01:00
op = opcode;
}
void AllocAssociatedInsts(std::unique_ptr<AssociatedInsts>& associated_insts) {
if (!associated_insts) {
associated_insts = std::make_unique<AssociatedInsts>();
}
}
2021-01-09 07:30:07 +01:00
void Inst::Use(const Value& value) {
2021-02-06 06:38:22 +01:00
Inst* const inst{value.Inst()};
++inst->use_count;
2021-01-09 07:30:07 +01:00
std::unique_ptr<AssociatedInsts>& assoc_inst{inst->associated_insts};
2021-01-09 07:30:07 +01:00
switch (op) {
case Opcode::GetZeroFromOp:
AllocAssociatedInsts(assoc_inst);
SetPseudoInstruction(assoc_inst->zero_inst, this);
2021-01-09 07:30:07 +01:00
break;
case Opcode::GetSignFromOp:
AllocAssociatedInsts(assoc_inst);
SetPseudoInstruction(assoc_inst->sign_inst, this);
2021-01-09 07:30:07 +01:00
break;
case Opcode::GetCarryFromOp:
AllocAssociatedInsts(assoc_inst);
SetPseudoInstruction(assoc_inst->carry_inst, this);
2021-01-09 07:30:07 +01:00
break;
case Opcode::GetOverflowFromOp:
AllocAssociatedInsts(assoc_inst);
SetPseudoInstruction(assoc_inst->overflow_inst, this);
break;
case Opcode::GetSparseFromOp:
AllocAssociatedInsts(assoc_inst);
SetPseudoInstruction(assoc_inst->sparse_inst, this);
2021-01-09 07:30:07 +01:00
break;
2021-03-25 16:31:37 +01:00
case Opcode::GetInBoundsFromOp:
AllocAssociatedInsts(assoc_inst);
SetPseudoInstruction(assoc_inst->in_bounds_inst, this);
break;
2021-01-09 07:30:07 +01:00
default:
break;
}
}
void Inst::UndoUse(const Value& value) {
2021-02-06 06:38:22 +01:00
Inst* const inst{value.Inst()};
--inst->use_count;
2021-01-09 07:30:07 +01:00
std::unique_ptr<AssociatedInsts>& assoc_inst{inst->associated_insts};
2021-01-09 07:30:07 +01:00
switch (op) {
case Opcode::GetZeroFromOp:
AllocAssociatedInsts(assoc_inst);
RemovePseudoInstruction(assoc_inst->zero_inst, Opcode::GetZeroFromOp);
2021-01-09 07:30:07 +01:00
break;
case Opcode::GetSignFromOp:
AllocAssociatedInsts(assoc_inst);
RemovePseudoInstruction(assoc_inst->sign_inst, Opcode::GetSignFromOp);
2021-01-09 07:30:07 +01:00
break;
case Opcode::GetCarryFromOp:
AllocAssociatedInsts(assoc_inst);
RemovePseudoInstruction(assoc_inst->carry_inst, Opcode::GetCarryFromOp);
2021-01-09 07:30:07 +01:00
break;
case Opcode::GetOverflowFromOp:
AllocAssociatedInsts(assoc_inst);
RemovePseudoInstruction(assoc_inst->overflow_inst, Opcode::GetOverflowFromOp);
2021-01-09 07:30:07 +01:00
break;
2021-03-25 16:31:37 +01:00
case Opcode::GetInBoundsFromOp:
AllocAssociatedInsts(assoc_inst);
RemovePseudoInstruction(assoc_inst->in_bounds_inst, Opcode::GetInBoundsFromOp);
break;
2021-01-09 07:30:07 +01:00
default:
break;
}
}
} // namespace Shader::IR