artemist/yuzu
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
yuzu/src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp

971 lines
36 KiB
C++
Raw Normal View History

spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
// Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
shader: Align constant buffer sizes to 16 bytes WAR for AMD reading zeroes on uniform buffers of size 2.
2021-06-17 23:35:25 +00:00
#include "common/alignment.h"
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
#include "shader_recompiler/environment.h"
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
#include "shader_recompiler/frontend/ir/modifiers.h"
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
#include "shader_recompiler/frontend/ir/program.h"
shader: Move microinstruction header to the value header
2021-04-21 03:35:47 +00:00
#include "shader_recompiler/frontend/ir/value.h"
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
#include "shader_recompiler/ir_opt/passes.h"
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
#include "shader_recompiler/shader_info.h"
namespace Shader::Optimization {
namespace {
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
void AddConstantBufferDescriptor(Info& info, u32 index, u32 count) {
if (count != 1) {
throw NotImplementedException("Constant buffer descriptor indexing");
}
if ((info.constant_buffer_mask & (1U << index)) != 0) {
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
return;
}
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
info.constant_buffer_mask |= 1U << index;
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
auto& cbufs{info.constant_buffer_descriptors};
cbufs.insert(std::ranges::lower_bound(cbufs, index, {}, &ConstantBufferDescriptor::index),
ConstantBufferDescriptor{
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
.index = index,
.count = 1,
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
});
}
shader: add support for const buffer indirect addressing
2022-03-14 23:35:48 +00:00
void AddRegisterIndexedLdc(Info& info) {
shader_recompiler: Use functions for indirect const buffer accesses
2022-03-17 17:30:21 +00:00
info.uses_cbuf_indirect = true;
shader: add support for const buffer indirect addressing
2022-03-14 23:35:48 +00:00
// The shader can use any possible constant buffer
info.constant_buffer_mask = (1 << Info::MAX_CBUFS) - 1;
auto& cbufs{info.constant_buffer_descriptors};
cbufs.clear();
for (u32 i = 0; i < Info::MAX_CBUFS; i++) {
cbufs.push_back(ConstantBufferDescriptor{.index = i, .count = 1});
// The shader can use any possible access size
info.constant_buffer_used_sizes[i] = 0x10'000;
}
}
Address review comments
2022-03-17 18:45:38 +00:00
u32 GetElementSize(IR::Type& used_type, Shader::IR::Opcode opcode) {
switch (opcode) {
case IR::Opcode::GetCbufU8:
case IR::Opcode::GetCbufS8:
used_type |= IR::Type::U8;
return 1;
case IR::Opcode::GetCbufU16:
case IR::Opcode::GetCbufS16:
used_type |= IR::Type::U16;
return 2;
case IR::Opcode::GetCbufU32:
used_type |= IR::Type::U32;
return 4;
case IR::Opcode::GetCbufF32:
used_type |= IR::Type::F32;
return 4;
case IR::Opcode::GetCbufU32x2:
used_type |= IR::Type::U32x2;
return 8;
default:
throw InvalidArgument("Invalid opcode {}", opcode);
}
}
shader: Implement tessellation shaders, polygon mode and invocation id
2021-04-16 01:46:11 +00:00
void GetPatch(Info& info, IR::Patch patch) {
if (!IR::IsGeneric(patch)) {
throw NotImplementedException("Reading non-generic patch {}", patch);
}
info.uses_patches.at(IR::GenericPatchIndex(patch)) = true;
}
void SetPatch(Info& info, IR::Patch patch) {
if (IR::IsGeneric(patch)) {
info.uses_patches.at(IR::GenericPatchIndex(patch)) = true;
return;
}
switch (patch) {
case IR::Patch::TessellationLodLeft:
case IR::Patch::TessellationLodTop:
case IR::Patch::TessellationLodRight:
case IR::Patch::TessellationLodBottom:
info.stores_tess_level_outer = true;
break;
case IR::Patch::TessellationLodInteriorU:
case IR::Patch::TessellationLodInteriorV:
info.stores_tess_level_inner = true;
break;
default:
throw NotImplementedException("Set patch {}", patch);
}
}
shader: Optimize NVN Fallthrough
2021-05-01 23:50:27 +00:00
void CheckCBufNVN(Info& info, IR::Inst& inst) {
const IR::Value cbuf_index{inst.Arg(0)};
if (!cbuf_index.IsImmediate()) {
info.nvn_buffer_used.set();
return;
}
const u32 index{cbuf_index.U32()};
if (index != 0) {
return;
}
const IR::Value cbuf_offset{inst.Arg(1)};
if (!cbuf_offset.IsImmediate()) {
info.nvn_buffer_used.set();
return;
}
const u32 offset{cbuf_offset.U32()};
const u32 descriptor_size{0x10};
const u32 upper_limit{info.nvn_buffer_base + descriptor_size * 16};
if (offset >= info.nvn_buffer_base && offset < upper_limit) {
const std::size_t nvn_index{(offset - info.nvn_buffer_base) / descriptor_size};
info.nvn_buffer_used.set(nvn_index, true);
}
}
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
void VisitUsages(Info& info, IR::Inst& inst) {
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
switch (inst.GetOpcode()) {
spirv: Add lower fp16 to fp32 pass
2021-02-19 21:10:18 +00:00
case IR::Opcode::CompositeConstructF16x2:
case IR::Opcode::CompositeConstructF16x3:
case IR::Opcode::CompositeConstructF16x4:
case IR::Opcode::CompositeExtractF16x2:
case IR::Opcode::CompositeExtractF16x3:
case IR::Opcode::CompositeExtractF16x4:
shader: Add support for fp16 comparisons and misc fixes
2021-03-21 03:42:56 +00:00
case IR::Opcode::CompositeInsertF16x2:
case IR::Opcode::CompositeInsertF16x3:
case IR::Opcode::CompositeInsertF16x4:
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::SelectF16:
spirv: Add lower fp16 to fp32 pass
2021-02-19 21:10:18 +00:00
case IR::Opcode::BitCastU16F16:
case IR::Opcode::BitCastF16U16:
case IR::Opcode::PackFloat2x16:
case IR::Opcode::UnpackFloat2x16:
case IR::Opcode::ConvertS16F16:
case IR::Opcode::ConvertS32F16:
case IR::Opcode::ConvertS64F16:
case IR::Opcode::ConvertU16F16:
case IR::Opcode::ConvertU32F16:
case IR::Opcode::ConvertU64F16:
shader: Implement I2F
2021-03-20 08:04:12 +00:00
case IR::Opcode::ConvertF16S8:
case IR::Opcode::ConvertF16S16:
case IR::Opcode::ConvertF16S32:
case IR::Opcode::ConvertF16S64:
case IR::Opcode::ConvertF16U8:
case IR::Opcode::ConvertF16U16:
case IR::Opcode::ConvertF16U32:
case IR::Opcode::ConvertF16U64:
shader: Mark ConvertF16F32 and ConvertF32F16 as fp16 instructions Fixes instances where fp16 types are not declared on SPIR-V but they are used. This shouldn't happen on master, as it's been uncovered by an additional optimization pass.
2021-07-28 00:33:02 +00:00
case IR::Opcode::ConvertF16F32:
case IR::Opcode::ConvertF32F16:
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
case IR::Opcode::FPAbs16:
case IR::Opcode::FPAdd16:
case IR::Opcode::FPCeil16:
case IR::Opcode::FPFloor16:
case IR::Opcode::FPFma16:
case IR::Opcode::FPMul16:
case IR::Opcode::FPNeg16:
case IR::Opcode::FPRoundEven16:
case IR::Opcode::FPSaturate16:
shader: Fix F2I
2021-03-23 23:02:30 +00:00
case IR::Opcode::FPClamp16:
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
case IR::Opcode::FPTrunc16:
shader: Add support for fp16 comparisons and misc fixes
2021-03-21 03:42:56 +00:00
case IR::Opcode::FPOrdEqual16:
case IR::Opcode::FPUnordEqual16:
case IR::Opcode::FPOrdNotEqual16:
case IR::Opcode::FPUnordNotEqual16:
case IR::Opcode::FPOrdLessThan16:
case IR::Opcode::FPUnordLessThan16:
case IR::Opcode::FPOrdGreaterThan16:
case IR::Opcode::FPUnordGreaterThan16:
case IR::Opcode::FPOrdLessThanEqual16:
case IR::Opcode::FPUnordLessThanEqual16:
case IR::Opcode::FPOrdGreaterThanEqual16:
case IR::Opcode::FPUnordGreaterThanEqual16:
case IR::Opcode::FPIsNan16:
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
case IR::Opcode::GlobalAtomicAddF16x2:
shader: Add NVN storage buffer fallbacks When we can't track the SSBO origin of a global memory instruction, leave it as a global memory operation and assume these pointers are in the NVN storage buffer slots, then apply a linear search in the shader's runtime.
2021-04-19 19:33:23 +00:00
case IR::Opcode::GlobalAtomicMinF16x2:
case IR::Opcode::GlobalAtomicMaxF16x2:
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
case IR::Opcode::StorageAtomicAddF16x2:
case IR::Opcode::StorageAtomicMinF16x2:
case IR::Opcode::StorageAtomicMaxF16x2:
spirv: Add lower fp16 to fp32 pass
2021-02-19 21:10:18 +00:00
info.uses_fp16 = true;
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
break;
shader: Add missing fp64 usage flags
2021-03-21 20:27:44 +00:00
case IR::Opcode::CompositeConstructF64x2:
case IR::Opcode::CompositeConstructF64x3:
case IR::Opcode::CompositeConstructF64x4:
case IR::Opcode::CompositeExtractF64x2:
case IR::Opcode::CompositeExtractF64x3:
case IR::Opcode::CompositeExtractF64x4:
case IR::Opcode::CompositeInsertF64x2:
case IR::Opcode::CompositeInsertF64x3:
case IR::Opcode::CompositeInsertF64x4:
shader: Implement DMNMX, DSET, DSETP
2021-03-21 23:28:37 +00:00
case IR::Opcode::SelectF64:
shader: Add missing fp64 usage flags
2021-03-21 20:27:44 +00:00
case IR::Opcode::BitCastU64F64:
case IR::Opcode::BitCastF64U64:
case IR::Opcode::PackDouble2x32:
case IR::Opcode::UnpackDouble2x32:
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
case IR::Opcode::FPAbs64:
case IR::Opcode::FPAdd64:
case IR::Opcode::FPCeil64:
case IR::Opcode::FPFloor64:
case IR::Opcode::FPFma64:
case IR::Opcode::FPMax64:
case IR::Opcode::FPMin64:
case IR::Opcode::FPMul64:
case IR::Opcode::FPNeg64:
case IR::Opcode::FPRecip64:
case IR::Opcode::FPRecipSqrt64:
case IR::Opcode::FPRoundEven64:
case IR::Opcode::FPSaturate64:
shader: Fix F2I
2021-03-23 23:02:30 +00:00
case IR::Opcode::FPClamp64:
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
case IR::Opcode::FPTrunc64:
shader: Add missing fp64 usage flags
2021-03-21 20:27:44 +00:00
case IR::Opcode::FPOrdEqual64:
case IR::Opcode::FPUnordEqual64:
case IR::Opcode::FPOrdNotEqual64:
case IR::Opcode::FPUnordNotEqual64:
case IR::Opcode::FPOrdLessThan64:
case IR::Opcode::FPUnordLessThan64:
case IR::Opcode::FPOrdGreaterThan64:
case IR::Opcode::FPUnordGreaterThan64:
case IR::Opcode::FPOrdLessThanEqual64:
case IR::Opcode::FPUnordLessThanEqual64:
case IR::Opcode::FPOrdGreaterThanEqual64:
case IR::Opcode::FPUnordGreaterThanEqual64:
case IR::Opcode::FPIsNan64:
case IR::Opcode::ConvertS16F64:
case IR::Opcode::ConvertS32F64:
case IR::Opcode::ConvertS64F64:
case IR::Opcode::ConvertU16F64:
case IR::Opcode::ConvertU32F64:
case IR::Opcode::ConvertU64F64:
case IR::Opcode::ConvertF32F64:
case IR::Opcode::ConvertF64F32:
shader: Implement I2F
2021-03-20 08:04:12 +00:00
case IR::Opcode::ConvertF64S8:
case IR::Opcode::ConvertF64S16:
case IR::Opcode::ConvertF64S32:
case IR::Opcode::ConvertF64S64:
case IR::Opcode::ConvertF64U8:
case IR::Opcode::ConvertF64U16:
case IR::Opcode::ConvertF64U32:
case IR::Opcode::ConvertF64U64:
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
info.uses_fp64 = true;
break;
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
default:
break;
}
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
switch (inst.GetOpcode()) {
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::GetCbufU8:
case IR::Opcode::GetCbufS8:
case IR::Opcode::UndefU8:
case IR::Opcode::LoadGlobalU8:
case IR::Opcode::LoadGlobalS8:
case IR::Opcode::WriteGlobalU8:
case IR::Opcode::WriteGlobalS8:
case IR::Opcode::LoadStorageU8:
case IR::Opcode::LoadStorageS8:
case IR::Opcode::WriteStorageU8:
case IR::Opcode::WriteStorageS8:
shader: Implement LDS, STS, LDL, and STS and use SPIR-V 1.4 when available
2021-03-28 22:53:34 +00:00
case IR::Opcode::LoadSharedU8:
case IR::Opcode::LoadSharedS8:
case IR::Opcode::WriteSharedU8:
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::SelectU8:
shader: Implement I2F
2021-03-20 08:04:12 +00:00
case IR::Opcode::ConvertF16S8:
case IR::Opcode::ConvertF16U8:
case IR::Opcode::ConvertF32S8:
case IR::Opcode::ConvertF32U8:
case IR::Opcode::ConvertF64S8:
case IR::Opcode::ConvertF64U8:
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
info.uses_int8 = true;
break;
default:
break;
}
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
switch (inst.GetOpcode()) {
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::GetCbufU16:
case IR::Opcode::GetCbufS16:
case IR::Opcode::UndefU16:
case IR::Opcode::LoadGlobalU16:
case IR::Opcode::LoadGlobalS16:
case IR::Opcode::WriteGlobalU16:
case IR::Opcode::WriteGlobalS16:
case IR::Opcode::LoadStorageU16:
case IR::Opcode::LoadStorageS16:
case IR::Opcode::WriteStorageU16:
case IR::Opcode::WriteStorageS16:
shader: Implement LDS, STS, LDL, and STS and use SPIR-V 1.4 when available
2021-03-28 22:53:34 +00:00
case IR::Opcode::LoadSharedU16:
case IR::Opcode::LoadSharedS16:
case IR::Opcode::WriteSharedU16:
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::SelectU16:
case IR::Opcode::BitCastU16F16:
case IR::Opcode::BitCastF16U16:
case IR::Opcode::ConvertS16F16:
case IR::Opcode::ConvertS16F32:
case IR::Opcode::ConvertS16F64:
case IR::Opcode::ConvertU16F16:
case IR::Opcode::ConvertU16F32:
case IR::Opcode::ConvertU16F64:
shader: Implement I2F
2021-03-20 08:04:12 +00:00
case IR::Opcode::ConvertF16S16:
case IR::Opcode::ConvertF16U16:
case IR::Opcode::ConvertF32S16:
case IR::Opcode::ConvertF32U16:
case IR::Opcode::ConvertF64S16:
case IR::Opcode::ConvertF64U16:
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
info.uses_int16 = true;
break;
default:
break;
}
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
switch (inst.GetOpcode()) {
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::UndefU64:
case IR::Opcode::LoadGlobalU8:
case IR::Opcode::LoadGlobalS8:
case IR::Opcode::LoadGlobalU16:
case IR::Opcode::LoadGlobalS16:
case IR::Opcode::LoadGlobal32:
case IR::Opcode::LoadGlobal64:
case IR::Opcode::LoadGlobal128:
case IR::Opcode::WriteGlobalU8:
case IR::Opcode::WriteGlobalS8:
case IR::Opcode::WriteGlobalU16:
case IR::Opcode::WriteGlobalS16:
case IR::Opcode::WriteGlobal32:
case IR::Opcode::WriteGlobal64:
case IR::Opcode::WriteGlobal128:
case IR::Opcode::SelectU64:
case IR::Opcode::BitCastU64F64:
case IR::Opcode::BitCastF64U64:
case IR::Opcode::PackUint2x32:
case IR::Opcode::UnpackUint2x32:
case IR::Opcode::IAdd64:
case IR::Opcode::ISub64:
case IR::Opcode::INeg64:
case IR::Opcode::ShiftLeftLogical64:
case IR::Opcode::ShiftRightLogical64:
case IR::Opcode::ShiftRightArithmetic64:
case IR::Opcode::ConvertS64F16:
case IR::Opcode::ConvertS64F32:
case IR::Opcode::ConvertS64F64:
case IR::Opcode::ConvertU64F16:
case IR::Opcode::ConvertU64F32:
case IR::Opcode::ConvertU64F64:
case IR::Opcode::ConvertU64U32:
case IR::Opcode::ConvertU32U64:
case IR::Opcode::ConvertF16U64:
case IR::Opcode::ConvertF32U64:
case IR::Opcode::ConvertF64U64:
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
case IR::Opcode::SharedAtomicExchange64:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
case IR::Opcode::GlobalAtomicIAdd64:
case IR::Opcode::GlobalAtomicSMin64:
case IR::Opcode::GlobalAtomicUMin64:
case IR::Opcode::GlobalAtomicSMax64:
case IR::Opcode::GlobalAtomicUMax64:
case IR::Opcode::GlobalAtomicAnd64:
case IR::Opcode::GlobalAtomicOr64:
case IR::Opcode::GlobalAtomicXor64:
case IR::Opcode::GlobalAtomicExchange64:
case IR::Opcode::StorageAtomicIAdd64:
case IR::Opcode::StorageAtomicSMin64:
case IR::Opcode::StorageAtomicUMin64:
case IR::Opcode::StorageAtomicSMax64:
case IR::Opcode::StorageAtomicUMax64:
case IR::Opcode::StorageAtomicAnd64:
case IR::Opcode::StorageAtomicOr64:
case IR::Opcode::StorageAtomicXor64:
shader: Add NVN storage buffer fallbacks When we can't track the SSBO origin of a global memory instruction, leave it as a global memory operation and assume these pointers are in the NVN storage buffer slots, then apply a linear search in the shader's runtime.
2021-04-19 19:33:23 +00:00
case IR::Opcode::StorageAtomicExchange64:
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
info.uses_int64 = true;
break;
default:
break;
}
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
switch (inst.GetOpcode()) {
shader: Add NVN storage buffer fallbacks When we can't track the SSBO origin of a global memory instruction, leave it as a global memory operation and assume these pointers are in the NVN storage buffer slots, then apply a linear search in the shader's runtime.
2021-04-19 19:33:23 +00:00
case IR::Opcode::WriteGlobalU8:
case IR::Opcode::WriteGlobalS8:
case IR::Opcode::WriteGlobalU16:
case IR::Opcode::WriteGlobalS16:
case IR::Opcode::WriteGlobal32:
case IR::Opcode::WriteGlobal64:
case IR::Opcode::WriteGlobal128:
case IR::Opcode::GlobalAtomicIAdd32:
case IR::Opcode::GlobalAtomicSMin32:
case IR::Opcode::GlobalAtomicUMin32:
case IR::Opcode::GlobalAtomicSMax32:
case IR::Opcode::GlobalAtomicUMax32:
case IR::Opcode::GlobalAtomicInc32:
case IR::Opcode::GlobalAtomicDec32:
case IR::Opcode::GlobalAtomicAnd32:
case IR::Opcode::GlobalAtomicOr32:
case IR::Opcode::GlobalAtomicXor32:
case IR::Opcode::GlobalAtomicExchange32:
case IR::Opcode::GlobalAtomicIAdd64:
case IR::Opcode::GlobalAtomicSMin64:
case IR::Opcode::GlobalAtomicUMin64:
case IR::Opcode::GlobalAtomicSMax64:
case IR::Opcode::GlobalAtomicUMax64:
case IR::Opcode::GlobalAtomicAnd64:
case IR::Opcode::GlobalAtomicOr64:
case IR::Opcode::GlobalAtomicXor64:
case IR::Opcode::GlobalAtomicExchange64:
shaders: Add U64->U32x2 Atomic fallback functions
2022-01-29 18:46:06 +00:00
case IR::Opcode::GlobalAtomicIAdd32x2:
case IR::Opcode::GlobalAtomicSMin32x2:
case IR::Opcode::GlobalAtomicUMin32x2:
case IR::Opcode::GlobalAtomicSMax32x2:
case IR::Opcode::GlobalAtomicUMax32x2:
case IR::Opcode::GlobalAtomicAnd32x2:
case IR::Opcode::GlobalAtomicOr32x2:
case IR::Opcode::GlobalAtomicXor32x2:
case IR::Opcode::GlobalAtomicExchange32x2:
shader: Add NVN storage buffer fallbacks When we can't track the SSBO origin of a global memory instruction, leave it as a global memory operation and assume these pointers are in the NVN storage buffer slots, then apply a linear search in the shader's runtime.
2021-04-19 19:33:23 +00:00
case IR::Opcode::GlobalAtomicAddF32:
case IR::Opcode::GlobalAtomicAddF16x2:
case IR::Opcode::GlobalAtomicAddF32x2:
case IR::Opcode::GlobalAtomicMinF16x2:
case IR::Opcode::GlobalAtomicMinF32x2:
case IR::Opcode::GlobalAtomicMaxF16x2:
case IR::Opcode::GlobalAtomicMaxF32x2:
shader: Optimize NVN Fallthrough
2021-05-01 23:50:27 +00:00
info.stores_global_memory = true;
[[fallthrough]];
case IR::Opcode::LoadGlobalU8:
case IR::Opcode::LoadGlobalS8:
case IR::Opcode::LoadGlobalU16:
case IR::Opcode::LoadGlobalS16:
case IR::Opcode::LoadGlobal32:
case IR::Opcode::LoadGlobal64:
case IR::Opcode::LoadGlobal128:
shader: Add NVN storage buffer fallbacks When we can't track the SSBO origin of a global memory instruction, leave it as a global memory operation and assume these pointers are in the NVN storage buffer slots, then apply a linear search in the shader's runtime.
2021-04-19 19:33:23 +00:00
info.uses_int64 = true;
info.uses_global_memory = true;
info.used_constant_buffer_types |= IR::Type::U32 | IR::Type::U32x2;
info.used_storage_buffer_types |= IR::Type::U32 | IR::Type::U32x2 | IR::Type::U32x4;
break;
default:
break;
}
switch (inst.GetOpcode()) {
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
case IR::Opcode::DemoteToHelperInvocation:
info.uses_demote_to_helper_invocation = true;
break;
case IR::Opcode::GetAttribute:
shader: Add integer attribute get optimization pass Works around an nvidia driver bug, where casting the integer attributes to float and back to an integer always returned 0.
2021-12-25 01:00:28 +00:00
case IR::Opcode::GetAttributeU32:
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
info.loads.mask[static_cast<size_t>(inst.Arg(0).Attribute())] = true;
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
break;
case IR::Opcode::SetAttribute:
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
info.stores.mask[static_cast<size_t>(inst.Arg(0).Attribute())] = true;
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
break;
shader: Implement tessellation shaders, polygon mode and invocation id
2021-04-16 01:46:11 +00:00
case IR::Opcode::GetPatch:
GetPatch(info, inst.Arg(0).Patch());
break;
case IR::Opcode::SetPatch:
SetPatch(info, inst.Arg(0).Patch());
break;
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
case IR::Opcode::GetAttributeIndexed:
info.loads_indexed_attributes = true;
break;
case IR::Opcode::SetAttributeIndexed:
info.stores_indexed_attributes = true;
break;
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
case IR::Opcode::SetFragColor:
info.stores_frag_color[inst.Arg(0).U32()] = true;
break;
shader: Implement SampleMask
2021-04-16 21:47:26 +00:00
case IR::Opcode::SetSampleMask:
info.stores_sample_mask = true;
break;
shader: Add partial rasterizer integration
2021-03-19 22:28:31 +00:00
case IR::Opcode::SetFragDepth:
info.stores_frag_depth = true;
break;
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::WorkgroupId:
info.uses_workgroup_id = true;
break;
case IR::Opcode::LocalInvocationId:
info.uses_local_invocation_id = true;
break;
shader: Implement tessellation shaders, polygon mode and invocation id
2021-04-16 01:46:11 +00:00
case IR::Opcode::InvocationId:
info.uses_invocation_id = true;
break;
shader: Implement PIXLD.MY_INDEX
2021-04-16 20:22:59 +00:00
case IR::Opcode::SampleId:
info.uses_sample_id = true;
break;
shader: Implement SR_THREAD_KILL
2021-04-11 22:16:12 +00:00
case IR::Opcode::IsHelperInvocation:
info.uses_is_helper_invocation = true;
break;
shader: Fix resolution scaling pass
2021-07-22 01:25:34 +00:00
case IR::Opcode::ResolutionDownFactor:
shader: Add IsTextureScaled opcode
2021-07-26 01:04:53 +00:00
case IR::Opcode::IsTextureScaled:
shader: Properly scale image reads and add GL SPIR-V support Thanks for everything!
2021-08-01 21:57:45 +00:00
case IR::Opcode::IsImageScaled:
shader: Fix resolution scaling pass
2021-07-22 01:25:34 +00:00
info.uses_rescaling_uniform = true;
break;
shader: Move LaneId to the warp emission file and fix AMD
2021-04-11 05:22:20 +00:00
case IR::Opcode::LaneId:
glasm: Implement shuffle and vote instructions on GLASM
2021-05-10 21:21:28 +00:00
info.uses_subgroup_invocation_id = true;
break;
shader: Implement SHFL
2021-03-25 15:31:37 +00:00
case IR::Opcode::ShuffleIndex:
case IR::Opcode::ShuffleUp:
case IR::Opcode::ShuffleDown:
case IR::Opcode::ShuffleButterfly:
glasm: Implement shuffle and vote instructions on GLASM
2021-05-10 21:21:28 +00:00
info.uses_subgroup_shuffles = true;
shader: Implement SHFL
2021-03-25 15:31:37 +00:00
break;
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
case IR::Opcode::GetCbufU8:
case IR::Opcode::GetCbufS8:
case IR::Opcode::GetCbufU16:
case IR::Opcode::GetCbufS16:
case IR::Opcode::GetCbufU32:
case IR::Opcode::GetCbufF32:
shader: Reimplement GetCbufU64 as GetCbufU32x2 It may generate better code on some compilers and it's easier to handle.
2021-04-04 05:31:09 +00:00
case IR::Opcode::GetCbufU32x2: {
buffer_cache: Reduce uniform buffer size from shader usage Increases performance significantly on certain titles.
2021-06-02 05:15:07 +00:00
const IR::Value index{inst.Arg(0)};
const IR::Value offset{inst.Arg(1)};
shader: add support for const buffer indirect addressing
2022-03-14 23:35:48 +00:00
if (index.IsImmediate()) {
AddConstantBufferDescriptor(info, index.U32(), 1);
Address review comments
2022-03-17 18:45:38 +00:00
u32 element_size = GetElementSize(info.used_constant_buffer_types, inst.GetOpcode());
shader: add support for const buffer indirect addressing
2022-03-14 23:35:48 +00:00
u32& size{info.constant_buffer_used_sizes[index.U32()]};
if (offset.IsImmediate()) {
size = Common::AlignUp(std::max(size, offset.U32() + element_size), 16u);
} else {
size = 0x10'000;
}
Address review comments
2022-03-17 18:45:38 +00:00
} else {
AddRegisterIndexedLdc(info);
GetElementSize(info.used_indirect_cbuf_types, inst.GetOpcode());
buffer_cache: Reduce uniform buffer size from shader usage Increases performance significantly on certain titles.
2021-06-02 05:15:07 +00:00
}
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
break;
shader: Partial implementation of LDC
2021-03-09 20:14:57 +00:00
}
shader: Initial support for textures and TEX
2021-03-08 21:31:53 +00:00
case IR::Opcode::BindlessImageSampleImplicitLod:
case IR::Opcode::BindlessImageSampleExplicitLod:
case IR::Opcode::BindlessImageSampleDrefImplicitLod:
case IR::Opcode::BindlessImageSampleDrefExplicitLod:
shader: Implement TLD4 and TLD4_B
2021-03-24 22:41:55 +00:00
case IR::Opcode::BindlessImageGather:
case IR::Opcode::BindlessImageGatherDref:
shader: Implement ImageGradient
2021-03-29 00:00:43 +00:00
case IR::Opcode::BindlessImageFetch:
case IR::Opcode::BindlessImageQueryDimensions:
case IR::Opcode::BindlessImageQueryLod:
case IR::Opcode::BindlessImageGradient:
shader: Initial support for textures and TEX
2021-03-08 21:31:53 +00:00
case IR::Opcode::BoundImageSampleImplicitLod:
case IR::Opcode::BoundImageSampleExplicitLod:
case IR::Opcode::BoundImageSampleDrefImplicitLod:
case IR::Opcode::BoundImageSampleDrefExplicitLod:
shader: Implement TLD4 and TLD4_B
2021-03-24 22:41:55 +00:00
case IR::Opcode::BoundImageGather:
case IR::Opcode::BoundImageGatherDref:
shader: Implement ImageGradient
2021-03-29 00:00:43 +00:00
case IR::Opcode::BoundImageFetch:
case IR::Opcode::BoundImageQueryDimensions:
case IR::Opcode::BoundImageQueryLod:
case IR::Opcode::BoundImageGradient:
shader: Implement TLD4 and TLD4_B
2021-03-24 22:41:55 +00:00
case IR::Opcode::ImageGather:
shader: Implement TXQ and fix FragDepth
2021-03-26 21:45:38 +00:00
case IR::Opcode::ImageGatherDref:
shader: Implement TLD
2021-03-26 19:51:05 +00:00
case IR::Opcode::ImageFetch:
shader,spirv: Implement ImageQueryLod.
2021-03-28 17:47:52 +00:00
case IR::Opcode::ImageQueryDimensions:
shader: Implement ImageGradient
2021-03-29 00:00:43 +00:00
case IR::Opcode::ImageGradient: {
shader: Initial support for textures and TEX
2021-03-08 21:31:53 +00:00
const TextureType type{inst.Flags<IR::TextureInstInfo>().type};
shader: Implement SULD and SUST
2021-04-09 04:45:39 +00:00
info.uses_sampled_1d |= type == TextureType::Color1D || type == TextureType::ColorArray1D;
shader: Initial support for textures and TEX
2021-03-08 21:31:53 +00:00
info.uses_sparse_residency |=
inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp) != nullptr;
break;
}
glsl: Fix tracking of info.uses_shadow_lod
2021-07-05 00:48:54 +00:00
case IR::Opcode::ImageSampleImplicitLod:
case IR::Opcode::ImageSampleExplicitLod:
case IR::Opcode::ImageSampleDrefImplicitLod:
case IR::Opcode::ImageSampleDrefExplicitLod:
glsl: Conditionally add EXT_texture_shadow_lod
2021-06-13 23:12:03 +00:00
case IR::Opcode::ImageQueryLod: {
const auto flags{inst.Flags<IR::TextureInstInfo>()};
const TextureType type{flags.type};
info.uses_sampled_1d |= type == TextureType::Color1D || type == TextureType::ColorArray1D;
info.uses_shadow_lod |= flags.is_depth != 0;
info.uses_sparse_residency |=
inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp) != nullptr;
break;
}
spirv: Guard against typeless image reads on unsupported devices
2021-04-11 05:37:03 +00:00
case IR::Opcode::ImageRead: {
const auto flags{inst.Flags<IR::TextureInstInfo>()};
info.uses_typeless_image_reads |= flags.image_format == ImageFormat::Typeless;
info.uses_sparse_residency |=
inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp) != nullptr;
break;
}
spirv: Define StorageImageWriteWithoutFormat capability when used
2021-04-12 00:02:44 +00:00
case IR::Opcode::ImageWrite: {
const auto flags{inst.Flags<IR::TextureInstInfo>()};
info.uses_typeless_image_writes |= flags.image_format == ImageFormat::Typeless;
shader: Implement Int32 SUATOM/SURED
2021-04-23 21:47:54 +00:00
info.uses_image_buffers |= flags.type == TextureType::Buffer;
spirv: Define StorageImageWriteWithoutFormat capability when used
2021-04-12 00:02:44 +00:00
break;
}
shader: Add subgroup masks
2021-04-04 08:17:17 +00:00
case IR::Opcode::SubgroupEqMask:
case IR::Opcode::SubgroupLtMask:
case IR::Opcode::SubgroupLeMask:
case IR::Opcode::SubgroupGtMask:
case IR::Opcode::SubgroupGeMask:
info.uses_subgroup_mask = true;
break;
shader: Implement VOTE
2021-03-24 00:27:17 +00:00
case IR::Opcode::VoteAll:
case IR::Opcode::VoteAny:
case IR::Opcode::VoteEqual:
case IR::Opcode::SubgroupBallot:
info.uses_subgroup_vote = true;
break;
shader: Implement FSWZADD
2021-03-29 02:23:45 +00:00
case IR::Opcode::FSwizzleAdd:
info.uses_fswzadd = true;
break;
shader: Implement fine derivates constant propagation
2021-04-17 09:56:45 +00:00
case IR::Opcode::DPdxFine:
case IR::Opcode::DPdyFine:
shader: Add coarse derivatives
2021-04-17 10:51:43 +00:00
case IR::Opcode::DPdxCoarse:
case IR::Opcode::DPdyCoarse:
shader: Address feedback
2021-04-18 07:07:48 +00:00
info.uses_derivatives = true;
shader: Implement fine derivates constant propagation
2021-04-17 09:56:45 +00:00
break;
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
case IR::Opcode::LoadStorageU8:
case IR::Opcode::LoadStorageS8:
case IR::Opcode::WriteStorageU8:
case IR::Opcode::WriteStorageS8:
info.used_storage_buffer_types |= IR::Type::U8;
break;
case IR::Opcode::LoadStorageU16:
case IR::Opcode::LoadStorageS16:
case IR::Opcode::WriteStorageU16:
case IR::Opcode::WriteStorageS16:
info.used_storage_buffer_types |= IR::Type::U16;
break;
case IR::Opcode::LoadStorage32:
case IR::Opcode::WriteStorage32:
case IR::Opcode::StorageAtomicIAdd32:
case IR::Opcode::StorageAtomicUMin32:
case IR::Opcode::StorageAtomicUMax32:
case IR::Opcode::StorageAtomicAnd32:
case IR::Opcode::StorageAtomicOr32:
case IR::Opcode::StorageAtomicXor32:
case IR::Opcode::StorageAtomicExchange32:
info.used_storage_buffer_types |= IR::Type::U32;
break;
case IR::Opcode::LoadStorage64:
case IR::Opcode::WriteStorage64:
shaders: Add U64->U32x2 Atomic fallback functions
2022-01-29 18:46:06 +00:00
case IR::Opcode::StorageAtomicIAdd32x2:
case IR::Opcode::StorageAtomicSMin32x2:
case IR::Opcode::StorageAtomicUMin32x2:
case IR::Opcode::StorageAtomicSMax32x2:
case IR::Opcode::StorageAtomicUMax32x2:
case IR::Opcode::StorageAtomicAnd32x2:
case IR::Opcode::StorageAtomicOr32x2:
case IR::Opcode::StorageAtomicXor32x2:
case IR::Opcode::StorageAtomicExchange32x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32x2;
break;
case IR::Opcode::LoadStorage128:
case IR::Opcode::WriteStorage128:
info.used_storage_buffer_types |= IR::Type::U32x4;
break;
glsl: Fix ATOM and implement ATOMS
2021-05-30 18:31:59 +00:00
case IR::Opcode::SharedAtomicSMin32:
info.uses_atomic_s32_min = true;
break;
case IR::Opcode::SharedAtomicSMax32:
info.uses_atomic_s32_max = true;
break;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
case IR::Opcode::SharedAtomicInc32:
info.uses_shared_increment = true;
break;
case IR::Opcode::SharedAtomicDec32:
info.uses_shared_decrement = true;
break;
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
case IR::Opcode::SharedAtomicExchange64:
info.uses_int64_bit_atomics = true;
break;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
case IR::Opcode::GlobalAtomicInc32:
case IR::Opcode::StorageAtomicInc32:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_global_increment = true;
break;
case IR::Opcode::GlobalAtomicDec32:
case IR::Opcode::StorageAtomicDec32:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_global_decrement = true;
break;
case IR::Opcode::GlobalAtomicAddF32:
case IR::Opcode::StorageAtomicAddF32:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f32_add = true;
break;
case IR::Opcode::GlobalAtomicAddF16x2:
case IR::Opcode::StorageAtomicAddF16x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f16x2_add = true;
break;
case IR::Opcode::GlobalAtomicAddF32x2:
case IR::Opcode::StorageAtomicAddF32x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f32x2_add = true;
break;
case IR::Opcode::GlobalAtomicMinF16x2:
case IR::Opcode::StorageAtomicMinF16x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f16x2_min = true;
break;
case IR::Opcode::GlobalAtomicMinF32x2:
case IR::Opcode::StorageAtomicMinF32x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f32x2_min = true;
break;
case IR::Opcode::GlobalAtomicMaxF16x2:
case IR::Opcode::StorageAtomicMaxF16x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f16x2_max = true;
break;
case IR::Opcode::GlobalAtomicMaxF32x2:
case IR::Opcode::StorageAtomicMaxF32x2:
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.used_storage_buffer_types |= IR::Type::U32;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
info.uses_atomic_f32x2_max = true;
break;
glsl: Track S32 atomics
2021-05-26 02:13:50 +00:00
case IR::Opcode::StorageAtomicSMin32:
info.used_storage_buffer_types |= IR::Type::U32;
info.uses_atomic_s32_min = true;
break;
case IR::Opcode::StorageAtomicSMax32:
info.used_storage_buffer_types |= IR::Type::U32;
info.uses_atomic_s32_max = true;
break;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
case IR::Opcode::GlobalAtomicIAdd64:
case IR::Opcode::GlobalAtomicSMin64:
case IR::Opcode::GlobalAtomicUMin64:
case IR::Opcode::GlobalAtomicSMax64:
case IR::Opcode::GlobalAtomicUMax64:
case IR::Opcode::GlobalAtomicAnd64:
case IR::Opcode::GlobalAtomicOr64:
case IR::Opcode::GlobalAtomicXor64:
case IR::Opcode::GlobalAtomicExchange64:
case IR::Opcode::StorageAtomicIAdd64:
case IR::Opcode::StorageAtomicSMin64:
case IR::Opcode::StorageAtomicUMin64:
case IR::Opcode::StorageAtomicSMax64:
case IR::Opcode::StorageAtomicUMax64:
case IR::Opcode::StorageAtomicAnd64:
case IR::Opcode::StorageAtomicOr64:
case IR::Opcode::StorageAtomicXor64:
spirv_atomic: Define U32x2 storage buffers for 64-bit storage atomics Some drivers do not support 64-bit atomics, and fallback to atomically modifying U32x2 vectors. This change ensures that U32x2 storage vectors are defined in the spir-v shader when 64-bit atomics are used. Fixes a hang on some devices, notably Intel GPUs, when booting Pokemon Legends Arceus
2022-01-29 00:00:04 +00:00
info.used_storage_buffer_types |= IR::Type::U64 | IR::Type::U32x2;
spirv: Rework storage buffers and shader memory
2021-04-13 08:32:21 +00:00
info.uses_int64_bit_atomics = true;
shader: Implement ATOM/S and RED
2021-04-11 06:07:02 +00:00
break;
shader: Implement Int32 SUATOM/SURED
2021-04-23 21:47:54 +00:00
case IR::Opcode::BindlessImageAtomicIAdd32:
case IR::Opcode::BindlessImageAtomicSMin32:
case IR::Opcode::BindlessImageAtomicUMin32:
case IR::Opcode::BindlessImageAtomicSMax32:
case IR::Opcode::BindlessImageAtomicUMax32:
case IR::Opcode::BindlessImageAtomicInc32:
case IR::Opcode::BindlessImageAtomicDec32:
case IR::Opcode::BindlessImageAtomicAnd32:
case IR::Opcode::BindlessImageAtomicOr32:
case IR::Opcode::BindlessImageAtomicXor32:
case IR::Opcode::BindlessImageAtomicExchange32:
case IR::Opcode::BoundImageAtomicIAdd32:
case IR::Opcode::BoundImageAtomicSMin32:
case IR::Opcode::BoundImageAtomicUMin32:
case IR::Opcode::BoundImageAtomicSMax32:
case IR::Opcode::BoundImageAtomicUMax32:
case IR::Opcode::BoundImageAtomicInc32:
case IR::Opcode::BoundImageAtomicDec32:
case IR::Opcode::BoundImageAtomicAnd32:
case IR::Opcode::BoundImageAtomicOr32:
case IR::Opcode::BoundImageAtomicXor32:
case IR::Opcode::BoundImageAtomicExchange32:
case IR::Opcode::ImageAtomicIAdd32:
case IR::Opcode::ImageAtomicSMin32:
case IR::Opcode::ImageAtomicUMin32:
case IR::Opcode::ImageAtomicSMax32:
case IR::Opcode::ImageAtomicUMax32:
case IR::Opcode::ImageAtomicInc32:
case IR::Opcode::ImageAtomicDec32:
case IR::Opcode::ImageAtomicAnd32:
case IR::Opcode::ImageAtomicOr32:
case IR::Opcode::ImageAtomicXor32:
case IR::Opcode::ImageAtomicExchange32:
info.uses_atomic_image_u32 = true;
break;
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
default:
break;
}
}
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
void VisitFpModifiers(Info& info, IR::Inst& inst) {
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-06 02:25:22 +00:00
switch (inst.GetOpcode()) {
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
case IR::Opcode::FPAdd16:
case IR::Opcode::FPFma16:
case IR::Opcode::FPMul16:
case IR::Opcode::FPRoundEven16:
case IR::Opcode::FPFloor16:
case IR::Opcode::FPCeil16:
case IR::Opcode::FPTrunc16: {
const auto control{inst.Flags<IR::FpControl>()};
switch (control.fmz_mode) {
case IR::FmzMode::DontCare:
break;
case IR::FmzMode::FTZ:
case IR::FmzMode::FMZ:
info.uses_fp16_denorms_flush = true;
break;
case IR::FmzMode::None:
info.uses_fp16_denorms_preserve = true;
break;
}
break;
}
case IR::Opcode::FPAdd32:
case IR::Opcode::FPFma32:
case IR::Opcode::FPMul32:
case IR::Opcode::FPRoundEven32:
case IR::Opcode::FPFloor32:
case IR::Opcode::FPCeil32:
shader: Implement FCMP still need to configure some settings for NV denorm flush and intel NaN
2021-03-11 03:42:17 +00:00
case IR::Opcode::FPTrunc32:
case IR::Opcode::FPOrdEqual32:
case IR::Opcode::FPUnordEqual32:
case IR::Opcode::FPOrdNotEqual32:
case IR::Opcode::FPUnordNotEqual32:
case IR::Opcode::FPOrdLessThan32:
case IR::Opcode::FPUnordLessThan32:
case IR::Opcode::FPOrdGreaterThan32:
case IR::Opcode::FPUnordGreaterThan32:
case IR::Opcode::FPOrdLessThanEqual32:
case IR::Opcode::FPUnordLessThanEqual32:
case IR::Opcode::FPOrdGreaterThanEqual32:
shader: Implement F2F
2021-03-21 08:32:16 +00:00
case IR::Opcode::FPUnordGreaterThanEqual32:
case IR::Opcode::ConvertF16F32:
case IR::Opcode::ConvertF64F32: {
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
const auto control{inst.Flags<IR::FpControl>()};
switch (control.fmz_mode) {
case IR::FmzMode::DontCare:
break;
case IR::FmzMode::FTZ:
case IR::FmzMode::FMZ:
info.uses_fp32_denorms_flush = true;
break;
case IR::FmzMode::None:
info.uses_fp32_denorms_preserve = true;
break;
}
break;
}
default:
break;
}
}
shader: Optimize NVN Fallthrough
2021-05-01 23:50:27 +00:00
void VisitCbufs(Info& info, IR::Inst& inst) {
switch (inst.GetOpcode()) {
case IR::Opcode::GetCbufU8:
case IR::Opcode::GetCbufS8:
case IR::Opcode::GetCbufU16:
case IR::Opcode::GetCbufS16:
case IR::Opcode::GetCbufU32:
case IR::Opcode::GetCbufF32:
case IR::Opcode::GetCbufU32x2: {
CheckCBufNVN(info, inst);
break;
}
default:
break;
}
}
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
void Visit(Info& info, IR::Inst& inst) {
VisitUsages(info, inst);
VisitFpModifiers(info, inst);
shader: Optimize NVN Fallthrough
2021-05-01 23:50:27 +00:00
VisitCbufs(info, inst);
shader: Add denorm flush support
2021-02-20 06:30:13 +00:00
}
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
void GatherInfoFromHeader(Environment& env, Info& info) {
shader: Address feedback
2021-04-05 02:03:12 +00:00
Stage stage{env.ShaderStage()};
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
if (stage == Stage::Compute) {
return;
}
shader: Address feedback
2021-04-05 02:03:12 +00:00
const auto& header{env.SPH()};
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
if (stage == Stage::Fragment) {
shader: Implement indexed Position and ClipDistances
2021-04-04 07:38:15 +00:00
if (!info.loads_indexed_attributes) {
return;
}
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
const size_t offset{static_cast<size_t>(IR::Attribute::Generic0X) + index * 4};
const auto vector{header.ps.imap_generic_vector[index]};
info.loads.mask[offset + 0] = vector.x != PixelImap::Unused;
info.loads.mask[offset + 1] = vector.y != PixelImap::Unused;
info.loads.mask[offset + 2] = vector.z != PixelImap::Unused;
info.loads.mask[offset + 3] = vector.w != PixelImap::Unused;
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
}
return;
}
shader: Implement indexed Position and ClipDistances
2021-04-04 07:38:15 +00:00
if (info.loads_indexed_attributes) {
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
const IR::Attribute attribute{IR::Attribute::Generic0X + index * 4};
const auto mask = header.vtg.InputGeneric(index);
for (size_t i = 0; i < 4; ++i) {
info.loads.Set(attribute + i, mask[i]);
}
}
for (size_t index = 0; index < 8; ++index) {
const u16 mask{header.vtg.clip_distances};
info.loads.Set(IR::Attribute::ClipDistance0 + index, ((mask >> index) & 1) != 0);
shader: Implement indexed Position and ClipDistances
2021-04-04 07:38:15 +00:00
}
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
info.loads.Set(IR::Attribute::PrimitiveId, header.vtg.imap_systemb.primitive_array_id != 0);
info.loads.Set(IR::Attribute::Layer, header.vtg.imap_systemb.rt_array_index != 0);
info.loads.Set(IR::Attribute::ViewportIndex, header.vtg.imap_systemb.viewport_index != 0);
info.loads.Set(IR::Attribute::PointSize, header.vtg.imap_systemb.point_size != 0);
info.loads.Set(IR::Attribute::PositionX, header.vtg.imap_systemb.position_x != 0);
info.loads.Set(IR::Attribute::PositionY, header.vtg.imap_systemb.position_y != 0);
info.loads.Set(IR::Attribute::PositionZ, header.vtg.imap_systemb.position_z != 0);
info.loads.Set(IR::Attribute::PositionW, header.vtg.imap_systemb.position_w != 0);
info.loads.Set(IR::Attribute::PointSpriteS, header.vtg.point_sprite_s != 0);
info.loads.Set(IR::Attribute::PointSpriteT, header.vtg.point_sprite_t != 0);
info.loads.Set(IR::Attribute::FogCoordinate, header.vtg.fog_coordinate != 0);
info.loads.Set(IR::Attribute::TessellationEvaluationPointU,
header.vtg.tessellation_eval_point_u != 0);
info.loads.Set(IR::Attribute::TessellationEvaluationPointV,
header.vtg.tessellation_eval_point_v != 0);
info.loads.Set(IR::Attribute::InstanceId, header.vtg.instance_id != 0);
info.loads.Set(IR::Attribute::VertexId, header.vtg.vertex_id != 0);
// TODO: Legacy varyings
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
}
shader: Implement indexed Position and ClipDistances
2021-04-04 07:38:15 +00:00
if (info.stores_indexed_attributes) {
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
const IR::Attribute attribute{IR::Attribute::Generic0X + index * 4};
const auto mask{header.vtg.OutputGeneric(index)};
for (size_t i = 0; i < 4; ++i) {
info.stores.Set(attribute + i, mask[i]);
shader: Properly manage attributes not written from previous stages
2021-06-16 07:59:30 +00:00
}
shader: Implement indexed Position and ClipDistances
2021-04-04 07:38:15 +00:00
}
shader: Rework varyings and implement passthrough geometry shaders Put all varyings into a single std::bitset with helpers to access it. Implement passthrough geometry shaders using host's.
2021-06-24 05:41:09 +00:00
for (size_t index = 0; index < 8; ++index) {
const u16 mask{header.vtg.omap_systemc.clip_distances};
info.stores.Set(IR::Attribute::ClipDistance0 + index, ((mask >> index) & 1) != 0);
}
info.stores.Set(IR::Attribute::PrimitiveId,
header.vtg.omap_systemb.primitive_array_id != 0);
info.stores.Set(IR::Attribute::Layer, header.vtg.omap_systemb.rt_array_index != 0);
info.stores.Set(IR::Attribute::ViewportIndex, header.vtg.omap_systemb.viewport_index != 0);
info.stores.Set(IR::Attribute::PointSize, header.vtg.omap_systemb.point_size != 0);
info.stores.Set(IR::Attribute::PositionX, header.vtg.omap_systemb.position_x != 0);
info.stores.Set(IR::Attribute::PositionY, header.vtg.omap_systemb.position_y != 0);
info.stores.Set(IR::Attribute::PositionZ, header.vtg.omap_systemb.position_z != 0);
info.stores.Set(IR::Attribute::PositionW, header.vtg.omap_systemb.position_w != 0);
info.stores.Set(IR::Attribute::PointSpriteS, header.vtg.omap_systemc.point_sprite_s != 0);
info.stores.Set(IR::Attribute::PointSpriteT, header.vtg.omap_systemc.point_sprite_t != 0);
info.stores.Set(IR::Attribute::FogCoordinate, header.vtg.omap_systemc.fog_coordinate != 0);
info.stores.Set(IR::Attribute::TessellationEvaluationPointU,
header.vtg.omap_systemc.tessellation_eval_point_u != 0);
info.stores.Set(IR::Attribute::TessellationEvaluationPointV,
header.vtg.omap_systemc.tessellation_eval_point_v != 0);
info.stores.Set(IR::Attribute::InstanceId, header.vtg.omap_systemc.instance_id != 0);
info.stores.Set(IR::Attribute::VertexId, header.vtg.omap_systemc.vertex_id != 0);
// TODO: Legacy varyings
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
}
}
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
} // Anonymous namespace
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
void CollectShaderInfoPass(Environment& env, IR::Program& program) {
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
Info& info{program.info};
shader: Optimize NVN Fallthrough
2021-05-01 23:50:27 +00:00
const u32 base{[&] {
switch (program.stage) {
case Stage::VertexA:
case Stage::VertexB:
return 0x110u;
case Stage::TessellationControl:
return 0x210u;
case Stage::TessellationEval:
return 0x310u;
case Stage::Geometry:
return 0x410u;
case Stage::Fragment:
return 0x510u;
case Stage::Compute:
return 0x310u;
}
throw InvalidArgument("Invalid stage {}", program.stage);
}()};
info.nvn_buffer_base = base;
shader: Implement CAL inlining function calls
2021-03-14 06:41:05 +00:00
for (IR::Block* const block : program.post_order_blocks) {
for (IR::Inst& inst : block->Instructions()) {
Visit(info, inst);
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
}
}
shader: Implement indexed attributes
2021-04-04 04:47:14 +00:00
GatherInfoFromHeader(env, info);
spirv: Initial bindings support
2021-02-16 07:10:22 +00:00
}
} // namespace Shader::Optimization
Reference in a new issue Copy permalink