mirror of
https://git.suyu.dev/suyu/suyu.git
synced 2024-11-27 05:46:34 -05:00
4e35177e23
Implement VOTE using Nvidia's intrinsics. Documentation about these can be found here https://developer.nvidia.com/reading-between-threads-shader-intrinsics Instead of using portable ARB instructions I opted to use Nvidia intrinsics because these are the closest we have to how Tegra X1 hardware renders. To stub VOTE on non-Nvidia drivers (including nouveau) this commit simulates a GPU with a warp size of one, returning what is meaningful for the instruction being emulated: * anyThreadNV(value) -> value * allThreadsNV(value) -> value * allThreadsEqualNV(value) -> true ballotARB, also known as "uint64_t(activeThreadsNV())", emits VOTE.ANY Rd, PT, PT; on nouveau's compiler. This doesn't match exactly to Nvidia's code VOTE.ALL Rd, PT, PT; Which is emulated with activeThreadsNV() by this commit. In theory this shouldn't really matter since .ANY, .ALL and .EQ affect the predicates (set to PT on those cases) and not the registers.
367 lines
14 KiB
C++
367 lines
14 KiB
C++
// Copyright 2018 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include <array>
|
|
#include <map>
|
|
#include <optional>
|
|
#include <set>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
#include "common/common_types.h"
|
|
#include "video_core/engines/maxwell_3d.h"
|
|
#include "video_core/engines/shader_bytecode.h"
|
|
#include "video_core/engines/shader_header.h"
|
|
#include "video_core/shader/node.h"
|
|
|
|
namespace VideoCommon::Shader {
|
|
|
|
struct ShaderBlock;
|
|
|
|
using ProgramCode = std::vector<u64>;
|
|
|
|
constexpr u32 MAX_PROGRAM_LENGTH = 0x1000;
|
|
|
|
class ConstBuffer {
|
|
public:
|
|
explicit ConstBuffer(u32 max_offset, bool is_indirect)
|
|
: max_offset{max_offset}, is_indirect{is_indirect} {}
|
|
|
|
ConstBuffer() = default;
|
|
|
|
void MarkAsUsed(u64 offset) {
|
|
max_offset = std::max(max_offset, static_cast<u32>(offset));
|
|
}
|
|
|
|
void MarkAsUsedIndirect() {
|
|
is_indirect = true;
|
|
}
|
|
|
|
bool IsIndirect() const {
|
|
return is_indirect;
|
|
}
|
|
|
|
u32 GetSize() const {
|
|
return max_offset + sizeof(float);
|
|
}
|
|
|
|
u32 GetMaxOffset() const {
|
|
return max_offset;
|
|
}
|
|
|
|
private:
|
|
u32 max_offset{};
|
|
bool is_indirect{};
|
|
};
|
|
|
|
struct GlobalMemoryUsage {
|
|
bool is_read{};
|
|
bool is_written{};
|
|
};
|
|
|
|
class ShaderIR final {
|
|
public:
|
|
explicit ShaderIR(const ProgramCode& program_code, u32 main_offset, std::size_t size);
|
|
~ShaderIR();
|
|
|
|
const std::map<u32, NodeBlock>& GetBasicBlocks() const {
|
|
return basic_blocks;
|
|
}
|
|
|
|
const std::set<u32>& GetRegisters() const {
|
|
return used_registers;
|
|
}
|
|
|
|
const std::set<Tegra::Shader::Pred>& GetPredicates() const {
|
|
return used_predicates;
|
|
}
|
|
|
|
const std::set<Tegra::Shader::Attribute::Index>& GetInputAttributes() const {
|
|
return used_input_attributes;
|
|
}
|
|
|
|
const std::set<Tegra::Shader::Attribute::Index>& GetOutputAttributes() const {
|
|
return used_output_attributes;
|
|
}
|
|
|
|
const std::map<u32, ConstBuffer>& GetConstantBuffers() const {
|
|
return used_cbufs;
|
|
}
|
|
|
|
const std::set<Sampler>& GetSamplers() const {
|
|
return used_samplers;
|
|
}
|
|
|
|
const std::set<Image>& GetImages() const {
|
|
return used_images;
|
|
}
|
|
|
|
const std::array<bool, Tegra::Engines::Maxwell3D::Regs::NumClipDistances>& GetClipDistances()
|
|
const {
|
|
return used_clip_distances;
|
|
}
|
|
|
|
const std::map<GlobalMemoryBase, GlobalMemoryUsage>& GetGlobalMemory() const {
|
|
return used_global_memory;
|
|
}
|
|
|
|
std::size_t GetLength() const {
|
|
return static_cast<std::size_t>(coverage_end * sizeof(u64));
|
|
}
|
|
|
|
bool UsesLayer() const {
|
|
return uses_layer;
|
|
}
|
|
|
|
bool UsesViewportIndex() const {
|
|
return uses_viewport_index;
|
|
}
|
|
|
|
bool UsesPointSize() const {
|
|
return uses_point_size;
|
|
}
|
|
|
|
bool HasPhysicalAttributes() const {
|
|
return uses_physical_attributes;
|
|
}
|
|
|
|
const Tegra::Shader::Header& GetHeader() const {
|
|
return header;
|
|
}
|
|
|
|
bool IsFlowStackDisabled() const {
|
|
return disable_flow_stack;
|
|
}
|
|
|
|
u32 ConvertAddressToNvidiaSpace(const u32 address) const {
|
|
return (address - main_offset) * sizeof(Tegra::Shader::Instruction);
|
|
}
|
|
|
|
private:
|
|
void Decode();
|
|
|
|
NodeBlock DecodeRange(u32 begin, u32 end);
|
|
void DecodeRangeInner(NodeBlock& bb, u32 begin, u32 end);
|
|
void InsertControlFlow(NodeBlock& bb, const ShaderBlock& block);
|
|
|
|
/**
|
|
* Decodes a single instruction from Tegra to IR.
|
|
* @param bb Basic block where the nodes will be written to.
|
|
* @param pc Program counter. Offset to decode.
|
|
* @return Next address to decode.
|
|
*/
|
|
u32 DecodeInstr(NodeBlock& bb, u32 pc);
|
|
|
|
u32 DecodeArithmetic(NodeBlock& bb, u32 pc);
|
|
u32 DecodeArithmeticImmediate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeBfe(NodeBlock& bb, u32 pc);
|
|
u32 DecodeBfi(NodeBlock& bb, u32 pc);
|
|
u32 DecodeShift(NodeBlock& bb, u32 pc);
|
|
u32 DecodeArithmeticInteger(NodeBlock& bb, u32 pc);
|
|
u32 DecodeArithmeticIntegerImmediate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeArithmeticHalf(NodeBlock& bb, u32 pc);
|
|
u32 DecodeArithmeticHalfImmediate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeFfma(NodeBlock& bb, u32 pc);
|
|
u32 DecodeHfma2(NodeBlock& bb, u32 pc);
|
|
u32 DecodeConversion(NodeBlock& bb, u32 pc);
|
|
u32 DecodeWarp(NodeBlock& bb, u32 pc);
|
|
u32 DecodeMemory(NodeBlock& bb, u32 pc);
|
|
u32 DecodeTexture(NodeBlock& bb, u32 pc);
|
|
u32 DecodeImage(NodeBlock& bb, u32 pc);
|
|
u32 DecodeFloatSetPredicate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeIntegerSetPredicate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeHalfSetPredicate(NodeBlock& bb, u32 pc);
|
|
u32 DecodePredicateSetRegister(NodeBlock& bb, u32 pc);
|
|
u32 DecodePredicateSetPredicate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeRegisterSetPredicate(NodeBlock& bb, u32 pc);
|
|
u32 DecodeFloatSet(NodeBlock& bb, u32 pc);
|
|
u32 DecodeIntegerSet(NodeBlock& bb, u32 pc);
|
|
u32 DecodeHalfSet(NodeBlock& bb, u32 pc);
|
|
u32 DecodeVideo(NodeBlock& bb, u32 pc);
|
|
u32 DecodeXmad(NodeBlock& bb, u32 pc);
|
|
u32 DecodeOther(NodeBlock& bb, u32 pc);
|
|
|
|
/// Generates a node for a passed register.
|
|
Node GetRegister(Tegra::Shader::Register reg);
|
|
/// Generates a node representing a 19-bit immediate value
|
|
Node GetImmediate19(Tegra::Shader::Instruction instr);
|
|
/// Generates a node representing a 32-bit immediate value
|
|
Node GetImmediate32(Tegra::Shader::Instruction instr);
|
|
/// Generates a node representing a constant buffer
|
|
Node GetConstBuffer(u64 index, u64 offset);
|
|
/// Generates a node representing a constant buffer with a variadic offset
|
|
Node GetConstBufferIndirect(u64 index, u64 offset, Node node);
|
|
/// Generates a node for a passed predicate. It can be optionally negated
|
|
Node GetPredicate(u64 pred, bool negated = false);
|
|
/// Generates a predicate node for an immediate true or false value
|
|
Node GetPredicate(bool immediate);
|
|
/// Generates a node representing an input attribute. Keeps track of used attributes.
|
|
Node GetInputAttribute(Tegra::Shader::Attribute::Index index, u64 element, Node buffer = {});
|
|
/// Generates a node representing a physical input attribute.
|
|
Node GetPhysicalInputAttribute(Tegra::Shader::Register physical_address, Node buffer = {});
|
|
/// Generates a node representing an output attribute. Keeps track of used attributes.
|
|
Node GetOutputAttribute(Tegra::Shader::Attribute::Index index, u64 element, Node buffer);
|
|
/// Generates a node representing an internal flag
|
|
Node GetInternalFlag(InternalFlag flag, bool negated = false);
|
|
/// Generates a node representing a local memory address
|
|
Node GetLocalMemory(Node address);
|
|
/// Generates a temporary, internally it uses a post-RZ register
|
|
Node GetTemporary(u32 id);
|
|
|
|
/// Sets a register. src value must be a number-evaluated node.
|
|
void SetRegister(NodeBlock& bb, Tegra::Shader::Register dest, Node src);
|
|
/// Sets a predicate. src value must be a bool-evaluated node
|
|
void SetPredicate(NodeBlock& bb, u64 dest, Node src);
|
|
/// Sets an internal flag. src value must be a bool-evaluated node
|
|
void SetInternalFlag(NodeBlock& bb, InternalFlag flag, Node value);
|
|
/// Sets a local memory address. address and value must be a number-evaluated node
|
|
void SetLocalMemory(NodeBlock& bb, Node address, Node value);
|
|
/// Sets a temporary. Internally it uses a post-RZ register
|
|
void SetTemporary(NodeBlock& bb, u32 id, Node value);
|
|
|
|
/// Sets internal flags from a float
|
|
void SetInternalFlagsFromFloat(NodeBlock& bb, Node value, bool sets_cc = true);
|
|
/// Sets internal flags from an integer
|
|
void SetInternalFlagsFromInteger(NodeBlock& bb, Node value, bool sets_cc = true);
|
|
|
|
/// Conditionally absolute/negated float. Absolute is applied first
|
|
Node GetOperandAbsNegFloat(Node value, bool absolute, bool negate);
|
|
/// Conditionally saturates a float
|
|
Node GetSaturatedFloat(Node value, bool saturate = true);
|
|
|
|
/// Converts an integer to different sizes.
|
|
Node ConvertIntegerSize(Node value, Tegra::Shader::Register::Size size, bool is_signed);
|
|
/// Conditionally absolute/negated integer. Absolute is applied first
|
|
Node GetOperandAbsNegInteger(Node value, bool absolute, bool negate, bool is_signed);
|
|
|
|
/// Unpacks a half immediate from an instruction
|
|
Node UnpackHalfImmediate(Tegra::Shader::Instruction instr, bool has_negation);
|
|
/// Unpacks a binary value into a half float pair with a type format
|
|
Node UnpackHalfFloat(Node value, Tegra::Shader::HalfType type);
|
|
/// Merges a half pair into another value
|
|
Node HalfMerge(Node dest, Node src, Tegra::Shader::HalfMerge merge);
|
|
/// Conditionally absolute/negated half float pair. Absolute is applied first
|
|
Node GetOperandAbsNegHalf(Node value, bool absolute, bool negate);
|
|
/// Conditionally saturates a half float pair
|
|
Node GetSaturatedHalfFloat(Node value, bool saturate = true);
|
|
|
|
/// Returns a predicate comparing two floats
|
|
Node GetPredicateComparisonFloat(Tegra::Shader::PredCondition condition, Node op_a, Node op_b);
|
|
/// Returns a predicate comparing two integers
|
|
Node GetPredicateComparisonInteger(Tegra::Shader::PredCondition condition, bool is_signed,
|
|
Node op_a, Node op_b);
|
|
/// Returns a predicate comparing two half floats. meta consumes how both pairs will be compared
|
|
Node GetPredicateComparisonHalf(Tegra::Shader::PredCondition condition, Node op_a, Node op_b);
|
|
|
|
/// Returns a predicate combiner operation
|
|
OperationCode GetPredicateCombiner(Tegra::Shader::PredOperation operation);
|
|
|
|
/// Returns a condition code evaluated from internal flags
|
|
Node GetConditionCode(Tegra::Shader::ConditionCode cc);
|
|
|
|
/// Accesses a texture sampler
|
|
const Sampler& GetSampler(const Tegra::Shader::Sampler& sampler,
|
|
Tegra::Shader::TextureType type, bool is_array, bool is_shadow);
|
|
|
|
// Accesses a texture sampler for a bindless texture.
|
|
const Sampler& GetBindlessSampler(const Tegra::Shader::Register& reg,
|
|
Tegra::Shader::TextureType type, bool is_array,
|
|
bool is_shadow);
|
|
|
|
/// Accesses an image.
|
|
const Image& GetImage(Tegra::Shader::Image image, Tegra::Shader::ImageType type);
|
|
|
|
/// Access a bindless image sampler.
|
|
const Image& GetBindlessImage(Tegra::Shader::Register reg, Tegra::Shader::ImageType type);
|
|
|
|
/// Extracts a sequence of bits from a node
|
|
Node BitfieldExtract(Node value, u32 offset, u32 bits);
|
|
|
|
void WriteTexInstructionFloat(NodeBlock& bb, Tegra::Shader::Instruction instr,
|
|
const Node4& components);
|
|
|
|
void WriteTexsInstructionFloat(NodeBlock& bb, Tegra::Shader::Instruction instr,
|
|
const Node4& components);
|
|
void WriteTexsInstructionHalfFloat(NodeBlock& bb, Tegra::Shader::Instruction instr,
|
|
const Node4& components);
|
|
|
|
Node4 GetTexCode(Tegra::Shader::Instruction instr, Tegra::Shader::TextureType texture_type,
|
|
Tegra::Shader::TextureProcessMode process_mode, bool depth_compare,
|
|
bool is_array, bool is_aoffi,
|
|
std::optional<Tegra::Shader::Register> bindless_reg);
|
|
|
|
Node4 GetTexsCode(Tegra::Shader::Instruction instr, Tegra::Shader::TextureType texture_type,
|
|
Tegra::Shader::TextureProcessMode process_mode, bool depth_compare,
|
|
bool is_array);
|
|
|
|
Node4 GetTld4Code(Tegra::Shader::Instruction instr, Tegra::Shader::TextureType texture_type,
|
|
bool depth_compare, bool is_array, bool is_aoffi);
|
|
|
|
Node4 GetTldCode(Tegra::Shader::Instruction instr);
|
|
|
|
Node4 GetTldsCode(Tegra::Shader::Instruction instr, Tegra::Shader::TextureType texture_type,
|
|
bool is_array);
|
|
|
|
std::tuple<std::size_t, std::size_t> ValidateAndGetCoordinateElement(
|
|
Tegra::Shader::TextureType texture_type, bool depth_compare, bool is_array,
|
|
bool lod_bias_enabled, std::size_t max_coords, std::size_t max_inputs);
|
|
|
|
std::vector<Node> GetAoffiCoordinates(Node aoffi_reg, std::size_t coord_count, bool is_tld4);
|
|
|
|
Node4 GetTextureCode(Tegra::Shader::Instruction instr, Tegra::Shader::TextureType texture_type,
|
|
Tegra::Shader::TextureProcessMode process_mode, std::vector<Node> coords,
|
|
Node array, Node depth_compare, u32 bias_offset, std::vector<Node> aoffi,
|
|
std::optional<Tegra::Shader::Register> bindless_reg);
|
|
|
|
Node GetVideoOperand(Node op, bool is_chunk, bool is_signed, Tegra::Shader::VideoType type,
|
|
u64 byte_height);
|
|
|
|
void WriteLogicOperation(NodeBlock& bb, Tegra::Shader::Register dest,
|
|
Tegra::Shader::LogicOperation logic_op, Node op_a, Node op_b,
|
|
Tegra::Shader::PredicateResultMode predicate_mode,
|
|
Tegra::Shader::Pred predicate, bool sets_cc);
|
|
void WriteLop3Instruction(NodeBlock& bb, Tegra::Shader::Register dest, Node op_a, Node op_b,
|
|
Node op_c, Node imm_lut, bool sets_cc);
|
|
|
|
std::tuple<Node, u32, u32> TrackCbuf(Node tracked, const NodeBlock& code, s64 cursor) const;
|
|
|
|
std::optional<u32> TrackImmediate(Node tracked, const NodeBlock& code, s64 cursor) const;
|
|
|
|
std::pair<Node, s64> TrackRegister(const GprNode* tracked, const NodeBlock& code,
|
|
s64 cursor) const;
|
|
|
|
std::tuple<Node, Node, GlobalMemoryBase> TrackAndGetGlobalMemory(
|
|
NodeBlock& bb, Tegra::Shader::Instruction instr, bool is_write);
|
|
|
|
const ProgramCode& program_code;
|
|
const u32 main_offset;
|
|
const std::size_t program_size;
|
|
bool disable_flow_stack{};
|
|
|
|
u32 coverage_begin{};
|
|
u32 coverage_end{};
|
|
|
|
std::map<u32, NodeBlock> basic_blocks;
|
|
NodeBlock global_code;
|
|
|
|
std::set<u32> used_registers;
|
|
std::set<Tegra::Shader::Pred> used_predicates;
|
|
std::set<Tegra::Shader::Attribute::Index> used_input_attributes;
|
|
std::set<Tegra::Shader::Attribute::Index> used_output_attributes;
|
|
std::map<u32, ConstBuffer> used_cbufs;
|
|
std::set<Sampler> used_samplers;
|
|
std::set<Image> used_images;
|
|
std::array<bool, Tegra::Engines::Maxwell3D::Regs::NumClipDistances> used_clip_distances{};
|
|
std::map<GlobalMemoryBase, GlobalMemoryUsage> used_global_memory;
|
|
bool uses_layer{};
|
|
bool uses_viewport_index{};
|
|
bool uses_point_size{};
|
|
bool uses_physical_attributes{}; // Shader uses AL2P or physical attribute read/writes
|
|
|
|
Tegra::Shader::Header header;
|
|
};
|
|
|
|
} // namespace VideoCommon::Shader
|