mirror of
https://git.suyu.dev/suyu/suyu.git
synced 2024-11-25 04:46:27 -05:00
ca05a13c62
Add support for null registers. These are used when an instruction has no usages. This comes handy when an instruction is only used for its CC value, with the caveat of having to invalidate all pseudo-instructions before defining the instruction itself in the register allocator. This commits changes this. Workaround a bug on Nvidia's condition codes conditional execution using branches.
244 lines
10 KiB
C++
244 lines
10 KiB
C++
// Copyright 2021 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "shader_recompiler/backend/glasm/emit_context.h"
|
|
#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
|
|
#include "shader_recompiler/frontend/ir/value.h"
|
|
|
|
namespace Shader::Backend::GLASM {
|
|
namespace {
|
|
template <auto read_imm, char type, typename... Values>
|
|
void CompositeConstruct(EmitContext& ctx, IR::Inst& inst, Values&&... elements) {
|
|
const Register ret{ctx.reg_alloc.Define(inst)};
|
|
if (std::ranges::any_of(std::array{elements...},
|
|
[](const IR::Value& value) { return value.IsImmediate(); })) {
|
|
using Type = std::invoke_result_t<decltype(read_imm), IR::Value>;
|
|
const std::array<Type, 4> values{(elements.IsImmediate() ? (elements.*read_imm)() : 0)...};
|
|
ctx.Add("MOV.{} {},{{{},{},{},{}}};", type, ret, fmt::to_string(values[0]),
|
|
fmt::to_string(values[1]), fmt::to_string(values[2]), fmt::to_string(values[3]));
|
|
}
|
|
size_t index{};
|
|
for (const IR::Value& element : {elements...}) {
|
|
if (!element.IsImmediate()) {
|
|
const ScalarU32 value{ctx.reg_alloc.Consume(element)};
|
|
ctx.Add("MOV.{} {}.{},{};", type, ret, "xyzw"[index], value);
|
|
}
|
|
++index;
|
|
}
|
|
}
|
|
|
|
void CompositeExtract(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index, char type) {
|
|
const Register ret{ctx.reg_alloc.Define(inst)};
|
|
if (ret == composite && index == 0) {
|
|
// No need to do anything here, the source and destination are the same register
|
|
return;
|
|
}
|
|
ctx.Add("MOV.{} {}.x,{}.{};", type, ret, composite, "xyzw"[index]);
|
|
}
|
|
|
|
template <typename ObjectType>
|
|
void CompositeInsert(EmitContext& ctx, IR::Inst& inst, Register composite, ObjectType object,
|
|
u32 index, char type) {
|
|
const Register ret{ctx.reg_alloc.Define(inst)};
|
|
const char swizzle{"xyzw"[index]};
|
|
if (ret != composite && ret == object) {
|
|
// The object is aliased with the return value, so we have to use a temporary to insert
|
|
ctx.Add("MOV.{} RC,{};"
|
|
"MOV.{} RC.{},{};"
|
|
"MOV.{} {},RC;",
|
|
type, composite, type, swizzle, object, type, ret);
|
|
} else if (ret != composite) {
|
|
// The input composite is not aliased with the return value so we have to copy it before
|
|
// hand. But the insert object is not aliased with the return value, so we don't have to
|
|
// worry about that
|
|
ctx.Add("MOV.{} {},{};"
|
|
"MOV.{} {}.{},{};",
|
|
type, ret, composite, type, ret, swizzle, object);
|
|
} else {
|
|
// The return value is alised so we can just insert the object, it doesn't matter if it's
|
|
// aliased
|
|
ctx.Add("MOV.{} {}.{},{};", type, ret, swizzle, object);
|
|
}
|
|
}
|
|
} // Anonymous namespace
|
|
|
|
void EmitCompositeConstructU32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
|
|
const IR::Value& e2) {
|
|
CompositeConstruct<&IR::Value::U32, 'U'>(ctx, inst, e1, e2);
|
|
}
|
|
|
|
void EmitCompositeConstructU32x3(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
|
|
const IR::Value& e2, const IR::Value& e3) {
|
|
CompositeConstruct<&IR::Value::U32, 'U'>(ctx, inst, e1, e2, e3);
|
|
}
|
|
|
|
void EmitCompositeConstructU32x4(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
|
|
const IR::Value& e2, const IR::Value& e3, const IR::Value& e4) {
|
|
CompositeConstruct<&IR::Value::U32, 'U'>(ctx, inst, e1, e2, e3, e4);
|
|
}
|
|
|
|
void EmitCompositeExtractU32x2(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
|
|
CompositeExtract(ctx, inst, composite, index, 'U');
|
|
}
|
|
|
|
void EmitCompositeExtractU32x3(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
|
|
CompositeExtract(ctx, inst, composite, index, 'U');
|
|
}
|
|
|
|
void EmitCompositeExtractU32x4(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
|
|
CompositeExtract(ctx, inst, composite, index, 'U');
|
|
}
|
|
|
|
void EmitCompositeInsertU32x2([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite,
|
|
[[maybe_unused]] ScalarU32 object, [[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertU32x3([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite,
|
|
[[maybe_unused]] ScalarU32 object, [[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertU32x4([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite,
|
|
[[maybe_unused]] ScalarU32 object, [[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeConstructF16x2([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register e1,
|
|
[[maybe_unused]] Register e2) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeConstructF16x3([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register e1,
|
|
[[maybe_unused]] Register e2, [[maybe_unused]] Register e3) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeConstructF16x4([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register e1,
|
|
[[maybe_unused]] Register e2, [[maybe_unused]] Register e3,
|
|
[[maybe_unused]] Register e4) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeExtractF16x2([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeExtractF16x3([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeExtractF16x4([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertF16x2([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] Register object,
|
|
[[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertF16x3([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] Register object,
|
|
[[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertF16x4([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] Register object,
|
|
[[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeConstructF32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
|
|
const IR::Value& e2) {
|
|
CompositeConstruct<&IR::Value::F32, 'F'>(ctx, inst, e1, e2);
|
|
}
|
|
|
|
void EmitCompositeConstructF32x3(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
|
|
const IR::Value& e2, const IR::Value& e3) {
|
|
CompositeConstruct<&IR::Value::F32, 'F'>(ctx, inst, e1, e2, e3);
|
|
}
|
|
|
|
void EmitCompositeConstructF32x4(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
|
|
const IR::Value& e2, const IR::Value& e3, const IR::Value& e4) {
|
|
CompositeConstruct<&IR::Value::F32, 'F'>(ctx, inst, e1, e2, e3, e4);
|
|
}
|
|
|
|
void EmitCompositeExtractF32x2(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
|
|
CompositeExtract(ctx, inst, composite, index, 'F');
|
|
}
|
|
|
|
void EmitCompositeExtractF32x3(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
|
|
CompositeExtract(ctx, inst, composite, index, 'F');
|
|
}
|
|
|
|
void EmitCompositeExtractF32x4(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
|
|
CompositeExtract(ctx, inst, composite, index, 'F');
|
|
}
|
|
|
|
void EmitCompositeInsertF32x2(EmitContext& ctx, IR::Inst& inst, Register composite,
|
|
ScalarF32 object, u32 index) {
|
|
CompositeInsert(ctx, inst, composite, object, index, 'F');
|
|
}
|
|
|
|
void EmitCompositeInsertF32x3(EmitContext& ctx, IR::Inst& inst, Register composite,
|
|
ScalarF32 object, u32 index) {
|
|
CompositeInsert(ctx, inst, composite, object, index, 'F');
|
|
}
|
|
|
|
void EmitCompositeInsertF32x4(EmitContext& ctx, IR::Inst& inst, Register composite,
|
|
ScalarF32 object, u32 index) {
|
|
CompositeInsert(ctx, inst, composite, object, index, 'F');
|
|
}
|
|
|
|
void EmitCompositeConstructF64x2([[maybe_unused]] EmitContext& ctx) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeConstructF64x3([[maybe_unused]] EmitContext& ctx) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeConstructF64x4([[maybe_unused]] EmitContext& ctx) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeExtractF64x2([[maybe_unused]] EmitContext& ctx) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeExtractF64x3([[maybe_unused]] EmitContext& ctx) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeExtractF64x4([[maybe_unused]] EmitContext& ctx) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertF64x2([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] Register object,
|
|
[[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertF64x3([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] Register object,
|
|
[[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
void EmitCompositeInsertF64x4([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] Register composite, [[maybe_unused]] Register object,
|
|
[[maybe_unused]] u32 index) {
|
|
throw NotImplementedException("GLASM instruction");
|
|
}
|
|
|
|
} // namespace Shader::Backend::GLASM
|