2021-05-20 03:58:32 +02:00
|
|
|
// Copyright 2021 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <tuple>
|
|
|
|
|
|
|
|
#include "shader_recompiler/backend/bindings.h"
|
|
|
|
#include "shader_recompiler/backend/glsl/emit_context.h"
|
|
|
|
#include "shader_recompiler/backend/glsl/emit_glsl.h"
|
|
|
|
#include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
|
|
|
|
#include "shader_recompiler/frontend/ir/program.h"
|
|
|
|
#include "shader_recompiler/profile.h"
|
|
|
|
|
|
|
|
#pragma optimize("", off)
|
|
|
|
namespace Shader::Backend::GLSL {
|
|
|
|
namespace {
|
|
|
|
template <class Func>
|
|
|
|
struct FuncTraits {};
|
|
|
|
|
|
|
|
template <class ReturnType_, class... Args>
|
|
|
|
struct FuncTraits<ReturnType_ (*)(Args...)> {
|
|
|
|
using ReturnType = ReturnType_;
|
|
|
|
|
|
|
|
static constexpr size_t NUM_ARGS = sizeof...(Args);
|
|
|
|
|
|
|
|
template <size_t I>
|
|
|
|
using ArgType = std::tuple_element_t<I, std::tuple<Args...>>;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <auto func, typename... Args>
|
|
|
|
void SetDefinition(EmitContext& ctx, IR::Inst* inst, Args... args) {
|
|
|
|
inst->SetDefinition<Id>(func(ctx, std::forward<Args>(args)...));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename ArgType>
|
|
|
|
ArgType Arg(EmitContext& ctx, const IR::Value& arg) {
|
2021-05-21 05:38:38 +02:00
|
|
|
if constexpr (std::is_same_v<ArgType, std::string>) {
|
2021-05-20 03:58:32 +02:00
|
|
|
return ctx.reg_alloc.Consume(arg);
|
|
|
|
} else if constexpr (std::is_same_v<ArgType, const IR::Value&>) {
|
|
|
|
return arg;
|
|
|
|
} else if constexpr (std::is_same_v<ArgType, u32>) {
|
|
|
|
return arg.U32();
|
|
|
|
} else if constexpr (std::is_same_v<ArgType, IR::Attribute>) {
|
|
|
|
return arg.Attribute();
|
|
|
|
} else if constexpr (std::is_same_v<ArgType, IR::Patch>) {
|
|
|
|
return arg.Patch();
|
|
|
|
} else if constexpr (std::is_same_v<ArgType, IR::Reg>) {
|
|
|
|
return arg.Reg();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <auto func, bool is_first_arg_inst, size_t... I>
|
|
|
|
void Invoke(EmitContext& ctx, IR::Inst* inst, std::index_sequence<I...>) {
|
|
|
|
using Traits = FuncTraits<decltype(func)>;
|
|
|
|
if constexpr (std::is_same_v<typename Traits::ReturnType, Id>) {
|
|
|
|
if constexpr (is_first_arg_inst) {
|
|
|
|
SetDefinition<func>(
|
2021-05-22 01:28:03 +02:00
|
|
|
ctx, inst, *inst,
|
2021-05-20 03:58:32 +02:00
|
|
|
Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
|
|
|
|
} else {
|
|
|
|
SetDefinition<func>(
|
|
|
|
ctx, inst, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if constexpr (is_first_arg_inst) {
|
2021-05-22 01:28:03 +02:00
|
|
|
func(ctx, *inst, Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...);
|
2021-05-20 03:58:32 +02:00
|
|
|
} else {
|
|
|
|
func(ctx, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <auto func>
|
|
|
|
void Invoke(EmitContext& ctx, IR::Inst* inst) {
|
|
|
|
using Traits = FuncTraits<decltype(func)>;
|
|
|
|
static_assert(Traits::NUM_ARGS >= 1, "Insufficient arguments");
|
|
|
|
if constexpr (Traits::NUM_ARGS == 1) {
|
|
|
|
Invoke<func, false>(ctx, inst, std::make_index_sequence<0>{});
|
|
|
|
} else {
|
|
|
|
using FirstArgType = typename Traits::template ArgType<1>;
|
2021-05-22 01:28:03 +02:00
|
|
|
static constexpr bool is_first_arg_inst = std::is_same_v<FirstArgType, IR::Inst&>;
|
2021-05-20 03:58:32 +02:00
|
|
|
using Indices = std::make_index_sequence<Traits::NUM_ARGS - (is_first_arg_inst ? 2 : 1)>;
|
|
|
|
Invoke<func, is_first_arg_inst>(ctx, inst, Indices{});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void EmitInst(EmitContext& ctx, IR::Inst* inst) {
|
|
|
|
switch (inst->GetOpcode()) {
|
|
|
|
#define OPCODE(name, result_type, ...) \
|
|
|
|
case IR::Opcode::name: \
|
|
|
|
return Invoke<&Emit##name>(ctx, inst);
|
|
|
|
#include "shader_recompiler/frontend/ir/opcodes.inc"
|
|
|
|
#undef OPCODE
|
|
|
|
}
|
|
|
|
throw LogicError("Invalid opcode {}", inst->GetOpcode());
|
|
|
|
}
|
|
|
|
|
|
|
|
void EmitCode(EmitContext& ctx, const IR::Program& program) {
|
|
|
|
for (const IR::AbstractSyntaxNode& node : program.syntax_list) {
|
|
|
|
switch (node.type) {
|
|
|
|
case IR::AbstractSyntaxNode::Type::Block:
|
|
|
|
for (IR::Inst& inst : node.data.block->Instructions()) {
|
|
|
|
EmitInst(ctx, &inst);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IR::AbstractSyntaxNode::Type::If:
|
|
|
|
ctx.Add("if (");
|
|
|
|
break;
|
|
|
|
case IR::AbstractSyntaxNode::Type::EndIf:
|
|
|
|
ctx.Add("){{");
|
|
|
|
break;
|
|
|
|
case IR::AbstractSyntaxNode::Type::Loop:
|
|
|
|
ctx.Add("while (");
|
|
|
|
break;
|
|
|
|
case IR::AbstractSyntaxNode::Type::Repeat:
|
|
|
|
if (node.data.repeat.cond.IsImmediate()) {
|
|
|
|
if (node.data.repeat.cond.U1()) {
|
|
|
|
ctx.Add("ENDREP;");
|
|
|
|
} else {
|
|
|
|
ctx.Add("BRK;"
|
|
|
|
"ENDREP;");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IR::AbstractSyntaxNode::Type::Break:
|
|
|
|
if (node.data.break_node.cond.IsImmediate()) {
|
|
|
|
if (node.data.break_node.cond.U1()) {
|
|
|
|
ctx.Add("break;");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IR::AbstractSyntaxNode::Type::Return:
|
|
|
|
case IR::AbstractSyntaxNode::Type::Unreachable:
|
|
|
|
ctx.Add("return;");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ctx.Add("UNAHNDLED {}", node.type);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // Anonymous namespace
|
|
|
|
|
|
|
|
std::string EmitGLSL(const Profile& profile, IR::Program& program, Bindings& bindings) {
|
|
|
|
EmitContext ctx{program, bindings, profile};
|
|
|
|
// ctx.SetupBuffers();
|
|
|
|
EmitCode(ctx, program);
|
|
|
|
ctx.code += "}";
|
|
|
|
return ctx.code;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Shader::Backend::GLSL
|