octo/yuzu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

shader: Implement indexed attributes

Browse Source
This commit is contained in:
FernandoS27
2021-04-04 06:47:14 +02:00
committed by ameerj
parent 0df7e509db
commit 1d51803169
12 changed files with 279 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
src/shader_recompiler/backend/spirv/emit_context.cpp
View File

@@ -82,6 +82,28 @@ Id GetAttributeType(EmitContext& ctx, AttributeType type) {
}
throw InvalidArgument("Invalid attribute type {}", type);
}
struct AttrInfo {
Id pointer;
Id id;
bool needs_cast;
};
std::optional<AttrInfo> AttrTypes(EmitContext& ctx, u32 index) {
const AttributeType type{ctx.profile.generic_input_types.at(index)};
switch (type) {
case AttributeType::Float:
return AttrInfo{ctx.input_f32, ctx.F32[1], false};
case AttributeType::UnsignedInt:
return AttrInfo{ctx.input_u32, ctx.U32[1], true};
case AttributeType::SignedInt:
return AttrInfo{ctx.input_s32, ctx.TypeInt(32, true), true};
case AttributeType::Disabled:
return std::nullopt;
}
throw InvalidArgument("Invalid attribute type {}", type);
}
} // Anonymous namespace
void VectorTypes::Define(Sirit::Module& sirit_ctx, Id base_type, std::string_view name) {
@@ -107,6 +129,7 @@ EmitContext::EmitContext(const Profile& profile_, IR::Program& program, u32& bin
DefineConstantBuffers(program.info, binding);
DefineStorageBuffers(program.info, binding);
DefineTextures(program.info, binding);
DefineAttributeMemAccess(program.info);
DefineLabels(program);
}
@@ -290,6 +313,107 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
}
}
void EmitContext::DefineAttributeMemAccess(const Info& info) {
const auto make_load{[&]() {
const Id end_block{OpLabel()};
const Id default_label{OpLabel()};
const Id func_type_load{TypeFunction(F32[1], U32[1])};
const Id func{OpFunction(F32[1], spv::FunctionControlMask::MaskNone, func_type_load)};
const Id offset{OpFunctionParameter(U32[1])};
AddLabel();
const Id base_index{OpShiftRightLogical(U32[1], offset, Constant(U32[1], 2U))};
const Id masked_index{OpBitwiseAnd(U32[1], base_index, Constant(U32[1], 3U))};
const Id compare_index{OpShiftRightLogical(U32[1], base_index, Constant(U32[1], 2U))};
std::vector<Sirit::Literal> literals;
std::vector<Id> labels;
const u32 base_attribute_value = static_cast<u32>(IR::Attribute::Generic0X) >> 2;
for (u32 i = 0; i < info.input_generics.size(); i++) {
if (!info.input_generics[i].used) {
continue;
}
literals.push_back(base_attribute_value + i);
labels.push_back(OpLabel());
}
OpSelectionMerge(end_block, spv::SelectionControlMask::MaskNone);
OpSwitch(compare_index, default_label, literals, labels);
AddLabel(default_label);
OpReturnValue(Constant(F32[1], 0.0f));
size_t label_index = 0;
for (u32 i = 0; i < info.input_generics.size(); i++) {
if (!info.input_generics[i].used) {
continue;
}
AddLabel(labels[label_index]);
const auto type{AttrTypes(*this, i)};
if (!type) {
OpReturnValue(Constant(F32[1], 0.0f));
label_index++;
continue;
}
const Id generic_id{input_generics.at(i)};
const Id pointer{OpAccessChain(type->pointer, generic_id, masked_index)};
const Id value{OpLoad(type->id, pointer)};
const Id result{type->needs_cast ? OpBitcast(F32[1], value) : value};
OpReturnValue(result);
label_index++;
}
AddLabel(end_block);
OpUnreachable();
OpFunctionEnd();
return func;
}};
const auto make_store{[&]() {
const Id end_block{OpLabel()};
const Id default_label{OpLabel()};
const Id func_type_store{TypeFunction(void_id, U32[1], F32[1])};
const Id func{OpFunction(void_id, spv::FunctionControlMask::MaskNone, func_type_store)};
const Id offset{OpFunctionParameter(U32[1])};
const Id store_value{OpFunctionParameter(F32[1])};
AddLabel();
const Id base_index{OpShiftRightLogical(U32[1], offset, Constant(U32[1], 2U))};
const Id masked_index{OpBitwiseAnd(U32[1], base_index, Constant(U32[1], 3U))};
const Id compare_index{OpShiftRightLogical(U32[1], base_index, Constant(U32[1], 2U))};
std::vector<Sirit::Literal> literals;
std::vector<Id> labels;
const u32 base_attribute_value = static_cast<u32>(IR::Attribute::Generic0X) >> 2;
for (u32 i = 0; i < info.stores_generics.size(); i++) {
if (!info.stores_generics[i]) {
continue;
}
literals.push_back(base_attribute_value + i);
labels.push_back(OpLabel());
}
OpSelectionMerge(end_block, spv::SelectionControlMask::MaskNone);
OpSwitch(compare_index, default_label, literals, labels);
AddLabel(default_label);
OpReturn();
size_t label_index = 0;
for (u32 i = 0; i < info.stores_generics.size(); i++) {
if (!info.stores_generics[i]) {
continue;
}
AddLabel(labels[label_index]);
const Id generic_id{output_generics.at(i)};
const Id pointer{OpAccessChain(output_f32, generic_id, masked_index)};
OpStore(pointer, store_value);
OpReturn();
label_index++;
}
AddLabel(end_block);
OpUnreachable();
OpFunctionEnd();
return func;
}};
if (info.loads_indexed_attributes) {
indexed_load_func = make_load();
}
if (info.stores_indexed_attributes) {
indexed_store_func = make_store();
}
}
void EmitContext::DefineConstantBuffers(const Info& info, u32& binding) {
if (info.constant_buffer_descriptors.empty()) {
return;

4
src/shader_recompiler/backend/spirv/emit_context.h
View File

@@ -116,6 +116,9 @@ public:
Id fswzadd_lut_a{};
Id fswzadd_lut_b{};
Id indexed_load_func{};
Id indexed_store_func{};
Id local_memory{};
Id shared_memory_u8{};
@@ -148,6 +151,7 @@ private:
void DefineConstantBuffers(const Info& info, u32& binding);
void DefineStorageBuffers(const Info& info, u32& binding);
void DefineTextures(const Info& info, u32& binding);
void DefineAttributeMemAccess(const Info& info);
void DefineLabels(IR::Program& program);
void DefineConstantBuffers(const Info& info, Id UniformDefinitions::*member_type, u32 binding,

4
src/shader_recompiler/backend/spirv/emit_spirv.h
View File

@@ -51,8 +51,8 @@ Id EmitGetCbufF32(EmitContext& ctx, const IR::Value& binding, const IR::Value& o
Id EmitGetCbufU32x2(EmitContext& ctx, const IR::Value& binding, const IR::Value& offset);
Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr);
void EmitSetAttribute(EmitContext& ctx, IR::Attribute attr, Id value);
void EmitGetAttributeIndexed(EmitContext& ctx);
void EmitSetAttributeIndexed(EmitContext& ctx);
Id EmitGetAttributeIndexed(EmitContext& ctx, Id offset);
void EmitSetAttributeIndexed(EmitContext& ctx, Id offset, Id value);
void EmitSetFragColor(EmitContext& ctx, u32 index, u32 component, Id value);
void EmitSetFragDepth(EmitContext& ctx, Id value);
void EmitGetZFlag(EmitContext& ctx);

8
src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp
View File

@@ -216,12 +216,12 @@ void EmitSetAttribute(EmitContext& ctx, IR::Attribute attr, Id value) {
ctx.OpStore(*output, value);
}
void EmitGetAttributeIndexed(EmitContext&) {
throw NotImplementedException("SPIR-V Instruction");
Id EmitGetAttributeIndexed(EmitContext& ctx, Id offset) {
return ctx.OpFunctionCall(ctx.F32[1], ctx.indexed_load_func, offset);
}
void EmitSetAttributeIndexed(EmitContext&) {
throw NotImplementedException("SPIR-V Instruction");
void EmitSetAttributeIndexed(EmitContext& ctx, Id offset, Id value) {
ctx.OpFunctionCall(ctx.void_id, ctx.indexed_store_func, offset, value);
}
void EmitSetFragColor(EmitContext& ctx, u32 index, u32 component, Id value) {

8
src/shader_recompiler/frontend/ir/ir_emitter.cpp
View File

@@ -307,6 +307,14 @@ void IREmitter::SetAttribute(IR::Attribute attribute, const F32& value) {
Inst(Opcode::SetAttribute, attribute, value);
}
F32 IREmitter::GetAttributeIndexed(IR::U32 phys_address) {
return Inst<F32>(Opcode::GetAttributeIndexed, phys_address);
}
void IREmitter::SetAttributeIndexed(IR::U32 phys_address, const F32& value) {
Inst(Opcode::SetAttributeIndexed, phys_address, value);
}
void IREmitter::SetFragColor(u32 index, u32 component, const F32& value) {
Inst(Opcode::SetFragColor, Imm32(index), Imm32(component), value);
}

3
src/shader_recompiler/frontend/ir/ir_emitter.h
View File

@@ -76,6 +76,9 @@ public:
[[nodiscard]] F32 GetAttribute(IR::Attribute attribute);
void SetAttribute(IR::Attribute attribute, const F32& value);
[[nodiscard]] F32 GetAttributeIndexed(IR::U32 phys_address);
void SetAttributeIndexed(IR::U32 phys_address, const F32& value);
void SetFragColor(u32 index, u32 component, const F32& value);
void SetFragDepth(const F32& value);

2
src/shader_recompiler/frontend/maxwell/program.cpp
View File

@@ -87,7 +87,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
Optimization::DeadCodeEliminationPass(program);
Optimization::IdentityRemovalPass(program);
Optimization::VerificationPass(program);
Optimization::CollectShaderInfoPass(program);
Optimization::CollectShaderInfoPass(env, program);
CollectInterpolationInfo(env, program);
return program;
}

38
src/shader_recompiler/frontend/maxwell/translate/impl/load_store_attribute.cpp
View File

@@ -31,7 +31,7 @@ enum class SampleMode : u64 {
Offset,
};
int NumElements(Size size) {
u32 NumElements(Size size) {
switch (size) {
case Size::B32:
return 1;
@@ -65,15 +65,21 @@ void TranslatorVisitor::ALD(u64 insn) {
if (ald.patch != 0) {
throw NotImplementedException("P");
}
if (ald.index_reg != IR::Reg::RZ) {
throw NotImplementedException("Indexed");
}
const u64 offset{ald.absolute_offset.Value()};
if (offset % 4 != 0) {
throw NotImplementedException("Unaligned absolute offset {}", offset);
}
const int num_elements{NumElements(ald.size)};
for (int element = 0; element < num_elements; ++element) {
const u32 num_elements{NumElements(ald.size)};
if (ald.index_reg != IR::Reg::RZ) {
const IR::U32 index_value = X(ald.index_reg);
for (u32 element = 0; element < num_elements; ++element) {
const IR::U32 final_offset =
element == 0 ? index_value : IR::U32{ir.IAdd(index_value, ir.Imm32(element * 4U))};
F(ald.dest_reg + element, ir.GetAttributeIndexed(final_offset));
}
return;
}
for (u32 element = 0; element < num_elements; ++element) {
F(ald.dest_reg + element, ir.GetAttribute(IR::Attribute{offset / 4 + element}));
}
}
@@ -103,8 +109,17 @@ void TranslatorVisitor::AST(u64 insn) {
if (offset % 4 != 0) {
throw NotImplementedException("Unaligned absolute offset {}", offset);
}
const int num_elements{NumElements(ast.size)};
for (int element = 0; element < num_elements; ++element) {
const u32 num_elements{NumElements(ast.size)};
if (ast.index_reg != IR::Reg::RZ) {
const IR::U32 index_value = X(ast.index_reg);
for (u32 element = 0; element < num_elements; ++element) {
const IR::U32 final_offset =
element == 0 ? index_value : IR::U32{ir.IAdd(index_value, ir.Imm32(element * 4U))};
ir.SetAttributeIndexed(final_offset, F(ast.src_reg + element));
}
return;
}
for (u32 element = 0; element < num_elements; ++element) {
ir.SetAttribute(IR::Attribute{offset / 4 + element}, F(ast.src_reg + element));
}
}
@@ -134,12 +149,9 @@ void TranslatorVisitor::IPA(u64 insn) {
// gl_FragColor = colors[idx];
// }
const bool is_indexed{ipa.idx != 0 && ipa.index_reg != IR::Reg::RZ};
if (is_indexed) {
throw NotImplementedException("IDX");
}
const IR::Attribute attribute{ipa.attribute};
IR::F32 value{ir.GetAttribute(attribute)};
IR::F32 value{is_indexed ? ir.GetAttributeIndexed(X(ipa.index_reg))
: ir.GetAttribute(attribute)};
if (IR::IsGeneric(attribute)) {
const ProgramHeader& sph{env.SPH()};
const u32 attr_index{IR::GenericAttributeIndex(attribute)};

36
src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp
View File

@@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "shader_recompiler/environment.h"
#include "shader_recompiler/frontend/ir/microinstruction.h"
#include "shader_recompiler/frontend/ir/modifiers.h"
#include "shader_recompiler/frontend/ir/program.h"
@@ -323,6 +324,12 @@ void VisitUsages(Info& info, IR::Inst& inst) {
case IR::Opcode::SetAttribute:
SetAttribute(info, inst.Arg(0).Attribute());
break;
case IR::Opcode::GetAttributeIndexed:
info.loads_indexed_attributes = true;
break;
case IR::Opcode::SetAttributeIndexed:
info.stores_indexed_attributes = true;
break;
case IR::Opcode::SetFragColor:
info.stores_frag_color[inst.Arg(0).U32()] = true;
break;
@@ -502,15 +509,42 @@ void Visit(Info& info, IR::Inst& inst) {
VisitUsages(info, inst);
VisitFpModifiers(info, inst);
}
void GatherInfoFromHeader(Environment& env, Info& info) {
auto stage = env.ShaderStage();
if (stage == Stage::Compute) {
return;
}
const auto& header = env.SPH();
if (stage == Stage::Fragment) {
for (size_t i = 0; i < info.input_generics.size(); i++) {
info.input_generics[i].used =
info.input_generics[i].used || header.ps.IsGenericVectorActive(i);
}
return;
}
for (size_t i = 0; i < info.input_generics.size(); i++) {
info.input_generics[i].used =
info.input_generics[i].used || header.vtg.IsInputGenericVectorActive(i);
}
for (size_t i = 0; i < info.stores_generics.size(); i++) {
info.stores_generics[i] =
info.stores_generics[i] || header.vtg.IsOutputGenericVectorActive(i);
}
info.stores_clip_distance =
info.stores_clip_distance || header.vtg.omap_systemc.clip_distances != 0;
}
} // Anonymous namespace
void CollectShaderInfoPass(IR::Program& program) {
void CollectShaderInfoPass(Environment& env, IR::Program& program) {
Info& info{program.info};
for (IR::Block* const block : program.post_order_blocks) {
for (IR::Inst& inst : block->Instructions()) {
Visit(info, inst);
}
}
GatherInfoFromHeader(env, info);
}
} // namespace Shader::Optimization

2
src/shader_recompiler/ir_opt/passes.h
View File

@@ -12,7 +12,7 @@
namespace Shader::Optimization {
void CollectShaderInfoPass(IR::Program& program);
void CollectShaderInfoPass(Environment& env, IR::Program& program);
void ConstantPropagationPass(IR::Program& program);
void DeadCodeEliminationPass(IR::Program& program);
void GlobalMemoryToStorageBufferPass(IR::Program& program);

83
src/shader_recompiler/program_header.h
View File

@@ -68,10 +68,24 @@ struct ProgramHeader {
union {
struct {
INSERT_PADDING_BYTES_NOINIT(3); // ImapSystemValuesA
INSERT_PADDING_BYTES_NOINIT(1); // ImapSystemValuesB
INSERT_PADDING_BYTES_NOINIT(16); // ImapGenericVector[32]
INSERT_PADDING_BYTES_NOINIT(2); // ImapColor
INSERT_PADDING_BYTES_NOINIT(3); // ImapSystemValuesA
INSERT_PADDING_BYTES_NOINIT(1); // ImapSystemValuesB
union {
BitField<0, 1, u8> x;
BitField<1, 1, u8> y;
BitField<2, 1, u8> z;
BitField<3, 1, u8> w;
BitField<4, 1, u8> x2;
BitField<5, 1, u8> y2;
BitField<6, 1, u8> z2;
BitField<7, 1, u8> w2;
BitField<0, 4, u8> first;
BitField<4, 4, u8> second;
u8 raw;
} imap_generic_vector[16];
INSERT_PADDING_BYTES_NOINIT(2); // ImapColor
union {
BitField<0, 8, u16> clip_distances;
BitField<8, 1, u16> point_sprite_s;
@@ -82,15 +96,54 @@ struct ProgramHeader {
BitField<14, 1, u16> instance_id;
BitField<15, 1, u16> vertex_id;
};
INSERT_PADDING_BYTES_NOINIT(5); // ImapFixedFncTexture[10]
INSERT_PADDING_BYTES_NOINIT(1); // ImapReserved
INSERT_PADDING_BYTES_NOINIT(3); // OmapSystemValuesA
INSERT_PADDING_BYTES_NOINIT(1); // OmapSystemValuesB
INSERT_PADDING_BYTES_NOINIT(16); // OmapGenericVector[32]
INSERT_PADDING_BYTES_NOINIT(2); // OmapColor
INSERT_PADDING_BYTES_NOINIT(2); // OmapSystemValuesC
INSERT_PADDING_BYTES_NOINIT(5); // OmapFixedFncTexture[10]
INSERT_PADDING_BYTES_NOINIT(1); // OmapReserved
INSERT_PADDING_BYTES_NOINIT(5); // ImapFixedFncTexture[10]
INSERT_PADDING_BYTES_NOINIT(1); // ImapReserved
INSERT_PADDING_BYTES_NOINIT(3); // OmapSystemValuesA
INSERT_PADDING_BYTES_NOINIT(1); // OmapSystemValuesB
union {
BitField<0, 1, u8> x;
BitField<1, 1, u8> y;
BitField<2, 1, u8> z;
BitField<3, 1, u8> w;
BitField<4, 1, u8> x2;
BitField<5, 1, u8> y2;
BitField<6, 1, u8> z2;
BitField<7, 1, u8> w2;
BitField<0, 4, u8> first;
BitField<4, 4, u8> second;
u8 raw;
} omap_generic_vector[16];
INSERT_PADDING_BYTES_NOINIT(2); // OmapColor
union {
BitField<0, 8, u16> clip_distances;
BitField<8, 1, u16> point_sprite_s;
BitField<9, 1, u16> point_sprite_t;
BitField<10, 1, u16> fog_coordinate;
BitField<12, 1, u16> tessellation_eval_point_u;
BitField<13, 1, u16> tessellation_eval_point_v;
BitField<14, 1, u16> instance_id;
BitField<15, 1, u16> vertex_id;
} omap_systemc;
INSERT_PADDING_BYTES_NOINIT(5); // OmapFixedFncTexture[10]
INSERT_PADDING_BYTES_NOINIT(1); // OmapReserved
[[nodiscard]] bool IsInputGenericVectorActive(size_t index) const {
if ((index & 1) == 0) {
return imap_generic_vector[index >> 1].first != 0;
}
return imap_generic_vector[index >> 1].second != 0;
}
[[nodiscard]] bool IsOutputGenericVectorActive(size_t index) const {
if ((index & 1) == 0) {
return omap_generic_vector[index >> 1].first != 0;
}
return omap_generic_vector[index >> 1].second != 0;
}
} vtg;
struct {
@@ -128,6 +181,10 @@ struct ProgramHeader {
const auto& vector{imap_generic_vector[attribute]};
return {vector.x, vector.y, vector.z, vector.w};
}
[[nodiscard]] bool IsGenericVectorActive(size_t index) const {
return imap_generic_vector[index].raw != 0;
}
} ps;
std::array<u32, 0xf> raw;

2
src/shader_recompiler/shader_info.h
View File

@@ -76,6 +76,7 @@ struct Info {
bool loads_vertex_id{};
bool loads_front_face{};
bool loads_point_coord{};
bool loads_indexed_attributes{};
std::array<bool, 8> stores_frag_color{};
bool stores_frag_depth{};
@@ -84,6 +85,7 @@ struct Info {
bool stores_point_size{};
bool stores_clip_distance{};
bool stores_viewport_index{};
bool stores_indexed_attributes{};
bool uses_fp16{};
bool uses_fp64{};