Browse Source
Merge pull request #2888 from FernandoS27/decompiler2
Merge pull request #2888 from FernandoS27/decompiler2
Shader_IR: Implement a full control flow decompiler for the shader IR.nce_cpp
David
6 years ago
committed by
GitHub
GitHub
17 changed files with 2299 additions and 160 deletions
-
6CMakeModules/GenerateSCMRev.cmake
-
6src/common/CMakeLists.txt
-
6src/video_core/CMakeLists.txt
-
272src/video_core/renderer_opengl/gl_shader_decompiler.cpp
-
16src/video_core/renderer_opengl/gl_shader_gen.cpp
-
359src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
-
766src/video_core/shader/ast.cpp
-
391src/video_core/shader/ast.h
-
26src/video_core/shader/compiler_settings.cpp
-
26src/video_core/shader/compiler_settings.h
-
154src/video_core/shader/control_flow.cpp
-
14src/video_core/shader/control_flow.h
-
170src/video_core/shader/decode.cpp
-
82src/video_core/shader/expr.cpp
-
120src/video_core/shader/expr.h
-
12src/video_core/shader/shader_ir.cpp
-
33src/video_core/shader/shader_ir.h
@ -0,0 +1,766 @@ |
|||
// Copyright 2019 yuzu Emulator Project
|
|||
// Licensed under GPLv2 or any later version
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include <string>
|
|||
|
|||
#include "common/assert.h"
|
|||
#include "common/common_types.h"
|
|||
#include "video_core/shader/ast.h"
|
|||
#include "video_core/shader/expr.h"
|
|||
|
|||
namespace VideoCommon::Shader { |
|||
|
|||
ASTZipper::ASTZipper() = default; |
|||
|
|||
void ASTZipper::Init(const ASTNode new_first, const ASTNode parent) { |
|||
ASSERT(new_first->manager == nullptr); |
|||
first = new_first; |
|||
last = new_first; |
|||
ASTNode current = first; |
|||
while (current) { |
|||
current->manager = this; |
|||
current->parent = parent; |
|||
last = current; |
|||
current = current->next; |
|||
} |
|||
} |
|||
|
|||
void ASTZipper::PushBack(const ASTNode new_node) { |
|||
ASSERT(new_node->manager == nullptr); |
|||
new_node->previous = last; |
|||
if (last) { |
|||
last->next = new_node; |
|||
} |
|||
new_node->next.reset(); |
|||
last = new_node; |
|||
if (!first) { |
|||
first = new_node; |
|||
} |
|||
new_node->manager = this; |
|||
} |
|||
|
|||
void ASTZipper::PushFront(const ASTNode new_node) { |
|||
ASSERT(new_node->manager == nullptr); |
|||
new_node->previous.reset(); |
|||
new_node->next = first; |
|||
if (first) { |
|||
first->previous = new_node; |
|||
} |
|||
if (last == first) { |
|||
last = new_node; |
|||
} |
|||
first = new_node; |
|||
new_node->manager = this; |
|||
} |
|||
|
|||
void ASTZipper::InsertAfter(const ASTNode new_node, const ASTNode at_node) { |
|||
ASSERT(new_node->manager == nullptr); |
|||
if (!at_node) { |
|||
PushFront(new_node); |
|||
return; |
|||
} |
|||
const ASTNode next = at_node->next; |
|||
if (next) { |
|||
next->previous = new_node; |
|||
} |
|||
new_node->previous = at_node; |
|||
if (at_node == last) { |
|||
last = new_node; |
|||
} |
|||
new_node->next = next; |
|||
at_node->next = new_node; |
|||
new_node->manager = this; |
|||
} |
|||
|
|||
void ASTZipper::InsertBefore(const ASTNode new_node, const ASTNode at_node) { |
|||
ASSERT(new_node->manager == nullptr); |
|||
if (!at_node) { |
|||
PushBack(new_node); |
|||
return; |
|||
} |
|||
const ASTNode previous = at_node->previous; |
|||
if (previous) { |
|||
previous->next = new_node; |
|||
} |
|||
new_node->next = at_node; |
|||
if (at_node == first) { |
|||
first = new_node; |
|||
} |
|||
new_node->previous = previous; |
|||
at_node->previous = new_node; |
|||
new_node->manager = this; |
|||
} |
|||
|
|||
void ASTZipper::DetachTail(const ASTNode node) { |
|||
ASSERT(node->manager == this); |
|||
if (node == first) { |
|||
first.reset(); |
|||
last.reset(); |
|||
return; |
|||
} |
|||
|
|||
last = node->previous; |
|||
last->next.reset(); |
|||
node->previous.reset(); |
|||
ASTNode current = node; |
|||
while (current) { |
|||
current->manager = nullptr; |
|||
current->parent.reset(); |
|||
current = current->next; |
|||
} |
|||
} |
|||
|
|||
void ASTZipper::DetachSegment(const ASTNode start, const ASTNode end) { |
|||
ASSERT(start->manager == this && end->manager == this); |
|||
if (start == end) { |
|||
DetachSingle(start); |
|||
return; |
|||
} |
|||
const ASTNode prev = start->previous; |
|||
const ASTNode post = end->next; |
|||
if (!prev) { |
|||
first = post; |
|||
} else { |
|||
prev->next = post; |
|||
} |
|||
if (!post) { |
|||
last = prev; |
|||
} else { |
|||
post->previous = prev; |
|||
} |
|||
start->previous.reset(); |
|||
end->next.reset(); |
|||
ASTNode current = start; |
|||
bool found = false; |
|||
while (current) { |
|||
current->manager = nullptr; |
|||
current->parent.reset(); |
|||
found |= current == end; |
|||
current = current->next; |
|||
} |
|||
ASSERT(found); |
|||
} |
|||
|
|||
void ASTZipper::DetachSingle(const ASTNode node) { |
|||
ASSERT(node->manager == this); |
|||
const ASTNode prev = node->previous; |
|||
const ASTNode post = node->next; |
|||
node->previous.reset(); |
|||
node->next.reset(); |
|||
if (!prev) { |
|||
first = post; |
|||
} else { |
|||
prev->next = post; |
|||
} |
|||
if (!post) { |
|||
last = prev; |
|||
} else { |
|||
post->previous = prev; |
|||
} |
|||
|
|||
node->manager = nullptr; |
|||
node->parent.reset(); |
|||
} |
|||
|
|||
void ASTZipper::Remove(const ASTNode node) { |
|||
ASSERT(node->manager == this); |
|||
const ASTNode next = node->next; |
|||
const ASTNode previous = node->previous; |
|||
if (previous) { |
|||
previous->next = next; |
|||
} |
|||
if (next) { |
|||
next->previous = previous; |
|||
} |
|||
node->parent.reset(); |
|||
node->manager = nullptr; |
|||
if (node == last) { |
|||
last = previous; |
|||
} |
|||
if (node == first) { |
|||
first = next; |
|||
} |
|||
} |
|||
|
|||
class ExprPrinter final { |
|||
public: |
|||
ExprPrinter() = default; |
|||
|
|||
void operator()(ExprAnd const& expr) { |
|||
inner += "( "; |
|||
std::visit(*this, *expr.operand1); |
|||
inner += " && "; |
|||
std::visit(*this, *expr.operand2); |
|||
inner += ')'; |
|||
} |
|||
|
|||
void operator()(ExprOr const& expr) { |
|||
inner += "( "; |
|||
std::visit(*this, *expr.operand1); |
|||
inner += " || "; |
|||
std::visit(*this, *expr.operand2); |
|||
inner += ')'; |
|||
} |
|||
|
|||
void operator()(ExprNot const& expr) { |
|||
inner += "!"; |
|||
std::visit(*this, *expr.operand1); |
|||
} |
|||
|
|||
void operator()(ExprPredicate const& expr) { |
|||
inner += "P" + std::to_string(expr.predicate); |
|||
} |
|||
|
|||
void operator()(ExprCondCode const& expr) { |
|||
u32 cc = static_cast<u32>(expr.cc); |
|||
inner += "CC" + std::to_string(cc); |
|||
} |
|||
|
|||
void operator()(ExprVar const& expr) { |
|||
inner += "V" + std::to_string(expr.var_index); |
|||
} |
|||
|
|||
void operator()(ExprBoolean const& expr) { |
|||
inner += expr.value ? "true" : "false"; |
|||
} |
|||
|
|||
std::string& GetResult() { |
|||
return inner; |
|||
} |
|||
|
|||
std::string inner{}; |
|||
}; |
|||
|
|||
class ASTPrinter { |
|||
public: |
|||
ASTPrinter() = default; |
|||
|
|||
void operator()(ASTProgram& ast) { |
|||
scope++; |
|||
inner += "program {\n"; |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
inner += "}\n"; |
|||
scope--; |
|||
} |
|||
|
|||
void operator()(ASTIfThen& ast) { |
|||
ExprPrinter expr_parser{}; |
|||
std::visit(expr_parser, *ast.condition); |
|||
inner += Ident() + "if (" + expr_parser.GetResult() + ") {\n"; |
|||
scope++; |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
scope--; |
|||
inner += Ident() + "}\n"; |
|||
} |
|||
|
|||
void operator()(ASTIfElse& ast) { |
|||
inner += Ident() + "else {\n"; |
|||
scope++; |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
scope--; |
|||
inner += Ident() + "}\n"; |
|||
} |
|||
|
|||
void operator()(ASTBlockEncoded& ast) { |
|||
inner += Ident() + "Block(" + std::to_string(ast.start) + ", " + std::to_string(ast.end) + |
|||
");\n"; |
|||
} |
|||
|
|||
void operator()(ASTBlockDecoded& ast) { |
|||
inner += Ident() + "Block;\n"; |
|||
} |
|||
|
|||
void operator()(ASTVarSet& ast) { |
|||
ExprPrinter expr_parser{}; |
|||
std::visit(expr_parser, *ast.condition); |
|||
inner += |
|||
Ident() + "V" + std::to_string(ast.index) + " := " + expr_parser.GetResult() + ";\n"; |
|||
} |
|||
|
|||
void operator()(ASTLabel& ast) { |
|||
inner += "Label_" + std::to_string(ast.index) + ":\n"; |
|||
} |
|||
|
|||
void operator()(ASTGoto& ast) { |
|||
ExprPrinter expr_parser{}; |
|||
std::visit(expr_parser, *ast.condition); |
|||
inner += Ident() + "(" + expr_parser.GetResult() + ") -> goto Label_" + |
|||
std::to_string(ast.label) + ";\n"; |
|||
} |
|||
|
|||
void operator()(ASTDoWhile& ast) { |
|||
ExprPrinter expr_parser{}; |
|||
std::visit(expr_parser, *ast.condition); |
|||
inner += Ident() + "do {\n"; |
|||
scope++; |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
scope--; |
|||
inner += Ident() + "} while (" + expr_parser.GetResult() + ");\n"; |
|||
} |
|||
|
|||
void operator()(ASTReturn& ast) { |
|||
ExprPrinter expr_parser{}; |
|||
std::visit(expr_parser, *ast.condition); |
|||
inner += Ident() + "(" + expr_parser.GetResult() + ") -> " + |
|||
(ast.kills ? "discard" : "exit") + ";\n"; |
|||
} |
|||
|
|||
void operator()(ASTBreak& ast) { |
|||
ExprPrinter expr_parser{}; |
|||
std::visit(expr_parser, *ast.condition); |
|||
inner += Ident() + "(" + expr_parser.GetResult() + ") -> break;\n"; |
|||
} |
|||
|
|||
std::string& Ident() { |
|||
if (memo_scope == scope) { |
|||
return tabs_memo; |
|||
} |
|||
tabs_memo = tabs.substr(0, scope * 2); |
|||
memo_scope = scope; |
|||
return tabs_memo; |
|||
} |
|||
|
|||
void Visit(ASTNode& node) { |
|||
std::visit(*this, *node->GetInnerData()); |
|||
} |
|||
|
|||
std::string& GetResult() { |
|||
return inner; |
|||
} |
|||
|
|||
private: |
|||
std::string inner{}; |
|||
u32 scope{}; |
|||
|
|||
std::string tabs_memo{}; |
|||
u32 memo_scope{}; |
|||
|
|||
static std::string tabs; |
|||
}; |
|||
|
|||
std::string ASTPrinter::tabs = " "; |
|||
|
|||
std::string ASTManager::Print() { |
|||
ASTPrinter printer{}; |
|||
printer.Visit(main_node); |
|||
return printer.GetResult(); |
|||
} |
|||
|
|||
ASTManager::ASTManager(bool full_decompile, bool disable_else_derivation) |
|||
: full_decompile{full_decompile}, disable_else_derivation{disable_else_derivation} {}; |
|||
|
|||
ASTManager::~ASTManager() { |
|||
Clear(); |
|||
} |
|||
|
|||
void ASTManager::Init() { |
|||
main_node = ASTBase::Make<ASTProgram>(ASTNode{}); |
|||
program = std::get_if<ASTProgram>(main_node->GetInnerData()); |
|||
false_condition = MakeExpr<ExprBoolean>(false); |
|||
} |
|||
|
|||
ASTManager::ASTManager(ASTManager&& other) noexcept |
|||
: labels_map(std::move(other.labels_map)), labels_count{other.labels_count}, |
|||
gotos(std::move(other.gotos)), labels(std::move(other.labels)), variables{other.variables}, |
|||
program{other.program}, main_node{other.main_node}, false_condition{other.false_condition}, |
|||
disable_else_derivation{other.disable_else_derivation} { |
|||
other.main_node.reset(); |
|||
} |
|||
|
|||
ASTManager& ASTManager::operator=(ASTManager&& other) noexcept { |
|||
full_decompile = other.full_decompile; |
|||
labels_map = std::move(other.labels_map); |
|||
labels_count = other.labels_count; |
|||
gotos = std::move(other.gotos); |
|||
labels = std::move(other.labels); |
|||
variables = other.variables; |
|||
program = other.program; |
|||
main_node = other.main_node; |
|||
false_condition = other.false_condition; |
|||
disable_else_derivation = other.disable_else_derivation; |
|||
|
|||
other.main_node.reset(); |
|||
return *this; |
|||
} |
|||
|
|||
void ASTManager::DeclareLabel(u32 address) { |
|||
const auto pair = labels_map.emplace(address, labels_count); |
|||
if (pair.second) { |
|||
labels_count++; |
|||
labels.resize(labels_count); |
|||
} |
|||
} |
|||
|
|||
void ASTManager::InsertLabel(u32 address) { |
|||
const u32 index = labels_map[address]; |
|||
const ASTNode label = ASTBase::Make<ASTLabel>(main_node, index); |
|||
labels[index] = label; |
|||
program->nodes.PushBack(label); |
|||
} |
|||
|
|||
void ASTManager::InsertGoto(Expr condition, u32 address) { |
|||
const u32 index = labels_map[address]; |
|||
const ASTNode goto_node = ASTBase::Make<ASTGoto>(main_node, condition, index); |
|||
gotos.push_back(goto_node); |
|||
program->nodes.PushBack(goto_node); |
|||
} |
|||
|
|||
void ASTManager::InsertBlock(u32 start_address, u32 end_address) { |
|||
const ASTNode block = ASTBase::Make<ASTBlockEncoded>(main_node, start_address, end_address); |
|||
program->nodes.PushBack(block); |
|||
} |
|||
|
|||
void ASTManager::InsertReturn(Expr condition, bool kills) { |
|||
const ASTNode node = ASTBase::Make<ASTReturn>(main_node, condition, kills); |
|||
program->nodes.PushBack(node); |
|||
} |
|||
|
|||
// The decompile algorithm is based on
|
|||
// "Taming control flow: A structured approach to eliminating goto statements"
|
|||
// by AM Erosa, LJ Hendren 1994. In general, the idea is to get gotos to be
|
|||
// on the same structured level as the label which they jump to. This is done,
|
|||
// through outward/inward movements and lifting. Once they are at the same
|
|||
// level, you can enclose them in an "if" structure or a "do-while" structure.
|
|||
void ASTManager::Decompile() { |
|||
auto it = gotos.begin(); |
|||
while (it != gotos.end()) { |
|||
const ASTNode goto_node = *it; |
|||
const auto label_index = goto_node->GetGotoLabel(); |
|||
if (!label_index) { |
|||
return; |
|||
} |
|||
const ASTNode label = labels[*label_index]; |
|||
if (!full_decompile) { |
|||
// We only decompile backward jumps
|
|||
if (!IsBackwardsJump(goto_node, label)) { |
|||
it++; |
|||
continue; |
|||
} |
|||
} |
|||
if (IndirectlyRelated(goto_node, label)) { |
|||
while (!DirectlyRelated(goto_node, label)) { |
|||
MoveOutward(goto_node); |
|||
} |
|||
} |
|||
if (DirectlyRelated(goto_node, label)) { |
|||
u32 goto_level = goto_node->GetLevel(); |
|||
const u32 label_level = label->GetLevel(); |
|||
while (label_level < goto_level) { |
|||
MoveOutward(goto_node); |
|||
goto_level--; |
|||
} |
|||
// TODO(Blinkhawk): Implement Lifting and Inward Movements
|
|||
} |
|||
if (label->GetParent() == goto_node->GetParent()) { |
|||
bool is_loop = false; |
|||
ASTNode current = goto_node->GetPrevious(); |
|||
while (current) { |
|||
if (current == label) { |
|||
is_loop = true; |
|||
break; |
|||
} |
|||
current = current->GetPrevious(); |
|||
} |
|||
|
|||
if (is_loop) { |
|||
EncloseDoWhile(goto_node, label); |
|||
} else { |
|||
EncloseIfThen(goto_node, label); |
|||
} |
|||
it = gotos.erase(it); |
|||
continue; |
|||
} |
|||
it++; |
|||
} |
|||
if (full_decompile) { |
|||
for (const ASTNode& label : labels) { |
|||
auto& manager = label->GetManager(); |
|||
manager.Remove(label); |
|||
} |
|||
labels.clear(); |
|||
} else { |
|||
auto it = labels.begin(); |
|||
while (it != labels.end()) { |
|||
bool can_remove = true; |
|||
ASTNode label = *it; |
|||
for (const ASTNode& goto_node : gotos) { |
|||
const auto label_index = goto_node->GetGotoLabel(); |
|||
if (!label_index) { |
|||
return; |
|||
} |
|||
ASTNode& glabel = labels[*label_index]; |
|||
if (glabel == label) { |
|||
can_remove = false; |
|||
break; |
|||
} |
|||
} |
|||
if (can_remove) { |
|||
label->MarkLabelUnused(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
bool ASTManager::IsBackwardsJump(ASTNode goto_node, ASTNode label_node) const { |
|||
u32 goto_level = goto_node->GetLevel(); |
|||
u32 label_level = label_node->GetLevel(); |
|||
while (goto_level > label_level) { |
|||
goto_level--; |
|||
goto_node = goto_node->GetParent(); |
|||
} |
|||
while (label_level > goto_level) { |
|||
label_level--; |
|||
label_node = label_node->GetParent(); |
|||
} |
|||
while (goto_node->GetParent() != label_node->GetParent()) { |
|||
goto_node = goto_node->GetParent(); |
|||
label_node = label_node->GetParent(); |
|||
} |
|||
ASTNode current = goto_node->GetPrevious(); |
|||
while (current) { |
|||
if (current == label_node) { |
|||
return true; |
|||
} |
|||
current = current->GetPrevious(); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool ASTManager::IndirectlyRelated(ASTNode first, ASTNode second) { |
|||
return !(first->GetParent() == second->GetParent() || DirectlyRelated(first, second)); |
|||
} |
|||
|
|||
bool ASTManager::DirectlyRelated(ASTNode first, ASTNode second) { |
|||
if (first->GetParent() == second->GetParent()) { |
|||
return false; |
|||
} |
|||
const u32 first_level = first->GetLevel(); |
|||
const u32 second_level = second->GetLevel(); |
|||
u32 min_level; |
|||
u32 max_level; |
|||
ASTNode max; |
|||
ASTNode min; |
|||
if (first_level > second_level) { |
|||
min_level = second_level; |
|||
min = second; |
|||
max_level = first_level; |
|||
max = first; |
|||
} else { |
|||
min_level = first_level; |
|||
min = first; |
|||
max_level = second_level; |
|||
max = second; |
|||
} |
|||
|
|||
while (max_level > min_level) { |
|||
max_level--; |
|||
max = max->GetParent(); |
|||
} |
|||
|
|||
return min->GetParent() == max->GetParent(); |
|||
} |
|||
|
|||
void ASTManager::ShowCurrentState(std::string state) { |
|||
LOG_CRITICAL(HW_GPU, "\nState {}:\n\n{}\n", state, Print()); |
|||
SanityCheck(); |
|||
} |
|||
|
|||
void ASTManager::SanityCheck() { |
|||
for (auto& label : labels) { |
|||
if (!label->GetParent()) { |
|||
LOG_CRITICAL(HW_GPU, "Sanity Check Failed"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void ASTManager::EncloseDoWhile(ASTNode goto_node, ASTNode label) { |
|||
ASTZipper& zipper = goto_node->GetManager(); |
|||
const ASTNode loop_start = label->GetNext(); |
|||
if (loop_start == goto_node) { |
|||
zipper.Remove(goto_node); |
|||
return; |
|||
} |
|||
const ASTNode parent = label->GetParent(); |
|||
const Expr condition = goto_node->GetGotoCondition(); |
|||
zipper.DetachSegment(loop_start, goto_node); |
|||
const ASTNode do_while_node = ASTBase::Make<ASTDoWhile>(parent, condition); |
|||
ASTZipper* sub_zipper = do_while_node->GetSubNodes(); |
|||
sub_zipper->Init(loop_start, do_while_node); |
|||
zipper.InsertAfter(do_while_node, label); |
|||
sub_zipper->Remove(goto_node); |
|||
} |
|||
|
|||
void ASTManager::EncloseIfThen(ASTNode goto_node, ASTNode label) { |
|||
ASTZipper& zipper = goto_node->GetManager(); |
|||
const ASTNode if_end = label->GetPrevious(); |
|||
if (if_end == goto_node) { |
|||
zipper.Remove(goto_node); |
|||
return; |
|||
} |
|||
const ASTNode prev = goto_node->GetPrevious(); |
|||
const Expr condition = goto_node->GetGotoCondition(); |
|||
bool do_else = false; |
|||
if (!disable_else_derivation && prev->IsIfThen()) { |
|||
const Expr if_condition = prev->GetIfCondition(); |
|||
do_else = ExprAreEqual(if_condition, condition); |
|||
} |
|||
const ASTNode parent = label->GetParent(); |
|||
zipper.DetachSegment(goto_node, if_end); |
|||
ASTNode if_node; |
|||
if (do_else) { |
|||
if_node = ASTBase::Make<ASTIfElse>(parent); |
|||
} else { |
|||
Expr neg_condition = MakeExprNot(condition); |
|||
if_node = ASTBase::Make<ASTIfThen>(parent, neg_condition); |
|||
} |
|||
ASTZipper* sub_zipper = if_node->GetSubNodes(); |
|||
sub_zipper->Init(goto_node, if_node); |
|||
zipper.InsertAfter(if_node, prev); |
|||
sub_zipper->Remove(goto_node); |
|||
} |
|||
|
|||
void ASTManager::MoveOutward(ASTNode goto_node) { |
|||
ASTZipper& zipper = goto_node->GetManager(); |
|||
const ASTNode parent = goto_node->GetParent(); |
|||
ASTZipper& zipper2 = parent->GetManager(); |
|||
const ASTNode grandpa = parent->GetParent(); |
|||
const bool is_loop = parent->IsLoop(); |
|||
const bool is_else = parent->IsIfElse(); |
|||
const bool is_if = parent->IsIfThen(); |
|||
|
|||
const ASTNode prev = goto_node->GetPrevious(); |
|||
const ASTNode post = goto_node->GetNext(); |
|||
|
|||
const Expr condition = goto_node->GetGotoCondition(); |
|||
zipper.DetachSingle(goto_node); |
|||
if (is_loop) { |
|||
const u32 var_index = NewVariable(); |
|||
const Expr var_condition = MakeExpr<ExprVar>(var_index); |
|||
const ASTNode var_node = ASTBase::Make<ASTVarSet>(parent, var_index, condition); |
|||
const ASTNode var_node_init = ASTBase::Make<ASTVarSet>(parent, var_index, false_condition); |
|||
zipper2.InsertBefore(var_node_init, parent); |
|||
zipper.InsertAfter(var_node, prev); |
|||
goto_node->SetGotoCondition(var_condition); |
|||
const ASTNode break_node = ASTBase::Make<ASTBreak>(parent, var_condition); |
|||
zipper.InsertAfter(break_node, var_node); |
|||
} else if (is_if || is_else) { |
|||
const u32 var_index = NewVariable(); |
|||
const Expr var_condition = MakeExpr<ExprVar>(var_index); |
|||
const ASTNode var_node = ASTBase::Make<ASTVarSet>(parent, var_index, condition); |
|||
const ASTNode var_node_init = ASTBase::Make<ASTVarSet>(parent, var_index, false_condition); |
|||
if (is_if) { |
|||
zipper2.InsertBefore(var_node_init, parent); |
|||
} else { |
|||
zipper2.InsertBefore(var_node_init, parent->GetPrevious()); |
|||
} |
|||
zipper.InsertAfter(var_node, prev); |
|||
goto_node->SetGotoCondition(var_condition); |
|||
if (post) { |
|||
zipper.DetachTail(post); |
|||
const ASTNode if_node = ASTBase::Make<ASTIfThen>(parent, MakeExprNot(var_condition)); |
|||
ASTZipper* sub_zipper = if_node->GetSubNodes(); |
|||
sub_zipper->Init(post, if_node); |
|||
zipper.InsertAfter(if_node, var_node); |
|||
} |
|||
} else { |
|||
UNREACHABLE(); |
|||
} |
|||
const ASTNode next = parent->GetNext(); |
|||
if (is_if && next && next->IsIfElse()) { |
|||
zipper2.InsertAfter(goto_node, next); |
|||
goto_node->SetParent(grandpa); |
|||
return; |
|||
} |
|||
zipper2.InsertAfter(goto_node, parent); |
|||
goto_node->SetParent(grandpa); |
|||
} |
|||
|
|||
class ASTClearer { |
|||
public: |
|||
ASTClearer() = default; |
|||
|
|||
void operator()(ASTProgram& ast) { |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
} |
|||
|
|||
void operator()(ASTIfThen& ast) { |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
} |
|||
|
|||
void operator()(ASTIfElse& ast) { |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
} |
|||
|
|||
void operator()(ASTBlockEncoded& ast) {} |
|||
|
|||
void operator()(ASTBlockDecoded& ast) { |
|||
ast.nodes.clear(); |
|||
} |
|||
|
|||
void operator()(ASTVarSet& ast) {} |
|||
|
|||
void operator()(ASTLabel& ast) {} |
|||
|
|||
void operator()(ASTGoto& ast) {} |
|||
|
|||
void operator()(ASTDoWhile& ast) { |
|||
ASTNode current = ast.nodes.GetFirst(); |
|||
while (current) { |
|||
Visit(current); |
|||
current = current->GetNext(); |
|||
} |
|||
} |
|||
|
|||
void operator()(ASTReturn& ast) {} |
|||
|
|||
void operator()(ASTBreak& ast) {} |
|||
|
|||
void Visit(ASTNode& node) { |
|||
std::visit(*this, *node->GetInnerData()); |
|||
node->Clear(); |
|||
} |
|||
}; |
|||
|
|||
void ASTManager::Clear() { |
|||
if (!main_node) { |
|||
return; |
|||
} |
|||
ASTClearer clearer{}; |
|||
clearer.Visit(main_node); |
|||
main_node.reset(); |
|||
program = nullptr; |
|||
labels_map.clear(); |
|||
labels.clear(); |
|||
gotos.clear(); |
|||
} |
|||
|
|||
} // namespace VideoCommon::Shader
|
|||
@ -0,0 +1,391 @@ |
|||
// Copyright 2019 yuzu Emulator Project |
|||
// Licensed under GPLv2 or any later version |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include <functional> |
|||
#include <list> |
|||
#include <memory> |
|||
#include <optional> |
|||
#include <string> |
|||
#include <unordered_map> |
|||
#include <vector> |
|||
|
|||
#include "video_core/shader/expr.h" |
|||
#include "video_core/shader/node.h" |
|||
|
|||
namespace VideoCommon::Shader { |
|||
|
|||
class ASTBase; |
|||
class ASTProgram; |
|||
class ASTIfThen; |
|||
class ASTIfElse; |
|||
class ASTBlockEncoded; |
|||
class ASTBlockDecoded; |
|||
class ASTVarSet; |
|||
class ASTGoto; |
|||
class ASTLabel; |
|||
class ASTDoWhile; |
|||
class ASTReturn; |
|||
class ASTBreak; |
|||
|
|||
using ASTData = std::variant<ASTProgram, ASTIfThen, ASTIfElse, ASTBlockEncoded, ASTBlockDecoded, |
|||
ASTVarSet, ASTGoto, ASTLabel, ASTDoWhile, ASTReturn, ASTBreak>; |
|||
|
|||
using ASTNode = std::shared_ptr<ASTBase>; |
|||
|
|||
enum class ASTZipperType : u32 { |
|||
Program, |
|||
IfThen, |
|||
IfElse, |
|||
Loop, |
|||
}; |
|||
|
|||
class ASTZipper final { |
|||
public: |
|||
explicit ASTZipper(); |
|||
|
|||
void Init(ASTNode first, ASTNode parent); |
|||
|
|||
ASTNode GetFirst() { |
|||
return first; |
|||
} |
|||
|
|||
ASTNode GetLast() { |
|||
return last; |
|||
} |
|||
|
|||
void PushBack(ASTNode new_node); |
|||
void PushFront(ASTNode new_node); |
|||
void InsertAfter(ASTNode new_node, ASTNode at_node); |
|||
void InsertBefore(ASTNode new_node, ASTNode at_node); |
|||
void DetachTail(ASTNode node); |
|||
void DetachSingle(ASTNode node); |
|||
void DetachSegment(ASTNode start, ASTNode end); |
|||
void Remove(ASTNode node); |
|||
|
|||
ASTNode first{}; |
|||
ASTNode last{}; |
|||
}; |
|||
|
|||
class ASTProgram { |
|||
public: |
|||
explicit ASTProgram() = default; |
|||
ASTZipper nodes{}; |
|||
}; |
|||
|
|||
class ASTIfThen { |
|||
public: |
|||
explicit ASTIfThen(Expr condition) : condition(condition) {} |
|||
Expr condition; |
|||
ASTZipper nodes{}; |
|||
}; |
|||
|
|||
class ASTIfElse { |
|||
public: |
|||
explicit ASTIfElse() = default; |
|||
ASTZipper nodes{}; |
|||
}; |
|||
|
|||
class ASTBlockEncoded { |
|||
public: |
|||
explicit ASTBlockEncoded(u32 start, u32 end) : start{start}, end{end} {} |
|||
u32 start; |
|||
u32 end; |
|||
}; |
|||
|
|||
class ASTBlockDecoded { |
|||
public: |
|||
explicit ASTBlockDecoded(NodeBlock&& new_nodes) : nodes(std::move(new_nodes)) {} |
|||
NodeBlock nodes; |
|||
}; |
|||
|
|||
class ASTVarSet { |
|||
public: |
|||
explicit ASTVarSet(u32 index, Expr condition) : index{index}, condition{condition} {} |
|||
u32 index; |
|||
Expr condition; |
|||
}; |
|||
|
|||
class ASTLabel { |
|||
public: |
|||
explicit ASTLabel(u32 index) : index{index} {} |
|||
u32 index; |
|||
bool unused{}; |
|||
}; |
|||
|
|||
class ASTGoto { |
|||
public: |
|||
explicit ASTGoto(Expr condition, u32 label) : condition{condition}, label{label} {} |
|||
Expr condition; |
|||
u32 label; |
|||
}; |
|||
|
|||
class ASTDoWhile { |
|||
public: |
|||
explicit ASTDoWhile(Expr condition) : condition(condition) {} |
|||
Expr condition; |
|||
ASTZipper nodes{}; |
|||
}; |
|||
|
|||
class ASTReturn { |
|||
public: |
|||
explicit ASTReturn(Expr condition, bool kills) : condition{condition}, kills{kills} {} |
|||
Expr condition; |
|||
bool kills; |
|||
}; |
|||
|
|||
class ASTBreak { |
|||
public: |
|||
explicit ASTBreak(Expr condition) : condition{condition} {} |
|||
Expr condition; |
|||
}; |
|||
|
|||
class ASTBase { |
|||
public: |
|||
explicit ASTBase(ASTNode parent, ASTData data) : parent{parent}, data{data} {} |
|||
|
|||
template <class U, class... Args> |
|||
static ASTNode Make(ASTNode parent, Args&&... args) { |
|||
return std::make_shared<ASTBase>(parent, ASTData(U(std::forward<Args>(args)...))); |
|||
} |
|||
|
|||
void SetParent(ASTNode new_parent) { |
|||
parent = new_parent; |
|||
} |
|||
|
|||
ASTNode& GetParent() { |
|||
return parent; |
|||
} |
|||
|
|||
const ASTNode& GetParent() const { |
|||
return parent; |
|||
} |
|||
|
|||
u32 GetLevel() const { |
|||
u32 level = 0; |
|||
auto next_parent = parent; |
|||
while (next_parent) { |
|||
next_parent = next_parent->GetParent(); |
|||
level++; |
|||
} |
|||
return level; |
|||
} |
|||
|
|||
ASTData* GetInnerData() { |
|||
return &data; |
|||
} |
|||
|
|||
ASTNode GetNext() const { |
|||
return next; |
|||
} |
|||
|
|||
ASTNode GetPrevious() const { |
|||
return previous; |
|||
} |
|||
|
|||
ASTZipper& GetManager() { |
|||
return *manager; |
|||
} |
|||
|
|||
std::optional<u32> GetGotoLabel() const { |
|||
auto inner = std::get_if<ASTGoto>(&data); |
|||
if (inner) { |
|||
return {inner->label}; |
|||
} |
|||
return {}; |
|||
} |
|||
|
|||
Expr GetGotoCondition() const { |
|||
auto inner = std::get_if<ASTGoto>(&data); |
|||
if (inner) { |
|||
return inner->condition; |
|||
} |
|||
return nullptr; |
|||
} |
|||
|
|||
void MarkLabelUnused() { |
|||
auto inner = std::get_if<ASTLabel>(&data); |
|||
if (inner) { |
|||
inner->unused = true; |
|||
} |
|||
} |
|||
|
|||
bool IsLabelUnused() const { |
|||
auto inner = std::get_if<ASTLabel>(&data); |
|||
if (inner) { |
|||
return inner->unused; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
std::optional<u32> GetLabelIndex() const { |
|||
auto inner = std::get_if<ASTLabel>(&data); |
|||
if (inner) { |
|||
return {inner->index}; |
|||
} |
|||
return {}; |
|||
} |
|||
|
|||
Expr GetIfCondition() const { |
|||
auto inner = std::get_if<ASTIfThen>(&data); |
|||
if (inner) { |
|||
return inner->condition; |
|||
} |
|||
return nullptr; |
|||
} |
|||
|
|||
void SetGotoCondition(Expr new_condition) { |
|||
auto inner = std::get_if<ASTGoto>(&data); |
|||
if (inner) { |
|||
inner->condition = new_condition; |
|||
} |
|||
} |
|||
|
|||
bool IsIfThen() const { |
|||
return std::holds_alternative<ASTIfThen>(data); |
|||
} |
|||
|
|||
bool IsIfElse() const { |
|||
return std::holds_alternative<ASTIfElse>(data); |
|||
} |
|||
|
|||
bool IsBlockEncoded() const { |
|||
return std::holds_alternative<ASTBlockEncoded>(data); |
|||
} |
|||
|
|||
void TransformBlockEncoded(NodeBlock&& nodes) { |
|||
data = ASTBlockDecoded(std::move(nodes)); |
|||
} |
|||
|
|||
bool IsLoop() const { |
|||
return std::holds_alternative<ASTDoWhile>(data); |
|||
} |
|||
|
|||
ASTZipper* GetSubNodes() { |
|||
if (std::holds_alternative<ASTProgram>(data)) { |
|||
return &std::get_if<ASTProgram>(&data)->nodes; |
|||
} |
|||
if (std::holds_alternative<ASTIfThen>(data)) { |
|||
return &std::get_if<ASTIfThen>(&data)->nodes; |
|||
} |
|||
if (std::holds_alternative<ASTIfElse>(data)) { |
|||
return &std::get_if<ASTIfElse>(&data)->nodes; |
|||
} |
|||
if (std::holds_alternative<ASTDoWhile>(data)) { |
|||
return &std::get_if<ASTDoWhile>(&data)->nodes; |
|||
} |
|||
return nullptr; |
|||
} |
|||
|
|||
void Clear() { |
|||
next.reset(); |
|||
previous.reset(); |
|||
parent.reset(); |
|||
manager = nullptr; |
|||
} |
|||
|
|||
private: |
|||
friend class ASTZipper; |
|||
|
|||
ASTData data; |
|||
ASTNode parent{}; |
|||
ASTNode next{}; |
|||
ASTNode previous{}; |
|||
ASTZipper* manager{}; |
|||
}; |
|||
|
|||
class ASTManager final { |
|||
public: |
|||
ASTManager(bool full_decompile, bool disable_else_derivation); |
|||
~ASTManager(); |
|||
|
|||
ASTManager(const ASTManager& o) = delete; |
|||
ASTManager& operator=(const ASTManager& other) = delete; |
|||
|
|||
ASTManager(ASTManager&& other) noexcept; |
|||
ASTManager& operator=(ASTManager&& other) noexcept; |
|||
|
|||
void Init(); |
|||
|
|||
void DeclareLabel(u32 address); |
|||
|
|||
void InsertLabel(u32 address); |
|||
|
|||
void InsertGoto(Expr condition, u32 address); |
|||
|
|||
void InsertBlock(u32 start_address, u32 end_address); |
|||
|
|||
void InsertReturn(Expr condition, bool kills); |
|||
|
|||
std::string Print(); |
|||
|
|||
void Decompile(); |
|||
|
|||
void ShowCurrentState(std::string state); |
|||
|
|||
void SanityCheck(); |
|||
|
|||
void Clear(); |
|||
|
|||
bool IsFullyDecompiled() const { |
|||
if (full_decompile) { |
|||
return gotos.size() == 0; |
|||
} else { |
|||
for (ASTNode goto_node : gotos) { |
|||
auto label_index = goto_node->GetGotoLabel(); |
|||
if (!label_index) { |
|||
return false; |
|||
} |
|||
ASTNode glabel = labels[*label_index]; |
|||
if (IsBackwardsJump(goto_node, glabel)) { |
|||
return false; |
|||
} |
|||
} |
|||
return true; |
|||
} |
|||
} |
|||
|
|||
ASTNode GetProgram() const { |
|||
return main_node; |
|||
} |
|||
|
|||
u32 GetVariables() const { |
|||
return variables; |
|||
} |
|||
|
|||
const std::vector<ASTNode>& GetLabels() const { |
|||
return labels; |
|||
} |
|||
|
|||
private: |
|||
bool IsBackwardsJump(ASTNode goto_node, ASTNode label_node) const; |
|||
|
|||
bool IndirectlyRelated(ASTNode first, ASTNode second); |
|||
|
|||
bool DirectlyRelated(ASTNode first, ASTNode second); |
|||
|
|||
void EncloseDoWhile(ASTNode goto_node, ASTNode label); |
|||
|
|||
void EncloseIfThen(ASTNode goto_node, ASTNode label); |
|||
|
|||
void MoveOutward(ASTNode goto_node); |
|||
|
|||
u32 NewVariable() { |
|||
return variables++; |
|||
} |
|||
|
|||
bool full_decompile{}; |
|||
bool disable_else_derivation{}; |
|||
std::unordered_map<u32, u32> labels_map{}; |
|||
u32 labels_count{}; |
|||
std::vector<ASTNode> labels{}; |
|||
std::list<ASTNode> gotos{}; |
|||
u32 variables{}; |
|||
ASTProgram* program{}; |
|||
ASTNode main_node{}; |
|||
Expr false_condition{}; |
|||
}; |
|||
|
|||
} // namespace VideoCommon::Shader |
|||
@ -0,0 +1,26 @@ |
|||
// Copyright 2019 yuzu Emulator Project
|
|||
// Licensed under GPLv2 or any later version
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include "video_core/shader/compiler_settings.h"
|
|||
|
|||
namespace VideoCommon::Shader { |
|||
|
|||
std::string CompileDepthAsString(const CompileDepth cd) { |
|||
switch (cd) { |
|||
case CompileDepth::BruteForce: |
|||
return "Brute Force Compile"; |
|||
case CompileDepth::FlowStack: |
|||
return "Simple Flow Stack Mode"; |
|||
case CompileDepth::NoFlowStack: |
|||
return "Remove Flow Stack"; |
|||
case CompileDepth::DecompileBackwards: |
|||
return "Decompile Backward Jumps"; |
|||
case CompileDepth::FullDecompile: |
|||
return "Full Decompilation"; |
|||
default: |
|||
return "Unknown Compiler Process"; |
|||
} |
|||
} |
|||
|
|||
} // namespace VideoCommon::Shader
|
|||
@ -0,0 +1,26 @@ |
|||
// Copyright 2019 yuzu Emulator Project |
|||
// Licensed under GPLv2 or any later version |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include "video_core/engines/shader_bytecode.h" |
|||
|
|||
namespace VideoCommon::Shader { |
|||
|
|||
enum class CompileDepth : u32 { |
|||
BruteForce = 0, |
|||
FlowStack = 1, |
|||
NoFlowStack = 2, |
|||
DecompileBackwards = 3, |
|||
FullDecompile = 4, |
|||
}; |
|||
|
|||
std::string CompileDepthAsString(CompileDepth cd); |
|||
|
|||
struct CompilerSettings { |
|||
CompileDepth depth{CompileDepth::NoFlowStack}; |
|||
bool disable_else_derivation{true}; |
|||
}; |
|||
|
|||
} // namespace VideoCommon::Shader |
|||
@ -0,0 +1,82 @@ |
|||
// Copyright 2019 yuzu Emulator Project
|
|||
// Licensed under GPLv2 or any later version
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#pragma once
|
|||
|
|||
#include <memory>
|
|||
#include <variant>
|
|||
|
|||
#include "video_core/shader/expr.h"
|
|||
|
|||
namespace VideoCommon::Shader { |
|||
|
|||
bool ExprAnd::operator==(const ExprAnd& b) const { |
|||
return (*operand1 == *b.operand1) && (*operand2 == *b.operand2); |
|||
} |
|||
|
|||
bool ExprOr::operator==(const ExprOr& b) const { |
|||
return (*operand1 == *b.operand1) && (*operand2 == *b.operand2); |
|||
} |
|||
|
|||
bool ExprNot::operator==(const ExprNot& b) const { |
|||
return (*operand1 == *b.operand1); |
|||
} |
|||
|
|||
bool ExprIsBoolean(Expr expr) { |
|||
return std::holds_alternative<ExprBoolean>(*expr); |
|||
} |
|||
|
|||
bool ExprBooleanGet(Expr expr) { |
|||
return std::get_if<ExprBoolean>(expr.get())->value; |
|||
} |
|||
|
|||
Expr MakeExprNot(Expr first) { |
|||
if (std::holds_alternative<ExprNot>(*first)) { |
|||
return std::get_if<ExprNot>(first.get())->operand1; |
|||
} |
|||
return MakeExpr<ExprNot>(first); |
|||
} |
|||
|
|||
Expr MakeExprAnd(Expr first, Expr second) { |
|||
if (ExprIsBoolean(first)) { |
|||
return ExprBooleanGet(first) ? second : first; |
|||
} |
|||
if (ExprIsBoolean(second)) { |
|||
return ExprBooleanGet(second) ? first : second; |
|||
} |
|||
return MakeExpr<ExprAnd>(first, second); |
|||
} |
|||
|
|||
Expr MakeExprOr(Expr first, Expr second) { |
|||
if (ExprIsBoolean(first)) { |
|||
return ExprBooleanGet(first) ? first : second; |
|||
} |
|||
if (ExprIsBoolean(second)) { |
|||
return ExprBooleanGet(second) ? second : first; |
|||
} |
|||
return MakeExpr<ExprOr>(first, second); |
|||
} |
|||
|
|||
bool ExprAreEqual(Expr first, Expr second) { |
|||
return (*first) == (*second); |
|||
} |
|||
|
|||
bool ExprAreOpposite(Expr first, Expr second) { |
|||
if (std::holds_alternative<ExprNot>(*first)) { |
|||
return ExprAreEqual(std::get_if<ExprNot>(first.get())->operand1, second); |
|||
} |
|||
if (std::holds_alternative<ExprNot>(*second)) { |
|||
return ExprAreEqual(std::get_if<ExprNot>(second.get())->operand1, first); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool ExprIsTrue(Expr first) { |
|||
if (ExprIsBoolean(first)) { |
|||
return ExprBooleanGet(first); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
} // namespace VideoCommon::Shader
|
|||
@ -0,0 +1,120 @@ |
|||
// Copyright 2019 yuzu Emulator Project |
|||
// Licensed under GPLv2 or any later version |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <variant> |
|||
|
|||
#include "video_core/engines/shader_bytecode.h" |
|||
|
|||
namespace VideoCommon::Shader { |
|||
|
|||
using Tegra::Shader::ConditionCode; |
|||
using Tegra::Shader::Pred; |
|||
|
|||
class ExprAnd; |
|||
class ExprOr; |
|||
class ExprNot; |
|||
class ExprPredicate; |
|||
class ExprCondCode; |
|||
class ExprVar; |
|||
class ExprBoolean; |
|||
|
|||
using ExprData = |
|||
std::variant<ExprVar, ExprCondCode, ExprPredicate, ExprNot, ExprOr, ExprAnd, ExprBoolean>; |
|||
using Expr = std::shared_ptr<ExprData>; |
|||
|
|||
class ExprAnd final { |
|||
public: |
|||
explicit ExprAnd(Expr a, Expr b) : operand1{a}, operand2{b} {} |
|||
|
|||
bool operator==(const ExprAnd& b) const; |
|||
|
|||
Expr operand1; |
|||
Expr operand2; |
|||
}; |
|||
|
|||
class ExprOr final { |
|||
public: |
|||
explicit ExprOr(Expr a, Expr b) : operand1{a}, operand2{b} {} |
|||
|
|||
bool operator==(const ExprOr& b) const; |
|||
|
|||
Expr operand1; |
|||
Expr operand2; |
|||
}; |
|||
|
|||
class ExprNot final { |
|||
public: |
|||
explicit ExprNot(Expr a) : operand1{a} {} |
|||
|
|||
bool operator==(const ExprNot& b) const; |
|||
|
|||
Expr operand1; |
|||
}; |
|||
|
|||
class ExprVar final { |
|||
public: |
|||
explicit ExprVar(u32 index) : var_index{index} {} |
|||
|
|||
bool operator==(const ExprVar& b) const { |
|||
return var_index == b.var_index; |
|||
} |
|||
|
|||
u32 var_index; |
|||
}; |
|||
|
|||
class ExprPredicate final { |
|||
public: |
|||
explicit ExprPredicate(u32 predicate) : predicate{predicate} {} |
|||
|
|||
bool operator==(const ExprPredicate& b) const { |
|||
return predicate == b.predicate; |
|||
} |
|||
|
|||
u32 predicate; |
|||
}; |
|||
|
|||
class ExprCondCode final { |
|||
public: |
|||
explicit ExprCondCode(ConditionCode cc) : cc{cc} {} |
|||
|
|||
bool operator==(const ExprCondCode& b) const { |
|||
return cc == b.cc; |
|||
} |
|||
|
|||
ConditionCode cc; |
|||
}; |
|||
|
|||
class ExprBoolean final { |
|||
public: |
|||
explicit ExprBoolean(bool val) : value{val} {} |
|||
|
|||
bool operator==(const ExprBoolean& b) const { |
|||
return value == b.value; |
|||
} |
|||
|
|||
bool value; |
|||
}; |
|||
|
|||
template <typename T, typename... Args> |
|||
Expr MakeExpr(Args&&... args) { |
|||
static_assert(std::is_convertible_v<T, ExprData>); |
|||
return std::make_shared<ExprData>(T(std::forward<Args>(args)...)); |
|||
} |
|||
|
|||
bool ExprAreEqual(Expr first, Expr second); |
|||
|
|||
bool ExprAreOpposite(Expr first, Expr second); |
|||
|
|||
Expr MakeExprNot(Expr first); |
|||
|
|||
Expr MakeExprAnd(Expr first, Expr second); |
|||
|
|||
Expr MakeExprOr(Expr first, Expr second); |
|||
|
|||
bool ExprIsTrue(Expr first); |
|||
|
|||
} // namespace VideoCommon::Shader |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue