mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-21 05:49:57 -04:00
Import the base tree (MIT, see LICENSE)
This commit is contained in:
14
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/AlphaTestOp.cs
vendored
Normal file
14
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/AlphaTestOp.cs
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
public enum AlphaTestOp
|
||||
{
|
||||
Never = 1,
|
||||
Less,
|
||||
Equal,
|
||||
LessOrEqual,
|
||||
Greater,
|
||||
NotEqual,
|
||||
GreaterOrEqual,
|
||||
Always,
|
||||
}
|
||||
}
|
||||
45
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/AttributeType.cs
vendored
Normal file
45
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/AttributeType.cs
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
[Flags]
|
||||
public enum AttributeType : byte
|
||||
{
|
||||
// Generic types.
|
||||
Float,
|
||||
Sint,
|
||||
Uint,
|
||||
Sscaled,
|
||||
Uscaled,
|
||||
|
||||
Packed = 1 << 6,
|
||||
PackedRgb10A2Signed = 1 << 7,
|
||||
AnyPacked = Packed | PackedRgb10A2Signed,
|
||||
}
|
||||
|
||||
static class AttributeTypeExtensions
|
||||
{
|
||||
extension(AttributeType type)
|
||||
{
|
||||
public AggregateType Aggregate =>
|
||||
(type & ~AttributeType.AnyPacked) switch
|
||||
{
|
||||
AttributeType.Float => AggregateType.FP32,
|
||||
AttributeType.Sint => AggregateType.S32,
|
||||
AttributeType.Uint => AggregateType.U32,
|
||||
_ => throw new ArgumentException($"Invalid attribute type \"{type}\"."),
|
||||
};
|
||||
|
||||
public AggregateType AsAggregate(bool supportsScaledFormats) => (type & ~AttributeType.AnyPacked) switch
|
||||
{
|
||||
AttributeType.Float => AggregateType.FP32,
|
||||
AttributeType.Sint => AggregateType.S32,
|
||||
AttributeType.Uint => AggregateType.U32,
|
||||
AttributeType.Sscaled => supportsScaledFormats ? AggregateType.FP32 : AggregateType.S32,
|
||||
AttributeType.Uscaled => supportsScaledFormats ? AggregateType.FP32 : AggregateType.U32,
|
||||
_ => throw new ArgumentException($"Invalid attribute type \"{type}\"."),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
34
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/BufferDescriptor.cs
vendored
Normal file
34
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/BufferDescriptor.cs
vendored
Normal file
@@ -0,0 +1,34 @@
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
public readonly struct BufferDescriptor
|
||||
{
|
||||
// New fields should be added to the end of the struct to keep disk shader cache compatibility.
|
||||
|
||||
public readonly int Set;
|
||||
public readonly int Binding;
|
||||
public readonly byte Slot;
|
||||
public readonly byte SbCbSlot;
|
||||
public readonly ushort SbCbOffset;
|
||||
public readonly BufferUsageFlags Flags;
|
||||
|
||||
public BufferDescriptor(int set, int binding, int slot)
|
||||
{
|
||||
Set = set;
|
||||
Binding = binding;
|
||||
Slot = (byte)slot;
|
||||
SbCbSlot = 0;
|
||||
SbCbOffset = 0;
|
||||
Flags = BufferUsageFlags.None;
|
||||
}
|
||||
|
||||
public BufferDescriptor(int set, int binding, int slot, int sbCbSlot, int sbCbOffset, BufferUsageFlags flags)
|
||||
{
|
||||
Set = set;
|
||||
Binding = binding;
|
||||
Slot = (byte)slot;
|
||||
SbCbSlot = (byte)sbCbSlot;
|
||||
SbCbOffset = (ushort)sbCbOffset;
|
||||
Flags = flags;
|
||||
}
|
||||
}
|
||||
}
|
||||
18
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/BufferUsageFlags.cs
vendored
Normal file
18
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/BufferUsageFlags.cs
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// Flags that indicate how a buffer will be used in a shader.
|
||||
/// </summary>
|
||||
[Flags]
|
||||
public enum BufferUsageFlags : byte
|
||||
{
|
||||
None = 0,
|
||||
|
||||
/// <summary>
|
||||
/// Buffer is written to.
|
||||
/// </summary>
|
||||
Write = 1 << 0,
|
||||
}
|
||||
}
|
||||
31
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/CodeGenParameters.cs
vendored
Normal file
31
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/CodeGenParameters.cs
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen
|
||||
{
|
||||
readonly struct CodeGenParameters
|
||||
{
|
||||
public readonly AttributeUsage AttributeUsage;
|
||||
public readonly ShaderDefinitions Definitions;
|
||||
public readonly ShaderProperties Properties;
|
||||
public readonly HostCapabilities HostCapabilities;
|
||||
public readonly ILogger Logger;
|
||||
public readonly TargetApi TargetApi;
|
||||
|
||||
public CodeGenParameters(
|
||||
AttributeUsage attributeUsage,
|
||||
ShaderDefinitions definitions,
|
||||
ShaderProperties properties,
|
||||
HostCapabilities hostCapabilities,
|
||||
ILogger logger,
|
||||
TargetApi targetApi)
|
||||
{
|
||||
AttributeUsage = attributeUsage;
|
||||
Definitions = definitions;
|
||||
Properties = properties;
|
||||
HostCapabilities = hostCapabilities;
|
||||
Logger = logger;
|
||||
TargetApi = targetApi;
|
||||
}
|
||||
}
|
||||
}
|
||||
105
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/CodeGenContext.cs
vendored
Normal file
105
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/CodeGenContext.cs
vendored
Normal file
@@ -0,0 +1,105 @@
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System.Text;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
class CodeGenContext
|
||||
{
|
||||
public const string Tab = " ";
|
||||
|
||||
public StructuredFunction CurrentFunction { get; set; }
|
||||
|
||||
public StructuredProgramInfo Info { get; }
|
||||
|
||||
public AttributeUsage AttributeUsage { get; }
|
||||
public ShaderDefinitions Definitions { get; }
|
||||
public ShaderProperties Properties { get; }
|
||||
public HostCapabilities HostCapabilities { get; }
|
||||
public ILogger Logger { get; }
|
||||
public TargetApi TargetApi { get; }
|
||||
|
||||
public OperandManager OperandManager { get; }
|
||||
|
||||
private readonly StringBuilder _sb;
|
||||
|
||||
private int _level;
|
||||
|
||||
private string _indentation;
|
||||
|
||||
public CodeGenContext(StructuredProgramInfo info, CodeGenParameters parameters)
|
||||
{
|
||||
Info = info;
|
||||
AttributeUsage = parameters.AttributeUsage;
|
||||
Definitions = parameters.Definitions;
|
||||
Properties = parameters.Properties;
|
||||
HostCapabilities = parameters.HostCapabilities;
|
||||
Logger = parameters.Logger;
|
||||
TargetApi = parameters.TargetApi;
|
||||
|
||||
OperandManager = new OperandManager();
|
||||
|
||||
_sb = new StringBuilder();
|
||||
}
|
||||
|
||||
public void AppendLine()
|
||||
{
|
||||
_sb.AppendLine();
|
||||
}
|
||||
|
||||
public void AppendLine(string str)
|
||||
{
|
||||
_sb.AppendLine(_indentation + str);
|
||||
}
|
||||
|
||||
public string GetCode()
|
||||
{
|
||||
return _sb.ToString();
|
||||
}
|
||||
|
||||
public void EnterScope()
|
||||
{
|
||||
AppendLine("{");
|
||||
|
||||
_level++;
|
||||
|
||||
UpdateIndentation();
|
||||
}
|
||||
|
||||
public void LeaveScope(string suffix = "")
|
||||
{
|
||||
if (_level == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_level--;
|
||||
|
||||
UpdateIndentation();
|
||||
|
||||
AppendLine("}" + suffix);
|
||||
}
|
||||
|
||||
public StructuredFunction GetFunction(int id)
|
||||
{
|
||||
return Info.Functions[id];
|
||||
}
|
||||
|
||||
private void UpdateIndentation()
|
||||
{
|
||||
_indentation = GetIndentation(_level);
|
||||
}
|
||||
|
||||
private static string GetIndentation(int level)
|
||||
{
|
||||
StringBuilder indentationBuilder = new();
|
||||
|
||||
for (int index = 0; index < level; index++)
|
||||
{
|
||||
indentationBuilder.Append(Tab);
|
||||
}
|
||||
|
||||
return indentationBuilder.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
659
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
vendored
Normal file
659
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Declarations.cs
vendored
Normal file
@@ -0,0 +1,659 @@
|
||||
using Ryujinx.Common;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class Declarations
|
||||
{
|
||||
public static void Declare(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
context.AppendLine(context.TargetApi == TargetApi.Vulkan ? "#version 460 core" : "#version 450 core");
|
||||
context.AppendLine("#extension GL_ARB_gpu_shader_int64 : enable");
|
||||
|
||||
if (context.HostCapabilities.SupportsShaderBallot)
|
||||
{
|
||||
context.AppendLine("#extension GL_ARB_shader_ballot : enable");
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AppendLine("#extension GL_KHR_shader_subgroup_basic : enable");
|
||||
context.AppendLine("#extension GL_KHR_shader_subgroup_ballot : enable");
|
||||
context.AppendLine("#extension GL_KHR_shader_subgroup_shuffle : enable");
|
||||
}
|
||||
|
||||
context.AppendLine("#extension GL_ARB_shader_group_vote : enable");
|
||||
context.AppendLine("#extension GL_EXT_shader_image_load_formatted : enable");
|
||||
context.AppendLine("#extension GL_EXT_texture_shadow_lod : enable");
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Compute)
|
||||
{
|
||||
context.AppendLine("#extension GL_ARB_compute_shader : enable");
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
if (context.HostCapabilities.SupportsFragmentShaderInterlock)
|
||||
{
|
||||
context.AppendLine("#extension GL_ARB_fragment_shader_interlock : enable");
|
||||
}
|
||||
else if (context.HostCapabilities.SupportsFragmentShaderOrderingIntel)
|
||||
{
|
||||
context.AppendLine("#extension GL_INTEL_fragment_shader_ordering : enable");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (context.Definitions.Stage == ShaderStage.Vertex)
|
||||
{
|
||||
context.AppendLine("#extension GL_ARB_shader_draw_parameters : enable");
|
||||
}
|
||||
|
||||
context.AppendLine("#extension GL_ARB_shader_viewport_layer_array : enable");
|
||||
}
|
||||
|
||||
if (context.Definitions.GpPassthrough && context.HostCapabilities.SupportsGeometryShaderPassthrough)
|
||||
{
|
||||
context.AppendLine("#extension GL_NV_geometry_shader_passthrough : enable");
|
||||
}
|
||||
|
||||
if (context.HostCapabilities.SupportsViewportMask)
|
||||
{
|
||||
context.AppendLine("#extension GL_NV_viewport_array2 : enable");
|
||||
}
|
||||
|
||||
context.AppendLine("#pragma optionNV(fastmath off)");
|
||||
context.AppendLine();
|
||||
|
||||
context.AppendLine($"const int {DefaultNames.UndefinedName} = 0;");
|
||||
context.AppendLine();
|
||||
|
||||
DeclareConstantBuffers(context, context.Properties.ConstantBuffers.Values);
|
||||
DeclareStorageBuffers(context, context.Properties.StorageBuffers.Values);
|
||||
DeclareMemories(context, context.Properties.LocalMemories.Values, isShared: false);
|
||||
DeclareMemories(context, context.Properties.SharedMemories.Values, isShared: true);
|
||||
DeclareSamplers(context, context.Properties.Textures.Values);
|
||||
DeclareImages(context, context.Properties.Images.Values);
|
||||
|
||||
if (context.Definitions.Stage != ShaderStage.Compute)
|
||||
{
|
||||
if (context.Definitions.Stage == ShaderStage.Geometry)
|
||||
{
|
||||
string inPrimitive = context.Definitions.InputTopology.GlslString;
|
||||
|
||||
context.AppendLine($"layout (invocations = {context.Definitions.ThreadsPerInputPrimitive}, {inPrimitive}) in;");
|
||||
|
||||
if (context.Definitions.GpPassthrough && context.HostCapabilities.SupportsGeometryShaderPassthrough)
|
||||
{
|
||||
context.AppendLine($"layout (passthrough) in gl_PerVertex");
|
||||
context.EnterScope();
|
||||
context.AppendLine("vec4 gl_Position;");
|
||||
context.AppendLine("float gl_PointSize;");
|
||||
context.AppendLine("float gl_ClipDistance[];");
|
||||
context.LeaveScope(";");
|
||||
}
|
||||
else
|
||||
{
|
||||
string outPrimitive = context.Definitions.OutputTopology.GlslString;
|
||||
int maxOutputVertices = context.Definitions.MaxOutputVertices;
|
||||
|
||||
context.AppendLine($"layout ({outPrimitive}, max_vertices = {maxOutputVertices}) out;");
|
||||
}
|
||||
|
||||
context.AppendLine();
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.TessellationControl)
|
||||
{
|
||||
int threadsPerInputPrimitive = context.Definitions.ThreadsPerInputPrimitive;
|
||||
|
||||
context.AppendLine($"layout (vertices = {threadsPerInputPrimitive}) out;");
|
||||
context.AppendLine();
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.TessellationEvaluation)
|
||||
{
|
||||
bool tessCw = context.Definitions.TessCw;
|
||||
|
||||
if (context.TargetApi == TargetApi.Vulkan)
|
||||
{
|
||||
// We invert the front face on Vulkan backend, so we need to do that here aswell.
|
||||
tessCw = !tessCw;
|
||||
}
|
||||
|
||||
string patchType = context.Definitions.TessPatchType.Glsl;
|
||||
string spacing = context.Definitions.TessSpacing.Glsl;
|
||||
string windingOrder = tessCw ? "cw" : "ccw";
|
||||
|
||||
context.AppendLine($"layout ({patchType}, {spacing}, {windingOrder}) in;");
|
||||
context.AppendLine();
|
||||
}
|
||||
|
||||
static bool IsUserDefined(IoDefinition ioDefinition, StorageKind storageKind)
|
||||
{
|
||||
return ioDefinition.StorageKind == storageKind && ioDefinition.IoVariable == IoVariable.UserDefined;
|
||||
}
|
||||
|
||||
static bool IsUserDefinedOutput(ShaderStage stage, IoDefinition ioDefinition)
|
||||
{
|
||||
IoVariable ioVariable = stage == ShaderStage.Fragment ? IoVariable.FragmentOutputColor : IoVariable.UserDefined;
|
||||
return ioDefinition.StorageKind == StorageKind.Output && ioDefinition.IoVariable == ioVariable;
|
||||
}
|
||||
|
||||
DeclareInputAttributes(context, info.IoDefinitions.Where(x => IsUserDefined(x, StorageKind.Input)));
|
||||
DeclareOutputAttributes(context, info.IoDefinitions.Where(x => IsUserDefinedOutput(context.Definitions.Stage, x)));
|
||||
DeclareInputAttributesPerPatch(context, info.IoDefinitions.Where(x => IsUserDefined(x, StorageKind.InputPerPatch)));
|
||||
DeclareOutputAttributesPerPatch(context, info.IoDefinitions.Where(x => IsUserDefined(x, StorageKind.OutputPerPatch)));
|
||||
|
||||
if (context.Definitions.TransformFeedbackEnabled && context.Definitions.LastInVertexPipeline)
|
||||
{
|
||||
TransformFeedbackOutput tfOutput = context.Definitions.GetTransformFeedbackOutput(AttributeConsts.PositionX);
|
||||
if (tfOutput.Valid)
|
||||
{
|
||||
context.AppendLine($"layout (xfb_buffer = {tfOutput.Buffer}, xfb_offset = {tfOutput.Offset}, xfb_stride = {tfOutput.Stride}) out gl_PerVertex");
|
||||
context.EnterScope();
|
||||
context.AppendLine("vec4 gl_Position;");
|
||||
context.LeaveScope(context.Definitions.Stage == ShaderStage.TessellationControl ? " gl_out[];" : ";");
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
string localSizeX = NumberFormatter.FormatInt(context.Definitions.ComputeLocalSizeX);
|
||||
string localSizeY = NumberFormatter.FormatInt(context.Definitions.ComputeLocalSizeY);
|
||||
string localSizeZ = NumberFormatter.FormatInt(context.Definitions.ComputeLocalSizeZ);
|
||||
|
||||
context.AppendLine(
|
||||
"layout (" +
|
||||
$"local_size_x = {localSizeX}, " +
|
||||
$"local_size_y = {localSizeY}, " +
|
||||
$"local_size_z = {localSizeZ}) in;");
|
||||
context.AppendLine();
|
||||
}
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
if (context.Definitions.EarlyZForce)
|
||||
{
|
||||
context.AppendLine("layout (early_fragment_tests) in;");
|
||||
context.AppendLine();
|
||||
}
|
||||
|
||||
if (context.Definitions.OriginUpperLeft)
|
||||
{
|
||||
context.AppendLine("layout (origin_upper_left) in vec4 gl_FragCoord;");
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
|
||||
if ((info.HelperFunctionsMask & HelperFunctionsMask.MultiplyHighS32) != 0)
|
||||
{
|
||||
AppendHelperFunction(context, "Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighS32.glsl");
|
||||
}
|
||||
|
||||
if ((info.HelperFunctionsMask & HelperFunctionsMask.MultiplyHighU32) != 0)
|
||||
{
|
||||
AppendHelperFunction(context, "Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/MultiplyHighU32.glsl");
|
||||
}
|
||||
|
||||
if ((info.HelperFunctionsMask & HelperFunctionsMask.SwizzleAdd) != 0)
|
||||
{
|
||||
AppendHelperFunction(context, "Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/SwizzleAdd.glsl");
|
||||
}
|
||||
}
|
||||
|
||||
public static void DeclareLocals(CodeGenContext context, StructuredFunction function)
|
||||
{
|
||||
foreach (AstOperand decl in function.Locals)
|
||||
{
|
||||
string name = context.OperandManager.DeclareLocal(decl);
|
||||
|
||||
context.AppendLine(GetVarTypeName(context, decl.VarType) + " " + name + ";");
|
||||
}
|
||||
}
|
||||
|
||||
public static string GetVarTypeName(CodeGenContext context, AggregateType type, bool precise = true)
|
||||
{
|
||||
if (context.HostCapabilities.ReducedPrecision)
|
||||
{
|
||||
precise = false;
|
||||
}
|
||||
|
||||
return type switch
|
||||
{
|
||||
AggregateType.Void => "void",
|
||||
AggregateType.Bool => "bool",
|
||||
AggregateType.FP32 => precise ? "precise float" : "float",
|
||||
AggregateType.FP64 => "double",
|
||||
AggregateType.S32 => "int",
|
||||
AggregateType.U32 => "uint",
|
||||
AggregateType.Vector2 | AggregateType.Bool => "bvec2",
|
||||
AggregateType.Vector2 | AggregateType.FP32 => precise ? "precise vec2" : "vec2",
|
||||
AggregateType.Vector2 | AggregateType.FP64 => "dvec2",
|
||||
AggregateType.Vector2 | AggregateType.S32 => "ivec2",
|
||||
AggregateType.Vector2 | AggregateType.U32 => "uvec2",
|
||||
AggregateType.Vector3 | AggregateType.Bool => "bvec3",
|
||||
AggregateType.Vector3 | AggregateType.FP32 => precise ? "precise vec3" : "vec3",
|
||||
AggregateType.Vector3 | AggregateType.FP64 => "dvec3",
|
||||
AggregateType.Vector3 | AggregateType.S32 => "ivec3",
|
||||
AggregateType.Vector3 | AggregateType.U32 => "uvec3",
|
||||
AggregateType.Vector4 | AggregateType.Bool => "bvec4",
|
||||
AggregateType.Vector4 | AggregateType.FP32 => precise ? "precise vec4" : "vec4",
|
||||
AggregateType.Vector4 | AggregateType.FP64 => "dvec4",
|
||||
AggregateType.Vector4 | AggregateType.S32 => "ivec4",
|
||||
AggregateType.Vector4 | AggregateType.U32 => "uvec4",
|
||||
_ => throw new ArgumentException($"Invalid variable type \"{type}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
private static void DeclareConstantBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers)
|
||||
{
|
||||
DeclareBuffers(context, buffers, "uniform");
|
||||
}
|
||||
|
||||
private static void DeclareStorageBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers)
|
||||
{
|
||||
DeclareBuffers(context, buffers, "buffer");
|
||||
}
|
||||
|
||||
private static void DeclareBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers, string declType)
|
||||
{
|
||||
foreach (BufferDefinition buffer in buffers)
|
||||
{
|
||||
string layout = buffer.Layout switch
|
||||
{
|
||||
BufferLayout.Std140 => "std140",
|
||||
_ => "std430",
|
||||
};
|
||||
|
||||
string set = string.Empty;
|
||||
|
||||
if (context.TargetApi == TargetApi.Vulkan)
|
||||
{
|
||||
set = $"set = {buffer.Set}, ";
|
||||
}
|
||||
|
||||
context.AppendLine($"layout ({set}binding = {buffer.Binding}, {layout}) {declType} _{buffer.Name}");
|
||||
context.EnterScope();
|
||||
|
||||
foreach (StructureField field in buffer.Type.Fields)
|
||||
{
|
||||
if (field.Type.HasFlag(AggregateType.Array))
|
||||
{
|
||||
string typeName = GetVarTypeName(context, field.Type & ~AggregateType.Array);
|
||||
|
||||
if (field.ArrayLength > 0)
|
||||
{
|
||||
string arraySize = field.ArrayLength.ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
context.AppendLine($"{typeName} {field.Name}[{arraySize}];");
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AppendLine($"{typeName} {field.Name}[];");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
string typeName = GetVarTypeName(context, field.Type);
|
||||
|
||||
context.AppendLine($"{typeName} {field.Name};");
|
||||
}
|
||||
}
|
||||
|
||||
context.LeaveScope($" {buffer.Name};");
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareMemories(CodeGenContext context, IEnumerable<MemoryDefinition> memories, bool isShared)
|
||||
{
|
||||
string prefix = isShared ? "shared " : string.Empty;
|
||||
|
||||
foreach (MemoryDefinition memory in memories)
|
||||
{
|
||||
string typeName = GetVarTypeName(context, memory.Type & ~AggregateType.Array);
|
||||
|
||||
if (memory.Type.HasFlag(AggregateType.Array))
|
||||
{
|
||||
if (memory.ArrayLength > 0)
|
||||
{
|
||||
string arraySize = memory.ArrayLength.ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
context.AppendLine($"{prefix}{typeName} {memory.Name}[{arraySize}];");
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AppendLine($"{prefix}{typeName} {memory.Name}[];");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AppendLine($"{prefix}{typeName} {memory.Name};");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareSamplers(CodeGenContext context, IEnumerable<TextureDefinition> definitions)
|
||||
{
|
||||
foreach (TextureDefinition definition in definitions)
|
||||
{
|
||||
string arrayDecl = string.Empty;
|
||||
|
||||
if (definition.ArrayLength > 1)
|
||||
{
|
||||
arrayDecl = $"[{NumberFormatter.FormatInt(definition.ArrayLength)}]";
|
||||
}
|
||||
else if (definition.ArrayLength == 0)
|
||||
{
|
||||
arrayDecl = "[]";
|
||||
}
|
||||
|
||||
string samplerTypeName = definition.Separate ? definition.Type.GlslTextureTypeName : definition.Type.GlslSamplerTypeName;
|
||||
|
||||
string layout = string.Empty;
|
||||
|
||||
if (context.TargetApi == TargetApi.Vulkan)
|
||||
{
|
||||
layout = $", set = {definition.Set}";
|
||||
}
|
||||
|
||||
context.AppendLine($"layout (binding = {definition.Binding}{layout}) uniform {samplerTypeName} {definition.Name}{arrayDecl};");
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareImages(CodeGenContext context, IEnumerable<TextureDefinition> definitions)
|
||||
{
|
||||
foreach (TextureDefinition definition in definitions)
|
||||
{
|
||||
string arrayDecl = string.Empty;
|
||||
|
||||
if (definition.ArrayLength > 1)
|
||||
{
|
||||
arrayDecl = $"[{NumberFormatter.FormatInt(definition.ArrayLength)}]";
|
||||
}
|
||||
else if (definition.ArrayLength == 0)
|
||||
{
|
||||
arrayDecl = "[]";
|
||||
}
|
||||
|
||||
string imageTypeName = definition.Type.GetGlslImageTypeName(definition.Format.GetComponentType());
|
||||
|
||||
if (definition.Flags.HasFlag(TextureUsageFlags.ImageCoherent))
|
||||
{
|
||||
imageTypeName = "coherent " + imageTypeName;
|
||||
}
|
||||
|
||||
string layout = definition.Format.ToGlslFormat();
|
||||
|
||||
if (!string.IsNullOrEmpty(layout))
|
||||
{
|
||||
layout = ", " + layout;
|
||||
}
|
||||
|
||||
if (context.TargetApi == TargetApi.Vulkan)
|
||||
{
|
||||
layout = $", set = {definition.Set}{layout}";
|
||||
}
|
||||
|
||||
context.AppendLine($"layout (binding = {definition.Binding}{layout}) uniform {imageTypeName} {definition.Name}{arrayDecl};");
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareInputAttributes(CodeGenContext context, IEnumerable<IoDefinition> inputs)
|
||||
{
|
||||
if (context.Definitions.IaIndexing)
|
||||
{
|
||||
string suffix = context.Definitions.Stage == ShaderStage.Geometry ? "[]" : string.Empty;
|
||||
|
||||
context.AppendLine($"layout (location = 0) in vec4 {DefaultNames.IAttributePrefix}{suffix}[{Constants.MaxAttributes}];");
|
||||
context.AppendLine();
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (IoDefinition ioDefinition in inputs.OrderBy(x => x.Location))
|
||||
{
|
||||
DeclareInputAttribute(context, ioDefinition.Location, ioDefinition.Component);
|
||||
}
|
||||
|
||||
if (inputs.Any())
|
||||
{
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareInputAttributesPerPatch(CodeGenContext context, IEnumerable<IoDefinition> inputs)
|
||||
{
|
||||
foreach (IoDefinition ioDefinition in inputs.OrderBy(x => x.Location))
|
||||
{
|
||||
DeclareInputAttributePerPatch(context, ioDefinition.Location);
|
||||
}
|
||||
|
||||
if (inputs.Any())
|
||||
{
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareInputAttribute(CodeGenContext context, int location, int component)
|
||||
{
|
||||
string suffix = IsArrayAttributeGlsl(context.Definitions.Stage, isOutAttr: false) ? "[]" : string.Empty;
|
||||
string iq = string.Empty;
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
iq = context.Definitions.ImapTypes[location].GetFirstUsedType() switch
|
||||
{
|
||||
PixelImap.Constant => "flat ",
|
||||
PixelImap.ScreenLinear => "noperspective ",
|
||||
_ => string.Empty,
|
||||
};
|
||||
}
|
||||
|
||||
string name = $"{DefaultNames.IAttributePrefix}{location}";
|
||||
|
||||
if (context.Definitions.TransformFeedbackEnabled && context.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
bool hasComponent = context.Definitions.HasPerLocationInputOrOutputComponent(IoVariable.UserDefined, location, component, isOutput: false);
|
||||
|
||||
if (hasComponent)
|
||||
{
|
||||
char swzMask = "xyzw"[component];
|
||||
|
||||
context.AppendLine($"layout (location = {location}, component = {component}) {iq}in float {name}_{swzMask}{suffix};");
|
||||
}
|
||||
else
|
||||
{
|
||||
int components = context.Definitions.GetTransformFeedbackOutputComponents(location, 0);
|
||||
|
||||
string type = components switch
|
||||
{
|
||||
2 => "vec2",
|
||||
3 => "vec3",
|
||||
4 => "vec4",
|
||||
_ => "float",
|
||||
};
|
||||
|
||||
context.AppendLine($"layout (location = {location}) in {type} {name};");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
bool passthrough = (context.AttributeUsage.PassthroughAttributes & (1 << location)) != 0;
|
||||
string pass = passthrough && context.HostCapabilities.SupportsGeometryShaderPassthrough ? "passthrough, " : string.Empty;
|
||||
string type = GetVarTypeName(context, context.Definitions.GetUserDefinedType(location, isOutput: false), false);
|
||||
|
||||
context.AppendLine($"layout ({pass}location = {location}) {iq}in {type} {name}{suffix};");
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareInputAttributePerPatch(CodeGenContext context, int patchLocation)
|
||||
{
|
||||
int location = context.AttributeUsage.GetPerPatchAttributeLocation(patchLocation);
|
||||
string name = $"{DefaultNames.PerPatchAttributePrefix}{patchLocation}";
|
||||
|
||||
context.AppendLine($"layout (location = {location}) patch in vec4 {name};");
|
||||
}
|
||||
|
||||
private static void DeclareOutputAttributes(CodeGenContext context, IEnumerable<IoDefinition> outputs)
|
||||
{
|
||||
if (context.Definitions.OaIndexing)
|
||||
{
|
||||
context.AppendLine($"layout (location = 0) out vec4 {DefaultNames.OAttributePrefix}[{Constants.MaxAttributes}];");
|
||||
context.AppendLine();
|
||||
}
|
||||
else
|
||||
{
|
||||
outputs = outputs.OrderBy(x => x.Location);
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Fragment && context.Definitions.DualSourceBlend)
|
||||
{
|
||||
IoDefinition firstOutput = outputs.ElementAtOrDefault(0);
|
||||
|
||||
DeclareOutputDualSourceBlendAttribute(context, firstOutput.Location);
|
||||
outputs = outputs.Skip(2);
|
||||
}
|
||||
|
||||
foreach (IoDefinition ioDefinition in outputs)
|
||||
{
|
||||
DeclareOutputAttribute(context, ioDefinition.Location, ioDefinition.Component);
|
||||
}
|
||||
|
||||
if (outputs.Any())
|
||||
{
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareOutputAttribute(CodeGenContext context, int location, int component)
|
||||
{
|
||||
string suffix = IsArrayAttributeGlsl(context.Definitions.Stage, isOutAttr: true) ? "[]" : string.Empty;
|
||||
string name = $"{DefaultNames.OAttributePrefix}{location}{suffix}";
|
||||
|
||||
if (context.Definitions.TransformFeedbackEnabled && context.Definitions.LastInVertexPipeline)
|
||||
{
|
||||
bool hasComponent = context.Definitions.HasPerLocationInputOrOutputComponent(IoVariable.UserDefined, location, component, isOutput: true);
|
||||
|
||||
if (hasComponent)
|
||||
{
|
||||
char swzMask = "xyzw"[component];
|
||||
|
||||
string xfb = string.Empty;
|
||||
|
||||
TransformFeedbackOutput tfOutput = context.Definitions.GetTransformFeedbackOutput(location, component);
|
||||
if (tfOutput.Valid)
|
||||
{
|
||||
xfb = $", xfb_buffer = {tfOutput.Buffer}, xfb_offset = {tfOutput.Offset}, xfb_stride = {tfOutput.Stride}";
|
||||
}
|
||||
|
||||
context.AppendLine($"layout (location = {location}, component = {component}{xfb}) out float {name}_{swzMask};");
|
||||
}
|
||||
else
|
||||
{
|
||||
int components = context.Definitions.GetTransformFeedbackOutputComponents(location, 0);
|
||||
|
||||
string type = components switch
|
||||
{
|
||||
2 => "vec2",
|
||||
3 => "vec3",
|
||||
4 => "vec4",
|
||||
_ => "float",
|
||||
};
|
||||
|
||||
string xfb = string.Empty;
|
||||
|
||||
TransformFeedbackOutput tfOutput = context.Definitions.GetTransformFeedbackOutput(location, 0);
|
||||
if (tfOutput.Valid)
|
||||
{
|
||||
xfb = $", xfb_buffer = {tfOutput.Buffer}, xfb_offset = {tfOutput.Offset}, xfb_stride = {tfOutput.Stride}";
|
||||
}
|
||||
|
||||
context.AppendLine($"layout (location = {location}{xfb}) out {type} {name};");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
string type = context.Definitions.Stage != ShaderStage.Fragment ? "vec4" :
|
||||
GetVarTypeName(context, context.Definitions.GetFragmentOutputColorType(location), false);
|
||||
|
||||
if (context.HostCapabilities.ReducedPrecision && context.Definitions.Stage == ShaderStage.Vertex && location == 0)
|
||||
{
|
||||
context.AppendLine($"layout (location = {location}) invariant out {type} {name};");
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AppendLine($"layout (location = {location}) out {type} {name};");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareOutputDualSourceBlendAttribute(CodeGenContext context, int location)
|
||||
{
|
||||
string name = $"{DefaultNames.OAttributePrefix}{location}";
|
||||
string name2 = $"{DefaultNames.OAttributePrefix}{(location + 1)}";
|
||||
|
||||
context.AppendLine($"layout (location = {location}, index = 0) out vec4 {name};");
|
||||
context.AppendLine($"layout (location = {location}, index = 1) out vec4 {name2};");
|
||||
}
|
||||
|
||||
private static void DeclareOutputAttributesPerPatch(CodeGenContext context, IEnumerable<IoDefinition> outputs)
|
||||
{
|
||||
foreach (IoDefinition ioDefinition in outputs)
|
||||
{
|
||||
DeclareOutputAttributePerPatch(context, ioDefinition.Location);
|
||||
}
|
||||
|
||||
if (outputs.Any())
|
||||
{
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareOutputAttributePerPatch(CodeGenContext context, int patchLocation)
|
||||
{
|
||||
int location = context.AttributeUsage.GetPerPatchAttributeLocation(patchLocation);
|
||||
string name = $"{DefaultNames.PerPatchAttributePrefix}{patchLocation}";
|
||||
|
||||
context.AppendLine($"layout (location = {location}) patch out vec4 {name};");
|
||||
}
|
||||
|
||||
private static bool IsArrayAttributeGlsl(ShaderStage stage, bool isOutAttr)
|
||||
{
|
||||
if (isOutAttr)
|
||||
{
|
||||
return stage == ShaderStage.TessellationControl;
|
||||
}
|
||||
else
|
||||
{
|
||||
return stage is ShaderStage.TessellationControl or
|
||||
ShaderStage.TessellationEvaluation or
|
||||
ShaderStage.Geometry;
|
||||
}
|
||||
}
|
||||
|
||||
private static void AppendHelperFunction(CodeGenContext context, string filename)
|
||||
{
|
||||
string code = EmbeddedResources.ReadAllText(filename);
|
||||
|
||||
code = code.Replace("\t", CodeGenContext.Tab);
|
||||
|
||||
if (context.HostCapabilities.SupportsShaderBallot)
|
||||
{
|
||||
code = code.Replace("$SUBGROUP_INVOCATION$", "gl_SubGroupInvocationARB");
|
||||
code = code.Replace("$SUBGROUP_BROADCAST$", "readInvocationARB");
|
||||
}
|
||||
else
|
||||
{
|
||||
code = code.Replace("$SUBGROUP_INVOCATION$", "gl_SubgroupInvocationID");
|
||||
code = code.Replace("$SUBGROUP_BROADCAST$", "subgroupBroadcast");
|
||||
}
|
||||
|
||||
context.AppendLine(code);
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
}
|
||||
15
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs
vendored
Normal file
15
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class DefaultNames
|
||||
{
|
||||
public const string LocalNamePrefix = "temp";
|
||||
|
||||
public const string PerPatchAttributePrefix = "patch_attr_";
|
||||
public const string IAttributePrefix = "in_attr";
|
||||
public const string OAttributePrefix = "out_attr";
|
||||
|
||||
public const string ArgumentNamePrefix = "a";
|
||||
|
||||
public const string UndefinedName = "undef";
|
||||
}
|
||||
}
|
||||
177
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/GlslGenerator.cs
vendored
Normal file
177
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/GlslGenerator.cs
vendored
Normal file
@@ -0,0 +1,177 @@
|
||||
using Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.TypeConversion;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class GlslGenerator
|
||||
{
|
||||
private const string MainFunctionName = "main";
|
||||
|
||||
public static string Generate(StructuredProgramInfo info, CodeGenParameters parameters)
|
||||
{
|
||||
CodeGenContext context = new(info, parameters);
|
||||
|
||||
Declarations.Declare(context, info);
|
||||
|
||||
if (info.Functions.Count != 0)
|
||||
{
|
||||
for (int i = 1; i < info.Functions.Count; i++)
|
||||
{
|
||||
context.AppendLine($"{GetFunctionSignature(context, info.Functions[i])};");
|
||||
}
|
||||
|
||||
context.AppendLine();
|
||||
|
||||
for (int i = 1; i < info.Functions.Count; i++)
|
||||
{
|
||||
PrintFunction(context, info.Functions[i]);
|
||||
|
||||
context.AppendLine();
|
||||
}
|
||||
}
|
||||
|
||||
PrintFunction(context, info.Functions[0], MainFunctionName);
|
||||
|
||||
return context.GetCode();
|
||||
}
|
||||
|
||||
private static void PrintFunction(CodeGenContext context, StructuredFunction function, string funcName = null)
|
||||
{
|
||||
context.CurrentFunction = function;
|
||||
|
||||
context.AppendLine(GetFunctionSignature(context, function, funcName));
|
||||
context.EnterScope();
|
||||
|
||||
Declarations.DeclareLocals(context, function);
|
||||
|
||||
PrintBlock(context, function.MainBlock, funcName == MainFunctionName);
|
||||
|
||||
context.LeaveScope();
|
||||
}
|
||||
|
||||
private static string GetFunctionSignature(CodeGenContext context, StructuredFunction function, string funcName = null)
|
||||
{
|
||||
string[] args = new string[function.InArguments.Length + function.OutArguments.Length];
|
||||
|
||||
for (int i = 0; i < function.InArguments.Length; i++)
|
||||
{
|
||||
args[i] = $"{Declarations.GetVarTypeName(context, function.InArguments[i])} {OperandManager.GetArgumentName(i)}";
|
||||
}
|
||||
|
||||
for (int i = 0; i < function.OutArguments.Length; i++)
|
||||
{
|
||||
int j = i + function.InArguments.Length;
|
||||
|
||||
args[j] = $"out {Declarations.GetVarTypeName(context, function.OutArguments[i])} {OperandManager.GetArgumentName(j)}";
|
||||
}
|
||||
|
||||
return $"{Declarations.GetVarTypeName(context, function.ReturnType)} {funcName ?? function.Name}({string.Join(", ", args)})";
|
||||
}
|
||||
|
||||
private static void PrintBlock(CodeGenContext context, AstBlock block, bool isMainFunction)
|
||||
{
|
||||
AstBlockVisitor visitor = new(block);
|
||||
|
||||
visitor.BlockEntered += (sender, e) =>
|
||||
{
|
||||
switch (e.Block.Type)
|
||||
{
|
||||
case AstBlockType.DoWhile:
|
||||
context.AppendLine("do");
|
||||
break;
|
||||
|
||||
case AstBlockType.Else:
|
||||
context.AppendLine("else");
|
||||
break;
|
||||
|
||||
case AstBlockType.ElseIf:
|
||||
context.AppendLine($"else if ({GetCondExpr(context, e.Block.Condition)})");
|
||||
break;
|
||||
|
||||
case AstBlockType.If:
|
||||
context.AppendLine($"if ({GetCondExpr(context, e.Block.Condition)})");
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new InvalidOperationException($"Found unexpected block type \"{e.Block.Type}\".");
|
||||
}
|
||||
|
||||
context.EnterScope();
|
||||
};
|
||||
|
||||
visitor.BlockLeft += (sender, e) =>
|
||||
{
|
||||
context.LeaveScope();
|
||||
|
||||
if (e.Block.Type == AstBlockType.DoWhile)
|
||||
{
|
||||
context.AppendLine($"while ({GetCondExpr(context, e.Block.Condition)});");
|
||||
}
|
||||
};
|
||||
|
||||
bool supportsBarrierDivergence = context.HostCapabilities.SupportsShaderBarrierDivergence;
|
||||
bool mayHaveReturned = false;
|
||||
|
||||
foreach (IAstNode node in visitor.Visit())
|
||||
{
|
||||
if (node is AstOperation operation)
|
||||
{
|
||||
if (!supportsBarrierDivergence)
|
||||
{
|
||||
if (operation.Inst == IntermediateRepresentation.Instruction.Barrier)
|
||||
{
|
||||
// Barrier on divergent control flow paths may cause the GPU to hang,
|
||||
// so skip emitting the barrier for those cases.
|
||||
if (visitor.Block.Type != AstBlockType.Main || mayHaveReturned || !isMainFunction)
|
||||
{
|
||||
context.Logger.Log("Shader has barrier on potentially divergent block, the barrier will be removed.");
|
||||
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else if (operation.Inst == IntermediateRepresentation.Instruction.Return)
|
||||
{
|
||||
mayHaveReturned = true;
|
||||
}
|
||||
}
|
||||
|
||||
string expr = InstGen.GetExpression(context, operation);
|
||||
|
||||
if (expr != null)
|
||||
{
|
||||
context.AppendLine(expr + ";");
|
||||
}
|
||||
}
|
||||
else if (node is AstAssignment assignment)
|
||||
{
|
||||
AggregateType dstType = OperandManager.GetNodeDestType(context, assignment.Destination);
|
||||
AggregateType srcType = OperandManager.GetNodeDestType(context, assignment.Source);
|
||||
|
||||
string dest = InstGen.GetExpression(context, assignment.Destination);
|
||||
string src = ReinterpretCast(context, assignment.Source, srcType, dstType);
|
||||
|
||||
context.AppendLine(dest + " = " + src + ";");
|
||||
}
|
||||
else if (node is AstComment comment)
|
||||
{
|
||||
context.AppendLine("// " + comment.Comment);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new InvalidOperationException($"Found unexpected node type \"{node?.GetType().Name ?? "null"}\".");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static string GetCondExpr(CodeGenContext context, IAstNode cond)
|
||||
{
|
||||
AggregateType srcType = OperandManager.GetNodeDestType(context, cond);
|
||||
|
||||
return ReinterpretCast(context, cond, srcType, AggregateType.Bool);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class HelperFunctionNames
|
||||
{
|
||||
public static string MultiplyHighS32 = "Helper_MultiplyHighS32";
|
||||
public static string MultiplyHighU32 = "Helper_MultiplyHighU32";
|
||||
|
||||
public static string SwizzleAdd = "Helper_SwizzleAdd";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
int Helper_MultiplyHighS32(int x, int y)
|
||||
{
|
||||
int msb;
|
||||
int lsb;
|
||||
imulExtended(x, y, msb, lsb);
|
||||
return msb;
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
uint Helper_MultiplyHighU32(uint x, uint y)
|
||||
{
|
||||
uint msb;
|
||||
uint lsb;
|
||||
umulExtended(x, y, msb, lsb);
|
||||
return msb;
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
float Helper_SwizzleAdd(float x, float y, int mask)
|
||||
{
|
||||
vec4 xLut = vec4(1.0, -1.0, 1.0, 0.0);
|
||||
vec4 yLut = vec4(1.0, 1.0, -1.0, 1.0);
|
||||
int lutIdx = (mask >> (int($SUBGROUP_INVOCATION$ & 3u) * 2)) & 3;
|
||||
return x * xLut[lutIdx] + y * yLut[lutIdx];
|
||||
}
|
||||
208
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGen.cs
vendored
Normal file
208
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGen.cs
vendored
Normal file
@@ -0,0 +1,208 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Text;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenBallot;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenCall;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenFSI;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenMemory;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenPacking;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenShuffle;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenVector;
|
||||
using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGen
|
||||
{
|
||||
public static string GetExpression(CodeGenContext context, IAstNode node)
|
||||
{
|
||||
if (node is AstOperation operation)
|
||||
{
|
||||
return GetExpression(context, operation);
|
||||
}
|
||||
else if (node is AstOperand operand)
|
||||
{
|
||||
return context.OperandManager.GetExpression(context, operand);
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Invalid node type \"{node?.GetType().Name ?? "null"}\".");
|
||||
}
|
||||
|
||||
public static string Negate(CodeGenContext context, AstOperation operation, InstInfo info)
|
||||
{
|
||||
IAstNode src = operation.GetSource(0);
|
||||
|
||||
AggregateType type = GetSrcVarType(operation.Inst, 0);
|
||||
|
||||
string srcExpr = GetSourceExpr(context, src, type);
|
||||
string zero;
|
||||
|
||||
if (type == AggregateType.FP64)
|
||||
{
|
||||
zero = "0.0";
|
||||
}
|
||||
else
|
||||
{
|
||||
NumberFormatter.TryFormat(0, type, out zero);
|
||||
}
|
||||
|
||||
// Starting in the 496.13 NVIDIA driver, there's an issue with assigning variables to negated expressions.
|
||||
// (-expr) does not work, but (0.0 - expr) does. This should be removed once the issue is resolved.
|
||||
|
||||
return $"{zero} - {Enclose(srcExpr, src, operation.Inst, info, false)}";
|
||||
}
|
||||
|
||||
private static string GetExpression(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
Instruction inst = operation.Inst;
|
||||
|
||||
InstInfo info = GetInstructionInfo(inst);
|
||||
|
||||
if ((info.Type & InstType.Call) != 0)
|
||||
{
|
||||
bool atomic = (info.Type & InstType.Atomic) != 0;
|
||||
|
||||
int arity = (int)(info.Type & InstType.ArityMask);
|
||||
|
||||
StringBuilder builder = new();
|
||||
|
||||
if (atomic && (operation.StorageKind == StorageKind.StorageBuffer || operation.StorageKind == StorageKind.SharedMemory))
|
||||
{
|
||||
builder.Append(GenerateLoadOrStore(context, operation, isStore: false));
|
||||
|
||||
AggregateType dstType = operation.Inst is Instruction.AtomicMaxS32 or Instruction.AtomicMinS32
|
||||
? AggregateType.S32
|
||||
: AggregateType.U32;
|
||||
|
||||
for (int argIndex = operation.SourcesCount - arity + 2; argIndex < operation.SourcesCount; argIndex++)
|
||||
{
|
||||
builder.Append($", {GetSourceExpr(context, operation.GetSource(argIndex), dstType)}");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int argIndex = 0; argIndex < arity; argIndex++)
|
||||
{
|
||||
if (argIndex != 0)
|
||||
{
|
||||
builder.Append(", ");
|
||||
}
|
||||
|
||||
AggregateType dstType = GetSrcVarType(inst, argIndex);
|
||||
|
||||
builder.Append(GetSourceExpr(context, operation.GetSource(argIndex), dstType));
|
||||
}
|
||||
}
|
||||
|
||||
return $"{info.OpName}({builder})";
|
||||
}
|
||||
else if ((info.Type & InstType.Op) != 0)
|
||||
{
|
||||
string op = info.OpName;
|
||||
|
||||
// Return may optionally have a return value (and in this case it is unary).
|
||||
if (inst == Instruction.Return && operation.SourcesCount != 0)
|
||||
{
|
||||
return $"{op} {GetSourceExpr(context, operation.GetSource(0), context.CurrentFunction.ReturnType)}";
|
||||
}
|
||||
|
||||
int arity = (int)(info.Type & InstType.ArityMask);
|
||||
|
||||
string[] expr = new string[arity];
|
||||
|
||||
for (int index = 0; index < arity; index++)
|
||||
{
|
||||
IAstNode src = operation.GetSource(index);
|
||||
|
||||
string srcExpr = GetSourceExpr(context, src, GetSrcVarType(inst, index));
|
||||
|
||||
bool isLhs = arity == 2 && index == 0;
|
||||
|
||||
expr[index] = Enclose(srcExpr, src, inst, info, isLhs);
|
||||
}
|
||||
|
||||
switch (arity)
|
||||
{
|
||||
case 0:
|
||||
return op;
|
||||
|
||||
case 1:
|
||||
return op + expr[0];
|
||||
|
||||
case 2:
|
||||
return $"{expr[0]} {op} {expr[1]}";
|
||||
|
||||
case 3:
|
||||
return $"{expr[0]} {op[0]} {expr[1]} {op[1]} {expr[2]}";
|
||||
}
|
||||
}
|
||||
else if ((info.Type & InstType.Special) != 0)
|
||||
{
|
||||
switch (inst & Instruction.Mask)
|
||||
{
|
||||
case Instruction.Ballot:
|
||||
return Ballot(context, operation);
|
||||
|
||||
case Instruction.Call:
|
||||
return Call(context, operation);
|
||||
|
||||
case Instruction.FSIBegin:
|
||||
return FSIBegin(context);
|
||||
|
||||
case Instruction.FSIEnd:
|
||||
return FSIEnd(context);
|
||||
|
||||
case Instruction.ImageLoad:
|
||||
case Instruction.ImageStore:
|
||||
case Instruction.ImageAtomic:
|
||||
return ImageLoadOrStore(context, operation);
|
||||
|
||||
case Instruction.Load:
|
||||
return Load(context, operation);
|
||||
|
||||
case Instruction.Lod:
|
||||
return Lod(context, operation);
|
||||
|
||||
case Instruction.Negate:
|
||||
return Negate(context, operation, info);
|
||||
|
||||
case Instruction.PackDouble2x32:
|
||||
return PackDouble2x32(context, operation);
|
||||
|
||||
case Instruction.PackHalf2x16:
|
||||
return PackHalf2x16(context, operation);
|
||||
|
||||
case Instruction.Shuffle:
|
||||
return Shuffle(context, operation);
|
||||
|
||||
case Instruction.Store:
|
||||
return Store(context, operation);
|
||||
|
||||
case Instruction.TextureSample:
|
||||
return TextureSample(context, operation);
|
||||
|
||||
case Instruction.TextureQuerySamples:
|
||||
return TextureQuerySamples(context, operation);
|
||||
|
||||
case Instruction.TextureQuerySize:
|
||||
return TextureQuerySize(context, operation);
|
||||
|
||||
case Instruction.UnpackDouble2x32:
|
||||
return UnpackDouble2x32(context, operation);
|
||||
|
||||
case Instruction.UnpackHalf2x16:
|
||||
return UnpackHalf2x16(context, operation);
|
||||
|
||||
case Instruction.VectorExtract:
|
||||
return VectorExtract(context, operation);
|
||||
}
|
||||
}
|
||||
|
||||
throw new InvalidOperationException($"Unexpected instruction type \"{info.Type}\".");
|
||||
}
|
||||
}
|
||||
}
|
||||
28
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenBallot.cs
vendored
Normal file
28
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenBallot.cs
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenBallot
|
||||
{
|
||||
public static string Ballot(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AggregateType dstType = GetSrcVarType(operation.Inst, 0);
|
||||
|
||||
string arg = GetSourceExpr(context, operation.GetSource(0), dstType);
|
||||
char component = "xyzw"[operation.Index];
|
||||
|
||||
if (context.HostCapabilities.SupportsShaderBallot)
|
||||
{
|
||||
return $"unpackUint2x32(ballotARB({arg})).{component}";
|
||||
}
|
||||
else
|
||||
{
|
||||
return $"subgroupBallot({arg}).{component}";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
29
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenCall.cs
vendored
Normal file
29
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenCall.cs
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using System.Diagnostics;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenCall
|
||||
{
|
||||
public static string Call(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AstOperand funcId = (AstOperand)operation.GetSource(0);
|
||||
|
||||
Debug.Assert(funcId.Type == OperandType.Constant);
|
||||
|
||||
StructuredFunction function = context.GetFunction(funcId.Value);
|
||||
|
||||
string[] args = new string[operation.SourcesCount - 1];
|
||||
|
||||
for (int i = 0; i < args.Length; i++)
|
||||
{
|
||||
args[i] = GetSourceExpr(context, operation.GetSource(i + 1), function.GetArgumentType(i));
|
||||
}
|
||||
|
||||
return $"{function.Name}({string.Join(", ", args)})";
|
||||
}
|
||||
}
|
||||
}
|
||||
29
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenFSI.cs
vendored
Normal file
29
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenFSI.cs
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenFSI
|
||||
{
|
||||
public static string FSIBegin(CodeGenContext context)
|
||||
{
|
||||
if (context.HostCapabilities.SupportsFragmentShaderInterlock)
|
||||
{
|
||||
return "beginInvocationInterlockARB()";
|
||||
}
|
||||
else if (context.HostCapabilities.SupportsFragmentShaderOrderingIntel)
|
||||
{
|
||||
return "beginFragmentShaderOrderingINTEL()";
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static string FSIEnd(CodeGenContext context)
|
||||
{
|
||||
if (context.HostCapabilities.SupportsFragmentShaderInterlock)
|
||||
{
|
||||
return "endInvocationInterlockARB()";
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
222
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs
vendored
Normal file
222
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenHelper.cs
vendored
Normal file
@@ -0,0 +1,222 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.TypeConversion;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenHelper
|
||||
{
|
||||
private static readonly InstInfo[] _infoTable;
|
||||
|
||||
static InstGenHelper()
|
||||
{
|
||||
_infoTable = new InstInfo[(int)Instruction.Count];
|
||||
|
||||
#pragma warning disable IDE0055 // Disable formatting
|
||||
Add(Instruction.AtomicAdd, InstType.AtomicBinary, "atomicAdd");
|
||||
Add(Instruction.AtomicAnd, InstType.AtomicBinary, "atomicAnd");
|
||||
Add(Instruction.AtomicCompareAndSwap, InstType.AtomicTernary, "atomicCompSwap");
|
||||
Add(Instruction.AtomicMaxU32, InstType.AtomicBinary, "atomicMax");
|
||||
Add(Instruction.AtomicMinU32, InstType.AtomicBinary, "atomicMin");
|
||||
Add(Instruction.AtomicOr, InstType.AtomicBinary, "atomicOr");
|
||||
Add(Instruction.AtomicSwap, InstType.AtomicBinary, "atomicExchange");
|
||||
Add(Instruction.AtomicXor, InstType.AtomicBinary, "atomicXor");
|
||||
Add(Instruction.Absolute, InstType.CallUnary, "abs");
|
||||
Add(Instruction.Add, InstType.OpBinaryCom, "+", 2);
|
||||
Add(Instruction.Ballot, InstType.Special);
|
||||
Add(Instruction.Barrier, InstType.CallNullary, "barrier");
|
||||
Add(Instruction.BitCount, InstType.CallUnary, "bitCount");
|
||||
Add(Instruction.BitfieldExtractS32, InstType.CallTernary, "bitfieldExtract");
|
||||
Add(Instruction.BitfieldExtractU32, InstType.CallTernary, "bitfieldExtract");
|
||||
Add(Instruction.BitfieldInsert, InstType.CallQuaternary, "bitfieldInsert");
|
||||
Add(Instruction.BitfieldReverse, InstType.CallUnary, "bitfieldReverse");
|
||||
Add(Instruction.BitwiseAnd, InstType.OpBinaryCom, "&", 6);
|
||||
Add(Instruction.BitwiseExclusiveOr, InstType.OpBinaryCom, "^", 7);
|
||||
Add(Instruction.BitwiseNot, InstType.OpUnary, "~", 0);
|
||||
Add(Instruction.BitwiseOr, InstType.OpBinaryCom, "|", 8);
|
||||
Add(Instruction.Call, InstType.Special);
|
||||
Add(Instruction.Ceiling, InstType.CallUnary, "ceil");
|
||||
Add(Instruction.Clamp, InstType.CallTernary, "clamp");
|
||||
Add(Instruction.ClampU32, InstType.CallTernary, "clamp");
|
||||
Add(Instruction.CompareEqual, InstType.OpBinaryCom, "==", 5);
|
||||
Add(Instruction.CompareGreater, InstType.OpBinary, ">", 4);
|
||||
Add(Instruction.CompareGreaterOrEqual, InstType.OpBinary, ">=", 4);
|
||||
Add(Instruction.CompareGreaterOrEqualU32, InstType.OpBinary, ">=", 4);
|
||||
Add(Instruction.CompareGreaterU32, InstType.OpBinary, ">", 4);
|
||||
Add(Instruction.CompareLess, InstType.OpBinary, "<", 4);
|
||||
Add(Instruction.CompareLessOrEqual, InstType.OpBinary, "<=", 4);
|
||||
Add(Instruction.CompareLessOrEqualU32, InstType.OpBinary, "<=", 4);
|
||||
Add(Instruction.CompareLessU32, InstType.OpBinary, "<", 4);
|
||||
Add(Instruction.CompareNotEqual, InstType.OpBinaryCom, "!=", 5);
|
||||
Add(Instruction.ConditionalSelect, InstType.OpTernary, "?:", 12);
|
||||
Add(Instruction.ConvertFP32ToFP64, InstType.CallUnary, "double");
|
||||
Add(Instruction.ConvertFP64ToFP32, InstType.CallUnary, "float");
|
||||
Add(Instruction.ConvertFP32ToS32, InstType.CallUnary, "int");
|
||||
Add(Instruction.ConvertFP32ToU32, InstType.CallUnary, "uint");
|
||||
Add(Instruction.ConvertFP64ToS32, InstType.CallUnary, "int");
|
||||
Add(Instruction.ConvertFP64ToU32, InstType.CallUnary, "uint");
|
||||
Add(Instruction.ConvertS32ToFP32, InstType.CallUnary, "float");
|
||||
Add(Instruction.ConvertS32ToFP64, InstType.CallUnary, "double");
|
||||
Add(Instruction.ConvertU32ToFP32, InstType.CallUnary, "float");
|
||||
Add(Instruction.ConvertU32ToFP64, InstType.CallUnary, "double");
|
||||
Add(Instruction.Cosine, InstType.CallUnary, "cos");
|
||||
Add(Instruction.Ddx, InstType.CallUnary, "dFdx");
|
||||
Add(Instruction.Ddy, InstType.CallUnary, "dFdy");
|
||||
Add(Instruction.Discard, InstType.OpNullary, "discard");
|
||||
Add(Instruction.Divide, InstType.OpBinary, "/", 1);
|
||||
Add(Instruction.EmitVertex, InstType.CallNullary, "EmitVertex");
|
||||
Add(Instruction.EndPrimitive, InstType.CallNullary, "EndPrimitive");
|
||||
Add(Instruction.ExponentB2, InstType.CallUnary, "exp2");
|
||||
Add(Instruction.FSIBegin, InstType.Special);
|
||||
Add(Instruction.FSIEnd, InstType.Special);
|
||||
Add(Instruction.FindLSB, InstType.CallUnary, "findLSB");
|
||||
Add(Instruction.FindMSBS32, InstType.CallUnary, "findMSB");
|
||||
Add(Instruction.FindMSBU32, InstType.CallUnary, "findMSB");
|
||||
Add(Instruction.Floor, InstType.CallUnary, "floor");
|
||||
Add(Instruction.FusedMultiplyAdd, InstType.CallTernary, "fma");
|
||||
Add(Instruction.GroupMemoryBarrier, InstType.CallNullary, "groupMemoryBarrier");
|
||||
Add(Instruction.ImageLoad, InstType.Special);
|
||||
Add(Instruction.ImageStore, InstType.Special);
|
||||
Add(Instruction.ImageAtomic, InstType.Special);
|
||||
Add(Instruction.IsNan, InstType.CallUnary, "isnan");
|
||||
Add(Instruction.Load, InstType.Special);
|
||||
Add(Instruction.Lod, InstType.Special);
|
||||
Add(Instruction.LogarithmB2, InstType.CallUnary, "log2");
|
||||
Add(Instruction.LogicalAnd, InstType.OpBinaryCom, "&&", 9);
|
||||
Add(Instruction.LogicalExclusiveOr, InstType.OpBinaryCom, "^^", 10);
|
||||
Add(Instruction.LogicalNot, InstType.OpUnary, "!", 0);
|
||||
Add(Instruction.LogicalOr, InstType.OpBinaryCom, "||", 11);
|
||||
Add(Instruction.LoopBreak, InstType.OpNullary, "break");
|
||||
Add(Instruction.LoopContinue, InstType.OpNullary, "continue");
|
||||
Add(Instruction.PackDouble2x32, InstType.Special);
|
||||
Add(Instruction.PackHalf2x16, InstType.Special);
|
||||
Add(Instruction.Maximum, InstType.CallBinary, "max");
|
||||
Add(Instruction.MaximumU32, InstType.CallBinary, "max");
|
||||
Add(Instruction.MemoryBarrier, InstType.CallNullary, "memoryBarrier");
|
||||
Add(Instruction.Minimum, InstType.CallBinary, "min");
|
||||
Add(Instruction.MinimumU32, InstType.CallBinary, "min");
|
||||
Add(Instruction.Modulo, InstType.CallBinary, "mod");
|
||||
Add(Instruction.Multiply, InstType.OpBinaryCom, "*", 1);
|
||||
Add(Instruction.MultiplyHighS32, InstType.CallBinary, HelperFunctionNames.MultiplyHighS32);
|
||||
Add(Instruction.MultiplyHighU32, InstType.CallBinary, HelperFunctionNames.MultiplyHighU32);
|
||||
Add(Instruction.Negate, InstType.Special);
|
||||
Add(Instruction.ReciprocalSquareRoot, InstType.CallUnary, "inversesqrt");
|
||||
Add(Instruction.Return, InstType.OpNullary, "return");
|
||||
Add(Instruction.Round, InstType.CallUnary, "roundEven");
|
||||
Add(Instruction.ShiftLeft, InstType.OpBinary, "<<", 3);
|
||||
Add(Instruction.ShiftRightS32, InstType.OpBinary, ">>", 3);
|
||||
Add(Instruction.ShiftRightU32, InstType.OpBinary, ">>", 3);
|
||||
Add(Instruction.Shuffle, InstType.Special);
|
||||
Add(Instruction.ShuffleDown, InstType.CallBinary, "subgroupShuffleDown");
|
||||
Add(Instruction.ShuffleUp, InstType.CallBinary, "subgroupShuffleUp");
|
||||
Add(Instruction.ShuffleXor, InstType.CallBinary, "subgroupShuffleXor");
|
||||
Add(Instruction.Sine, InstType.CallUnary, "sin");
|
||||
Add(Instruction.SquareRoot, InstType.CallUnary, "sqrt");
|
||||
Add(Instruction.Store, InstType.Special);
|
||||
Add(Instruction.Subtract, InstType.OpBinary, "-", 2);
|
||||
Add(Instruction.SwizzleAdd, InstType.CallTernary, HelperFunctionNames.SwizzleAdd);
|
||||
Add(Instruction.TextureSample, InstType.Special);
|
||||
Add(Instruction.TextureQuerySamples, InstType.Special);
|
||||
Add(Instruction.TextureQuerySize, InstType.Special);
|
||||
Add(Instruction.Truncate, InstType.CallUnary, "trunc");
|
||||
Add(Instruction.UnpackDouble2x32, InstType.Special);
|
||||
Add(Instruction.UnpackHalf2x16, InstType.Special);
|
||||
Add(Instruction.VectorExtract, InstType.Special);
|
||||
Add(Instruction.VoteAll, InstType.CallUnary, "allInvocationsARB");
|
||||
Add(Instruction.VoteAllEqual, InstType.CallUnary, "allInvocationsEqualARB");
|
||||
Add(Instruction.VoteAny, InstType.CallUnary, "anyInvocationARB");
|
||||
#pragma warning restore IDE0055
|
||||
}
|
||||
|
||||
private static void Add(Instruction inst, InstType flags, string opName = null, int precedence = 0)
|
||||
{
|
||||
_infoTable[(int)inst] = new InstInfo(flags, opName, precedence);
|
||||
}
|
||||
|
||||
public static InstInfo GetInstructionInfo(Instruction inst)
|
||||
{
|
||||
return _infoTable[(int)(inst & Instruction.Mask)];
|
||||
}
|
||||
|
||||
public static string GetSourceExpr(CodeGenContext context, IAstNode node, AggregateType dstType)
|
||||
{
|
||||
return ReinterpretCast(context, node, OperandManager.GetNodeDestType(context, node), dstType);
|
||||
}
|
||||
|
||||
public static string Enclose(string expr, IAstNode node, Instruction pInst, bool isLhs)
|
||||
{
|
||||
InstInfo pInfo = GetInstructionInfo(pInst);
|
||||
|
||||
return Enclose(expr, node, pInst, pInfo, isLhs);
|
||||
}
|
||||
|
||||
public static string Enclose(string expr, IAstNode node, Instruction pInst, InstInfo pInfo, bool isLhs = false)
|
||||
{
|
||||
if (NeedsParenthesis(node, pInst, pInfo, isLhs))
|
||||
{
|
||||
expr = "(" + expr + ")";
|
||||
}
|
||||
|
||||
return expr;
|
||||
}
|
||||
|
||||
public static bool NeedsParenthesis(IAstNode node, Instruction pInst, InstInfo pInfo, bool isLhs)
|
||||
{
|
||||
// If the node isn't a operation, then it can only be a operand,
|
||||
// and those never needs to be surrounded in parenthesis.
|
||||
if (node is not AstOperation operation)
|
||||
{
|
||||
// This is sort of a special case, if this is a negative constant,
|
||||
// and it is consumed by a unary operation, we need to put on the parenthesis,
|
||||
// as in GLSL a sequence like --2 or ~-1 is not valid.
|
||||
if (IsNegativeConst(node) && pInfo.Type == InstType.OpUnary)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
if ((pInfo.Type & (InstType.Call | InstType.Special)) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
InstInfo info = _infoTable[(int)(operation.Inst & Instruction.Mask)];
|
||||
|
||||
if ((info.Type & (InstType.Call | InstType.Special)) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (info.Precedence < pInfo.Precedence)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (info.Precedence == pInfo.Precedence && isLhs)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pInst == operation.Inst && info.Type == InstType.OpBinaryCom)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private static bool IsNegativeConst(IAstNode node)
|
||||
{
|
||||
if (node is not AstOperand operand)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return operand.Type == OperandType.Constant && operand.Value < 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
701
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs
vendored
Normal file
701
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenMemory.cs
vendored
Normal file
@@ -0,0 +1,701 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Text;
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenMemory
|
||||
{
|
||||
public static string ImageLoadOrStore(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AstTextureOperation texOp = (AstTextureOperation)operation;
|
||||
|
||||
bool isArray = (texOp.Type & SamplerType.Array) != 0;
|
||||
|
||||
StringBuilder texCallBuilder = new();
|
||||
|
||||
if (texOp.Inst == Instruction.ImageAtomic)
|
||||
{
|
||||
texCallBuilder.Append((texOp.Flags & TextureFlags.AtomicMask) switch
|
||||
{
|
||||
#pragma warning disable IDE0055 // Disable formatting
|
||||
TextureFlags.Add => "imageAtomicAdd",
|
||||
TextureFlags.Minimum => "imageAtomicMin",
|
||||
TextureFlags.Maximum => "imageAtomicMax",
|
||||
TextureFlags.Increment => "imageAtomicAdd", // TODO: Clamp value.
|
||||
TextureFlags.Decrement => "imageAtomicAdd", // TODO: Clamp value.
|
||||
TextureFlags.BitwiseAnd => "imageAtomicAnd",
|
||||
TextureFlags.BitwiseOr => "imageAtomicOr",
|
||||
TextureFlags.BitwiseXor => "imageAtomicXor",
|
||||
TextureFlags.Swap => "imageAtomicExchange",
|
||||
TextureFlags.CAS => "imageAtomicCompSwap",
|
||||
_ => "imageAtomicAdd",
|
||||
#pragma warning restore IDE0055
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
texCallBuilder.Append(texOp.Inst == Instruction.ImageLoad ? "imageLoad" : "imageStore");
|
||||
}
|
||||
|
||||
int srcIndex = 0;
|
||||
|
||||
string Src(AggregateType type)
|
||||
{
|
||||
return GetSourceExpr(context, texOp.GetSource(srcIndex++), type);
|
||||
}
|
||||
|
||||
string imageName = GetImageName(context, texOp, ref srcIndex);
|
||||
|
||||
texCallBuilder.Append('(');
|
||||
texCallBuilder.Append(imageName);
|
||||
|
||||
int coordsCount = texOp.Type.Dimensions;
|
||||
|
||||
int pCount = coordsCount + (isArray ? 1 : 0);
|
||||
|
||||
void Append(string str)
|
||||
{
|
||||
texCallBuilder.Append(", ");
|
||||
texCallBuilder.Append(str);
|
||||
}
|
||||
|
||||
if (pCount > 1)
|
||||
{
|
||||
string[] elems = new string[pCount];
|
||||
|
||||
for (int index = 0; index < pCount; index++)
|
||||
{
|
||||
elems[index] = Src(AggregateType.S32);
|
||||
}
|
||||
|
||||
Append($"ivec{pCount}({string.Join(", ", elems)})");
|
||||
}
|
||||
else
|
||||
{
|
||||
Append(Src(AggregateType.S32));
|
||||
}
|
||||
|
||||
if (texOp.Inst == Instruction.ImageStore)
|
||||
{
|
||||
AggregateType type = texOp.Format.GetComponentType();
|
||||
|
||||
string[] cElems = new string[4];
|
||||
|
||||
for (int index = 0; index < 4; index++)
|
||||
{
|
||||
if (srcIndex < texOp.SourcesCount)
|
||||
{
|
||||
cElems[index] = Src(type);
|
||||
}
|
||||
else
|
||||
{
|
||||
cElems[index] = type switch
|
||||
{
|
||||
AggregateType.S32 => NumberFormatter.FormatInt(0),
|
||||
AggregateType.U32 => NumberFormatter.FormatUint(0),
|
||||
_ => NumberFormatter.FormatFloat(0),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
string prefix = type switch
|
||||
{
|
||||
AggregateType.S32 => "i",
|
||||
AggregateType.U32 => "u",
|
||||
_ => string.Empty,
|
||||
};
|
||||
|
||||
Append($"{prefix}vec4({string.Join(", ", cElems)})");
|
||||
}
|
||||
|
||||
if (texOp.Inst == Instruction.ImageAtomic)
|
||||
{
|
||||
AggregateType type = texOp.Format.GetComponentType();
|
||||
|
||||
if ((texOp.Flags & TextureFlags.AtomicMask) == TextureFlags.CAS)
|
||||
{
|
||||
Append(Src(type)); // Compare value.
|
||||
}
|
||||
|
||||
string value = (texOp.Flags & TextureFlags.AtomicMask) switch
|
||||
{
|
||||
TextureFlags.Increment => NumberFormatter.FormatInt(1, type), // TODO: Clamp value
|
||||
TextureFlags.Decrement => NumberFormatter.FormatInt(-1, type), // TODO: Clamp value
|
||||
_ => Src(type),
|
||||
};
|
||||
|
||||
Append(value);
|
||||
|
||||
texCallBuilder.Append(')');
|
||||
|
||||
if (type != AggregateType.S32)
|
||||
{
|
||||
texCallBuilder
|
||||
.Insert(0, "int(")
|
||||
.Append(')');
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
texCallBuilder.Append(')');
|
||||
|
||||
if (texOp.Inst == Instruction.ImageLoad)
|
||||
{
|
||||
texCallBuilder.Append(GetMaskMultiDest(texOp.Index));
|
||||
}
|
||||
}
|
||||
|
||||
return texCallBuilder.ToString();
|
||||
}
|
||||
|
||||
public static string Load(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
return GenerateLoadOrStore(context, operation, isStore: false);
|
||||
}
|
||||
|
||||
public static string Lod(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AstTextureOperation texOp = (AstTextureOperation)operation;
|
||||
|
||||
int coordsCount = texOp.Type.Dimensions;
|
||||
int coordsIndex = 0;
|
||||
|
||||
string samplerName = GetSamplerName(context, texOp, ref coordsIndex);
|
||||
|
||||
string coordsExpr;
|
||||
|
||||
if (coordsCount > 1)
|
||||
{
|
||||
string[] elems = new string[coordsCount];
|
||||
|
||||
for (int index = 0; index < coordsCount; index++)
|
||||
{
|
||||
elems[index] = GetSourceExpr(context, texOp.GetSource(coordsIndex + index), AggregateType.FP32);
|
||||
}
|
||||
|
||||
coordsExpr = "vec" + coordsCount + "(" + string.Join(", ", elems) + ")";
|
||||
}
|
||||
else
|
||||
{
|
||||
coordsExpr = GetSourceExpr(context, texOp.GetSource(coordsIndex), AggregateType.FP32);
|
||||
}
|
||||
|
||||
return $"textureQueryLod({samplerName}, {coordsExpr}){GetMask(texOp.Index)}";
|
||||
}
|
||||
|
||||
public static string Store(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
return GenerateLoadOrStore(context, operation, isStore: true);
|
||||
}
|
||||
|
||||
public static string TextureSample(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AstTextureOperation texOp = (AstTextureOperation)operation;
|
||||
|
||||
bool isGather = (texOp.Flags & TextureFlags.Gather) != 0;
|
||||
bool hasDerivatives = (texOp.Flags & TextureFlags.Derivatives) != 0;
|
||||
bool intCoords = (texOp.Flags & TextureFlags.IntCoords) != 0;
|
||||
bool hasLodBias = (texOp.Flags & TextureFlags.LodBias) != 0;
|
||||
bool hasLodLevel = (texOp.Flags & TextureFlags.LodLevel) != 0;
|
||||
bool hasOffset = (texOp.Flags & TextureFlags.Offset) != 0;
|
||||
bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0;
|
||||
|
||||
bool isArray = (texOp.Type & SamplerType.Array) != 0;
|
||||
bool isMultisample = (texOp.Type & SamplerType.Multisample) != 0;
|
||||
bool isShadow = (texOp.Type & SamplerType.Shadow) != 0;
|
||||
|
||||
SamplerType type = texOp.Type & SamplerType.Mask;
|
||||
|
||||
bool is2D = type == SamplerType.Texture2D;
|
||||
bool isCube = type == SamplerType.TextureCube;
|
||||
|
||||
// 2D Array and Cube shadow samplers with LOD level or bias requires an extension.
|
||||
// If the extension is not supported, just remove the LOD parameter.
|
||||
if (isArray && isShadow && (is2D || isCube) && !context.HostCapabilities.SupportsTextureShadowLod)
|
||||
{
|
||||
hasLodBias = false;
|
||||
hasLodLevel = false;
|
||||
}
|
||||
|
||||
// Cube shadow samplers with LOD level requires an extension.
|
||||
// If the extension is not supported, just remove the LOD level parameter.
|
||||
if (isShadow && isCube && !context.HostCapabilities.SupportsTextureShadowLod)
|
||||
{
|
||||
hasLodLevel = false;
|
||||
}
|
||||
|
||||
string texCall = intCoords ? "texelFetch" : "texture";
|
||||
|
||||
if (isGather)
|
||||
{
|
||||
texCall += "Gather";
|
||||
}
|
||||
else if (hasDerivatives)
|
||||
{
|
||||
texCall += "Grad";
|
||||
}
|
||||
else if (hasLodLevel && !intCoords)
|
||||
{
|
||||
texCall += "Lod";
|
||||
}
|
||||
|
||||
if (hasOffset)
|
||||
{
|
||||
texCall += "Offset";
|
||||
}
|
||||
else if (hasOffsets)
|
||||
{
|
||||
texCall += "Offsets";
|
||||
}
|
||||
|
||||
int srcIndex = 0;
|
||||
|
||||
string Src(AggregateType type)
|
||||
{
|
||||
return GetSourceExpr(context, texOp.GetSource(srcIndex++), type);
|
||||
}
|
||||
|
||||
string samplerName = GetSamplerName(context, texOp, ref srcIndex);
|
||||
|
||||
texCall += "(" + samplerName;
|
||||
|
||||
int coordsCount = texOp.Type.Dimensions;
|
||||
|
||||
int pCount = coordsCount;
|
||||
|
||||
int arrayIndexElem = -1;
|
||||
|
||||
if (isArray)
|
||||
{
|
||||
arrayIndexElem = pCount++;
|
||||
}
|
||||
|
||||
// The sampler 1D shadow overload expects a
|
||||
// dummy value on the middle of the vector, who knows why...
|
||||
bool hasDummy1DShadowElem = texOp.Type == (SamplerType.Texture1D | SamplerType.Shadow);
|
||||
|
||||
if (hasDummy1DShadowElem)
|
||||
{
|
||||
pCount++;
|
||||
}
|
||||
|
||||
if (isShadow && !isGather)
|
||||
{
|
||||
pCount++;
|
||||
}
|
||||
|
||||
// On textureGather*, the comparison value is
|
||||
// always specified as an extra argument.
|
||||
bool hasExtraCompareArg = isShadow && isGather;
|
||||
|
||||
if (pCount == 5)
|
||||
{
|
||||
pCount = 4;
|
||||
|
||||
hasExtraCompareArg = true;
|
||||
}
|
||||
|
||||
void Append(string str)
|
||||
{
|
||||
texCall += ", " + str;
|
||||
}
|
||||
|
||||
AggregateType coordType = intCoords ? AggregateType.S32 : AggregateType.FP32;
|
||||
|
||||
string AssemblePVector(int count)
|
||||
{
|
||||
if (count > 1)
|
||||
{
|
||||
string[] elems = new string[count];
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
if (arrayIndexElem == index)
|
||||
{
|
||||
elems[index] = Src(AggregateType.S32);
|
||||
|
||||
if (!intCoords)
|
||||
{
|
||||
elems[index] = "float(" + elems[index] + ")";
|
||||
}
|
||||
}
|
||||
else if (index == 1 && hasDummy1DShadowElem)
|
||||
{
|
||||
elems[index] = NumberFormatter.FormatFloat(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
elems[index] = Src(coordType);
|
||||
}
|
||||
}
|
||||
|
||||
string prefix = intCoords ? "i" : string.Empty;
|
||||
|
||||
return prefix + "vec" + count + "(" + string.Join(", ", elems) + ")";
|
||||
}
|
||||
else
|
||||
{
|
||||
return Src(coordType);
|
||||
}
|
||||
}
|
||||
|
||||
Append(AssemblePVector(pCount));
|
||||
|
||||
string AssembleDerivativesVector(int count)
|
||||
{
|
||||
if (count > 1)
|
||||
{
|
||||
string[] elems = new string[count];
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
elems[index] = Src(AggregateType.FP32);
|
||||
}
|
||||
|
||||
return "vec" + count + "(" + string.Join(", ", elems) + ")";
|
||||
}
|
||||
else
|
||||
{
|
||||
return Src(AggregateType.FP32);
|
||||
}
|
||||
}
|
||||
|
||||
if (hasExtraCompareArg)
|
||||
{
|
||||
Append(Src(AggregateType.FP32));
|
||||
}
|
||||
|
||||
if (hasDerivatives)
|
||||
{
|
||||
Append(AssembleDerivativesVector(coordsCount)); // dPdx
|
||||
Append(AssembleDerivativesVector(coordsCount)); // dPdy
|
||||
}
|
||||
|
||||
if (isMultisample)
|
||||
{
|
||||
Append(Src(AggregateType.S32));
|
||||
}
|
||||
else if (hasLodLevel)
|
||||
{
|
||||
Append(Src(coordType));
|
||||
}
|
||||
|
||||
string AssembleOffsetVector(int count)
|
||||
{
|
||||
if (count > 1)
|
||||
{
|
||||
string[] elems = new string[count];
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
elems[index] = Src(AggregateType.S32);
|
||||
}
|
||||
|
||||
return "ivec" + count + "(" + string.Join(", ", elems) + ")";
|
||||
}
|
||||
else
|
||||
{
|
||||
return Src(AggregateType.S32);
|
||||
}
|
||||
}
|
||||
|
||||
if (hasOffset)
|
||||
{
|
||||
Append(AssembleOffsetVector(coordsCount));
|
||||
}
|
||||
else if (hasOffsets)
|
||||
{
|
||||
texCall += $", ivec{coordsCount}[4](";
|
||||
|
||||
texCall += AssembleOffsetVector(coordsCount) + ", ";
|
||||
texCall += AssembleOffsetVector(coordsCount) + ", ";
|
||||
texCall += AssembleOffsetVector(coordsCount) + ", ";
|
||||
texCall += AssembleOffsetVector(coordsCount) + ")";
|
||||
}
|
||||
|
||||
if (hasLodBias)
|
||||
{
|
||||
Append(Src(AggregateType.FP32));
|
||||
}
|
||||
|
||||
// textureGather* optional extra component index,
|
||||
// not needed for shadow samplers.
|
||||
if (isGather && !isShadow)
|
||||
{
|
||||
Append(Src(AggregateType.S32));
|
||||
}
|
||||
|
||||
bool colorIsVector = isGather || !isShadow;
|
||||
|
||||
texCall += ")" + (colorIsVector ? GetMaskMultiDest(texOp.Index) : string.Empty);
|
||||
|
||||
return texCall;
|
||||
}
|
||||
|
||||
public static string TextureQuerySamples(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AstTextureOperation texOp = (AstTextureOperation)operation;
|
||||
|
||||
int srcIndex = 0;
|
||||
|
||||
string samplerName = GetSamplerName(context, texOp, ref srcIndex);
|
||||
|
||||
return $"textureSamples({samplerName})";
|
||||
}
|
||||
|
||||
public static string TextureQuerySize(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
AstTextureOperation texOp = (AstTextureOperation)operation;
|
||||
|
||||
int srcIndex = 0;
|
||||
|
||||
string samplerName = GetSamplerName(context, texOp, ref srcIndex);
|
||||
|
||||
if (texOp.Index == 3)
|
||||
{
|
||||
return $"textureQueryLevels({samplerName})";
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Properties.Textures.TryGetValue(texOp.GetTextureSetAndBinding(), out TextureDefinition definition);
|
||||
bool hasLod = !definition.Type.HasFlag(SamplerType.Multisample) && (definition.Type & SamplerType.Mask) != SamplerType.TextureBuffer;
|
||||
string texCall;
|
||||
|
||||
if (hasLod)
|
||||
{
|
||||
IAstNode lod = operation.GetSource(srcIndex);
|
||||
string lodExpr = GetSourceExpr(context, lod, GetSrcVarType(operation.Inst, srcIndex));
|
||||
|
||||
texCall = $"textureSize({samplerName}, {lodExpr}){GetMask(texOp.Index)}";
|
||||
}
|
||||
else
|
||||
{
|
||||
texCall = $"textureSize({samplerName}){GetMask(texOp.Index)}";
|
||||
}
|
||||
|
||||
return texCall;
|
||||
}
|
||||
}
|
||||
|
||||
public static string GenerateLoadOrStore(CodeGenContext context, AstOperation operation, bool isStore)
|
||||
{
|
||||
StorageKind storageKind = operation.StorageKind;
|
||||
|
||||
string varName;
|
||||
AggregateType varType;
|
||||
int srcIndex = 0;
|
||||
bool isStoreOrAtomic = operation.Inst == Instruction.Store || operation.Inst.IsAtomic();
|
||||
int inputsCount = isStoreOrAtomic ? operation.SourcesCount - 1 : operation.SourcesCount;
|
||||
|
||||
if (operation.Inst == Instruction.AtomicCompareAndSwap)
|
||||
{
|
||||
inputsCount--;
|
||||
}
|
||||
|
||||
switch (storageKind)
|
||||
{
|
||||
case StorageKind.ConstantBuffer:
|
||||
case StorageKind.StorageBuffer:
|
||||
if (operation.GetSource(srcIndex++) is not AstOperand bindingIndex || bindingIndex.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"First input of {operation.Inst} with {storageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
int binding = bindingIndex.Value;
|
||||
BufferDefinition buffer = storageKind == StorageKind.ConstantBuffer
|
||||
? context.Properties.ConstantBuffers[binding]
|
||||
: context.Properties.StorageBuffers[binding];
|
||||
|
||||
if (operation.GetSource(srcIndex++) is not AstOperand fieldIndex || fieldIndex.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"Second input of {operation.Inst} with {storageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
StructureField field = buffer.Type.Fields[fieldIndex.Value];
|
||||
varName = $"{buffer.Name}.{field.Name}";
|
||||
varType = field.Type;
|
||||
break;
|
||||
|
||||
case StorageKind.LocalMemory:
|
||||
case StorageKind.SharedMemory:
|
||||
if (operation.GetSource(srcIndex++) is not AstOperand { Type: OperandType.Constant } bindingId)
|
||||
{
|
||||
throw new InvalidOperationException($"First input of {operation.Inst} with {storageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
MemoryDefinition memory = storageKind == StorageKind.LocalMemory
|
||||
? context.Properties.LocalMemories[bindingId.Value]
|
||||
: context.Properties.SharedMemories[bindingId.Value];
|
||||
|
||||
varName = memory.Name;
|
||||
varType = memory.Type;
|
||||
break;
|
||||
|
||||
case StorageKind.Input:
|
||||
case StorageKind.InputPerPatch:
|
||||
case StorageKind.Output:
|
||||
case StorageKind.OutputPerPatch:
|
||||
if (operation.GetSource(srcIndex++) is not AstOperand varId || varId.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"First input of {operation.Inst} with {storageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
IoVariable ioVariable = (IoVariable)varId.Value;
|
||||
bool isOutput = storageKind.IsOutput();
|
||||
bool isPerPatch = storageKind.IsPerPatch();
|
||||
int location = -1;
|
||||
int component = 0;
|
||||
|
||||
if (context.Definitions.HasPerLocationInputOrOutput(ioVariable, isOutput))
|
||||
{
|
||||
if (operation.GetSource(srcIndex++) is not AstOperand vecIndex || vecIndex.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"Second input of {operation.Inst} with {storageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
location = vecIndex.Value;
|
||||
|
||||
if (operation.SourcesCount > srcIndex &&
|
||||
operation.GetSource(srcIndex) is AstOperand elemIndex &&
|
||||
elemIndex.Type == OperandType.Constant &&
|
||||
context.Definitions.HasPerLocationInputOrOutputComponent(ioVariable, location, elemIndex.Value, isOutput))
|
||||
{
|
||||
component = elemIndex.Value;
|
||||
srcIndex++;
|
||||
}
|
||||
}
|
||||
|
||||
(varName, varType) = IoMap.GetGlslVariable(
|
||||
context.Definitions,
|
||||
context.HostCapabilities,
|
||||
ioVariable,
|
||||
location,
|
||||
component,
|
||||
isOutput,
|
||||
isPerPatch);
|
||||
|
||||
if (IoMap.IsPerVertexBuiltIn(context.Definitions.Stage, ioVariable, isOutput))
|
||||
{
|
||||
// Since those exist both as input and output on geometry and tessellation shaders,
|
||||
// we need the gl_in and gl_out prefixes to disambiguate.
|
||||
|
||||
if (storageKind == StorageKind.Input)
|
||||
{
|
||||
string expr = GetSourceExpr(context, operation.GetSource(srcIndex++), AggregateType.S32);
|
||||
varName = $"gl_in[{expr}].{varName}";
|
||||
}
|
||||
else if (storageKind == StorageKind.Output)
|
||||
{
|
||||
string expr = GetSourceExpr(context, operation.GetSource(srcIndex++), AggregateType.S32);
|
||||
varName = $"gl_out[{expr}].{varName}";
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
throw new InvalidOperationException($"Invalid storage kind {storageKind}.");
|
||||
}
|
||||
|
||||
int firstSrcIndex = srcIndex;
|
||||
|
||||
for (; srcIndex < inputsCount; srcIndex++)
|
||||
{
|
||||
IAstNode src = operation.GetSource(srcIndex);
|
||||
|
||||
if ((varType & AggregateType.ElementCountMask) != 0 &&
|
||||
srcIndex == inputsCount - 1 &&
|
||||
src is AstOperand elementIndex &&
|
||||
elementIndex.Type == OperandType.Constant)
|
||||
{
|
||||
varName += "." + "xyzw"[elementIndex.Value & 3];
|
||||
}
|
||||
else if (srcIndex == firstSrcIndex && context.Definitions.Stage == ShaderStage.TessellationControl && storageKind == StorageKind.Output)
|
||||
{
|
||||
// GLSL requires that for tessellation control shader outputs,
|
||||
// that the index expression must be *exactly* "gl_InvocationID",
|
||||
// otherwise the compilation fails.
|
||||
// TODO: Get rid of this and use expression propagation to make sure we generate the correct code from IR.
|
||||
varName += "[gl_InvocationID]";
|
||||
}
|
||||
else
|
||||
{
|
||||
varName += $"[{GetSourceExpr(context, src, AggregateType.S32)}]";
|
||||
}
|
||||
}
|
||||
|
||||
if (isStore)
|
||||
{
|
||||
varType &= AggregateType.ElementTypeMask;
|
||||
varName = $"{varName} = {GetSourceExpr(context, operation.GetSource(srcIndex), varType)}";
|
||||
}
|
||||
|
||||
return varName;
|
||||
}
|
||||
|
||||
private static string GetSamplerName(CodeGenContext context, AstTextureOperation texOp, ref int srcIndex)
|
||||
{
|
||||
TextureDefinition textureDefinition = context.Properties.Textures[texOp.GetTextureSetAndBinding()];
|
||||
string name = textureDefinition.Name;
|
||||
|
||||
if (textureDefinition.ArrayLength != 1)
|
||||
{
|
||||
name = $"{name}[{GetSourceExpr(context, texOp.GetSource(srcIndex++), AggregateType.S32)}]";
|
||||
}
|
||||
|
||||
if (texOp.IsSeparate)
|
||||
{
|
||||
TextureDefinition samplerDefinition = context.Properties.Textures[texOp.GetSamplerSetAndBinding()];
|
||||
string samplerName = samplerDefinition.Name;
|
||||
|
||||
if (samplerDefinition.ArrayLength != 1)
|
||||
{
|
||||
samplerName = $"{samplerName}[{GetSourceExpr(context, texOp.GetSource(srcIndex++), AggregateType.S32)}]";
|
||||
}
|
||||
|
||||
name = $"{texOp.Type.GlslSamplerTypeName}({name}, {samplerName})";
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
private static string GetImageName(CodeGenContext context, AstTextureOperation texOp, ref int srcIndex)
|
||||
{
|
||||
TextureDefinition definition = context.Properties.Images[texOp.GetTextureSetAndBinding()];
|
||||
string name = definition.Name;
|
||||
|
||||
if (definition.ArrayLength != 1)
|
||||
{
|
||||
name = $"{name}[{GetSourceExpr(context, texOp.GetSource(srcIndex++), AggregateType.S32)}]";
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
private static string GetMask(int index)
|
||||
{
|
||||
return $".{"rgba".AsSpan(index, 1)}";
|
||||
}
|
||||
|
||||
private static string GetMaskMultiDest(int mask)
|
||||
{
|
||||
StringBuilder swizzleBuilder = new();
|
||||
swizzleBuilder.Append('.');
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
if ((mask & (1 << i)) != 0)
|
||||
{
|
||||
swizzleBuilder.Append("xyzw"[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return swizzleBuilder.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
56
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenPacking.cs
vendored
Normal file
56
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenPacking.cs
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using System;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenPacking
|
||||
{
|
||||
public static string PackDouble2x32(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
IAstNode src0 = operation.GetSource(0);
|
||||
IAstNode src1 = operation.GetSource(1);
|
||||
|
||||
string src0Expr = GetSourceExpr(context, src0, GetSrcVarType(operation.Inst, 0));
|
||||
string src1Expr = GetSourceExpr(context, src1, GetSrcVarType(operation.Inst, 1));
|
||||
|
||||
return $"packDouble2x32(uvec2({src0Expr}, {src1Expr}))";
|
||||
}
|
||||
|
||||
public static string PackHalf2x16(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
IAstNode src0 = operation.GetSource(0);
|
||||
IAstNode src1 = operation.GetSource(1);
|
||||
|
||||
string src0Expr = GetSourceExpr(context, src0, GetSrcVarType(operation.Inst, 0));
|
||||
string src1Expr = GetSourceExpr(context, src1, GetSrcVarType(operation.Inst, 1));
|
||||
|
||||
return $"packHalf2x16(vec2({src0Expr}, {src1Expr}))";
|
||||
}
|
||||
|
||||
public static string UnpackDouble2x32(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
IAstNode src = operation.GetSource(0);
|
||||
|
||||
string srcExpr = GetSourceExpr(context, src, GetSrcVarType(operation.Inst, 0));
|
||||
|
||||
return $"unpackDouble2x32({srcExpr}){GetMask(operation.Index)}";
|
||||
}
|
||||
|
||||
public static string UnpackHalf2x16(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
IAstNode src = operation.GetSource(0);
|
||||
|
||||
string srcExpr = GetSourceExpr(context, src, GetSrcVarType(operation.Inst, 0));
|
||||
|
||||
return $"unpackHalf2x16({srcExpr}){GetMask(operation.Index)}";
|
||||
}
|
||||
|
||||
private static string GetMask(int index)
|
||||
{
|
||||
return $".{"xy".AsSpan(index, 1)}";
|
||||
}
|
||||
}
|
||||
}
|
||||
25
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenShuffle.cs
vendored
Normal file
25
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenShuffle.cs
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenShuffle
|
||||
{
|
||||
public static string Shuffle(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
string value = GetSourceExpr(context, operation.GetSource(0), AggregateType.FP32);
|
||||
string index = GetSourceExpr(context, operation.GetSource(1), AggregateType.U32);
|
||||
|
||||
if (context.HostCapabilities.SupportsShaderBallot)
|
||||
{
|
||||
return $"readInvocationARB({value}, {index})";
|
||||
}
|
||||
else
|
||||
{
|
||||
return $"subgroupShuffle({value}, {index})";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
32
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenVector.cs
vendored
Normal file
32
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstGenVector.cs
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions.InstGenHelper;
|
||||
using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class InstGenVector
|
||||
{
|
||||
public static string VectorExtract(CodeGenContext context, AstOperation operation)
|
||||
{
|
||||
IAstNode vector = operation.GetSource(0);
|
||||
IAstNode index = operation.GetSource(1);
|
||||
|
||||
string vectorExpr = GetSourceExpr(context, vector, OperandManager.GetNodeDestType(context, vector));
|
||||
|
||||
if (index is AstOperand indexOperand && indexOperand.Type == OperandType.Constant)
|
||||
{
|
||||
char elem = "xyzw"[indexOperand.Value];
|
||||
|
||||
return $"{vectorExpr}.{elem}";
|
||||
}
|
||||
else
|
||||
{
|
||||
string indexExpr = GetSourceExpr(context, index, GetSrcVarType(operation.Inst, 1));
|
||||
|
||||
return $"{vectorExpr}[{indexExpr}]";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
18
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstInfo.cs
vendored
Normal file
18
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstInfo.cs
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
readonly struct InstInfo
|
||||
{
|
||||
public InstType Type { get; }
|
||||
|
||||
public string OpName { get; }
|
||||
|
||||
public int Precedence { get; }
|
||||
|
||||
public InstInfo(InstType type, string opName, int precedence)
|
||||
{
|
||||
Type = type;
|
||||
OpName = opName;
|
||||
Precedence = precedence;
|
||||
}
|
||||
}
|
||||
}
|
||||
33
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstType.cs
vendored
Normal file
33
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/InstType.cs
vendored
Normal file
@@ -0,0 +1,33 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
[Flags]
|
||||
enum InstType
|
||||
{
|
||||
OpNullary = Op | 0,
|
||||
OpUnary = Op | 1,
|
||||
OpBinary = Op | 2,
|
||||
OpBinaryCom = Op | 2 | Commutative,
|
||||
OpTernary = Op | 3,
|
||||
|
||||
CallNullary = Call | 0,
|
||||
CallUnary = Call | 1,
|
||||
CallBinary = Call | 2,
|
||||
CallTernary = Call | 3,
|
||||
CallQuaternary = Call | 4,
|
||||
|
||||
// The atomic instructions have one extra operand,
|
||||
// for the storage slot and offset pair.
|
||||
AtomicBinary = Call | Atomic | 3,
|
||||
AtomicTernary = Call | Atomic | 4,
|
||||
|
||||
Commutative = 1 << 8,
|
||||
Op = 1 << 9,
|
||||
Call = 1 << 10,
|
||||
Atomic = 1 << 11,
|
||||
Special = 1 << 12,
|
||||
|
||||
ArityMask = 0xff,
|
||||
}
|
||||
}
|
||||
144
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/IoMap.cs
vendored
Normal file
144
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/Instructions/IoMap.cs
vendored
Normal file
@@ -0,0 +1,144 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System.Globalization;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions
|
||||
{
|
||||
static class IoMap
|
||||
{
|
||||
public static (string, AggregateType) GetGlslVariable(
|
||||
ShaderDefinitions definitions,
|
||||
HostCapabilities hostCapabilities,
|
||||
IoVariable ioVariable,
|
||||
int location,
|
||||
int component,
|
||||
bool isOutput,
|
||||
bool isPerPatch)
|
||||
{
|
||||
return ioVariable switch
|
||||
{
|
||||
IoVariable.BackColorDiffuse => ("gl_BackColor", AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
|
||||
IoVariable.BackColorSpecular => ("gl_BackSecondaryColor", AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
|
||||
IoVariable.BaseInstance => ("gl_BaseInstanceARB", AggregateType.S32),
|
||||
IoVariable.BaseVertex => ("gl_BaseVertexARB", AggregateType.S32),
|
||||
IoVariable.ClipDistance => ("gl_ClipDistance", AggregateType.Array | AggregateType.FP32),
|
||||
IoVariable.CtaId => ("gl_WorkGroupID", AggregateType.Vector3 | AggregateType.U32),
|
||||
IoVariable.DrawIndex => ("gl_DrawIDARB", AggregateType.S32),
|
||||
IoVariable.FogCoord => ("gl_FogFragCoord", AggregateType.FP32), // Deprecated.
|
||||
IoVariable.FragmentCoord => ("gl_FragCoord", AggregateType.Vector4 | AggregateType.FP32),
|
||||
IoVariable.FragmentOutputColor => GetFragmentOutputColorVariableName(definitions, location),
|
||||
IoVariable.FragmentOutputDepth => ("gl_FragDepth", AggregateType.FP32),
|
||||
IoVariable.FrontColorDiffuse => ("gl_FrontColor", AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
|
||||
IoVariable.FrontColorSpecular => ("gl_FrontSecondaryColor", AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
|
||||
IoVariable.FrontFacing => ("gl_FrontFacing", AggregateType.Bool),
|
||||
IoVariable.GlobalId => ("gl_GlobalInvocationID", AggregateType.Vector3 | AggregateType.U32),
|
||||
IoVariable.InstanceId => ("gl_InstanceID", AggregateType.S32),
|
||||
IoVariable.InstanceIndex => ("gl_InstanceIndex", AggregateType.S32),
|
||||
IoVariable.InvocationId => ("gl_InvocationID", AggregateType.S32),
|
||||
IoVariable.Layer => ("gl_Layer", AggregateType.S32),
|
||||
IoVariable.PatchVertices => ("gl_PatchVerticesIn", AggregateType.S32),
|
||||
IoVariable.PointCoord => ("gl_PointCoord", AggregateType.Vector2 | AggregateType.FP32),
|
||||
IoVariable.PointSize => ("gl_PointSize", AggregateType.FP32),
|
||||
IoVariable.Position => ("gl_Position", AggregateType.Vector4 | AggregateType.FP32),
|
||||
IoVariable.PrimitiveId => GetPrimitiveIdVariableName(definitions.Stage, isOutput),
|
||||
IoVariable.SubgroupEqMask => GetSubgroupMaskVariableName(hostCapabilities.SupportsShaderBallot, "Eq"),
|
||||
IoVariable.SubgroupGeMask => GetSubgroupMaskVariableName(hostCapabilities.SupportsShaderBallot, "Ge"),
|
||||
IoVariable.SubgroupGtMask => GetSubgroupMaskVariableName(hostCapabilities.SupportsShaderBallot, "Gt"),
|
||||
IoVariable.SubgroupLaneId => GetSubgroupInvocationIdVariableName(hostCapabilities.SupportsShaderBallot),
|
||||
IoVariable.SubgroupLeMask => GetSubgroupMaskVariableName(hostCapabilities.SupportsShaderBallot, "Le"),
|
||||
IoVariable.SubgroupLtMask => GetSubgroupMaskVariableName(hostCapabilities.SupportsShaderBallot, "Lt"),
|
||||
IoVariable.TessellationCoord => ("gl_TessCoord", AggregateType.Vector3 | AggregateType.FP32),
|
||||
IoVariable.TessellationLevelInner => ("gl_TessLevelInner", AggregateType.Array | AggregateType.FP32),
|
||||
IoVariable.TessellationLevelOuter => ("gl_TessLevelOuter", AggregateType.Array | AggregateType.FP32),
|
||||
IoVariable.TextureCoord => ("gl_TexCoord", AggregateType.Array | AggregateType.Vector4 | AggregateType.FP32), // Deprecated.
|
||||
IoVariable.ThreadId => ("gl_LocalInvocationID", AggregateType.Vector3 | AggregateType.U32),
|
||||
IoVariable.ThreadKill => ("gl_HelperInvocation", AggregateType.Bool),
|
||||
IoVariable.UserDefined => GetUserDefinedVariableName(definitions, location, component, isOutput, isPerPatch),
|
||||
IoVariable.VertexId => ("gl_VertexID", AggregateType.S32),
|
||||
IoVariable.VertexIndex => ("gl_VertexIndex", AggregateType.S32),
|
||||
IoVariable.ViewportIndex => ("gl_ViewportIndex", AggregateType.S32),
|
||||
IoVariable.ViewportMask => ("gl_ViewportMask", AggregateType.Array | AggregateType.S32),
|
||||
_ => (null, AggregateType.Invalid),
|
||||
};
|
||||
}
|
||||
|
||||
public static bool IsPerVertexBuiltIn(ShaderStage stage, IoVariable ioVariable, bool isOutput)
|
||||
{
|
||||
switch (ioVariable)
|
||||
{
|
||||
case IoVariable.Layer:
|
||||
case IoVariable.ViewportIndex:
|
||||
case IoVariable.PointSize:
|
||||
case IoVariable.Position:
|
||||
case IoVariable.ClipDistance:
|
||||
case IoVariable.PointCoord:
|
||||
case IoVariable.ViewportMask:
|
||||
if (isOutput)
|
||||
{
|
||||
return stage == ShaderStage.TessellationControl;
|
||||
}
|
||||
else
|
||||
{
|
||||
return stage is ShaderStage.TessellationControl or
|
||||
ShaderStage.TessellationEvaluation or
|
||||
ShaderStage.Geometry;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private static (string, AggregateType) GetFragmentOutputColorVariableName(ShaderDefinitions definitions, int location)
|
||||
{
|
||||
if (location < 0)
|
||||
{
|
||||
return (DefaultNames.OAttributePrefix, definitions.GetFragmentOutputColorType(0));
|
||||
}
|
||||
|
||||
string name = DefaultNames.OAttributePrefix + location.ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
return (name, definitions.GetFragmentOutputColorType(location));
|
||||
}
|
||||
|
||||
private static (string, AggregateType) GetPrimitiveIdVariableName(ShaderStage stage, bool isOutput)
|
||||
{
|
||||
// The geometry stage has an additional gl_PrimitiveIDIn variable.
|
||||
return (isOutput || stage != ShaderStage.Geometry ? "gl_PrimitiveID" : "gl_PrimitiveIDIn", AggregateType.S32);
|
||||
}
|
||||
|
||||
private static (string, AggregateType) GetSubgroupMaskVariableName(bool supportsShaderBallot, string cc)
|
||||
{
|
||||
return supportsShaderBallot
|
||||
? ($"unpackUint2x32(gl_SubGroup{cc}MaskARB)", AggregateType.Vector2 | AggregateType.U32)
|
||||
: ($"gl_Subgroup{cc}Mask", AggregateType.Vector4 | AggregateType.U32);
|
||||
}
|
||||
|
||||
private static (string, AggregateType) GetSubgroupInvocationIdVariableName(bool supportsShaderBallot)
|
||||
{
|
||||
return supportsShaderBallot
|
||||
? ("gl_SubGroupInvocationARB", AggregateType.U32)
|
||||
: ("gl_SubgroupInvocationID", AggregateType.U32);
|
||||
}
|
||||
|
||||
private static (string, AggregateType) GetUserDefinedVariableName(ShaderDefinitions definitions, int location, int component, bool isOutput, bool isPerPatch)
|
||||
{
|
||||
string name = isPerPatch
|
||||
? DefaultNames.PerPatchAttributePrefix
|
||||
: (isOutput ? DefaultNames.OAttributePrefix : DefaultNames.IAttributePrefix);
|
||||
|
||||
if (location < 0)
|
||||
{
|
||||
return (name, definitions.GetUserDefinedType(0, isOutput));
|
||||
}
|
||||
|
||||
name += location.ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
if (definitions.HasPerLocationInputOrOutputComponent(IoVariable.UserDefined, location, component, isOutput))
|
||||
{
|
||||
name += "_" + "xyzw"[component & 3];
|
||||
}
|
||||
|
||||
return (name, definitions.GetUserDefinedType(location, isOutput));
|
||||
}
|
||||
}
|
||||
}
|
||||
104
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/NumberFormatter.cs
vendored
Normal file
104
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/NumberFormatter.cs
vendored
Normal file
@@ -0,0 +1,104 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Globalization;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class NumberFormatter
|
||||
{
|
||||
private const int MaxDecimal = 256;
|
||||
|
||||
public static bool TryFormat(int value, AggregateType dstType, out string formatted)
|
||||
{
|
||||
if (dstType == AggregateType.FP32)
|
||||
{
|
||||
return TryFormatFloat(BitConverter.Int32BitsToSingle(value), out formatted);
|
||||
}
|
||||
else if (dstType == AggregateType.S32)
|
||||
{
|
||||
formatted = FormatInt(value);
|
||||
}
|
||||
else if (dstType == AggregateType.U32)
|
||||
{
|
||||
formatted = FormatUint((uint)value);
|
||||
}
|
||||
else if (dstType == AggregateType.Bool)
|
||||
{
|
||||
formatted = value != 0 ? "true" : "false";
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new ArgumentException($"Invalid variable type \"{dstType}\".");
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static string FormatFloat(float value)
|
||||
{
|
||||
if (!TryFormatFloat(value, out string formatted))
|
||||
{
|
||||
throw new ArgumentException("Failed to convert float value to string.");
|
||||
}
|
||||
|
||||
return formatted;
|
||||
}
|
||||
|
||||
public static bool TryFormatFloat(float value, out string formatted)
|
||||
{
|
||||
if (float.IsNaN(value) || float.IsInfinity(value))
|
||||
{
|
||||
formatted = null;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
formatted = value.ToString("G9", CultureInfo.InvariantCulture);
|
||||
|
||||
if (!(formatted.Contains('.') ||
|
||||
formatted.Contains('e') ||
|
||||
formatted.Contains('E')))
|
||||
{
|
||||
formatted += ".0";
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static string FormatInt(int value, AggregateType dstType)
|
||||
{
|
||||
if (dstType == AggregateType.S32)
|
||||
{
|
||||
return FormatInt(value);
|
||||
}
|
||||
else if (dstType == AggregateType.U32)
|
||||
{
|
||||
return FormatUint((uint)value);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new ArgumentException($"Invalid variable type \"{dstType}\".");
|
||||
}
|
||||
}
|
||||
|
||||
public static string FormatInt(int value)
|
||||
{
|
||||
if (value is <= MaxDecimal and >= (-MaxDecimal))
|
||||
{
|
||||
return value.ToString(CultureInfo.InvariantCulture);
|
||||
}
|
||||
|
||||
return "0x" + value.ToString("X", CultureInfo.InvariantCulture);
|
||||
}
|
||||
|
||||
public static string FormatUint(uint value)
|
||||
{
|
||||
if (value is <= MaxDecimal and >= 0)
|
||||
{
|
||||
return value.ToString(CultureInfo.InvariantCulture) + "u";
|
||||
}
|
||||
|
||||
return "0x" + value.ToString("X", CultureInfo.InvariantCulture) + "u";
|
||||
}
|
||||
}
|
||||
}
|
||||
178
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/OperandManager.cs
vendored
Normal file
178
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/OperandManager.cs
vendored
Normal file
@@ -0,0 +1,178 @@
|
||||
using Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
class OperandManager
|
||||
{
|
||||
private readonly Dictionary<AstOperand, string> _locals;
|
||||
|
||||
public OperandManager()
|
||||
{
|
||||
_locals = new Dictionary<AstOperand, string>();
|
||||
}
|
||||
|
||||
public string DeclareLocal(AstOperand operand)
|
||||
{
|
||||
string name = $"{DefaultNames.LocalNamePrefix}_{_locals.Count}";
|
||||
|
||||
_locals.Add(operand, name);
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
public string GetExpression(CodeGenContext context, AstOperand operand)
|
||||
{
|
||||
return operand.Type switch
|
||||
{
|
||||
OperandType.Argument => GetArgumentName(operand.Value),
|
||||
OperandType.Constant => NumberFormatter.FormatInt(operand.Value),
|
||||
OperandType.LocalVariable => _locals[operand],
|
||||
OperandType.Undefined => DefaultNames.UndefinedName,
|
||||
_ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
public static string GetArgumentName(int argIndex)
|
||||
{
|
||||
return $"{DefaultNames.ArgumentNamePrefix}{argIndex}";
|
||||
}
|
||||
|
||||
public static AggregateType GetNodeDestType(CodeGenContext context, IAstNode node)
|
||||
{
|
||||
// TODO: Get rid of that function entirely and return the type from the operation generation
|
||||
// functions directly, like SPIR-V does.
|
||||
|
||||
if (node is AstOperation operation)
|
||||
{
|
||||
if (operation.Inst == Instruction.Load || operation.Inst.IsAtomic())
|
||||
{
|
||||
switch (operation.StorageKind)
|
||||
{
|
||||
case StorageKind.ConstantBuffer:
|
||||
case StorageKind.StorageBuffer:
|
||||
if (operation.GetSource(0) is not AstOperand bindingIndex || bindingIndex.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
if (operation.GetSource(1) is not AstOperand fieldIndex || fieldIndex.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"Second input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
BufferDefinition buffer = operation.StorageKind == StorageKind.ConstantBuffer
|
||||
? context.Properties.ConstantBuffers[bindingIndex.Value]
|
||||
: context.Properties.StorageBuffers[bindingIndex.Value];
|
||||
StructureField field = buffer.Type.Fields[fieldIndex.Value];
|
||||
|
||||
return field.Type & AggregateType.ElementTypeMask;
|
||||
|
||||
case StorageKind.LocalMemory:
|
||||
case StorageKind.SharedMemory:
|
||||
if (operation.GetSource(0) is not AstOperand { Type: OperandType.Constant } bindingId)
|
||||
{
|
||||
throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
MemoryDefinition memory = operation.StorageKind == StorageKind.LocalMemory
|
||||
? context.Properties.LocalMemories[bindingId.Value]
|
||||
: context.Properties.SharedMemories[bindingId.Value];
|
||||
|
||||
return memory.Type & AggregateType.ElementTypeMask;
|
||||
|
||||
case StorageKind.Input:
|
||||
case StorageKind.InputPerPatch:
|
||||
case StorageKind.Output:
|
||||
case StorageKind.OutputPerPatch:
|
||||
if (operation.GetSource(0) is not AstOperand varId || varId.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"First input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
IoVariable ioVariable = (IoVariable)varId.Value;
|
||||
bool isOutput = operation.StorageKind is StorageKind.Output or StorageKind.OutputPerPatch;
|
||||
bool isPerPatch = operation.StorageKind is StorageKind.InputPerPatch or StorageKind.OutputPerPatch;
|
||||
int location = 0;
|
||||
int component = 0;
|
||||
|
||||
if (context.Definitions.HasPerLocationInputOrOutput(ioVariable, isOutput))
|
||||
{
|
||||
if (operation.GetSource(1) is not AstOperand vecIndex || vecIndex.Type != OperandType.Constant)
|
||||
{
|
||||
throw new InvalidOperationException($"Second input of {operation.Inst} with {operation.StorageKind} storage must be a constant operand.");
|
||||
}
|
||||
|
||||
location = vecIndex.Value;
|
||||
|
||||
if (operation.SourcesCount > 2 &&
|
||||
operation.GetSource(2) is AstOperand elemIndex &&
|
||||
elemIndex.Type == OperandType.Constant &&
|
||||
context.Definitions.HasPerLocationInputOrOutputComponent(ioVariable, location, elemIndex.Value, isOutput))
|
||||
{
|
||||
component = elemIndex.Value;
|
||||
}
|
||||
}
|
||||
|
||||
(_, AggregateType varType) = IoMap.GetGlslVariable(
|
||||
context.Definitions,
|
||||
context.HostCapabilities,
|
||||
ioVariable,
|
||||
location,
|
||||
component,
|
||||
isOutput,
|
||||
isPerPatch);
|
||||
|
||||
return varType & AggregateType.ElementTypeMask;
|
||||
}
|
||||
}
|
||||
else if (operation.Inst == Instruction.Call)
|
||||
{
|
||||
AstOperand funcId = (AstOperand)operation.GetSource(0);
|
||||
|
||||
Debug.Assert(funcId.Type == OperandType.Constant);
|
||||
|
||||
return context.GetFunction(funcId.Value).ReturnType;
|
||||
}
|
||||
else if (operation.Inst == Instruction.VectorExtract)
|
||||
{
|
||||
return GetNodeDestType(context, operation.GetSource(0)) & ~AggregateType.ElementCountMask;
|
||||
}
|
||||
else if (operation is AstTextureOperation texOp)
|
||||
{
|
||||
if (texOp.Inst.IsImage())
|
||||
{
|
||||
return texOp.GetVectorType(texOp.Format.GetComponentType());
|
||||
}
|
||||
else if (texOp.Inst == Instruction.TextureSample)
|
||||
{
|
||||
return texOp.GetVectorType(GetDestVarType(operation.Inst));
|
||||
}
|
||||
}
|
||||
|
||||
return GetDestVarType(operation.Inst);
|
||||
}
|
||||
else if (node is AstOperand operand)
|
||||
{
|
||||
if (operand.Type == OperandType.Argument)
|
||||
{
|
||||
int argIndex = operand.Value;
|
||||
|
||||
return context.CurrentFunction.GetArgumentType(argIndex);
|
||||
}
|
||||
|
||||
return OperandInfo.GetVarType(operand);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new ArgumentException($"Invalid node type \"{node?.GetType().Name ?? "null"}\".");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
93
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/TypeConversion.cs
vendored
Normal file
93
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Glsl/TypeConversion.cs
vendored
Normal file
@@ -0,0 +1,93 @@
|
||||
using Ryujinx.Graphics.Shader.CodeGen.Glsl.Instructions;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class TypeConversion
|
||||
{
|
||||
public static string ReinterpretCast(
|
||||
CodeGenContext context,
|
||||
IAstNode node,
|
||||
AggregateType srcType,
|
||||
AggregateType dstType)
|
||||
{
|
||||
if (node is AstOperand operand && operand.Type == OperandType.Constant)
|
||||
{
|
||||
if (NumberFormatter.TryFormat(operand.Value, dstType, out string formatted))
|
||||
{
|
||||
return formatted;
|
||||
}
|
||||
}
|
||||
|
||||
string expr = InstGen.GetExpression(context, node);
|
||||
|
||||
return ReinterpretCast(expr, node, srcType, dstType);
|
||||
}
|
||||
|
||||
private static string ReinterpretCast(string expr, IAstNode node, AggregateType srcType, AggregateType dstType)
|
||||
{
|
||||
if (srcType == dstType)
|
||||
{
|
||||
return expr;
|
||||
}
|
||||
|
||||
if (srcType == AggregateType.FP32)
|
||||
{
|
||||
switch (dstType)
|
||||
{
|
||||
case AggregateType.Bool:
|
||||
return $"(floatBitsToInt({expr}) != 0)";
|
||||
case AggregateType.S32:
|
||||
return $"floatBitsToInt({expr})";
|
||||
case AggregateType.U32:
|
||||
return $"floatBitsToUint({expr})";
|
||||
}
|
||||
}
|
||||
else if (dstType == AggregateType.FP32)
|
||||
{
|
||||
switch (srcType)
|
||||
{
|
||||
case AggregateType.Bool:
|
||||
return $"intBitsToFloat({ReinterpretBoolToInt(expr, node, AggregateType.S32)})";
|
||||
case AggregateType.S32:
|
||||
return $"intBitsToFloat({expr})";
|
||||
case AggregateType.U32:
|
||||
return $"uintBitsToFloat({expr})";
|
||||
}
|
||||
}
|
||||
else if (srcType == AggregateType.Bool)
|
||||
{
|
||||
return ReinterpretBoolToInt(expr, node, dstType);
|
||||
}
|
||||
else if (dstType == AggregateType.Bool)
|
||||
{
|
||||
expr = InstGenHelper.Enclose(expr, node, Instruction.CompareNotEqual, isLhs: true);
|
||||
|
||||
return $"({expr} != 0)";
|
||||
}
|
||||
else if (dstType == AggregateType.S32)
|
||||
{
|
||||
return $"int({expr})";
|
||||
}
|
||||
else if (dstType == AggregateType.U32)
|
||||
{
|
||||
return $"uint({expr})";
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Invalid reinterpret cast from \"{srcType}\" to \"{dstType}\".");
|
||||
}
|
||||
|
||||
private static string ReinterpretBoolToInt(string expr, IAstNode node, AggregateType dstType)
|
||||
{
|
||||
string trueExpr = NumberFormatter.FormatInt(IrConsts.True, dstType);
|
||||
string falseExpr = NumberFormatter.FormatInt(IrConsts.False, dstType);
|
||||
|
||||
expr = InstGenHelper.Enclose(expr, node, Instruction.ConditionalSelect, isLhs: false);
|
||||
|
||||
return $"({expr} ? {trueExpr} : {falseExpr})";
|
||||
}
|
||||
}
|
||||
}
|
||||
375
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs
vendored
Normal file
375
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs
vendored
Normal file
@@ -0,0 +1,375 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using Spv.Generator;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Instruction = Spv.Generator.Instruction;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
using IrOperandType = IntermediateRepresentation.OperandType;
|
||||
|
||||
partial class CodeGenContext : Module
|
||||
{
|
||||
private const uint SpirvVersionMajor = 1;
|
||||
private const uint SpirvVersionMinor = 3;
|
||||
private const uint SpirvVersionRevision = 0;
|
||||
private const uint SpirvVersionPacked = (SpirvVersionMajor << 16) | (SpirvVersionMinor << 8) | SpirvVersionRevision;
|
||||
|
||||
public StructuredProgramInfo Info { get; }
|
||||
|
||||
public AttributeUsage AttributeUsage { get; }
|
||||
public ShaderDefinitions Definitions { get; }
|
||||
public ShaderProperties Properties { get; }
|
||||
public HostCapabilities HostCapabilities { get; }
|
||||
public ILogger Logger { get; }
|
||||
public TargetApi TargetApi { get; }
|
||||
|
||||
public Dictionary<int, Instruction> ConstantBuffers { get; } = new();
|
||||
public Dictionary<int, Instruction> StorageBuffers { get; } = new();
|
||||
|
||||
public Dictionary<int, Instruction> LocalMemories { get; } = new();
|
||||
public Dictionary<int, Instruction> SharedMemories { get; } = new();
|
||||
|
||||
public Dictionary<SetBindingPair, SamplerType> SamplersTypes { get; } = new();
|
||||
public Dictionary<SetBindingPair, SamplerDeclaration> Samplers { get; } = new();
|
||||
public Dictionary<SetBindingPair, ImageDeclaration> Images { get; } = new();
|
||||
|
||||
public Dictionary<IoDefinition, Instruction> Inputs { get; } = new();
|
||||
public Dictionary<IoDefinition, Instruction> Outputs { get; } = new();
|
||||
public Dictionary<IoDefinition, Instruction> InputsPerPatch { get; } = new();
|
||||
public Dictionary<IoDefinition, Instruction> OutputsPerPatch { get; } = new();
|
||||
|
||||
public StructuredFunction CurrentFunction { get; set; }
|
||||
private readonly Dictionary<AstOperand, Instruction> _locals = new();
|
||||
private readonly Dictionary<int, Instruction> _funcArgs = new();
|
||||
private readonly Dictionary<int, (StructuredFunction, Instruction)> _functions = new();
|
||||
|
||||
private class BlockState
|
||||
{
|
||||
private int _entryCount;
|
||||
private readonly List<Instruction> _labels = [];
|
||||
|
||||
public Instruction GetNextLabel(CodeGenContext context)
|
||||
{
|
||||
return GetLabel(context, _entryCount);
|
||||
}
|
||||
|
||||
public Instruction GetNextLabelAutoIncrement(CodeGenContext context)
|
||||
{
|
||||
return GetLabel(context, _entryCount++);
|
||||
}
|
||||
|
||||
public Instruction GetLabel(CodeGenContext context, int index)
|
||||
{
|
||||
while (index >= _labels.Count)
|
||||
{
|
||||
_labels.Add(context.Label());
|
||||
}
|
||||
|
||||
return _labels[index];
|
||||
}
|
||||
}
|
||||
|
||||
private readonly Dictionary<AstBlock, BlockState> _labels = new();
|
||||
|
||||
public Dictionary<AstBlock, (Instruction, Instruction)> LoopTargets { get; set; }
|
||||
|
||||
public AstBlock CurrentBlock { get; private set; }
|
||||
|
||||
public SpirvDelegates Delegates { get; }
|
||||
|
||||
public bool IsMainFunction { get; private set; }
|
||||
public bool MayHaveReturned { get; set; }
|
||||
public bool WasNonUniformAccessDeclared { get; set; }
|
||||
|
||||
public CodeGenContext(
|
||||
StructuredProgramInfo info,
|
||||
CodeGenParameters parameters,
|
||||
GeneratorPool<Instruction> instPool,
|
||||
GeneratorPool<LiteralInteger> integerPool) : base(SpirvVersionPacked, instPool, integerPool)
|
||||
{
|
||||
WasNonUniformAccessDeclared = false;
|
||||
|
||||
Info = info;
|
||||
AttributeUsage = parameters.AttributeUsage;
|
||||
Definitions = parameters.Definitions;
|
||||
Properties = parameters.Properties;
|
||||
HostCapabilities = parameters.HostCapabilities;
|
||||
Logger = parameters.Logger;
|
||||
TargetApi = parameters.TargetApi;
|
||||
|
||||
Delegates = new SpirvDelegates(this);
|
||||
}
|
||||
|
||||
public void StartFunction(bool isMainFunction)
|
||||
{
|
||||
IsMainFunction = isMainFunction;
|
||||
MayHaveReturned = false;
|
||||
_locals.Clear();
|
||||
_funcArgs.Clear();
|
||||
}
|
||||
|
||||
public void EnterBlock(AstBlock block)
|
||||
{
|
||||
CurrentBlock = block;
|
||||
AddLabel(GetBlockStateLazy(block).GetNextLabelAutoIncrement(this));
|
||||
}
|
||||
|
||||
public Instruction GetFirstLabel(AstBlock block)
|
||||
{
|
||||
return GetBlockStateLazy(block).GetLabel(this, 0);
|
||||
}
|
||||
|
||||
public Instruction GetNextLabel(AstBlock block)
|
||||
{
|
||||
return GetBlockStateLazy(block).GetNextLabel(this);
|
||||
}
|
||||
|
||||
private BlockState GetBlockStateLazy(AstBlock block)
|
||||
{
|
||||
if (!_labels.TryGetValue(block, out BlockState blockState))
|
||||
{
|
||||
blockState = new BlockState();
|
||||
|
||||
_labels.Add(block, blockState);
|
||||
}
|
||||
|
||||
return blockState;
|
||||
}
|
||||
|
||||
public Instruction NewBlock()
|
||||
{
|
||||
Instruction label = Label();
|
||||
Branch(label);
|
||||
AddLabel(label);
|
||||
return label;
|
||||
}
|
||||
|
||||
public Instruction[] GetMainInterface()
|
||||
{
|
||||
List<Instruction> mainInterface = [];
|
||||
|
||||
mainInterface.AddRange(Inputs.Values);
|
||||
mainInterface.AddRange(Outputs.Values);
|
||||
mainInterface.AddRange(InputsPerPatch.Values);
|
||||
mainInterface.AddRange(OutputsPerPatch.Values);
|
||||
|
||||
return mainInterface.ToArray();
|
||||
}
|
||||
|
||||
public void DeclareLocal(AstOperand local, Instruction spvLocal)
|
||||
{
|
||||
_locals.Add(local, spvLocal);
|
||||
}
|
||||
|
||||
public void DeclareArgument(int argIndex, Instruction spvLocal)
|
||||
{
|
||||
_funcArgs.Add(argIndex, spvLocal);
|
||||
}
|
||||
|
||||
public void DeclareFunction(int funcIndex, StructuredFunction function, Instruction spvFunc)
|
||||
{
|
||||
_functions.Add(funcIndex, (function, spvFunc));
|
||||
}
|
||||
|
||||
public Instruction GetFP32(IAstNode node)
|
||||
{
|
||||
return Get(AggregateType.FP32, node);
|
||||
}
|
||||
|
||||
public Instruction GetFP64(IAstNode node)
|
||||
{
|
||||
return Get(AggregateType.FP64, node);
|
||||
}
|
||||
|
||||
public Instruction GetS32(IAstNode node)
|
||||
{
|
||||
return Get(AggregateType.S32, node);
|
||||
}
|
||||
|
||||
public Instruction GetU32(IAstNode node)
|
||||
{
|
||||
return Get(AggregateType.U32, node);
|
||||
}
|
||||
|
||||
public Instruction Get(AggregateType type, IAstNode node)
|
||||
{
|
||||
if (node is AstOperation operation)
|
||||
{
|
||||
OperationResult opResult = Instructions.Generate(this, operation);
|
||||
return BitcastIfNeeded(type, opResult.Type, opResult.Value);
|
||||
}
|
||||
else if (node is AstOperand operand)
|
||||
{
|
||||
return operand.Type switch
|
||||
{
|
||||
IrOperandType.Argument => GetArgument(type, operand),
|
||||
IrOperandType.Constant => GetConstant(type, operand),
|
||||
IrOperandType.LocalVariable => GetLocal(type, operand),
|
||||
IrOperandType.Undefined => GetUndefined(type),
|
||||
_ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
throw new NotImplementedException(node.GetType().Name);
|
||||
}
|
||||
|
||||
public Instruction GetWithType(IAstNode node, out AggregateType type)
|
||||
{
|
||||
if (node is AstOperation operation)
|
||||
{
|
||||
OperationResult opResult = Instructions.Generate(this, operation);
|
||||
type = opResult.Type;
|
||||
return opResult.Value;
|
||||
}
|
||||
else if (node is AstOperand operand)
|
||||
{
|
||||
switch (operand.Type)
|
||||
{
|
||||
case IrOperandType.LocalVariable:
|
||||
type = operand.VarType;
|
||||
return GetLocal(type, operand);
|
||||
default:
|
||||
throw new ArgumentException($"Invalid operand type \"{operand.Type}\".");
|
||||
}
|
||||
}
|
||||
|
||||
throw new NotImplementedException(node.GetType().Name);
|
||||
}
|
||||
|
||||
private Instruction GetUndefined(AggregateType type)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
AggregateType.Bool => ConstantFalse(TypeBool()),
|
||||
AggregateType.FP32 => Constant(TypeFP32(), 0f),
|
||||
AggregateType.FP64 => Constant(TypeFP64(), 0d),
|
||||
_ => Constant(GetType(type), 0),
|
||||
};
|
||||
}
|
||||
|
||||
public Instruction GetConstant(AggregateType type, AstOperand operand)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
AggregateType.Bool => operand.Value != 0 ? ConstantTrue(TypeBool()) : ConstantFalse(TypeBool()),
|
||||
AggregateType.FP32 => Constant(TypeFP32(), BitConverter.Int32BitsToSingle(operand.Value)),
|
||||
AggregateType.FP64 => Constant(TypeFP64(), (double)BitConverter.Int32BitsToSingle(operand.Value)),
|
||||
AggregateType.S32 => Constant(TypeS32(), operand.Value),
|
||||
AggregateType.U32 => Constant(TypeU32(), (uint)operand.Value),
|
||||
_ => throw new ArgumentException($"Invalid type \"{type}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
public Instruction GetLocalPointer(AstOperand local)
|
||||
{
|
||||
return _locals[local];
|
||||
}
|
||||
|
||||
public Instruction GetArgumentPointer(AstOperand funcArg)
|
||||
{
|
||||
return _funcArgs[funcArg.Value];
|
||||
}
|
||||
|
||||
public Instruction GetLocal(AggregateType dstType, AstOperand local)
|
||||
{
|
||||
AggregateType srcType = local.VarType;
|
||||
return BitcastIfNeeded(dstType, srcType, Load(GetType(srcType), GetLocalPointer(local)));
|
||||
}
|
||||
|
||||
public Instruction GetArgument(AggregateType dstType, AstOperand funcArg)
|
||||
{
|
||||
AggregateType srcType = funcArg.VarType;
|
||||
return BitcastIfNeeded(dstType, srcType, Load(GetType(srcType), GetArgumentPointer(funcArg)));
|
||||
}
|
||||
|
||||
public (StructuredFunction, Instruction) GetFunction(int funcIndex)
|
||||
{
|
||||
return _functions[funcIndex];
|
||||
}
|
||||
|
||||
public Instruction GetType(AggregateType type, int length = 1)
|
||||
{
|
||||
if ((type & AggregateType.Array) != 0)
|
||||
{
|
||||
if (length > 0)
|
||||
{
|
||||
return TypeArray(GetType(type & ~AggregateType.Array), Constant(TypeU32(), length));
|
||||
}
|
||||
else
|
||||
{
|
||||
return TypeRuntimeArray(GetType(type & ~AggregateType.Array));
|
||||
}
|
||||
}
|
||||
else if ((type & AggregateType.ElementCountMask) != 0)
|
||||
{
|
||||
int vectorLength = (type & AggregateType.ElementCountMask) switch
|
||||
{
|
||||
AggregateType.Vector2 => 2,
|
||||
AggregateType.Vector3 => 3,
|
||||
AggregateType.Vector4 => 4,
|
||||
_ => 1,
|
||||
};
|
||||
|
||||
return TypeVector(GetType(type & ~AggregateType.ElementCountMask), vectorLength);
|
||||
}
|
||||
|
||||
return type switch
|
||||
{
|
||||
AggregateType.Void => TypeVoid(),
|
||||
AggregateType.Bool => TypeBool(),
|
||||
AggregateType.FP32 => TypeFP32(),
|
||||
AggregateType.FP64 => TypeFP64(),
|
||||
AggregateType.S32 => TypeS32(),
|
||||
AggregateType.U32 => TypeU32(),
|
||||
_ => throw new ArgumentException($"Invalid attribute type \"{type}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
public Instruction BitcastIfNeeded(AggregateType dstType, AggregateType srcType, Instruction value)
|
||||
{
|
||||
if (dstType == srcType)
|
||||
{
|
||||
return value;
|
||||
}
|
||||
|
||||
if (dstType == AggregateType.Bool)
|
||||
{
|
||||
return INotEqual(TypeBool(), BitcastIfNeeded(AggregateType.S32, srcType, value), Constant(TypeS32(), 0));
|
||||
}
|
||||
else if (srcType == AggregateType.Bool)
|
||||
{
|
||||
Instruction intTrue = Constant(TypeS32(), IrConsts.True);
|
||||
Instruction intFalse = Constant(TypeS32(), IrConsts.False);
|
||||
|
||||
return BitcastIfNeeded(dstType, AggregateType.S32, Select(TypeS32(), value, intTrue, intFalse));
|
||||
}
|
||||
else
|
||||
{
|
||||
return Bitcast(GetType(dstType, 1), value);
|
||||
}
|
||||
}
|
||||
|
||||
public Instruction TypeS32()
|
||||
{
|
||||
return TypeInt(32, true);
|
||||
}
|
||||
|
||||
public Instruction TypeU32()
|
||||
{
|
||||
return TypeInt(32, false);
|
||||
}
|
||||
|
||||
public Instruction TypeFP32()
|
||||
{
|
||||
return TypeFloat(32);
|
||||
}
|
||||
|
||||
public Instruction TypeFP64()
|
||||
{
|
||||
return TypeFloat(64);
|
||||
}
|
||||
}
|
||||
}
|
||||
659
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs
vendored
Normal file
659
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs
vendored
Normal file
@@ -0,0 +1,659 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using Spv.Generator;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using static Spv.Specification;
|
||||
using SpvInstruction = Spv.Generator.Instruction;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
static class Declarations
|
||||
{
|
||||
public static void DeclareParameters(CodeGenContext context, StructuredFunction function)
|
||||
{
|
||||
DeclareParameters(context, function.InArguments, 0);
|
||||
DeclareParameters(context, function.OutArguments, function.InArguments.Length);
|
||||
}
|
||||
|
||||
private static void DeclareParameters(CodeGenContext context, IEnumerable<AggregateType> argTypes, int argIndex)
|
||||
{
|
||||
foreach (AggregateType argType in argTypes)
|
||||
{
|
||||
SpvInstruction argPointerType = context.TypePointer(StorageClass.Function, context.GetType(argType));
|
||||
SpvInstruction spvArg = context.FunctionParameter(argPointerType);
|
||||
|
||||
context.DeclareArgument(argIndex++, spvArg);
|
||||
}
|
||||
}
|
||||
|
||||
public static void DeclareLocals(CodeGenContext context, StructuredFunction function)
|
||||
{
|
||||
foreach (AstOperand local in function.Locals)
|
||||
{
|
||||
SpvInstruction localPointerType = context.TypePointer(StorageClass.Function, context.GetType(local.VarType));
|
||||
SpvInstruction spvLocal = context.Variable(localPointerType, StorageClass.Function);
|
||||
|
||||
context.AddLocalVariable(spvLocal);
|
||||
context.DeclareLocal(local, spvLocal);
|
||||
}
|
||||
}
|
||||
|
||||
public static void DeclareAll(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
DeclareConstantBuffers(context, context.Properties.ConstantBuffers.Values);
|
||||
DeclareStorageBuffers(context, context.Properties.StorageBuffers.Values);
|
||||
DeclareMemories(context, context.Properties.LocalMemories, context.LocalMemories, StorageClass.Private);
|
||||
DeclareMemories(context, context.Properties.SharedMemories, context.SharedMemories, StorageClass.Workgroup);
|
||||
DeclareSamplers(context, context.Properties.Textures.Values);
|
||||
DeclareImages(context, context.Properties.Images.Values);
|
||||
DeclareInputsAndOutputs(context, info);
|
||||
}
|
||||
|
||||
private static void DeclareMemories(
|
||||
CodeGenContext context,
|
||||
IReadOnlyDictionary<int, MemoryDefinition> memories,
|
||||
Dictionary<int, SpvInstruction> dict,
|
||||
StorageClass storage)
|
||||
{
|
||||
foreach ((int id, MemoryDefinition memory) in memories)
|
||||
{
|
||||
SpvInstruction pointerType = context.TypePointer(storage, context.GetType(memory.Type, memory.ArrayLength));
|
||||
SpvInstruction variable = context.Variable(pointerType, storage);
|
||||
|
||||
context.AddGlobalVariable(variable);
|
||||
|
||||
dict.Add(id, variable);
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareConstantBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers)
|
||||
{
|
||||
DeclareBuffers(context, buffers, isBuffer: false);
|
||||
}
|
||||
|
||||
private static void DeclareStorageBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers)
|
||||
{
|
||||
DeclareBuffers(context, buffers, isBuffer: true);
|
||||
}
|
||||
|
||||
private static void DeclareBuffers(CodeGenContext context, IEnumerable<BufferDefinition> buffers, bool isBuffer)
|
||||
{
|
||||
HashSet<SpvInstruction> decoratedTypes = [];
|
||||
|
||||
foreach (BufferDefinition buffer in buffers)
|
||||
{
|
||||
int setIndex = context.TargetApi == TargetApi.Vulkan ? buffer.Set : 0;
|
||||
int alignment = buffer.Layout == BufferLayout.Std140 ? 16 : 4;
|
||||
int alignmentMask = alignment - 1;
|
||||
int offset = 0;
|
||||
|
||||
SpvInstruction[] structFieldTypes = new SpvInstruction[buffer.Type.Fields.Length];
|
||||
int[] structFieldOffsets = new int[buffer.Type.Fields.Length];
|
||||
|
||||
for (int fieldIndex = 0; fieldIndex < buffer.Type.Fields.Length; fieldIndex++)
|
||||
{
|
||||
StructureField field = buffer.Type.Fields[fieldIndex];
|
||||
int fieldSize = (field.Type.GetSizeInBytes() + alignmentMask) & ~alignmentMask;
|
||||
|
||||
structFieldTypes[fieldIndex] = context.GetType(field.Type, field.ArrayLength);
|
||||
structFieldOffsets[fieldIndex] = offset;
|
||||
|
||||
if (field.Type.HasFlag(AggregateType.Array))
|
||||
{
|
||||
// We can't decorate the type more than once.
|
||||
if (decoratedTypes.Add(structFieldTypes[fieldIndex]))
|
||||
{
|
||||
context.Decorate(structFieldTypes[fieldIndex], Decoration.ArrayStride, (LiteralInteger)fieldSize);
|
||||
}
|
||||
|
||||
// Zero lengths are assumed to be a "runtime array" (which does not have a explicit length
|
||||
// specified on the shader, and instead assumes the bound buffer length).
|
||||
// It is only valid as the last struct element.
|
||||
|
||||
Debug.Assert(field.ArrayLength > 0 || fieldIndex == buffer.Type.Fields.Length - 1);
|
||||
|
||||
offset += fieldSize * field.ArrayLength;
|
||||
}
|
||||
else
|
||||
{
|
||||
offset += fieldSize;
|
||||
}
|
||||
}
|
||||
|
||||
SpvInstruction structType = context.TypeStruct(false, structFieldTypes);
|
||||
|
||||
if (decoratedTypes.Add(structType))
|
||||
{
|
||||
context.Decorate(structType, isBuffer ? Decoration.BufferBlock : Decoration.Block);
|
||||
|
||||
for (int fieldIndex = 0; fieldIndex < structFieldOffsets.Length; fieldIndex++)
|
||||
{
|
||||
context.MemberDecorate(structType, fieldIndex, Decoration.Offset, (LiteralInteger)structFieldOffsets[fieldIndex]);
|
||||
}
|
||||
}
|
||||
|
||||
SpvInstruction pointerType = context.TypePointer(StorageClass.Uniform, structType);
|
||||
SpvInstruction variable = context.Variable(pointerType, StorageClass.Uniform);
|
||||
|
||||
context.Name(variable, buffer.Name);
|
||||
context.Decorate(variable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
|
||||
context.Decorate(variable, Decoration.Binding, (LiteralInteger)buffer.Binding);
|
||||
context.AddGlobalVariable(variable);
|
||||
|
||||
if (isBuffer)
|
||||
{
|
||||
context.StorageBuffers.Add(buffer.Binding, variable);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.ConstantBuffers.Add(buffer.Binding, variable);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareSamplers(CodeGenContext context, IEnumerable<TextureDefinition> samplers)
|
||||
{
|
||||
foreach (TextureDefinition sampler in samplers)
|
||||
{
|
||||
int setIndex = context.TargetApi == TargetApi.Vulkan ? sampler.Set : 0;
|
||||
|
||||
SpvInstruction imageType;
|
||||
SpvInstruction sampledImageType;
|
||||
|
||||
if (sampler.Type != SamplerType.None)
|
||||
{
|
||||
Dim dim = (sampler.Type & SamplerType.Mask) switch
|
||||
{
|
||||
SamplerType.Texture1D => Dim.Dim1D,
|
||||
SamplerType.Texture2D => Dim.Dim2D,
|
||||
SamplerType.Texture3D => Dim.Dim3D,
|
||||
SamplerType.TextureCube => Dim.Cube,
|
||||
SamplerType.TextureBuffer => Dim.Buffer,
|
||||
_ => throw new InvalidOperationException($"Invalid sampler type \"{sampler.Type & SamplerType.Mask}\"."),
|
||||
};
|
||||
|
||||
imageType = context.TypeImage(
|
||||
context.TypeFP32(),
|
||||
dim,
|
||||
sampler.Type.HasFlag(SamplerType.Shadow),
|
||||
sampler.Type.HasFlag(SamplerType.Array),
|
||||
sampler.Type.HasFlag(SamplerType.Multisample),
|
||||
1,
|
||||
ImageFormat.Unknown);
|
||||
|
||||
sampledImageType = context.TypeSampledImage(imageType);
|
||||
}
|
||||
else
|
||||
{
|
||||
imageType = sampledImageType = context.TypeSampler();
|
||||
}
|
||||
|
||||
SpvInstruction sampledOrSeparateImageType = sampler.Separate ? imageType : sampledImageType;
|
||||
SpvInstruction sampledImagePointerType = context.TypePointer(StorageClass.UniformConstant, sampledOrSeparateImageType);
|
||||
SpvInstruction sampledImageArrayPointerType = sampledImagePointerType;
|
||||
|
||||
if (sampler.ArrayLength == 0)
|
||||
{
|
||||
SpvInstruction sampledImageArrayType = context.TypeRuntimeArray(sampledOrSeparateImageType);
|
||||
sampledImageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageArrayType);
|
||||
}
|
||||
else if (sampler.ArrayLength != 1)
|
||||
{
|
||||
SpvInstruction sampledImageArrayType = context.TypeArray(sampledOrSeparateImageType, context.Constant(context.TypeU32(), sampler.ArrayLength));
|
||||
sampledImageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageArrayType);
|
||||
}
|
||||
|
||||
SpvInstruction sampledImageVariable = context.Variable(sampledImageArrayPointerType, StorageClass.UniformConstant);
|
||||
|
||||
context.Samplers.Add(new(sampler.Set, sampler.Binding), new SamplerDeclaration(
|
||||
imageType,
|
||||
sampledImageType,
|
||||
sampledImagePointerType,
|
||||
sampledImageVariable,
|
||||
sampler.ArrayLength != 1));
|
||||
context.SamplersTypes.Add(new(sampler.Set, sampler.Binding), sampler.Type);
|
||||
|
||||
context.Name(sampledImageVariable, sampler.Name);
|
||||
context.Decorate(sampledImageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
|
||||
context.Decorate(sampledImageVariable, Decoration.Binding, (LiteralInteger)sampler.Binding);
|
||||
context.AddGlobalVariable(sampledImageVariable);
|
||||
}
|
||||
}
|
||||
|
||||
private static void DeclareImages(CodeGenContext context, IEnumerable<TextureDefinition> images)
|
||||
{
|
||||
foreach (TextureDefinition image in images)
|
||||
{
|
||||
int setIndex = context.TargetApi == TargetApi.Vulkan ? image.Set : 0;
|
||||
|
||||
Dim dim = GetDim(image.Type);
|
||||
|
||||
SpvInstruction imageType = context.TypeImage(
|
||||
context.GetType(image.Format.GetComponentType()),
|
||||
dim,
|
||||
image.Type.HasFlag(SamplerType.Shadow),
|
||||
image.Type.HasFlag(SamplerType.Array),
|
||||
image.Type.HasFlag(SamplerType.Multisample),
|
||||
AccessQualifier.ReadWrite,
|
||||
GetImageFormat(image.Format));
|
||||
|
||||
SpvInstruction imagePointerType = context.TypePointer(StorageClass.UniformConstant, imageType);
|
||||
SpvInstruction imageArrayPointerType = imagePointerType;
|
||||
|
||||
if (image.ArrayLength == 0)
|
||||
{
|
||||
SpvInstruction imageArrayType = context.TypeRuntimeArray(imageType);
|
||||
imageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, imageArrayType);
|
||||
}
|
||||
else if (image.ArrayLength != 1)
|
||||
{
|
||||
SpvInstruction imageArrayType = context.TypeArray(imageType, context.Constant(context.TypeU32(), image.ArrayLength));
|
||||
imageArrayPointerType = context.TypePointer(StorageClass.UniformConstant, imageArrayType);
|
||||
}
|
||||
|
||||
SpvInstruction imageVariable = context.Variable(imageArrayPointerType, StorageClass.UniformConstant);
|
||||
|
||||
context.Images.Add(new(image.Set, image.Binding), new ImageDeclaration(imageType, imagePointerType, imageVariable, image.ArrayLength != 1));
|
||||
|
||||
context.Name(imageVariable, image.Name);
|
||||
context.Decorate(imageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
|
||||
context.Decorate(imageVariable, Decoration.Binding, (LiteralInteger)image.Binding);
|
||||
|
||||
if (image.Flags.HasFlag(TextureUsageFlags.ImageCoherent))
|
||||
{
|
||||
context.Decorate(imageVariable, Decoration.Coherent);
|
||||
}
|
||||
|
||||
context.AddGlobalVariable(imageVariable);
|
||||
}
|
||||
}
|
||||
|
||||
private static Dim GetDim(SamplerType type)
|
||||
{
|
||||
return (type & SamplerType.Mask) switch
|
||||
{
|
||||
SamplerType.Texture1D => Dim.Dim1D,
|
||||
SamplerType.Texture2D => Dim.Dim2D,
|
||||
SamplerType.Texture3D => Dim.Dim3D,
|
||||
SamplerType.TextureCube => Dim.Cube,
|
||||
SamplerType.TextureBuffer => Dim.Buffer,
|
||||
_ => throw new ArgumentException($"Invalid sampler type \"{type & SamplerType.Mask}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
private static ImageFormat GetImageFormat(TextureFormat format)
|
||||
{
|
||||
return format switch
|
||||
{
|
||||
TextureFormat.Unknown => ImageFormat.Unknown,
|
||||
TextureFormat.R8Unorm => ImageFormat.R8,
|
||||
TextureFormat.R8Snorm => ImageFormat.R8Snorm,
|
||||
TextureFormat.R8Uint => ImageFormat.R8ui,
|
||||
TextureFormat.R8Sint => ImageFormat.R8i,
|
||||
TextureFormat.R16Float => ImageFormat.R16f,
|
||||
TextureFormat.R16Unorm => ImageFormat.R16,
|
||||
TextureFormat.R16Snorm => ImageFormat.R16Snorm,
|
||||
TextureFormat.R16Uint => ImageFormat.R16ui,
|
||||
TextureFormat.R16Sint => ImageFormat.R16i,
|
||||
TextureFormat.R32Float => ImageFormat.R32f,
|
||||
TextureFormat.R32Uint => ImageFormat.R32ui,
|
||||
TextureFormat.R32Sint => ImageFormat.R32i,
|
||||
TextureFormat.R8G8Unorm => ImageFormat.Rg8,
|
||||
TextureFormat.R8G8Snorm => ImageFormat.Rg8Snorm,
|
||||
TextureFormat.R8G8Uint => ImageFormat.Rg8ui,
|
||||
TextureFormat.R8G8Sint => ImageFormat.Rg8i,
|
||||
TextureFormat.R16G16Float => ImageFormat.Rg16f,
|
||||
TextureFormat.R16G16Unorm => ImageFormat.Rg16,
|
||||
TextureFormat.R16G16Snorm => ImageFormat.Rg16Snorm,
|
||||
TextureFormat.R16G16Uint => ImageFormat.Rg16ui,
|
||||
TextureFormat.R16G16Sint => ImageFormat.Rg16i,
|
||||
TextureFormat.R32G32Float => ImageFormat.Rg32f,
|
||||
TextureFormat.R32G32Uint => ImageFormat.Rg32ui,
|
||||
TextureFormat.R32G32Sint => ImageFormat.Rg32i,
|
||||
TextureFormat.R8G8B8A8Unorm => ImageFormat.Rgba8,
|
||||
TextureFormat.R8G8B8A8Snorm => ImageFormat.Rgba8Snorm,
|
||||
TextureFormat.R8G8B8A8Uint => ImageFormat.Rgba8ui,
|
||||
TextureFormat.R8G8B8A8Sint => ImageFormat.Rgba8i,
|
||||
TextureFormat.R16G16B16A16Float => ImageFormat.Rgba16f,
|
||||
TextureFormat.R16G16B16A16Unorm => ImageFormat.Rgba16,
|
||||
TextureFormat.R16G16B16A16Snorm => ImageFormat.Rgba16Snorm,
|
||||
TextureFormat.R16G16B16A16Uint => ImageFormat.Rgba16ui,
|
||||
TextureFormat.R16G16B16A16Sint => ImageFormat.Rgba16i,
|
||||
TextureFormat.R32G32B32A32Float => ImageFormat.Rgba32f,
|
||||
TextureFormat.R32G32B32A32Uint => ImageFormat.Rgba32ui,
|
||||
TextureFormat.R32G32B32A32Sint => ImageFormat.Rgba32i,
|
||||
TextureFormat.R10G10B10A2Unorm => ImageFormat.Rgb10A2,
|
||||
TextureFormat.R10G10B10A2Uint => ImageFormat.Rgb10a2ui,
|
||||
TextureFormat.R11G11B10Float => ImageFormat.R11fG11fB10f,
|
||||
_ => throw new ArgumentException($"Invalid texture format \"{format}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
private static void DeclareInputsAndOutputs(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
int firstLocation = int.MaxValue;
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Fragment && context.Definitions.DualSourceBlend)
|
||||
{
|
||||
foreach (IoDefinition ioDefinition in info.IoDefinitions)
|
||||
{
|
||||
if (ioDefinition.IoVariable == IoVariable.FragmentOutputColor && ioDefinition.Location < firstLocation)
|
||||
{
|
||||
firstLocation = ioDefinition.Location;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
foreach (IoDefinition ioDefinition in info.IoDefinitions)
|
||||
{
|
||||
PixelImap iq = PixelImap.Unused;
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
IoVariable ioVariable = ioDefinition.IoVariable;
|
||||
if (ioVariable == IoVariable.UserDefined)
|
||||
{
|
||||
iq = context.Definitions.ImapTypes[ioDefinition.Location].GetFirstUsedType();
|
||||
}
|
||||
else
|
||||
{
|
||||
(_, AggregateType varType) = IoMap.GetSpirvBuiltIn(ioVariable);
|
||||
AggregateType elemType = varType & AggregateType.ElementTypeMask;
|
||||
|
||||
if (elemType is AggregateType.S32 or AggregateType.U32)
|
||||
{
|
||||
iq = PixelImap.Constant;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (IoMap.IsPerVertexBuiltIn(ioDefinition.IoVariable))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
bool isOutput = ioDefinition.StorageKind.IsOutput();
|
||||
bool isPerPatch = ioDefinition.StorageKind.IsPerPatch();
|
||||
|
||||
DeclareInputOrOutput(context, ioDefinition, isOutput, isPerPatch, iq, firstLocation);
|
||||
}
|
||||
|
||||
DeclarePerVertexBlock(context);
|
||||
}
|
||||
|
||||
private static void DeclarePerVertexBlock(CodeGenContext context)
|
||||
{
|
||||
if (context.Definitions.Stage.IsVtg)
|
||||
{
|
||||
if (context.Definitions.Stage != ShaderStage.Vertex)
|
||||
{
|
||||
SpvInstruction perVertexInputStructType = CreatePerVertexStructType(context);
|
||||
int arraySize = context.Definitions.Stage == ShaderStage.Geometry ? context.Definitions.InputTopology.InputVertexCount : 32;
|
||||
SpvInstruction perVertexInputArrayType = context.TypeArray(perVertexInputStructType, context.Constant(context.TypeU32(), arraySize));
|
||||
SpvInstruction perVertexInputPointerType = context.TypePointer(StorageClass.Input, perVertexInputArrayType);
|
||||
SpvInstruction perVertexInputVariable = context.Variable(perVertexInputPointerType, StorageClass.Input);
|
||||
|
||||
context.Name(perVertexInputVariable, "gl_in");
|
||||
|
||||
context.AddGlobalVariable(perVertexInputVariable);
|
||||
context.Inputs.Add(new IoDefinition(StorageKind.Input, IoVariable.Position), perVertexInputVariable);
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Geometry &&
|
||||
context.Definitions.GpPassthrough &&
|
||||
context.HostCapabilities.SupportsGeometryShaderPassthrough)
|
||||
{
|
||||
context.MemberDecorate(perVertexInputStructType, 0, Decoration.PassthroughNV);
|
||||
context.MemberDecorate(perVertexInputStructType, 1, Decoration.PassthroughNV);
|
||||
context.MemberDecorate(perVertexInputStructType, 2, Decoration.PassthroughNV);
|
||||
context.MemberDecorate(perVertexInputStructType, 3, Decoration.PassthroughNV);
|
||||
}
|
||||
}
|
||||
|
||||
SpvInstruction perVertexOutputStructType = CreatePerVertexStructType(context);
|
||||
|
||||
void DecorateTfo(IoVariable ioVariable, int fieldIndex)
|
||||
{
|
||||
if (context.Definitions.TryGetTransformFeedbackOutput(ioVariable, 0, 0, out TransformFeedbackOutput transformFeedbackOutput))
|
||||
{
|
||||
context.MemberDecorate(perVertexOutputStructType, fieldIndex, Decoration.XfbBuffer, (LiteralInteger)transformFeedbackOutput.Buffer);
|
||||
context.MemberDecorate(perVertexOutputStructType, fieldIndex, Decoration.XfbStride, (LiteralInteger)transformFeedbackOutput.Stride);
|
||||
context.MemberDecorate(perVertexOutputStructType, fieldIndex, Decoration.Offset, (LiteralInteger)transformFeedbackOutput.Offset);
|
||||
}
|
||||
}
|
||||
|
||||
DecorateTfo(IoVariable.Position, 0);
|
||||
DecorateTfo(IoVariable.PointSize, 1);
|
||||
DecorateTfo(IoVariable.ClipDistance, 2);
|
||||
|
||||
SpvInstruction perVertexOutputArrayType;
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.TessellationControl)
|
||||
{
|
||||
int arraySize = context.Definitions.ThreadsPerInputPrimitive;
|
||||
perVertexOutputArrayType = context.TypeArray(perVertexOutputStructType, context.Constant(context.TypeU32(), arraySize));
|
||||
}
|
||||
else
|
||||
{
|
||||
perVertexOutputArrayType = perVertexOutputStructType;
|
||||
}
|
||||
|
||||
SpvInstruction perVertexOutputPointerType = context.TypePointer(StorageClass.Output, perVertexOutputArrayType);
|
||||
SpvInstruction perVertexOutputVariable = context.Variable(perVertexOutputPointerType, StorageClass.Output);
|
||||
|
||||
context.AddGlobalVariable(perVertexOutputVariable);
|
||||
context.Outputs.Add(new IoDefinition(StorageKind.Output, IoVariable.Position), perVertexOutputVariable);
|
||||
}
|
||||
}
|
||||
|
||||
private static SpvInstruction CreatePerVertexStructType(CodeGenContext context)
|
||||
{
|
||||
SpvInstruction vec4FloatType = context.TypeVector(context.TypeFP32(), 4);
|
||||
SpvInstruction floatType = context.TypeFP32();
|
||||
SpvInstruction array8FloatType = context.TypeArray(context.TypeFP32(), context.Constant(context.TypeU32(), 8));
|
||||
SpvInstruction array1FloatType = context.TypeArray(context.TypeFP32(), context.Constant(context.TypeU32(), 1));
|
||||
|
||||
SpvInstruction perVertexStructType = context.TypeStruct(true, vec4FloatType, floatType, array8FloatType, array1FloatType);
|
||||
|
||||
context.Name(perVertexStructType, "gl_PerVertex");
|
||||
|
||||
context.MemberName(perVertexStructType, 0, "gl_Position");
|
||||
context.MemberName(perVertexStructType, 1, "gl_PointSize");
|
||||
context.MemberName(perVertexStructType, 2, "gl_ClipDistance");
|
||||
context.MemberName(perVertexStructType, 3, "gl_CullDistance");
|
||||
|
||||
context.Decorate(perVertexStructType, Decoration.Block);
|
||||
|
||||
if (context.HostCapabilities.ReducedPrecision)
|
||||
{
|
||||
context.MemberDecorate(perVertexStructType, 0, Decoration.Invariant);
|
||||
}
|
||||
|
||||
context.MemberDecorate(perVertexStructType, 0, Decoration.BuiltIn, (LiteralInteger)BuiltIn.Position);
|
||||
context.MemberDecorate(perVertexStructType, 1, Decoration.BuiltIn, (LiteralInteger)BuiltIn.PointSize);
|
||||
context.MemberDecorate(perVertexStructType, 2, Decoration.BuiltIn, (LiteralInteger)BuiltIn.ClipDistance);
|
||||
context.MemberDecorate(perVertexStructType, 3, Decoration.BuiltIn, (LiteralInteger)BuiltIn.CullDistance);
|
||||
|
||||
return perVertexStructType;
|
||||
}
|
||||
|
||||
private static void DeclareInputOrOutput(
|
||||
CodeGenContext context,
|
||||
IoDefinition ioDefinition,
|
||||
bool isOutput,
|
||||
bool isPerPatch,
|
||||
PixelImap iq = PixelImap.Unused,
|
||||
int firstLocation = 0)
|
||||
{
|
||||
IoVariable ioVariable = ioDefinition.IoVariable;
|
||||
StorageClass storageClass = isOutput ? StorageClass.Output : StorageClass.Input;
|
||||
|
||||
bool isBuiltIn;
|
||||
BuiltIn builtIn = default;
|
||||
AggregateType varType;
|
||||
|
||||
if (ioVariable == IoVariable.UserDefined)
|
||||
{
|
||||
varType = context.Definitions.GetUserDefinedType(ioDefinition.Location, isOutput);
|
||||
isBuiltIn = false;
|
||||
}
|
||||
else if (ioVariable == IoVariable.FragmentOutputColor)
|
||||
{
|
||||
varType = context.Definitions.GetFragmentOutputColorType(ioDefinition.Location);
|
||||
isBuiltIn = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
(builtIn, varType) = IoMap.GetSpirvBuiltIn(ioVariable);
|
||||
isBuiltIn = true;
|
||||
|
||||
if (varType == AggregateType.Invalid)
|
||||
{
|
||||
throw new InvalidOperationException($"Unknown variable {ioVariable}.");
|
||||
}
|
||||
}
|
||||
|
||||
bool hasComponent = context.Definitions.HasPerLocationInputOrOutputComponent(ioVariable, ioDefinition.Location, ioDefinition.Component, isOutput);
|
||||
|
||||
if (hasComponent)
|
||||
{
|
||||
varType &= AggregateType.ElementTypeMask;
|
||||
}
|
||||
else if (ioVariable == IoVariable.UserDefined && context.Definitions.HasTransformFeedbackOutputs(isOutput))
|
||||
{
|
||||
varType &= AggregateType.ElementTypeMask;
|
||||
varType |= context.Definitions.GetTransformFeedbackOutputComponents(ioDefinition.Location, ioDefinition.Component) switch
|
||||
{
|
||||
2 => AggregateType.Vector2,
|
||||
3 => AggregateType.Vector3,
|
||||
4 => AggregateType.Vector4,
|
||||
_ => AggregateType.Invalid,
|
||||
};
|
||||
}
|
||||
|
||||
SpvInstruction spvType = context.GetType(varType, IoMap.GetSpirvBuiltInArrayLength(ioVariable));
|
||||
bool builtInPassthrough = false;
|
||||
|
||||
if (!isPerPatch && IoMap.IsPerVertex(ioVariable, context.Definitions.Stage, isOutput))
|
||||
{
|
||||
int arraySize = context.Definitions.Stage == ShaderStage.Geometry ? context.Definitions.InputTopology.InputVertexCount : 32;
|
||||
spvType = context.TypeArray(spvType, context.Constant(context.TypeU32(), arraySize));
|
||||
|
||||
if (context.Definitions.GpPassthrough && context.HostCapabilities.SupportsGeometryShaderPassthrough)
|
||||
{
|
||||
builtInPassthrough = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.TessellationControl && isOutput && !isPerPatch)
|
||||
{
|
||||
spvType = context.TypeArray(spvType, context.Constant(context.TypeU32(), context.Definitions.ThreadsPerInputPrimitive));
|
||||
}
|
||||
|
||||
SpvInstruction spvPointerType = context.TypePointer(storageClass, spvType);
|
||||
SpvInstruction spvVar = context.Variable(spvPointerType, storageClass);
|
||||
|
||||
if (builtInPassthrough)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.PassthroughNV);
|
||||
}
|
||||
|
||||
if (isBuiltIn)
|
||||
{
|
||||
if (isPerPatch)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Patch);
|
||||
}
|
||||
|
||||
if (context.HostCapabilities.ReducedPrecision && ioVariable == IoVariable.Position)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Invariant);
|
||||
}
|
||||
|
||||
context.Decorate(spvVar, Decoration.BuiltIn, (LiteralInteger)builtIn);
|
||||
}
|
||||
else if (isPerPatch)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Patch);
|
||||
|
||||
if (ioVariable == IoVariable.UserDefined)
|
||||
{
|
||||
int location = context.AttributeUsage.GetPerPatchAttributeLocation(ioDefinition.Location);
|
||||
|
||||
context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
|
||||
}
|
||||
}
|
||||
else if (ioVariable == IoVariable.UserDefined)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Location, (LiteralInteger)ioDefinition.Location);
|
||||
|
||||
if (hasComponent)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Component, (LiteralInteger)ioDefinition.Component);
|
||||
}
|
||||
|
||||
if (!isOutput &&
|
||||
!isPerPatch &&
|
||||
(context.AttributeUsage.PassthroughAttributes & (1 << ioDefinition.Location)) != 0 &&
|
||||
context.HostCapabilities.SupportsGeometryShaderPassthrough)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.PassthroughNV);
|
||||
}
|
||||
}
|
||||
else if (ioVariable == IoVariable.FragmentOutputColor)
|
||||
{
|
||||
int location = ioDefinition.Location;
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.Fragment && context.Definitions.DualSourceBlend)
|
||||
{
|
||||
int index = location - firstLocation;
|
||||
|
||||
if ((uint)index < 2)
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Location, (LiteralInteger)firstLocation);
|
||||
context.Decorate(spvVar, Decoration.Index, (LiteralInteger)index);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
|
||||
}
|
||||
}
|
||||
|
||||
if (!isOutput)
|
||||
{
|
||||
switch (iq)
|
||||
{
|
||||
case PixelImap.Constant:
|
||||
context.Decorate(spvVar, Decoration.Flat);
|
||||
break;
|
||||
case PixelImap.ScreenLinear:
|
||||
context.Decorate(spvVar, Decoration.NoPerspective);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (context.Definitions.TryGetTransformFeedbackOutput(
|
||||
ioVariable,
|
||||
ioDefinition.Location,
|
||||
ioDefinition.Component,
|
||||
out TransformFeedbackOutput transformFeedbackOutput))
|
||||
{
|
||||
context.Decorate(spvVar, Decoration.XfbBuffer, (LiteralInteger)transformFeedbackOutput.Buffer);
|
||||
context.Decorate(spvVar, Decoration.XfbStride, (LiteralInteger)transformFeedbackOutput.Stride);
|
||||
context.Decorate(spvVar, Decoration.Offset, (LiteralInteger)transformFeedbackOutput.Offset);
|
||||
}
|
||||
|
||||
context.AddGlobalVariable(spvVar);
|
||||
|
||||
Dictionary<IoDefinition, SpvInstruction> dict = isPerPatch
|
||||
? (isOutput ? context.OutputsPerPatch : context.InputsPerPatch)
|
||||
: (isOutput ? context.Outputs : context.Inputs);
|
||||
dict.Add(ioDefinition, spvVar);
|
||||
}
|
||||
}
|
||||
}
|
||||
22
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/EnumConversion.cs
vendored
Normal file
22
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/EnumConversion.cs
vendored
Normal file
@@ -0,0 +1,22 @@
|
||||
using System;
|
||||
using static Spv.Specification;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
static class EnumConversion
|
||||
{
|
||||
public static ExecutionModel Convert(this ShaderStage stage)
|
||||
{
|
||||
return stage switch
|
||||
{
|
||||
ShaderStage.Compute => ExecutionModel.GLCompute,
|
||||
ShaderStage.Vertex => ExecutionModel.Vertex,
|
||||
ShaderStage.TessellationControl => ExecutionModel.TessellationControl,
|
||||
ShaderStage.TessellationEvaluation => ExecutionModel.TessellationEvaluation,
|
||||
ShaderStage.Geometry => ExecutionModel.Geometry,
|
||||
ShaderStage.Fragment => ExecutionModel.Fragment,
|
||||
_ => throw new ArgumentException($"Invalid shader stage \"{stage}\"."),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
20
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/ImageDeclaration.cs
vendored
Normal file
20
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/ImageDeclaration.cs
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
using Spv.Generator;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
readonly struct ImageDeclaration
|
||||
{
|
||||
public readonly Instruction ImageType;
|
||||
public readonly Instruction ImagePointerType;
|
||||
public readonly Instruction Image;
|
||||
public readonly bool IsIndexed;
|
||||
|
||||
public ImageDeclaration(Instruction imageType, Instruction imagePointerType, Instruction image, bool isIndexed)
|
||||
{
|
||||
ImageType = imageType;
|
||||
ImagePointerType = imagePointerType;
|
||||
Image = image;
|
||||
IsIndexed = isIndexed;
|
||||
}
|
||||
}
|
||||
}
|
||||
2190
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs
vendored
Normal file
2190
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
124
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/IoMap.cs
vendored
Normal file
124
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/IoMap.cs
vendored
Normal file
@@ -0,0 +1,124 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using static Spv.Specification;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
static class IoMap
|
||||
{
|
||||
// At least 16 attributes are guaranteed by the spec.
|
||||
private const int MaxAttributes = 16;
|
||||
|
||||
public static (BuiltIn, AggregateType) GetSpirvBuiltIn(IoVariable ioVariable)
|
||||
{
|
||||
return ioVariable switch
|
||||
{
|
||||
IoVariable.BaseInstance => (BuiltIn.BaseInstance, AggregateType.S32),
|
||||
IoVariable.BaseVertex => (BuiltIn.BaseVertex, AggregateType.S32),
|
||||
IoVariable.ClipDistance => (BuiltIn.ClipDistance, AggregateType.Array | AggregateType.FP32),
|
||||
IoVariable.CtaId => (BuiltIn.WorkgroupId, AggregateType.Vector3 | AggregateType.U32),
|
||||
IoVariable.DrawIndex => (BuiltIn.DrawIndex, AggregateType.S32),
|
||||
IoVariable.FragmentCoord => (BuiltIn.FragCoord, AggregateType.Vector4 | AggregateType.FP32),
|
||||
IoVariable.FragmentOutputDepth => (BuiltIn.FragDepth, AggregateType.FP32),
|
||||
IoVariable.FrontFacing => (BuiltIn.FrontFacing, AggregateType.Bool),
|
||||
IoVariable.GlobalId => (BuiltIn.GlobalInvocationId, AggregateType.Vector3 | AggregateType.U32),
|
||||
IoVariable.InstanceId => (BuiltIn.InstanceId, AggregateType.S32),
|
||||
IoVariable.InstanceIndex => (BuiltIn.InstanceIndex, AggregateType.S32),
|
||||
IoVariable.InvocationId => (BuiltIn.InvocationId, AggregateType.S32),
|
||||
IoVariable.Layer => (BuiltIn.Layer, AggregateType.S32),
|
||||
IoVariable.PatchVertices => (BuiltIn.PatchVertices, AggregateType.S32),
|
||||
IoVariable.PointCoord => (BuiltIn.PointCoord, AggregateType.Vector2 | AggregateType.FP32),
|
||||
IoVariable.PointSize => (BuiltIn.PointSize, AggregateType.FP32),
|
||||
IoVariable.Position => (BuiltIn.Position, AggregateType.Vector4 | AggregateType.FP32),
|
||||
IoVariable.PrimitiveId => (BuiltIn.PrimitiveId, AggregateType.S32),
|
||||
IoVariable.SubgroupEqMask => (BuiltIn.SubgroupEqMask, AggregateType.Vector4 | AggregateType.U32),
|
||||
IoVariable.SubgroupGeMask => (BuiltIn.SubgroupGeMask, AggregateType.Vector4 | AggregateType.U32),
|
||||
IoVariable.SubgroupGtMask => (BuiltIn.SubgroupGtMask, AggregateType.Vector4 | AggregateType.U32),
|
||||
IoVariable.SubgroupLaneId => (BuiltIn.SubgroupLocalInvocationId, AggregateType.U32),
|
||||
IoVariable.SubgroupLeMask => (BuiltIn.SubgroupLeMask, AggregateType.Vector4 | AggregateType.U32),
|
||||
IoVariable.SubgroupLtMask => (BuiltIn.SubgroupLtMask, AggregateType.Vector4 | AggregateType.U32),
|
||||
IoVariable.TessellationCoord => (BuiltIn.TessCoord, AggregateType.Vector3 | AggregateType.FP32),
|
||||
IoVariable.TessellationLevelInner => (BuiltIn.TessLevelInner, AggregateType.Array | AggregateType.FP32),
|
||||
IoVariable.TessellationLevelOuter => (BuiltIn.TessLevelOuter, AggregateType.Array | AggregateType.FP32),
|
||||
IoVariable.ThreadId => (BuiltIn.LocalInvocationId, AggregateType.Vector3 | AggregateType.U32),
|
||||
IoVariable.ThreadKill => (BuiltIn.HelperInvocation, AggregateType.Bool),
|
||||
IoVariable.VertexId => (BuiltIn.VertexId, AggregateType.S32),
|
||||
IoVariable.VertexIndex => (BuiltIn.VertexIndex, AggregateType.S32),
|
||||
IoVariable.ViewportIndex => (BuiltIn.ViewportIndex, AggregateType.S32),
|
||||
IoVariable.ViewportMask => (BuiltIn.ViewportMaskNV, AggregateType.Array | AggregateType.S32),
|
||||
_ => (default, AggregateType.Invalid),
|
||||
};
|
||||
}
|
||||
|
||||
public static int GetSpirvBuiltInArrayLength(IoVariable ioVariable)
|
||||
{
|
||||
return ioVariable switch
|
||||
{
|
||||
IoVariable.ClipDistance => 8,
|
||||
IoVariable.TessellationLevelInner => 2,
|
||||
IoVariable.TessellationLevelOuter => 4,
|
||||
IoVariable.ViewportMask => 1,
|
||||
IoVariable.UserDefined => MaxAttributes,
|
||||
_ => 1,
|
||||
};
|
||||
}
|
||||
|
||||
public static bool IsPerVertex(IoVariable ioVariable, ShaderStage stage, bool isOutput)
|
||||
{
|
||||
switch (ioVariable)
|
||||
{
|
||||
case IoVariable.Layer:
|
||||
case IoVariable.ViewportIndex:
|
||||
case IoVariable.PointSize:
|
||||
case IoVariable.Position:
|
||||
case IoVariable.UserDefined:
|
||||
case IoVariable.ClipDistance:
|
||||
case IoVariable.PointCoord:
|
||||
case IoVariable.ViewportMask:
|
||||
return !isOutput &&
|
||||
stage is ShaderStage.TessellationControl or ShaderStage.TessellationEvaluation or ShaderStage.Geometry;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool IsPerVertexBuiltIn(IoVariable ioVariable)
|
||||
{
|
||||
switch (ioVariable)
|
||||
{
|
||||
case IoVariable.Position:
|
||||
case IoVariable.PointSize:
|
||||
case IoVariable.ClipDistance:
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool IsPerVertexArrayBuiltIn(StorageKind storageKind, ShaderStage stage)
|
||||
{
|
||||
if (storageKind == StorageKind.Output)
|
||||
{
|
||||
return stage == ShaderStage.TessellationControl;
|
||||
}
|
||||
else
|
||||
{
|
||||
return stage is ShaderStage.TessellationControl or
|
||||
ShaderStage.TessellationEvaluation or
|
||||
ShaderStage.Geometry;
|
||||
}
|
||||
}
|
||||
|
||||
public static int GetPerVertexStructFieldIndex(IoVariable ioVariable)
|
||||
{
|
||||
return ioVariable switch
|
||||
{
|
||||
IoVariable.Position => 0,
|
||||
IoVariable.PointSize => 1,
|
||||
IoVariable.ClipDistance => 2,
|
||||
_ => throw new ArgumentException($"Invalid built-in variable {ioVariable}.")
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
19
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/OperationResult.cs
vendored
Normal file
19
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/OperationResult.cs
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using Spv.Generator;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
readonly struct OperationResult
|
||||
{
|
||||
public static OperationResult Invalid => new(AggregateType.Invalid, null);
|
||||
|
||||
public AggregateType Type { get; }
|
||||
public Instruction Value { get; }
|
||||
|
||||
public OperationResult(AggregateType type, Instruction value)
|
||||
{
|
||||
Type = type;
|
||||
Value = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
27
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SamplerDeclaration.cs
vendored
Normal file
27
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SamplerDeclaration.cs
vendored
Normal file
@@ -0,0 +1,27 @@
|
||||
using Spv.Generator;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
readonly struct SamplerDeclaration
|
||||
{
|
||||
public readonly Instruction ImageType;
|
||||
public readonly Instruction SampledImageType;
|
||||
public readonly Instruction SampledImagePointerType;
|
||||
public readonly Instruction Image;
|
||||
public readonly bool IsIndexed;
|
||||
|
||||
public SamplerDeclaration(
|
||||
Instruction imageType,
|
||||
Instruction sampledImageType,
|
||||
Instruction sampledImagePointerType,
|
||||
Instruction image,
|
||||
bool isIndexed)
|
||||
{
|
||||
ImageType = imageType;
|
||||
SampledImageType = sampledImageType;
|
||||
SampledImagePointerType = sampledImagePointerType;
|
||||
Image = image;
|
||||
IsIndexed = isIndexed;
|
||||
}
|
||||
}
|
||||
}
|
||||
228
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvDelegates.cs
vendored
Normal file
228
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvDelegates.cs
vendored
Normal file
@@ -0,0 +1,228 @@
|
||||
using FuncBinaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
|
||||
using FuncQuaternaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
|
||||
using FuncTernaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
|
||||
using FuncUnaryInstruction = System.Func<Spv.Generator.Instruction, Spv.Generator.Instruction, Spv.Generator.Instruction>;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
/// <summary>
|
||||
/// Delegate cache for SPIR-V instruction generators. Avoids delegate allocation when passing generators as arguments.
|
||||
/// </summary>
|
||||
internal readonly struct SpirvDelegates
|
||||
{
|
||||
// Unary
|
||||
public readonly FuncUnaryInstruction GlslFAbs;
|
||||
public readonly FuncUnaryInstruction GlslSAbs;
|
||||
public readonly FuncUnaryInstruction GlslCeil;
|
||||
public readonly FuncUnaryInstruction GlslCos;
|
||||
public readonly FuncUnaryInstruction GlslExp2;
|
||||
public readonly FuncUnaryInstruction GlslFloor;
|
||||
public readonly FuncUnaryInstruction GlslLog2;
|
||||
public readonly FuncUnaryInstruction FNegate;
|
||||
public readonly FuncUnaryInstruction SNegate;
|
||||
public readonly FuncUnaryInstruction GlslInverseSqrt;
|
||||
public readonly FuncUnaryInstruction GlslRoundEven;
|
||||
public readonly FuncUnaryInstruction GlslSin;
|
||||
public readonly FuncUnaryInstruction GlslSqrt;
|
||||
public readonly FuncUnaryInstruction GlslTrunc;
|
||||
|
||||
// UnaryBool
|
||||
public readonly FuncUnaryInstruction LogicalNot;
|
||||
|
||||
// UnaryFP32
|
||||
public readonly FuncUnaryInstruction DPdx;
|
||||
public readonly FuncUnaryInstruction DPdy;
|
||||
|
||||
// UnaryS32
|
||||
public readonly FuncUnaryInstruction BitCount;
|
||||
public readonly FuncUnaryInstruction BitReverse;
|
||||
public readonly FuncUnaryInstruction Not;
|
||||
|
||||
// Compare
|
||||
public readonly FuncBinaryInstruction FOrdEqual;
|
||||
public readonly FuncBinaryInstruction IEqual;
|
||||
public readonly FuncBinaryInstruction FOrdGreaterThan;
|
||||
public readonly FuncBinaryInstruction SGreaterThan;
|
||||
public readonly FuncBinaryInstruction FOrdGreaterThanEqual;
|
||||
public readonly FuncBinaryInstruction SGreaterThanEqual;
|
||||
public readonly FuncBinaryInstruction FOrdLessThan;
|
||||
public readonly FuncBinaryInstruction SLessThan;
|
||||
public readonly FuncBinaryInstruction FOrdLessThanEqual;
|
||||
public readonly FuncBinaryInstruction SLessThanEqual;
|
||||
public readonly FuncBinaryInstruction FOrdNotEqual;
|
||||
public readonly FuncBinaryInstruction INotEqual;
|
||||
|
||||
// CompareU32
|
||||
public readonly FuncBinaryInstruction UGreaterThanEqual;
|
||||
public readonly FuncBinaryInstruction UGreaterThan;
|
||||
public readonly FuncBinaryInstruction ULessThanEqual;
|
||||
public readonly FuncBinaryInstruction ULessThan;
|
||||
|
||||
// Binary
|
||||
public readonly FuncBinaryInstruction FAdd;
|
||||
public readonly FuncBinaryInstruction IAdd;
|
||||
public readonly FuncBinaryInstruction FDiv;
|
||||
public readonly FuncBinaryInstruction SDiv;
|
||||
public readonly FuncBinaryInstruction GlslFMax;
|
||||
public readonly FuncBinaryInstruction GlslSMax;
|
||||
public readonly FuncBinaryInstruction GlslFMin;
|
||||
public readonly FuncBinaryInstruction GlslSMin;
|
||||
public readonly FuncBinaryInstruction FMod;
|
||||
public readonly FuncBinaryInstruction FMul;
|
||||
public readonly FuncBinaryInstruction IMul;
|
||||
public readonly FuncBinaryInstruction FSub;
|
||||
public readonly FuncBinaryInstruction ISub;
|
||||
|
||||
// BinaryBool
|
||||
public readonly FuncBinaryInstruction LogicalAnd;
|
||||
public readonly FuncBinaryInstruction LogicalNotEqual;
|
||||
public readonly FuncBinaryInstruction LogicalOr;
|
||||
|
||||
// BinaryS32
|
||||
public readonly FuncBinaryInstruction BitwiseAnd;
|
||||
public readonly FuncBinaryInstruction BitwiseXor;
|
||||
public readonly FuncBinaryInstruction BitwiseOr;
|
||||
public readonly FuncBinaryInstruction ShiftLeftLogical;
|
||||
public readonly FuncBinaryInstruction ShiftRightArithmetic;
|
||||
public readonly FuncBinaryInstruction ShiftRightLogical;
|
||||
|
||||
// BinaryU32
|
||||
public readonly FuncBinaryInstruction GlslUMax;
|
||||
public readonly FuncBinaryInstruction GlslUMin;
|
||||
|
||||
// AtomicMemoryBinary
|
||||
public readonly FuncQuaternaryInstruction AtomicIAdd;
|
||||
public readonly FuncQuaternaryInstruction AtomicAnd;
|
||||
public readonly FuncQuaternaryInstruction AtomicSMin;
|
||||
public readonly FuncQuaternaryInstruction AtomicUMin;
|
||||
public readonly FuncQuaternaryInstruction AtomicSMax;
|
||||
public readonly FuncQuaternaryInstruction AtomicUMax;
|
||||
public readonly FuncQuaternaryInstruction AtomicOr;
|
||||
public readonly FuncQuaternaryInstruction AtomicExchange;
|
||||
public readonly FuncQuaternaryInstruction AtomicXor;
|
||||
|
||||
// Ternary
|
||||
public readonly FuncTernaryInstruction GlslFClamp;
|
||||
public readonly FuncTernaryInstruction GlslSClamp;
|
||||
public readonly FuncTernaryInstruction GlslFma;
|
||||
|
||||
// TernaryS32
|
||||
public readonly FuncTernaryInstruction BitFieldSExtract;
|
||||
public readonly FuncTernaryInstruction BitFieldUExtract;
|
||||
|
||||
// TernaryU32
|
||||
public readonly FuncTernaryInstruction GlslUClamp;
|
||||
|
||||
// QuaternaryS32
|
||||
public readonly FuncQuaternaryInstruction BitFieldInsert;
|
||||
|
||||
public SpirvDelegates(CodeGenContext context)
|
||||
{
|
||||
// Unary
|
||||
GlslFAbs = context.GlslFAbs;
|
||||
GlslSAbs = context.GlslSAbs;
|
||||
GlslCeil = context.GlslCeil;
|
||||
GlslCos = context.GlslCos;
|
||||
GlslExp2 = context.GlslExp2;
|
||||
GlslFloor = context.GlslFloor;
|
||||
GlslLog2 = context.GlslLog2;
|
||||
FNegate = context.FNegate;
|
||||
SNegate = context.SNegate;
|
||||
GlslInverseSqrt = context.GlslInverseSqrt;
|
||||
GlslRoundEven = context.GlslRoundEven;
|
||||
GlslSin = context.GlslSin;
|
||||
GlslSqrt = context.GlslSqrt;
|
||||
GlslTrunc = context.GlslTrunc;
|
||||
|
||||
// UnaryBool
|
||||
LogicalNot = context.LogicalNot;
|
||||
|
||||
// UnaryFP32
|
||||
DPdx = context.DPdx;
|
||||
DPdy = context.DPdy;
|
||||
|
||||
// UnaryS32
|
||||
BitCount = context.BitCount;
|
||||
BitReverse = context.BitReverse;
|
||||
Not = context.Not;
|
||||
|
||||
// Compare
|
||||
FOrdEqual = context.FOrdEqual;
|
||||
IEqual = context.IEqual;
|
||||
FOrdGreaterThan = context.FOrdGreaterThan;
|
||||
SGreaterThan = context.SGreaterThan;
|
||||
FOrdGreaterThanEqual = context.FOrdGreaterThanEqual;
|
||||
SGreaterThanEqual = context.SGreaterThanEqual;
|
||||
FOrdLessThan = context.FOrdLessThan;
|
||||
SLessThan = context.SLessThan;
|
||||
FOrdLessThanEqual = context.FOrdLessThanEqual;
|
||||
SLessThanEqual = context.SLessThanEqual;
|
||||
FOrdNotEqual = context.FOrdNotEqual;
|
||||
INotEqual = context.INotEqual;
|
||||
|
||||
// CompareU32
|
||||
UGreaterThanEqual = context.UGreaterThanEqual;
|
||||
UGreaterThan = context.UGreaterThan;
|
||||
ULessThanEqual = context.ULessThanEqual;
|
||||
ULessThan = context.ULessThan;
|
||||
|
||||
// Binary
|
||||
FAdd = context.FAdd;
|
||||
IAdd = context.IAdd;
|
||||
FDiv = context.FDiv;
|
||||
SDiv = context.SDiv;
|
||||
GlslFMax = context.GlslFMax;
|
||||
GlslSMax = context.GlslSMax;
|
||||
GlslFMin = context.GlslFMin;
|
||||
GlslSMin = context.GlslSMin;
|
||||
FMod = context.FMod;
|
||||
FMul = context.FMul;
|
||||
IMul = context.IMul;
|
||||
FSub = context.FSub;
|
||||
ISub = context.ISub;
|
||||
|
||||
// BinaryBool
|
||||
LogicalAnd = context.LogicalAnd;
|
||||
LogicalNotEqual = context.LogicalNotEqual;
|
||||
LogicalOr = context.LogicalOr;
|
||||
|
||||
// BinaryS32
|
||||
BitwiseAnd = context.BitwiseAnd;
|
||||
BitwiseXor = context.BitwiseXor;
|
||||
BitwiseOr = context.BitwiseOr;
|
||||
ShiftLeftLogical = context.ShiftLeftLogical;
|
||||
ShiftRightArithmetic = context.ShiftRightArithmetic;
|
||||
ShiftRightLogical = context.ShiftRightLogical;
|
||||
|
||||
// BinaryU32
|
||||
GlslUMax = context.GlslUMax;
|
||||
GlslUMin = context.GlslUMin;
|
||||
|
||||
// AtomicMemoryBinary
|
||||
AtomicIAdd = context.AtomicIAdd;
|
||||
AtomicAnd = context.AtomicAnd;
|
||||
AtomicSMin = context.AtomicSMin;
|
||||
AtomicUMin = context.AtomicUMin;
|
||||
AtomicSMax = context.AtomicSMax;
|
||||
AtomicUMax = context.AtomicUMax;
|
||||
AtomicOr = context.AtomicOr;
|
||||
AtomicExchange = context.AtomicExchange;
|
||||
AtomicXor = context.AtomicXor;
|
||||
|
||||
// Ternary
|
||||
GlslFClamp = context.GlslFClamp;
|
||||
GlslSClamp = context.GlslSClamp;
|
||||
GlslFma = context.GlslFma;
|
||||
|
||||
// TernaryS32
|
||||
BitFieldSExtract = context.BitFieldSExtract;
|
||||
BitFieldUExtract = context.BitFieldUExtract;
|
||||
|
||||
// TernaryU32
|
||||
GlslUClamp = context.GlslUClamp;
|
||||
|
||||
// QuaternaryS32
|
||||
BitFieldInsert = context.BitFieldInsert;
|
||||
}
|
||||
}
|
||||
}
|
||||
425
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs
vendored
Normal file
425
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs
vendored
Normal file
@@ -0,0 +1,425 @@
|
||||
using Ryujinx.Common;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using static Spv.Specification;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
|
||||
{
|
||||
using SpvInstruction = Spv.Generator.Instruction;
|
||||
using SpvInstructionPool = Spv.Generator.GeneratorPool<Spv.Generator.Instruction>;
|
||||
using SpvLiteralInteger = Spv.Generator.LiteralInteger;
|
||||
using SpvLiteralIntegerPool = Spv.Generator.GeneratorPool<Spv.Generator.LiteralInteger>;
|
||||
|
||||
static class SpirvGenerator
|
||||
{
|
||||
// Resource pools for Spirv generation. Note: Increase count when more threads are being used.
|
||||
private const int GeneratorPoolCount = 1;
|
||||
private static readonly ObjectPool<SpvInstructionPool> _instructionPool;
|
||||
private static readonly ObjectPool<SpvLiteralIntegerPool> _integerPool;
|
||||
private static readonly Lock _poolLock = new();
|
||||
|
||||
static SpirvGenerator()
|
||||
{
|
||||
_instructionPool = new(() => new SpvInstructionPool(), GeneratorPoolCount);
|
||||
_integerPool = new(() => new SpvLiteralIntegerPool(), GeneratorPoolCount);
|
||||
}
|
||||
|
||||
private const HelperFunctionsMask NeedsInvocationIdMask = HelperFunctionsMask.SwizzleAdd;
|
||||
|
||||
public static byte[] Generate(StructuredProgramInfo info, CodeGenParameters parameters)
|
||||
{
|
||||
SpvInstructionPool instPool;
|
||||
SpvLiteralIntegerPool integerPool;
|
||||
|
||||
lock (_poolLock)
|
||||
{
|
||||
instPool = _instructionPool.Allocate();
|
||||
integerPool = _integerPool.Allocate();
|
||||
}
|
||||
|
||||
CodeGenContext context = new(info, parameters, instPool, integerPool);
|
||||
|
||||
context.AddCapability(Capability.Shader);
|
||||
|
||||
context.SetMemoryModel(AddressingModel.Logical, MemoryModel.GLSL450);
|
||||
|
||||
context.AddCapability(Capability.GroupNonUniformBallot);
|
||||
context.AddCapability(Capability.GroupNonUniformShuffle);
|
||||
context.AddCapability(Capability.GroupNonUniformVote);
|
||||
context.AddCapability(Capability.ImageBuffer);
|
||||
context.AddCapability(Capability.ImageGatherExtended);
|
||||
context.AddCapability(Capability.ImageQuery);
|
||||
context.AddCapability(Capability.SampledBuffer);
|
||||
|
||||
if (parameters.HostCapabilities.SupportsShaderFloat64)
|
||||
{
|
||||
context.AddCapability(Capability.Float64);
|
||||
}
|
||||
|
||||
if (parameters.Definitions.TransformFeedbackEnabled && parameters.Definitions.LastInVertexPipeline)
|
||||
{
|
||||
context.AddCapability(Capability.TransformFeedback);
|
||||
}
|
||||
|
||||
if (parameters.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Input, IoVariable.Layer)) ||
|
||||
context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Input, IoVariable.PrimitiveId)))
|
||||
{
|
||||
context.AddCapability(Capability.Geometry);
|
||||
}
|
||||
|
||||
if (context.HostCapabilities.SupportsFragmentShaderInterlock)
|
||||
{
|
||||
context.AddCapability(Capability.FragmentShaderPixelInterlockEXT);
|
||||
context.AddExtension("SPV_EXT_fragment_shader_interlock");
|
||||
}
|
||||
}
|
||||
else if (parameters.Definitions.Stage == ShaderStage.Geometry)
|
||||
{
|
||||
context.AddCapability(Capability.Geometry);
|
||||
|
||||
if (parameters.Definitions.GpPassthrough && context.HostCapabilities.SupportsGeometryShaderPassthrough)
|
||||
{
|
||||
context.AddExtension("SPV_NV_geometry_shader_passthrough");
|
||||
context.AddCapability(Capability.GeometryShaderPassthroughNV);
|
||||
}
|
||||
}
|
||||
else if (parameters.Definitions.Stage is ShaderStage.TessellationControl or
|
||||
ShaderStage.TessellationEvaluation)
|
||||
{
|
||||
context.AddCapability(Capability.Tessellation);
|
||||
}
|
||||
else if (parameters.Definitions.Stage == ShaderStage.Vertex)
|
||||
{
|
||||
context.AddCapability(Capability.DrawParameters);
|
||||
}
|
||||
|
||||
if (context.Definitions.Stage != ShaderStage.Fragment &&
|
||||
context.Definitions.Stage != ShaderStage.Geometry &&
|
||||
context.Definitions.Stage != ShaderStage.Compute &&
|
||||
(context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.Layer)) ||
|
||||
context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.ViewportIndex))))
|
||||
{
|
||||
context.AddExtension("SPV_EXT_shader_viewport_index_layer");
|
||||
context.AddCapability(Capability.ShaderViewportIndexLayerEXT);
|
||||
}
|
||||
|
||||
if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.ViewportMask)))
|
||||
{
|
||||
context.AddExtension("SPV_NV_viewport_array2");
|
||||
context.AddCapability(Capability.ShaderViewportMaskNV);
|
||||
}
|
||||
|
||||
if ((info.HelperFunctionsMask & NeedsInvocationIdMask) != 0)
|
||||
{
|
||||
info.IoDefinitions.Add(new IoDefinition(StorageKind.Input, IoVariable.SubgroupLaneId));
|
||||
}
|
||||
|
||||
Declarations.DeclareAll(context, info);
|
||||
|
||||
for (int funcIndex = 0; funcIndex < info.Functions.Count; funcIndex++)
|
||||
{
|
||||
StructuredFunction function = info.Functions[funcIndex];
|
||||
SpvInstruction retType = context.GetType(function.ReturnType);
|
||||
|
||||
SpvInstruction[] funcArgs = new SpvInstruction[function.InArguments.Length + function.OutArguments.Length];
|
||||
|
||||
for (int argIndex = 0; argIndex < funcArgs.Length; argIndex++)
|
||||
{
|
||||
SpvInstruction argType = context.GetType(function.GetArgumentType(argIndex));
|
||||
SpvInstruction argPointerType = context.TypePointer(StorageClass.Function, argType);
|
||||
funcArgs[argIndex] = argPointerType;
|
||||
}
|
||||
|
||||
SpvInstruction funcType = context.TypeFunction(retType, false, funcArgs);
|
||||
SpvInstruction spvFunc = context.Function(retType, FunctionControlMask.MaskNone, funcType);
|
||||
|
||||
context.DeclareFunction(funcIndex, function, spvFunc);
|
||||
}
|
||||
|
||||
for (int funcIndex = 0; funcIndex < info.Functions.Count; funcIndex++)
|
||||
{
|
||||
Generate(context, info, funcIndex);
|
||||
}
|
||||
|
||||
byte[] result = context.Generate();
|
||||
|
||||
lock (_poolLock)
|
||||
{
|
||||
_instructionPool.Release(instPool);
|
||||
_integerPool.Release(integerPool);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private static void Generate(CodeGenContext context, StructuredProgramInfo info, int funcIndex)
|
||||
{
|
||||
(StructuredFunction function, SpvInstruction spvFunc) = context.GetFunction(funcIndex);
|
||||
|
||||
context.CurrentFunction = function;
|
||||
context.AddFunction(spvFunc);
|
||||
context.StartFunction(isMainFunction: funcIndex == 0);
|
||||
|
||||
Declarations.DeclareParameters(context, function);
|
||||
|
||||
context.EnterBlock(function.MainBlock);
|
||||
|
||||
Declarations.DeclareLocals(context, function);
|
||||
|
||||
Generate(context, function.MainBlock);
|
||||
|
||||
// Functions must always end with a return.
|
||||
if (function.MainBlock.Last is not AstOperation operation ||
|
||||
(operation.Inst != Instruction.Return && operation.Inst != Instruction.Discard))
|
||||
{
|
||||
context.Return();
|
||||
}
|
||||
|
||||
context.FunctionEnd();
|
||||
|
||||
if (funcIndex == 0)
|
||||
{
|
||||
context.AddEntryPoint(context.Definitions.Stage.Convert(), spvFunc, "main", context.GetMainInterface());
|
||||
|
||||
if (context.Definitions.Stage == ShaderStage.TessellationControl)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.OutputVertices, (SpvLiteralInteger)context.Definitions.ThreadsPerInputPrimitive);
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.TessellationEvaluation)
|
||||
{
|
||||
switch (context.Definitions.TessPatchType)
|
||||
{
|
||||
case TessPatchType.Isolines:
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.Isolines);
|
||||
break;
|
||||
case TessPatchType.Triangles:
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.Triangles);
|
||||
break;
|
||||
case TessPatchType.Quads:
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.Quads);
|
||||
break;
|
||||
}
|
||||
|
||||
switch (context.Definitions.TessSpacing)
|
||||
{
|
||||
case TessSpacing.EqualSpacing:
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.SpacingEqual);
|
||||
break;
|
||||
case TessSpacing.FractionalEventSpacing:
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.SpacingFractionalEven);
|
||||
break;
|
||||
case TessSpacing.FractionalOddSpacing:
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.SpacingFractionalOdd);
|
||||
break;
|
||||
}
|
||||
|
||||
bool tessCw = context.Definitions.TessCw;
|
||||
|
||||
if (context.TargetApi == TargetApi.Vulkan)
|
||||
{
|
||||
// We invert the front face on Vulkan backend, so we need to do that here as well.
|
||||
tessCw = !tessCw;
|
||||
}
|
||||
|
||||
if (tessCw)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.VertexOrderCw);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.VertexOrderCcw);
|
||||
}
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.Geometry)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, context.Definitions.InputTopology switch
|
||||
{
|
||||
InputTopology.Points => ExecutionMode.InputPoints,
|
||||
InputTopology.Lines => ExecutionMode.InputLines,
|
||||
InputTopology.LinesAdjacency => ExecutionMode.InputLinesAdjacency,
|
||||
InputTopology.Triangles => ExecutionMode.Triangles,
|
||||
InputTopology.TrianglesAdjacency => ExecutionMode.InputTrianglesAdjacency,
|
||||
_ => throw new InvalidOperationException($"Invalid input topology \"{context.Definitions.InputTopology}\"."),
|
||||
});
|
||||
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.Invocations, (SpvLiteralInteger)context.Definitions.ThreadsPerInputPrimitive);
|
||||
|
||||
context.AddExecutionMode(spvFunc, context.Definitions.OutputTopology switch
|
||||
{
|
||||
OutputTopology.PointList => ExecutionMode.OutputPoints,
|
||||
OutputTopology.LineStrip => ExecutionMode.OutputLineStrip,
|
||||
OutputTopology.TriangleStrip => ExecutionMode.OutputTriangleStrip,
|
||||
_ => throw new InvalidOperationException($"Invalid output topology \"{context.Definitions.OutputTopology}\"."),
|
||||
});
|
||||
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.OutputVertices, (SpvLiteralInteger)context.Definitions.MaxOutputVertices);
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, context.Definitions.OriginUpperLeft
|
||||
? ExecutionMode.OriginUpperLeft
|
||||
: ExecutionMode.OriginLowerLeft);
|
||||
|
||||
if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.FragmentOutputDepth)))
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.DepthReplacing);
|
||||
}
|
||||
|
||||
if (context.Definitions.EarlyZForce)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.EarlyFragmentTests);
|
||||
}
|
||||
|
||||
if ((info.HelperFunctionsMask & HelperFunctionsMask.FSI) != 0 &&
|
||||
context.HostCapabilities.SupportsFragmentShaderInterlock)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.PixelInterlockOrderedEXT);
|
||||
}
|
||||
}
|
||||
else if (context.Definitions.Stage == ShaderStage.Compute)
|
||||
{
|
||||
SpvLiteralInteger localSizeX = (SpvLiteralInteger)context.Definitions.ComputeLocalSizeX;
|
||||
SpvLiteralInteger localSizeY = (SpvLiteralInteger)context.Definitions.ComputeLocalSizeY;
|
||||
SpvLiteralInteger localSizeZ = (SpvLiteralInteger)context.Definitions.ComputeLocalSizeZ;
|
||||
|
||||
context.AddExecutionMode(
|
||||
spvFunc,
|
||||
ExecutionMode.LocalSize,
|
||||
localSizeX,
|
||||
localSizeY,
|
||||
localSizeZ);
|
||||
}
|
||||
|
||||
if (context.Definitions.TransformFeedbackEnabled && context.Definitions.LastInVertexPipeline)
|
||||
{
|
||||
context.AddExecutionMode(spvFunc, ExecutionMode.Xfb);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void Generate(CodeGenContext context, AstBlock block)
|
||||
{
|
||||
AstBlockVisitor visitor = new(block);
|
||||
|
||||
Dictionary<AstBlock, (SpvInstruction, SpvInstruction)> loopTargets = new();
|
||||
|
||||
context.LoopTargets = loopTargets;
|
||||
|
||||
visitor.BlockEntered += (sender, e) =>
|
||||
{
|
||||
AstBlock mergeBlock = e.Block.Parent;
|
||||
|
||||
if (e.Block.Type == AstBlockType.If)
|
||||
{
|
||||
AstBlock ifTrueBlock = e.Block;
|
||||
AstBlock ifFalseBlock;
|
||||
|
||||
if (AstHelper.Next(e.Block) is AstBlock nextBlock && nextBlock.Type == AstBlockType.Else)
|
||||
{
|
||||
ifFalseBlock = nextBlock;
|
||||
}
|
||||
else
|
||||
{
|
||||
ifFalseBlock = mergeBlock;
|
||||
}
|
||||
|
||||
SpvInstruction condition = context.Get(AggregateType.Bool, e.Block.Condition);
|
||||
|
||||
context.SelectionMerge(context.GetNextLabel(mergeBlock), SelectionControlMask.MaskNone);
|
||||
context.BranchConditional(condition, context.GetNextLabel(ifTrueBlock), context.GetNextLabel(ifFalseBlock));
|
||||
}
|
||||
else if (e.Block.Type == AstBlockType.DoWhile)
|
||||
{
|
||||
SpvInstruction continueTarget = context.Label();
|
||||
|
||||
loopTargets.Add(e.Block, (context.NewBlock(), continueTarget));
|
||||
|
||||
context.LoopMerge(context.GetNextLabel(mergeBlock), continueTarget, LoopControlMask.MaskNone);
|
||||
context.Branch(context.GetFirstLabel(e.Block));
|
||||
}
|
||||
|
||||
context.EnterBlock(e.Block);
|
||||
};
|
||||
|
||||
visitor.BlockLeft += (sender, e) =>
|
||||
{
|
||||
if (e.Block.Parent != null)
|
||||
{
|
||||
if (e.Block.Type == AstBlockType.DoWhile)
|
||||
{
|
||||
// This is a loop, we need to jump back to the loop header
|
||||
// if the condition is true.
|
||||
AstBlock mergeBlock = e.Block.Parent;
|
||||
|
||||
(SpvInstruction loopTarget, SpvInstruction continueTarget) = loopTargets[e.Block];
|
||||
|
||||
context.Branch(continueTarget);
|
||||
context.AddLabel(continueTarget);
|
||||
|
||||
SpvInstruction condition = context.Get(AggregateType.Bool, e.Block.Condition);
|
||||
|
||||
context.BranchConditional(condition, loopTarget, context.GetNextLabel(mergeBlock));
|
||||
}
|
||||
else
|
||||
{
|
||||
// We only need a branch if the last instruction didn't
|
||||
// already cause the program to exit or jump elsewhere.
|
||||
bool lastIsCf = e.Block.Last is AstOperation lastOp &&
|
||||
(lastOp.Inst == Instruction.Discard ||
|
||||
lastOp.Inst == Instruction.LoopBreak ||
|
||||
lastOp.Inst == Instruction.LoopContinue ||
|
||||
lastOp.Inst == Instruction.Return);
|
||||
|
||||
if (!lastIsCf)
|
||||
{
|
||||
context.Branch(context.GetNextLabel(e.Block.Parent));
|
||||
}
|
||||
}
|
||||
|
||||
bool hasElse = AstHelper.Next(e.Block) is AstBlock nextBlock &&
|
||||
(nextBlock.Type == AstBlockType.Else ||
|
||||
nextBlock.Type == AstBlockType.ElseIf);
|
||||
|
||||
// Re-enter the parent block.
|
||||
if (e.Block.Parent != null && !hasElse)
|
||||
{
|
||||
context.EnterBlock(e.Block.Parent);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
foreach (IAstNode node in visitor.Visit())
|
||||
{
|
||||
if (node is AstAssignment assignment)
|
||||
{
|
||||
AstOperand dest = (AstOperand)assignment.Destination;
|
||||
|
||||
if (dest.Type == OperandType.LocalVariable)
|
||||
{
|
||||
SpvInstruction source = context.Get(dest.VarType, assignment.Source);
|
||||
context.Store(context.GetLocalPointer(dest), source);
|
||||
}
|
||||
else if (dest.Type == OperandType.Argument)
|
||||
{
|
||||
SpvInstruction source = context.Get(dest.VarType, assignment.Source);
|
||||
context.Store(context.GetArgumentPointer(dest), source);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new NotImplementedException(dest.Type.ToString());
|
||||
}
|
||||
}
|
||||
else if (node is AstOperation operation)
|
||||
{
|
||||
Instructions.Generate(context, operation);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
14
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Constants.cs
vendored
Normal file
14
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Constants.cs
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
static class Constants
|
||||
{
|
||||
public const int ConstantBufferSize = 0x10000; // In bytes
|
||||
|
||||
public const int MaxAttributes = 16;
|
||||
public const int AllAttributesMask = (int)(uint.MaxValue >> (32 - MaxAttributes));
|
||||
|
||||
public const int NvnBaseVertexByteOffset = 0x640;
|
||||
public const int NvnBaseInstanceByteOffset = 0x644;
|
||||
public const int NvnDrawIndexByteOffset = 0x648;
|
||||
}
|
||||
}
|
||||
168
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/Block.cs
vendored
Normal file
168
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/Block.cs
vendored
Normal file
@@ -0,0 +1,168 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
class PushOpInfo
|
||||
{
|
||||
public InstOp Op { get; }
|
||||
public Dictionary<Block, Operand> Consumers;
|
||||
|
||||
public PushOpInfo(InstOp op)
|
||||
{
|
||||
Op = op;
|
||||
Consumers = new Dictionary<Block, Operand>();
|
||||
}
|
||||
}
|
||||
|
||||
readonly struct SyncTarget
|
||||
{
|
||||
public PushOpInfo PushOpInfo { get; }
|
||||
public int PushOpId { get; }
|
||||
|
||||
public SyncTarget(PushOpInfo pushOpInfo, int pushOpId)
|
||||
{
|
||||
PushOpInfo = pushOpInfo;
|
||||
PushOpId = pushOpId;
|
||||
}
|
||||
}
|
||||
|
||||
class Block
|
||||
{
|
||||
public ulong Address { get; set; }
|
||||
public ulong EndAddress { get; set; }
|
||||
|
||||
public List<Block> Predecessors { get; }
|
||||
public List<Block> Successors { get; }
|
||||
|
||||
public List<InstOp> OpCodes { get; }
|
||||
public List<PushOpInfo> PushOpCodes { get; }
|
||||
public Dictionary<ulong, SyncTarget> SyncTargets { get; }
|
||||
|
||||
public Block(ulong address)
|
||||
{
|
||||
Address = address;
|
||||
|
||||
Predecessors = [];
|
||||
Successors = [];
|
||||
|
||||
OpCodes = [];
|
||||
PushOpCodes = [];
|
||||
SyncTargets = new Dictionary<ulong, SyncTarget>();
|
||||
}
|
||||
|
||||
public void Split(Block rightBlock)
|
||||
{
|
||||
int splitIndex = BinarySearch(OpCodes, rightBlock.Address);
|
||||
|
||||
if (OpCodes[splitIndex].Address < rightBlock.Address)
|
||||
{
|
||||
splitIndex++;
|
||||
}
|
||||
|
||||
int splitCount = OpCodes.Count - splitIndex;
|
||||
if (splitCount <= 0)
|
||||
{
|
||||
throw new ArgumentException("Can't split at right block address.");
|
||||
}
|
||||
|
||||
rightBlock.EndAddress = EndAddress;
|
||||
rightBlock.Successors.AddRange(Successors);
|
||||
rightBlock.Predecessors.Add(this);
|
||||
|
||||
EndAddress = rightBlock.Address;
|
||||
|
||||
Successors.Clear();
|
||||
Successors.Add(rightBlock);
|
||||
|
||||
// Move ops.
|
||||
rightBlock.OpCodes.AddRange(OpCodes.GetRange(splitIndex, splitCount));
|
||||
|
||||
OpCodes.RemoveRange(splitIndex, splitCount);
|
||||
|
||||
// Update push consumers that points to this block.
|
||||
foreach (SyncTarget syncTarget in SyncTargets.Values)
|
||||
{
|
||||
PushOpInfo pushOpInfo = syncTarget.PushOpInfo;
|
||||
|
||||
Operand local = pushOpInfo.Consumers[this];
|
||||
pushOpInfo.Consumers.Remove(this);
|
||||
pushOpInfo.Consumers.Add(rightBlock, local);
|
||||
}
|
||||
|
||||
foreach ((ulong key, SyncTarget value) in SyncTargets)
|
||||
{
|
||||
rightBlock.SyncTargets.Add(key, value);
|
||||
}
|
||||
|
||||
SyncTargets.Clear();
|
||||
|
||||
// Move push ops.
|
||||
for (int i = 0; i < PushOpCodes.Count; i++)
|
||||
{
|
||||
if (PushOpCodes[i].Op.Address >= rightBlock.Address)
|
||||
{
|
||||
int count = PushOpCodes.Count - i;
|
||||
rightBlock.PushOpCodes.AddRange(PushOpCodes.Skip(i));
|
||||
PushOpCodes.RemoveRange(i, count);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static int BinarySearch(List<InstOp> opCodes, ulong address)
|
||||
{
|
||||
int left = 0;
|
||||
int middle = 0;
|
||||
int right = opCodes.Count - 1;
|
||||
|
||||
while (left <= right)
|
||||
{
|
||||
int size = right - left;
|
||||
|
||||
middle = left + (size >> 1);
|
||||
|
||||
InstOp opCode = opCodes[middle];
|
||||
|
||||
if (address == opCode.Address)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (address < opCode.Address)
|
||||
{
|
||||
right = middle - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
left = middle + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return middle;
|
||||
}
|
||||
|
||||
public InstOp GetLastOp()
|
||||
{
|
||||
if (OpCodes.Count != 0)
|
||||
{
|
||||
return OpCodes[^1];
|
||||
}
|
||||
|
||||
return default;
|
||||
}
|
||||
|
||||
public bool HasNext()
|
||||
{
|
||||
InstOp lastOp = GetLastOp();
|
||||
return OpCodes.Count != 0 && !Decoder.IsUnconditionalBranch(ref lastOp);
|
||||
}
|
||||
|
||||
public void AddPushOp(InstOp op)
|
||||
{
|
||||
PushOpCodes.Add(new PushOpInfo(op));
|
||||
}
|
||||
}
|
||||
}
|
||||
48
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/DecodedFunction.cs
vendored
Normal file
48
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/DecodedFunction.cs
vendored
Normal file
@@ -0,0 +1,48 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
class DecodedFunction
|
||||
{
|
||||
private readonly HashSet<DecodedFunction> _callers;
|
||||
|
||||
public bool IsCompilerGenerated => Type != FunctionType.User;
|
||||
public FunctionType Type { get; set; }
|
||||
public int Id { get; set; }
|
||||
|
||||
public ulong Address { get; }
|
||||
public Block[] Blocks { get; private set; }
|
||||
|
||||
public DecodedFunction(ulong address)
|
||||
{
|
||||
Address = address;
|
||||
_callers = [];
|
||||
Type = FunctionType.User;
|
||||
Id = -1;
|
||||
}
|
||||
|
||||
public void SetBlocks(Block[] blocks)
|
||||
{
|
||||
if (Blocks != null)
|
||||
{
|
||||
throw new InvalidOperationException("Blocks have already been set.");
|
||||
}
|
||||
|
||||
Blocks = blocks;
|
||||
}
|
||||
|
||||
public void AddCaller(DecodedFunction caller)
|
||||
{
|
||||
_callers.Add(caller);
|
||||
}
|
||||
|
||||
public void RemoveCaller(DecodedFunction caller)
|
||||
{
|
||||
if (_callers.Remove(caller) && _callers.Count == 0)
|
||||
{
|
||||
Type = FunctionType.Unused;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
78
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/DecodedProgram.cs
vendored
Normal file
78
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/DecodedProgram.cs
vendored
Normal file
@@ -0,0 +1,78 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
readonly struct DecodedProgram : IEnumerable<DecodedFunction>
|
||||
{
|
||||
public DecodedFunction MainFunction { get; }
|
||||
private readonly IReadOnlyDictionary<ulong, DecodedFunction> _functions;
|
||||
private readonly List<DecodedFunction> _functionsWithId;
|
||||
public int FunctionsWithIdCount => _functionsWithId.Count;
|
||||
|
||||
public AttributeUsage AttributeUsage { get; }
|
||||
public FeatureFlags UsedFeatures { get; }
|
||||
public byte ClipDistancesWritten { get; }
|
||||
public int Cb1DataSize { get; }
|
||||
|
||||
public DecodedProgram(
|
||||
DecodedFunction mainFunction,
|
||||
IReadOnlyDictionary<ulong, DecodedFunction> functions,
|
||||
AttributeUsage attributeUsage,
|
||||
FeatureFlags usedFeatures,
|
||||
byte clipDistancesWritten,
|
||||
int cb1DataSize)
|
||||
{
|
||||
MainFunction = mainFunction;
|
||||
_functions = functions;
|
||||
_functionsWithId = [];
|
||||
AttributeUsage = attributeUsage;
|
||||
UsedFeatures = usedFeatures;
|
||||
ClipDistancesWritten = clipDistancesWritten;
|
||||
Cb1DataSize = cb1DataSize;
|
||||
}
|
||||
|
||||
public DecodedFunction GetFunctionByAddress(ulong address)
|
||||
{
|
||||
if (_functions.TryGetValue(address, out DecodedFunction function))
|
||||
{
|
||||
return function;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public DecodedFunction GetFunctionById(int id)
|
||||
{
|
||||
if ((uint)id >= (uint)_functionsWithId.Count)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException(nameof(id));
|
||||
}
|
||||
|
||||
return _functionsWithId[id];
|
||||
}
|
||||
|
||||
public void AddFunctionAndSetId(DecodedFunction function)
|
||||
{
|
||||
function.Id = _functionsWithId.Count;
|
||||
_functionsWithId.Add(function);
|
||||
}
|
||||
|
||||
public IoUsage GetIoUsage()
|
||||
{
|
||||
return new IoUsage(UsedFeatures, ClipDistancesWritten, AttributeUsage.UsedOutputAttributes);
|
||||
}
|
||||
|
||||
public IEnumerator<DecodedFunction> GetEnumerator()
|
||||
{
|
||||
return _functions.Values.GetEnumerator();
|
||||
}
|
||||
|
||||
IEnumerator IEnumerable.GetEnumerator()
|
||||
{
|
||||
return GetEnumerator();
|
||||
}
|
||||
}
|
||||
}
|
||||
911
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/Decoder.cs
vendored
Normal file
911
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/Decoder.cs
vendored
Normal file
@@ -0,0 +1,911 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
static class Decoder
|
||||
{
|
||||
private class Context
|
||||
{
|
||||
public AttributeUsage AttributeUsage { get; }
|
||||
public FeatureFlags UsedFeatures { get; private set; }
|
||||
public byte ClipDistancesWritten { get; private set; }
|
||||
public int Cb1DataSize { get; private set; }
|
||||
|
||||
private readonly IGpuAccessor _gpuAccessor;
|
||||
|
||||
public Context(IGpuAccessor gpuAccessor)
|
||||
{
|
||||
_gpuAccessor = gpuAccessor;
|
||||
AttributeUsage = new(gpuAccessor);
|
||||
}
|
||||
|
||||
public uint ConstantBuffer1Read(int offset)
|
||||
{
|
||||
if (Cb1DataSize < offset + 4)
|
||||
{
|
||||
Cb1DataSize = offset + 4;
|
||||
}
|
||||
|
||||
return _gpuAccessor.ConstantBuffer1Read(offset);
|
||||
}
|
||||
|
||||
public void SetUsedFeature(FeatureFlags flags)
|
||||
{
|
||||
UsedFeatures |= flags;
|
||||
}
|
||||
|
||||
public void SetClipDistanceWritten(int index)
|
||||
{
|
||||
ClipDistancesWritten |= (byte)(1 << index);
|
||||
}
|
||||
}
|
||||
|
||||
public static DecodedProgram Decode(ShaderDefinitions definitions, IGpuAccessor gpuAccessor, ulong startAddress)
|
||||
{
|
||||
Context context = new(gpuAccessor);
|
||||
Queue<DecodedFunction> functionsQueue = new();
|
||||
Dictionary<ulong, DecodedFunction> functionsVisited = new();
|
||||
|
||||
DecodedFunction EnqueueFunction(ulong address)
|
||||
{
|
||||
if (!functionsVisited.TryGetValue(address, out DecodedFunction function))
|
||||
{
|
||||
functionsVisited.Add(address, function = new DecodedFunction(address));
|
||||
functionsQueue.Enqueue(function);
|
||||
}
|
||||
|
||||
return function;
|
||||
}
|
||||
|
||||
DecodedFunction mainFunction = EnqueueFunction(0);
|
||||
|
||||
while (functionsQueue.TryDequeue(out DecodedFunction currentFunction))
|
||||
{
|
||||
List<Block> blocks = [];
|
||||
Queue<Block> workQueue = new();
|
||||
Dictionary<ulong, Block> visited = new();
|
||||
|
||||
Block GetBlock(ulong blkAddress)
|
||||
{
|
||||
if (!visited.TryGetValue(blkAddress, out Block block))
|
||||
{
|
||||
block = new Block(blkAddress);
|
||||
|
||||
workQueue.Enqueue(block);
|
||||
visited.Add(blkAddress, block);
|
||||
}
|
||||
|
||||
return block;
|
||||
}
|
||||
|
||||
GetBlock(currentFunction.Address);
|
||||
|
||||
bool hasNewTarget;
|
||||
|
||||
do
|
||||
{
|
||||
while (workQueue.TryDequeue(out Block currBlock))
|
||||
{
|
||||
// Check if the current block is inside another block.
|
||||
if (BinarySearch(blocks, currBlock.Address, out int nBlkIndex))
|
||||
{
|
||||
Block nBlock = blocks[nBlkIndex];
|
||||
|
||||
if (nBlock.Address == currBlock.Address)
|
||||
{
|
||||
throw new InvalidOperationException("Found duplicate block address on the list.");
|
||||
}
|
||||
|
||||
nBlock.Split(currBlock);
|
||||
blocks.Insert(nBlkIndex + 1, currBlock);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// If we have a block after the current one, set the limit address.
|
||||
ulong limitAddress = ulong.MaxValue;
|
||||
|
||||
if (nBlkIndex != blocks.Count)
|
||||
{
|
||||
Block nBlock = blocks[nBlkIndex];
|
||||
|
||||
int nextIndex = nBlkIndex + 1;
|
||||
|
||||
if (nBlock.Address < currBlock.Address && nextIndex < blocks.Count)
|
||||
{
|
||||
limitAddress = blocks[nextIndex].Address;
|
||||
}
|
||||
else if (nBlock.Address > currBlock.Address)
|
||||
{
|
||||
limitAddress = blocks[nBlkIndex].Address;
|
||||
}
|
||||
}
|
||||
|
||||
FillBlock(definitions, gpuAccessor, context, currBlock, limitAddress, startAddress);
|
||||
|
||||
if (currBlock.OpCodes.Count != 0)
|
||||
{
|
||||
// We should have blocks for all possible branch targets,
|
||||
// including those from PBK/PCNT/SSY instructions.
|
||||
foreach (PushOpInfo pushOp in currBlock.PushOpCodes)
|
||||
{
|
||||
GetBlock(pushOp.Op.GetAbsoluteAddress());
|
||||
}
|
||||
|
||||
// Set child blocks. "Branch" is the block the branch instruction
|
||||
// points to (when taken), "Next" is the block at the next address,
|
||||
// executed when the branch is not taken. For Unconditional Branches
|
||||
// or end of program, Next is null.
|
||||
InstOp lastOp = currBlock.GetLastOp();
|
||||
|
||||
if (lastOp.Name == InstName.Cal)
|
||||
{
|
||||
EnqueueFunction(lastOp.GetAbsoluteAddress()).AddCaller(currentFunction);
|
||||
}
|
||||
else if (lastOp.Name == InstName.Bra)
|
||||
{
|
||||
Block succBlock = GetBlock(lastOp.GetAbsoluteAddress());
|
||||
currBlock.Successors.Add(succBlock);
|
||||
succBlock.Predecessors.Add(currBlock);
|
||||
}
|
||||
|
||||
if (!IsUnconditionalBranch(ref lastOp))
|
||||
{
|
||||
Block succBlock = GetBlock(currBlock.EndAddress);
|
||||
currBlock.Successors.Insert(0, succBlock);
|
||||
succBlock.Predecessors.Add(currBlock);
|
||||
}
|
||||
}
|
||||
|
||||
// Insert the new block on the list (sorted by address).
|
||||
if (blocks.Count != 0)
|
||||
{
|
||||
Block nBlock = blocks[nBlkIndex];
|
||||
|
||||
blocks.Insert(nBlkIndex + (nBlock.Address < currBlock.Address ? 1 : 0), currBlock);
|
||||
}
|
||||
else
|
||||
{
|
||||
blocks.Add(currBlock);
|
||||
}
|
||||
}
|
||||
|
||||
// Propagate SSY/PBK addresses into their uses (SYNC/BRK).
|
||||
foreach (Block block in blocks.Where(x => x.PushOpCodes.Count != 0))
|
||||
{
|
||||
for (int pushOpIndex = 0; pushOpIndex < block.PushOpCodes.Count; pushOpIndex++)
|
||||
{
|
||||
PropagatePushOp(visited, block, pushOpIndex);
|
||||
}
|
||||
}
|
||||
|
||||
// Try to find targets for BRX (indirect branch) instructions.
|
||||
hasNewTarget = FindBrxTargets(context, blocks, GetBlock);
|
||||
|
||||
// If we discovered new branch targets from the BRX instruction,
|
||||
// we need another round of decoding to decode the new blocks.
|
||||
// Additionally, we may have more SSY/PBK targets to propagate,
|
||||
// and new BRX instructions.
|
||||
}
|
||||
while (hasNewTarget);
|
||||
|
||||
currentFunction.SetBlocks(blocks.ToArray());
|
||||
}
|
||||
|
||||
return new DecodedProgram(
|
||||
mainFunction,
|
||||
functionsVisited,
|
||||
context.AttributeUsage,
|
||||
context.UsedFeatures,
|
||||
context.ClipDistancesWritten,
|
||||
context.Cb1DataSize);
|
||||
}
|
||||
|
||||
private static bool BinarySearch(List<Block> blocks, ulong address, out int index)
|
||||
{
|
||||
index = 0;
|
||||
|
||||
int left = 0;
|
||||
int right = blocks.Count - 1;
|
||||
|
||||
while (left <= right)
|
||||
{
|
||||
int size = right - left;
|
||||
|
||||
int middle = left + (size >> 1);
|
||||
|
||||
Block block = blocks[middle];
|
||||
|
||||
index = middle;
|
||||
|
||||
if (address >= block.Address && address < block.EndAddress)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if (address < block.Address)
|
||||
{
|
||||
right = middle - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
left = middle + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private static void FillBlock(
|
||||
ShaderDefinitions definitions,
|
||||
IGpuAccessor gpuAccessor,
|
||||
Context context,
|
||||
Block block,
|
||||
ulong limitAddress,
|
||||
ulong startAddress)
|
||||
{
|
||||
ulong address = block.Address;
|
||||
int bufferOffset = 0;
|
||||
ReadOnlySpan<ulong> buffer = ReadOnlySpan<ulong>.Empty;
|
||||
|
||||
InstOp op = default;
|
||||
|
||||
do
|
||||
{
|
||||
if (address + 7 >= limitAddress)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// Ignore scheduling instructions, which are written every 32 bytes.
|
||||
if ((address & 0x1f) == 0)
|
||||
{
|
||||
address += 8;
|
||||
bufferOffset++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (bufferOffset >= buffer.Length)
|
||||
{
|
||||
buffer = gpuAccessor.GetCode(startAddress + address, 8);
|
||||
bufferOffset = 0;
|
||||
}
|
||||
|
||||
ulong opCode = buffer[bufferOffset++];
|
||||
|
||||
op = InstTable.GetOp(address, opCode);
|
||||
|
||||
if (op.Props.HasFlag(InstProps.TexB))
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.Bindless);
|
||||
}
|
||||
|
||||
switch (op.Name)
|
||||
{
|
||||
case InstName.Ald:
|
||||
case InstName.Ast:
|
||||
case InstName.Ipa:
|
||||
SetUserAttributeUses(definitions, context, op.Name, opCode);
|
||||
break;
|
||||
case InstName.Pbk:
|
||||
case InstName.Pcnt:
|
||||
case InstName.Ssy:
|
||||
block.AddPushOp(op);
|
||||
break;
|
||||
case InstName.Shfl:
|
||||
context.SetUsedFeature(FeatureFlags.Shuffle);
|
||||
break;
|
||||
case InstName.Ldl:
|
||||
case InstName.Stl:
|
||||
context.SetUsedFeature(FeatureFlags.LocalMemory);
|
||||
break;
|
||||
case InstName.Atoms:
|
||||
case InstName.AtomsCas:
|
||||
case InstName.Lds:
|
||||
case InstName.Sts:
|
||||
context.SetUsedFeature(FeatureFlags.SharedMemory);
|
||||
break;
|
||||
case InstName.Atom:
|
||||
case InstName.AtomCas:
|
||||
case InstName.Red:
|
||||
case InstName.Stg:
|
||||
case InstName.Suatom:
|
||||
case InstName.SuatomB:
|
||||
case InstName.SuatomB2:
|
||||
case InstName.SuatomCas:
|
||||
case InstName.SuatomCasB:
|
||||
case InstName.Sured:
|
||||
case InstName.SuredB:
|
||||
case InstName.Sust:
|
||||
case InstName.SustB:
|
||||
case InstName.SustD:
|
||||
case InstName.SustDB:
|
||||
context.SetUsedFeature(FeatureFlags.Store);
|
||||
break;
|
||||
}
|
||||
|
||||
block.OpCodes.Add(op);
|
||||
|
||||
address += 8;
|
||||
}
|
||||
while (!op.Props.HasFlag(InstProps.Bra));
|
||||
|
||||
block.EndAddress = address;
|
||||
}
|
||||
|
||||
private static void SetUserAttributeUses(ShaderDefinitions definitions, Context context, InstName name, ulong opCode)
|
||||
{
|
||||
int offset;
|
||||
int count = 1;
|
||||
bool isStore = false;
|
||||
bool indexed;
|
||||
bool perPatch = false;
|
||||
|
||||
if (name == InstName.Ast)
|
||||
{
|
||||
InstAst opAst = new(opCode);
|
||||
count = (int)opAst.AlSize + 1;
|
||||
offset = opAst.Imm11;
|
||||
indexed = opAst.Phys;
|
||||
perPatch = opAst.P;
|
||||
isStore = true;
|
||||
}
|
||||
else if (name == InstName.Ald)
|
||||
{
|
||||
InstAld opAld = new(opCode);
|
||||
count = (int)opAld.AlSize + 1;
|
||||
offset = opAld.Imm11;
|
||||
indexed = opAld.Phys;
|
||||
perPatch = opAld.P;
|
||||
isStore = opAld.O;
|
||||
}
|
||||
else /* if (name == InstName.Ipa) */
|
||||
{
|
||||
InstIpa opIpa = new(opCode);
|
||||
offset = opIpa.Imm10;
|
||||
indexed = opIpa.Idx;
|
||||
}
|
||||
|
||||
if (indexed)
|
||||
{
|
||||
if (isStore)
|
||||
{
|
||||
context.AttributeUsage.SetAllOutputUserAttributes();
|
||||
definitions.EnableOutputIndexing();
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AttributeUsage.SetAllInputUserAttributes();
|
||||
definitions.EnableInputIndexing();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int elemIndex = 0; elemIndex < count; elemIndex++)
|
||||
{
|
||||
int attr = offset + elemIndex * 4;
|
||||
|
||||
if (perPatch)
|
||||
{
|
||||
if (attr is >= AttributeConsts.UserAttributePerPatchBase and < AttributeConsts.UserAttributePerPatchEnd)
|
||||
{
|
||||
int userAttr = attr - AttributeConsts.UserAttributePerPatchBase;
|
||||
int index = userAttr / 16;
|
||||
|
||||
if (isStore)
|
||||
{
|
||||
context.AttributeUsage.SetOutputUserAttributePerPatch(index);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AttributeUsage.SetInputUserAttributePerPatch(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (attr is >= AttributeConsts.UserAttributeBase and < AttributeConsts.UserAttributeEnd)
|
||||
{
|
||||
int userAttr = attr - AttributeConsts.UserAttributeBase;
|
||||
int index = userAttr / 16;
|
||||
|
||||
if (isStore)
|
||||
{
|
||||
context.AttributeUsage.SetOutputUserAttribute(index);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AttributeUsage.SetInputUserAttribute(index, (userAttr >> 2) & 3);
|
||||
}
|
||||
}
|
||||
|
||||
if (!isStore &&
|
||||
(attr == AttributeConsts.FogCoord ||
|
||||
(attr >= AttributeConsts.FrontColorDiffuseR && attr < AttributeConsts.ClipDistance0) ||
|
||||
(attr >= AttributeConsts.TexCoordBase && attr < AttributeConsts.TexCoordEnd)))
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.FixedFuncAttr);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (isStore)
|
||||
{
|
||||
switch (attr)
|
||||
{
|
||||
case AttributeConsts.Layer:
|
||||
if (definitions.Stage is not ShaderStage.Compute and not ShaderStage.Fragment)
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.RtLayer);
|
||||
}
|
||||
|
||||
break;
|
||||
case AttributeConsts.ViewportIndex:
|
||||
if (definitions.Stage != ShaderStage.Fragment)
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.ViewportIndex);
|
||||
}
|
||||
|
||||
break;
|
||||
case AttributeConsts.ClipDistance0:
|
||||
case AttributeConsts.ClipDistance1:
|
||||
case AttributeConsts.ClipDistance2:
|
||||
case AttributeConsts.ClipDistance3:
|
||||
case AttributeConsts.ClipDistance4:
|
||||
case AttributeConsts.ClipDistance5:
|
||||
case AttributeConsts.ClipDistance6:
|
||||
case AttributeConsts.ClipDistance7:
|
||||
if (definitions.Stage.IsVtg)
|
||||
{
|
||||
context.SetClipDistanceWritten((attr - AttributeConsts.ClipDistance0) / 4);
|
||||
}
|
||||
|
||||
break;
|
||||
case AttributeConsts.ViewportMask:
|
||||
if (definitions.Stage != ShaderStage.Fragment)
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.ViewportMask);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (attr)
|
||||
{
|
||||
case AttributeConsts.PositionX:
|
||||
case AttributeConsts.PositionY:
|
||||
if (definitions.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.FragCoordXY);
|
||||
}
|
||||
|
||||
break;
|
||||
case AttributeConsts.InstanceId:
|
||||
if (definitions.Stage == ShaderStage.Vertex)
|
||||
{
|
||||
context.SetUsedFeature(FeatureFlags.InstanceId);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static bool IsUnconditionalBranch(ref InstOp op)
|
||||
{
|
||||
return IsUnconditional(ref op) && op.Props.HasFlag(InstProps.Bra);
|
||||
}
|
||||
|
||||
private static bool IsUnconditional(ref InstOp op)
|
||||
{
|
||||
InstConditional condOp = new(op.RawOpCode);
|
||||
|
||||
if ((op.Name == InstName.Bra || op.Name == InstName.Exit) && condOp.Ccc != Ccc.T)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return condOp.Pred == RegisterConsts.PredicateTrueIndex && !condOp.PredInv;
|
||||
}
|
||||
|
||||
private static bool FindBrxTargets(Context context, IEnumerable<Block> blocks, Func<ulong, Block> getBlock)
|
||||
{
|
||||
bool hasNewTarget = false;
|
||||
|
||||
foreach (Block block in blocks)
|
||||
{
|
||||
InstOp lastOp = block.GetLastOp();
|
||||
bool hasNext = block.HasNext();
|
||||
|
||||
if (lastOp.Name == InstName.Brx && block.Successors.Count == (hasNext ? 1 : 0))
|
||||
{
|
||||
HashSet<ulong> visited = [];
|
||||
|
||||
InstBrx opBrx = new(lastOp.RawOpCode);
|
||||
ulong baseOffset = lastOp.GetAbsoluteAddress();
|
||||
|
||||
// An indirect branch could go anywhere,
|
||||
// try to get the possible target offsets from the constant buffer.
|
||||
(int cbBaseOffset, int cbOffsetsCount) = FindBrxTargetRange(block, opBrx.SrcA);
|
||||
|
||||
if (cbOffsetsCount != 0)
|
||||
{
|
||||
hasNewTarget = true;
|
||||
}
|
||||
|
||||
for (int i = 0; i < cbOffsetsCount; i++)
|
||||
{
|
||||
uint targetOffset = context.ConstantBuffer1Read(cbBaseOffset + i * 4);
|
||||
ulong targetAddress = baseOffset + targetOffset;
|
||||
|
||||
if (visited.Add(targetAddress))
|
||||
{
|
||||
Block target = getBlock(targetAddress);
|
||||
target.Predecessors.Add(block);
|
||||
block.Successors.Add(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return hasNewTarget;
|
||||
}
|
||||
|
||||
private static (int, int) FindBrxTargetRange(Block block, int brxReg)
|
||||
{
|
||||
// Try to match the following pattern:
|
||||
//
|
||||
// IMNMX.U32 Rx, Rx, UpperBound, PT
|
||||
// SHL Rx, Rx, 0x2
|
||||
// LDC Rx, c[0x1][Rx+BaseOffset]
|
||||
//
|
||||
// Here, Rx is an arbitrary register, "UpperBound" and "BaseOffset" are constants.
|
||||
// The above pattern is assumed to be generated by the compiler before BRX,
|
||||
// as the instruction is usually used to implement jump tables for switch statement optimizations.
|
||||
// On a successful match, "BaseOffset" is the offset in bytes where the jump offsets are
|
||||
// located on the constant buffer, and "UpperBound" is the total number of offsets for the BRX, minus 1.
|
||||
|
||||
HashSet<Block> visited = [];
|
||||
|
||||
BlockLocation ldcLocation = FindFirstRegWrite(visited, new BlockLocation(block, block.OpCodes.Count - 1), brxReg);
|
||||
if (ldcLocation.Block == null || ldcLocation.Block.OpCodes[ldcLocation.Index].Name != InstName.Ldc)
|
||||
{
|
||||
return (0, 0);
|
||||
}
|
||||
|
||||
GetOp<InstLdc>(ldcLocation, out InstLdc opLdc);
|
||||
|
||||
if (opLdc.CbufSlot != 1 || opLdc.AddressMode != 0)
|
||||
{
|
||||
return (0, 0);
|
||||
}
|
||||
|
||||
BlockLocation shlLocation = FindFirstRegWrite(visited, ldcLocation, opLdc.SrcA);
|
||||
if (shlLocation.Block == null || !shlLocation.IsImmInst(InstName.Shl))
|
||||
{
|
||||
return (0, 0);
|
||||
}
|
||||
|
||||
GetOp<InstShlI>(shlLocation, out InstShlI opShl);
|
||||
|
||||
if (opShl.Imm20 != 2)
|
||||
{
|
||||
return (0, 0);
|
||||
}
|
||||
|
||||
BlockLocation imnmxLocation = FindFirstRegWrite(visited, shlLocation, opShl.SrcA);
|
||||
if (imnmxLocation.Block == null || !imnmxLocation.IsImmInst(InstName.Imnmx))
|
||||
{
|
||||
return (0, 0);
|
||||
}
|
||||
|
||||
GetOp<InstImnmxI>(imnmxLocation, out InstImnmxI opImnmx);
|
||||
|
||||
if (opImnmx.Signed || opImnmx.SrcPred != RegisterConsts.PredicateTrueIndex || opImnmx.SrcPredInv)
|
||||
{
|
||||
return (0, 0);
|
||||
}
|
||||
|
||||
return (opLdc.CbufOffset, opImnmx.Imm20 + 1);
|
||||
}
|
||||
|
||||
private static void GetOp<T>(BlockLocation location, out T op) where T : unmanaged
|
||||
{
|
||||
ulong rawOp = location.Block.OpCodes[location.Index].RawOpCode;
|
||||
op = Unsafe.As<ulong, T>(ref rawOp);
|
||||
}
|
||||
|
||||
private readonly struct BlockLocation
|
||||
{
|
||||
public Block Block { get; }
|
||||
public int Index { get; }
|
||||
|
||||
public BlockLocation(Block block, int index)
|
||||
{
|
||||
Block = block;
|
||||
Index = index;
|
||||
}
|
||||
|
||||
public bool IsImmInst(InstName name)
|
||||
{
|
||||
InstOp op = Block.OpCodes[Index];
|
||||
return op.Name == name && op.Props.HasFlag(InstProps.Ib);
|
||||
}
|
||||
}
|
||||
|
||||
private static BlockLocation FindFirstRegWrite(HashSet<Block> visited, BlockLocation location, int regIndex)
|
||||
{
|
||||
Queue<BlockLocation> toVisit = new();
|
||||
toVisit.Enqueue(location);
|
||||
visited.Add(location.Block);
|
||||
|
||||
while (toVisit.TryDequeue(out BlockLocation currentLocation))
|
||||
{
|
||||
Block block = currentLocation.Block;
|
||||
for (int i = currentLocation.Index - 1; i >= 0; i--)
|
||||
{
|
||||
if (WritesToRegister(block.OpCodes[i], regIndex))
|
||||
{
|
||||
return new BlockLocation(block, i);
|
||||
}
|
||||
}
|
||||
|
||||
foreach (Block predecessor in block.Predecessors)
|
||||
{
|
||||
if (visited.Add(predecessor))
|
||||
{
|
||||
toVisit.Enqueue(new BlockLocation(predecessor, predecessor.OpCodes.Count));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return new BlockLocation(null, 0);
|
||||
}
|
||||
|
||||
private static bool WritesToRegister(InstOp op, int regIndex)
|
||||
{
|
||||
// Predicate instruction only ever writes to predicate, so we shouldn't check those.
|
||||
if ((op.Props & (InstProps.Rd | InstProps.Rd2)) == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (op.Props.HasFlag(InstProps.Rd2) && (byte)(op.RawOpCode >> 28) == regIndex)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return (byte)op.RawOpCode == regIndex;
|
||||
}
|
||||
|
||||
private enum MergeType
|
||||
{
|
||||
Brk,
|
||||
Cont,
|
||||
Sync,
|
||||
}
|
||||
|
||||
private readonly struct PathBlockState
|
||||
{
|
||||
public Block Block { get; }
|
||||
|
||||
private enum RestoreType
|
||||
{
|
||||
None,
|
||||
PopPushOp,
|
||||
PushBranchOp,
|
||||
}
|
||||
|
||||
private readonly RestoreType _restoreType;
|
||||
|
||||
private readonly ulong _restoreValue;
|
||||
private readonly MergeType _restoreMergeType;
|
||||
|
||||
public bool ReturningFromVisit => _restoreType != RestoreType.None;
|
||||
|
||||
public PathBlockState(Block block)
|
||||
{
|
||||
Block = block;
|
||||
_restoreType = RestoreType.None;
|
||||
_restoreValue = 0;
|
||||
_restoreMergeType = default;
|
||||
}
|
||||
|
||||
public PathBlockState(int oldStackSize)
|
||||
{
|
||||
Block = null;
|
||||
_restoreType = RestoreType.PopPushOp;
|
||||
_restoreValue = (ulong)oldStackSize;
|
||||
_restoreMergeType = default;
|
||||
}
|
||||
|
||||
public PathBlockState(ulong syncAddress, MergeType mergeType)
|
||||
{
|
||||
Block = null;
|
||||
_restoreType = RestoreType.PushBranchOp;
|
||||
_restoreValue = syncAddress;
|
||||
_restoreMergeType = mergeType;
|
||||
}
|
||||
|
||||
public void RestoreStackState(Stack<(ulong, MergeType)> branchStack)
|
||||
{
|
||||
if (_restoreType == RestoreType.PushBranchOp)
|
||||
{
|
||||
branchStack.Push((_restoreValue, _restoreMergeType));
|
||||
}
|
||||
else if (_restoreType == RestoreType.PopPushOp)
|
||||
{
|
||||
while (branchStack.Count > (uint)_restoreValue)
|
||||
{
|
||||
branchStack.Pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void PropagatePushOp(Dictionary<ulong, Block> blocks, Block currBlock, int pushOpIndex)
|
||||
{
|
||||
PushOpInfo pushOpInfo = currBlock.PushOpCodes[pushOpIndex];
|
||||
InstOp pushOp = pushOpInfo.Op;
|
||||
|
||||
Block target = blocks[pushOp.GetAbsoluteAddress()];
|
||||
|
||||
Stack<PathBlockState> workQueue = new();
|
||||
HashSet<Block> visited = [];
|
||||
Stack<(ulong, MergeType)> branchStack = new();
|
||||
|
||||
void Push(PathBlockState pbs)
|
||||
{
|
||||
// When block is null, this means we are pushing a restore operation.
|
||||
// Restore operations are used to undo the work done inside a block
|
||||
// when we return from it, for example it pops addresses pushed by
|
||||
// SSY/PBK instructions inside the block, and pushes addresses poped
|
||||
// by SYNC/BRK.
|
||||
// For blocks, if it's already visited, we just ignore to avoid going
|
||||
// around in circles and getting stuck here.
|
||||
if (pbs.Block == null || !visited.Contains(pbs.Block))
|
||||
{
|
||||
workQueue.Push(pbs);
|
||||
}
|
||||
}
|
||||
|
||||
Push(new PathBlockState(currBlock));
|
||||
|
||||
while (workQueue.TryPop(out PathBlockState pbs))
|
||||
{
|
||||
if (pbs.ReturningFromVisit)
|
||||
{
|
||||
pbs.RestoreStackState(branchStack);
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
Block current = pbs.Block;
|
||||
|
||||
// If the block was already processed, we just ignore it, otherwise
|
||||
// we would push the same child blocks of an already processed block,
|
||||
// and go around in circles until memory is exhausted.
|
||||
if (!visited.Add(current))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
int pushOpsCount = current.PushOpCodes.Count;
|
||||
if (pushOpsCount != 0)
|
||||
{
|
||||
Push(new PathBlockState(branchStack.Count));
|
||||
|
||||
for (int index = pushOpIndex; index < pushOpsCount; index++)
|
||||
{
|
||||
InstOp currentPushOp = current.PushOpCodes[index].Op;
|
||||
MergeType pushMergeType = GetMergeTypeFromPush(currentPushOp.Name);
|
||||
branchStack.Push((currentPushOp.GetAbsoluteAddress(), pushMergeType));
|
||||
}
|
||||
}
|
||||
|
||||
pushOpIndex = 0;
|
||||
|
||||
bool hasNext = current.HasNext();
|
||||
if (hasNext)
|
||||
{
|
||||
Push(new PathBlockState(current.Successors[0]));
|
||||
}
|
||||
|
||||
InstOp lastOp = current.GetLastOp();
|
||||
if (IsPopBranch(lastOp.Name))
|
||||
{
|
||||
MergeType popMergeType = GetMergeTypeFromPop(lastOp.Name);
|
||||
|
||||
bool found = true;
|
||||
ulong targetAddress = 0UL;
|
||||
MergeType mergeType;
|
||||
|
||||
do
|
||||
{
|
||||
if (branchStack.Count == 0)
|
||||
{
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
|
||||
(targetAddress, mergeType) = branchStack.Pop();
|
||||
|
||||
// Push the target address (this will be used to push the address
|
||||
// back into the PBK/PCNT/SSY stack when we return from that block),
|
||||
Push(new PathBlockState(targetAddress, mergeType));
|
||||
}
|
||||
while (mergeType != popMergeType);
|
||||
|
||||
// Make sure we found the correct address,
|
||||
// the push and pop instruction types must match, so:
|
||||
// - BRK can only consume addresses pushed by PBK.
|
||||
// - CONT can only consume addresses pushed by PCNT.
|
||||
// - SYNC can only consume addresses pushed by SSY.
|
||||
if (found)
|
||||
{
|
||||
if (branchStack.Count == 0)
|
||||
{
|
||||
// If the entire stack was consumed, then the current pop instruction
|
||||
// just consumed the address from our push instruction.
|
||||
if (current.SyncTargets.TryAdd(pushOp.Address, new SyncTarget(pushOpInfo, current.SyncTargets.Count)))
|
||||
{
|
||||
pushOpInfo.Consumers.Add(current, Local());
|
||||
target.Predecessors.Add(current);
|
||||
current.Successors.Add(target);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Push the block itself into the work queue for processing.
|
||||
Push(new PathBlockState(blocks[targetAddress]));
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// By adding them in descending order (sorted by address), we process the blocks
|
||||
// in order (of ascending address), since we work with a LIFO.
|
||||
foreach (Block possibleTarget in current.Successors.OrderByDescending(x => x.Address))
|
||||
{
|
||||
if (!hasNext || possibleTarget != current.Successors[0])
|
||||
{
|
||||
Push(new PathBlockState(possibleTarget));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static bool IsPopBranch(InstName name)
|
||||
{
|
||||
return name is InstName.Brk or InstName.Cont or InstName.Sync;
|
||||
}
|
||||
|
||||
private static MergeType GetMergeTypeFromPush(InstName name)
|
||||
{
|
||||
return name switch
|
||||
{
|
||||
InstName.Pbk => MergeType.Brk,
|
||||
InstName.Pcnt => MergeType.Cont,
|
||||
_ => MergeType.Sync,
|
||||
};
|
||||
}
|
||||
|
||||
private static MergeType GetMergeTypeFromPop(InstName name)
|
||||
{
|
||||
return name switch
|
||||
{
|
||||
InstName.Brk => MergeType.Brk,
|
||||
InstName.Cont => MergeType.Cont,
|
||||
_ => MergeType.Sync,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
10
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/FunctionType.cs
vendored
Normal file
10
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/FunctionType.cs
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
enum FunctionType : byte
|
||||
{
|
||||
User,
|
||||
Unused,
|
||||
BuiltInFSIBegin,
|
||||
BuiltInFSIEnd
|
||||
}
|
||||
}
|
||||
5394
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs
vendored
Normal file
5394
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
188
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstName.cs
vendored
Normal file
188
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstName.cs
vendored
Normal file
@@ -0,0 +1,188 @@
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
enum InstName : byte
|
||||
{
|
||||
Invalid = 0,
|
||||
|
||||
Al2p,
|
||||
Ald,
|
||||
Ast,
|
||||
Atom,
|
||||
AtomCas,
|
||||
Atoms,
|
||||
AtomsCas,
|
||||
B2r,
|
||||
Bar,
|
||||
Bfe,
|
||||
Bfi,
|
||||
Bpt,
|
||||
Bra,
|
||||
Brk,
|
||||
Brx,
|
||||
Cal,
|
||||
Cctl,
|
||||
Cctll,
|
||||
Cctlt,
|
||||
Cont,
|
||||
Cset,
|
||||
Csetp,
|
||||
Cs2r,
|
||||
Dadd,
|
||||
Depbar,
|
||||
Dfma,
|
||||
Dmnmx,
|
||||
Dmul,
|
||||
Dset,
|
||||
Dsetp,
|
||||
Exit,
|
||||
F2f,
|
||||
F2i,
|
||||
Fadd,
|
||||
Fadd32i,
|
||||
Fchk,
|
||||
Fcmp,
|
||||
Ffma,
|
||||
Ffma32i,
|
||||
Flo,
|
||||
Fmnmx,
|
||||
Fmul,
|
||||
Fmul32i,
|
||||
Fset,
|
||||
Fsetp,
|
||||
Fswzadd,
|
||||
Getcrsptr,
|
||||
Getlmembase,
|
||||
Hadd2,
|
||||
Hadd232i,
|
||||
Hfma2,
|
||||
Hmul2,
|
||||
Hmul232i,
|
||||
Hset2,
|
||||
Hsetp2,
|
||||
I2f,
|
||||
I2i,
|
||||
Iadd,
|
||||
Iadd32i,
|
||||
Iadd3,
|
||||
Icmp,
|
||||
Ide,
|
||||
Idp,
|
||||
Imad,
|
||||
Imad32i,
|
||||
Imadsp,
|
||||
Imnmx,
|
||||
Imul,
|
||||
Imul32i,
|
||||
Ipa,
|
||||
Isberd,
|
||||
Iscadd,
|
||||
Iscadd32i,
|
||||
Iset,
|
||||
Isetp,
|
||||
Jcal,
|
||||
Jmp,
|
||||
Jmx,
|
||||
Kil,
|
||||
Ld,
|
||||
Ldc,
|
||||
Ldg,
|
||||
Ldl,
|
||||
Lds,
|
||||
Lea,
|
||||
LeaHi,
|
||||
Lepc,
|
||||
Longjmp,
|
||||
Lop,
|
||||
Lop3,
|
||||
Lop32i,
|
||||
Membar,
|
||||
Mov,
|
||||
Mov32i,
|
||||
Mufu,
|
||||
Nop,
|
||||
Out,
|
||||
P2r,
|
||||
Pbk,
|
||||
Pcnt,
|
||||
Pexit,
|
||||
Pixld,
|
||||
Plongjmp,
|
||||
Popc,
|
||||
Pret,
|
||||
Prmt,
|
||||
Pset,
|
||||
Psetp,
|
||||
R2b,
|
||||
R2p,
|
||||
Ram,
|
||||
Red,
|
||||
Ret,
|
||||
Rro,
|
||||
Rtt,
|
||||
S2r,
|
||||
Sam,
|
||||
Sel,
|
||||
Setcrsptr,
|
||||
Setlmembase,
|
||||
Shf,
|
||||
Shf_2,
|
||||
Shf_3,
|
||||
Shf_4,
|
||||
Shfl,
|
||||
Shl,
|
||||
Shr,
|
||||
Ssy,
|
||||
St,
|
||||
Stg,
|
||||
Stl,
|
||||
Stp,
|
||||
Sts,
|
||||
SuatomB,
|
||||
Suatom,
|
||||
SuatomB2,
|
||||
SuatomCasB,
|
||||
SuatomCas,
|
||||
SuldDB,
|
||||
SuldD,
|
||||
SuldB,
|
||||
Suld,
|
||||
SuredB,
|
||||
Sured,
|
||||
SustDB,
|
||||
SustD,
|
||||
SustB,
|
||||
Sust,
|
||||
Sync,
|
||||
Tex,
|
||||
TexB,
|
||||
Texs,
|
||||
TexsF16,
|
||||
Tld,
|
||||
TldB,
|
||||
Tlds,
|
||||
TldsF16,
|
||||
Tld4,
|
||||
Tld4B,
|
||||
Tld4s,
|
||||
Tld4sF16,
|
||||
Tmml,
|
||||
TmmlB,
|
||||
Txa,
|
||||
Txd,
|
||||
TxdB,
|
||||
Txq,
|
||||
TxqB,
|
||||
Vabsdiff,
|
||||
Vabsdiff4,
|
||||
Vadd,
|
||||
Vmad,
|
||||
Vmnmx,
|
||||
Vote,
|
||||
Votevtg,
|
||||
Vset,
|
||||
Vsetp,
|
||||
Vshl,
|
||||
Vshr,
|
||||
Xmad,
|
||||
}
|
||||
}
|
||||
27
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstOp.cs
vendored
Normal file
27
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstOp.cs
vendored
Normal file
@@ -0,0 +1,27 @@
|
||||
using Ryujinx.Graphics.Shader.Instructions;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
readonly struct InstOp
|
||||
{
|
||||
public readonly ulong Address;
|
||||
public readonly ulong RawOpCode;
|
||||
public readonly InstEmitter Emitter;
|
||||
public readonly InstProps Props;
|
||||
public readonly InstName Name;
|
||||
|
||||
public InstOp(ulong address, ulong rawOpCode, InstName name, InstEmitter emitter, InstProps props)
|
||||
{
|
||||
Address = address;
|
||||
RawOpCode = rawOpCode;
|
||||
Name = name;
|
||||
Emitter = emitter;
|
||||
Props = props;
|
||||
}
|
||||
|
||||
public ulong GetAbsoluteAddress()
|
||||
{
|
||||
return (ulong)((long)Address + (((int)(RawOpCode >> 20) << 8) >> 8) + 8);
|
||||
}
|
||||
}
|
||||
}
|
||||
31
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstProps.cs
vendored
Normal file
31
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstProps.cs
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
[Flags]
|
||||
enum InstProps : ushort
|
||||
{
|
||||
None = 0,
|
||||
Rd = 1 << 0,
|
||||
Rd2 = 1 << 1,
|
||||
Ra = 1 << 2,
|
||||
Rb = 1 << 3,
|
||||
Rb2 = 1 << 4,
|
||||
Ib = 1 << 5,
|
||||
Rc = 1 << 6,
|
||||
|
||||
Pd = 1 << 7,
|
||||
LPd = 2 << 7,
|
||||
SPd = 3 << 7,
|
||||
TPd = 4 << 7,
|
||||
VPd = 5 << 7,
|
||||
PdMask = 7 << 7,
|
||||
|
||||
Pdn = 1 << 10,
|
||||
Ps = 1 << 11,
|
||||
Tex = 1 << 12,
|
||||
TexB = 1 << 13,
|
||||
Bra = 1 << 14,
|
||||
NoPred = 1 << 15,
|
||||
}
|
||||
}
|
||||
392
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstTable.cs
vendored
Normal file
392
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/InstTable.cs
vendored
Normal file
@@ -0,0 +1,392 @@
|
||||
using Ryujinx.Graphics.Shader.Instructions;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
static class InstTable
|
||||
{
|
||||
private const int EncodingBits = 14;
|
||||
|
||||
private readonly struct TableEntry
|
||||
{
|
||||
public InstName Name { get; }
|
||||
public InstEmitter Emitter { get; }
|
||||
public InstProps Props { get; }
|
||||
|
||||
public int XBits { get; }
|
||||
|
||||
public TableEntry(InstName name, InstEmitter emitter, InstProps props, int xBits)
|
||||
{
|
||||
Name = name;
|
||||
Emitter = emitter;
|
||||
Props = props;
|
||||
XBits = xBits;
|
||||
}
|
||||
}
|
||||
|
||||
private static readonly TableEntry[] _opCodes;
|
||||
|
||||
static InstTable()
|
||||
{
|
||||
_opCodes = new TableEntry[1 << EncodingBits];
|
||||
|
||||
#region Instructions
|
||||
#pragma warning disable IDE0055 // Disable formatting
|
||||
Add("1110111110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Al2p, InstEmit.Al2p, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ald, InstEmit.Ald, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ast, InstEmit.Ast, InstProps.Ra | InstProps.Rb2 | InstProps.Rc);
|
||||
Add("11101101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Atom, InstEmit.Atom, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("111011101111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.AtomCas, InstEmit.AtomCas, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("11101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Atoms, InstEmit.Atoms, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("111011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.AtomsCas, InstEmit.AtomsCas, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("1111000010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.B2r, InstEmit.B2r, InstProps.Rd | InstProps.Ra | InstProps.VPd);
|
||||
Add("1111000010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bar, InstEmit.Bar, InstProps.Ra | InstProps.Ps);
|
||||
Add("0101110000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfe, InstEmit.BfeR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x00000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfe, InstEmit.BfeI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfe, InstEmit.BfeC, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101101111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi, InstEmit.BfiR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x11110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi, InstEmit.BfiI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("0100101111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi, InstEmit.BfiC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("0101001111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bfi, InstEmit.BfiRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("111000111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bpt, InstEmit.Bpt, InstProps.NoPred);
|
||||
Add("111000100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Bra, InstEmit.Bra, InstProps.Bra);
|
||||
Add("111000110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Brk, InstEmit.Brk, InstProps.Bra);
|
||||
Add("111000100101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Brx, InstEmit.Brx, InstProps.Ra | InstProps.Bra);
|
||||
Add("111000100110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cal, InstEmit.Cal, InstProps.Bra | InstProps.NoPred);
|
||||
Add("11101111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctl, InstEmit.Cctl, InstProps.Ra);
|
||||
Add("1110111110000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctll, InstEmit.Cctll, InstProps.Ra);
|
||||
Add("1110101111110xx0000000000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctlt, InstEmit.Cctlt);
|
||||
Add("1110101111101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cctlt, InstEmit.Cctlt, InstProps.Rc);
|
||||
Add("111000110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cont, InstEmit.Cont, InstProps.Bra);
|
||||
Add("0101000010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cset, InstEmit.Cset, InstProps.Rd | InstProps.Ps);
|
||||
Add("0101000010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Csetp, InstEmit.Csetp, InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0101000011001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Cs2r, InstEmit.Cs2r, InstProps.Rd);
|
||||
Add("0101110001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dadd, InstEmit.DaddR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x01110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dadd, InstEmit.DaddI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dadd, InstEmit.DaddC, InstProps.Rd | InstProps.Ra);
|
||||
Add("1111000011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Depbar, InstEmit.Depbar);
|
||||
Add("010110110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma, InstEmit.DfmaR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x0111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma, InstEmit.DfmaI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma, InstEmit.DfmaC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dfma, InstEmit.DfmaRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("0101110001010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmnmx, InstEmit.DmnmxR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011100x01010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmnmx, InstEmit.DmnmxI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("0100110001010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmnmx, InstEmit.DmnmxC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("0101110010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmul, InstEmit.DmulR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x10000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmul, InstEmit.DmulI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dmul, InstEmit.DmulC, InstProps.Rd | InstProps.Ra);
|
||||
Add("010110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dset, InstEmit.DsetR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011001x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dset, InstEmit.DsetI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("010010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dset, InstEmit.DsetC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("010110111000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dsetp, InstEmit.DsetpR, InstProps.Ra | InstProps.Rb | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0011011x1000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dsetp, InstEmit.DsetpI, InstProps.Ra | InstProps.Ib | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("010010111000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Dsetp, InstEmit.DsetpC, InstProps.Ra | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("111000110000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Exit, InstEmit.Exit, InstProps.Bra);
|
||||
Add("0101110010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2f, InstEmit.F2fR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x10101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2f, InstEmit.F2fI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2f, InstEmit.F2fC, InstProps.Rd);
|
||||
Add("0101110010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2i, InstEmit.F2iR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x10110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2i, InstEmit.F2iI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.F2i, InstEmit.F2iC, InstProps.Rd);
|
||||
Add("0101110001011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd, InstEmit.FaddR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x01011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd, InstEmit.FaddI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110001011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd, InstEmit.FaddC, InstProps.Rd | InstProps.Ra);
|
||||
Add("000010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fadd32i, InstEmit.Fadd32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110010001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fchk, InstEmit.FchkR, InstProps.Ra | InstProps.Rb | InstProps.Pd);
|
||||
Add("0011100x10001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fchk, InstEmit.FchkI, InstProps.Ra | InstProps.Ib | InstProps.Pd);
|
||||
Add("0100110010001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fchk, InstEmit.FchkC, InstProps.Ra | InstProps.Pd);
|
||||
Add("010110111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp, InstEmit.FcmpR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x1010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp, InstEmit.FcmpI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp, InstEmit.FcmpC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fcmp, InstEmit.FcmpRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010110011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma, InstEmit.FfmaR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011001x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma, InstEmit.FfmaI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma, InstEmit.FfmaC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma, InstEmit.FfmaRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("000011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ffma32i, InstEmit.Ffma32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110000110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Flo, InstEmit.FloR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x00110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Flo, InstEmit.FloI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110000110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Flo, InstEmit.FloC, InstProps.Rd);
|
||||
Add("0101110001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmnmx, InstEmit.FmnmxR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011100x01100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmnmx, InstEmit.FmnmxI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("0100110001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmnmx, InstEmit.FmnmxC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("0101110001101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul, InstEmit.FmulR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x01101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul, InstEmit.FmulI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110001101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul, InstEmit.FmulC, InstProps.Rd | InstProps.Ra);
|
||||
Add("00011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fmul32i, InstEmit.Fmul32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("01011000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fset, InstEmit.FsetR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fset, InstEmit.FsetI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("01001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fset, InstEmit.FsetC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("010110111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fsetp, InstEmit.FsetpR, InstProps.Ra | InstProps.Rb | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0011011x1011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fsetp, InstEmit.FsetpI, InstProps.Ra | InstProps.Ib | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("010010111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fsetp, InstEmit.FsetpC, InstProps.Ra | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0101000011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Fswzadd, InstEmit.Fswzadd, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("111000101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Getcrsptr, InstEmit.Getcrsptr, InstProps.Rd | InstProps.NoPred);
|
||||
Add("111000101101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Getlmembase, InstEmit.Getlmembase, InstProps.Rd | InstProps.NoPred);
|
||||
Add("0101110100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd2, InstEmit.Hadd2R, InstProps.Rd | InstProps.Ra);
|
||||
Add("0111101x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd2, InstEmit.Hadd2I, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0111101x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd2, InstEmit.Hadd2C, InstProps.Rd | InstProps.Ra);
|
||||
Add("0010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hadd232i, InstEmit.Hadd232i, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2, InstEmit.Hfma2R, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("01110xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2, InstEmit.Hfma2I, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("01110xxx1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2, InstEmit.Hfma2C, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("01100xxx1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2, InstEmit.Hfma2Rc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("0010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hfma2, InstEmit.Hfma232i, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110100001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul2, InstEmit.Hmul2R, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0111100x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul2, InstEmit.Hmul2I, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0111100x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul2, InstEmit.Hmul2C, InstProps.Rd | InstProps.Ra);
|
||||
Add("0010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hmul232i, InstEmit.Hmul232i, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hset2, InstEmit.Hset2R, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0111110x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hset2, InstEmit.Hset2I, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("0111110x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hset2, InstEmit.Hset2C, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("0101110100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hsetp2, InstEmit.Hsetp2R, InstProps.Ra | InstProps.Rb | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0111111x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hsetp2, InstEmit.Hsetp2I, InstProps.Ra | InstProps.Ib | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0111111x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Hsetp2, InstEmit.Hsetp2C, InstProps.Ra | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0101110010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2f, InstEmit.I2fR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x10111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2f, InstEmit.I2fI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2f, InstEmit.I2fC, InstProps.Rd);
|
||||
Add("0101110011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2i, InstEmit.I2iR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x11100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2i, InstEmit.I2iI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.I2i, InstEmit.I2iC, InstProps.Rd);
|
||||
Add("0101110000010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd, InstEmit.IaddR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x00010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd, InstEmit.IaddI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110000010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd, InstEmit.IaddC, InstProps.Rd | InstProps.Ra);
|
||||
Add("0001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd32i, InstEmit.Iadd32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("010111001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd3, InstEmit.Iadd3R, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011100x1100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd3, InstEmit.Iadd3I, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010011001100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iadd3, InstEmit.Iadd3C, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010110110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp, InstEmit.IcmpR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x0100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp, InstEmit.IcmpI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp, InstEmit.IcmpC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Icmp, InstEmit.IcmpRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("111000111001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ide, InstEmit.Ide, InstProps.NoPred);
|
||||
Add("0101001111111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Idp, InstEmit.IdpR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0101001111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Idp, InstEmit.IdpC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010110100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad, InstEmit.ImadR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011010x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad, InstEmit.ImadI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad, InstEmit.ImadC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad, InstEmit.ImadRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("000100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imad32i, InstEmit.Imad32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("010110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp, InstEmit.ImadspR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011010x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp, InstEmit.ImadspI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp, InstEmit.ImadspC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imadsp, InstEmit.ImadspRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("0101110000100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imnmx, InstEmit.ImnmxR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011100x00100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imnmx, InstEmit.ImnmxI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("0100110000100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imnmx, InstEmit.ImnmxC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("0101110000111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul, InstEmit.ImulR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x00111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul, InstEmit.ImulI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110000111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul, InstEmit.ImulC, InstProps.Rd | InstProps.Ra);
|
||||
Add("00011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Imul32i, InstEmit.Imul32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("11100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ipa, InstEmit.Ipa, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("1110111111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isberd, InstEmit.Isberd, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110000011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd, InstEmit.IscaddR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x00011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd, InstEmit.IscaddI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110000011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd, InstEmit.IscaddC, InstProps.Rd | InstProps.Ra);
|
||||
Add("000101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iscadd32i, InstEmit.Iscadd32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("010110110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iset, InstEmit.IsetR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011011x0101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iset, InstEmit.IsetI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("010010110101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Iset, InstEmit.IsetC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("010110110110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isetp, InstEmit.IsetpR, InstProps.Ra | InstProps.Rb | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("0011011x0110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isetp, InstEmit.IsetpI, InstProps.Ra | InstProps.Ib | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("010010110110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Isetp, InstEmit.IsetpC, InstProps.Ra | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("111000100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Jcal, InstEmit.Jcal, InstProps.Bra);
|
||||
Add("111000100001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Jmp, InstEmit.Jmp, InstProps.Ra | InstProps.Bra);
|
||||
Add("111000100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Jmx, InstEmit.Jmx, InstProps.Ra | InstProps.Bra);
|
||||
Add("111000110011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Kil, InstEmit.Kil, InstProps.Bra);
|
||||
Add("100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ld, InstEmit.Ld, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ldc, InstEmit.Ldc, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111011010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ldg, InstEmit.Ldg, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ldl, InstEmit.Ldl, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lds, InstEmit.Lds, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101101111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lea, InstEmit.LeaR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.LPd);
|
||||
Add("0011011x11010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lea, InstEmit.LeaI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.LPd);
|
||||
Add("0100101111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lea, InstEmit.LeaC, InstProps.Rd | InstProps.Ra | InstProps.LPd);
|
||||
Add("0101101111011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.LeaHi, InstEmit.LeaHiR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc | InstProps.LPd);
|
||||
Add("000110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.LeaHi, InstEmit.LeaHiC, InstProps.Rd | InstProps.Ra | InstProps.Rc | InstProps.LPd);
|
||||
Add("0101000011010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lepc, InstEmit.Lepc);
|
||||
Add("111000110001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Longjmp, InstEmit.Longjmp, InstProps.Bra);
|
||||
Add("0101110001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop, InstEmit.LopR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.LPd);
|
||||
Add("0011100x01000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop, InstEmit.LopI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.LPd);
|
||||
Add("0100110001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop, InstEmit.LopC, InstProps.Rd | InstProps.Ra | InstProps.LPd);
|
||||
Add("0101101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop3, InstEmit.Lop3R, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc | InstProps.LPd);
|
||||
Add("001111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop3, InstEmit.Lop3I, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("0000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop3, InstEmit.Lop3C, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Lop32i, InstEmit.Lop32i, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111110011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Membar, InstEmit.Membar);
|
||||
Add("0101110010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov, InstEmit.MovR, InstProps.Rd | InstProps.Ra);
|
||||
Add("0011100x10011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov, InstEmit.MovI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110010011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov, InstEmit.MovC, InstProps.Rd);
|
||||
Add("000000010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mov32i, InstEmit.Mov32i, InstProps.Rd);
|
||||
Add("0101000010000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Mufu, InstEmit.Mufu, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101000010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Nop, InstEmit.Nop);
|
||||
Add("1111101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Out, InstEmit.OutR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("1111011x11100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Out, InstEmit.OutI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("1110101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Out, InstEmit.OutC, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.P2r, InstEmit.P2rR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x11101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.P2r, InstEmit.P2rI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.P2r, InstEmit.P2rC, InstProps.Rd | InstProps.Ra);
|
||||
Add("111000101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pbk, InstEmit.Pbk, InstProps.NoPred);
|
||||
Add("111000101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pcnt, InstEmit.Pcnt, InstProps.NoPred);
|
||||
Add("111000100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pexit, InstEmit.Pexit);
|
||||
Add("1110111111101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pixld, InstEmit.Pixld, InstProps.Rd | InstProps.Ra | InstProps.VPd);
|
||||
Add("111000101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Plongjmp, InstEmit.Plongjmp, InstProps.Bra | InstProps.NoPred);
|
||||
Add("0101110000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Popc, InstEmit.PopcR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x00001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Popc, InstEmit.PopcI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110000001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Popc, InstEmit.PopcC, InstProps.Rd);
|
||||
Add("111000100111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pret, InstEmit.Pret, InstProps.NoPred);
|
||||
Add("010110111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt, InstEmit.PrmtR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x1100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt, InstEmit.PrmtI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("010010111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt, InstEmit.PrmtC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Prmt, InstEmit.PrmtRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("0101000010001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Pset, InstEmit.Pset, InstProps.Rd | InstProps.Ps);
|
||||
Add("0101000010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Psetp, InstEmit.Psetp, InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("1111000011000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2b, InstEmit.R2b, InstProps.Rb);
|
||||
Add("0101110011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2p, InstEmit.R2pR, InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x11110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2p, InstEmit.R2pI, InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.R2p, InstEmit.R2pC, InstProps.Ra);
|
||||
Add("111000111000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ram, InstEmit.Ram, InstProps.NoPred);
|
||||
Add("1110101111111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Red, InstEmit.Red, InstProps.Ra | InstProps.Rb2);
|
||||
Add("111000110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ret, InstEmit.Ret, InstProps.Bra);
|
||||
Add("0101110010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rro, InstEmit.RroR, InstProps.Rd | InstProps.Rb);
|
||||
Add("0011100x10010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rro, InstEmit.RroI, InstProps.Rd | InstProps.Ib);
|
||||
Add("0100110010010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rro, InstEmit.RroC, InstProps.Rd);
|
||||
Add("111000110110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Rtt, InstEmit.Rtt, InstProps.NoPred);
|
||||
Add("1111000011001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.S2r, InstEmit.S2r, InstProps.Rd);
|
||||
Add("111000110111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sam, InstEmit.Sam, InstProps.NoPred);
|
||||
Add("0101110010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sel, InstEmit.SelR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Ps);
|
||||
Add("0011100x10100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sel, InstEmit.SelI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Ps);
|
||||
Add("0100110010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sel, InstEmit.SelC, InstProps.Rd | InstProps.Ra | InstProps.Ps);
|
||||
Add("111000101110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Setcrsptr, InstEmit.Setcrsptr, InstProps.Ra | InstProps.NoPred);
|
||||
Add("111000101111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Setlmembase, InstEmit.Setlmembase, InstProps.Ra | InstProps.NoPred);
|
||||
Add("0101101111111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf, InstEmit.ShfLR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0101110011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf, InstEmit.ShfRR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x11111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf, InstEmit.ShfLI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("0011100x11111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shf, InstEmit.ShfRI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("1110111100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shfl, InstEmit.Shfl, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc | InstProps.LPd);
|
||||
Add("0101110001001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shl, InstEmit.ShlR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x01001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shl, InstEmit.ShlI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110001001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shl, InstEmit.ShlC, InstProps.Rd | InstProps.Ra);
|
||||
Add("0101110000101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shr, InstEmit.ShrR, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("0011100x00101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shr, InstEmit.ShrI, InstProps.Rd | InstProps.Ra | InstProps.Ib);
|
||||
Add("0100110000101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Shr, InstEmit.ShrC, InstProps.Rd | InstProps.Ra);
|
||||
Add("111000101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Ssy, InstEmit.Ssy, InstProps.NoPred);
|
||||
Add("101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.St, InstEmit.St, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111011011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Stg, InstEmit.Stg, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Stl, InstEmit.Stl, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110111010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Stp, InstEmit.Stp, InstProps.NoPred);
|
||||
Add("1110111101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sts, InstEmit.Sts, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110101001110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomB, InstEmit.SuatomB, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("11101010x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Suatom, InstEmit.Suatom, InstProps.Rd | InstProps.Ra | InstProps.Rb);
|
||||
Add("1110101110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomB2, InstEmit.SuatomB2, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("1110101011010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomCasB, InstEmit.SuatomCasB, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc | InstProps.SPd);
|
||||
Add("1110101x1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuatomCas, InstEmit.SuatomCas, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.SPd);
|
||||
Add("1110101100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuldDB, InstEmit.SuldDB, InstProps.Rd | InstProps.Ra | InstProps.Rc | InstProps.SPd | InstProps.TexB);
|
||||
Add("1110101100011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuldD, InstEmit.SuldD, InstProps.Rd | InstProps.Ra | InstProps.SPd | InstProps.Tex);
|
||||
Add("1110101100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuldB, InstEmit.SuldB, InstProps.Rd | InstProps.Ra | InstProps.Rc | InstProps.SPd | InstProps.TexB);
|
||||
Add("1110101100001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Suld, InstEmit.Suld, InstProps.Rd | InstProps.Ra | InstProps.SPd | InstProps.Tex);
|
||||
Add("1110101101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SuredB, InstEmit.SuredB, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("1110101101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sured, InstEmit.Sured, InstProps.Rd | InstProps.Ra);
|
||||
Add("1110101100110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SustDB, InstEmit.SustDB, InstProps.Rd | InstProps.Ra | InstProps.Rc | InstProps.TexB);
|
||||
Add("1110101100111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SustD, InstEmit.SustD, InstProps.Rd | InstProps.Ra | InstProps.Tex);
|
||||
Add("1110101100100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.SustB, InstEmit.SustB, InstProps.Rd | InstProps.Ra | InstProps.Rc | InstProps.TexB);
|
||||
Add("1110101100101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sust, InstEmit.Sust, InstProps.Rd | InstProps.Ra | InstProps.Tex);
|
||||
Add("1111000011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Sync, InstEmit.Sync, InstProps.Bra);
|
||||
Add("11000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tex, InstEmit.Tex, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.Tex);
|
||||
Add("1101111010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TexB, InstEmit.TexB, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.TexB);
|
||||
Add("1101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Texs, InstEmit.Texs, InstProps.Rd | InstProps.Rd2 | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("1101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TexsF16, InstEmit.TexsF16, InstProps.Rd | InstProps.Rd2 | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("11011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld, InstEmit.Tld, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.Tex);
|
||||
Add("11011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TldB, InstEmit.TldB, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.TexB);
|
||||
Add("1101101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tlds, InstEmit.Tlds, InstProps.Rd | InstProps.Rd2 | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("1101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TldsF16, InstEmit.TldsF16, InstProps.Rd | InstProps.Rd2 | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("110010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4, InstEmit.Tld4, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.Tex);
|
||||
Add("1101111011xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4B, InstEmit.Tld4B, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.TexB);
|
||||
Add("1101111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4s, InstEmit.Tld4s, InstProps.Rd | InstProps.Rd2 | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("1101111110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tld4sF16, InstEmit.Tld4sF16, InstProps.Rd | InstProps.Rd2 | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("1101111101011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Tmml, InstEmit.Tmml, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Tex);
|
||||
Add("1101111101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TmmlB, InstEmit.TmmlB, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TexB);
|
||||
Add("1101111101000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Txa, InstEmit.Txa, InstProps.Rd | InstProps.Ra | InstProps.Tex);
|
||||
Add("110111100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Txd, InstEmit.Txd, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.Tex);
|
||||
Add("1101111001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TxdB, InstEmit.TxdB, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.TPd | InstProps.TexB);
|
||||
Add("1101111101001xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Txq, InstEmit.Txq, InstProps.Rd | InstProps.Ra | InstProps.Tex);
|
||||
Add("1101111101010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.TxqB, InstEmit.TxqB, InstProps.Rd | InstProps.Ra | InstProps.TexB);
|
||||
Add("01010100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vabsdiff, InstEmit.Vabsdiff, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("010100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vabsdiff4, InstEmit.Vabsdiff4, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("001000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vadd, InstEmit.Vadd, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("01011111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vmad, InstEmit.Vmad, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vmnmx, InstEmit.Vmnmx, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0101000011011xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vote, InstEmit.Vote, InstProps.Rd | InstProps.VPd | InstProps.Ps);
|
||||
Add("0101000011100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Votevtg, InstEmit.Votevtg);
|
||||
Add("0100000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vset, InstEmit.Vset, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0101000011110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vsetp, InstEmit.Vsetp, InstProps.Ra | InstProps.Rb | InstProps.Pd | InstProps.Pdn | InstProps.Ps);
|
||||
Add("01010111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vshl, InstEmit.Vshl, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("01010110xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Vshr, InstEmit.Vshr, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0101101100xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad, InstEmit.XmadR, InstProps.Rd | InstProps.Ra | InstProps.Rb | InstProps.Rc);
|
||||
Add("0011011x00xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad, InstEmit.XmadI, InstProps.Rd | InstProps.Ra | InstProps.Ib | InstProps.Rc);
|
||||
Add("0100111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad, InstEmit.XmadC, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
Add("010100010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", InstName.Xmad, InstEmit.XmadRc, InstProps.Rd | InstProps.Ra | InstProps.Rc);
|
||||
#pragma warning restore IDE0055
|
||||
#endregion
|
||||
}
|
||||
|
||||
private static void Add(string encoding, InstName name, InstEmitter emitter, InstProps props = InstProps.None)
|
||||
{
|
||||
ReadOnlySpan<char> encodingPart = encoding.AsSpan(0, EncodingBits);
|
||||
|
||||
int bit = encodingPart.Length - 1;
|
||||
int value = 0;
|
||||
int xMask = 0;
|
||||
int xBits = 0;
|
||||
|
||||
int[] xPos = new int[encodingPart.Length];
|
||||
|
||||
for (int index = 0; index < encodingPart.Length; index++, bit--)
|
||||
{
|
||||
char chr = encodingPart[index];
|
||||
|
||||
if (chr == '1')
|
||||
{
|
||||
value |= 1 << bit;
|
||||
}
|
||||
else if (chr == 'x')
|
||||
{
|
||||
xMask |= 1 << bit;
|
||||
|
||||
xPos[xBits++] = bit;
|
||||
}
|
||||
}
|
||||
|
||||
xMask = ~xMask;
|
||||
|
||||
TableEntry entry = new(name, emitter, props, xBits);
|
||||
|
||||
for (int index = 0; index < (1 << xBits); index++)
|
||||
{
|
||||
value &= xMask;
|
||||
|
||||
for (int x = 0; x < xBits; x++)
|
||||
{
|
||||
value |= ((index >> x) & 1) << xPos[x];
|
||||
}
|
||||
|
||||
if (_opCodes[value].Emitter == null || _opCodes[value].XBits > xBits)
|
||||
{
|
||||
_opCodes[value] = entry;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static InstOp GetOp(ulong address, ulong opCode)
|
||||
{
|
||||
ref TableEntry entry = ref _opCodes[opCode >> (64 - EncodingBits)];
|
||||
|
||||
if (entry.Emitter != null)
|
||||
{
|
||||
return new InstOp(address, opCode, entry.Name, entry.Emitter, entry.Props);
|
||||
}
|
||||
|
||||
return new InstOp(address, opCode, InstName.Invalid, null, InstProps.None);
|
||||
}
|
||||
}
|
||||
}
|
||||
36
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/Register.cs
vendored
Normal file
36
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/Register.cs
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
readonly struct Register : IEquatable<Register>
|
||||
{
|
||||
public int Index { get; }
|
||||
|
||||
public RegisterType Type { get; }
|
||||
|
||||
public bool IsRZ => Type == RegisterType.Gpr && Index == RegisterConsts.RegisterZeroIndex;
|
||||
public bool IsPT => Type == RegisterType.Predicate && Index == RegisterConsts.PredicateTrueIndex;
|
||||
|
||||
public Register(int index, RegisterType type)
|
||||
{
|
||||
Index = index;
|
||||
Type = type;
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
return (ushort)Index | ((ushort)Type << 16);
|
||||
}
|
||||
|
||||
public override bool Equals(object obj)
|
||||
{
|
||||
return obj is Register reg && Equals(reg);
|
||||
}
|
||||
|
||||
public bool Equals(Register other)
|
||||
{
|
||||
return other.Index == Index &&
|
||||
other.Type == Type;
|
||||
}
|
||||
}
|
||||
}
|
||||
13
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/RegisterConsts.cs
vendored
Normal file
13
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/RegisterConsts.cs
vendored
Normal file
@@ -0,0 +1,13 @@
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
static class RegisterConsts
|
||||
{
|
||||
public const int GprsCount = 255;
|
||||
public const int PredsCount = 7;
|
||||
public const int FlagsCount = 4;
|
||||
public const int TotalCount = GprsCount + PredsCount + FlagsCount;
|
||||
|
||||
public const int RegisterZeroIndex = GprsCount;
|
||||
public const int PredicateTrueIndex = PredsCount;
|
||||
}
|
||||
}
|
||||
9
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/RegisterType.cs
vendored
Normal file
9
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Decoders/RegisterType.cs
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
enum RegisterType
|
||||
{
|
||||
Flag,
|
||||
Gpr,
|
||||
Predicate,
|
||||
}
|
||||
}
|
||||
177
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/GpuGraphicsState.cs
vendored
Normal file
177
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/GpuGraphicsState.cs
vendored
Normal file
@@ -0,0 +1,177 @@
|
||||
using Ryujinx.Common.Memory;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// GPU graphics state that the shader depends on.
|
||||
/// </summary>
|
||||
public readonly struct GpuGraphicsState
|
||||
{
|
||||
/// <summary>
|
||||
/// Early Z force enable.
|
||||
/// </summary>
|
||||
public readonly bool EarlyZForce;
|
||||
|
||||
/// <summary>
|
||||
/// Primitive topology of current draw.
|
||||
/// </summary>
|
||||
public readonly InputTopology Topology;
|
||||
|
||||
/// <summary>
|
||||
/// Tessellation winding order.
|
||||
/// </summary>
|
||||
public readonly bool TessCw;
|
||||
|
||||
/// <summary>
|
||||
/// Tessellation patch type.
|
||||
/// </summary>
|
||||
public readonly TessPatchType TessPatchType;
|
||||
|
||||
/// <summary>
|
||||
/// Tessellation spacing.
|
||||
/// </summary>
|
||||
public readonly TessSpacing TessSpacing;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether alpha-to-coverage is enabled.
|
||||
/// </summary>
|
||||
public readonly bool AlphaToCoverageEnable;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether alpha-to-coverage dithering is enabled.
|
||||
/// </summary>
|
||||
public readonly bool AlphaToCoverageDitherEnable;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether the viewport transform is disabled.
|
||||
/// </summary>
|
||||
public readonly bool ViewportTransformDisable;
|
||||
|
||||
/// <summary>
|
||||
/// Depth mode zero to one or minus one to one.
|
||||
/// </summary>
|
||||
public readonly bool DepthMode;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates if the point size is set on the shader or is fixed.
|
||||
/// </summary>
|
||||
public readonly bool ProgramPointSizeEnable;
|
||||
|
||||
/// <summary>
|
||||
/// Point size used if <see cref="ProgramPointSizeEnable" /> is false.
|
||||
/// </summary>
|
||||
public readonly float PointSize;
|
||||
|
||||
/// <summary>
|
||||
/// When alpha test is enabled, indicates the comparison that decides if the fragment should be discarded.
|
||||
/// </summary>
|
||||
public readonly AlphaTestOp AlphaTestCompare;
|
||||
|
||||
/// <summary>
|
||||
/// When alpha test is enabled, indicates the value to compare with the fragment output alpha.
|
||||
/// </summary>
|
||||
public readonly float AlphaTestReference;
|
||||
|
||||
/// <summary>
|
||||
/// Type of the vertex attributes consumed by the shader.
|
||||
/// </summary>
|
||||
public readonly Array32<AttributeType> AttributeTypes;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates that the draw is writing the base vertex, base instance and draw index to Constant Buffer 0.
|
||||
/// </summary>
|
||||
public readonly bool HasConstantBufferDrawParameters;
|
||||
|
||||
/// <summary>
|
||||
/// Type of the fragment shader outputs.
|
||||
/// </summary>
|
||||
public readonly Array8<AttributeType> FragmentOutputTypes;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates whether dual source blend is enabled.
|
||||
/// </summary>
|
||||
public readonly bool DualSourceBlendEnable;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates if negation of the viewport Y axis is enabled.
|
||||
/// </summary>
|
||||
public readonly bool YNegateEnabled;
|
||||
|
||||
/// <summary>
|
||||
/// If true, indicates that the fragment origin is the upper left corner of the viewport, otherwise it is the lower left corner.
|
||||
/// </summary>
|
||||
public readonly bool OriginUpperLeft;
|
||||
|
||||
/// <summary>
|
||||
/// Indicates that the primitive ID values on the shader should be halved due to quad to triangles conversion.
|
||||
/// </summary>
|
||||
public readonly bool HalvePrimitiveId;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new GPU graphics state.
|
||||
/// </summary>
|
||||
/// <param name="earlyZForce">Early Z force enable</param>
|
||||
/// <param name="topology">Primitive topology</param>
|
||||
/// <param name="tessCw">Tessellation winding order (clockwise or counter-clockwise)</param>
|
||||
/// <param name="tessPatchType">Tessellation patch type</param>
|
||||
/// <param name="tessSpacing">Tessellation spacing</param>
|
||||
/// <param name="alphaToCoverageEnable">Indicates whether alpha-to-coverage is enabled</param>
|
||||
/// <param name="alphaToCoverageDitherEnable">Indicates whether alpha-to-coverage dithering is enabled</param>
|
||||
/// <param name="viewportTransformDisable">Indicates whether the viewport transform is disabled</param>
|
||||
/// <param name="depthMode">Depth mode zero to one or minus one to one</param>
|
||||
/// <param name="programPointSizeEnable">Indicates if the point size is set on the shader or is fixed</param>
|
||||
/// <param name="pointSize">Point size if not set from shader</param>
|
||||
/// <param name="alphaTestCompare">When alpha test is enabled, indicates the comparison that decides if the fragment should be discarded</param>
|
||||
/// <param name="alphaTestReference">When alpha test is enabled, indicates the value to compare with the fragment output alpha</param>
|
||||
/// <param name="attributeTypes">Type of the vertex attributes consumed by the shader</param>
|
||||
/// <param name="hasConstantBufferDrawParameters">Indicates that the draw is writing the base vertex, base instance and draw index to Constant Buffer 0</param>
|
||||
/// <param name="fragmentOutputTypes">Type of the fragment shader outputs</param>
|
||||
/// <param name="dualSourceBlendEnable">Indicates whether dual source blend is enabled</param>
|
||||
/// <param name="yNegateEnabled">Indicates if negation of the viewport Y axis is enabled</param>
|
||||
/// <param name="originUpperLeft">If true, indicates that the fragment origin is the upper left corner of the viewport, otherwise it is the lower left corner</param>
|
||||
/// <param name="halvePrimitiveId">Indicates that the primitive ID values on the shader should be halved due to quad to triangles conversion</param>
|
||||
public GpuGraphicsState(
|
||||
bool earlyZForce,
|
||||
InputTopology topology,
|
||||
bool tessCw,
|
||||
TessPatchType tessPatchType,
|
||||
TessSpacing tessSpacing,
|
||||
bool alphaToCoverageEnable,
|
||||
bool alphaToCoverageDitherEnable,
|
||||
bool viewportTransformDisable,
|
||||
bool depthMode,
|
||||
bool programPointSizeEnable,
|
||||
float pointSize,
|
||||
AlphaTestOp alphaTestCompare,
|
||||
float alphaTestReference,
|
||||
in Array32<AttributeType> attributeTypes,
|
||||
bool hasConstantBufferDrawParameters,
|
||||
in Array8<AttributeType> fragmentOutputTypes,
|
||||
bool dualSourceBlendEnable,
|
||||
bool yNegateEnabled,
|
||||
bool originUpperLeft,
|
||||
bool halvePrimitiveId)
|
||||
{
|
||||
EarlyZForce = earlyZForce;
|
||||
Topology = topology;
|
||||
TessCw = tessCw;
|
||||
TessPatchType = tessPatchType;
|
||||
TessSpacing = tessSpacing;
|
||||
AlphaToCoverageEnable = alphaToCoverageEnable;
|
||||
AlphaToCoverageDitherEnable = alphaToCoverageDitherEnable;
|
||||
ViewportTransformDisable = viewportTransformDisable;
|
||||
DepthMode = depthMode;
|
||||
ProgramPointSizeEnable = programPointSizeEnable;
|
||||
PointSize = pointSize;
|
||||
AlphaTestCompare = alphaTestCompare;
|
||||
AlphaTestReference = alphaTestReference;
|
||||
AttributeTypes = attributeTypes;
|
||||
HasConstantBufferDrawParameters = hasConstantBufferDrawParameters;
|
||||
FragmentOutputTypes = fragmentOutputTypes;
|
||||
DualSourceBlendEnable = dualSourceBlendEnable;
|
||||
YNegateEnabled = yNegateEnabled;
|
||||
OriginUpperLeft = originUpperLeft;
|
||||
HalvePrimitiveId = halvePrimitiveId;
|
||||
}
|
||||
}
|
||||
}
|
||||
502
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IGpuAccessor.cs
vendored
Normal file
502
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IGpuAccessor.cs
vendored
Normal file
@@ -0,0 +1,502 @@
|
||||
using Ryujinx.Graphics.Shader.CodeGen;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// GPU state access interface.
|
||||
/// </summary>
|
||||
public interface IGpuAccessor : ILogger
|
||||
{
|
||||
/// <summary>
|
||||
/// Reads data from the constant buffer 1.
|
||||
/// </summary>
|
||||
/// <param name="offset">Offset in bytes to read from</param>
|
||||
/// <returns>Value at the given offset</returns>
|
||||
uint ConstantBuffer1Read(int offset)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a span of the specified memory location, containing shader code.
|
||||
/// </summary>
|
||||
/// <param name="address">GPU virtual address of the data</param>
|
||||
/// <param name="minimumSize">Minimum size that the returned span may have</param>
|
||||
/// <returns>Span of the memory location</returns>
|
||||
ReadOnlySpan<ulong> GetCode(ulong address, int minimumSize);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the binding number of a constant buffer.
|
||||
/// </summary>
|
||||
/// <param name="index">Constant buffer index</param>
|
||||
/// <returns>Binding number</returns>
|
||||
SetBindingPair CreateConstantBufferBinding(int index);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the binding number of an image.
|
||||
/// </summary>
|
||||
/// <param name="count">For array of images, the number of elements of the array, otherwise it should be 1</param>
|
||||
/// <param name="isBuffer">Indicates if the image is a buffer image</param>
|
||||
/// <returns>Binding number</returns>
|
||||
SetBindingPair CreateImageBinding(int count, bool isBuffer);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the binding number of a storage buffer.
|
||||
/// </summary>
|
||||
/// <param name="index">Storage buffer index</param>
|
||||
/// <returns>Binding number</returns>
|
||||
SetBindingPair CreateStorageBufferBinding(int index);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the binding number of a texture.
|
||||
/// </summary>
|
||||
/// <param name="count">For array of textures, the number of elements of the array, otherwise it should be 1</param>
|
||||
/// <param name="isBuffer">Indicates if the texture is a buffer texture</param>
|
||||
/// <returns>Binding number</returns>
|
||||
SetBindingPair CreateTextureBinding(int count, bool isBuffer);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the set index for an additional set, or -1 if there's no extra set available.
|
||||
/// </summary>
|
||||
/// <returns>Extra set index, or -1 if not available</returns>
|
||||
int CreateExtraSet()
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Size X for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Size X</returns>
|
||||
int QueryComputeLocalSizeX()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Size Y for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Size Y</returns>
|
||||
int QueryComputeLocalSizeY()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Size Z for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Size Z</returns>
|
||||
int QueryComputeLocalSizeZ()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Local Memory size in bytes for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Local Memory size in bytes</returns>
|
||||
int QueryComputeLocalMemorySize()
|
||||
{
|
||||
return 0x1000;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Shared Memory size in bytes for compute shaders.
|
||||
/// </summary>
|
||||
/// <returns>Shared Memory size in bytes</returns>
|
||||
int QueryComputeSharedMemorySize()
|
||||
{
|
||||
return 0xc000;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries Constant Buffer usage information.
|
||||
/// </summary>
|
||||
/// <returns>A mask where each bit set indicates a bound constant buffer</returns>
|
||||
uint QueryConstantBufferUse()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries specialized GPU graphics state that the shader depends on.
|
||||
/// </summary>
|
||||
/// <returns>GPU graphics state</returns>
|
||||
GpuGraphicsState QueryGraphicsState()
|
||||
{
|
||||
return new GpuGraphicsState(
|
||||
false,
|
||||
InputTopology.Points,
|
||||
false,
|
||||
TessPatchType.Triangles,
|
||||
TessSpacing.EqualSpacing,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
1f,
|
||||
AlphaTestOp.Always,
|
||||
0f,
|
||||
default,
|
||||
true,
|
||||
default,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries whenever the current draw has written the base vertex and base instance into Constant Buffer 0.
|
||||
/// </summary>
|
||||
/// <returns>True if the shader translator can assume that the constant buffer contains the base IDs, false otherwise</returns>
|
||||
bool QueryHasConstantBufferDrawParameters()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries whenever the current draw uses unaligned storage buffer addresses.
|
||||
/// </summary>
|
||||
/// <returns>True if any storage buffer address is not aligned to 16 bytes, false otherwise</returns>
|
||||
bool QueryHasUnalignedStorageBuffer()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host's gather operation precision bits for biasing their coordinates. Zero means no bias.
|
||||
/// </summary>
|
||||
/// <returns>Bits of gather operation precision to use for coordinate bias</returns>
|
||||
int QueryHostGatherBiasPrecision()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host about whether to reduce precision to improve performance.
|
||||
/// </summary>
|
||||
/// <returns>True if precision is limited to vertex position, false otherwise</returns>
|
||||
bool QueryHostReducedPrecision()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host about the presence of the FrontFacing built-in variable bug.
|
||||
/// </summary>
|
||||
/// <returns>True if the bug is present on the host device used, false otherwise</returns>
|
||||
bool QueryHostHasFrontFacingBug()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host about the presence of the vector indexing bug.
|
||||
/// </summary>
|
||||
/// <returns>True if the bug is present on the host device used, false otherwise</returns>
|
||||
bool QueryHostHasVectorIndexingBug()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host storage buffer alignment required.
|
||||
/// </summary>
|
||||
/// <returns>Host storage buffer alignment in bytes</returns>
|
||||
int QueryHostStorageBufferOffsetAlignment()
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host shader subgroup size.
|
||||
/// </summary>
|
||||
/// <returns>Host shader subgroup size in invocations</returns>
|
||||
int QueryHostSubgroupSize()
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support for texture formats with BGRA component order (such as BGRA8).
|
||||
/// </summary>
|
||||
/// <returns>True if BGRA formats are supported, false otherwise</returns>
|
||||
bool QueryHostSupportsBgraFormat()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support for fragment shader ordering critical sections on the shader code.
|
||||
/// </summary>
|
||||
/// <returns>True if fragment shader interlock is supported, false otherwise</returns>
|
||||
bool QueryHostSupportsFragmentShaderInterlock()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support for fragment shader ordering scoped critical sections on the shader code.
|
||||
/// </summary>
|
||||
/// <returns>True if fragment shader ordering is supported, false otherwise</returns>
|
||||
bool QueryHostSupportsFragmentShaderOrderingIntel()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU geometry shader support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports geometry shaders, false otherwise</returns>
|
||||
bool QueryHostSupportsGeometryShader()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU geometry shader passthrough support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports geometry shader passthrough, false otherwise</returns>
|
||||
bool QueryHostSupportsGeometryShaderPassthrough()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support for readable images without a explicit format declaration on the shader.
|
||||
/// </summary>
|
||||
/// <returns>True if formatted image load is supported, false otherwise</returns>
|
||||
bool QueryHostSupportsImageLoadFormatted()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support for writes to the layer from vertex or tessellation shader stages.
|
||||
/// </summary>
|
||||
/// <returns>True if writes to the layer from vertex or tessellation are supported, false otherwise</returns>
|
||||
bool QueryHostSupportsLayerVertexTessellation()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU non-constant texture offset support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports non-constant texture offsets, false otherwise</returns>
|
||||
bool QueryHostSupportsNonConstantTextureOffset()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support scaled vertex formats, where a integer value is converted to floating-point.
|
||||
/// </summary>
|
||||
/// <returns>True if the host support scaled vertex formats, false otherwise</returns>
|
||||
bool QueryHostSupportsScaledVertexFormats()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host API support for separate textures and samplers.
|
||||
/// </summary>
|
||||
/// <returns>True if the API supports samplers and textures to be combined on the shader, false otherwise</returns>
|
||||
bool QueryHostSupportsSeparateSampler()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU shader ballot support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports shader ballot, false otherwise</returns>
|
||||
bool QueryHostSupportsShaderBallot()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU shader support for barrier instructions on divergent control flow paths.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU supports barriers on divergent control flow paths, false otherwise</returns>
|
||||
bool QueryHostSupportsShaderBarrierDivergence()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU support for 64-bit floating point (double precision) operations on the shader.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports double operations, false otherwise</returns>
|
||||
bool QueryHostSupportsShaderFloat64()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
bool QueryHostSupportsShaderNonUniformIndexing()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU support for signed normalized buffer texture formats.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports the formats, false otherwise</returns>
|
||||
bool QueryHostSupportsSnormBufferTextureFormat()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU texture gather with multiple offsets support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports texture gather offsets, false otherwise</returns>
|
||||
bool QueryHostSupportsTextureGatherOffsets()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU texture shadow LOD support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports texture shadow LOD, false otherwise</returns>
|
||||
bool QueryHostSupportsTextureShadowLod()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU transform feedback support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports transform feedback, false otherwise</returns>
|
||||
bool QueryHostSupportsTransformFeedback()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host support for writes to the viewport index from vertex or tessellation shader stages.
|
||||
/// </summary>
|
||||
/// <returns>True if writes to the viewport index from vertex or tessellation are supported, false otherwise</returns>
|
||||
bool QueryHostSupportsViewportIndexVertexTessellation()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries host GPU shader viewport mask output support.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports shader viewport mask output, false otherwise</returns>
|
||||
bool QueryHostSupportsViewportMask()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries whether the host supports depth clip control.
|
||||
/// </summary>
|
||||
/// <returns>True if the GPU and driver supports depth clip control, false otherwise</returns>
|
||||
bool QueryHostSupportsDepthClipControl()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the maximum number of samplers that the bound texture pool may have.
|
||||
/// </summary>
|
||||
/// <returns>Maximum amount of samplers that the pool may have</returns>
|
||||
int QuerySamplerArrayLengthFromPool();
|
||||
|
||||
/// <summary>
|
||||
/// Queries sampler type information.
|
||||
/// </summary>
|
||||
/// <param name="handle">Texture handle</param>
|
||||
/// <param name="cbufSlot">Constant buffer slot for the texture handle</param>
|
||||
/// <returns>The sampler type value for the given handle</returns>
|
||||
SamplerType QuerySamplerType(int handle, int cbufSlot = -1)
|
||||
{
|
||||
return SamplerType.Texture2D;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size in bytes of a bound constant buffer for the current shader stage.
|
||||
/// </summary>
|
||||
/// <param name="slot">The number of the constant buffer to get the size from</param>
|
||||
/// <returns>Size in bytes</returns>
|
||||
int QueryTextureArrayLengthFromBuffer(int slot);
|
||||
|
||||
/// <summary>
|
||||
/// Gets the maximum number of textures that the bound texture pool may have.
|
||||
/// </summary>
|
||||
/// <returns>Maximum amount of textures that the pool may have</returns>
|
||||
int QueryTextureArrayLengthFromPool();
|
||||
|
||||
/// <summary>
|
||||
/// Queries texture coordinate normalization information.
|
||||
/// </summary>
|
||||
/// <param name="handle">Texture handle</param>
|
||||
/// <param name="cbufSlot">Constant buffer slot for the texture handle</param>
|
||||
/// <returns>True if the coordinates are normalized, false otherwise</returns>
|
||||
bool QueryTextureCoordNormalized(int handle, int cbufSlot = -1)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries texture format information, for shaders using image load or store.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// This only returns non-compressed color formats.
|
||||
/// If the format of the texture is a compressed, depth or unsupported format, then a default value is returned.
|
||||
/// </remarks>
|
||||
/// <param name="handle">Texture handle</param>
|
||||
/// <param name="cbufSlot">Constant buffer slot for the texture handle</param>
|
||||
/// <returns>Color format of the non-compressed texture</returns>
|
||||
TextureFormat QueryTextureFormat(int handle, int cbufSlot = -1)
|
||||
{
|
||||
return TextureFormat.R8G8B8A8Unorm;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries transform feedback enable state.
|
||||
/// </summary>
|
||||
/// <returns>True if the shader uses transform feedback, false otherwise</returns>
|
||||
bool QueryTransformFeedbackEnabled()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries the varying locations that should be written to the transform feedback buffer.
|
||||
/// </summary>
|
||||
/// <param name="bufferIndex">Index of the transform feedback buffer</param>
|
||||
/// <returns>Varying locations for the specified buffer</returns>
|
||||
ReadOnlySpan<byte> QueryTransformFeedbackVaryingLocations(int bufferIndex)
|
||||
{
|
||||
return ReadOnlySpan<byte>.Empty;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Queries the stride (in bytes) of the per vertex data written into the transform feedback buffer.
|
||||
/// </summary>
|
||||
/// <param name="bufferIndex">Index of the transform feedback buffer</param>
|
||||
/// <returns>Stride for the specified buffer</returns>
|
||||
int QueryTransformFeedbackStride(int bufferIndex)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Registers a texture used by the shader.
|
||||
/// </summary>
|
||||
/// <param name="handle">Texture handle word offset</param>
|
||||
/// <param name="cbufSlot">Constant buffer slot where the texture handle is located</param>
|
||||
void RegisterTexture(int handle, int cbufSlot)
|
||||
{
|
||||
// Only useful when recording information for a disk shader cache.
|
||||
}
|
||||
}
|
||||
}
|
||||
17
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/ILogger.cs
vendored
Normal file
17
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/ILogger.cs
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen
|
||||
{
|
||||
/// <summary>
|
||||
/// Shader code generation logging interface.
|
||||
/// </summary>
|
||||
public interface ILogger
|
||||
{
|
||||
/// <summary>
|
||||
/// Prints a log message.
|
||||
/// </summary>
|
||||
/// <param name="message">Message to print</param>
|
||||
void Log(string message)
|
||||
{
|
||||
// No default log output.
|
||||
}
|
||||
}
|
||||
}
|
||||
47
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/InputTopology.cs
vendored
Normal file
47
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/InputTopology.cs
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
namespace Ryujinx.Graphics.Shader
|
||||
{
|
||||
public enum InputTopology : byte
|
||||
{
|
||||
Points,
|
||||
Lines,
|
||||
LinesAdjacency,
|
||||
Triangles,
|
||||
TrianglesAdjacency,
|
||||
}
|
||||
|
||||
static class InputTopologyExtensions
|
||||
{
|
||||
extension(InputTopology topology)
|
||||
{
|
||||
public string GlslString => topology switch
|
||||
{
|
||||
InputTopology.Points => "points",
|
||||
InputTopology.Lines => "lines",
|
||||
InputTopology.LinesAdjacency => "lines_adjacency",
|
||||
InputTopology.Triangles => "triangles",
|
||||
InputTopology.TrianglesAdjacency => "triangles_adjacency",
|
||||
_ => "points",
|
||||
};
|
||||
|
||||
public int InputVertexCount => topology switch
|
||||
{
|
||||
InputTopology.Points => 1,
|
||||
InputTopology.Lines => 2,
|
||||
InputTopology.LinesAdjacency => 4,
|
||||
InputTopology.Triangles => 3,
|
||||
InputTopology.TrianglesAdjacency => 6,
|
||||
_ => 1,
|
||||
};
|
||||
|
||||
public int InputVertexCountNoAdjacency => topology switch
|
||||
{
|
||||
InputTopology.Points => 1,
|
||||
InputTopology.Lines or
|
||||
InputTopology.LinesAdjacency => 2,
|
||||
InputTopology.Triangles or
|
||||
InputTopology.TrianglesAdjacency => 3,
|
||||
_ => 1,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
351
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/AttributeMap.cs
vendored
Normal file
351
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/AttributeMap.cs
vendored
Normal file
@@ -0,0 +1,351 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static class AttributeMap
|
||||
{
|
||||
private enum StagesMask : byte
|
||||
{
|
||||
None = 0,
|
||||
Compute = 1 << (int)ShaderStage.Compute,
|
||||
Vertex = 1 << (int)ShaderStage.Vertex,
|
||||
TessellationControl = 1 << (int)ShaderStage.TessellationControl,
|
||||
TessellationEvaluation = 1 << (int)ShaderStage.TessellationEvaluation,
|
||||
Geometry = 1 << (int)ShaderStage.Geometry,
|
||||
Fragment = 1 << (int)ShaderStage.Fragment,
|
||||
|
||||
Tessellation = TessellationControl | TessellationEvaluation,
|
||||
VertexTessellationGeometry = Vertex | Tessellation | Geometry,
|
||||
TessellationGeometryFragment = Tessellation | Geometry | Fragment,
|
||||
AllGraphics = Vertex | Tessellation | Geometry | Fragment,
|
||||
}
|
||||
|
||||
private readonly struct AttributeEntry
|
||||
{
|
||||
public int BaseOffset { get; }
|
||||
public AggregateType Type { get; }
|
||||
public IoVariable IoVariable { get; }
|
||||
public StagesMask InputMask { get; }
|
||||
public StagesMask OutputMask { get; }
|
||||
|
||||
public AttributeEntry(
|
||||
int baseOffset,
|
||||
AggregateType type,
|
||||
IoVariable ioVariable,
|
||||
StagesMask inputMask,
|
||||
StagesMask outputMask)
|
||||
{
|
||||
BaseOffset = baseOffset;
|
||||
Type = type;
|
||||
IoVariable = ioVariable;
|
||||
InputMask = inputMask;
|
||||
OutputMask = outputMask;
|
||||
}
|
||||
}
|
||||
|
||||
private static readonly ReadOnlyDictionary<int, AttributeEntry> _attributes;
|
||||
private static readonly ReadOnlyDictionary<int, AttributeEntry> _attributesPerPatch;
|
||||
|
||||
static AttributeMap()
|
||||
{
|
||||
_attributes = CreateMap();
|
||||
_attributesPerPatch = CreatePerPatchMap();
|
||||
}
|
||||
|
||||
private static ReadOnlyDictionary<int, AttributeEntry> CreateMap()
|
||||
{
|
||||
Dictionary<int, AttributeEntry> map = new();
|
||||
|
||||
Add(map, 0x060, AggregateType.S32, IoVariable.PrimitiveId, StagesMask.TessellationGeometryFragment, StagesMask.Geometry);
|
||||
Add(map, 0x064, AggregateType.S32, IoVariable.Layer, StagesMask.Fragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x068, AggregateType.S32, IoVariable.ViewportIndex, StagesMask.Fragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x06c, AggregateType.FP32, IoVariable.PointSize, StagesMask.None, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x070, AggregateType.Vector4 | AggregateType.FP32, IoVariable.Position, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x080, AggregateType.Vector4 | AggregateType.FP32, IoVariable.UserDefined, StagesMask.AllGraphics, StagesMask.VertexTessellationGeometry, 32);
|
||||
Add(map, 0x280, AggregateType.Vector4 | AggregateType.FP32, IoVariable.FrontColorDiffuse, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x290, AggregateType.Vector4 | AggregateType.FP32, IoVariable.FrontColorSpecular, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x2a0, AggregateType.Vector4 | AggregateType.FP32, IoVariable.BackColorDiffuse, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x2b0, AggregateType.Vector4 | AggregateType.FP32, IoVariable.BackColorSpecular, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x2c0, AggregateType.Array | AggregateType.FP32, IoVariable.ClipDistance, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry, 8);
|
||||
Add(map, 0x2e0, AggregateType.Vector2 | AggregateType.FP32, IoVariable.PointCoord, StagesMask.Fragment, StagesMask.None);
|
||||
Add(map, 0x2e8, AggregateType.FP32, IoVariable.FogCoord, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x2f0, AggregateType.Vector2 | AggregateType.FP32, IoVariable.TessellationCoord, StagesMask.TessellationEvaluation, StagesMask.None);
|
||||
Add(map, 0x2f8, AggregateType.S32, IoVariable.InstanceId, StagesMask.Vertex, StagesMask.None);
|
||||
Add(map, 0x2fc, AggregateType.S32, IoVariable.VertexId, StagesMask.Vertex, StagesMask.None);
|
||||
Add(map, 0x300, AggregateType.Vector4 | AggregateType.FP32, IoVariable.TextureCoord, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x3a0, AggregateType.Array | AggregateType.S32, IoVariable.ViewportMask, StagesMask.Fragment, StagesMask.VertexTessellationGeometry);
|
||||
Add(map, 0x3fc, AggregateType.Bool, IoVariable.FrontFacing, StagesMask.Fragment, StagesMask.None);
|
||||
|
||||
return map.AsReadOnly();
|
||||
}
|
||||
|
||||
private static ReadOnlyDictionary<int, AttributeEntry> CreatePerPatchMap()
|
||||
{
|
||||
Dictionary<int, AttributeEntry> map = new();
|
||||
|
||||
Add(map, 0x000, AggregateType.Vector4 | AggregateType.FP32, IoVariable.TessellationLevelOuter, StagesMask.TessellationEvaluation, StagesMask.TessellationControl);
|
||||
Add(map, 0x010, AggregateType.Vector2 | AggregateType.FP32, IoVariable.TessellationLevelInner, StagesMask.TessellationEvaluation, StagesMask.TessellationControl);
|
||||
Add(map, 0x018, AggregateType.Vector4 | AggregateType.FP32, IoVariable.UserDefined, StagesMask.TessellationEvaluation, StagesMask.TessellationControl, 31, 0x200);
|
||||
|
||||
return map.AsReadOnly();
|
||||
}
|
||||
|
||||
private static void Add(
|
||||
Dictionary<int, AttributeEntry> attributes,
|
||||
int offset,
|
||||
AggregateType type,
|
||||
IoVariable ioVariable,
|
||||
StagesMask inputMask,
|
||||
StagesMask outputMask,
|
||||
int count = 1,
|
||||
int upperBound = 0x400)
|
||||
{
|
||||
int baseOffset = offset;
|
||||
|
||||
int elementsCount = GetElementCount(type);
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
for (int elementIndex = 0; elementIndex < elementsCount; elementIndex++)
|
||||
{
|
||||
attributes.Add(offset, new AttributeEntry(baseOffset, type, ioVariable, inputMask, outputMask));
|
||||
|
||||
offset += 4;
|
||||
|
||||
if (offset >= upperBound)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static Operand GenerateAttributeLoad(EmitterContext context, Operand primVertex, int offset, bool isOutput, bool isPerPatch)
|
||||
{
|
||||
if (!(isPerPatch ? _attributesPerPatch : _attributes).TryGetValue(offset, out AttributeEntry entry))
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Attribute offset 0x{offset:X} is not valid.");
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
StagesMask validUseMask = isOutput ? entry.OutputMask : entry.InputMask;
|
||||
|
||||
if (((StagesMask)(1 << (int)context.TranslatorContext.Definitions.Stage) & validUseMask) == StagesMask.None)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not valid for stage {context.TranslatorContext.Definitions.Stage}.");
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
if (!IsSupportedByHost(context.TranslatorContext.GpuAccessor, context.TranslatorContext.Definitions.Stage, entry.IoVariable))
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not supported by the host for stage {context.TranslatorContext.Definitions.Stage}.");
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
if (HasInvocationId(context.TranslatorContext.Definitions.Stage, isOutput) && !isPerPatch)
|
||||
{
|
||||
primVertex = context.Load(StorageKind.Input, IoVariable.InvocationId);
|
||||
}
|
||||
|
||||
int innerOffset = offset - entry.BaseOffset;
|
||||
int innerIndex = innerOffset / 4;
|
||||
|
||||
StorageKind storageKind = isPerPatch
|
||||
? (isOutput ? StorageKind.OutputPerPatch : StorageKind.InputPerPatch)
|
||||
: (isOutput ? StorageKind.Output : StorageKind.Input);
|
||||
IoVariable ioVariable = GetIoVariable(context.TranslatorContext.Definitions.Stage, in entry);
|
||||
AggregateType type = GetType(context.TranslatorContext.Definitions, isOutput, innerIndex, in entry);
|
||||
int elementCount = GetElementCount(type);
|
||||
|
||||
bool isArray = type.HasFlag(AggregateType.Array);
|
||||
bool hasArrayIndex = isArray || context.TranslatorContext.Definitions.HasPerLocationInputOrOutput(ioVariable, isOutput);
|
||||
|
||||
bool hasElementIndex = elementCount > 1;
|
||||
|
||||
if (hasArrayIndex && hasElementIndex)
|
||||
{
|
||||
int arrayIndex = innerIndex / elementCount;
|
||||
int elementIndex = innerIndex - (arrayIndex * elementCount);
|
||||
|
||||
return primVertex == null || isArray
|
||||
? context.Load(storageKind, ioVariable, primVertex, Const(arrayIndex), Const(elementIndex))
|
||||
: context.Load(storageKind, ioVariable, Const(arrayIndex), primVertex, Const(elementIndex));
|
||||
}
|
||||
else if (hasArrayIndex || hasElementIndex)
|
||||
{
|
||||
return primVertex == null || isArray || !hasArrayIndex
|
||||
? context.Load(storageKind, ioVariable, primVertex, Const(innerIndex))
|
||||
: context.Load(storageKind, ioVariable, Const(innerIndex), primVertex);
|
||||
}
|
||||
else
|
||||
{
|
||||
return context.Load(storageKind, ioVariable, primVertex);
|
||||
}
|
||||
}
|
||||
|
||||
public static void GenerateAttributeStore(EmitterContext context, int offset, bool isPerPatch, Operand value)
|
||||
{
|
||||
if (!(isPerPatch ? _attributesPerPatch : _attributes).TryGetValue(offset, out AttributeEntry entry))
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Attribute offset 0x{offset:X} is not valid.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (((StagesMask)(1 << (int)context.TranslatorContext.Definitions.Stage) & entry.OutputMask) == StagesMask.None)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not valid for stage {context.TranslatorContext.Definitions.Stage}.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!IsSupportedByHost(context.TranslatorContext.GpuAccessor, context.TranslatorContext.Definitions.Stage, entry.IoVariable))
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not supported by the host for stage {context.TranslatorContext.Definitions.Stage}.");
|
||||
return;
|
||||
}
|
||||
|
||||
Operand invocationId = null;
|
||||
|
||||
if (HasInvocationId(context.TranslatorContext.Definitions.Stage, isOutput: true) && !isPerPatch)
|
||||
{
|
||||
invocationId = context.Load(StorageKind.Input, IoVariable.InvocationId);
|
||||
}
|
||||
|
||||
int innerOffset = offset - entry.BaseOffset;
|
||||
int innerIndex = innerOffset / 4;
|
||||
|
||||
StorageKind storageKind = isPerPatch ? StorageKind.OutputPerPatch : StorageKind.Output;
|
||||
IoVariable ioVariable = GetIoVariable(context.TranslatorContext.Definitions.Stage, in entry);
|
||||
AggregateType type = GetType(context.TranslatorContext.Definitions, isOutput: true, innerIndex, in entry);
|
||||
int elementCount = GetElementCount(type);
|
||||
|
||||
bool isArray = type.HasFlag(AggregateType.Array);
|
||||
bool hasArrayIndex = isArray || context.TranslatorContext.Definitions.HasPerLocationInputOrOutput(ioVariable, isOutput: true);
|
||||
|
||||
bool hasElementIndex = elementCount > 1;
|
||||
|
||||
if (hasArrayIndex && hasElementIndex)
|
||||
{
|
||||
int arrayIndex = innerIndex / elementCount;
|
||||
int elementIndex = innerIndex - (arrayIndex * elementCount);
|
||||
|
||||
if (invocationId == null || isArray)
|
||||
{
|
||||
context.Store(storageKind, ioVariable, invocationId, Const(arrayIndex), Const(elementIndex), value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Store(storageKind, ioVariable, Const(arrayIndex), invocationId, Const(elementIndex), value);
|
||||
}
|
||||
}
|
||||
else if (hasArrayIndex || hasElementIndex)
|
||||
{
|
||||
if (invocationId == null || isArray || !hasArrayIndex)
|
||||
{
|
||||
context.Store(storageKind, ioVariable, invocationId, Const(innerIndex), value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Store(storageKind, ioVariable, Const(innerIndex), invocationId, value);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Store(storageKind, ioVariable, invocationId, value);
|
||||
}
|
||||
}
|
||||
|
||||
private static bool IsSupportedByHost(IGpuAccessor gpuAccessor, ShaderStage stage, IoVariable ioVariable)
|
||||
{
|
||||
if (ioVariable == IoVariable.ViewportIndex && stage != ShaderStage.Geometry && stage != ShaderStage.Fragment)
|
||||
{
|
||||
return gpuAccessor.QueryHostSupportsViewportIndexVertexTessellation();
|
||||
}
|
||||
else if (ioVariable == IoVariable.ViewportMask)
|
||||
{
|
||||
return gpuAccessor.QueryHostSupportsViewportMask();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static IoVariable GetIoVariable(ShaderDefinitions definitions, int offset, out int location)
|
||||
{
|
||||
location = 0;
|
||||
|
||||
if (!_attributes.TryGetValue(offset, out AttributeEntry entry))
|
||||
{
|
||||
return IoVariable.Invalid;
|
||||
}
|
||||
|
||||
if (((StagesMask)(1 << (int)definitions.Stage) & entry.OutputMask) == StagesMask.None)
|
||||
{
|
||||
return IoVariable.Invalid;
|
||||
}
|
||||
|
||||
if (definitions.HasPerLocationInputOrOutput(entry.IoVariable, isOutput: true))
|
||||
{
|
||||
location = (offset - entry.BaseOffset) / 16;
|
||||
}
|
||||
|
||||
return GetIoVariable(definitions.Stage, in entry);
|
||||
}
|
||||
|
||||
private static IoVariable GetIoVariable(ShaderStage stage, in AttributeEntry entry)
|
||||
{
|
||||
if (entry.IoVariable == IoVariable.Position && stage == ShaderStage.Fragment)
|
||||
{
|
||||
return IoVariable.FragmentCoord;
|
||||
}
|
||||
|
||||
return entry.IoVariable;
|
||||
}
|
||||
|
||||
private static AggregateType GetType(ShaderDefinitions definitions, bool isOutput, int innerIndex, in AttributeEntry entry)
|
||||
{
|
||||
AggregateType type = entry.Type;
|
||||
|
||||
if (entry.IoVariable == IoVariable.UserDefined)
|
||||
{
|
||||
type = definitions.GetUserDefinedType(innerIndex / 4, isOutput);
|
||||
}
|
||||
else if (entry.IoVariable == IoVariable.FragmentOutputColor)
|
||||
{
|
||||
type = definitions.GetFragmentOutputColorType(innerIndex / 4);
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
public static bool HasPrimitiveVertex(ShaderStage stage, bool isOutput)
|
||||
{
|
||||
if (isOutput)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return stage is ShaderStage.TessellationControl or
|
||||
ShaderStage.TessellationEvaluation or
|
||||
ShaderStage.Geometry;
|
||||
}
|
||||
|
||||
public static bool HasInvocationId(ShaderStage stage, bool isOutput)
|
||||
{
|
||||
return isOutput && stage == ShaderStage.TessellationControl;
|
||||
}
|
||||
|
||||
private static int GetElementCount(AggregateType type)
|
||||
{
|
||||
return (type & AggregateType.ElementCountMask) switch
|
||||
{
|
||||
AggregateType.Vector2 => 2,
|
||||
AggregateType.Vector3 => 3,
|
||||
AggregateType.Vector4 => 4,
|
||||
_ => 1,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
359
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs
vendored
Normal file
359
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs
vendored
Normal file
@@ -0,0 +1,359 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void AtomCas(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstAtomCas>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction AtomCas is not implemented.");
|
||||
}
|
||||
|
||||
public static void AtomsCas(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstAtomsCas>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction AtomsCas is not implemented.");
|
||||
}
|
||||
|
||||
public static void B2r(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstB2r>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction B2r is not implemented.");
|
||||
}
|
||||
|
||||
public static void Bpt(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstBpt>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Bpt is not implemented.");
|
||||
}
|
||||
|
||||
public static void Cctl(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstCctl>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Cctl is not implemented.");
|
||||
}
|
||||
|
||||
public static void Cctll(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstCctll>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Cctll is not implemented.");
|
||||
}
|
||||
|
||||
public static void Cctlt(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstCctlt>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Cctlt is not implemented.");
|
||||
}
|
||||
|
||||
public static void Cs2r(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstCs2r>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Cs2r is not implemented.");
|
||||
}
|
||||
|
||||
public static void FchkR(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstFchkR>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction FchkR is not implemented.");
|
||||
}
|
||||
|
||||
public static void FchkI(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstFchkI>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction FchkI is not implemented.");
|
||||
}
|
||||
|
||||
public static void FchkC(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstFchkC>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction FchkC is not implemented.");
|
||||
}
|
||||
|
||||
public static void Getcrsptr(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstGetcrsptr>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Getcrsptr is not implemented.");
|
||||
}
|
||||
|
||||
public static void Getlmembase(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstGetlmembase>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Getlmembase is not implemented.");
|
||||
}
|
||||
|
||||
public static void Ide(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstIde>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Ide is not implemented.");
|
||||
}
|
||||
|
||||
public static void IdpR(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstIdpR>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction IdpR is not implemented.");
|
||||
}
|
||||
|
||||
public static void IdpC(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstIdpC>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction IdpC is not implemented.");
|
||||
}
|
||||
|
||||
public static void ImadspR(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstImadspR>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction ImadspR is not implemented.");
|
||||
}
|
||||
|
||||
public static void ImadspI(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstImadspI>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction ImadspI is not implemented.");
|
||||
}
|
||||
|
||||
public static void ImadspC(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstImadspC>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction ImadspC is not implemented.");
|
||||
}
|
||||
|
||||
public static void ImadspRc(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstImadspRc>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction ImadspRc is not implemented.");
|
||||
}
|
||||
|
||||
public static void Jcal(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstJcal>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Jcal is not implemented.");
|
||||
}
|
||||
|
||||
public static void Jmp(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstJmp>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Jmp is not implemented.");
|
||||
}
|
||||
|
||||
public static void Jmx(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstJmx>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Jmx is not implemented.");
|
||||
}
|
||||
|
||||
public static void Ld(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstLd>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Ld is not implemented.");
|
||||
}
|
||||
|
||||
public static void Lepc(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstLepc>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Lepc is not implemented.");
|
||||
}
|
||||
|
||||
public static void Longjmp(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstLongjmp>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Longjmp is not implemented.");
|
||||
}
|
||||
|
||||
public static void Pexit(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPexit>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Pexit is not implemented.");
|
||||
}
|
||||
|
||||
public static void Pixld(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPixld>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Pixld is not implemented.");
|
||||
}
|
||||
|
||||
public static void Plongjmp(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPlongjmp>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Plongjmp is not implemented.");
|
||||
}
|
||||
|
||||
public static void Pret(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPret>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Pret is not implemented.");
|
||||
}
|
||||
|
||||
public static void PrmtR(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPrmtR>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtR is not implemented.");
|
||||
}
|
||||
|
||||
public static void PrmtI(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPrmtI>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtI is not implemented.");
|
||||
}
|
||||
|
||||
public static void PrmtC(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPrmtC>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtC is not implemented.");
|
||||
}
|
||||
|
||||
public static void PrmtRc(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPrmtRc>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtRc is not implemented.");
|
||||
}
|
||||
|
||||
public static void R2b(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstR2b>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction R2b is not implemented.");
|
||||
}
|
||||
|
||||
public static void Ram(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstRam>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Ram is not implemented.");
|
||||
}
|
||||
|
||||
public static void Rtt(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstRtt>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Rtt is not implemented.");
|
||||
}
|
||||
|
||||
public static void Sam(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstSam>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Sam is not implemented.");
|
||||
}
|
||||
|
||||
public static void Setcrsptr(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstSetcrsptr>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Setcrsptr is not implemented.");
|
||||
}
|
||||
|
||||
public static void Setlmembase(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstSetlmembase>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Setlmembase is not implemented.");
|
||||
}
|
||||
|
||||
public static void St(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstSt>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction St is not implemented.");
|
||||
}
|
||||
|
||||
public static void Stp(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstStp>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Stp is not implemented.");
|
||||
}
|
||||
|
||||
public static void Txa(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstTxa>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Txa is not implemented.");
|
||||
}
|
||||
|
||||
public static void Vabsdiff(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVabsdiff>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Vabsdiff is not implemented.");
|
||||
}
|
||||
|
||||
public static void Vabsdiff4(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVabsdiff4>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Vabsdiff4 is not implemented.");
|
||||
}
|
||||
|
||||
public static void Vadd(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVadd>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Vadd is not implemented.");
|
||||
}
|
||||
|
||||
public static void Votevtg(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVotevtg>();
|
||||
|
||||
// This instruction is proprietary and will not be implemented. Commenting it out to avoid false reports.
|
||||
//context.TranslatorContext.GpuAccessor.Log("Shader instruction Votevtg is not implemented.");
|
||||
}
|
||||
|
||||
public static void Vset(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVset>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Vset is not implemented.");
|
||||
}
|
||||
|
||||
public static void Vshl(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVshl>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Vshl is not implemented.");
|
||||
}
|
||||
|
||||
public static void Vshr(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstVshr>();
|
||||
|
||||
context.TranslatorContext.GpuAccessor.Log("Shader instruction Vshr is not implemented.");
|
||||
}
|
||||
}
|
||||
}
|
||||
159
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitAluHelper.cs
vendored
Normal file
159
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitAluHelper.cs
vendored
Normal file
@@ -0,0 +1,159 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static class InstEmitAluHelper
|
||||
{
|
||||
public static long GetIntMin(IDstFmt type)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
IDstFmt.U16 => ushort.MinValue,
|
||||
IDstFmt.S16 => short.MinValue,
|
||||
IDstFmt.U32 => uint.MinValue,
|
||||
IDstFmt.S32 => int.MinValue,
|
||||
_ => throw new ArgumentException($"The type \"{type}\" is not a supported integer type."),
|
||||
};
|
||||
}
|
||||
|
||||
public static long GetIntMax(IDstFmt type)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
IDstFmt.U16 => ushort.MaxValue,
|
||||
IDstFmt.S16 => short.MaxValue,
|
||||
IDstFmt.U32 => uint.MaxValue,
|
||||
IDstFmt.S32 => int.MaxValue,
|
||||
_ => throw new ArgumentException($"The type \"{type}\" is not a supported integer type."),
|
||||
};
|
||||
}
|
||||
|
||||
public static long GetIntMin(ISrcDstFmt type)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
ISrcDstFmt.U8 => byte.MinValue,
|
||||
ISrcDstFmt.S8 => sbyte.MinValue,
|
||||
ISrcDstFmt.U16 => ushort.MinValue,
|
||||
ISrcDstFmt.S16 => short.MinValue,
|
||||
ISrcDstFmt.U32 => uint.MinValue,
|
||||
ISrcDstFmt.S32 => int.MinValue,
|
||||
_ => throw new ArgumentException($"The type \"{type}\" is not a supported integer type."),
|
||||
};
|
||||
}
|
||||
|
||||
public static long GetIntMax(ISrcDstFmt type)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
ISrcDstFmt.U8 => byte.MaxValue,
|
||||
ISrcDstFmt.S8 => sbyte.MaxValue,
|
||||
ISrcDstFmt.U16 => ushort.MaxValue,
|
||||
ISrcDstFmt.S16 => short.MaxValue,
|
||||
ISrcDstFmt.U32 => uint.MaxValue,
|
||||
ISrcDstFmt.S32 => int.MaxValue,
|
||||
_ => throw new ArgumentException($"The type \"{type}\" is not a supported integer type."),
|
||||
};
|
||||
}
|
||||
|
||||
public static Operand GetPredLogicalOp(EmitterContext context, BoolOp logicOp, Operand input, Operand pred)
|
||||
{
|
||||
return logicOp switch
|
||||
{
|
||||
BoolOp.And => context.BitwiseAnd(input, pred),
|
||||
BoolOp.Or => context.BitwiseOr(input, pred),
|
||||
BoolOp.Xor => context.BitwiseExclusiveOr(input, pred),
|
||||
_ => input,
|
||||
};
|
||||
}
|
||||
|
||||
public static Operand Extend(EmitterContext context, Operand src, VectorSelect type)
|
||||
{
|
||||
return type switch
|
||||
{
|
||||
VectorSelect.U8B0 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(0)), 8),
|
||||
VectorSelect.U8B1 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(8)), 8),
|
||||
VectorSelect.U8B2 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(16)), 8),
|
||||
VectorSelect.U8B3 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(24)), 8),
|
||||
VectorSelect.U16H0 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(0)), 16),
|
||||
VectorSelect.U16H1 => ZeroExtendTo32(context, context.ShiftRightU32(src, Const(16)), 16),
|
||||
VectorSelect.S8B0 => SignExtendTo32(context, context.ShiftRightU32(src, Const(0)), 8),
|
||||
VectorSelect.S8B1 => SignExtendTo32(context, context.ShiftRightU32(src, Const(8)), 8),
|
||||
VectorSelect.S8B2 => SignExtendTo32(context, context.ShiftRightU32(src, Const(16)), 8),
|
||||
VectorSelect.S8B3 => SignExtendTo32(context, context.ShiftRightU32(src, Const(24)), 8),
|
||||
VectorSelect.S16H0 => SignExtendTo32(context, context.ShiftRightU32(src, Const(0)), 16),
|
||||
VectorSelect.S16H1 => SignExtendTo32(context, context.ShiftRightU32(src, Const(16)), 16),
|
||||
_ => src,
|
||||
};
|
||||
}
|
||||
|
||||
public static void SetZnFlags(EmitterContext context, Operand dest, bool setCC, bool extended = false)
|
||||
{
|
||||
if (!setCC)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (extended)
|
||||
{
|
||||
// When the operation is extended, it means we are doing
|
||||
// the operation on a long word with any number of bits,
|
||||
// so we need to AND the zero flag from result with the
|
||||
// previous result when extended is specified, to ensure
|
||||
// we have ZF set only if all words are zero, and not just
|
||||
// the last one.
|
||||
Operand oldZF = GetZF();
|
||||
|
||||
Operand res = context.BitwiseAnd(context.ICompareEqual(dest, Const(0)), oldZF);
|
||||
|
||||
context.Copy(GetZF(), res);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Copy(GetZF(), context.ICompareEqual(dest, Const(0)));
|
||||
}
|
||||
|
||||
context.Copy(GetNF(), context.ICompareLess(dest, Const(0)));
|
||||
}
|
||||
|
||||
public static void SetFPZnFlags(EmitterContext context, Operand dest, bool setCC, Instruction fpType = Instruction.FP32)
|
||||
{
|
||||
if (setCC)
|
||||
{
|
||||
Operand zero = ConstF(0);
|
||||
|
||||
if (fpType == Instruction.FP64)
|
||||
{
|
||||
zero = context.FP32ConvertToFP64(zero);
|
||||
}
|
||||
|
||||
context.Copy(GetZF(), context.FPCompareEqual(dest, zero, fpType));
|
||||
context.Copy(GetNF(), context.FPCompareLess(dest, zero, fpType));
|
||||
}
|
||||
}
|
||||
|
||||
public static (Operand, Operand) NegateLong(EmitterContext context, Operand low, Operand high)
|
||||
{
|
||||
low = context.BitwiseNot(low);
|
||||
high = context.BitwiseNot(high);
|
||||
low = AddWithCarry(context, low, Const(1), out Operand carryOut);
|
||||
high = context.IAdd(high, carryOut);
|
||||
return (low, high);
|
||||
}
|
||||
|
||||
public static Operand AddWithCarry(EmitterContext context, Operand lhs, Operand rhs, out Operand carryOut)
|
||||
{
|
||||
Operand result = context.IAdd(lhs, rhs);
|
||||
|
||||
// C = Rd < Rn
|
||||
carryOut = context.INegate(context.ICompareLessUnsigned(result, lhs));
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
409
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitAttribute.cs
vendored
Normal file
409
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitAttribute.cs
vendored
Normal file
@@ -0,0 +1,409 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Al2p(EmitterContext context)
|
||||
{
|
||||
InstAl2p op = context.GetOp<InstAl2p>();
|
||||
|
||||
context.Copy(GetDest(op.Dest), context.IAdd(GetSrcReg(context, op.SrcA), Const(op.Imm11)));
|
||||
}
|
||||
|
||||
public static void Ald(EmitterContext context)
|
||||
{
|
||||
InstAld op = context.GetOp<InstAld>();
|
||||
|
||||
// Some of those attributes are per invocation,
|
||||
// so we should ignore any primitive vertex indexing for those.
|
||||
bool hasPrimitiveVertex = AttributeMap.HasPrimitiveVertex(context.TranslatorContext.Definitions.Stage, op.O) && !op.P;
|
||||
|
||||
if (!op.Phys)
|
||||
{
|
||||
hasPrimitiveVertex &= HasPrimitiveVertex(op.Imm11);
|
||||
}
|
||||
|
||||
Operand primVertex = hasPrimitiveVertex ? context.Copy(GetSrcReg(context, op.SrcB)) : null;
|
||||
|
||||
for (int index = 0; index < (int)op.AlSize + 1; index++)
|
||||
{
|
||||
Register rd = new(op.Dest + index, RegisterType.Gpr);
|
||||
|
||||
if (rd.IsRZ)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if (op.Phys)
|
||||
{
|
||||
Operand offset = context.ISubtract(GetSrcReg(context, op.SrcA), Const(AttributeConsts.UserAttributeBase));
|
||||
Operand vecIndex = context.ShiftRightU32(offset, Const(4));
|
||||
Operand elemIndex = context.BitwiseAnd(context.ShiftRightU32(offset, Const(2)), Const(3));
|
||||
|
||||
StorageKind storageKind = op.O ? StorageKind.Output : StorageKind.Input;
|
||||
|
||||
context.Copy(Register(rd), context.Load(storageKind, IoVariable.UserDefined, primVertex, vecIndex, elemIndex));
|
||||
}
|
||||
else if (op.SrcB == RegisterConsts.RegisterZeroIndex || op.P)
|
||||
{
|
||||
int offset = FixedFuncToUserAttribute(context.TranslatorContext, op.Imm11 + index * 4, op.O);
|
||||
bool isOutput = op.O && CanLoadOutput(offset);
|
||||
|
||||
if (!op.P && !isOutput && TryConvertIdToIndexForVulkan(context, offset, out Operand value))
|
||||
{
|
||||
context.Copy(Register(rd), value);
|
||||
}
|
||||
else
|
||||
{
|
||||
value = AttributeMap.GenerateAttributeLoad(context, primVertex, offset, isOutput, op.P);
|
||||
|
||||
if ((!context.TranslatorContext.Definitions.SupportsScaledVertexFormats || context.VertexAsCompute) &&
|
||||
context.TranslatorContext.Stage == ShaderStage.Vertex &&
|
||||
!op.O &&
|
||||
offset >= 0x80 &&
|
||||
offset < 0x280)
|
||||
{
|
||||
// The host does not support scaled vertex formats,
|
||||
// the emulator should use a integer format, and
|
||||
// we compensate here inserting the conversion to float.
|
||||
|
||||
AttributeType type = context.TranslatorContext.Definitions.GetAttributeType((offset - 0x80) >> 4);
|
||||
|
||||
if (type == AttributeType.Sscaled)
|
||||
{
|
||||
value = context.IConvertS32ToFP32(value);
|
||||
}
|
||||
else if (type == AttributeType.Uscaled)
|
||||
{
|
||||
value = context.IConvertU32ToFP32(value);
|
||||
}
|
||||
}
|
||||
else if (offset == AttributeConsts.PrimitiveId && context.TranslatorContext.Definitions.HalvePrimitiveId)
|
||||
{
|
||||
value = context.ShiftRightS32(value, Const(1));
|
||||
}
|
||||
|
||||
context.Copy(Register(rd), value);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int offset = FixedFuncToUserAttribute(context.TranslatorContext, op.Imm11 + index * 4, op.O);
|
||||
bool isOutput = op.O && CanLoadOutput(offset);
|
||||
|
||||
context.Copy(Register(rd), AttributeMap.GenerateAttributeLoad(context, primVertex, offset, isOutput, false));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void Ast(EmitterContext context)
|
||||
{
|
||||
InstAst op = context.GetOp<InstAst>();
|
||||
|
||||
for (int index = 0; index < (int)op.AlSize + 1; index++)
|
||||
{
|
||||
if (op.SrcB + index > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
Register rd = new(op.SrcB + index, RegisterType.Gpr);
|
||||
|
||||
if (op.Phys)
|
||||
{
|
||||
Operand offset = context.ISubtract(GetSrcReg(context, op.SrcA), Const(AttributeConsts.UserAttributeBase));
|
||||
Operand vecIndex = context.ShiftRightU32(offset, Const(4));
|
||||
Operand elemIndex = context.BitwiseAnd(context.ShiftRightU32(offset, Const(2)), Const(3));
|
||||
Operand invocationId = AttributeMap.HasInvocationId(context.TranslatorContext.Definitions.Stage, isOutput: true)
|
||||
? context.Load(StorageKind.Input, IoVariable.InvocationId)
|
||||
: null;
|
||||
|
||||
context.Store(StorageKind.Output, IoVariable.UserDefined, invocationId, vecIndex, elemIndex, Register(rd));
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Support indirect stores using Ra.
|
||||
|
||||
int offset = op.Imm11 + index * 4;
|
||||
|
||||
if (!context.TranslatorContext.AttributeUsage.IsUsedOutputAttribute(offset))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
offset = FixedFuncToUserAttribute(context.TranslatorContext, offset, isOutput: true);
|
||||
AttributeMap.GenerateAttributeStore(context, offset, op.P, Register(rd));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void Ipa(EmitterContext context)
|
||||
{
|
||||
InstIpa op = context.GetOp<InstIpa>();
|
||||
|
||||
Operand res;
|
||||
|
||||
bool isFixedFunc = false;
|
||||
|
||||
if (op.Idx)
|
||||
{
|
||||
Operand offset = context.ISubtract(GetSrcReg(context, op.SrcA), Const(AttributeConsts.UserAttributeBase));
|
||||
Operand vecIndex = context.ShiftRightU32(offset, Const(4));
|
||||
Operand elemIndex = context.BitwiseAnd(context.ShiftRightU32(offset, Const(2)), Const(3));
|
||||
|
||||
res = context.Load(StorageKind.Input, IoVariable.UserDefined, null, vecIndex, elemIndex);
|
||||
res = context.FPMultiply(res, context.Load(StorageKind.Input, IoVariable.FragmentCoord, null, Const(3)));
|
||||
}
|
||||
else
|
||||
{
|
||||
isFixedFunc = TryFixedFuncToUserAttributeIpa(context, op.Imm10, out res);
|
||||
|
||||
if (op.Imm10 is >= AttributeConsts.UserAttributeBase and < AttributeConsts.UserAttributeEnd)
|
||||
{
|
||||
int index = (op.Imm10 - AttributeConsts.UserAttributeBase) >> 4;
|
||||
|
||||
if (context.TranslatorContext.Definitions.ImapTypes[index].GetFirstUsedType() == PixelImap.Perspective)
|
||||
{
|
||||
res = context.FPMultiply(res, context.Load(StorageKind.Input, IoVariable.FragmentCoord, null, Const(3)));
|
||||
}
|
||||
}
|
||||
else if (op.Imm10 is AttributeConsts.PositionX or AttributeConsts.PositionY)
|
||||
{
|
||||
// FragCoord X/Y must be divided by the render target scale, if resolution scaling is active,
|
||||
// because the shader code is not expecting scaled values.
|
||||
res = context.FPDivide(res, context.Load(StorageKind.ConstantBuffer, SupportBuffer.Binding, Const((int)SupportBufferField.RenderScale), Const(0)));
|
||||
|
||||
if (op.Imm10 == AttributeConsts.PositionY && context.TranslatorContext.Options.TargetApi != TargetApi.OpenGL)
|
||||
{
|
||||
// If YNegate is enabled, we need to flip the fragment coordinates vertically, unless
|
||||
// the API supports changing the origin (only OpenGL does).
|
||||
if (context.TranslatorContext.Definitions.YNegateEnabled)
|
||||
{
|
||||
Operand viewportHeight = context.Load(StorageKind.ConstantBuffer, 0, Const((int)SupportBufferField.ViewportSize), Const(1));
|
||||
|
||||
res = context.FPSubtract(viewportHeight, res);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (op.Imm10 == AttributeConsts.PrimitiveId && context.TranslatorContext.Definitions.HalvePrimitiveId)
|
||||
{
|
||||
// If quads are used, but the host does not support them, they need to be converted to triangles.
|
||||
// Since each quad becomes 2 triangles, we need to compensate here and divide primitive ID by 2.
|
||||
res = context.ShiftRightS32(res, Const(1));
|
||||
}
|
||||
else if (op.Imm10 == AttributeConsts.FrontFacing && context.TranslatorContext.GpuAccessor.QueryHostHasFrontFacingBug())
|
||||
{
|
||||
// gl_FrontFacing sometimes has incorrect (flipped) values depending how it is accessed on Intel GPUs.
|
||||
// This weird trick makes it behave.
|
||||
res = context.ICompareLess(context.INegate(context.FP32ConvertToS32(context.ConditionalSelect(res, ConstF(1f), ConstF(0f)))), Const(0));
|
||||
}
|
||||
}
|
||||
|
||||
if (op.IpaOp == IpaOp.Multiply && !isFixedFunc)
|
||||
{
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
res = context.FPMultiply(res, srcB);
|
||||
}
|
||||
|
||||
res = context.FPSaturate(res, op.Sat);
|
||||
|
||||
context.Copy(GetDest(op.Dest), res);
|
||||
}
|
||||
|
||||
public static void Isberd(EmitterContext context)
|
||||
{
|
||||
InstIsberd op = context.GetOp<InstIsberd>();
|
||||
|
||||
// This instruction performs a load from ISBE (Internal Stage Buffer Entry) memory.
|
||||
// Here, we just propagate the offset, as the result from this instruction is usually
|
||||
// used with ALD to perform vertex load on geometry or tessellation shaders.
|
||||
// The offset is calculated as (PrimitiveIndex * VerticesPerPrimitive) + VertexIndex.
|
||||
// Since we hardcode PrimitiveIndex to zero, then the offset will be just VertexIndex.
|
||||
context.Copy(GetDest(op.Dest), GetSrcReg(context, op.SrcA));
|
||||
}
|
||||
|
||||
public static void OutR(EmitterContext context)
|
||||
{
|
||||
InstOutR op = context.GetOp<InstOutR>();
|
||||
|
||||
EmitOut(context, op.OutType.HasFlag(OutType.Emit), op.OutType.HasFlag(OutType.Cut));
|
||||
}
|
||||
|
||||
public static void OutI(EmitterContext context)
|
||||
{
|
||||
InstOutI op = context.GetOp<InstOutI>();
|
||||
|
||||
EmitOut(context, op.OutType.HasFlag(OutType.Emit), op.OutType.HasFlag(OutType.Cut));
|
||||
}
|
||||
|
||||
public static void OutC(EmitterContext context)
|
||||
{
|
||||
InstOutC op = context.GetOp<InstOutC>();
|
||||
|
||||
EmitOut(context, op.OutType.HasFlag(OutType.Emit), op.OutType.HasFlag(OutType.Cut));
|
||||
}
|
||||
|
||||
private static void EmitOut(EmitterContext context, bool emit, bool cut)
|
||||
{
|
||||
if (!(emit || cut))
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid OUT encoding.");
|
||||
}
|
||||
|
||||
if (emit)
|
||||
{
|
||||
if (context.TranslatorContext.Definitions.LastInVertexPipeline)
|
||||
{
|
||||
context.PrepareForVertexReturn(out Operand tempXLocal, out Operand tempYLocal, out Operand tempZLocal);
|
||||
|
||||
context.EmitVertex();
|
||||
|
||||
// Restore output position value before transformation.
|
||||
|
||||
if (tempXLocal != null)
|
||||
{
|
||||
context.Copy(context.Load(StorageKind.Input, IoVariable.Position, null, Const(0)), tempXLocal);
|
||||
}
|
||||
|
||||
if (tempYLocal != null)
|
||||
{
|
||||
context.Copy(context.Load(StorageKind.Input, IoVariable.Position, null, Const(1)), tempYLocal);
|
||||
}
|
||||
|
||||
if (tempZLocal != null)
|
||||
{
|
||||
context.Copy(context.Load(StorageKind.Input, IoVariable.Position, null, Const(2)), tempZLocal);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
context.EmitVertex();
|
||||
}
|
||||
}
|
||||
|
||||
if (cut)
|
||||
{
|
||||
context.EndPrimitive();
|
||||
}
|
||||
}
|
||||
|
||||
private static bool HasPrimitiveVertex(int attr)
|
||||
{
|
||||
return attr is not AttributeConsts.PrimitiveId and
|
||||
not AttributeConsts.TessCoordX and
|
||||
not AttributeConsts.TessCoordY;
|
||||
}
|
||||
|
||||
private static bool CanLoadOutput(int attr)
|
||||
{
|
||||
return attr is not AttributeConsts.TessCoordX and not AttributeConsts.TessCoordY;
|
||||
}
|
||||
|
||||
private static bool TryFixedFuncToUserAttributeIpa(EmitterContext context, int attr, out Operand selectedAttr)
|
||||
{
|
||||
if (attr is >= AttributeConsts.FrontColorDiffuseR and < AttributeConsts.BackColorDiffuseR)
|
||||
{
|
||||
// TODO: If two sided rendering is enabled, then this should return
|
||||
// FrontColor if the fragment is front facing, and back color otherwise.
|
||||
selectedAttr = GenerateIpaLoad(context, FixedFuncToUserAttribute(context.TranslatorContext, attr, isOutput: false));
|
||||
return true;
|
||||
}
|
||||
else if (attr == AttributeConsts.FogCoord)
|
||||
{
|
||||
// TODO: We likely need to emulate the fixed-function functionality for FogCoord here.
|
||||
selectedAttr = GenerateIpaLoad(context, FixedFuncToUserAttribute(context.TranslatorContext, attr, isOutput: false));
|
||||
return true;
|
||||
}
|
||||
else if (attr is >= AttributeConsts.BackColorDiffuseR and < AttributeConsts.ClipDistance0)
|
||||
{
|
||||
selectedAttr = ConstF(((attr >> 2) & 3) == 3 ? 1f : 0f);
|
||||
return true;
|
||||
}
|
||||
else if (attr is >= AttributeConsts.TexCoordBase and < AttributeConsts.TexCoordEnd)
|
||||
{
|
||||
selectedAttr = GenerateIpaLoad(context, FixedFuncToUserAttribute(context.TranslatorContext, attr, isOutput: false));
|
||||
return true;
|
||||
}
|
||||
|
||||
selectedAttr = GenerateIpaLoad(context, attr);
|
||||
return false;
|
||||
}
|
||||
|
||||
private static Operand GenerateIpaLoad(EmitterContext context, int offset)
|
||||
{
|
||||
return AttributeMap.GenerateAttributeLoad(context, null, offset, isOutput: false, isPerPatch: false);
|
||||
}
|
||||
|
||||
private static int FixedFuncToUserAttribute(TranslatorContext translatorContext, int attr, bool isOutput)
|
||||
{
|
||||
bool supportsLayerFromVertexOrTess = translatorContext.GpuAccessor.QueryHostSupportsLayerVertexTessellation();
|
||||
int fixedStartAttr = supportsLayerFromVertexOrTess ? 0 : 1;
|
||||
|
||||
if (attr == AttributeConsts.Layer && translatorContext.Definitions.Stage != ShaderStage.Geometry && !supportsLayerFromVertexOrTess)
|
||||
{
|
||||
attr = FixedFuncToUserAttribute(translatorContext, attr, AttributeConsts.Layer, 0, isOutput);
|
||||
translatorContext.SetLayerOutputAttribute(attr);
|
||||
}
|
||||
else if (attr == AttributeConsts.FogCoord)
|
||||
{
|
||||
attr = FixedFuncToUserAttribute(translatorContext, attr, AttributeConsts.FogCoord, fixedStartAttr, isOutput);
|
||||
}
|
||||
else if (attr is >= AttributeConsts.FrontColorDiffuseR and < AttributeConsts.ClipDistance0)
|
||||
{
|
||||
attr = FixedFuncToUserAttribute(translatorContext, attr, AttributeConsts.FrontColorDiffuseR, fixedStartAttr + 1, isOutput);
|
||||
}
|
||||
else if (attr is >= AttributeConsts.TexCoordBase and < AttributeConsts.TexCoordEnd)
|
||||
{
|
||||
attr = FixedFuncToUserAttribute(translatorContext, attr, AttributeConsts.TexCoordBase, fixedStartAttr + 5, isOutput);
|
||||
}
|
||||
|
||||
return attr;
|
||||
}
|
||||
|
||||
private static int FixedFuncToUserAttribute(TranslatorContext translatorContext, int attr, int baseAttr, int baseIndex, bool isOutput)
|
||||
{
|
||||
int index = (attr - baseAttr) >> 4;
|
||||
int userAttrIndex = translatorContext.AttributeUsage.GetFreeUserAttribute(isOutput, baseIndex + index);
|
||||
|
||||
if ((uint)userAttrIndex < Constants.MaxAttributes)
|
||||
{
|
||||
attr = AttributeConsts.UserAttributeBase + userAttrIndex * 16 + (attr & 0xf);
|
||||
}
|
||||
else
|
||||
{
|
||||
translatorContext.GpuAccessor.Log($"No enough user attributes for fixed attribute offset 0x{attr:X}.");
|
||||
}
|
||||
|
||||
return attr;
|
||||
}
|
||||
|
||||
private static bool TryConvertIdToIndexForVulkan(EmitterContext context, int attr, out Operand value)
|
||||
{
|
||||
if (context.TranslatorContext.Options.TargetApi == TargetApi.Vulkan)
|
||||
{
|
||||
if (attr == AttributeConsts.InstanceId)
|
||||
{
|
||||
value = context.ISubtract(
|
||||
context.Load(StorageKind.Input, IoVariable.InstanceIndex),
|
||||
context.Load(StorageKind.Input, IoVariable.BaseInstance));
|
||||
return true;
|
||||
}
|
||||
else if (attr == AttributeConsts.VertexId)
|
||||
{
|
||||
value = context.Load(StorageKind.Input, IoVariable.VertexIndex);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
value = null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
46
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitBarrier.cs
vendored
Normal file
46
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitBarrier.cs
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Bar(EmitterContext context)
|
||||
{
|
||||
InstBar op = context.GetOp<InstBar>();
|
||||
|
||||
// TODO: Support other modes.
|
||||
if (op.BarOp == BarOp.Sync)
|
||||
{
|
||||
context.Barrier();
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid barrier mode: {op.BarOp}.");
|
||||
}
|
||||
}
|
||||
|
||||
public static void Depbar(EmitterContext context)
|
||||
{
|
||||
#pragma warning disable IDE0059 // Remove unnecessary value assignment
|
||||
InstDepbar op = context.GetOp<InstDepbar>();
|
||||
#pragma warning restore IDE0059
|
||||
|
||||
// No operation.
|
||||
}
|
||||
|
||||
public static void Membar(EmitterContext context)
|
||||
{
|
||||
InstMembar op = context.GetOp<InstMembar>();
|
||||
|
||||
if (op.Membar == Decoders.Membar.Cta)
|
||||
{
|
||||
context.GroupMemoryBarrier();
|
||||
}
|
||||
else
|
||||
{
|
||||
context.MemoryBarrier();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
194
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitBitfield.cs
vendored
Normal file
194
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitBitfield.cs
vendored
Normal file
@@ -0,0 +1,194 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void BfeR(EmitterContext context)
|
||||
{
|
||||
InstBfeR op = context.GetOp<InstBfeR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitBfe(context, srcA, srcB, op.Dest, op.Brev, op.Signed);
|
||||
}
|
||||
|
||||
public static void BfeI(EmitterContext context)
|
||||
{
|
||||
InstBfeI op = context.GetOp<InstBfeI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitBfe(context, srcA, srcB, op.Dest, op.Brev, op.Signed);
|
||||
}
|
||||
|
||||
public static void BfeC(EmitterContext context)
|
||||
{
|
||||
InstBfeC op = context.GetOp<InstBfeC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitBfe(context, srcA, srcB, op.Dest, op.Brev, op.Signed);
|
||||
}
|
||||
|
||||
public static void BfiR(EmitterContext context)
|
||||
{
|
||||
InstBfiR op = context.GetOp<InstBfiR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitBfi(context, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void BfiI(EmitterContext context)
|
||||
{
|
||||
InstBfiI op = context.GetOp<InstBfiI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitBfi(context, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void BfiC(EmitterContext context)
|
||||
{
|
||||
InstBfiC op = context.GetOp<InstBfiC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitBfi(context, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void BfiRc(EmitterContext context)
|
||||
{
|
||||
InstBfiRc op = context.GetOp<InstBfiRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitBfi(context, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void FloR(EmitterContext context)
|
||||
{
|
||||
InstFloR op = context.GetOp<InstFloR>();
|
||||
|
||||
EmitFlo(context, GetSrcReg(context, op.SrcB), op.Dest, op.NegB, op.Sh, op.Signed);
|
||||
}
|
||||
|
||||
public static void FloI(EmitterContext context)
|
||||
{
|
||||
InstFloI op = context.GetOp<InstFloI>();
|
||||
|
||||
EmitFlo(context, GetSrcImm(context, Imm20ToSInt(op.Imm20)), op.Dest, op.NegB, op.Sh, op.Signed);
|
||||
}
|
||||
|
||||
public static void FloC(EmitterContext context)
|
||||
{
|
||||
InstFloC op = context.GetOp<InstFloC>();
|
||||
|
||||
EmitFlo(context, GetSrcCbuf(context, op.CbufSlot, op.CbufOffset), op.Dest, op.NegB, op.Sh, op.Signed);
|
||||
}
|
||||
|
||||
public static void PopcR(EmitterContext context)
|
||||
{
|
||||
InstPopcR op = context.GetOp<InstPopcR>();
|
||||
|
||||
EmitPopc(context, GetSrcReg(context, op.SrcB), op.Dest, op.NegB);
|
||||
}
|
||||
|
||||
public static void PopcI(EmitterContext context)
|
||||
{
|
||||
InstPopcI op = context.GetOp<InstPopcI>();
|
||||
|
||||
EmitPopc(context, GetSrcImm(context, Imm20ToSInt(op.Imm20)), op.Dest, op.NegB);
|
||||
}
|
||||
|
||||
public static void PopcC(EmitterContext context)
|
||||
{
|
||||
InstPopcC op = context.GetOp<InstPopcC>();
|
||||
|
||||
EmitPopc(context, GetSrcCbuf(context, op.CbufSlot, op.CbufOffset), op.Dest, op.NegB);
|
||||
}
|
||||
|
||||
private static void EmitBfe(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
bool bitReverse,
|
||||
bool isSigned)
|
||||
{
|
||||
if (bitReverse)
|
||||
{
|
||||
srcA = context.BitfieldReverse(srcA);
|
||||
}
|
||||
|
||||
Operand position = context.BitwiseAnd(srcB, Const(0xff));
|
||||
|
||||
Operand size = context.BitfieldExtractU32(srcB, Const(8), Const(8));
|
||||
|
||||
Operand res = isSigned
|
||||
? context.BitfieldExtractS32(srcA, position, size)
|
||||
: context.BitfieldExtractU32(srcA, position, size);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
// TODO: CC, X, corner cases.
|
||||
}
|
||||
|
||||
private static void EmitBfi(EmitterContext context, Operand srcA, Operand srcB, Operand srcC, int rd)
|
||||
{
|
||||
Operand position = context.BitwiseAnd(srcB, Const(0xff));
|
||||
|
||||
Operand size = context.BitfieldExtractU32(srcB, Const(8), Const(8));
|
||||
|
||||
Operand res = context.BitfieldInsert(srcC, srcA, position, size);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitFlo(EmitterContext context, Operand src, int rd, bool invert, bool sh, bool isSigned)
|
||||
{
|
||||
Operand srcB = context.BitwiseNot(src, invert);
|
||||
|
||||
Operand res;
|
||||
|
||||
if (sh)
|
||||
{
|
||||
res = context.FindLSB(context.BitfieldReverse(srcB));
|
||||
}
|
||||
else
|
||||
{
|
||||
res = isSigned
|
||||
? context.FindMSBS32(srcB)
|
||||
: context.FindMSBU32(srcB);
|
||||
}
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitPopc(EmitterContext context, Operand src, int rd, bool invert)
|
||||
{
|
||||
Operand srcB = context.BitwiseNot(src, invert);
|
||||
|
||||
Operand res = context.BitCount(srcB);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
}
|
||||
}
|
||||
86
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitConditionCode.cs
vendored
Normal file
86
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitConditionCode.cs
vendored
Normal file
@@ -0,0 +1,86 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Cset(EmitterContext context)
|
||||
{
|
||||
InstCset op = context.GetOp<InstCset>();
|
||||
|
||||
Operand res = GetCondition(context, op.Ccc);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
res = GetPredLogicalOp(context, op.Bop, res, srcPred);
|
||||
|
||||
Operand dest = GetDest(op.Dest);
|
||||
|
||||
if (op.BVal)
|
||||
{
|
||||
context.Copy(dest, context.ConditionalSelect(res, ConstF(1), Const(0)));
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Copy(dest, res);
|
||||
}
|
||||
|
||||
// TODO: CC.
|
||||
}
|
||||
|
||||
public static void Csetp(EmitterContext context)
|
||||
{
|
||||
InstCsetp op = context.GetOp<InstCsetp>();
|
||||
|
||||
Operand p0Res = GetCondition(context, op.Ccc);
|
||||
Operand p1Res = context.BitwiseNot(p0Res);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
p0Res = GetPredLogicalOp(context, op.Bop, p0Res, srcPred);
|
||||
p1Res = GetPredLogicalOp(context, op.Bop, p1Res, srcPred);
|
||||
|
||||
context.Copy(Register(op.DestPred, RegisterType.Predicate), p0Res);
|
||||
context.Copy(Register(op.DestPredInv, RegisterType.Predicate), p1Res);
|
||||
|
||||
// TODO: CC.
|
||||
}
|
||||
|
||||
private static Operand GetCondition(EmitterContext context, Ccc cond, int defaultCond = IrConsts.True)
|
||||
{
|
||||
return cond switch
|
||||
{
|
||||
Ccc.F => Const(IrConsts.False),
|
||||
Ccc.Lt => context.BitwiseExclusiveOr(context.BitwiseAnd(GetNF(), context.BitwiseNot(GetZF())), GetVF()),
|
||||
Ccc.Eq => context.BitwiseAnd(context.BitwiseNot(GetNF()), GetZF()),
|
||||
Ccc.Le => context.BitwiseExclusiveOr(GetNF(), context.BitwiseOr(GetZF(), GetVF())),
|
||||
Ccc.Gt => context.BitwiseNot(context.BitwiseOr(context.BitwiseExclusiveOr(GetNF(), GetVF()), GetZF())),
|
||||
Ccc.Ne => context.BitwiseNot(GetZF()),
|
||||
Ccc.Ge => context.BitwiseNot(context.BitwiseExclusiveOr(GetNF(), GetVF())),
|
||||
Ccc.Num => context.BitwiseNot(context.BitwiseAnd(GetNF(), GetZF())),
|
||||
Ccc.Nan => context.BitwiseAnd(GetNF(), GetZF()),
|
||||
Ccc.Ltu => context.BitwiseExclusiveOr(GetNF(), GetVF()),
|
||||
Ccc.Equ => GetZF(),
|
||||
Ccc.Leu => context.BitwiseOr(context.BitwiseExclusiveOr(GetNF(), GetVF()), GetZF()),
|
||||
Ccc.Gtu => context.BitwiseExclusiveOr(context.BitwiseNot(GetNF()), context.BitwiseOr(GetVF(), GetZF())),
|
||||
Ccc.Neu => context.BitwiseOr(GetNF(), context.BitwiseNot(GetZF())),
|
||||
Ccc.Geu => context.BitwiseExclusiveOr(context.BitwiseOr(context.BitwiseNot(GetNF()), GetZF()), GetVF()),
|
||||
Ccc.T => Const(IrConsts.True),
|
||||
Ccc.Off => context.BitwiseNot(GetVF()),
|
||||
Ccc.Lo => context.BitwiseNot(GetCF()),
|
||||
Ccc.Sff => context.BitwiseNot(GetNF()),
|
||||
Ccc.Ls => context.BitwiseOr(GetZF(), context.BitwiseNot(GetCF())),
|
||||
Ccc.Hi => context.BitwiseAnd(GetCF(), context.BitwiseNot(GetZF())),
|
||||
Ccc.Sft => GetNF(),
|
||||
Ccc.Hs => GetCF(),
|
||||
Ccc.Oft => GetVF(),
|
||||
Ccc.Rle => context.BitwiseOr(GetNF(), GetZF()),
|
||||
Ccc.Rgt => context.BitwiseNot(context.BitwiseOr(GetNF(), GetZF())),
|
||||
_ => Const(defaultCond),
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
424
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitConversion.cs
vendored
Normal file
424
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitConversion.cs
vendored
Normal file
@@ -0,0 +1,424 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void F2fR(EmitterContext context)
|
||||
{
|
||||
InstF2fR op = context.GetOp<InstF2fR>();
|
||||
|
||||
Operand src = UnpackReg(context, op.SrcFmt, op.Sh, op.SrcB);
|
||||
|
||||
EmitF2F(context, op.SrcFmt, op.DstFmt, op.RoundMode, src, op.Dest, op.AbsB, op.NegB, op.Sat);
|
||||
}
|
||||
|
||||
public static void F2fI(EmitterContext context)
|
||||
{
|
||||
InstF2fI op = context.GetOp<InstF2fI>();
|
||||
|
||||
Operand src = UnpackImm(context, op.SrcFmt, op.Sh, Imm20ToFloat(op.Imm20));
|
||||
|
||||
EmitF2F(context, op.SrcFmt, op.DstFmt, op.RoundMode, src, op.Dest, op.AbsB, op.NegB, op.Sat);
|
||||
}
|
||||
|
||||
public static void F2fC(EmitterContext context)
|
||||
{
|
||||
InstF2fC op = context.GetOp<InstF2fC>();
|
||||
|
||||
Operand src = UnpackCbuf(context, op.SrcFmt, op.Sh, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitF2F(context, op.SrcFmt, op.DstFmt, op.RoundMode, src, op.Dest, op.AbsB, op.NegB, op.Sat);
|
||||
}
|
||||
|
||||
public static void F2iR(EmitterContext context)
|
||||
{
|
||||
InstF2iR op = context.GetOp<InstF2iR>();
|
||||
|
||||
Operand src = UnpackReg(context, op.SrcFmt, op.Sh, op.SrcB);
|
||||
|
||||
EmitF2I(context, op.SrcFmt, op.IDstFmt, op.RoundMode, src, op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void F2iI(EmitterContext context)
|
||||
{
|
||||
InstF2iI op = context.GetOp<InstF2iI>();
|
||||
|
||||
Operand src = UnpackImm(context, op.SrcFmt, op.Sh, Imm20ToFloat(op.Imm20));
|
||||
|
||||
EmitF2I(context, op.SrcFmt, op.IDstFmt, op.RoundMode, src, op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void F2iC(EmitterContext context)
|
||||
{
|
||||
InstF2iC op = context.GetOp<InstF2iC>();
|
||||
|
||||
Operand src = UnpackCbuf(context, op.SrcFmt, op.Sh, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitF2I(context, op.SrcFmt, op.IDstFmt, op.RoundMode, src, op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void I2fR(EmitterContext context)
|
||||
{
|
||||
InstI2fR op = context.GetOp<InstI2fR>();
|
||||
|
||||
Operand src = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitI2F(context, op.ISrcFmt, op.DstFmt, src, op.ByteSel, op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void I2fI(EmitterContext context)
|
||||
{
|
||||
InstI2fI op = context.GetOp<InstI2fI>();
|
||||
|
||||
Operand src = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitI2F(context, op.ISrcFmt, op.DstFmt, src, op.ByteSel, op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void I2fC(EmitterContext context)
|
||||
{
|
||||
InstI2fC op = context.GetOp<InstI2fC>();
|
||||
|
||||
Operand src = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitI2F(context, op.ISrcFmt, op.DstFmt, src, op.ByteSel, op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void I2iR(EmitterContext context)
|
||||
{
|
||||
InstI2iR op = context.GetOp<InstI2iR>();
|
||||
|
||||
Operand src = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitI2I(context, op.ISrcFmt, op.IDstFmt, src, op.ByteSel, op.Dest, op.AbsB, op.NegB, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void I2iI(EmitterContext context)
|
||||
{
|
||||
InstI2iI op = context.GetOp<InstI2iI>();
|
||||
|
||||
Operand src = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitI2I(context, op.ISrcFmt, op.IDstFmt, src, op.ByteSel, op.Dest, op.AbsB, op.NegB, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void I2iC(EmitterContext context)
|
||||
{
|
||||
InstI2iC op = context.GetOp<InstI2iC>();
|
||||
|
||||
Operand src = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitI2I(context, op.ISrcFmt, op.IDstFmt, src, op.ByteSel, op.Dest, op.AbsB, op.NegB, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
private static void EmitF2F(
|
||||
EmitterContext context,
|
||||
DstFmt srcType,
|
||||
DstFmt dstType,
|
||||
IntegerRound roundingMode,
|
||||
Operand src,
|
||||
int rd,
|
||||
bool absolute,
|
||||
bool negate,
|
||||
bool saturate)
|
||||
{
|
||||
Operand srcB = context.FPAbsNeg(src, absolute, negate, srcType.ToInstFPType());
|
||||
|
||||
if (srcType == dstType)
|
||||
{
|
||||
srcB = roundingMode switch
|
||||
{
|
||||
IntegerRound.Round => context.FPRound(srcB, srcType.ToInstFPType()),
|
||||
IntegerRound.Floor => context.FPFloor(srcB, srcType.ToInstFPType()),
|
||||
IntegerRound.Ceil => context.FPCeiling(srcB, srcType.ToInstFPType()),
|
||||
IntegerRound.Trunc => context.FPTruncate(srcB, srcType.ToInstFPType()),
|
||||
_ => srcB,
|
||||
};
|
||||
}
|
||||
|
||||
// We don't need to handle conversions between FP16 <-> FP32
|
||||
// since we do FP16 operations as FP32 directly.
|
||||
// FP16 <-> FP64 conversions are invalid.
|
||||
if (srcType == DstFmt.F32 && dstType == DstFmt.F64)
|
||||
{
|
||||
srcB = context.FP32ConvertToFP64(srcB);
|
||||
}
|
||||
else if (srcType == DstFmt.F64 && dstType == DstFmt.F32)
|
||||
{
|
||||
srcB = context.FP64ConvertToFP32(srcB);
|
||||
}
|
||||
|
||||
srcB = context.FPSaturate(srcB, saturate, dstType.ToInstFPType());
|
||||
|
||||
WriteFP(context, dstType, srcB, rd);
|
||||
|
||||
// TODO: CC.
|
||||
}
|
||||
|
||||
private static void EmitF2I(
|
||||
EmitterContext context,
|
||||
DstFmt srcType,
|
||||
IDstFmt dstType,
|
||||
RoundMode2 roundingMode,
|
||||
Operand src,
|
||||
int rd,
|
||||
bool absolute,
|
||||
bool negate)
|
||||
{
|
||||
if (dstType == IDstFmt.U64)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Unimplemented 64-bits F2I.");
|
||||
}
|
||||
|
||||
Instruction fpType = srcType.ToInstFPType();
|
||||
|
||||
bool isSignedInt = dstType is IDstFmt.S16 or IDstFmt.S32 or IDstFmt.S64;
|
||||
bool isSmallInt = dstType is IDstFmt.U16 or IDstFmt.S16;
|
||||
|
||||
Operand srcB = context.FPAbsNeg(src, absolute, negate, fpType);
|
||||
|
||||
srcB = roundingMode switch
|
||||
{
|
||||
RoundMode2.Round => context.FPRound(srcB, fpType),
|
||||
RoundMode2.Floor => context.FPFloor(srcB, fpType),
|
||||
RoundMode2.Ceil => context.FPCeiling(srcB, fpType),
|
||||
RoundMode2.Trunc => context.FPTruncate(srcB, fpType),
|
||||
_ => srcB,
|
||||
};
|
||||
|
||||
if (!isSignedInt)
|
||||
{
|
||||
// Negative float to uint cast is undefined, so we clamp the value before conversion.
|
||||
Operand c0 = srcType == DstFmt.F64 ? context.PackDouble2x32(0.0) : ConstF(0);
|
||||
|
||||
srcB = context.FPMaximum(srcB, c0, fpType);
|
||||
}
|
||||
|
||||
if (srcType == DstFmt.F64)
|
||||
{
|
||||
srcB = isSignedInt
|
||||
? context.FP64ConvertToS32(srcB)
|
||||
: context.FP64ConvertToU32(srcB);
|
||||
}
|
||||
else
|
||||
{
|
||||
srcB = isSignedInt
|
||||
? context.FP32ConvertToS32(srcB)
|
||||
: context.FP32ConvertToU32(srcB);
|
||||
}
|
||||
|
||||
if (isSmallInt)
|
||||
{
|
||||
int min = (int)GetIntMin(dstType);
|
||||
int max = (int)GetIntMax(dstType);
|
||||
|
||||
srcB = isSignedInt
|
||||
? context.IClampS32(srcB, Const(min), Const(max))
|
||||
: context.IClampU32(srcB, Const(min), Const(max));
|
||||
}
|
||||
|
||||
Operand dest = GetDest(rd);
|
||||
|
||||
context.Copy(dest, srcB);
|
||||
|
||||
// TODO: CC.
|
||||
}
|
||||
|
||||
private static void EmitI2F(
|
||||
EmitterContext context,
|
||||
ISrcFmt srcType,
|
||||
DstFmt dstType,
|
||||
Operand src,
|
||||
ByteSel byteSelection,
|
||||
int rd,
|
||||
bool absolute,
|
||||
bool negate)
|
||||
{
|
||||
bool isSignedInt =
|
||||
srcType is ISrcFmt.S8 or
|
||||
ISrcFmt.S16 or
|
||||
ISrcFmt.S32 or
|
||||
ISrcFmt.S64;
|
||||
bool isSmallInt =
|
||||
srcType is ISrcFmt.U16 or
|
||||
ISrcFmt.S16 or
|
||||
ISrcFmt.U8 or
|
||||
ISrcFmt.S8;
|
||||
|
||||
// TODO: Handle S/U64.
|
||||
|
||||
Operand srcB = context.IAbsNeg(src, absolute, negate);
|
||||
|
||||
if (isSmallInt)
|
||||
{
|
||||
int size = srcType is ISrcFmt.U16 or ISrcFmt.S16 ? 16 : 8;
|
||||
|
||||
srcB = isSignedInt
|
||||
? context.BitfieldExtractS32(srcB, Const((int)byteSelection * 8), Const(size))
|
||||
: context.BitfieldExtractU32(srcB, Const((int)byteSelection * 8), Const(size));
|
||||
}
|
||||
|
||||
if (dstType == DstFmt.F64)
|
||||
{
|
||||
srcB = isSignedInt
|
||||
? context.IConvertS32ToFP64(srcB)
|
||||
: context.IConvertU32ToFP64(srcB);
|
||||
}
|
||||
else
|
||||
{
|
||||
srcB = isSignedInt
|
||||
? context.IConvertS32ToFP32(srcB)
|
||||
: context.IConvertU32ToFP32(srcB);
|
||||
}
|
||||
|
||||
WriteFP(context, dstType, srcB, rd);
|
||||
|
||||
// TODO: CC.
|
||||
}
|
||||
|
||||
private static void EmitI2I(
|
||||
EmitterContext context,
|
||||
ISrcDstFmt srcType,
|
||||
ISrcDstFmt dstType,
|
||||
Operand src,
|
||||
ByteSel byteSelection,
|
||||
int rd,
|
||||
bool absolute,
|
||||
bool negate,
|
||||
bool saturate,
|
||||
bool writeCC)
|
||||
{
|
||||
if ((srcType & ~ISrcDstFmt.S8) > ISrcDstFmt.U32 || (dstType & ~ISrcDstFmt.S8) > ISrcDstFmt.U32)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid I2I encoding.");
|
||||
return;
|
||||
}
|
||||
|
||||
bool srcIsSignedInt =
|
||||
srcType is ISrcDstFmt.S8 or
|
||||
ISrcDstFmt.S16 or
|
||||
ISrcDstFmt.S32;
|
||||
bool dstIsSignedInt =
|
||||
dstType is ISrcDstFmt.S8 or
|
||||
ISrcDstFmt.S16 or
|
||||
ISrcDstFmt.S32;
|
||||
bool srcIsSmallInt =
|
||||
srcType is ISrcDstFmt.U16 or
|
||||
ISrcDstFmt.S16 or
|
||||
ISrcDstFmt.U8 or
|
||||
ISrcDstFmt.S8;
|
||||
|
||||
if (srcIsSmallInt)
|
||||
{
|
||||
int size = srcType is ISrcDstFmt.U16 or ISrcDstFmt.S16 ? 16 : 8;
|
||||
|
||||
src = srcIsSignedInt
|
||||
? context.BitfieldExtractS32(src, Const((int)byteSelection * 8), Const(size))
|
||||
: context.BitfieldExtractU32(src, Const((int)byteSelection * 8), Const(size));
|
||||
}
|
||||
|
||||
src = context.IAbsNeg(src, absolute, negate);
|
||||
|
||||
if (saturate)
|
||||
{
|
||||
int min = (int)GetIntMin(dstType);
|
||||
int max = (int)GetIntMax(dstType);
|
||||
|
||||
src = dstIsSignedInt
|
||||
? context.IClampS32(src, Const(min), Const(max))
|
||||
: context.IClampU32(src, Const(min), Const(max));
|
||||
}
|
||||
|
||||
context.Copy(GetDest(rd), src);
|
||||
|
||||
SetZnFlags(context, src, writeCC);
|
||||
}
|
||||
|
||||
private static Operand UnpackReg(EmitterContext context, DstFmt floatType, bool h, int reg)
|
||||
{
|
||||
if (floatType == DstFmt.F32)
|
||||
{
|
||||
return GetSrcReg(context, reg);
|
||||
}
|
||||
else if (floatType == DstFmt.F16)
|
||||
{
|
||||
return GetHalfUnpacked(context, GetSrcReg(context, reg), HalfSwizzle.F16)[h ? 1 : 0];
|
||||
}
|
||||
else if (floatType == DstFmt.F64)
|
||||
{
|
||||
return GetSrcReg(context, reg, isFP64: true);
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Invalid floating point type \"{floatType}\".");
|
||||
}
|
||||
|
||||
private static Operand UnpackCbuf(EmitterContext context, DstFmt floatType, bool h, int cbufSlot, int cbufOffset)
|
||||
{
|
||||
if (floatType == DstFmt.F32)
|
||||
{
|
||||
return GetSrcCbuf(context, cbufSlot, cbufOffset);
|
||||
}
|
||||
else if (floatType == DstFmt.F16)
|
||||
{
|
||||
return GetHalfUnpacked(context, GetSrcCbuf(context, cbufSlot, cbufOffset), HalfSwizzle.F16)[h ? 1 : 0];
|
||||
}
|
||||
else if (floatType == DstFmt.F64)
|
||||
{
|
||||
return GetSrcCbuf(context, cbufSlot, cbufOffset, isFP64: true);
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Invalid floating point type \"{floatType}\".");
|
||||
}
|
||||
|
||||
private static Operand UnpackImm(EmitterContext context, DstFmt floatType, bool h, int imm)
|
||||
{
|
||||
if (floatType == DstFmt.F32)
|
||||
{
|
||||
return GetSrcImm(context, imm);
|
||||
}
|
||||
else if (floatType == DstFmt.F16)
|
||||
{
|
||||
return GetHalfUnpacked(context, GetSrcImm(context, imm), HalfSwizzle.F16)[h ? 1 : 0];
|
||||
}
|
||||
else if (floatType == DstFmt.F64)
|
||||
{
|
||||
return GetSrcImm(context, imm, isFP64: true);
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Invalid floating point type \"{floatType}\".");
|
||||
}
|
||||
|
||||
private static void WriteFP(EmitterContext context, DstFmt type, Operand srcB, int rd)
|
||||
{
|
||||
Operand dest = GetDest(rd);
|
||||
|
||||
if (type == DstFmt.F32)
|
||||
{
|
||||
context.Copy(dest, srcB);
|
||||
}
|
||||
else if (type == DstFmt.F16)
|
||||
{
|
||||
context.Copy(dest, context.PackHalf2x16(srcB, ConstF(0)));
|
||||
}
|
||||
else /* if (type == FPType.FP64) */
|
||||
{
|
||||
Operand dest2 = GetDest2(rd);
|
||||
|
||||
context.Copy(dest, context.UnpackDouble2x32Low(srcB));
|
||||
context.Copy(dest2, context.UnpackDouble2x32High(srcB));
|
||||
}
|
||||
}
|
||||
|
||||
private static Instruction ToInstFPType(this DstFmt type)
|
||||
{
|
||||
return type == DstFmt.F64 ? Instruction.FP64 : Instruction.FP32;
|
||||
}
|
||||
}
|
||||
}
|
||||
531
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatArithmetic.cs
vendored
Normal file
531
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatArithmetic.cs
vendored
Normal file
@@ -0,0 +1,531 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void DaddR(EmitterContext context)
|
||||
{
|
||||
InstDaddR op = context.GetOp<InstDaddR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB, isFP64: true);
|
||||
|
||||
EmitFadd(context, Instruction.FP64, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DaddI(EmitterContext context)
|
||||
{
|
||||
InstDaddI op = context.GetOp<InstDaddI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
|
||||
|
||||
EmitFadd(context, Instruction.FP64, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DaddC(EmitterContext context)
|
||||
{
|
||||
InstDaddC op = context.GetOp<InstDaddC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
|
||||
EmitFadd(context, Instruction.FP64, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DfmaR(EmitterContext context)
|
||||
{
|
||||
InstDfmaR op = context.GetOp<InstDfmaR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB, isFP64: true);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC, isFP64: true);
|
||||
|
||||
EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DfmaI(EmitterContext context)
|
||||
{
|
||||
InstDfmaI op = context.GetOp<InstDfmaI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC, isFP64: true);
|
||||
|
||||
EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DfmaC(EmitterContext context)
|
||||
{
|
||||
InstDfmaC op = context.GetOp<InstDfmaC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC, isFP64: true);
|
||||
|
||||
EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DfmaRc(EmitterContext context)
|
||||
{
|
||||
InstDfmaRc op = context.GetOp<InstDfmaRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC, isFP64: true);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
|
||||
EmitFfma(context, Instruction.FP64, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DmulR(EmitterContext context)
|
||||
{
|
||||
InstDmulR op = context.GetOp<InstDmulR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB, isFP64: true);
|
||||
|
||||
EmitFmul(context, Instruction.FP64, MultiplyScale.NoScale, srcA, srcB, op.Dest, op.NegA, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DmulI(EmitterContext context)
|
||||
{
|
||||
InstDmulI op = context.GetOp<InstDmulI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
|
||||
|
||||
EmitFmul(context, Instruction.FP64, MultiplyScale.NoScale, srcA, srcB, op.Dest, op.NegA, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void DmulC(EmitterContext context)
|
||||
{
|
||||
InstDmulC op = context.GetOp<InstDmulC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
|
||||
EmitFmul(context, Instruction.FP64, MultiplyScale.NoScale, srcA, srcB, op.Dest, op.NegA, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FaddR(EmitterContext context)
|
||||
{
|
||||
InstFaddR op = context.GetOp<InstFaddR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FaddI(EmitterContext context)
|
||||
{
|
||||
InstFaddI op = context.GetOp<InstFaddI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
|
||||
EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FaddC(EmitterContext context)
|
||||
{
|
||||
InstFaddC op = context.GetOp<InstFaddC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Fadd32i(EmitterContext context)
|
||||
{
|
||||
InstFadd32i op = context.GetOp<InstFadd32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
|
||||
EmitFadd(context, Instruction.FP32, srcA, srcB, op.Dest, op.NegA, op.NegB, op.AbsA, op.AbsB, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FfmaR(EmitterContext context)
|
||||
{
|
||||
InstFfmaR op = context.GetOp<InstFfmaR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FfmaI(EmitterContext context)
|
||||
{
|
||||
InstFfmaI op = context.GetOp<InstFfmaI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FfmaC(EmitterContext context)
|
||||
{
|
||||
InstFfmaC op = context.GetOp<InstFfmaC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FfmaRc(EmitterContext context)
|
||||
{
|
||||
InstFfmaRc op = context.GetOp<InstFfmaRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Ffma32i(EmitterContext context)
|
||||
{
|
||||
InstFfma32i op = context.GetOp<InstFfma32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
Operand srcC = GetSrcReg(context, op.Dest);
|
||||
|
||||
EmitFfma(context, Instruction.FP32, srcA, srcB, srcC, op.Dest, op.NegA, op.NegC, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FmulR(EmitterContext context)
|
||||
{
|
||||
InstFmulR op = context.GetOp<InstFmulR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitFmul(context, Instruction.FP32, op.Scale, srcA, srcB, op.Dest, op.NegA, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FmulI(EmitterContext context)
|
||||
{
|
||||
InstFmulI op = context.GetOp<InstFmulI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
|
||||
EmitFmul(context, Instruction.FP32, op.Scale, srcA, srcB, op.Dest, op.NegA, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FmulC(EmitterContext context)
|
||||
{
|
||||
InstFmulC op = context.GetOp<InstFmulC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitFmul(context, Instruction.FP32, op.Scale, srcA, srcB, op.Dest, op.NegA, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Fmul32i(EmitterContext context)
|
||||
{
|
||||
InstFmul32i op = context.GetOp<InstFmul32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
|
||||
EmitFmul(context, Instruction.FP32, MultiplyScale.NoScale, srcA, srcB, op.Dest, false, op.Sat, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Hadd2R(EmitterContext context)
|
||||
{
|
||||
InstHadd2R op = context.GetOp<InstHadd2R>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegB, op.AbsB);
|
||||
|
||||
EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: true, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hadd2I(EmitterContext context)
|
||||
{
|
||||
InstHadd2I op = context.GetOp<InstHadd2I>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
|
||||
|
||||
EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: true, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hadd2C(EmitterContext context)
|
||||
{
|
||||
InstHadd2C op = context.GetOp<InstHadd2C>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegB, op.AbsB);
|
||||
|
||||
EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: true, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hadd232i(EmitterContext context)
|
||||
{
|
||||
InstHadd232i op = context.GetOp<InstHadd232i>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, false);
|
||||
Operand[] srcB = GetHalfSrc(context, op.Imm);
|
||||
|
||||
EmitHadd2Hmul2(context, OFmt.F16, srcA, srcB, isAdd: true, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hfma2R(EmitterContext context)
|
||||
{
|
||||
InstHfma2R op = context.GetOp<InstHfma2R>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegA, false);
|
||||
Operand[] srcC = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegC, false);
|
||||
|
||||
EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hfma2I(EmitterContext context)
|
||||
{
|
||||
InstHfma2I op = context.GetOp<InstHfma2I>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
|
||||
Operand[] srcC = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegC, false);
|
||||
|
||||
EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hfma2C(EmitterContext context)
|
||||
{
|
||||
InstHfma2C op = context.GetOp<InstHfma2C>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
|
||||
Operand[] srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegA, false);
|
||||
Operand[] srcC = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegC, false);
|
||||
|
||||
EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hfma2Rc(EmitterContext context)
|
||||
{
|
||||
InstHfma2Rc op = context.GetOp<InstHfma2Rc>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
|
||||
Operand[] srcB = GetHalfSrc(context, op.CSwizzle, op.SrcC, op.NegA, false);
|
||||
Operand[] srcC = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegC, false);
|
||||
|
||||
EmitHfma2(context, op.OFmt, srcA, srcB, srcC, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hfma232i(EmitterContext context)
|
||||
{
|
||||
InstHfma232i op = context.GetOp<InstHfma232i>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
|
||||
Operand[] srcB = GetHalfSrc(context, op.Imm);
|
||||
Operand[] srcC = GetHalfSrc(context, HalfSwizzle.F16, op.Dest, op.NegC, false);
|
||||
|
||||
EmitHfma2(context, OFmt.F16, srcA, srcB, srcC, op.Dest, saturate: false);
|
||||
}
|
||||
|
||||
public static void Hmul2R(EmitterContext context)
|
||||
{
|
||||
InstHmul2R op = context.GetOp<InstHmul2R>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegA, op.AbsB);
|
||||
|
||||
EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: false, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hmul2I(EmitterContext context)
|
||||
{
|
||||
InstHmul2I op = context.GetOp<InstHmul2I>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
|
||||
|
||||
EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: false, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hmul2C(EmitterContext context)
|
||||
{
|
||||
InstHmul2C op = context.GetOp<InstHmul2C>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegA, op.AbsB);
|
||||
|
||||
EmitHadd2Hmul2(context, op.OFmt, srcA, srcB, isAdd: false, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
public static void Hmul232i(EmitterContext context)
|
||||
{
|
||||
InstHmul232i op = context.GetOp<InstHmul232i>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, false, false);
|
||||
Operand[] srcB = GetHalfSrc(context, op.Imm32);
|
||||
|
||||
EmitHadd2Hmul2(context, OFmt.F16, srcA, srcB, isAdd: false, op.Dest, op.Sat);
|
||||
}
|
||||
|
||||
private static void EmitFadd(
|
||||
EmitterContext context,
|
||||
Instruction fpType,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
bool negateA,
|
||||
bool negateB,
|
||||
bool absoluteA,
|
||||
bool absoluteB,
|
||||
bool saturate,
|
||||
bool writeCC)
|
||||
{
|
||||
bool isFP64 = fpType == Instruction.FP64;
|
||||
|
||||
srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
|
||||
srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
|
||||
|
||||
Operand res = context.FPSaturate(context.FPAdd(srcA, srcB, fpType), saturate, fpType);
|
||||
|
||||
SetDest(context, res, rd, isFP64);
|
||||
|
||||
SetFPZnFlags(context, res, writeCC, fpType);
|
||||
}
|
||||
|
||||
private static void EmitFfma(
|
||||
EmitterContext context,
|
||||
Instruction fpType,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
bool negateB,
|
||||
bool negateC,
|
||||
bool saturate,
|
||||
bool writeCC)
|
||||
{
|
||||
bool isFP64 = fpType == Instruction.FP64;
|
||||
|
||||
srcB = context.FPNegate(srcB, negateB, fpType);
|
||||
srcC = context.FPNegate(srcC, negateC, fpType);
|
||||
|
||||
Operand res = context.FPSaturate(context.FPFusedMultiplyAdd(srcA, srcB, srcC, fpType), saturate, fpType);
|
||||
|
||||
SetDest(context, res, rd, isFP64);
|
||||
|
||||
SetFPZnFlags(context, res, writeCC, fpType);
|
||||
}
|
||||
|
||||
private static void EmitFmul(
|
||||
EmitterContext context,
|
||||
Instruction fpType,
|
||||
MultiplyScale scale,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
bool negateB,
|
||||
bool saturate,
|
||||
bool writeCC)
|
||||
{
|
||||
bool isFP64 = fpType == Instruction.FP64;
|
||||
|
||||
srcB = context.FPNegate(srcB, negateB, fpType);
|
||||
|
||||
if (scale != MultiplyScale.NoScale)
|
||||
{
|
||||
Operand scaleConst = scale switch
|
||||
{
|
||||
MultiplyScale.D2 => ConstF(0.5f),
|
||||
MultiplyScale.D4 => ConstF(0.25f),
|
||||
MultiplyScale.D8 => ConstF(0.125f),
|
||||
MultiplyScale.M2 => ConstF(2f),
|
||||
MultiplyScale.M4 => ConstF(4f),
|
||||
MultiplyScale.M8 => ConstF(8f),
|
||||
_ => ConstF(1f), // Invalid, behave as if it had no scale.
|
||||
};
|
||||
|
||||
if (scaleConst.AsFloat() == 1f)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid FP multiply scale \"{scale}\".");
|
||||
}
|
||||
|
||||
if (isFP64)
|
||||
{
|
||||
scaleConst = context.FP32ConvertToFP64(scaleConst);
|
||||
}
|
||||
|
||||
srcA = context.FPMultiply(srcA, scaleConst, fpType);
|
||||
}
|
||||
|
||||
Operand res = context.FPSaturate(context.FPMultiply(srcA, srcB, fpType), saturate, fpType);
|
||||
|
||||
SetDest(context, res, rd, isFP64);
|
||||
|
||||
SetFPZnFlags(context, res, writeCC, fpType);
|
||||
}
|
||||
|
||||
private static void EmitHadd2Hmul2(
|
||||
EmitterContext context,
|
||||
OFmt swizzle,
|
||||
Operand[] srcA,
|
||||
Operand[] srcB,
|
||||
bool isAdd,
|
||||
int rd,
|
||||
bool saturate)
|
||||
{
|
||||
Operand[] res = new Operand[2];
|
||||
|
||||
for (int index = 0; index < res.Length; index++)
|
||||
{
|
||||
if (isAdd)
|
||||
{
|
||||
res[index] = context.FPAdd(srcA[index], srcB[index]);
|
||||
}
|
||||
else
|
||||
{
|
||||
res[index] = context.FPMultiply(srcA[index], srcB[index]);
|
||||
}
|
||||
|
||||
res[index] = context.FPSaturate(res[index], saturate);
|
||||
}
|
||||
|
||||
context.Copy(GetDest(rd), GetHalfPacked(context, swizzle, res, rd));
|
||||
}
|
||||
|
||||
public static void EmitHfma2(
|
||||
EmitterContext context,
|
||||
OFmt swizzle,
|
||||
Operand[] srcA,
|
||||
Operand[] srcB,
|
||||
Operand[] srcC,
|
||||
int rd,
|
||||
bool saturate)
|
||||
{
|
||||
Operand[] res = new Operand[2];
|
||||
|
||||
for (int index = 0; index < res.Length; index++)
|
||||
{
|
||||
res[index] = context.FPFusedMultiplyAdd(srcA[index], srcB[index], srcC[index]);
|
||||
res[index] = context.FPSaturate(res[index], saturate);
|
||||
}
|
||||
|
||||
context.Copy(GetDest(rd), GetHalfPacked(context, swizzle, res, rd));
|
||||
}
|
||||
}
|
||||
}
|
||||
570
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatComparison.cs
vendored
Normal file
570
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatComparison.cs
vendored
Normal file
@@ -0,0 +1,570 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void DsetR(EmitterContext context)
|
||||
{
|
||||
InstDsetR op = context.GetOp<InstDsetR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB, isFP64: true);
|
||||
|
||||
EmitFset(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.Dest,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
op.BVal,
|
||||
op.WriteCC,
|
||||
isFP64: true);
|
||||
}
|
||||
|
||||
public static void DsetI(EmitterContext context)
|
||||
{
|
||||
InstDsetI op = context.GetOp<InstDsetI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
|
||||
|
||||
EmitFset(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.Dest,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
op.BVal,
|
||||
op.WriteCC,
|
||||
isFP64: true);
|
||||
}
|
||||
|
||||
public static void DsetC(EmitterContext context)
|
||||
{
|
||||
InstDsetC op = context.GetOp<InstDsetC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
|
||||
EmitFset(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.Dest,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
op.BVal,
|
||||
op.WriteCC,
|
||||
isFP64: true);
|
||||
}
|
||||
|
||||
public static void DsetpR(EmitterContext context)
|
||||
{
|
||||
InstDsetpR op = context.GetOp<InstDsetpR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB, isFP64: true);
|
||||
|
||||
EmitFsetp(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.DestPred,
|
||||
op.DestPredInv,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
writeCC: false,
|
||||
isFP64: true);
|
||||
}
|
||||
|
||||
public static void DsetpI(EmitterContext context)
|
||||
{
|
||||
InstDsetpI op = context.GetOp<InstDsetpI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
|
||||
|
||||
EmitFsetp(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.DestPred,
|
||||
op.DestPredInv,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
writeCC: false,
|
||||
isFP64: true);
|
||||
}
|
||||
|
||||
public static void DsetpC(EmitterContext context)
|
||||
{
|
||||
InstDsetpC op = context.GetOp<InstDsetpC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
|
||||
EmitFsetp(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.DestPred,
|
||||
op.DestPredInv,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
writeCC: false,
|
||||
isFP64: true);
|
||||
}
|
||||
|
||||
public static void FcmpR(EmitterContext context)
|
||||
{
|
||||
InstFcmpR op = context.GetOp<InstFcmpR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitFcmp(context, op.FComp, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void FcmpI(EmitterContext context)
|
||||
{
|
||||
InstFcmpI op = context.GetOp<InstFcmpI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitFcmp(context, op.FComp, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void FcmpC(EmitterContext context)
|
||||
{
|
||||
InstFcmpC op = context.GetOp<InstFcmpC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitFcmp(context, op.FComp, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void FcmpRc(EmitterContext context)
|
||||
{
|
||||
InstFcmpRc op = context.GetOp<InstFcmpRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitFcmp(context, op.FComp, srcA, srcB, srcC, op.Dest);
|
||||
}
|
||||
|
||||
public static void FsetR(EmitterContext context)
|
||||
{
|
||||
InstFsetR op = context.GetOp<InstFsetR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitFset(context, op.FComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.BVal, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FsetC(EmitterContext context)
|
||||
{
|
||||
InstFsetC op = context.GetOp<InstFsetC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitFset(context, op.FComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.BVal, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FsetI(EmitterContext context)
|
||||
{
|
||||
InstFsetI op = context.GetOp<InstFsetI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
|
||||
EmitFset(context, op.FComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.BVal, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FsetpR(EmitterContext context)
|
||||
{
|
||||
InstFsetpR op = context.GetOp<InstFsetpR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitFsetp(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.DestPred,
|
||||
op.DestPredInv,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FsetpI(EmitterContext context)
|
||||
{
|
||||
InstFsetpI op = context.GetOp<InstFsetpI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
|
||||
EmitFsetp(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.DestPred,
|
||||
op.DestPredInv,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FsetpC(EmitterContext context)
|
||||
{
|
||||
InstFsetpC op = context.GetOp<InstFsetpC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitFsetp(
|
||||
context,
|
||||
op.FComp,
|
||||
op.Bop,
|
||||
srcA,
|
||||
srcB,
|
||||
op.SrcPred,
|
||||
op.SrcPredInv,
|
||||
op.DestPred,
|
||||
op.DestPredInv,
|
||||
op.AbsA,
|
||||
op.AbsB,
|
||||
op.NegA,
|
||||
op.NegB,
|
||||
op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Hset2R(EmitterContext context)
|
||||
{
|
||||
InstHset2R op = context.GetOp<InstHset2R>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegB, op.AbsB);
|
||||
|
||||
EmitHset2(context, op.Cmp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.Bval);
|
||||
}
|
||||
|
||||
public static void Hset2I(EmitterContext context)
|
||||
{
|
||||
InstHset2I op = context.GetOp<InstHset2I>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
|
||||
|
||||
EmitHset2(context, op.Cmp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.Bval);
|
||||
}
|
||||
|
||||
public static void Hset2C(EmitterContext context)
|
||||
{
|
||||
InstHset2C op = context.GetOp<InstHset2C>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegB, false);
|
||||
|
||||
EmitHset2(context, op.Cmp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.Bval);
|
||||
}
|
||||
|
||||
public static void Hsetp2R(EmitterContext context)
|
||||
{
|
||||
InstHsetp2R op = context.GetOp<InstHsetp2R>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BSwizzle, op.SrcB, op.NegB, op.AbsB);
|
||||
|
||||
EmitHsetp2(context, op.FComp2, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.DestPred, op.DestPredInv, op.HAnd);
|
||||
}
|
||||
|
||||
public static void Hsetp2I(EmitterContext context)
|
||||
{
|
||||
InstHsetp2I op = context.GetOp<InstHsetp2I>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, op.BimmH0, op.BimmH1);
|
||||
|
||||
EmitHsetp2(context, op.FComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.DestPred, op.DestPredInv, op.HAnd);
|
||||
}
|
||||
|
||||
public static void Hsetp2C(EmitterContext context)
|
||||
{
|
||||
InstHsetp2C op = context.GetOp<InstHsetp2C>();
|
||||
|
||||
Operand[] srcA = GetHalfSrc(context, op.ASwizzle, op.SrcA, op.NegA, op.AbsA);
|
||||
Operand[] srcB = GetHalfSrc(context, HalfSwizzle.F32, op.CbufSlot, op.CbufOffset, op.NegB, op.AbsB);
|
||||
|
||||
EmitHsetp2(context, op.FComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.DestPred, op.DestPredInv, op.HAnd);
|
||||
}
|
||||
|
||||
private static void EmitFcmp(EmitterContext context, FComp cmpOp, Operand srcA, Operand srcB, Operand srcC, int rd)
|
||||
{
|
||||
Operand cmpRes = GetFPComparison(context, cmpOp, srcC, ConstF(0));
|
||||
|
||||
Operand res = context.ConditionalSelect(cmpRes, srcA, srcB);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitFset(
|
||||
EmitterContext context,
|
||||
FComp cmpOp,
|
||||
BoolOp logicOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int srcPred,
|
||||
bool srcPredInv,
|
||||
int rd,
|
||||
bool absoluteA,
|
||||
bool absoluteB,
|
||||
bool negateA,
|
||||
bool negateB,
|
||||
bool boolFloat,
|
||||
bool writeCC,
|
||||
bool isFP64 = false)
|
||||
{
|
||||
Instruction fpType = isFP64 ? Instruction.FP64 : Instruction.FP32;
|
||||
|
||||
srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
|
||||
srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
|
||||
|
||||
Operand res = GetFPComparison(context, cmpOp, srcA, srcB, fpType);
|
||||
Operand pred = GetPredicate(context, srcPred, srcPredInv);
|
||||
|
||||
res = GetPredLogicalOp(context, logicOp, res, pred);
|
||||
|
||||
Operand dest = GetDest(rd);
|
||||
|
||||
if (boolFloat)
|
||||
{
|
||||
res = context.ConditionalSelect(res, ConstF(1), Const(0));
|
||||
|
||||
context.Copy(dest, res);
|
||||
|
||||
SetFPZnFlags(context, res, writeCC);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Copy(dest, res);
|
||||
|
||||
SetZnFlags(context, res, writeCC, extended: false);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitFsetp(
|
||||
EmitterContext context,
|
||||
FComp cmpOp,
|
||||
BoolOp logicOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int srcPred,
|
||||
bool srcPredInv,
|
||||
int destPred,
|
||||
int destPredInv,
|
||||
bool absoluteA,
|
||||
bool absoluteB,
|
||||
bool negateA,
|
||||
bool negateB,
|
||||
bool writeCC,
|
||||
bool isFP64 = false)
|
||||
{
|
||||
Instruction fpType = isFP64 ? Instruction.FP64 : Instruction.FP32;
|
||||
|
||||
srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
|
||||
srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
|
||||
|
||||
Operand p0Res = GetFPComparison(context, cmpOp, srcA, srcB, fpType);
|
||||
Operand p1Res = context.BitwiseNot(p0Res);
|
||||
Operand pred = GetPredicate(context, srcPred, srcPredInv);
|
||||
|
||||
p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred);
|
||||
p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred);
|
||||
|
||||
context.Copy(Register(destPred, RegisterType.Predicate), p0Res);
|
||||
context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res);
|
||||
}
|
||||
|
||||
private static void EmitHset2(
|
||||
EmitterContext context,
|
||||
FComp cmpOp,
|
||||
BoolOp logicOp,
|
||||
Operand[] srcA,
|
||||
Operand[] srcB,
|
||||
int srcPred,
|
||||
bool srcPredInv,
|
||||
int rd,
|
||||
bool boolFloat)
|
||||
{
|
||||
Operand[] res = new Operand[2];
|
||||
|
||||
res[0] = GetFPComparison(context, cmpOp, srcA[0], srcB[0]);
|
||||
res[1] = GetFPComparison(context, cmpOp, srcA[1], srcB[1]);
|
||||
|
||||
Operand pred = GetPredicate(context, srcPred, srcPredInv);
|
||||
|
||||
res[0] = GetPredLogicalOp(context, logicOp, res[0], pred);
|
||||
res[1] = GetPredLogicalOp(context, logicOp, res[1], pred);
|
||||
|
||||
if (boolFloat)
|
||||
{
|
||||
res[0] = context.ConditionalSelect(res[0], ConstF(1), Const(0));
|
||||
res[1] = context.ConditionalSelect(res[1], ConstF(1), Const(0));
|
||||
|
||||
context.Copy(GetDest(rd), context.PackHalf2x16(res[0], res[1]));
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand low = context.BitwiseAnd(res[0], Const(0xffff));
|
||||
Operand high = context.ShiftLeft(res[1], Const(16));
|
||||
|
||||
Operand packed = context.BitwiseOr(low, high);
|
||||
|
||||
context.Copy(GetDest(rd), packed);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitHsetp2(
|
||||
EmitterContext context,
|
||||
FComp cmpOp,
|
||||
BoolOp logicOp,
|
||||
Operand[] srcA,
|
||||
Operand[] srcB,
|
||||
int srcPred,
|
||||
bool srcPredInv,
|
||||
int destPred,
|
||||
int destPredInv,
|
||||
bool hAnd)
|
||||
{
|
||||
Operand p0Res = GetFPComparison(context, cmpOp, srcA[0], srcB[0]);
|
||||
Operand p1Res = GetFPComparison(context, cmpOp, srcA[1], srcB[1]);
|
||||
|
||||
if (hAnd)
|
||||
{
|
||||
p0Res = context.BitwiseAnd(p0Res, p1Res);
|
||||
p1Res = context.BitwiseNot(p0Res);
|
||||
}
|
||||
|
||||
Operand pred = GetPredicate(context, srcPred, srcPredInv);
|
||||
|
||||
p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred);
|
||||
p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred);
|
||||
|
||||
context.Copy(Register(destPred, RegisterType.Predicate), p0Res);
|
||||
context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res);
|
||||
}
|
||||
|
||||
private static Operand GetFPComparison(EmitterContext context, FComp cond, Operand srcA, Operand srcB, Instruction fpType = Instruction.FP32)
|
||||
{
|
||||
Operand res;
|
||||
|
||||
if (cond == FComp.T)
|
||||
{
|
||||
res = Const(IrConsts.True);
|
||||
}
|
||||
else if (cond == FComp.F)
|
||||
{
|
||||
res = Const(IrConsts.False);
|
||||
}
|
||||
else if (cond is FComp.Nan or FComp.Num)
|
||||
{
|
||||
res = context.BitwiseOr(context.IsNan(srcA, fpType), context.IsNan(srcB, fpType));
|
||||
|
||||
if (cond == FComp.Num)
|
||||
{
|
||||
res = context.BitwiseNot(res);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Instruction inst = (cond & ~FComp.Nan) switch
|
||||
{
|
||||
FComp.Lt => Instruction.CompareLess,
|
||||
FComp.Eq => Instruction.CompareEqual,
|
||||
FComp.Le => Instruction.CompareLessOrEqual,
|
||||
FComp.Gt => Instruction.CompareGreater,
|
||||
FComp.Ne => Instruction.CompareNotEqual,
|
||||
FComp.Ge => Instruction.CompareGreaterOrEqual,
|
||||
_ => throw new ArgumentException($"Unexpected condition \"{cond}\"."),
|
||||
};
|
||||
res = context.Add(inst | fpType, Local(), srcA, srcB);
|
||||
|
||||
if ((cond & FComp.Nan) != 0)
|
||||
{
|
||||
res = context.BitwiseOr(res, context.IsNan(srcA, fpType));
|
||||
res = context.BitwiseOr(res, context.IsNan(srcB, fpType));
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
106
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatMinMax.cs
vendored
Normal file
106
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFloatMinMax.cs
vendored
Normal file
@@ -0,0 +1,106 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void DmnmxR(EmitterContext context)
|
||||
{
|
||||
InstDmnmxR op = context.GetOp<InstDmnmxR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB, isFP64: true);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitFmnmx(context, srcA, srcB, srcPred, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.WriteCC, isFP64: true);
|
||||
}
|
||||
|
||||
public static void DmnmxI(EmitterContext context)
|
||||
{
|
||||
InstDmnmxI op = context.GetOp<InstDmnmxI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20), isFP64: true);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitFmnmx(context, srcA, srcB, srcPred, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.WriteCC, isFP64: true);
|
||||
}
|
||||
|
||||
public static void DmnmxC(EmitterContext context)
|
||||
{
|
||||
InstDmnmxC op = context.GetOp<InstDmnmxC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA, isFP64: true);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset, isFP64: true);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitFmnmx(context, srcA, srcB, srcPred, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.WriteCC, isFP64: true);
|
||||
}
|
||||
|
||||
public static void FmnmxR(EmitterContext context)
|
||||
{
|
||||
InstFmnmxR op = context.GetOp<InstFmnmxR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitFmnmx(context, srcA, srcB, srcPred, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FmnmxI(EmitterContext context)
|
||||
{
|
||||
InstFmnmxI op = context.GetOp<InstFmnmxI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToFloat(op.Imm20));
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitFmnmx(context, srcA, srcB, srcPred, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void FmnmxC(EmitterContext context)
|
||||
{
|
||||
InstFmnmxC op = context.GetOp<InstFmnmxC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitFmnmx(context, srcA, srcB, srcPred, op.Dest, op.AbsA, op.AbsB, op.NegA, op.NegB, op.WriteCC);
|
||||
}
|
||||
|
||||
private static void EmitFmnmx(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcPred,
|
||||
int rd,
|
||||
bool absoluteA,
|
||||
bool absoluteB,
|
||||
bool negateA,
|
||||
bool negateB,
|
||||
bool writeCC,
|
||||
bool isFP64 = false)
|
||||
{
|
||||
Instruction fpType = isFP64 ? Instruction.FP64 : Instruction.FP32;
|
||||
|
||||
srcA = context.FPAbsNeg(srcA, absoluteA, negateA, fpType);
|
||||
srcB = context.FPAbsNeg(srcB, absoluteB, negateB, fpType);
|
||||
|
||||
Operand resMin = context.FPMinimum(srcA, srcB, fpType);
|
||||
Operand resMax = context.FPMaximum(srcA, srcB, fpType);
|
||||
|
||||
Operand res = context.ConditionalSelect(srcPred, resMin, resMax);
|
||||
|
||||
SetDest(context, res, rd, isFP64);
|
||||
|
||||
SetFPZnFlags(context, res, writeCC, fpType);
|
||||
}
|
||||
}
|
||||
}
|
||||
328
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFlowControl.cs
vendored
Normal file
328
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitFlowControl.cs
vendored
Normal file
@@ -0,0 +1,328 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Bra(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstBra>();
|
||||
|
||||
EmitBranch(context, context.CurrBlock.Successors[^1].Address);
|
||||
}
|
||||
|
||||
public static void Brk(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstBrk>();
|
||||
|
||||
EmitBrkContSync(context);
|
||||
}
|
||||
|
||||
public static void Brx(EmitterContext context)
|
||||
{
|
||||
InstBrx op = context.GetOp<InstBrx>();
|
||||
InstOp currOp = context.CurrOp;
|
||||
int startIndex = context.CurrBlock.HasNext() ? 1 : 0;
|
||||
|
||||
if (context.CurrBlock.Successors.Count <= startIndex)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Failed to find targets for BRX instruction at 0x{currOp.Address:X}.");
|
||||
return;
|
||||
}
|
||||
|
||||
int offset = (int)currOp.GetAbsoluteAddress();
|
||||
|
||||
Operand address = context.IAdd(Register(op.SrcA, RegisterType.Gpr), Const(offset));
|
||||
|
||||
IEnumerable<Block> targets = context.CurrBlock.Successors.Skip(startIndex);
|
||||
|
||||
bool allTargetsSinglePred = true;
|
||||
int total = context.CurrBlock.Successors.Count - startIndex;
|
||||
int count = 0;
|
||||
|
||||
foreach (Block target in targets.OrderBy(x => x.Address))
|
||||
{
|
||||
if (++count < total && (target.Predecessors.Count > 1 || target.Address <= context.CurrBlock.Address))
|
||||
{
|
||||
allTargetsSinglePred = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (allTargetsSinglePred)
|
||||
{
|
||||
// Chain blocks, each target block will check if the BRX target address
|
||||
// matches its own address, if not, it jumps to the next target which will do the same check,
|
||||
// until it reaches the last possible target, which executed unconditionally.
|
||||
// We can only do this if the BRX block is the only predecessor of all target blocks.
|
||||
// Additionally, this is not supported for blocks located before the current block,
|
||||
// since it will be too late to insert a label, but this is something that can be improved
|
||||
// in the future if necessary.
|
||||
|
||||
IOrderedEnumerable<Block> sortedTargets = targets.OrderBy(x => x.Address);
|
||||
|
||||
Block currentTarget = null;
|
||||
ulong firstTargetAddress = 0;
|
||||
|
||||
foreach (Block nextTarget in sortedTargets)
|
||||
{
|
||||
if (currentTarget != null)
|
||||
{
|
||||
if (currentTarget.Address != nextTarget.Address)
|
||||
{
|
||||
context.SetBrxTarget(currentTarget.Address, address, (int)currentTarget.Address, nextTarget.Address);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
firstTargetAddress = nextTarget.Address;
|
||||
}
|
||||
|
||||
currentTarget = nextTarget;
|
||||
}
|
||||
|
||||
context.Branch(context.GetLabel(firstTargetAddress));
|
||||
}
|
||||
else
|
||||
{
|
||||
// Emit the branches sequentially.
|
||||
// This generates slightly worse code, but should work for all cases.
|
||||
|
||||
IOrderedEnumerable<Block> sortedTargets = targets.OrderByDescending(x => x.Address);
|
||||
ulong lastTargetAddress = ulong.MaxValue;
|
||||
|
||||
count = 0;
|
||||
|
||||
foreach (Block target in sortedTargets)
|
||||
{
|
||||
Operand label = context.GetLabel(target.Address);
|
||||
|
||||
if (++count < total)
|
||||
{
|
||||
if (target.Address != lastTargetAddress)
|
||||
{
|
||||
context.BranchIfTrue(label, context.ICompareEqual(address, Const((int)target.Address)));
|
||||
}
|
||||
|
||||
lastTargetAddress = target.Address;
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Branch(label);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void Cal(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstCal>();
|
||||
|
||||
DecodedFunction function = context.Program.GetFunctionByAddress(context.CurrOp.GetAbsoluteAddress());
|
||||
|
||||
if (function.IsCompilerGenerated)
|
||||
{
|
||||
switch (function.Type)
|
||||
{
|
||||
case FunctionType.BuiltInFSIBegin:
|
||||
context.FSIBegin();
|
||||
break;
|
||||
case FunctionType.BuiltInFSIEnd:
|
||||
context.FSIEnd();
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Call(function.Id, false);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Cont(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstCont>();
|
||||
|
||||
EmitBrkContSync(context);
|
||||
}
|
||||
|
||||
public static void Exit(EmitterContext context)
|
||||
{
|
||||
InstExit op = context.GetOp<InstExit>();
|
||||
|
||||
if (context.IsNonMain)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid exit on non-main function.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (op.Ccc == Ccc.T)
|
||||
{
|
||||
if (context.PrepareForReturn())
|
||||
{
|
||||
context.Return();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand cond = GetCondition(context, op.Ccc, IrConsts.False);
|
||||
|
||||
// If the condition is always false, we don't need to do anything.
|
||||
if (cond.Type != OperandType.Constant || cond.Value != IrConsts.False)
|
||||
{
|
||||
Operand lblSkip = Label();
|
||||
context.BranchIfFalse(lblSkip, cond);
|
||||
|
||||
if (context.PrepareForReturn())
|
||||
{
|
||||
context.Return();
|
||||
}
|
||||
|
||||
context.MarkLabel(lblSkip);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void Kil(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstKil>();
|
||||
|
||||
context.Discard();
|
||||
}
|
||||
|
||||
public static void Pbk(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPbk>();
|
||||
|
||||
EmitPbkPcntSsy(context);
|
||||
}
|
||||
|
||||
public static void Pcnt(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstPcnt>();
|
||||
|
||||
EmitPbkPcntSsy(context);
|
||||
}
|
||||
|
||||
public static void Ret(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstRet>();
|
||||
|
||||
if (context.IsNonMain)
|
||||
{
|
||||
context.Return();
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid return on main function.");
|
||||
}
|
||||
}
|
||||
|
||||
public static void Ssy(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstSsy>();
|
||||
|
||||
EmitPbkPcntSsy(context);
|
||||
}
|
||||
|
||||
public static void Sync(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstSync>();
|
||||
|
||||
EmitBrkContSync(context);
|
||||
}
|
||||
|
||||
private static void EmitPbkPcntSsy(EmitterContext context)
|
||||
{
|
||||
Dictionary<Block, Operand> consumers = context.CurrBlock.PushOpCodes.First(x => x.Op.Address == context.CurrOp.Address).Consumers;
|
||||
|
||||
foreach (KeyValuePair<Block, Operand> kv in consumers)
|
||||
{
|
||||
Block consumerBlock = kv.Key;
|
||||
Operand local = kv.Value;
|
||||
|
||||
int id = consumerBlock.SyncTargets[context.CurrOp.Address].PushOpId;
|
||||
|
||||
context.Copy(local, Const(id));
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitBrkContSync(EmitterContext context)
|
||||
{
|
||||
Dictionary<ulong, SyncTarget> targets = context.CurrBlock.SyncTargets;
|
||||
|
||||
if (targets.Count == 1)
|
||||
{
|
||||
// If we have only one target, then the SSY/PBK is basically
|
||||
// a branch, we can produce better codegen for this case.
|
||||
EmitBranch(context, targets.Values.First().PushOpInfo.Op.GetAbsoluteAddress());
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Support CC here as well (condition).
|
||||
foreach (SyncTarget target in targets.Values)
|
||||
{
|
||||
PushOpInfo pushOpInfo = target.PushOpInfo;
|
||||
|
||||
Operand label = context.GetLabel(pushOpInfo.Op.GetAbsoluteAddress());
|
||||
Operand local = pushOpInfo.Consumers[context.CurrBlock];
|
||||
|
||||
context.BranchIfTrue(label, context.ICompareEqual(local, Const(target.PushOpId)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitBranch(EmitterContext context, ulong address)
|
||||
{
|
||||
InstOp op = context.CurrOp;
|
||||
InstConditional opCond = new(op.RawOpCode);
|
||||
|
||||
// If we're branching to the next instruction, then the branch
|
||||
// is useless and we can ignore it.
|
||||
if (address == op.Address + 8)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Operand label = context.GetLabel(address);
|
||||
|
||||
Operand pred = Register(opCond.Pred, RegisterType.Predicate);
|
||||
|
||||
if (opCond.Ccc != Ccc.T)
|
||||
{
|
||||
Operand cond = GetCondition(context, opCond.Ccc);
|
||||
|
||||
if (opCond.Pred == RegisterConsts.PredicateTrueIndex)
|
||||
{
|
||||
pred = cond;
|
||||
}
|
||||
else if (opCond.PredInv)
|
||||
{
|
||||
pred = context.BitwiseAnd(context.BitwiseNot(pred), cond);
|
||||
}
|
||||
else
|
||||
{
|
||||
pred = context.BitwiseAnd(pred, cond);
|
||||
}
|
||||
|
||||
context.BranchIfTrue(label, pred);
|
||||
}
|
||||
else if (opCond.Pred == RegisterConsts.PredicateTrueIndex)
|
||||
{
|
||||
context.Branch(label);
|
||||
}
|
||||
else if (opCond.PredInv)
|
||||
{
|
||||
context.BranchIfFalse(label, pred);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.BranchIfTrue(label, pred);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
260
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitHelper.cs
vendored
Normal file
260
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitHelper.cs
vendored
Normal file
@@ -0,0 +1,260 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Runtime.CompilerServices;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static class InstEmitHelper
|
||||
{
|
||||
public static Operand GetZF()
|
||||
{
|
||||
return Register(0, RegisterType.Flag);
|
||||
}
|
||||
|
||||
public static Operand GetNF()
|
||||
{
|
||||
return Register(1, RegisterType.Flag);
|
||||
}
|
||||
|
||||
public static Operand GetCF()
|
||||
{
|
||||
return Register(2, RegisterType.Flag);
|
||||
}
|
||||
|
||||
public static Operand GetVF()
|
||||
{
|
||||
return Register(3, RegisterType.Flag);
|
||||
}
|
||||
|
||||
public static Operand GetDest(int rd)
|
||||
{
|
||||
return Register(rd, RegisterType.Gpr);
|
||||
}
|
||||
|
||||
public static Operand GetDest2(int rd)
|
||||
{
|
||||
return Register(rd | 1, RegisterType.Gpr);
|
||||
}
|
||||
|
||||
public static Operand GetSrcCbuf(EmitterContext context, int cbufSlot, int cbufOffset, bool isFP64 = false)
|
||||
{
|
||||
if (isFP64)
|
||||
{
|
||||
return context.PackDouble2x32(
|
||||
Cbuf(cbufSlot, cbufOffset),
|
||||
Cbuf(cbufSlot, cbufOffset + 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
return Cbuf(cbufSlot, cbufOffset);
|
||||
}
|
||||
}
|
||||
|
||||
public static Operand GetSrcImm(EmitterContext context, int imm, bool isFP64 = false)
|
||||
{
|
||||
if (isFP64)
|
||||
{
|
||||
return context.PackDouble2x32(Const(0), Const(imm));
|
||||
}
|
||||
else
|
||||
{
|
||||
return Const(imm);
|
||||
}
|
||||
}
|
||||
|
||||
public static Operand GetSrcReg(EmitterContext context, int reg, bool isFP64 = false)
|
||||
{
|
||||
if (isFP64)
|
||||
{
|
||||
return context.PackDouble2x32(Register(reg, RegisterType.Gpr), Register(reg | 1, RegisterType.Gpr));
|
||||
}
|
||||
else
|
||||
{
|
||||
return Register(reg, RegisterType.Gpr);
|
||||
}
|
||||
}
|
||||
|
||||
public static Operand[] GetHalfSrc(
|
||||
EmitterContext context,
|
||||
HalfSwizzle swizzle,
|
||||
int ra,
|
||||
bool negate,
|
||||
bool absolute)
|
||||
{
|
||||
Operand[] operands = GetHalfUnpacked(context, GetSrcReg(context, ra), swizzle);
|
||||
|
||||
return FPAbsNeg(context, operands, absolute, negate);
|
||||
}
|
||||
|
||||
public static Operand[] GetHalfSrc(
|
||||
EmitterContext context,
|
||||
HalfSwizzle swizzle,
|
||||
int cbufSlot,
|
||||
int cbufOffset,
|
||||
bool negate,
|
||||
bool absolute)
|
||||
{
|
||||
Operand[] operands = GetHalfUnpacked(context, GetSrcCbuf(context, cbufSlot, cbufOffset), swizzle);
|
||||
|
||||
return FPAbsNeg(context, operands, absolute, negate);
|
||||
}
|
||||
|
||||
public static Operand[] GetHalfSrc(EmitterContext context, int immH0, int immH1)
|
||||
{
|
||||
ushort low = (ushort)(immH0 << 6);
|
||||
ushort high = (ushort)(immH1 << 6);
|
||||
|
||||
return
|
||||
[
|
||||
ConstF((float)Unsafe.As<ushort, Half>(ref low)),
|
||||
ConstF((float)Unsafe.As<ushort, Half>(ref high))
|
||||
];
|
||||
}
|
||||
|
||||
public static Operand[] GetHalfSrc(EmitterContext context, int imm32)
|
||||
{
|
||||
ushort low = (ushort)imm32;
|
||||
ushort high = (ushort)(imm32 >> 16);
|
||||
|
||||
return
|
||||
[
|
||||
ConstF((float)Unsafe.As<ushort, Half>(ref low)),
|
||||
ConstF((float)Unsafe.As<ushort, Half>(ref high))
|
||||
];
|
||||
}
|
||||
|
||||
public static Operand[] FPAbsNeg(EmitterContext context, Operand[] operands, bool abs, bool neg)
|
||||
{
|
||||
for (int index = 0; index < operands.Length; index++)
|
||||
{
|
||||
operands[index] = context.FPAbsNeg(operands[index], abs, neg);
|
||||
}
|
||||
|
||||
return operands;
|
||||
}
|
||||
|
||||
public static Operand[] GetHalfUnpacked(EmitterContext context, Operand src, HalfSwizzle swizzle)
|
||||
{
|
||||
return swizzle switch
|
||||
{
|
||||
HalfSwizzle.F16 =>
|
||||
[
|
||||
context.UnpackHalf2x16Low (src),
|
||||
context.UnpackHalf2x16High(src)
|
||||
],
|
||||
HalfSwizzle.F32 => [src, src],
|
||||
HalfSwizzle.H0H0 =>
|
||||
[
|
||||
context.UnpackHalf2x16Low(src),
|
||||
context.UnpackHalf2x16Low(src)
|
||||
],
|
||||
HalfSwizzle.H1H1 =>
|
||||
[
|
||||
context.UnpackHalf2x16High(src),
|
||||
context.UnpackHalf2x16High(src)
|
||||
],
|
||||
_ => throw new ArgumentException($"Invalid swizzle \"{swizzle}\"."),
|
||||
};
|
||||
}
|
||||
|
||||
public static Operand GetHalfPacked(EmitterContext context, OFmt swizzle, Operand[] results, int rd)
|
||||
{
|
||||
switch (swizzle)
|
||||
{
|
||||
case OFmt.F16:
|
||||
return context.PackHalf2x16(results[0], results[1]);
|
||||
|
||||
case OFmt.F32:
|
||||
return results[0];
|
||||
|
||||
case OFmt.MrgH0:
|
||||
{
|
||||
Operand h1 = GetHalfDest(context, rd, isHigh: true);
|
||||
|
||||
return context.PackHalf2x16(results[0], h1);
|
||||
}
|
||||
|
||||
case OFmt.MrgH1:
|
||||
{
|
||||
Operand h0 = GetHalfDest(context, rd, isHigh: false);
|
||||
|
||||
return context.PackHalf2x16(h0, results[1]);
|
||||
}
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Invalid swizzle \"{swizzle}\".");
|
||||
}
|
||||
|
||||
public static Operand GetHalfDest(EmitterContext context, int rd, bool isHigh)
|
||||
{
|
||||
if (isHigh)
|
||||
{
|
||||
return context.UnpackHalf2x16High(GetDest(rd));
|
||||
}
|
||||
else
|
||||
{
|
||||
return context.UnpackHalf2x16Low(GetDest(rd));
|
||||
}
|
||||
}
|
||||
|
||||
public static Operand GetPredicate(EmitterContext context, int pred, bool not)
|
||||
{
|
||||
Operand local = Register(pred, RegisterType.Predicate);
|
||||
|
||||
if (not)
|
||||
{
|
||||
local = context.BitwiseNot(local);
|
||||
}
|
||||
|
||||
return local;
|
||||
}
|
||||
|
||||
public static void SetDest(EmitterContext context, Operand value, int rd, bool isFP64)
|
||||
{
|
||||
if (isFP64)
|
||||
{
|
||||
context.Copy(GetDest(rd), context.UnpackDouble2x32Low(value));
|
||||
context.Copy(GetDest2(rd), context.UnpackDouble2x32High(value));
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Copy(GetDest(rd), value);
|
||||
}
|
||||
}
|
||||
|
||||
public static int Imm16ToSInt(int imm16)
|
||||
{
|
||||
return (short)imm16;
|
||||
}
|
||||
|
||||
public static int Imm20ToFloat(int imm20)
|
||||
{
|
||||
return imm20 << 12;
|
||||
}
|
||||
|
||||
public static int Imm20ToSInt(int imm20)
|
||||
{
|
||||
return (imm20 << 12) >> 12;
|
||||
}
|
||||
|
||||
public static int Imm24ToSInt(int imm24)
|
||||
{
|
||||
return (imm24 << 8) >> 8;
|
||||
}
|
||||
|
||||
public static Operand SignExtendTo32(EmitterContext context, Operand src, int srcBits)
|
||||
{
|
||||
return context.BitfieldExtractS32(src, Const(0), Const(srcBits));
|
||||
}
|
||||
|
||||
public static Operand ZeroExtendTo32(EmitterContext context, Operand src, int srcBits)
|
||||
{
|
||||
int mask = (int)(uint.MaxValue >> (32 - srcBits));
|
||||
|
||||
return context.BitwiseAnd(src, Const(mask));
|
||||
}
|
||||
}
|
||||
}
|
||||
701
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerArithmetic.cs
vendored
Normal file
701
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerArithmetic.cs
vendored
Normal file
@@ -0,0 +1,701 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void IaddR(EmitterContext context)
|
||||
{
|
||||
InstIaddR op = context.GetOp<InstIaddR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitIadd(context, srcA, srcB, op.Dest, op.AvgMode, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IaddI(EmitterContext context)
|
||||
{
|
||||
InstIaddI op = context.GetOp<InstIaddI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitIadd(context, srcA, srcB, op.Dest, op.AvgMode, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IaddC(EmitterContext context)
|
||||
{
|
||||
InstIaddC op = context.GetOp<InstIaddC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitIadd(context, srcA, srcB, op.Dest, op.AvgMode, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Iadd32i(EmitterContext context)
|
||||
{
|
||||
InstIadd32i op = context.GetOp<InstIadd32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
|
||||
EmitIadd(context, srcA, srcB, op.Dest, op.AvgMode, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Iadd3R(EmitterContext context)
|
||||
{
|
||||
InstIadd3R op = context.GetOp<InstIadd3R>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitIadd3(context, op.Lrs, srcA, srcB, srcC, op.Apart, op.Bpart, op.Cpart, op.Dest, op.NegA, op.NegB, op.NegC);
|
||||
}
|
||||
|
||||
public static void Iadd3I(EmitterContext context)
|
||||
{
|
||||
InstIadd3I op = context.GetOp<InstIadd3I>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitIadd3(context, Lrs.None, srcA, srcB, srcC, HalfSelect.B32, HalfSelect.B32, HalfSelect.B32, op.Dest, op.NegA, op.NegB, op.NegC);
|
||||
}
|
||||
|
||||
public static void Iadd3C(EmitterContext context)
|
||||
{
|
||||
InstIadd3C op = context.GetOp<InstIadd3C>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitIadd3(context, Lrs.None, srcA, srcB, srcC, HalfSelect.B32, HalfSelect.B32, HalfSelect.B32, op.Dest, op.NegA, op.NegB, op.NegC);
|
||||
}
|
||||
|
||||
public static void ImadR(EmitterContext context)
|
||||
{
|
||||
InstImadR op = context.GetOp<InstImadR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitImad(context, srcA, srcB, srcC, op.Dest, op.AvgMode, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void ImadI(EmitterContext context)
|
||||
{
|
||||
InstImadI op = context.GetOp<InstImadI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitImad(context, srcA, srcB, srcC, op.Dest, op.AvgMode, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void ImadC(EmitterContext context)
|
||||
{
|
||||
InstImadC op = context.GetOp<InstImadC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitImad(context, srcA, srcB, srcC, op.Dest, op.AvgMode, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void ImadRc(EmitterContext context)
|
||||
{
|
||||
InstImadRc op = context.GetOp<InstImadRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitImad(context, srcA, srcB, srcC, op.Dest, op.AvgMode, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void Imad32i(EmitterContext context)
|
||||
{
|
||||
InstImad32i op = context.GetOp<InstImad32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
Operand srcC = GetSrcReg(context, op.Dest);
|
||||
|
||||
EmitImad(context, srcA, srcB, srcC, op.Dest, op.AvgMode, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void ImulR(EmitterContext context)
|
||||
{
|
||||
InstImulR op = context.GetOp<InstImulR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitImad(context, srcA, srcB, Const(0), op.Dest, AvgMode.NoNeg, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void ImulI(EmitterContext context)
|
||||
{
|
||||
InstImulI op = context.GetOp<InstImulI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitImad(context, srcA, srcB, Const(0), op.Dest, AvgMode.NoNeg, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void ImulC(EmitterContext context)
|
||||
{
|
||||
InstImulC op = context.GetOp<InstImulC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitImad(context, srcA, srcB, Const(0), op.Dest, AvgMode.NoNeg, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void Imul32i(EmitterContext context)
|
||||
{
|
||||
InstImul32i op = context.GetOp<InstImul32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
|
||||
EmitImad(context, srcA, srcB, Const(0), op.Dest, AvgMode.NoNeg, op.ASigned, op.BSigned, op.Hilo);
|
||||
}
|
||||
|
||||
public static void IscaddR(EmitterContext context)
|
||||
{
|
||||
InstIscaddR op = context.GetOp<InstIscaddR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitIscadd(context, srcA, srcB, op.Dest, op.Imm5, op.AvgMode, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IscaddI(EmitterContext context)
|
||||
{
|
||||
InstIscaddI op = context.GetOp<InstIscaddI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitIscadd(context, srcA, srcB, op.Dest, op.Imm5, op.AvgMode, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IscaddC(EmitterContext context)
|
||||
{
|
||||
InstIscaddC op = context.GetOp<InstIscaddC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitIscadd(context, srcA, srcB, op.Dest, op.Imm5, op.AvgMode, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Iscadd32i(EmitterContext context)
|
||||
{
|
||||
InstIscadd32i op = context.GetOp<InstIscadd32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
|
||||
EmitIscadd(context, srcA, srcB, op.Dest, op.Imm5, AvgMode.NoNeg, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void LeaR(EmitterContext context)
|
||||
{
|
||||
InstLeaR op = context.GetOp<InstLeaR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitLea(context, srcA, srcB, op.Dest, op.NegA, op.ImmU5);
|
||||
}
|
||||
|
||||
public static void LeaI(EmitterContext context)
|
||||
{
|
||||
InstLeaI op = context.GetOp<InstLeaI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitLea(context, srcA, srcB, op.Dest, op.NegA, op.ImmU5);
|
||||
}
|
||||
|
||||
public static void LeaC(EmitterContext context)
|
||||
{
|
||||
InstLeaC op = context.GetOp<InstLeaC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitLea(context, srcA, srcB, op.Dest, op.NegA, op.ImmU5);
|
||||
}
|
||||
|
||||
public static void LeaHiR(EmitterContext context)
|
||||
{
|
||||
InstLeaHiR op = context.GetOp<InstLeaHiR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitLeaHi(context, srcA, srcB, srcC, op.Dest, op.NegA, op.ImmU5);
|
||||
}
|
||||
|
||||
public static void LeaHiC(EmitterContext context)
|
||||
{
|
||||
InstLeaHiC op = context.GetOp<InstLeaHiC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitLeaHi(context, srcA, srcB, srcC, op.Dest, op.NegA, op.ImmU5);
|
||||
}
|
||||
|
||||
public static void XmadR(EmitterContext context)
|
||||
{
|
||||
InstXmadR op = context.GetOp<InstXmadR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitXmad(context, op.XmadCop, srcA, srcB, srcC, op.Dest, op.ASigned, op.BSigned, op.HiloA, op.HiloB, op.Psl, op.Mrg, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void XmadI(EmitterContext context)
|
||||
{
|
||||
InstXmadI op = context.GetOp<InstXmadI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm16);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitXmad(context, op.XmadCop, srcA, srcB, srcC, op.Dest, op.ASigned, op.BSigned, op.HiloA, false, op.Psl, op.Mrg, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void XmadC(EmitterContext context)
|
||||
{
|
||||
InstXmadC op = context.GetOp<InstXmadC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitXmad(context, op.XmadCop, srcA, srcB, srcC, op.Dest, op.ASigned, op.BSigned, op.HiloA, op.HiloB, op.Psl, op.Mrg, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void XmadRc(EmitterContext context)
|
||||
{
|
||||
InstXmadRc op = context.GetOp<InstXmadRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitXmad(context, op.XmadCop, srcA, srcB, srcC, op.Dest, op.ASigned, op.BSigned, op.HiloA, op.HiloB, false, false, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
private static void EmitIadd(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
AvgMode avgMode,
|
||||
bool extended,
|
||||
bool writeCC)
|
||||
{
|
||||
srcA = context.INegate(srcA, avgMode == AvgMode.NegA);
|
||||
srcB = context.INegate(srcB, avgMode == AvgMode.NegB);
|
||||
|
||||
Operand res = context.IAdd(srcA, srcB);
|
||||
|
||||
if (extended)
|
||||
{
|
||||
res = context.IAdd(res, context.BitwiseAnd(GetCF(), Const(1)));
|
||||
}
|
||||
|
||||
SetIaddFlags(context, res, srcA, srcB, writeCC, extended);
|
||||
|
||||
// TODO: SAT.
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitIadd3(
|
||||
EmitterContext context,
|
||||
Lrs mode,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
HalfSelect partA,
|
||||
HalfSelect partB,
|
||||
HalfSelect partC,
|
||||
int rd,
|
||||
bool negateA,
|
||||
bool negateB,
|
||||
bool negateC)
|
||||
{
|
||||
Operand Extend(Operand src, HalfSelect part)
|
||||
{
|
||||
if (part == HalfSelect.B32)
|
||||
{
|
||||
return src;
|
||||
}
|
||||
|
||||
if (part == HalfSelect.H0)
|
||||
{
|
||||
return context.BitwiseAnd(src, Const(0xffff));
|
||||
}
|
||||
else if (part == HalfSelect.H1)
|
||||
{
|
||||
return context.ShiftRightU32(src, Const(16));
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Iadd3 has invalid component selection {part}.");
|
||||
}
|
||||
|
||||
return src;
|
||||
}
|
||||
|
||||
srcA = context.INegate(Extend(srcA, partA), negateA);
|
||||
srcB = context.INegate(Extend(srcB, partB), negateB);
|
||||
srcC = context.INegate(Extend(srcC, partC), negateC);
|
||||
|
||||
Operand res = context.IAdd(srcA, srcB);
|
||||
|
||||
if (mode != Lrs.None)
|
||||
{
|
||||
if (mode == Lrs.LeftShift)
|
||||
{
|
||||
res = context.ShiftLeft(res, Const(16));
|
||||
}
|
||||
else if (mode == Lrs.RightShift)
|
||||
{
|
||||
res = context.ShiftRightU32(res, Const(16));
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Warning.
|
||||
}
|
||||
}
|
||||
|
||||
res = context.IAdd(res, srcC);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
// TODO: CC, X, corner cases.
|
||||
}
|
||||
|
||||
private static void EmitImad(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
AvgMode avgMode,
|
||||
bool signedA,
|
||||
bool signedB,
|
||||
bool high)
|
||||
{
|
||||
srcB = context.INegate(srcB, avgMode == AvgMode.NegA);
|
||||
srcC = context.INegate(srcC, avgMode == AvgMode.NegB);
|
||||
|
||||
Operand res;
|
||||
|
||||
if (high)
|
||||
{
|
||||
if (signedA && signedB)
|
||||
{
|
||||
res = context.MultiplyHighS32(srcA, srcB);
|
||||
}
|
||||
else
|
||||
{
|
||||
res = context.MultiplyHighU32(srcA, srcB);
|
||||
|
||||
if (signedA)
|
||||
{
|
||||
res = context.IAdd(res, context.IMultiply(srcB, context.ShiftRightS32(srcA, Const(31))));
|
||||
}
|
||||
else if (signedB)
|
||||
{
|
||||
res = context.IAdd(res, context.IMultiply(srcA, context.ShiftRightS32(srcB, Const(31))));
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
res = context.IMultiply(srcA, srcB);
|
||||
}
|
||||
|
||||
if (srcC.Type != OperandType.Constant || srcC.Value != 0)
|
||||
{
|
||||
res = context.IAdd(res, srcC);
|
||||
}
|
||||
|
||||
// TODO: CC, X, SAT, and more?
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitIscadd(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
int shift,
|
||||
AvgMode avgMode,
|
||||
bool writeCC)
|
||||
{
|
||||
srcA = context.ShiftLeft(srcA, Const(shift));
|
||||
|
||||
srcA = context.INegate(srcA, avgMode == AvgMode.NegA);
|
||||
srcB = context.INegate(srcB, avgMode == AvgMode.NegB);
|
||||
|
||||
Operand res = context.IAdd(srcA, srcB);
|
||||
|
||||
SetIaddFlags(context, res, srcA, srcB, writeCC, false);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
public static void EmitLea(EmitterContext context, Operand srcA, Operand srcB, int rd, bool negateA, int shift)
|
||||
{
|
||||
srcA = context.ShiftLeft(srcA, Const(shift));
|
||||
srcA = context.INegate(srcA, negateA);
|
||||
|
||||
Operand res = context.IAdd(srcA, srcB);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
// TODO: CC, X.
|
||||
}
|
||||
|
||||
private static void EmitLeaHi(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
bool negateA,
|
||||
int shift)
|
||||
{
|
||||
Operand aLow = context.ShiftLeft(srcA, Const(shift));
|
||||
Operand aHigh = shift == 0 ? Const(0) : context.ShiftRightU32(srcA, Const(32 - shift));
|
||||
aHigh = context.BitwiseOr(aHigh, context.ShiftLeft(srcC, Const(shift)));
|
||||
|
||||
if (negateA)
|
||||
{
|
||||
// Perform 64-bit negation by doing bitwise not of the value,
|
||||
// then adding 1 and carrying over from low to high.
|
||||
aLow = context.BitwiseNot(aLow);
|
||||
aHigh = context.BitwiseNot(aHigh);
|
||||
|
||||
#pragma warning disable IDE0059 // Remove unnecessary value assignment
|
||||
aLow = AddWithCarry(context, aLow, Const(1), out Operand aLowCOut);
|
||||
#pragma warning restore IDE0059
|
||||
aHigh = context.IAdd(aHigh, aLowCOut);
|
||||
}
|
||||
|
||||
Operand res = context.IAdd(aHigh, srcB);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
// TODO: CC, X.
|
||||
}
|
||||
|
||||
public static void EmitXmad(
|
||||
EmitterContext context,
|
||||
XmadCop2 mode,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
bool signedA,
|
||||
bool signedB,
|
||||
bool highA,
|
||||
bool highB,
|
||||
bool productShiftLeft,
|
||||
bool merge,
|
||||
bool extended,
|
||||
bool writeCC)
|
||||
{
|
||||
XmadCop modeConv;
|
||||
switch (mode)
|
||||
{
|
||||
case XmadCop2.Cfull:
|
||||
modeConv = XmadCop.Cfull;
|
||||
break;
|
||||
case XmadCop2.Clo:
|
||||
modeConv = XmadCop.Clo;
|
||||
break;
|
||||
case XmadCop2.Chi:
|
||||
modeConv = XmadCop.Chi;
|
||||
break;
|
||||
case XmadCop2.Csfu:
|
||||
modeConv = XmadCop.Csfu;
|
||||
break;
|
||||
default:
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid XMAD mode \"{mode}\".");
|
||||
return;
|
||||
}
|
||||
|
||||
EmitXmad(context, modeConv, srcA, srcB, srcC, rd, signedA, signedB, highA, highB, productShiftLeft, merge, extended, writeCC);
|
||||
}
|
||||
|
||||
public static void EmitXmad(
|
||||
EmitterContext context,
|
||||
XmadCop mode,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
bool signedA,
|
||||
bool signedB,
|
||||
bool highA,
|
||||
bool highB,
|
||||
bool productShiftLeft,
|
||||
bool merge,
|
||||
bool extended,
|
||||
bool writeCC)
|
||||
{
|
||||
Operand srcBUnmodified = srcB;
|
||||
|
||||
Operand Extend16To32(Operand src, bool high, bool signed)
|
||||
{
|
||||
if (signed && high)
|
||||
{
|
||||
return context.ShiftRightS32(src, Const(16));
|
||||
}
|
||||
else if (signed)
|
||||
{
|
||||
return context.BitfieldExtractS32(src, Const(0), Const(16));
|
||||
}
|
||||
else if (high)
|
||||
{
|
||||
return context.ShiftRightU32(src, Const(16));
|
||||
}
|
||||
else
|
||||
{
|
||||
return context.BitwiseAnd(src, Const(0xffff));
|
||||
}
|
||||
}
|
||||
|
||||
srcA = Extend16To32(srcA, highA, signedA);
|
||||
srcB = Extend16To32(srcB, highB, signedB);
|
||||
|
||||
Operand res = context.IMultiply(srcA, srcB);
|
||||
|
||||
if (productShiftLeft)
|
||||
{
|
||||
res = context.ShiftLeft(res, Const(16));
|
||||
}
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
case XmadCop.Cfull:
|
||||
break;
|
||||
|
||||
case XmadCop.Clo:
|
||||
srcC = Extend16To32(srcC, high: false, signed: false);
|
||||
break;
|
||||
case XmadCop.Chi:
|
||||
srcC = Extend16To32(srcC, high: true, signed: false);
|
||||
break;
|
||||
|
||||
case XmadCop.Cbcc:
|
||||
srcC = context.IAdd(srcC, context.ShiftLeft(srcBUnmodified, Const(16)));
|
||||
break;
|
||||
|
||||
case XmadCop.Csfu:
|
||||
Operand signAdjustA = context.ShiftLeft(context.ShiftRightU32(srcA, Const(31)), Const(16));
|
||||
Operand signAdjustB = context.ShiftLeft(context.ShiftRightU32(srcB, Const(31)), Const(16));
|
||||
|
||||
srcC = context.ISubtract(srcC, context.IAdd(signAdjustA, signAdjustB));
|
||||
break;
|
||||
|
||||
default:
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid XMAD mode \"{mode}\".");
|
||||
return;
|
||||
}
|
||||
|
||||
Operand product = res;
|
||||
|
||||
if (extended)
|
||||
{
|
||||
// Add with carry.
|
||||
res = context.IAdd(res, context.BitwiseAnd(GetCF(), Const(1)));
|
||||
}
|
||||
else
|
||||
{
|
||||
// Add (no carry in).
|
||||
res = context.IAdd(res, srcC);
|
||||
}
|
||||
|
||||
SetIaddFlags(context, res, product, srcC, writeCC, extended);
|
||||
|
||||
if (merge)
|
||||
{
|
||||
res = context.BitwiseAnd(res, Const(0xffff));
|
||||
res = context.BitwiseOr(res, context.ShiftLeft(srcBUnmodified, Const(16)));
|
||||
}
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void SetIaddFlags(EmitterContext context, Operand res, Operand srcA, Operand srcB, bool setCC, bool extended)
|
||||
{
|
||||
if (!setCC)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (extended)
|
||||
{
|
||||
// C = (d == a && CIn) || d < a
|
||||
Operand tempC0 = context.ICompareEqual(res, srcA);
|
||||
Operand tempC1 = context.ICompareLessUnsigned(res, srcA);
|
||||
|
||||
tempC0 = context.BitwiseAnd(tempC0, GetCF());
|
||||
|
||||
context.Copy(GetCF(), context.BitwiseOr(tempC0, tempC1));
|
||||
}
|
||||
else
|
||||
{
|
||||
// C = d < a
|
||||
context.Copy(GetCF(), context.ICompareLessUnsigned(res, srcA));
|
||||
}
|
||||
|
||||
// V = (d ^ a) & ~(a ^ b) < 0
|
||||
Operand tempV0 = context.BitwiseExclusiveOr(res, srcA);
|
||||
Operand tempV1 = context.BitwiseExclusiveOr(srcA, srcB);
|
||||
|
||||
tempV1 = context.BitwiseNot(tempV1);
|
||||
|
||||
Operand tempV = context.BitwiseAnd(tempV0, tempV1);
|
||||
|
||||
context.Copy(GetVF(), context.ICompareLess(tempV, Const(0)));
|
||||
|
||||
SetZnFlags(context, res, setCC: true, extended: extended);
|
||||
}
|
||||
}
|
||||
}
|
||||
319
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerComparison.cs
vendored
Normal file
319
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerComparison.cs
vendored
Normal file
@@ -0,0 +1,319 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void IcmpR(EmitterContext context)
|
||||
{
|
||||
InstIcmpR op = context.GetOp<InstIcmpR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitIcmp(context, op.IComp, srcA, srcB, srcC, op.Dest, op.Signed);
|
||||
}
|
||||
|
||||
public static void IcmpI(EmitterContext context)
|
||||
{
|
||||
InstIcmpI op = context.GetOp<InstIcmpI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitIcmp(context, op.IComp, srcA, srcB, srcC, op.Dest, op.Signed);
|
||||
}
|
||||
|
||||
public static void IcmpC(EmitterContext context)
|
||||
{
|
||||
InstIcmpC op = context.GetOp<InstIcmpC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitIcmp(context, op.IComp, srcA, srcB, srcC, op.Dest, op.Signed);
|
||||
}
|
||||
|
||||
public static void IcmpRc(EmitterContext context)
|
||||
{
|
||||
InstIcmpRc op = context.GetOp<InstIcmpRc>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcC);
|
||||
Operand srcC = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitIcmp(context, op.IComp, srcA, srcB, srcC, op.Dest, op.Signed);
|
||||
}
|
||||
|
||||
public static void IsetR(EmitterContext context)
|
||||
{
|
||||
InstIsetR op = context.GetOp<InstIsetR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitIset(context, op.IComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.BVal, op.Signed, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IsetI(EmitterContext context)
|
||||
{
|
||||
InstIsetI op = context.GetOp<InstIsetI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitIset(context, op.IComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.BVal, op.Signed, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IsetC(EmitterContext context)
|
||||
{
|
||||
InstIsetC op = context.GetOp<InstIsetC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitIset(context, op.IComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.Dest, op.BVal, op.Signed, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void IsetpR(EmitterContext context)
|
||||
{
|
||||
InstIsetpR op = context.GetOp<InstIsetpR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitIsetp(context, op.IComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.DestPred, op.DestPredInv, op.Signed, op.X);
|
||||
}
|
||||
|
||||
public static void IsetpI(EmitterContext context)
|
||||
{
|
||||
InstIsetpI op = context.GetOp<InstIsetpI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitIsetp(context, op.IComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.DestPred, op.DestPredInv, op.Signed, op.X);
|
||||
}
|
||||
|
||||
public static void IsetpC(EmitterContext context)
|
||||
{
|
||||
InstIsetpC op = context.GetOp<InstIsetpC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitIsetp(context, op.IComp, op.Bop, srcA, srcB, op.SrcPred, op.SrcPredInv, op.DestPred, op.DestPredInv, op.Signed, op.X);
|
||||
}
|
||||
|
||||
private static void EmitIcmp(
|
||||
EmitterContext context,
|
||||
IComp cmpOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
bool isSigned)
|
||||
{
|
||||
Operand cmpRes = GetIntComparison(context, cmpOp, srcC, Const(0), isSigned);
|
||||
|
||||
Operand res = context.ConditionalSelect(cmpRes, srcA, srcB);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitIset(
|
||||
EmitterContext context,
|
||||
IComp cmpOp,
|
||||
BoolOp logicOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int srcPred,
|
||||
bool srcPredInv,
|
||||
int rd,
|
||||
bool boolFloat,
|
||||
bool isSigned,
|
||||
bool extended,
|
||||
bool writeCC)
|
||||
{
|
||||
Operand res = GetIntComparison(context, cmpOp, srcA, srcB, isSigned, extended);
|
||||
Operand pred = GetPredicate(context, srcPred, srcPredInv);
|
||||
|
||||
res = GetPredLogicalOp(context, logicOp, res, pred);
|
||||
|
||||
Operand dest = GetDest(rd);
|
||||
|
||||
if (boolFloat)
|
||||
{
|
||||
res = context.ConditionalSelect(res, ConstF(1), Const(0));
|
||||
|
||||
context.Copy(dest, res);
|
||||
|
||||
SetFPZnFlags(context, res, writeCC);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Copy(dest, res);
|
||||
|
||||
SetZnFlags(context, res, writeCC, extended);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitIsetp(
|
||||
EmitterContext context,
|
||||
IComp cmpOp,
|
||||
BoolOp logicOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int srcPred,
|
||||
bool srcPredInv,
|
||||
int destPred,
|
||||
int destPredInv,
|
||||
bool isSigned,
|
||||
bool extended)
|
||||
{
|
||||
Operand p0Res = GetIntComparison(context, cmpOp, srcA, srcB, isSigned, extended);
|
||||
Operand p1Res = context.BitwiseNot(p0Res);
|
||||
Operand pred = GetPredicate(context, srcPred, srcPredInv);
|
||||
|
||||
p0Res = GetPredLogicalOp(context, logicOp, p0Res, pred);
|
||||
p1Res = GetPredLogicalOp(context, logicOp, p1Res, pred);
|
||||
|
||||
context.Copy(Register(destPred, RegisterType.Predicate), p0Res);
|
||||
context.Copy(Register(destPredInv, RegisterType.Predicate), p1Res);
|
||||
}
|
||||
|
||||
private static Operand GetIntComparison(
|
||||
EmitterContext context,
|
||||
IComp cond,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
bool isSigned,
|
||||
bool extended)
|
||||
{
|
||||
return extended
|
||||
? GetIntComparisonExtended(context, cond, srcA, srcB, isSigned)
|
||||
: GetIntComparison(context, cond, srcA, srcB, isSigned);
|
||||
}
|
||||
|
||||
private static Operand GetIntComparisonExtended(EmitterContext context, IComp cond, Operand srcA, Operand srcB, bool isSigned)
|
||||
{
|
||||
Operand res;
|
||||
|
||||
if (cond == IComp.T)
|
||||
{
|
||||
res = Const(IrConsts.True);
|
||||
}
|
||||
else if (cond == IComp.F)
|
||||
{
|
||||
res = Const(IrConsts.False);
|
||||
}
|
||||
else
|
||||
{
|
||||
res = context.ISubtract(srcA, srcB);
|
||||
#pragma warning disable IDE0059 // Remove unnecessary value assignment
|
||||
res = context.IAdd(res, context.BitwiseNot(GetCF()));
|
||||
#pragma warning restore IDE0059
|
||||
|
||||
switch (cond)
|
||||
{
|
||||
case IComp.Eq: // r = xh == yh && xl == yl
|
||||
res = context.BitwiseAnd(context.ICompareEqual(srcA, srcB), GetZF());
|
||||
break;
|
||||
case IComp.Lt: // r = xh < yh || (xh == yh && xl < yl)
|
||||
Operand notC = context.BitwiseNot(GetCF());
|
||||
Operand prevLt = context.BitwiseAnd(context.ICompareEqual(srcA, srcB), notC);
|
||||
res = isSigned
|
||||
? context.BitwiseOr(context.ICompareLess(srcA, srcB), prevLt)
|
||||
: context.BitwiseOr(context.ICompareLessUnsigned(srcA, srcB), prevLt);
|
||||
break;
|
||||
case IComp.Le: // r = xh < yh || (xh == yh && xl <= yl)
|
||||
Operand zOrNotC = context.BitwiseOr(GetZF(), context.BitwiseNot(GetCF()));
|
||||
Operand prevLe = context.BitwiseAnd(context.ICompareEqual(srcA, srcB), zOrNotC);
|
||||
res = isSigned
|
||||
? context.BitwiseOr(context.ICompareLess(srcA, srcB), prevLe)
|
||||
: context.BitwiseOr(context.ICompareLessUnsigned(srcA, srcB), prevLe);
|
||||
break;
|
||||
case IComp.Gt: // r = xh > yh || (xh == yh && xl > yl)
|
||||
Operand notZAndC = context.BitwiseAnd(context.BitwiseNot(GetZF()), GetCF());
|
||||
Operand prevGt = context.BitwiseAnd(context.ICompareEqual(srcA, srcB), notZAndC);
|
||||
res = isSigned
|
||||
? context.BitwiseOr(context.ICompareGreater(srcA, srcB), prevGt)
|
||||
: context.BitwiseOr(context.ICompareGreaterUnsigned(srcA, srcB), prevGt);
|
||||
break;
|
||||
case IComp.Ge: // r = xh > yh || (xh == yh && xl >= yl)
|
||||
Operand prevGe = context.BitwiseAnd(context.ICompareEqual(srcA, srcB), GetCF());
|
||||
res = isSigned
|
||||
? context.BitwiseOr(context.ICompareGreater(srcA, srcB), prevGe)
|
||||
: context.BitwiseOr(context.ICompareGreaterUnsigned(srcA, srcB), prevGe);
|
||||
break;
|
||||
case IComp.Ne: // r = xh != yh || xl != yl
|
||||
res = context.BitwiseOr(context.ICompareNotEqual(srcA, srcB), context.BitwiseNot(GetZF()));
|
||||
break;
|
||||
default:
|
||||
throw new ArgumentException($"Unexpected condition \"{cond}\".");
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
private static Operand GetIntComparison(EmitterContext context, IComp cond, Operand srcA, Operand srcB, bool isSigned)
|
||||
{
|
||||
Operand res;
|
||||
|
||||
if (cond == IComp.T)
|
||||
{
|
||||
res = Const(IrConsts.True);
|
||||
}
|
||||
else if (cond == IComp.F)
|
||||
{
|
||||
res = Const(IrConsts.False);
|
||||
}
|
||||
else
|
||||
{
|
||||
Instruction inst = cond switch
|
||||
{
|
||||
IComp.Lt => Instruction.CompareLessU32,
|
||||
IComp.Eq => Instruction.CompareEqual,
|
||||
IComp.Le => Instruction.CompareLessOrEqualU32,
|
||||
IComp.Gt => Instruction.CompareGreaterU32,
|
||||
IComp.Ne => Instruction.CompareNotEqual,
|
||||
IComp.Ge => Instruction.CompareGreaterOrEqualU32,
|
||||
_ => throw new InvalidOperationException($"Unexpected condition \"{cond}\"."),
|
||||
};
|
||||
|
||||
if (isSigned)
|
||||
{
|
||||
switch (cond)
|
||||
{
|
||||
case IComp.Lt:
|
||||
inst = Instruction.CompareLess;
|
||||
break;
|
||||
case IComp.Le:
|
||||
inst = Instruction.CompareLessOrEqual;
|
||||
break;
|
||||
case IComp.Gt:
|
||||
inst = Instruction.CompareGreater;
|
||||
break;
|
||||
case IComp.Ge:
|
||||
inst = Instruction.CompareGreaterOrEqual;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
res = context.Add(inst, Local(), srcA, srcB);
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
166
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerLogical.cs
vendored
Normal file
166
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerLogical.cs
vendored
Normal file
@@ -0,0 +1,166 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
private const int PT = RegisterConsts.PredicateTrueIndex;
|
||||
|
||||
public static void LopR(EmitterContext context)
|
||||
{
|
||||
InstLopR op = context.GetOp<InstLopR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitLop(context, op.Lop, op.PredicateOp, srcA, srcB, op.Dest, op.DestPred, op.NegA, op.NegB, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void LopI(EmitterContext context)
|
||||
{
|
||||
InstLopI op = context.GetOp<InstLopI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitLop(context, op.LogicOp, op.PredicateOp, srcA, srcB, op.Dest, op.DestPred, op.NegA, op.NegB, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void LopC(EmitterContext context)
|
||||
{
|
||||
InstLopC op = context.GetOp<InstLopC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitLop(context, op.LogicOp, op.PredicateOp, srcA, srcB, op.Dest, op.DestPred, op.NegA, op.NegB, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Lop32i(EmitterContext context)
|
||||
{
|
||||
InstLop32i op = context.GetOp<InstLop32i>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, op.Imm32);
|
||||
|
||||
EmitLop(context, op.LogicOp, PredicateOp.F, srcA, srcB, op.Dest, PT, op.NegA, op.NegB, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Lop3R(EmitterContext context)
|
||||
{
|
||||
InstLop3R op = context.GetOp<InstLop3R>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitLop3(context, op.Imm, op.PredicateOp, srcA, srcB, srcC, op.Dest, op.DestPred, op.X, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Lop3I(EmitterContext context)
|
||||
{
|
||||
InstLop3I op = context.GetOp<InstLop3I>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitLop3(context, op.Imm, PredicateOp.F, srcA, srcB, srcC, op.Dest, PT, false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Lop3C(EmitterContext context)
|
||||
{
|
||||
InstLop3C op = context.GetOp<InstLop3C>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitLop3(context, op.Imm, PredicateOp.F, srcA, srcB, srcC, op.Dest, PT, false, op.WriteCC);
|
||||
}
|
||||
|
||||
private static void EmitLop(
|
||||
EmitterContext context,
|
||||
LogicOp logicOp,
|
||||
PredicateOp predOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
int destPred,
|
||||
bool invertA,
|
||||
bool invertB,
|
||||
bool extended,
|
||||
bool writeCC)
|
||||
{
|
||||
srcA = context.BitwiseNot(srcA, invertA);
|
||||
srcB = context.BitwiseNot(srcB, invertB);
|
||||
|
||||
Operand res = logicOp switch
|
||||
{
|
||||
LogicOp.And => context.BitwiseAnd(srcA, srcB),
|
||||
LogicOp.Or => context.BitwiseOr(srcA, srcB),
|
||||
LogicOp.Xor => context.BitwiseExclusiveOr(srcA, srcB),
|
||||
_ => srcB,
|
||||
};
|
||||
|
||||
EmitLopPredWrite(context, res, predOp, destPred);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
SetZnFlags(context, res, writeCC, extended);
|
||||
}
|
||||
|
||||
private static void EmitLop3(
|
||||
EmitterContext context,
|
||||
int truthTable,
|
||||
PredicateOp predOp,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
int destPred,
|
||||
bool extended,
|
||||
bool writeCC)
|
||||
{
|
||||
Operand res = Lop3Expression.GetFromTruthTable(context, srcA, srcB, srcC, truthTable);
|
||||
|
||||
EmitLopPredWrite(context, res, predOp, destPred);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
SetZnFlags(context, res, writeCC, extended);
|
||||
}
|
||||
|
||||
private static void EmitLopPredWrite(EmitterContext context, Operand result, PredicateOp predOp, int pred)
|
||||
{
|
||||
if (pred != RegisterConsts.PredicateTrueIndex)
|
||||
{
|
||||
Operand pRes;
|
||||
|
||||
if (predOp == PredicateOp.F)
|
||||
{
|
||||
pRes = Const(IrConsts.False);
|
||||
}
|
||||
else if (predOp == PredicateOp.T)
|
||||
{
|
||||
pRes = Const(IrConsts.True);
|
||||
}
|
||||
else if (predOp == PredicateOp.Z)
|
||||
{
|
||||
pRes = context.ICompareEqual(result, Const(0));
|
||||
}
|
||||
else /* if (predOp == Pop.Nz) */
|
||||
{
|
||||
pRes = context.ICompareNotEqual(result, Const(0));
|
||||
}
|
||||
|
||||
context.Copy(Register(pred, RegisterType.Predicate), pRes);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
71
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerMinMax.cs
vendored
Normal file
71
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitIntegerMinMax.cs
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void ImnmxR(EmitterContext context)
|
||||
{
|
||||
InstImnmxR op = context.GetOp<InstImnmxR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitImnmx(context, srcA, srcB, srcPred, op.Dest, op.Signed, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void ImnmxI(EmitterContext context)
|
||||
{
|
||||
InstImnmxI op = context.GetOp<InstImnmxI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitImnmx(context, srcA, srcB, srcPred, op.Dest, op.Signed, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void ImnmxC(EmitterContext context)
|
||||
{
|
||||
InstImnmxC op = context.GetOp<InstImnmxC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitImnmx(context, srcA, srcB, srcPred, op.Dest, op.Signed, op.WriteCC);
|
||||
}
|
||||
|
||||
private static void EmitImnmx(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcPred,
|
||||
int rd,
|
||||
bool isSignedInt,
|
||||
bool writeCC)
|
||||
{
|
||||
Operand resMin = isSignedInt
|
||||
? context.IMinimumS32(srcA, srcB)
|
||||
: context.IMinimumU32(srcA, srcB);
|
||||
|
||||
Operand resMax = isSignedInt
|
||||
? context.IMaximumS32(srcA, srcB)
|
||||
: context.IMaximumU32(srcA, srcB);
|
||||
|
||||
Operand res = context.ConditionalSelect(srcPred, resMin, resMax);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
SetZnFlags(context, res, writeCC);
|
||||
|
||||
// TODO: X flags.
|
||||
}
|
||||
}
|
||||
}
|
||||
604
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMemory.cs
vendored
Normal file
604
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMemory.cs
vendored
Normal file
@@ -0,0 +1,604 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System.Numerics;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Atom(EmitterContext context)
|
||||
{
|
||||
InstAtom op = context.GetOp<InstAtom>();
|
||||
|
||||
int sOffset = (op.Imm20 << 12) >> 12;
|
||||
|
||||
(Operand addrLow, Operand addrHigh) = Get40BitsAddress(context, new Register(op.SrcA, RegisterType.Gpr), op.E, sOffset);
|
||||
|
||||
Operand value = GetSrcReg(context, op.SrcB);
|
||||
|
||||
Operand res = EmitAtomicOp(context, StorageKind.GlobalMemory, op.Op, op.Size, addrLow, addrHigh, value);
|
||||
|
||||
context.Copy(GetDest(op.Dest), res);
|
||||
}
|
||||
|
||||
public static void Atoms(EmitterContext context)
|
||||
{
|
||||
if (context.TranslatorContext.Definitions.Stage != ShaderStage.Compute)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Atoms instruction is not valid on \"{context.TranslatorContext.Definitions.Stage}\" stage.");
|
||||
return;
|
||||
}
|
||||
|
||||
InstAtoms op = context.GetOp<InstAtoms>();
|
||||
|
||||
Operand offset = context.ShiftRightU32(GetSrcReg(context, op.SrcA), Const(2));
|
||||
|
||||
int sOffset = (op.Imm22 << 10) >> 10;
|
||||
|
||||
offset = context.IAdd(offset, Const(sOffset));
|
||||
|
||||
Operand value = GetSrcReg(context, op.SrcB);
|
||||
|
||||
AtomSize size = op.AtomsSize switch
|
||||
{
|
||||
AtomsSize.S32 => AtomSize.S32,
|
||||
AtomsSize.U64 => AtomSize.U64,
|
||||
AtomsSize.S64 => AtomSize.S64,
|
||||
_ => AtomSize.U32,
|
||||
};
|
||||
|
||||
Operand id = Const(context.ResourceManager.SharedMemoryId);
|
||||
Operand res = EmitAtomicOp(context, StorageKind.SharedMemory, op.AtomOp, size, id, offset, value);
|
||||
|
||||
context.Copy(GetDest(op.Dest), res);
|
||||
}
|
||||
|
||||
public static void Ldc(EmitterContext context)
|
||||
{
|
||||
InstLdc op = context.GetOp<InstLdc>();
|
||||
|
||||
if (op.LsSize > LsSize2.B64)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid LDC size: {op.LsSize}.");
|
||||
return;
|
||||
}
|
||||
|
||||
bool isSmallInt = op.LsSize < LsSize2.B32;
|
||||
|
||||
int count = op.LsSize == LsSize2.B64 ? 2 : 1;
|
||||
|
||||
Operand slot = Const(op.CbufSlot);
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
|
||||
if (op.AddressMode is AddressMode.Is or AddressMode.Isl)
|
||||
{
|
||||
slot = context.IAdd(slot, context.BitfieldExtractU32(srcA, Const(16), Const(16)));
|
||||
srcA = context.BitwiseAnd(srcA, Const(0xffff));
|
||||
}
|
||||
|
||||
Operand addr = context.IAdd(srcA, Const(Imm16ToSInt(op.CbufOffset)));
|
||||
Operand wordOffset = context.ShiftRightU32(addr, Const(2));
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
Register dest = new(op.Dest + index, RegisterType.Gpr);
|
||||
|
||||
if (dest.IsRZ)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
Operand offset = context.IAdd(wordOffset, Const(index));
|
||||
Operand value = EmitLoadConstant(context, slot, offset);
|
||||
|
||||
if (isSmallInt)
|
||||
{
|
||||
value = ExtractSmallInt(context, (LsSize)op.LsSize, GetBitOffset(context, addr), value);
|
||||
}
|
||||
|
||||
context.Copy(Register(dest), value);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Ldg(EmitterContext context)
|
||||
{
|
||||
InstLdg op = context.GetOp<InstLdg>();
|
||||
|
||||
EmitLdg(context, op.LsSize, op.SrcA, op.Dest, Imm24ToSInt(op.Imm24), op.E);
|
||||
}
|
||||
|
||||
public static void Ldl(EmitterContext context)
|
||||
{
|
||||
InstLdl op = context.GetOp<InstLdl>();
|
||||
|
||||
EmitLoad(context, StorageKind.LocalMemory, op.LsSize, GetSrcReg(context, op.SrcA), op.Dest, Imm24ToSInt(op.Imm24));
|
||||
}
|
||||
|
||||
public static void Lds(EmitterContext context)
|
||||
{
|
||||
if (context.TranslatorContext.Definitions.Stage != ShaderStage.Compute)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Lds instruction is not valid on \"{context.TranslatorContext.Definitions.Stage}\" stage.");
|
||||
return;
|
||||
}
|
||||
|
||||
InstLds op = context.GetOp<InstLds>();
|
||||
|
||||
EmitLoad(context, StorageKind.SharedMemory, op.LsSize, GetSrcReg(context, op.SrcA), op.Dest, Imm24ToSInt(op.Imm24));
|
||||
}
|
||||
|
||||
public static void Red(EmitterContext context)
|
||||
{
|
||||
InstRed op = context.GetOp<InstRed>();
|
||||
|
||||
(Operand addrLow, Operand addrHigh) = Get40BitsAddress(context, new Register(op.SrcA, RegisterType.Gpr), op.E, op.Imm20);
|
||||
|
||||
EmitAtomicOp(context, StorageKind.GlobalMemory, (AtomOp)op.RedOp, op.RedSize, addrLow, addrHigh, GetDest(op.SrcB));
|
||||
}
|
||||
|
||||
public static void Stg(EmitterContext context)
|
||||
{
|
||||
InstStg op = context.GetOp<InstStg>();
|
||||
|
||||
EmitStg(context, op.LsSize, op.SrcA, op.Dest, Imm24ToSInt(op.Imm24), op.E);
|
||||
}
|
||||
|
||||
public static void Stl(EmitterContext context)
|
||||
{
|
||||
InstStl op = context.GetOp<InstStl>();
|
||||
|
||||
EmitStore(context, StorageKind.LocalMemory, op.LsSize, GetSrcReg(context, op.SrcA), op.Dest, Imm24ToSInt(op.Imm24));
|
||||
}
|
||||
|
||||
public static void Sts(EmitterContext context)
|
||||
{
|
||||
if (context.TranslatorContext.Definitions.Stage != ShaderStage.Compute)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Sts instruction is not valid on \"{context.TranslatorContext.Definitions.Stage}\" stage.");
|
||||
return;
|
||||
}
|
||||
|
||||
InstSts op = context.GetOp<InstSts>();
|
||||
|
||||
EmitStore(context, StorageKind.SharedMemory, op.LsSize, GetSrcReg(context, op.SrcA), op.Dest, Imm24ToSInt(op.Imm24));
|
||||
}
|
||||
|
||||
private static Operand EmitLoadConstant(EmitterContext context, Operand slot, Operand offset)
|
||||
{
|
||||
Operand vecIndex = context.ShiftRightU32(offset, Const(2));
|
||||
Operand elemIndex = context.BitwiseAnd(offset, Const(3));
|
||||
|
||||
if (slot.Type == OperandType.Constant)
|
||||
{
|
||||
int binding = context.ResourceManager.GetConstantBufferBinding(slot.Value);
|
||||
return context.Load(StorageKind.ConstantBuffer, binding, Const(0), vecIndex, elemIndex);
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand value = Const(0);
|
||||
|
||||
uint cbUseMask = context.TranslatorContext.GpuAccessor.QueryConstantBufferUse();
|
||||
|
||||
while (cbUseMask != 0)
|
||||
{
|
||||
int cbIndex = BitOperations.TrailingZeroCount(cbUseMask);
|
||||
int binding = context.ResourceManager.GetConstantBufferBinding(cbIndex);
|
||||
|
||||
Operand isCurrent = context.ICompareEqual(slot, Const(cbIndex));
|
||||
Operand currentValue = context.Load(StorageKind.ConstantBuffer, binding, Const(0), vecIndex, elemIndex);
|
||||
|
||||
value = context.ConditionalSelect(isCurrent, currentValue, value);
|
||||
|
||||
cbUseMask &= ~(1u << cbIndex);
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
private static Operand EmitAtomicOp(
|
||||
EmitterContext context,
|
||||
StorageKind storageKind,
|
||||
AtomOp op,
|
||||
AtomSize type,
|
||||
Operand e0,
|
||||
Operand e1,
|
||||
Operand value)
|
||||
{
|
||||
Operand res = Const(0);
|
||||
|
||||
switch (op)
|
||||
{
|
||||
case AtomOp.Add:
|
||||
if (type is AtomSize.S32 or AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicAdd(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
case AtomOp.Min:
|
||||
if (type == AtomSize.S32)
|
||||
{
|
||||
res = context.AtomicMinS32(storageKind, e0, e1, value);
|
||||
}
|
||||
else if (type == AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicMinU32(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
case AtomOp.Max:
|
||||
if (type == AtomSize.S32)
|
||||
{
|
||||
res = context.AtomicMaxS32(storageKind, e0, e1, value);
|
||||
}
|
||||
else if (type == AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicMaxU32(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
case AtomOp.And:
|
||||
if (type is AtomSize.S32 or AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicAnd(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
case AtomOp.Or:
|
||||
if (type is AtomSize.S32 or AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicOr(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
case AtomOp.Xor:
|
||||
if (type is AtomSize.S32 or AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicXor(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
case AtomOp.Exch:
|
||||
if (type is AtomSize.S32 or AtomSize.U32)
|
||||
{
|
||||
res = context.AtomicSwap(storageKind, e0, e1, value);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid reduction type: {type}.");
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid atomic operation: {op}.");
|
||||
break;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
private static void EmitLoad(
|
||||
EmitterContext context,
|
||||
StorageKind storageKind,
|
||||
LsSize2 size,
|
||||
Operand srcA,
|
||||
int rd,
|
||||
int offset)
|
||||
{
|
||||
if (size > LsSize2.B128)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid load size: {size}.");
|
||||
return;
|
||||
}
|
||||
|
||||
int id = storageKind == StorageKind.LocalMemory
|
||||
? context.ResourceManager.LocalMemoryId
|
||||
: context.ResourceManager.SharedMemoryId;
|
||||
bool isSmallInt = size < LsSize2.B32;
|
||||
|
||||
int count = size switch
|
||||
{
|
||||
LsSize2.B64 => 2,
|
||||
LsSize2.B128 => 4,
|
||||
_ => 1,
|
||||
};
|
||||
|
||||
Operand baseOffset = context.Copy(srcA);
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
Register dest = new(rd + index, RegisterType.Gpr);
|
||||
|
||||
if (dest.IsRZ)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
Operand byteOffset = context.IAdd(baseOffset, Const(offset + index * 4));
|
||||
Operand wordOffset = context.ShiftRightU32(byteOffset, Const(2)); // Word offset = byte offset / 4 (one word = 4 bytes).
|
||||
Operand bitOffset = GetBitOffset(context, byteOffset);
|
||||
Operand value = context.Load(storageKind, id, wordOffset);
|
||||
|
||||
if (isSmallInt)
|
||||
{
|
||||
value = ExtractSmallInt(context, (LsSize)size, bitOffset, value);
|
||||
}
|
||||
|
||||
context.Copy(Register(dest), value);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitLdg(
|
||||
EmitterContext context,
|
||||
LsSize size,
|
||||
int ra,
|
||||
int rd,
|
||||
int offset,
|
||||
bool extended)
|
||||
{
|
||||
int count = GetVectorCount(size);
|
||||
StorageKind storageKind = GetStorageKind(size);
|
||||
|
||||
(_, Operand addrHigh) = Get40BitsAddress(context, new Register(ra, RegisterType.Gpr), extended, offset);
|
||||
|
||||
Operand srcA = context.Copy(new Operand(new Register(ra, RegisterType.Gpr)));
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
Register dest = new(rd + index, RegisterType.Gpr);
|
||||
|
||||
if (dest.IsRZ)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
Operand value = context.Load(storageKind, context.IAdd(srcA, Const(offset + index * 4)), addrHigh);
|
||||
|
||||
context.Copy(Register(dest), value);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitStore(
|
||||
EmitterContext context,
|
||||
StorageKind storageKind,
|
||||
LsSize2 size,
|
||||
Operand srcA,
|
||||
int rd,
|
||||
int offset)
|
||||
{
|
||||
if (size > LsSize2.B128)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid store size: {size}.");
|
||||
return;
|
||||
}
|
||||
|
||||
int id = storageKind == StorageKind.LocalMemory
|
||||
? context.ResourceManager.LocalMemoryId
|
||||
: context.ResourceManager.SharedMemoryId;
|
||||
bool isSmallInt = size < LsSize2.B32;
|
||||
|
||||
int count = size switch
|
||||
{
|
||||
LsSize2.B64 => 2,
|
||||
LsSize2.B128 => 4,
|
||||
_ => 1,
|
||||
};
|
||||
|
||||
Operand baseOffset = context.Copy(srcA);
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
bool isRz = rd + index >= RegisterConsts.RegisterZeroIndex;
|
||||
|
||||
Operand value = Register(isRz ? rd : rd + index, RegisterType.Gpr);
|
||||
Operand byteOffset = context.IAdd(baseOffset, Const(offset + index * 4));
|
||||
Operand wordOffset = context.ShiftRightU32(byteOffset, Const(2));
|
||||
Operand bitOffset = GetBitOffset(context, byteOffset);
|
||||
|
||||
if (isSmallInt && storageKind == StorageKind.LocalMemory)
|
||||
{
|
||||
Operand word = context.Load(storageKind, id, wordOffset);
|
||||
|
||||
value = InsertSmallInt(context, (LsSize)size, bitOffset, word, value);
|
||||
}
|
||||
|
||||
if (storageKind == StorageKind.LocalMemory)
|
||||
{
|
||||
context.Store(storageKind, id, wordOffset, value);
|
||||
}
|
||||
else if (storageKind == StorageKind.SharedMemory)
|
||||
{
|
||||
switch (size)
|
||||
{
|
||||
case LsSize2.U8:
|
||||
case LsSize2.S8:
|
||||
context.Store(StorageKind.SharedMemory8, id, byteOffset, value);
|
||||
break;
|
||||
case LsSize2.U16:
|
||||
case LsSize2.S16:
|
||||
context.Store(StorageKind.SharedMemory16, id, byteOffset, value);
|
||||
break;
|
||||
default:
|
||||
context.Store(storageKind, id, wordOffset, value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitStg(
|
||||
EmitterContext context,
|
||||
LsSize2 size,
|
||||
int ra,
|
||||
int rd,
|
||||
int offset,
|
||||
bool extended)
|
||||
{
|
||||
if (size > LsSize2.B128)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid store size: {size}.");
|
||||
return;
|
||||
}
|
||||
|
||||
int count = GetVectorCount((LsSize)size);
|
||||
StorageKind storageKind = GetStorageKind((LsSize)size);
|
||||
|
||||
(_, Operand addrHigh) = Get40BitsAddress(context, new Register(ra, RegisterType.Gpr), extended, offset);
|
||||
|
||||
Operand srcA = context.Copy(new Operand(new Register(ra, RegisterType.Gpr)));
|
||||
|
||||
for (int index = 0; index < count; index++)
|
||||
{
|
||||
bool isRz = rd + index >= RegisterConsts.RegisterZeroIndex;
|
||||
|
||||
Operand value = Register(isRz ? rd : rd + index, RegisterType.Gpr);
|
||||
|
||||
Operand addrLowOffset = context.IAdd(srcA, Const(offset + index * 4));
|
||||
|
||||
context.Store(storageKind, addrLowOffset, addrHigh, value);
|
||||
}
|
||||
}
|
||||
|
||||
private static StorageKind GetStorageKind(LsSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
LsSize.U8 => StorageKind.GlobalMemoryU8,
|
||||
LsSize.S8 => StorageKind.GlobalMemoryS8,
|
||||
LsSize.U16 => StorageKind.GlobalMemoryU16,
|
||||
LsSize.S16 => StorageKind.GlobalMemoryS16,
|
||||
_ => StorageKind.GlobalMemory,
|
||||
};
|
||||
}
|
||||
|
||||
private static int GetVectorCount(LsSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
LsSize.B64 => 2,
|
||||
LsSize.B128 or LsSize.UB128 => 4,
|
||||
_ => 1,
|
||||
};
|
||||
}
|
||||
|
||||
private static (Operand, Operand) Get40BitsAddress(
|
||||
EmitterContext context,
|
||||
Register ra,
|
||||
bool extended,
|
||||
int offset)
|
||||
{
|
||||
Operand addrLow = Register(ra);
|
||||
Operand addrHigh;
|
||||
|
||||
if (extended && !ra.IsRZ)
|
||||
{
|
||||
addrHigh = Register(ra.Index + 1, RegisterType.Gpr);
|
||||
}
|
||||
else
|
||||
{
|
||||
addrHigh = Const(0);
|
||||
}
|
||||
|
||||
Operand offs = Const(offset);
|
||||
|
||||
addrLow = context.IAdd(addrLow, offs);
|
||||
|
||||
if (extended)
|
||||
{
|
||||
Operand carry = context.ICompareLessUnsigned(addrLow, offs);
|
||||
|
||||
addrHigh = context.IAdd(addrHigh, context.ConditionalSelect(carry, Const(1), Const(0)));
|
||||
}
|
||||
|
||||
return (addrLow, addrHigh);
|
||||
}
|
||||
|
||||
private static Operand GetBitOffset(EmitterContext context, Operand baseOffset)
|
||||
{
|
||||
// Note: bit offset = (baseOffset & 0b11) * 8.
|
||||
// Addresses should be always aligned to the integer type,
|
||||
// so we don't need to take unaligned addresses into account.
|
||||
return context.ShiftLeft(context.BitwiseAnd(baseOffset, Const(3)), Const(3));
|
||||
}
|
||||
|
||||
private static Operand ExtractSmallInt(
|
||||
EmitterContext context,
|
||||
LsSize size,
|
||||
Operand bitOffset,
|
||||
Operand value)
|
||||
{
|
||||
value = context.ShiftRightU32(value, bitOffset);
|
||||
|
||||
switch (size)
|
||||
{
|
||||
case LsSize.U8:
|
||||
value = ZeroExtendTo32(context, value, 8);
|
||||
break;
|
||||
case LsSize.U16:
|
||||
value = ZeroExtendTo32(context, value, 16);
|
||||
break;
|
||||
case LsSize.S8:
|
||||
value = SignExtendTo32(context, value, 8);
|
||||
break;
|
||||
case LsSize.S16:
|
||||
value = SignExtendTo32(context, value, 16);
|
||||
break;
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
private static Operand InsertSmallInt(
|
||||
EmitterContext context,
|
||||
LsSize size,
|
||||
Operand bitOffset,
|
||||
Operand word,
|
||||
Operand value)
|
||||
{
|
||||
switch (size)
|
||||
{
|
||||
case LsSize.U8:
|
||||
case LsSize.S8:
|
||||
value = context.BitwiseAnd(value, Const(0xff));
|
||||
value = context.BitfieldInsert(word, value, bitOffset, Const(8));
|
||||
break;
|
||||
|
||||
case LsSize.U16:
|
||||
case LsSize.S16:
|
||||
value = context.BitwiseAnd(value, Const(0xffff));
|
||||
value = context.BitfieldInsert(word, value, bitOffset, Const(16));
|
||||
break;
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
278
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMove.cs
vendored
Normal file
278
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMove.cs
vendored
Normal file
@@ -0,0 +1,278 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void MovR(EmitterContext context)
|
||||
{
|
||||
InstMovR op = context.GetOp<InstMovR>();
|
||||
|
||||
context.Copy(GetDest(op.Dest), GetSrcReg(context, op.SrcA));
|
||||
}
|
||||
|
||||
public static void MovI(EmitterContext context)
|
||||
{
|
||||
InstMovI op = context.GetOp<InstMovI>();
|
||||
|
||||
context.Copy(GetDest(op.Dest), GetSrcImm(context, op.Imm20));
|
||||
}
|
||||
|
||||
public static void MovC(EmitterContext context)
|
||||
{
|
||||
InstMovC op = context.GetOp<InstMovC>();
|
||||
|
||||
context.Copy(GetDest(op.Dest), GetSrcCbuf(context, op.CbufSlot, op.CbufOffset));
|
||||
}
|
||||
|
||||
public static void Mov32i(EmitterContext context)
|
||||
{
|
||||
InstMov32i op = context.GetOp<InstMov32i>();
|
||||
|
||||
context.Copy(GetDest(op.Dest), GetSrcImm(context, op.Imm32));
|
||||
}
|
||||
|
||||
public static void R2pR(EmitterContext context)
|
||||
{
|
||||
InstR2pR op = context.GetOp<InstR2pR>();
|
||||
|
||||
Operand value = GetSrcReg(context, op.SrcA);
|
||||
Operand mask = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitR2p(context, value, mask, op.ByteSel, op.Ccpr);
|
||||
}
|
||||
|
||||
public static void R2pI(EmitterContext context)
|
||||
{
|
||||
InstR2pI op = context.GetOp<InstR2pI>();
|
||||
|
||||
Operand value = GetSrcReg(context, op.SrcA);
|
||||
Operand mask = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitR2p(context, value, mask, op.ByteSel, op.Ccpr);
|
||||
}
|
||||
|
||||
public static void R2pC(EmitterContext context)
|
||||
{
|
||||
InstR2pC op = context.GetOp<InstR2pC>();
|
||||
|
||||
Operand value = GetSrcReg(context, op.SrcA);
|
||||
Operand mask = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitR2p(context, value, mask, op.ByteSel, op.Ccpr);
|
||||
}
|
||||
|
||||
public static void S2r(EmitterContext context)
|
||||
{
|
||||
InstS2r op = context.GetOp<InstS2r>();
|
||||
|
||||
Operand src;
|
||||
|
||||
switch (op.SReg)
|
||||
{
|
||||
case SReg.LaneId:
|
||||
src = EmitLoadSubgroupLaneId(context);
|
||||
break;
|
||||
|
||||
case SReg.InvocationId:
|
||||
src = context.Load(StorageKind.Input, IoVariable.InvocationId);
|
||||
break;
|
||||
|
||||
case SReg.YDirection:
|
||||
src = ConstF(1); // TODO: Use value from Y direction GPU register.
|
||||
break;
|
||||
|
||||
case SReg.ThreadKill:
|
||||
src = context.TranslatorContext.Definitions.Stage == ShaderStage.Fragment ? context.Load(StorageKind.Input, IoVariable.ThreadKill) : Const(0);
|
||||
break;
|
||||
|
||||
case SReg.InvocationInfo:
|
||||
if (context.TranslatorContext.Definitions.Stage is not ShaderStage.Compute and not ShaderStage.Fragment)
|
||||
{
|
||||
// Note: Lowest 8-bits seems to contain some primitive index,
|
||||
// but it seems to be NVIDIA implementation specific as it's only used
|
||||
// to calculate ISBE offsets, so we can just keep it as zero.
|
||||
|
||||
if (context.TranslatorContext.Definitions.Stage is ShaderStage.TessellationControl or
|
||||
ShaderStage.TessellationEvaluation)
|
||||
{
|
||||
src = context.ShiftLeft(context.Load(StorageKind.Input, IoVariable.PatchVertices), Const(16));
|
||||
}
|
||||
else
|
||||
{
|
||||
src = Const(context.TranslatorContext.Definitions.InputTopology.InputVertexCount << 16);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
src = Const(0);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case SReg.TId:
|
||||
Operand tidX = context.Load(StorageKind.Input, IoVariable.ThreadId, null, Const(0));
|
||||
Operand tidY = context.Load(StorageKind.Input, IoVariable.ThreadId, null, Const(1));
|
||||
Operand tidZ = context.Load(StorageKind.Input, IoVariable.ThreadId, null, Const(2));
|
||||
|
||||
tidY = context.ShiftLeft(tidY, Const(16));
|
||||
tidZ = context.ShiftLeft(tidZ, Const(26));
|
||||
|
||||
src = context.BitwiseOr(tidX, context.BitwiseOr(tidY, tidZ));
|
||||
break;
|
||||
|
||||
case SReg.TIdX:
|
||||
src = context.Load(StorageKind.Input, IoVariable.ThreadId, null, Const(0));
|
||||
break;
|
||||
case SReg.TIdY:
|
||||
src = context.Load(StorageKind.Input, IoVariable.ThreadId, null, Const(1));
|
||||
break;
|
||||
case SReg.TIdZ:
|
||||
src = context.Load(StorageKind.Input, IoVariable.ThreadId, null, Const(2));
|
||||
break;
|
||||
|
||||
case SReg.CtaIdX:
|
||||
src = context.Load(StorageKind.Input, IoVariable.CtaId, null, Const(0));
|
||||
break;
|
||||
case SReg.CtaIdY:
|
||||
src = context.Load(StorageKind.Input, IoVariable.CtaId, null, Const(1));
|
||||
break;
|
||||
case SReg.CtaIdZ:
|
||||
src = context.Load(StorageKind.Input, IoVariable.CtaId, null, Const(2));
|
||||
break;
|
||||
|
||||
case SReg.EqMask:
|
||||
src = EmitLoadSubgroupMask(context, IoVariable.SubgroupEqMask);
|
||||
break;
|
||||
case SReg.LtMask:
|
||||
src = EmitLoadSubgroupMask(context, IoVariable.SubgroupLtMask);
|
||||
break;
|
||||
case SReg.LeMask:
|
||||
src = EmitLoadSubgroupMask(context, IoVariable.SubgroupLeMask);
|
||||
break;
|
||||
case SReg.GtMask:
|
||||
src = EmitLoadSubgroupMask(context, IoVariable.SubgroupGtMask);
|
||||
break;
|
||||
case SReg.GeMask:
|
||||
src = EmitLoadSubgroupMask(context, IoVariable.SubgroupGeMask);
|
||||
break;
|
||||
|
||||
default:
|
||||
src = Const(0);
|
||||
break;
|
||||
}
|
||||
|
||||
context.Copy(GetDest(op.Dest), src);
|
||||
}
|
||||
|
||||
private static Operand EmitLoadSubgroupLaneId(EmitterContext context)
|
||||
{
|
||||
if (context.TranslatorContext.GpuAccessor.QueryHostSubgroupSize() <= 32)
|
||||
{
|
||||
return context.Load(StorageKind.Input, IoVariable.SubgroupLaneId);
|
||||
}
|
||||
|
||||
return context.BitwiseAnd(context.Load(StorageKind.Input, IoVariable.SubgroupLaneId), Const(0x1f));
|
||||
}
|
||||
|
||||
private static Operand EmitLoadSubgroupMask(EmitterContext context, IoVariable ioVariable)
|
||||
{
|
||||
int subgroupSize = context.TranslatorContext.GpuAccessor.QueryHostSubgroupSize();
|
||||
|
||||
if (subgroupSize <= 32)
|
||||
{
|
||||
return context.Load(StorageKind.Input, ioVariable, null, Const(0));
|
||||
}
|
||||
else if (subgroupSize == 64)
|
||||
{
|
||||
Operand laneId = context.Load(StorageKind.Input, IoVariable.SubgroupLaneId);
|
||||
Operand low = context.Load(StorageKind.Input, ioVariable, null, Const(0));
|
||||
Operand high = context.Load(StorageKind.Input, ioVariable, null, Const(1));
|
||||
|
||||
return context.ConditionalSelect(context.BitwiseAnd(laneId, Const(32)), high, low);
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand laneId = context.Load(StorageKind.Input, IoVariable.SubgroupLaneId);
|
||||
Operand element = context.ShiftRightU32(laneId, Const(5));
|
||||
|
||||
Operand res = context.Load(StorageKind.Input, ioVariable, null, Const(0));
|
||||
res = context.ConditionalSelect(
|
||||
context.ICompareEqual(element, Const(1)),
|
||||
context.Load(StorageKind.Input, ioVariable, null, Const(1)), res);
|
||||
res = context.ConditionalSelect(
|
||||
context.ICompareEqual(element, Const(2)),
|
||||
context.Load(StorageKind.Input, ioVariable, null, Const(2)), res);
|
||||
res = context.ConditionalSelect(
|
||||
context.ICompareEqual(element, Const(3)),
|
||||
context.Load(StorageKind.Input, ioVariable, null, Const(3)), res);
|
||||
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
public static void SelR(EmitterContext context)
|
||||
{
|
||||
InstSelR op = context.GetOp<InstSelR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitSel(context, srcA, srcB, srcPred, op.Dest);
|
||||
}
|
||||
|
||||
public static void SelI(EmitterContext context)
|
||||
{
|
||||
InstSelI op = context.GetOp<InstSelI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitSel(context, srcA, srcB, srcPred, op.Dest);
|
||||
}
|
||||
|
||||
public static void SelC(EmitterContext context)
|
||||
{
|
||||
InstSelC op = context.GetOp<InstSelC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
EmitSel(context, srcA, srcB, srcPred, op.Dest);
|
||||
}
|
||||
|
||||
private static void EmitR2p(EmitterContext context, Operand value, Operand mask, ByteSel byteSel, bool ccpr)
|
||||
{
|
||||
Operand Test(Operand value, int bit)
|
||||
{
|
||||
return context.ICompareNotEqual(context.BitwiseAnd(value, Const(1 << bit)), Const(0));
|
||||
}
|
||||
|
||||
int count = ccpr ? RegisterConsts.FlagsCount : RegisterConsts.PredsCount;
|
||||
RegisterType type = ccpr ? RegisterType.Flag : RegisterType.Predicate;
|
||||
int shift = (int)byteSel * 8;
|
||||
|
||||
for (int bit = 0; bit < count; bit++)
|
||||
{
|
||||
Operand flag = Register(bit, type);
|
||||
Operand res = context.ConditionalSelect(Test(mask, bit), Test(value, bit + shift), flag);
|
||||
context.Copy(flag, res);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitSel(EmitterContext context, Operand srcA, Operand srcB, Operand srcPred, int rd)
|
||||
{
|
||||
Operand res = context.ConditionalSelect(srcPred, srcA, srcB);
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
}
|
||||
}
|
||||
97
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMultifunction.cs
vendored
Normal file
97
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitMultifunction.cs
vendored
Normal file
@@ -0,0 +1,97 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void RroR(EmitterContext context)
|
||||
{
|
||||
InstRroR op = context.GetOp<InstRroR>();
|
||||
|
||||
EmitRro(context, GetSrcReg(context, op.SrcB), op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void RroI(EmitterContext context)
|
||||
{
|
||||
InstRroI op = context.GetOp<InstRroI>();
|
||||
|
||||
EmitRro(context, GetSrcImm(context, Imm20ToFloat(op.Imm20)), op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void RroC(EmitterContext context)
|
||||
{
|
||||
InstRroC op = context.GetOp<InstRroC>();
|
||||
|
||||
EmitRro(context, GetSrcCbuf(context, op.CbufSlot, op.CbufOffset), op.Dest, op.AbsB, op.NegB);
|
||||
}
|
||||
|
||||
public static void Mufu(EmitterContext context)
|
||||
{
|
||||
InstMufu op = context.GetOp<InstMufu>();
|
||||
|
||||
Operand res = context.FPAbsNeg(GetSrcReg(context, op.SrcA), op.AbsA, op.NegA);
|
||||
|
||||
switch (op.MufuOp)
|
||||
{
|
||||
case MufuOp.Cos:
|
||||
res = context.FPCosine(res);
|
||||
break;
|
||||
|
||||
case MufuOp.Sin:
|
||||
res = context.FPSine(res);
|
||||
break;
|
||||
|
||||
case MufuOp.Ex2:
|
||||
res = context.FPExponentB2(res);
|
||||
break;
|
||||
|
||||
case MufuOp.Lg2:
|
||||
res = context.FPLogarithmB2(res);
|
||||
break;
|
||||
|
||||
case MufuOp.Rcp:
|
||||
res = context.FPReciprocal(res);
|
||||
break;
|
||||
|
||||
case MufuOp.Rsq:
|
||||
res = context.FPReciprocalSquareRoot(res);
|
||||
break;
|
||||
|
||||
case MufuOp.Rcp64h:
|
||||
res = context.PackDouble2x32(OperandHelper.Const(0), res);
|
||||
res = context.UnpackDouble2x32High(context.FPReciprocal(res, Instruction.FP64));
|
||||
break;
|
||||
|
||||
case MufuOp.Rsq64h:
|
||||
res = context.PackDouble2x32(OperandHelper.Const(0), res);
|
||||
res = context.UnpackDouble2x32High(context.FPReciprocalSquareRoot(res, Instruction.FP64));
|
||||
break;
|
||||
|
||||
case MufuOp.Sqrt:
|
||||
res = context.FPSquareRoot(res);
|
||||
break;
|
||||
|
||||
default:
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid MUFU operation \"{op.MufuOp}\".");
|
||||
break;
|
||||
}
|
||||
|
||||
context.Copy(GetDest(op.Dest), context.FPSaturate(res, op.Sat));
|
||||
}
|
||||
|
||||
private static void EmitRro(EmitterContext context, Operand srcB, int rd, bool absB, bool negB)
|
||||
{
|
||||
// This is the range reduction operator,
|
||||
// we translate it as a simple move, as it
|
||||
// should be always followed by a matching
|
||||
// MUFU instruction.
|
||||
srcB = context.FPAbsNeg(srcB, absB, negB);
|
||||
|
||||
context.Copy(GetDest(rd), srcB);
|
||||
}
|
||||
}
|
||||
}
|
||||
15
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitNop.cs
vendored
Normal file
15
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitNop.cs
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Nop(EmitterContext context)
|
||||
{
|
||||
context.GetOp<InstNop>();
|
||||
|
||||
// No operation.
|
||||
}
|
||||
}
|
||||
}
|
||||
116
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitPredicate.cs
vendored
Normal file
116
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitPredicate.cs
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Pset(EmitterContext context)
|
||||
{
|
||||
InstPset op = context.GetOp<InstPset>();
|
||||
|
||||
Operand srcA = context.BitwiseNot(Register(op.Src2Pred, RegisterType.Predicate), op.Src2PredInv);
|
||||
Operand srcB = context.BitwiseNot(Register(op.Src1Pred, RegisterType.Predicate), op.Src1PredInv);
|
||||
Operand srcC = context.BitwiseNot(Register(op.SrcPred, RegisterType.Predicate), op.SrcPredInv);
|
||||
|
||||
Operand res = GetPredLogicalOp(context, op.BoolOpAB, srcA, srcB);
|
||||
res = GetPredLogicalOp(context, op.BoolOpC, res, srcC);
|
||||
|
||||
Operand dest = GetDest(op.Dest);
|
||||
|
||||
if (op.BVal)
|
||||
{
|
||||
context.Copy(dest, context.ConditionalSelect(res, ConstF(1), ConstF(0)));
|
||||
}
|
||||
else
|
||||
{
|
||||
context.Copy(dest, res);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Psetp(EmitterContext context)
|
||||
{
|
||||
InstPsetp op = context.GetOp<InstPsetp>();
|
||||
|
||||
Operand srcA = context.BitwiseNot(Register(op.Src2Pred, RegisterType.Predicate), op.Src2PredInv);
|
||||
Operand srcB = context.BitwiseNot(Register(op.Src1Pred, RegisterType.Predicate), op.Src1PredInv);
|
||||
|
||||
Operand p0Res = GetPredLogicalOp(context, op.BoolOpAB, srcA, srcB);
|
||||
Operand p1Res = context.BitwiseNot(p0Res);
|
||||
Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
p0Res = GetPredLogicalOp(context, op.BoolOpC, p0Res, srcPred);
|
||||
p1Res = GetPredLogicalOp(context, op.BoolOpC, p1Res, srcPred);
|
||||
|
||||
context.Copy(Register(op.DestPred, RegisterType.Predicate), p0Res);
|
||||
context.Copy(Register(op.DestPredInv, RegisterType.Predicate), p1Res);
|
||||
}
|
||||
|
||||
public static void P2rC(EmitterContext context)
|
||||
{
|
||||
InstP2rC op = context.GetOp<InstP2rC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand dest = GetSrcReg(context, op.Dest);
|
||||
Operand mask = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitP2r(context, srcA, dest, mask, op.ByteSel, op.Ccpr);
|
||||
}
|
||||
|
||||
public static void P2rI(EmitterContext context)
|
||||
{
|
||||
InstP2rI op = context.GetOp<InstP2rI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand dest = GetSrcReg(context, op.Dest);
|
||||
Operand mask = GetSrcImm(context, op.Imm20);
|
||||
|
||||
EmitP2r(context, srcA, dest, mask, op.ByteSel, op.Ccpr);
|
||||
}
|
||||
|
||||
public static void P2rR(EmitterContext context)
|
||||
{
|
||||
InstP2rR op = context.GetOp<InstP2rR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand dest = GetSrcReg(context, op.Dest);
|
||||
Operand mask = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitP2r(context, srcA, dest, mask, op.ByteSel, op.Ccpr);
|
||||
}
|
||||
|
||||
private static void EmitP2r(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand dest,
|
||||
Operand mask,
|
||||
ByteSel byteSel,
|
||||
bool ccpr)
|
||||
{
|
||||
int count = ccpr ? RegisterConsts.FlagsCount : RegisterConsts.PredsCount;
|
||||
int shift = (int)byteSel * 8;
|
||||
mask = context.BitwiseAnd(mask, Const(0xff));
|
||||
|
||||
Operand insert = Const(0);
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Operand condition = ccpr
|
||||
? Register(i, RegisterType.Flag)
|
||||
: Register(i, RegisterType.Predicate);
|
||||
|
||||
Operand bit = context.ConditionalSelect(condition, Const(1 << (i + shift)), Const(0));
|
||||
insert = context.BitwiseOr(insert, bit);
|
||||
}
|
||||
|
||||
Operand maskShifted = context.ShiftLeft(mask, Const(shift));
|
||||
Operand masked = context.BitwiseAnd(srcA, context.BitwiseNot(maskShifted));
|
||||
Operand res = context.BitwiseOr(masked, context.BitwiseAnd(insert, maskShifted));
|
||||
|
||||
context.Copy(dest, res);
|
||||
}
|
||||
}
|
||||
}
|
||||
249
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitShift.cs
vendored
Normal file
249
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitShift.cs
vendored
Normal file
@@ -0,0 +1,249 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void ShfLR(EmitterContext context)
|
||||
{
|
||||
InstShfLR op = context.GetOp<InstShfLR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitShf(context, op.MaxShift, srcA, srcB, srcC, op.Dest, op.M, left: true, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void ShfRR(EmitterContext context)
|
||||
{
|
||||
InstShfRR op = context.GetOp<InstShfRR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitShf(context, op.MaxShift, srcA, srcB, srcC, op.Dest, op.M, left: false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void ShfLI(EmitterContext context)
|
||||
{
|
||||
InstShfLI op = context.GetOp<InstShfLI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = Const(op.Imm6);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitShf(context, op.MaxShift, srcA, srcB, srcC, op.Dest, op.M, left: true, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void ShfRI(EmitterContext context)
|
||||
{
|
||||
InstShfRI op = context.GetOp<InstShfRI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = Const(op.Imm6);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
|
||||
EmitShf(context, op.MaxShift, srcA, srcB, srcC, op.Dest, op.M, left: false, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void ShlR(EmitterContext context)
|
||||
{
|
||||
InstShlR op = context.GetOp<InstShlR>();
|
||||
|
||||
EmitShl(context, GetSrcReg(context, op.SrcA), GetSrcReg(context, op.SrcB), op.Dest, op.M);
|
||||
}
|
||||
|
||||
public static void ShlI(EmitterContext context)
|
||||
{
|
||||
InstShlI op = context.GetOp<InstShlI>();
|
||||
|
||||
EmitShl(context, GetSrcReg(context, op.SrcA), GetSrcImm(context, Imm20ToSInt(op.Imm20)), op.Dest, op.M);
|
||||
}
|
||||
|
||||
public static void ShlC(EmitterContext context)
|
||||
{
|
||||
InstShlC op = context.GetOp<InstShlC>();
|
||||
|
||||
EmitShl(context, GetSrcReg(context, op.SrcA), GetSrcCbuf(context, op.CbufSlot, op.CbufOffset), op.Dest, op.M);
|
||||
}
|
||||
|
||||
public static void ShrR(EmitterContext context)
|
||||
{
|
||||
InstShrR op = context.GetOp<InstShrR>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
|
||||
EmitShr(context, srcA, srcB, op.Dest, op.M, op.Brev, op.Signed);
|
||||
}
|
||||
|
||||
public static void ShrI(EmitterContext context)
|
||||
{
|
||||
InstShrI op = context.GetOp<InstShrI>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
|
||||
|
||||
EmitShr(context, srcA, srcB, op.Dest, op.M, op.Brev, op.Signed);
|
||||
}
|
||||
|
||||
public static void ShrC(EmitterContext context)
|
||||
{
|
||||
InstShrC op = context.GetOp<InstShrC>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
|
||||
|
||||
EmitShr(context, srcA, srcB, op.Dest, op.M, op.Brev, op.Signed);
|
||||
}
|
||||
|
||||
private static void EmitShf(
|
||||
EmitterContext context,
|
||||
MaxShift maxShift,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
Operand srcC,
|
||||
int rd,
|
||||
bool mask,
|
||||
bool left,
|
||||
bool writeCC)
|
||||
{
|
||||
bool isLongShift = maxShift is MaxShift.U64 or MaxShift.S64;
|
||||
bool signedShift = maxShift == MaxShift.S64;
|
||||
int maxShiftConst = isLongShift ? 64 : 32;
|
||||
|
||||
if (mask)
|
||||
{
|
||||
srcB = context.BitwiseAnd(srcB, Const(maxShiftConst - 1));
|
||||
}
|
||||
|
||||
Operand res;
|
||||
|
||||
if (left)
|
||||
{
|
||||
// res = (C << B) | (A >> (32 - B))
|
||||
res = context.ShiftLeft(srcC, srcB);
|
||||
res = context.BitwiseOr(res, context.ShiftRightU32(srcA, context.ISubtract(Const(32), srcB)));
|
||||
|
||||
if (isLongShift)
|
||||
{
|
||||
// res = B >= 32 ? A << (B - 32) : res
|
||||
Operand lowerShift = context.ShiftLeft(srcA, context.ISubtract(srcB, Const(32)));
|
||||
|
||||
Operand shiftGreaterThan31 = context.ICompareGreaterOrEqualUnsigned(srcB, Const(32));
|
||||
res = context.ConditionalSelect(shiftGreaterThan31, lowerShift, res);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// res = (A >> B) | (C << (32 - B))
|
||||
res = context.ShiftRightU32(srcA, srcB);
|
||||
res = context.BitwiseOr(res, context.ShiftLeft(srcC, context.ISubtract(Const(32), srcB)));
|
||||
|
||||
if (isLongShift)
|
||||
{
|
||||
// res = B >= 32 ? C >> (B - 32) : res
|
||||
Operand upperShift = signedShift
|
||||
? context.ShiftRightS32(srcC, context.ISubtract(srcB, Const(32)))
|
||||
: context.ShiftRightU32(srcC, context.ISubtract(srcB, Const(32)));
|
||||
|
||||
Operand shiftGreaterThan31 = context.ICompareGreaterOrEqualUnsigned(srcB, Const(32));
|
||||
res = context.ConditionalSelect(shiftGreaterThan31, upperShift, res);
|
||||
}
|
||||
}
|
||||
|
||||
if (!mask)
|
||||
{
|
||||
// Clamped shift value.
|
||||
Operand isLessThanMax = context.ICompareLessUnsigned(srcB, Const(maxShiftConst));
|
||||
|
||||
res = context.ConditionalSelect(isLessThanMax, res, Const(0));
|
||||
}
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
|
||||
if (writeCC)
|
||||
{
|
||||
InstEmitAluHelper.SetZnFlags(context, res, writeCC);
|
||||
}
|
||||
|
||||
// TODO: X.
|
||||
}
|
||||
|
||||
private static void EmitShl(EmitterContext context, Operand srcA, Operand srcB, int rd, bool mask)
|
||||
{
|
||||
if (mask)
|
||||
{
|
||||
srcB = context.BitwiseAnd(srcB, Const(0x1f));
|
||||
}
|
||||
|
||||
Operand res = context.ShiftLeft(srcA, srcB);
|
||||
|
||||
if (!mask)
|
||||
{
|
||||
// Clamped shift value.
|
||||
Operand isLessThan32 = context.ICompareLessUnsigned(srcB, Const(32));
|
||||
|
||||
res = context.ConditionalSelect(isLessThan32, res, Const(0));
|
||||
}
|
||||
|
||||
// TODO: X, CC.
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
|
||||
private static void EmitShr(
|
||||
EmitterContext context,
|
||||
Operand srcA,
|
||||
Operand srcB,
|
||||
int rd,
|
||||
bool mask,
|
||||
bool bitReverse,
|
||||
bool isSigned)
|
||||
{
|
||||
if (bitReverse)
|
||||
{
|
||||
srcA = context.BitfieldReverse(srcA);
|
||||
}
|
||||
|
||||
if (mask)
|
||||
{
|
||||
srcB = context.BitwiseAnd(srcB, Const(0x1f));
|
||||
}
|
||||
|
||||
Operand res = isSigned
|
||||
? context.ShiftRightS32(srcA, srcB)
|
||||
: context.ShiftRightU32(srcA, srcB);
|
||||
|
||||
if (!mask)
|
||||
{
|
||||
// Clamped shift value.
|
||||
Operand resShiftBy32;
|
||||
|
||||
if (isSigned)
|
||||
{
|
||||
resShiftBy32 = context.ShiftRightS32(srcA, Const(31));
|
||||
}
|
||||
else
|
||||
{
|
||||
resShiftBy32 = Const(0);
|
||||
}
|
||||
|
||||
Operand isLessThan32 = context.ICompareLessUnsigned(srcB, Const(32));
|
||||
|
||||
res = context.ConditionalSelect(isLessThan32, res, resShiftBy32);
|
||||
}
|
||||
|
||||
// TODO: X, CC.
|
||||
|
||||
context.Copy(GetDest(rd), res);
|
||||
}
|
||||
}
|
||||
}
|
||||
799
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitSurface.cs
vendored
Normal file
799
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitSurface.cs
vendored
Normal file
@@ -0,0 +1,799 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.StructuredIr;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void SuatomB(EmitterContext context)
|
||||
{
|
||||
InstSuatomB op = context.GetOp<InstSuatomB>();
|
||||
|
||||
EmitSuatom(
|
||||
context,
|
||||
op.Dim,
|
||||
op.Op,
|
||||
op.Size,
|
||||
0,
|
||||
op.SrcA,
|
||||
op.SrcB,
|
||||
op.SrcC,
|
||||
op.Dest,
|
||||
op.Ba,
|
||||
isBindless: true,
|
||||
compareAndSwap: false);
|
||||
}
|
||||
|
||||
public static void Suatom(EmitterContext context)
|
||||
{
|
||||
InstSuatom op = context.GetOp<InstSuatom>();
|
||||
|
||||
EmitSuatom(
|
||||
context,
|
||||
op.Dim,
|
||||
op.Op,
|
||||
op.Size,
|
||||
op.TidB,
|
||||
op.SrcA,
|
||||
op.SrcB,
|
||||
0,
|
||||
op.Dest,
|
||||
op.Ba,
|
||||
isBindless: false,
|
||||
compareAndSwap: false);
|
||||
}
|
||||
|
||||
public static void SuatomB2(EmitterContext context)
|
||||
{
|
||||
InstSuatomB2 op = context.GetOp<InstSuatomB2>();
|
||||
|
||||
EmitSuatom(
|
||||
context,
|
||||
op.Dim,
|
||||
op.Op,
|
||||
op.Size,
|
||||
0,
|
||||
op.SrcA,
|
||||
op.SrcB,
|
||||
op.SrcC,
|
||||
op.Dest,
|
||||
op.Ba,
|
||||
isBindless: true,
|
||||
compareAndSwap: false);
|
||||
}
|
||||
|
||||
public static void SuatomCasB(EmitterContext context)
|
||||
{
|
||||
InstSuatomCasB op = context.GetOp<InstSuatomCasB>();
|
||||
|
||||
EmitSuatom(
|
||||
context,
|
||||
op.Dim,
|
||||
0,
|
||||
op.Size,
|
||||
0,
|
||||
op.SrcA,
|
||||
op.SrcB,
|
||||
op.SrcC,
|
||||
op.Dest,
|
||||
op.Ba,
|
||||
isBindless: true,
|
||||
compareAndSwap: true);
|
||||
}
|
||||
|
||||
public static void SuatomCas(EmitterContext context)
|
||||
{
|
||||
InstSuatomCas op = context.GetOp<InstSuatomCas>();
|
||||
|
||||
EmitSuatom(
|
||||
context,
|
||||
op.Dim,
|
||||
0,
|
||||
op.Size,
|
||||
op.TidB,
|
||||
op.SrcA,
|
||||
op.SrcB,
|
||||
0,
|
||||
op.Dest,
|
||||
op.Ba,
|
||||
isBindless: false,
|
||||
compareAndSwap: true);
|
||||
}
|
||||
|
||||
public static void SuldDB(EmitterContext context)
|
||||
{
|
||||
InstSuldDB op = context.GetOp<InstSuldDB>();
|
||||
|
||||
EmitSuld(context, op.CacheOp, op.Dim, op.Size, 0, 0, op.SrcA, op.Dest, op.SrcC, useComponents: false, op.Ba, isBindless: true);
|
||||
}
|
||||
|
||||
public static void SuldD(EmitterContext context)
|
||||
{
|
||||
InstSuldD op = context.GetOp<InstSuldD>();
|
||||
|
||||
EmitSuld(context, op.CacheOp, op.Dim, op.Size, op.TidB, 0, op.SrcA, op.Dest, 0, useComponents: false, op.Ba, isBindless: false);
|
||||
}
|
||||
|
||||
public static void SuldB(EmitterContext context)
|
||||
{
|
||||
InstSuldB op = context.GetOp<InstSuldB>();
|
||||
|
||||
EmitSuld(context, op.CacheOp, op.Dim, 0, 0, op.Rgba, op.SrcA, op.Dest, op.SrcC, useComponents: true, false, isBindless: true);
|
||||
}
|
||||
|
||||
public static void Suld(EmitterContext context)
|
||||
{
|
||||
InstSuld op = context.GetOp<InstSuld>();
|
||||
|
||||
EmitSuld(context, op.CacheOp, op.Dim, 0, op.TidB, op.Rgba, op.SrcA, op.Dest, 0, useComponents: true, false, isBindless: false);
|
||||
}
|
||||
|
||||
public static void SuredB(EmitterContext context)
|
||||
{
|
||||
InstSuredB op = context.GetOp<InstSuredB>();
|
||||
|
||||
EmitSured(context, op.Dim, op.Op, op.Size, 0, op.SrcA, op.Dest, op.SrcC, op.Ba, isBindless: true);
|
||||
}
|
||||
|
||||
public static void Sured(EmitterContext context)
|
||||
{
|
||||
InstSured op = context.GetOp<InstSured>();
|
||||
|
||||
EmitSured(context, op.Dim, op.Op, op.Size, op.TidB, op.SrcA, op.Dest, 0, op.Ba, isBindless: false);
|
||||
}
|
||||
|
||||
public static void SustDB(EmitterContext context)
|
||||
{
|
||||
InstSustDB op = context.GetOp<InstSustDB>();
|
||||
|
||||
EmitSust(context, op.CacheOp, op.Dim, op.Size, 0, 0, op.SrcA, op.Dest, op.SrcC, useComponents: false, op.Ba, isBindless: true);
|
||||
}
|
||||
|
||||
public static void SustD(EmitterContext context)
|
||||
{
|
||||
InstSustD op = context.GetOp<InstSustD>();
|
||||
|
||||
EmitSust(context, op.CacheOp, op.Dim, op.Size, op.TidB, 0, op.SrcA, op.Dest, 0, useComponents: false, op.Ba, isBindless: false);
|
||||
}
|
||||
|
||||
public static void SustB(EmitterContext context)
|
||||
{
|
||||
InstSustB op = context.GetOp<InstSustB>();
|
||||
|
||||
EmitSust(context, op.CacheOp, op.Dim, 0, 0, op.Rgba, op.SrcA, op.Dest, op.SrcC, useComponents: true, false, isBindless: true);
|
||||
}
|
||||
|
||||
public static void Sust(EmitterContext context)
|
||||
{
|
||||
InstSust op = context.GetOp<InstSust>();
|
||||
|
||||
EmitSust(context, op.CacheOp, op.Dim, 0, op.TidB, op.Rgba, op.SrcA, op.Dest, 0, useComponents: true, false, isBindless: false);
|
||||
}
|
||||
|
||||
private static void EmitSuatom(
|
||||
EmitterContext context,
|
||||
SuDim dimensions,
|
||||
SuatomOp atomicOp,
|
||||
SuatomSize size,
|
||||
int imm,
|
||||
int srcA,
|
||||
int srcB,
|
||||
int srcC,
|
||||
int dest,
|
||||
bool byteAddress,
|
||||
bool isBindless,
|
||||
bool compareAndSwap)
|
||||
{
|
||||
SamplerType type = ConvertSamplerType(dimensions);
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid image atomic sampler type.");
|
||||
return;
|
||||
}
|
||||
|
||||
Operand Ra()
|
||||
{
|
||||
if (srcA > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcA++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
Operand Rb()
|
||||
{
|
||||
if (srcB > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcB++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
Operand d = Register(dest, RegisterType.Gpr);
|
||||
|
||||
List<Operand> sourcesList = [];
|
||||
|
||||
if (isBindless)
|
||||
{
|
||||
sourcesList.Add(context.Copy(GetSrcReg(context, srcC)));
|
||||
}
|
||||
|
||||
int coordsCount = type.Dimensions;
|
||||
|
||||
for (int index = 0; index < coordsCount; index++)
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
}
|
||||
|
||||
if (Sample1DAs2D && (type & SamplerType.Mask) == SamplerType.Texture1D)
|
||||
{
|
||||
sourcesList.Add(Const(0));
|
||||
|
||||
type &= ~SamplerType.Mask;
|
||||
type |= SamplerType.Texture2D;
|
||||
}
|
||||
|
||||
if (type.HasFlag(SamplerType.Array))
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
|
||||
type |= SamplerType.Array;
|
||||
}
|
||||
|
||||
if (byteAddress)
|
||||
{
|
||||
int xIndex = isBindless ? 1 : 0;
|
||||
|
||||
sourcesList[xIndex] = context.ShiftRightS32(sourcesList[xIndex], Const(GetComponentSizeInBytesLog2(size)));
|
||||
}
|
||||
|
||||
// TODO: FP and 64-bit formats.
|
||||
TextureFormat format = size is SuatomSize.Sd32 or SuatomSize.Sd64
|
||||
? (isBindless ? TextureFormat.Unknown : ShaderProperties.GetTextureFormatAtomic(context.TranslatorContext.GpuAccessor, imm))
|
||||
: GetTextureFormat(size);
|
||||
|
||||
if (compareAndSwap)
|
||||
{
|
||||
sourcesList.Add(Rb());
|
||||
}
|
||||
|
||||
sourcesList.Add(Rb());
|
||||
|
||||
Operand[] sources = sourcesList.ToArray();
|
||||
|
||||
TextureFlags flags = compareAndSwap ? TextureFlags.CAS : GetAtomicOpFlags(atomicOp);
|
||||
|
||||
if (isBindless)
|
||||
{
|
||||
flags |= TextureFlags.Bindless;
|
||||
}
|
||||
|
||||
SetBindingPair setAndBinding = isBindless ? default : context.ResourceManager.GetTextureOrImageBinding(
|
||||
Instruction.ImageAtomic,
|
||||
type,
|
||||
format,
|
||||
flags,
|
||||
TextureOperation.DefaultCbufSlot,
|
||||
imm);
|
||||
|
||||
Operand res = context.ImageAtomic(type, format, flags, setAndBinding, sources);
|
||||
|
||||
context.Copy(d, res);
|
||||
}
|
||||
|
||||
private static void EmitSuld(
|
||||
EmitterContext context,
|
||||
CacheOpLd cacheOp,
|
||||
SuDim dimensions,
|
||||
SuSize size,
|
||||
int imm,
|
||||
SuRgba componentMask,
|
||||
int srcA,
|
||||
int srcB,
|
||||
int srcC,
|
||||
bool useComponents,
|
||||
bool byteAddress,
|
||||
bool isBindless)
|
||||
{
|
||||
if (srcB == RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
SamplerType type = ConvertSamplerType(dimensions);
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid image store sampler type.");
|
||||
return;
|
||||
}
|
||||
|
||||
Operand Ra()
|
||||
{
|
||||
if (srcA > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcA++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
List<Operand> sourcesList = [];
|
||||
|
||||
if (isBindless)
|
||||
{
|
||||
sourcesList.Add(context.Copy(Register(srcC, RegisterType.Gpr)));
|
||||
}
|
||||
|
||||
int coordsCount = type.Dimensions;
|
||||
|
||||
for (int index = 0; index < coordsCount; index++)
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
}
|
||||
|
||||
if (Sample1DAs2D && (type & SamplerType.Mask) == SamplerType.Texture1D)
|
||||
{
|
||||
sourcesList.Add(Const(0));
|
||||
|
||||
type &= ~SamplerType.Mask;
|
||||
type |= SamplerType.Texture2D;
|
||||
}
|
||||
|
||||
if (type.HasFlag(SamplerType.Array))
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
}
|
||||
|
||||
Operand[] sources = sourcesList.ToArray();
|
||||
|
||||
int handle = imm;
|
||||
|
||||
TextureFlags flags = isBindless ? TextureFlags.Bindless : TextureFlags.None;
|
||||
|
||||
if (cacheOp == CacheOpLd.Cg)
|
||||
{
|
||||
flags |= TextureFlags.Coherent;
|
||||
}
|
||||
|
||||
if (useComponents)
|
||||
{
|
||||
Operand[] dests = new Operand[BitOperations.PopCount((uint)componentMask)];
|
||||
|
||||
int outputIndex = 0;
|
||||
|
||||
for (int i = 0; i < dests.Length; i++)
|
||||
{
|
||||
if (srcB + i >= RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
dests[outputIndex++] = Register(srcB + i, RegisterType.Gpr);
|
||||
}
|
||||
|
||||
if (outputIndex != dests.Length)
|
||||
{
|
||||
Array.Resize(ref dests, outputIndex);
|
||||
}
|
||||
|
||||
TextureFormat format = isBindless ? TextureFormat.Unknown : ShaderProperties.GetTextureFormat(context.TranslatorContext.GpuAccessor, handle);
|
||||
|
||||
SetBindingPair setAndBinding = isBindless ? default : context.ResourceManager.GetTextureOrImageBinding(
|
||||
Instruction.ImageLoad,
|
||||
type,
|
||||
format,
|
||||
flags,
|
||||
TextureOperation.DefaultCbufSlot,
|
||||
handle);
|
||||
|
||||
context.ImageLoad(type, format, flags, setAndBinding, (int)componentMask, dests, sources);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (byteAddress)
|
||||
{
|
||||
int xIndex = isBindless ? 1 : 0;
|
||||
|
||||
sources[xIndex] = context.ShiftRightS32(sources[xIndex], Const(GetComponentSizeInBytesLog2(size)));
|
||||
}
|
||||
|
||||
int components = GetComponents(size);
|
||||
int compMask = (1 << components) - 1;
|
||||
|
||||
Operand[] dests = new Operand[components];
|
||||
|
||||
int outputIndex = 0;
|
||||
|
||||
for (int i = 0; i < dests.Length; i++)
|
||||
{
|
||||
if (srcB + i >= RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
dests[outputIndex++] = Register(srcB + i, RegisterType.Gpr);
|
||||
}
|
||||
|
||||
if (outputIndex != dests.Length)
|
||||
{
|
||||
Array.Resize(ref dests, outputIndex);
|
||||
}
|
||||
|
||||
TextureFormat format = GetTextureFormat(size);
|
||||
|
||||
SetBindingPair setAndBinding = isBindless ? default : context.ResourceManager.GetTextureOrImageBinding(
|
||||
Instruction.ImageLoad,
|
||||
type,
|
||||
format,
|
||||
flags,
|
||||
TextureOperation.DefaultCbufSlot,
|
||||
handle);
|
||||
|
||||
context.ImageLoad(type, format, flags, setAndBinding, compMask, dests, sources);
|
||||
|
||||
switch (size)
|
||||
{
|
||||
case SuSize.U8:
|
||||
context.Copy(dests[0], ZeroExtendTo32(context, dests[0], 8));
|
||||
break;
|
||||
case SuSize.U16:
|
||||
context.Copy(dests[0], ZeroExtendTo32(context, dests[0], 16));
|
||||
break;
|
||||
case SuSize.S8:
|
||||
context.Copy(dests[0], SignExtendTo32(context, dests[0], 8));
|
||||
break;
|
||||
case SuSize.S16:
|
||||
context.Copy(dests[0], SignExtendTo32(context, dests[0], 16));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitSured(
|
||||
EmitterContext context,
|
||||
SuDim dimensions,
|
||||
RedOp atomicOp,
|
||||
SuatomSize size,
|
||||
int imm,
|
||||
int srcA,
|
||||
int srcB,
|
||||
int srcC,
|
||||
bool byteAddress,
|
||||
bool isBindless)
|
||||
{
|
||||
SamplerType type = ConvertSamplerType(dimensions);
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid image reduction sampler type.");
|
||||
return;
|
||||
}
|
||||
|
||||
Operand Ra()
|
||||
{
|
||||
if (srcA > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcA++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
Operand Rb()
|
||||
{
|
||||
if (srcB > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcB++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
List<Operand> sourcesList = [];
|
||||
|
||||
if (isBindless)
|
||||
{
|
||||
sourcesList.Add(context.Copy(GetSrcReg(context, srcC)));
|
||||
}
|
||||
|
||||
int coordsCount = type.Dimensions;
|
||||
|
||||
for (int index = 0; index < coordsCount; index++)
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
}
|
||||
|
||||
if (Sample1DAs2D && (type & SamplerType.Mask) == SamplerType.Texture1D)
|
||||
{
|
||||
sourcesList.Add(Const(0));
|
||||
|
||||
type &= ~SamplerType.Mask;
|
||||
type |= SamplerType.Texture2D;
|
||||
}
|
||||
|
||||
if (type.HasFlag(SamplerType.Array))
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
|
||||
type |= SamplerType.Array;
|
||||
}
|
||||
|
||||
if (byteAddress)
|
||||
{
|
||||
int xIndex = isBindless ? 1 : 0;
|
||||
|
||||
sourcesList[xIndex] = context.ShiftRightS32(sourcesList[xIndex], Const(GetComponentSizeInBytesLog2(size)));
|
||||
}
|
||||
|
||||
// TODO: FP and 64-bit formats.
|
||||
TextureFormat format = size is SuatomSize.Sd32 or SuatomSize.Sd64
|
||||
? (isBindless ? TextureFormat.Unknown : ShaderProperties.GetTextureFormatAtomic(context.TranslatorContext.GpuAccessor, imm))
|
||||
: GetTextureFormat(size);
|
||||
|
||||
sourcesList.Add(Rb());
|
||||
|
||||
Operand[] sources = sourcesList.ToArray();
|
||||
|
||||
TextureFlags flags = GetAtomicOpFlags((SuatomOp)atomicOp);
|
||||
|
||||
if (isBindless)
|
||||
{
|
||||
flags |= TextureFlags.Bindless;
|
||||
}
|
||||
|
||||
SetBindingPair setAndBinding = isBindless ? default : context.ResourceManager.GetTextureOrImageBinding(
|
||||
Instruction.ImageAtomic,
|
||||
type,
|
||||
format,
|
||||
flags,
|
||||
TextureOperation.DefaultCbufSlot,
|
||||
imm);
|
||||
|
||||
context.ImageAtomic(type, format, flags, setAndBinding, sources);
|
||||
}
|
||||
|
||||
private static void EmitSust(
|
||||
EmitterContext context,
|
||||
CacheOpSt cacheOp,
|
||||
SuDim dimensions,
|
||||
SuSize size,
|
||||
int imm,
|
||||
SuRgba componentMask,
|
||||
int srcA,
|
||||
int srcB,
|
||||
int srcC,
|
||||
bool useComponents,
|
||||
bool byteAddress,
|
||||
bool isBindless)
|
||||
{
|
||||
SamplerType type = ConvertSamplerType(dimensions);
|
||||
|
||||
if (type == SamplerType.None)
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log("Invalid image store sampler type.");
|
||||
return;
|
||||
}
|
||||
|
||||
Operand Ra()
|
||||
{
|
||||
if (srcA > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcA++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
Operand Rb()
|
||||
{
|
||||
if (srcB > RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
|
||||
return context.Copy(Register(srcB++, RegisterType.Gpr));
|
||||
}
|
||||
|
||||
List<Operand> sourcesList = [];
|
||||
|
||||
if (isBindless)
|
||||
{
|
||||
sourcesList.Add(context.Copy(Register(srcC, RegisterType.Gpr)));
|
||||
}
|
||||
|
||||
int coordsCount = type.Dimensions;
|
||||
|
||||
for (int index = 0; index < coordsCount; index++)
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
}
|
||||
|
||||
if (Sample1DAs2D && (type & SamplerType.Mask) == SamplerType.Texture1D)
|
||||
{
|
||||
sourcesList.Add(Const(0));
|
||||
|
||||
type &= ~SamplerType.Mask;
|
||||
type |= SamplerType.Texture2D;
|
||||
}
|
||||
|
||||
if (type.HasFlag(SamplerType.Array))
|
||||
{
|
||||
sourcesList.Add(Ra());
|
||||
}
|
||||
|
||||
TextureFormat format = TextureFormat.Unknown;
|
||||
|
||||
if (useComponents)
|
||||
{
|
||||
for (int compMask = (int)componentMask, compIndex = 0; compMask != 0; compMask >>= 1, compIndex++)
|
||||
{
|
||||
if ((compMask & 1) != 0)
|
||||
{
|
||||
sourcesList.Add(Rb());
|
||||
}
|
||||
}
|
||||
|
||||
if (!isBindless)
|
||||
{
|
||||
format = ShaderProperties.GetTextureFormat(context.TranslatorContext.GpuAccessor, imm);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (byteAddress)
|
||||
{
|
||||
int xIndex = isBindless ? 1 : 0;
|
||||
|
||||
sourcesList[xIndex] = context.ShiftRightS32(sourcesList[xIndex], Const(GetComponentSizeInBytesLog2(size)));
|
||||
}
|
||||
|
||||
int components = GetComponents(size);
|
||||
|
||||
for (int compIndex = 0; compIndex < components; compIndex++)
|
||||
{
|
||||
sourcesList.Add(Rb());
|
||||
}
|
||||
|
||||
format = GetTextureFormat(size);
|
||||
}
|
||||
|
||||
Operand[] sources = sourcesList.ToArray();
|
||||
|
||||
int handle = imm;
|
||||
|
||||
TextureFlags flags = isBindless ? TextureFlags.Bindless : TextureFlags.None;
|
||||
|
||||
if (cacheOp == CacheOpSt.Cg)
|
||||
{
|
||||
flags |= TextureFlags.Coherent;
|
||||
}
|
||||
|
||||
SetBindingPair setAndBinding = isBindless ? default : context.ResourceManager.GetTextureOrImageBinding(
|
||||
Instruction.ImageStore,
|
||||
type,
|
||||
format,
|
||||
flags,
|
||||
TextureOperation.DefaultCbufSlot,
|
||||
handle);
|
||||
|
||||
context.ImageStore(type, format, flags, setAndBinding, sources);
|
||||
}
|
||||
|
||||
private static int GetComponentSizeInBytesLog2(SuatomSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
SuatomSize.U32 => 2,
|
||||
SuatomSize.S32 => 2,
|
||||
SuatomSize.U64 => 3,
|
||||
SuatomSize.F32FtzRn => 2,
|
||||
SuatomSize.F16x2FtzRn => 2,
|
||||
SuatomSize.S64 => 3,
|
||||
SuatomSize.Sd32 => 2,
|
||||
SuatomSize.Sd64 => 3,
|
||||
_ => 2,
|
||||
};
|
||||
}
|
||||
|
||||
private static TextureFormat GetTextureFormat(SuatomSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
SuatomSize.U32 => TextureFormat.R32Uint,
|
||||
SuatomSize.S32 => TextureFormat.R32Sint,
|
||||
SuatomSize.U64 => TextureFormat.R32G32Uint,
|
||||
SuatomSize.F32FtzRn => TextureFormat.R32Float,
|
||||
SuatomSize.F16x2FtzRn => TextureFormat.R16G16Float,
|
||||
SuatomSize.S64 => TextureFormat.R32G32Uint,
|
||||
SuatomSize.Sd32 => TextureFormat.R32Uint,
|
||||
SuatomSize.Sd64 => TextureFormat.R32G32Uint,
|
||||
_ => TextureFormat.R32Uint,
|
||||
};
|
||||
}
|
||||
|
||||
private static TextureFlags GetAtomicOpFlags(SuatomOp op)
|
||||
{
|
||||
return op switch
|
||||
{
|
||||
SuatomOp.Add => TextureFlags.Add,
|
||||
SuatomOp.Min => TextureFlags.Minimum,
|
||||
SuatomOp.Max => TextureFlags.Maximum,
|
||||
SuatomOp.Inc => TextureFlags.Increment,
|
||||
SuatomOp.Dec => TextureFlags.Decrement,
|
||||
SuatomOp.And => TextureFlags.BitwiseAnd,
|
||||
SuatomOp.Or => TextureFlags.BitwiseOr,
|
||||
SuatomOp.Xor => TextureFlags.BitwiseXor,
|
||||
SuatomOp.Exch => TextureFlags.Swap,
|
||||
_ => TextureFlags.Add,
|
||||
};
|
||||
}
|
||||
|
||||
private static int GetComponents(SuSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
SuSize.B64 => 2,
|
||||
SuSize.B128 => 4,
|
||||
SuSize.UB128 => 4,
|
||||
_ => 1,
|
||||
};
|
||||
}
|
||||
|
||||
private static int GetComponentSizeInBytesLog2(SuSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
SuSize.U8 => 0,
|
||||
SuSize.S8 => 0,
|
||||
SuSize.U16 => 1,
|
||||
SuSize.S16 => 1,
|
||||
SuSize.B32 => 2,
|
||||
SuSize.B64 => 3,
|
||||
SuSize.B128 => 4,
|
||||
SuSize.UB128 => 4,
|
||||
_ => 2,
|
||||
};
|
||||
}
|
||||
|
||||
private static TextureFormat GetTextureFormat(SuSize size)
|
||||
{
|
||||
return size switch
|
||||
{
|
||||
SuSize.U8 => TextureFormat.R8Uint,
|
||||
SuSize.S8 => TextureFormat.R8Sint,
|
||||
SuSize.U16 => TextureFormat.R16Uint,
|
||||
SuSize.S16 => TextureFormat.R16Sint,
|
||||
SuSize.B32 => TextureFormat.R32Uint,
|
||||
SuSize.B64 => TextureFormat.R32G32Uint,
|
||||
SuSize.B128 => TextureFormat.R32G32B32A32Uint,
|
||||
SuSize.UB128 => TextureFormat.R32G32B32A32Uint,
|
||||
_ => TextureFormat.R32Uint,
|
||||
};
|
||||
}
|
||||
|
||||
private static SamplerType ConvertSamplerType(SuDim target)
|
||||
{
|
||||
return target switch
|
||||
{
|
||||
SuDim._1d => SamplerType.Texture1D,
|
||||
SuDim._1dBuffer => SamplerType.TextureBuffer,
|
||||
SuDim._1dArray => SamplerType.Texture1D | SamplerType.Array,
|
||||
SuDim._2d => SamplerType.Texture2D,
|
||||
SuDim._2dArray => SamplerType.Texture2D | SamplerType.Array,
|
||||
SuDim._3d => SamplerType.Texture3D,
|
||||
_ => SamplerType.None,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
1336
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitTexture.cs
vendored
Normal file
1336
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitTexture.cs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
117
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitVideoArithmetic.cs
vendored
Normal file
117
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitVideoArithmetic.cs
vendored
Normal file
@@ -0,0 +1,117 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Vmad(EmitterContext context)
|
||||
{
|
||||
InstVmad op = context.GetOp<InstVmad>();
|
||||
|
||||
bool aSigned = (op.ASelect & VectorSelect.S8B0) != 0;
|
||||
bool bSigned = (op.BSelect & VectorSelect.S8B0) != 0;
|
||||
|
||||
Operand srcA = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
|
||||
Operand srcC = context.INegate(GetSrcReg(context, op.SrcC), op.AvgMode == AvgMode.NegB);
|
||||
Operand srcB;
|
||||
|
||||
if (op.BVideo)
|
||||
{
|
||||
srcB = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
|
||||
}
|
||||
else
|
||||
{
|
||||
int imm = op.Imm16;
|
||||
|
||||
if (bSigned)
|
||||
{
|
||||
imm = (imm << 16) >> 16;
|
||||
}
|
||||
|
||||
srcB = Const(imm);
|
||||
}
|
||||
|
||||
Operand productLow = context.IMultiply(srcA, srcB);
|
||||
Operand productHigh;
|
||||
|
||||
if (aSigned == bSigned)
|
||||
{
|
||||
productHigh = aSigned
|
||||
? context.MultiplyHighS32(srcA, srcB)
|
||||
: context.MultiplyHighU32(srcA, srcB);
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand temp = aSigned
|
||||
? context.IMultiply(srcB, context.ShiftRightS32(srcA, Const(31)))
|
||||
: context.IMultiply(srcA, context.ShiftRightS32(srcB, Const(31)));
|
||||
|
||||
productHigh = context.IAdd(temp, context.MultiplyHighU32(srcA, srcB));
|
||||
}
|
||||
|
||||
if (op.AvgMode == AvgMode.NegA)
|
||||
{
|
||||
(productLow, productHigh) = InstEmitAluHelper.NegateLong(context, productLow, productHigh);
|
||||
}
|
||||
|
||||
Operand resLow = InstEmitAluHelper.AddWithCarry(context, productLow, srcC, out Operand sumCarry);
|
||||
Operand resHigh = context.IAdd(productHigh, sumCarry);
|
||||
|
||||
if (op.AvgMode == AvgMode.PlusOne)
|
||||
{
|
||||
resLow = InstEmitAluHelper.AddWithCarry(context, resLow, Const(1), out Operand poCarry);
|
||||
resHigh = context.IAdd(resHigh, poCarry);
|
||||
}
|
||||
|
||||
bool resSigned = op.ASelect == VectorSelect.S32 ||
|
||||
op.BSelect == VectorSelect.S32 ||
|
||||
op.AvgMode == AvgMode.NegB ||
|
||||
op.AvgMode == AvgMode.NegA;
|
||||
|
||||
int shift = op.VideoScale switch
|
||||
{
|
||||
VideoScale.Shr7 => 7,
|
||||
VideoScale.Shr15 => 15,
|
||||
_ => 0,
|
||||
};
|
||||
|
||||
if (shift != 0)
|
||||
{
|
||||
// Low = (Low >> Shift) | (High << (32 - Shift))
|
||||
// High >>= Shift
|
||||
resLow = context.ShiftRightU32(resLow, Const(shift));
|
||||
resLow = context.BitwiseOr(resLow, context.ShiftLeft(resHigh, Const(32 - shift)));
|
||||
resHigh = resSigned
|
||||
? context.ShiftRightS32(resHigh, Const(shift))
|
||||
: context.ShiftRightU32(resHigh, Const(shift));
|
||||
}
|
||||
|
||||
Operand res = resLow;
|
||||
|
||||
if (op.Sat)
|
||||
{
|
||||
Operand sign = context.ShiftRightS32(resHigh, Const(31));
|
||||
|
||||
if (resSigned)
|
||||
{
|
||||
Operand overflow = context.ICompareNotEqual(resHigh, context.ShiftRightS32(resLow, Const(31)));
|
||||
Operand clampValue = context.ConditionalSelect(sign, Const(int.MinValue), Const(int.MaxValue));
|
||||
res = context.ConditionalSelect(overflow, clampValue, resLow);
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand overflow = context.ICompareNotEqual(resHigh, Const(0));
|
||||
res = context.ConditionalSelect(overflow, context.BitwiseNot(sign), resLow);
|
||||
}
|
||||
}
|
||||
|
||||
context.Copy(GetDest(op.Dest), res);
|
||||
|
||||
// TODO: CC.
|
||||
}
|
||||
}
|
||||
}
|
||||
183
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitVideoMinMax.cs
vendored
Normal file
183
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitVideoMinMax.cs
vendored
Normal file
@@ -0,0 +1,183 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Vmnmx(EmitterContext context)
|
||||
{
|
||||
InstVmnmx op = context.GetOp<InstVmnmx>();
|
||||
|
||||
Operand srcA = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
|
||||
Operand srcC = GetSrcReg(context, op.SrcC);
|
||||
Operand srcB;
|
||||
|
||||
if (op.BVideo)
|
||||
{
|
||||
srcB = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
|
||||
}
|
||||
else
|
||||
{
|
||||
int imm = op.Imm16;
|
||||
|
||||
if ((op.BSelect & VectorSelect.S8B0) != 0)
|
||||
{
|
||||
imm = (imm << 16) >> 16;
|
||||
}
|
||||
|
||||
srcB = Const(imm);
|
||||
}
|
||||
|
||||
Operand res;
|
||||
|
||||
bool resSigned;
|
||||
|
||||
if ((op.ASelect & VectorSelect.S8B0) != (op.BSelect & VectorSelect.S8B0))
|
||||
{
|
||||
// Signedness is different, but for max, result will always fit a U32,
|
||||
// since one of the inputs can't be negative, and the result is the one
|
||||
// with highest value. For min, it will always fit on a S32, since
|
||||
// one of the input can't be greater than INT_MAX and we want the lowest value.
|
||||
resSigned = !op.Mn;
|
||||
|
||||
res = op.Mn ? context.IMaximumU32(srcA, srcB) : context.IMinimumS32(srcA, srcB);
|
||||
|
||||
if ((op.ASelect & VectorSelect.S8B0) != 0)
|
||||
{
|
||||
Operand isBGtIntMax = context.ICompareLess(srcB, Const(0));
|
||||
|
||||
res = context.ConditionalSelect(isBGtIntMax, srcB, res);
|
||||
}
|
||||
else
|
||||
{
|
||||
Operand isAGtIntMax = context.ICompareLess(srcA, Const(0));
|
||||
|
||||
res = context.ConditionalSelect(isAGtIntMax, srcA, res);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Ra and Rb have the same signedness, so doesn't matter which one we test.
|
||||
resSigned = (op.ASelect & VectorSelect.S8B0) != 0;
|
||||
|
||||
if (op.Mn)
|
||||
{
|
||||
res = resSigned
|
||||
? context.IMaximumS32(srcA, srcB)
|
||||
: context.IMaximumU32(srcA, srcB);
|
||||
}
|
||||
else
|
||||
{
|
||||
res = resSigned
|
||||
? context.IMinimumS32(srcA, srcB)
|
||||
: context.IMinimumU32(srcA, srcB);
|
||||
}
|
||||
}
|
||||
|
||||
if (op.Sat)
|
||||
{
|
||||
if (op.DFormat && !resSigned)
|
||||
{
|
||||
res = context.IMinimumU32(res, Const(int.MaxValue));
|
||||
}
|
||||
else if (!op.DFormat && resSigned)
|
||||
{
|
||||
res = context.IMaximumS32(res, Const(0));
|
||||
}
|
||||
}
|
||||
|
||||
switch (op.VideoOp)
|
||||
{
|
||||
case VideoOp.Acc:
|
||||
res = context.IAdd(res, srcC);
|
||||
break;
|
||||
case VideoOp.Max:
|
||||
res = op.DFormat ? context.IMaximumS32(res, srcC) : context.IMaximumU32(res, srcC);
|
||||
break;
|
||||
case VideoOp.Min:
|
||||
res = op.DFormat ? context.IMinimumS32(res, srcC) : context.IMinimumU32(res, srcC);
|
||||
break;
|
||||
case VideoOp.Mrg16h:
|
||||
res = context.BitfieldInsert(srcC, res, Const(16), Const(16));
|
||||
break;
|
||||
case VideoOp.Mrg16l:
|
||||
res = context.BitfieldInsert(srcC, res, Const(0), Const(16));
|
||||
break;
|
||||
case VideoOp.Mrg8b0:
|
||||
res = context.BitfieldInsert(srcC, res, Const(0), Const(8));
|
||||
break;
|
||||
case VideoOp.Mrg8b2:
|
||||
res = context.BitfieldInsert(srcC, res, Const(16), Const(8));
|
||||
break;
|
||||
}
|
||||
|
||||
context.Copy(GetDest(op.Dest), res);
|
||||
}
|
||||
|
||||
public static void Vsetp(EmitterContext context)
|
||||
{
|
||||
InstVsetp op = context.GetOp<InstVsetp>();
|
||||
|
||||
Operand srcA = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcA), op.ASelect);
|
||||
Operand srcB;
|
||||
|
||||
if (op.BVideo)
|
||||
{
|
||||
srcB = InstEmitAluHelper.Extend(context, GetSrcReg(context, op.SrcB), op.BSelect);
|
||||
}
|
||||
else
|
||||
{
|
||||
int imm = op.Imm16;
|
||||
|
||||
if ((op.BSelect & VectorSelect.S8B0) != 0)
|
||||
{
|
||||
imm = (imm << 16) >> 16;
|
||||
}
|
||||
|
||||
srcB = Const(imm);
|
||||
}
|
||||
|
||||
Operand p0Res;
|
||||
|
||||
bool signedA = (op.ASelect & VectorSelect.S8B0) != 0;
|
||||
bool signedB = (op.BSelect & VectorSelect.S8B0) != 0;
|
||||
|
||||
if (signedA != signedB)
|
||||
{
|
||||
bool a32 = (op.ASelect & ~VectorSelect.S8B0) == VectorSelect.U32;
|
||||
bool b32 = (op.BSelect & ~VectorSelect.S8B0) == VectorSelect.U32;
|
||||
|
||||
if (!a32 && !b32)
|
||||
{
|
||||
// Both values are extended small integer and can always fit in a S32, just do a signed comparison.
|
||||
p0Res = GetIntComparison(context, op.VComp, srcA, srcB, isSigned: true, extended: false);
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Mismatching sign case.
|
||||
p0Res = Const(0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Sign matches, just do a regular comparison.
|
||||
p0Res = GetIntComparison(context, op.VComp, srcA, srcB, signedA, extended: false);
|
||||
}
|
||||
|
||||
Operand p1Res = context.BitwiseNot(p0Res);
|
||||
|
||||
Operand pred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
|
||||
p0Res = InstEmitAluHelper.GetPredLogicalOp(context, op.BoolOp, p0Res, pred);
|
||||
p1Res = InstEmitAluHelper.GetPredLogicalOp(context, op.BoolOp, p1Res, pred);
|
||||
|
||||
context.Copy(Register(op.DestPred, RegisterType.Predicate), p0Res);
|
||||
context.Copy(Register(op.DestPredInv, RegisterType.Predicate), p1Res);
|
||||
}
|
||||
}
|
||||
}
|
||||
144
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitWarp.cs
vendored
Normal file
144
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitWarp.cs
vendored
Normal file
@@ -0,0 +1,144 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static partial class InstEmit
|
||||
{
|
||||
public static void Fswzadd(EmitterContext context)
|
||||
{
|
||||
InstFswzadd op = context.GetOp<InstFswzadd>();
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
Operand srcB = GetSrcReg(context, op.SrcB);
|
||||
Operand dest = GetDest(op.Dest);
|
||||
|
||||
context.Copy(dest, context.FPSwizzleAdd(srcA, srcB, op.PnWord));
|
||||
|
||||
InstEmitAluHelper.SetFPZnFlags(context, dest, op.WriteCC);
|
||||
}
|
||||
|
||||
public static void Shfl(EmitterContext context)
|
||||
{
|
||||
InstShfl op = context.GetOp<InstShfl>();
|
||||
|
||||
Operand pred = Register(op.DestPred, RegisterType.Predicate);
|
||||
|
||||
Operand srcA = GetSrcReg(context, op.SrcA);
|
||||
|
||||
Operand srcB = op.BFixShfl ? Const(op.SrcBImm) : GetSrcReg(context, op.SrcB);
|
||||
Operand srcC = op.CFixShfl ? Const(op.SrcCImm) : GetSrcReg(context, op.SrcC);
|
||||
|
||||
(Operand res, Operand valid) = op.ShflMode switch
|
||||
{
|
||||
ShflMode.Idx => context.Shuffle(srcA, srcB, srcC),
|
||||
ShflMode.Up => context.ShuffleUp(srcA, srcB, srcC),
|
||||
ShflMode.Down => context.ShuffleDown(srcA, srcB, srcC),
|
||||
ShflMode.Bfly => context.ShuffleXor(srcA, srcB, srcC),
|
||||
_ => (null, null),
|
||||
};
|
||||
|
||||
context.Copy(GetDest(op.Dest), res);
|
||||
context.Copy(pred, valid);
|
||||
}
|
||||
|
||||
public static void Vote(EmitterContext context)
|
||||
{
|
||||
InstVote op = context.GetOp<InstVote>();
|
||||
|
||||
Operand pred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
|
||||
Operand res = EmitVote(context, op.VoteMode, pred);
|
||||
|
||||
if (res != null)
|
||||
{
|
||||
context.Copy(Register(op.VpDest, RegisterType.Predicate), res);
|
||||
}
|
||||
else
|
||||
{
|
||||
context.TranslatorContext.GpuAccessor.Log($"Invalid vote operation: {op.VoteMode}.");
|
||||
}
|
||||
|
||||
if (op.Dest != RegisterConsts.RegisterZeroIndex)
|
||||
{
|
||||
context.Copy(GetDest(op.Dest), EmitBallot(context, pred));
|
||||
}
|
||||
}
|
||||
|
||||
private static Operand EmitVote(EmitterContext context, VoteMode voteMode, Operand pred)
|
||||
{
|
||||
int subgroupSize = context.TranslatorContext.GpuAccessor.QueryHostSubgroupSize();
|
||||
|
||||
if (subgroupSize <= 32)
|
||||
{
|
||||
return voteMode switch
|
||||
{
|
||||
VoteMode.All => context.VoteAll(pred),
|
||||
VoteMode.Any => context.VoteAny(pred),
|
||||
VoteMode.Eq => context.VoteAllEqual(pred),
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
|
||||
// Emulate vote with ballot masks.
|
||||
// We do that when the GPU thread count is not 32,
|
||||
// since the shader code assumes it is 32.
|
||||
// allInvocations => ballot(pred) == ballot(true),
|
||||
// anyInvocation => ballot(pred) != 0,
|
||||
// allInvocationsEqual => ballot(pred) == balot(true) || ballot(pred) == 0
|
||||
Operand ballotMask = EmitBallot(context, pred);
|
||||
|
||||
Operand AllTrue() => context.ICompareEqual(ballotMask, EmitBallot(context, Const(IrConsts.True)));
|
||||
|
||||
return voteMode switch
|
||||
{
|
||||
VoteMode.All => AllTrue(),
|
||||
VoteMode.Any => context.ICompareNotEqual(ballotMask, Const(0)),
|
||||
VoteMode.Eq => context.BitwiseOr(AllTrue(), context.ICompareEqual(ballotMask, Const(0))),
|
||||
_ => null,
|
||||
};
|
||||
}
|
||||
|
||||
private static Operand EmitBallot(EmitterContext context, Operand pred)
|
||||
{
|
||||
int subgroupSize = context.TranslatorContext.GpuAccessor.QueryHostSubgroupSize();
|
||||
|
||||
if (subgroupSize <= 32)
|
||||
{
|
||||
return context.Ballot(pred, 0);
|
||||
}
|
||||
else if (subgroupSize == 64)
|
||||
{
|
||||
// TODO: Add support for vector destination and do that with a single operation.
|
||||
|
||||
Operand laneId = context.Load(StorageKind.Input, IoVariable.SubgroupLaneId);
|
||||
Operand low = context.Ballot(pred, 0);
|
||||
Operand high = context.Ballot(pred, 1);
|
||||
|
||||
return context.ConditionalSelect(context.BitwiseAnd(laneId, Const(32)), high, low);
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: Add support for vector destination and do that with a single operation.
|
||||
|
||||
Operand laneId = context.Load(StorageKind.Input, IoVariable.SubgroupLaneId);
|
||||
Operand element = context.ShiftRightU32(laneId, Const(5));
|
||||
|
||||
Operand res = context.Ballot(pred, 0);
|
||||
res = context.ConditionalSelect(
|
||||
context.ICompareEqual(element, Const(1)),
|
||||
context.Ballot(pred, 1), res);
|
||||
res = context.ConditionalSelect(
|
||||
context.ICompareEqual(element, Const(2)),
|
||||
context.Ballot(pred, 2), res);
|
||||
res = context.ConditionalSelect(
|
||||
context.ICompareEqual(element, Const(3)),
|
||||
context.Ballot(pred, 3), res);
|
||||
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
6
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitter.cs
vendored
Normal file
6
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/InstEmitter.cs
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
delegate void InstEmitter(EmitterContext context);
|
||||
}
|
||||
142
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/Lop3Expression.cs
vendored
Normal file
142
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/Instructions/Lop3Expression.cs
vendored
Normal file
@@ -0,0 +1,142 @@
|
||||
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.Instructions
|
||||
{
|
||||
static class Lop3Expression
|
||||
{
|
||||
private enum TruthTable : byte
|
||||
{
|
||||
False = 0x00, // false
|
||||
True = 0xff, // true
|
||||
In = 0xf0, // a
|
||||
And2 = 0xc0, // a & b
|
||||
Or2 = 0xfc, // a | b
|
||||
Xor2 = 0x3c, // a ^ b
|
||||
And3 = 0x80, // a & b & c
|
||||
Or3 = 0xfe, // a | b | c
|
||||
XorAnd = 0x60, // a & (b ^ c)
|
||||
XorOr = 0xf6, // a | (b ^ c)
|
||||
OrAnd = 0xe0, // a & (b | c)
|
||||
AndOr = 0xf8, // a | (b & c)
|
||||
Onehot = 0x16, // (a & !b & !c) | (!a & b & !c) | (!a & !b & c) - Only one value is true.
|
||||
Majority = 0xe8, // Popcount(a, b, c) >= 2
|
||||
Gamble = 0x81, // (a & b & c) | (!a & !b & !c) - All on or all off
|
||||
InverseGamble = 0x7e, // Inverse of Gamble
|
||||
Dot = 0x1a, // a ^ (c | (a & b))
|
||||
Mux = 0xca, // a ? b : c
|
||||
AndXor = 0x78, // a ^ (b & c)
|
||||
OrXor = 0x1e, // a ^ (b | c)
|
||||
Xor3 = 0x96, // a ^ b ^ c
|
||||
}
|
||||
|
||||
public static Operand GetFromTruthTable(EmitterContext context, Operand srcA, Operand srcB, Operand srcC, int imm)
|
||||
{
|
||||
for (int i = 0; i < 0x40; i++)
|
||||
{
|
||||
TruthTable currImm = (TruthTable)imm;
|
||||
|
||||
Operand x = srcA;
|
||||
Operand y = srcB;
|
||||
Operand z = srcC;
|
||||
|
||||
if ((i & 0x01) != 0)
|
||||
{
|
||||
(x, y) = (y, x);
|
||||
currImm = PermuteTable(currImm, 7, 6, 3, 2, 5, 4, 1, 0);
|
||||
}
|
||||
|
||||
if ((i & 0x02) != 0)
|
||||
{
|
||||
(x, z) = (z, x);
|
||||
currImm = PermuteTable(currImm, 7, 3, 5, 1, 6, 2, 4, 0);
|
||||
}
|
||||
|
||||
if ((i & 0x04) != 0)
|
||||
{
|
||||
(y, z) = (z, y);
|
||||
currImm = PermuteTable(currImm, 7, 5, 6, 4, 3, 1, 2, 0);
|
||||
}
|
||||
|
||||
if ((i & 0x08) != 0)
|
||||
{
|
||||
x = context.BitwiseNot(x);
|
||||
currImm = PermuteTable(currImm, 3, 2, 1, 0, 7, 6, 5, 4);
|
||||
}
|
||||
|
||||
if ((i & 0x10) != 0)
|
||||
{
|
||||
y = context.BitwiseNot(y);
|
||||
currImm = PermuteTable(currImm, 5, 4, 7, 6, 1, 0, 3, 2);
|
||||
}
|
||||
|
||||
if ((i & 0x20) != 0)
|
||||
{
|
||||
z = context.BitwiseNot(z);
|
||||
currImm = PermuteTable(currImm, 6, 7, 4, 5, 2, 3, 0, 1);
|
||||
}
|
||||
|
||||
Operand result = GetExpr(currImm, context, x, y, z);
|
||||
if (result != null)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
Operand notResult = GetExpr((TruthTable)((~(int)currImm) & 0xff), context, x, y, z);
|
||||
if (notResult != null)
|
||||
{
|
||||
return context.BitwiseNot(notResult);
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static Operand GetExpr(TruthTable imm, EmitterContext context, Operand x, Operand y, Operand z)
|
||||
{
|
||||
return imm switch
|
||||
{
|
||||
#pragma warning disable IDE0055 // Disable formatting
|
||||
TruthTable.False => Const(0),
|
||||
TruthTable.True => Const(-1),
|
||||
TruthTable.In => x,
|
||||
TruthTable.And2 => context.BitwiseAnd(x, y),
|
||||
TruthTable.Or2 => context.BitwiseOr(x, y),
|
||||
TruthTable.Xor2 => context.BitwiseExclusiveOr(x, y),
|
||||
TruthTable.And3 => context.BitwiseAnd(x, context.BitwiseAnd(y, z)),
|
||||
TruthTable.Or3 => context.BitwiseOr(x, context.BitwiseOr(y, z)),
|
||||
TruthTable.XorAnd => context.BitwiseAnd(x, context.BitwiseExclusiveOr(y, z)),
|
||||
TruthTable.XorOr => context.BitwiseOr(x, context.BitwiseExclusiveOr(y, z)),
|
||||
TruthTable.OrAnd => context.BitwiseAnd(x, context.BitwiseOr(y, z)),
|
||||
TruthTable.AndOr => context.BitwiseOr(x, context.BitwiseAnd(y, z)),
|
||||
TruthTable.Onehot => context.BitwiseExclusiveOr(context.BitwiseOr(x, y), context.BitwiseOr(z, context.BitwiseAnd(x, y))),
|
||||
TruthTable.Majority => context.BitwiseAnd(context.BitwiseOr(x, y), context.BitwiseOr(z, context.BitwiseAnd(x, y))),
|
||||
TruthTable.InverseGamble => context.BitwiseOr(context.BitwiseExclusiveOr(x, y), context.BitwiseExclusiveOr(x, z)),
|
||||
TruthTable.Dot => context.BitwiseAnd(context.BitwiseExclusiveOr(x, z), context.BitwiseOr(context.BitwiseNot(y), z)),
|
||||
TruthTable.Mux => context.BitwiseOr(context.BitwiseAnd(x, y), context.BitwiseAnd(context.BitwiseNot(x), z)),
|
||||
TruthTable.AndXor => context.BitwiseExclusiveOr(x, context.BitwiseAnd(y, z)),
|
||||
TruthTable.OrXor => context.BitwiseExclusiveOr(x, context.BitwiseOr(y, z)),
|
||||
TruthTable.Xor3 => context.BitwiseExclusiveOr(x, context.BitwiseExclusiveOr(y, z)),
|
||||
_ => null,
|
||||
#pragma warning restore IDE0055
|
||||
};
|
||||
}
|
||||
|
||||
private static TruthTable PermuteTable(TruthTable imm, int bit7, int bit6, int bit5, int bit4, int bit3, int bit2, int bit1, int bit0)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
result |= (((int)imm >> 0) & 1) << bit0;
|
||||
result |= (((int)imm >> 1) & 1) << bit1;
|
||||
result |= (((int)imm >> 2) & 1) << bit2;
|
||||
result |= (((int)imm >> 3) & 1) << bit3;
|
||||
result |= (((int)imm >> 4) & 1) << bit4;
|
||||
result |= (((int)imm >> 5) & 1) << bit5;
|
||||
result |= (((int)imm >> 6) & 1) << bit6;
|
||||
result |= (((int)imm >> 7) & 1) << bit7;
|
||||
|
||||
return (TruthTable)result;
|
||||
}
|
||||
}
|
||||
}
|
||||
91
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/BasicBlock.cs
vendored
Normal file
91
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/BasicBlock.cs
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
class BasicBlock
|
||||
{
|
||||
public int Index { get; set; }
|
||||
|
||||
public LinkedList<INode> Operations { get; }
|
||||
|
||||
private BasicBlock _next;
|
||||
private BasicBlock _branch;
|
||||
|
||||
public BasicBlock Next
|
||||
{
|
||||
get => _next;
|
||||
set => _next = AddSuccessor(_next, value);
|
||||
}
|
||||
|
||||
public BasicBlock Branch
|
||||
{
|
||||
get => _branch;
|
||||
set => _branch = AddSuccessor(_branch, value);
|
||||
}
|
||||
|
||||
public bool HasBranch => _branch != null;
|
||||
public bool Reachable => Index == 0 || Predecessors.Count != 0;
|
||||
|
||||
public List<BasicBlock> Predecessors { get; }
|
||||
|
||||
public HashSet<BasicBlock> DominanceFrontiers { get; }
|
||||
|
||||
public BasicBlock ImmediateDominator { get; set; }
|
||||
|
||||
public BasicBlock()
|
||||
{
|
||||
Operations = [];
|
||||
|
||||
Predecessors = [];
|
||||
|
||||
DominanceFrontiers = [];
|
||||
}
|
||||
|
||||
public BasicBlock(int index) : this()
|
||||
{
|
||||
Index = index;
|
||||
}
|
||||
|
||||
private BasicBlock AddSuccessor(BasicBlock oldBlock, BasicBlock newBlock)
|
||||
{
|
||||
oldBlock?.Predecessors.Remove(this);
|
||||
newBlock?.Predecessors.Add(this);
|
||||
|
||||
return newBlock;
|
||||
}
|
||||
|
||||
public INode GetLastOp()
|
||||
{
|
||||
return Operations.Last?.Value;
|
||||
}
|
||||
|
||||
public void Append(INode node)
|
||||
{
|
||||
INode lastOp = GetLastOp();
|
||||
|
||||
if (lastOp is Operation operation && IsControlFlowInst(operation.Inst))
|
||||
{
|
||||
Operations.AddBefore(Operations.Last, node);
|
||||
}
|
||||
else
|
||||
{
|
||||
Operations.AddLast(node);
|
||||
}
|
||||
}
|
||||
|
||||
private static bool IsControlFlowInst(Instruction inst)
|
||||
{
|
||||
switch (inst)
|
||||
{
|
||||
case Instruction.Branch:
|
||||
case Instruction.BranchIfFalse:
|
||||
case Instruction.BranchIfTrue:
|
||||
case Instruction.Discard:
|
||||
case Instruction.Return:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
12
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/CommentNode.cs
vendored
Normal file
12
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/CommentNode.cs
vendored
Normal file
@@ -0,0 +1,12 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
class CommentNode : Operation
|
||||
{
|
||||
public string Comment { get; }
|
||||
|
||||
public CommentNode(string comment) : base(Instruction.Comment, null)
|
||||
{
|
||||
Comment = comment;
|
||||
}
|
||||
}
|
||||
}
|
||||
23
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Function.cs
vendored
Normal file
23
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Function.cs
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
class Function
|
||||
{
|
||||
public BasicBlock[] Blocks { get; }
|
||||
|
||||
public string Name { get; }
|
||||
|
||||
public bool ReturnsValue { get; }
|
||||
|
||||
public int InArgumentsCount { get; }
|
||||
public int OutArgumentsCount { get; }
|
||||
|
||||
public Function(BasicBlock[] blocks, string name, bool returnsValue, int inArgumentsCount, int outArgumentsCount)
|
||||
{
|
||||
Blocks = blocks;
|
||||
Name = name;
|
||||
ReturnsValue = returnsValue;
|
||||
InArgumentsCount = inArgumentsCount;
|
||||
OutArgumentsCount = outArgumentsCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
15
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/INode.cs
vendored
Normal file
15
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/INode.cs
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
interface INode
|
||||
{
|
||||
Operand Dest { get; set; }
|
||||
|
||||
int DestsCount { get; }
|
||||
int SourcesCount { get; }
|
||||
|
||||
Operand GetDest(int index);
|
||||
Operand GetSource(int index);
|
||||
|
||||
void SetSource(int index, Operand operand);
|
||||
}
|
||||
}
|
||||
197
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs
vendored
Normal file
197
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Instruction.cs
vendored
Normal file
@@ -0,0 +1,197 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
[Flags]
|
||||
enum Instruction
|
||||
{
|
||||
Absolute = 1,
|
||||
Add,
|
||||
AtomicAdd,
|
||||
AtomicAnd,
|
||||
AtomicCompareAndSwap,
|
||||
AtomicMinS32,
|
||||
AtomicMinU32,
|
||||
AtomicMaxS32,
|
||||
AtomicMaxU32,
|
||||
AtomicOr,
|
||||
AtomicSwap,
|
||||
AtomicXor,
|
||||
Ballot,
|
||||
Barrier,
|
||||
BitCount,
|
||||
BitfieldExtractS32,
|
||||
BitfieldExtractU32,
|
||||
BitfieldInsert,
|
||||
BitfieldReverse,
|
||||
BitwiseAnd,
|
||||
BitwiseExclusiveOr,
|
||||
BitwiseNot,
|
||||
BitwiseOr,
|
||||
Branch,
|
||||
BranchIfFalse,
|
||||
BranchIfTrue,
|
||||
Call,
|
||||
Ceiling,
|
||||
Clamp,
|
||||
ClampU32,
|
||||
Comment,
|
||||
CompareEqual,
|
||||
CompareGreater,
|
||||
CompareGreaterOrEqual,
|
||||
CompareGreaterOrEqualU32,
|
||||
CompareGreaterU32,
|
||||
CompareLess,
|
||||
CompareLessOrEqual,
|
||||
CompareLessOrEqualU32,
|
||||
CompareLessU32,
|
||||
CompareNotEqual,
|
||||
ConditionalSelect,
|
||||
ConvertFP32ToFP64,
|
||||
ConvertFP64ToFP32,
|
||||
ConvertFP32ToS32,
|
||||
ConvertFP32ToU32,
|
||||
ConvertFP64ToS32,
|
||||
ConvertFP64ToU32,
|
||||
ConvertS32ToFP32,
|
||||
ConvertS32ToFP64,
|
||||
ConvertU32ToFP32,
|
||||
ConvertU32ToFP64,
|
||||
Copy,
|
||||
Cosine,
|
||||
Ddx,
|
||||
Ddy,
|
||||
Discard,
|
||||
Divide,
|
||||
EmitVertex,
|
||||
EndPrimitive,
|
||||
ExponentB2,
|
||||
FSIBegin,
|
||||
FSIEnd,
|
||||
FindLSB,
|
||||
FindMSBS32,
|
||||
FindMSBU32,
|
||||
Floor,
|
||||
FusedMultiplyAdd,
|
||||
GroupMemoryBarrier,
|
||||
ImageLoad,
|
||||
ImageStore,
|
||||
ImageAtomic,
|
||||
IsNan,
|
||||
Load,
|
||||
Lod,
|
||||
LogarithmB2,
|
||||
LogicalAnd,
|
||||
LogicalExclusiveOr,
|
||||
LogicalNot,
|
||||
LogicalOr,
|
||||
LoopBreak,
|
||||
LoopContinue,
|
||||
MarkLabel,
|
||||
Maximum,
|
||||
MaximumU32,
|
||||
MemoryBarrier,
|
||||
Minimum,
|
||||
MinimumU32,
|
||||
Modulo,
|
||||
Multiply,
|
||||
MultiplyHighS32,
|
||||
MultiplyHighU32,
|
||||
Negate,
|
||||
PackDouble2x32,
|
||||
PackHalf2x16,
|
||||
ReciprocalSquareRoot,
|
||||
Return,
|
||||
Round,
|
||||
ShiftLeft,
|
||||
ShiftRightS32,
|
||||
ShiftRightU32,
|
||||
Shuffle,
|
||||
ShuffleDown,
|
||||
ShuffleUp,
|
||||
ShuffleXor,
|
||||
Sine,
|
||||
SquareRoot,
|
||||
Store,
|
||||
Subtract,
|
||||
SwizzleAdd,
|
||||
TextureSample,
|
||||
TextureQuerySamples,
|
||||
TextureQuerySize,
|
||||
Truncate,
|
||||
UnpackDouble2x32,
|
||||
UnpackHalf2x16,
|
||||
VectorExtract,
|
||||
VoteAll,
|
||||
VoteAllEqual,
|
||||
VoteAny,
|
||||
|
||||
Count,
|
||||
|
||||
FP32 = 1 << 16,
|
||||
FP64 = 1 << 17,
|
||||
|
||||
Mask = 0xffff,
|
||||
}
|
||||
|
||||
static class InstructionExtensions
|
||||
{
|
||||
public static bool IsAtomic(this Instruction inst)
|
||||
{
|
||||
switch (inst & Instruction.Mask)
|
||||
{
|
||||
case Instruction.AtomicAdd:
|
||||
case Instruction.AtomicAnd:
|
||||
case Instruction.AtomicCompareAndSwap:
|
||||
case Instruction.AtomicMaxS32:
|
||||
case Instruction.AtomicMaxU32:
|
||||
case Instruction.AtomicMinS32:
|
||||
case Instruction.AtomicMinU32:
|
||||
case Instruction.AtomicOr:
|
||||
case Instruction.AtomicSwap:
|
||||
case Instruction.AtomicXor:
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool IsComparison(this Instruction inst)
|
||||
{
|
||||
switch (inst & Instruction.Mask)
|
||||
{
|
||||
case Instruction.CompareEqual:
|
||||
case Instruction.CompareGreater:
|
||||
case Instruction.CompareGreaterOrEqual:
|
||||
case Instruction.CompareGreaterOrEqualU32:
|
||||
case Instruction.CompareGreaterU32:
|
||||
case Instruction.CompareLess:
|
||||
case Instruction.CompareLessOrEqual:
|
||||
case Instruction.CompareLessOrEqualU32:
|
||||
case Instruction.CompareLessU32:
|
||||
case Instruction.CompareNotEqual:
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool IsTextureQuery(this Instruction inst)
|
||||
{
|
||||
inst &= Instruction.Mask;
|
||||
return inst is Instruction.Lod or Instruction.TextureQuerySamples or Instruction.TextureQuerySize;
|
||||
}
|
||||
|
||||
public static bool IsImage(this Instruction inst)
|
||||
{
|
||||
inst &= Instruction.Mask;
|
||||
return inst is Instruction.ImageAtomic or Instruction.ImageLoad or Instruction.ImageStore;
|
||||
}
|
||||
|
||||
public static bool IsImageStore(this Instruction inst)
|
||||
{
|
||||
inst &= Instruction.Mask;
|
||||
return inst is Instruction.ImageAtomic or Instruction.ImageStore;
|
||||
}
|
||||
}
|
||||
}
|
||||
49
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/IoVariable.cs
vendored
Normal file
49
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/IoVariable.cs
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
enum IoVariable
|
||||
{
|
||||
Invalid,
|
||||
|
||||
BackColorDiffuse,
|
||||
BackColorSpecular,
|
||||
BaseInstance,
|
||||
BaseVertex,
|
||||
ClipDistance,
|
||||
CtaId,
|
||||
DrawIndex,
|
||||
FogCoord,
|
||||
FragmentCoord,
|
||||
FragmentOutputColor,
|
||||
FragmentOutputDepth,
|
||||
FrontColorDiffuse,
|
||||
FrontColorSpecular,
|
||||
FrontFacing,
|
||||
GlobalId,
|
||||
InstanceId,
|
||||
InstanceIndex,
|
||||
InvocationId,
|
||||
Layer,
|
||||
PatchVertices,
|
||||
PointCoord,
|
||||
PointSize,
|
||||
Position,
|
||||
PrimitiveId,
|
||||
SubgroupEqMask,
|
||||
SubgroupGeMask,
|
||||
SubgroupGtMask,
|
||||
SubgroupLaneId,
|
||||
SubgroupLeMask,
|
||||
SubgroupLtMask,
|
||||
TessellationCoord,
|
||||
TessellationLevelInner,
|
||||
TessellationLevelOuter,
|
||||
TextureCoord,
|
||||
ThreadId,
|
||||
ThreadKill,
|
||||
UserDefined,
|
||||
VertexId,
|
||||
VertexIndex,
|
||||
ViewportIndex,
|
||||
ViewportMask,
|
||||
}
|
||||
}
|
||||
8
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/IrConsts.cs
vendored
Normal file
8
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/IrConsts.cs
vendored
Normal file
@@ -0,0 +1,8 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
static class IrConsts
|
||||
{
|
||||
public const int False = 0;
|
||||
public const int True = -1;
|
||||
}
|
||||
}
|
||||
79
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Operand.cs
vendored
Normal file
79
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Operand.cs
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
class Operand
|
||||
{
|
||||
private const int CbufSlotBits = 5;
|
||||
private const int CbufSlotLsb = 32 - CbufSlotBits;
|
||||
private const int CbufSlotMask = (1 << CbufSlotBits) - 1;
|
||||
|
||||
public OperandType Type { get; }
|
||||
|
||||
public int Value { get; }
|
||||
|
||||
public INode AsgOp { get; set; }
|
||||
|
||||
public HashSet<INode> UseOps { get; }
|
||||
|
||||
private Operand()
|
||||
{
|
||||
UseOps = [];
|
||||
}
|
||||
|
||||
public Operand(OperandType type) : this()
|
||||
{
|
||||
Type = type;
|
||||
}
|
||||
|
||||
public Operand(OperandType type, int value) : this()
|
||||
{
|
||||
Type = type;
|
||||
Value = value;
|
||||
}
|
||||
|
||||
public Operand(Register reg) : this()
|
||||
{
|
||||
Type = OperandType.Register;
|
||||
Value = PackRegInfo(reg.Index, reg.Type);
|
||||
}
|
||||
|
||||
public Operand(int slot, int offset) : this()
|
||||
{
|
||||
Type = OperandType.ConstantBuffer;
|
||||
Value = PackCbufInfo(slot, offset);
|
||||
}
|
||||
|
||||
private static int PackCbufInfo(int slot, int offset)
|
||||
{
|
||||
return (slot << CbufSlotLsb) | offset;
|
||||
}
|
||||
|
||||
private static int PackRegInfo(int index, RegisterType type)
|
||||
{
|
||||
return ((int)type << 24) | index;
|
||||
}
|
||||
|
||||
public int GetCbufSlot()
|
||||
{
|
||||
return (Value >> CbufSlotLsb) & CbufSlotMask;
|
||||
}
|
||||
|
||||
public int GetCbufOffset()
|
||||
{
|
||||
return Value & ~(CbufSlotMask << CbufSlotLsb);
|
||||
}
|
||||
|
||||
public Register GetRegister()
|
||||
{
|
||||
return new Register(Value & 0xffffff, (RegisterType)(Value >> 24));
|
||||
}
|
||||
|
||||
public float AsFloat()
|
||||
{
|
||||
return BitConverter.Int32BitsToSingle(Value);
|
||||
}
|
||||
}
|
||||
}
|
||||
62
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/OperandHelper.cs
vendored
Normal file
62
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/OperandHelper.cs
vendored
Normal file
@@ -0,0 +1,62 @@
|
||||
using Ryujinx.Graphics.Shader.Decoders;
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
static class OperandHelper
|
||||
{
|
||||
public static Operand Argument(int value)
|
||||
{
|
||||
return new Operand(OperandType.Argument, value);
|
||||
}
|
||||
|
||||
public static Operand Cbuf(int slot, int offset)
|
||||
{
|
||||
return new Operand(slot, offset);
|
||||
}
|
||||
|
||||
public static Operand Const(int value)
|
||||
{
|
||||
return new Operand(OperandType.Constant, value);
|
||||
}
|
||||
|
||||
public static Operand ConstF(float value)
|
||||
{
|
||||
return new Operand(OperandType.Constant, BitConverter.SingleToInt32Bits(value));
|
||||
}
|
||||
|
||||
public static Operand Label()
|
||||
{
|
||||
return new Operand(OperandType.Label);
|
||||
}
|
||||
|
||||
public static Operand Local()
|
||||
{
|
||||
return new Operand(OperandType.LocalVariable);
|
||||
}
|
||||
|
||||
public static Operand Register(int index, RegisterType type)
|
||||
{
|
||||
return Register(new Register(index, type));
|
||||
}
|
||||
|
||||
public static Operand Register(Register reg)
|
||||
{
|
||||
if (reg.IsRZ)
|
||||
{
|
||||
return Const(0);
|
||||
}
|
||||
else if (reg.IsPT)
|
||||
{
|
||||
return Const(IrConsts.True);
|
||||
}
|
||||
|
||||
return new Operand(reg);
|
||||
}
|
||||
|
||||
public static Operand Undef()
|
||||
{
|
||||
return new Operand(OperandType.Undefined);
|
||||
}
|
||||
}
|
||||
}
|
||||
13
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/OperandType.cs
vendored
Normal file
13
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/OperandType.cs
vendored
Normal file
@@ -0,0 +1,13 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
enum OperandType
|
||||
{
|
||||
Argument,
|
||||
Constant,
|
||||
ConstantBuffer,
|
||||
Label,
|
||||
LocalVariable,
|
||||
Register,
|
||||
Undefined,
|
||||
}
|
||||
}
|
||||
294
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Operation.cs
vendored
Normal file
294
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/Operation.cs
vendored
Normal file
@@ -0,0 +1,294 @@
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
class Operation : INode
|
||||
{
|
||||
public Instruction Inst { get; private set; }
|
||||
public StorageKind StorageKind { get; }
|
||||
|
||||
public bool ForcePrecise { get; set; }
|
||||
|
||||
private Operand[] _dests;
|
||||
|
||||
public Operand Dest
|
||||
{
|
||||
get
|
||||
{
|
||||
return _dests.Length != 0 ? _dests[0] : null;
|
||||
}
|
||||
set
|
||||
{
|
||||
if (value != null)
|
||||
{
|
||||
if (value.Type == OperandType.LocalVariable)
|
||||
{
|
||||
value.AsgOp = this;
|
||||
}
|
||||
|
||||
_dests = [value];
|
||||
}
|
||||
else
|
||||
{
|
||||
_dests = [];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int DestsCount => _dests.Length;
|
||||
|
||||
private Operand[] _sources;
|
||||
|
||||
public int SourcesCount => _sources.Length;
|
||||
|
||||
public int Index { get; }
|
||||
|
||||
private Operation(Operand[] sources)
|
||||
{
|
||||
// The array may be modified externally, so we store a copy.
|
||||
_sources = (Operand[])sources.Clone();
|
||||
|
||||
for (int index = 0; index < _sources.Length; index++)
|
||||
{
|
||||
Operand source = _sources[index];
|
||||
|
||||
if (source.Type == OperandType.LocalVariable)
|
||||
{
|
||||
source.UseOps.Add(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Operation(Instruction inst, int index, Operand[] dests, Operand[] sources) : this(sources)
|
||||
{
|
||||
Inst = inst;
|
||||
Index = index;
|
||||
|
||||
if (dests != null)
|
||||
{
|
||||
// The array may be modified externally, so we store a copy.
|
||||
_dests = (Operand[])dests.Clone();
|
||||
|
||||
for (int dstIndex = 0; dstIndex < dests.Length; dstIndex++)
|
||||
{
|
||||
Operand dest = dests[dstIndex];
|
||||
|
||||
if (dest != null && dest.Type == OperandType.LocalVariable)
|
||||
{
|
||||
dest.AsgOp = this;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_dests = [];
|
||||
}
|
||||
}
|
||||
|
||||
public Operation(Instruction inst, Operand dest, params Operand[] sources) : this(sources)
|
||||
{
|
||||
Inst = inst;
|
||||
|
||||
if (dest != null)
|
||||
{
|
||||
dest.AsgOp = this;
|
||||
|
||||
_dests = [dest];
|
||||
}
|
||||
else
|
||||
{
|
||||
_dests = [];
|
||||
}
|
||||
}
|
||||
|
||||
public Operation(Instruction inst, StorageKind storageKind, Operand dest, params Operand[] sources) : this(sources)
|
||||
{
|
||||
Inst = inst;
|
||||
StorageKind = storageKind;
|
||||
|
||||
if (dest != null)
|
||||
{
|
||||
dest.AsgOp = this;
|
||||
|
||||
_dests = [dest];
|
||||
}
|
||||
else
|
||||
{
|
||||
_dests = [];
|
||||
}
|
||||
}
|
||||
|
||||
public Operation(Instruction inst, int index, Operand dest, params Operand[] sources) : this(inst, dest, sources)
|
||||
{
|
||||
Index = index;
|
||||
}
|
||||
|
||||
public void AppendDests(Operand[] operands)
|
||||
{
|
||||
int startIndex = _dests.Length;
|
||||
|
||||
Array.Resize(ref _dests, startIndex + operands.Length);
|
||||
|
||||
for (int index = 0; index < operands.Length; index++)
|
||||
{
|
||||
Operand dest = operands[index];
|
||||
|
||||
if (dest != null && dest.Type == OperandType.LocalVariable)
|
||||
{
|
||||
Debug.Assert(dest.AsgOp == null);
|
||||
dest.AsgOp = this;
|
||||
}
|
||||
|
||||
_dests[startIndex + index] = dest;
|
||||
}
|
||||
}
|
||||
|
||||
public void AppendSources(Operand[] operands)
|
||||
{
|
||||
int startIndex = _sources.Length;
|
||||
|
||||
Array.Resize(ref _sources, startIndex + operands.Length);
|
||||
|
||||
for (int index = 0; index < operands.Length; index++)
|
||||
{
|
||||
Operand source = operands[index];
|
||||
|
||||
if (source.Type == OperandType.LocalVariable)
|
||||
{
|
||||
source.UseOps.Add(this);
|
||||
}
|
||||
|
||||
_sources[startIndex + index] = source;
|
||||
}
|
||||
}
|
||||
|
||||
public Operand GetDest(int index)
|
||||
{
|
||||
return _dests[index];
|
||||
}
|
||||
|
||||
public Operand GetSource(int index)
|
||||
{
|
||||
return _sources[index];
|
||||
}
|
||||
|
||||
public void SetDest(int index, Operand dest)
|
||||
{
|
||||
Operand oldDest = _dests[index];
|
||||
|
||||
if (oldDest != null && oldDest.Type == OperandType.LocalVariable)
|
||||
{
|
||||
oldDest.AsgOp = null;
|
||||
}
|
||||
|
||||
if (dest != null && dest.Type == OperandType.LocalVariable)
|
||||
{
|
||||
dest.AsgOp = this;
|
||||
}
|
||||
|
||||
_dests[index] = dest;
|
||||
}
|
||||
|
||||
public void SetSource(int index, Operand source)
|
||||
{
|
||||
Operand oldSrc = _sources[index];
|
||||
|
||||
if (oldSrc != null && oldSrc.Type == OperandType.LocalVariable)
|
||||
{
|
||||
oldSrc.UseOps.Remove(this);
|
||||
}
|
||||
|
||||
if (source != null && source.Type == OperandType.LocalVariable)
|
||||
{
|
||||
source.UseOps.Add(this);
|
||||
}
|
||||
|
||||
_sources[index] = source;
|
||||
}
|
||||
|
||||
public void InsertSource(int index, Operand source)
|
||||
{
|
||||
Operand[] newSources = new Operand[_sources.Length + 1];
|
||||
|
||||
Array.Copy(_sources, 0, newSources, 0, index);
|
||||
Array.Copy(_sources, index, newSources, index + 1, _sources.Length - index);
|
||||
|
||||
newSources[index] = source;
|
||||
|
||||
if (source != null && source.Type == OperandType.LocalVariable)
|
||||
{
|
||||
source.UseOps.Add(this);
|
||||
}
|
||||
|
||||
_sources = newSources;
|
||||
}
|
||||
|
||||
protected void RemoveSource(int index)
|
||||
{
|
||||
SetSource(index, null);
|
||||
|
||||
Operand[] newSources = new Operand[_sources.Length - 1];
|
||||
|
||||
Array.Copy(_sources, 0, newSources, 0, index);
|
||||
Array.Copy(_sources, index + 1, newSources, index, _sources.Length - (index + 1));
|
||||
|
||||
_sources = newSources;
|
||||
}
|
||||
|
||||
public void TurnIntoCopy(Operand source)
|
||||
{
|
||||
TurnInto(Instruction.Copy, source);
|
||||
}
|
||||
|
||||
public void TurnInto(Instruction newInst, Operand source)
|
||||
{
|
||||
Inst = newInst;
|
||||
|
||||
foreach (Operand oldSrc in _sources)
|
||||
{
|
||||
if (oldSrc != null && oldSrc.Type == OperandType.LocalVariable)
|
||||
{
|
||||
oldSrc.UseOps.Remove(this);
|
||||
}
|
||||
}
|
||||
|
||||
if (source.Type == OperandType.LocalVariable)
|
||||
{
|
||||
source.UseOps.Add(this);
|
||||
}
|
||||
|
||||
_sources = [source];
|
||||
}
|
||||
|
||||
public void TurnDoubleIntoFloat()
|
||||
{
|
||||
if ((Inst & ~Instruction.Mask) == Instruction.FP64)
|
||||
{
|
||||
Inst = (Inst & Instruction.Mask) | Instruction.FP32;
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (Inst)
|
||||
{
|
||||
case Instruction.ConvertFP32ToFP64:
|
||||
case Instruction.ConvertFP64ToFP32:
|
||||
Inst = Instruction.Copy;
|
||||
break;
|
||||
case Instruction.ConvertFP64ToS32:
|
||||
Inst = Instruction.ConvertFP32ToS32;
|
||||
break;
|
||||
case Instruction.ConvertFP64ToU32:
|
||||
Inst = Instruction.ConvertFP32ToU32;
|
||||
break;
|
||||
case Instruction.ConvertS32ToFP64:
|
||||
Inst = Instruction.ConvertS32ToFP32;
|
||||
break;
|
||||
case Instruction.ConvertU32ToFP64:
|
||||
Inst = Instruction.ConvertU32ToFP32;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
104
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/PhiNode.cs
vendored
Normal file
104
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/PhiNode.cs
vendored
Normal file
@@ -0,0 +1,104 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
class PhiNode : INode
|
||||
{
|
||||
private Operand _dest;
|
||||
|
||||
public Operand Dest
|
||||
{
|
||||
get => _dest;
|
||||
set => _dest = AssignDest(value);
|
||||
}
|
||||
|
||||
public int DestsCount => _dest != null ? 1 : 0;
|
||||
|
||||
private readonly HashSet<BasicBlock> _blocks;
|
||||
|
||||
private class PhiSource
|
||||
{
|
||||
public BasicBlock Block { get; }
|
||||
public Operand Operand { get; set; }
|
||||
|
||||
public PhiSource(BasicBlock block, Operand operand)
|
||||
{
|
||||
Block = block;
|
||||
Operand = operand;
|
||||
}
|
||||
}
|
||||
|
||||
private readonly List<PhiSource> _sources;
|
||||
|
||||
public int SourcesCount => _sources.Count;
|
||||
|
||||
public PhiNode(Operand dest)
|
||||
{
|
||||
_blocks = [];
|
||||
|
||||
_sources = [];
|
||||
|
||||
dest.AsgOp = this;
|
||||
|
||||
Dest = dest;
|
||||
}
|
||||
|
||||
private Operand AssignDest(Operand dest)
|
||||
{
|
||||
if (dest != null && dest.Type == OperandType.LocalVariable)
|
||||
{
|
||||
dest.AsgOp = this;
|
||||
}
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
public void AddSource(BasicBlock block, Operand operand)
|
||||
{
|
||||
if (_blocks.Add(block))
|
||||
{
|
||||
if (operand.Type == OperandType.LocalVariable)
|
||||
{
|
||||
operand.UseOps.Add(this);
|
||||
}
|
||||
|
||||
_sources.Add(new PhiSource(block, operand));
|
||||
}
|
||||
}
|
||||
|
||||
public Operand GetDest(int index)
|
||||
{
|
||||
ArgumentOutOfRangeException.ThrowIfNotEqual(index, 0);
|
||||
|
||||
return _dest;
|
||||
}
|
||||
|
||||
public Operand GetSource(int index)
|
||||
{
|
||||
return _sources[index].Operand;
|
||||
}
|
||||
|
||||
public BasicBlock GetBlock(int index)
|
||||
{
|
||||
return _sources[index].Block;
|
||||
}
|
||||
|
||||
public void SetSource(int index, Operand source)
|
||||
{
|
||||
Operand oldSrc = _sources[index].Operand;
|
||||
|
||||
if (oldSrc != null && oldSrc.Type == OperandType.LocalVariable)
|
||||
{
|
||||
oldSrc.UseOps.Remove(this);
|
||||
}
|
||||
|
||||
if (source.Type == OperandType.LocalVariable)
|
||||
{
|
||||
source.UseOps.Add(this);
|
||||
}
|
||||
|
||||
_sources[index].Operand = source;
|
||||
}
|
||||
}
|
||||
}
|
||||
45
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/StorageKind.cs
vendored
Normal file
45
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/StorageKind.cs
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
enum StorageKind
|
||||
{
|
||||
None,
|
||||
Input,
|
||||
InputPerPatch,
|
||||
Output,
|
||||
OutputPerPatch,
|
||||
ConstantBuffer,
|
||||
StorageBuffer,
|
||||
LocalMemory,
|
||||
SharedMemory,
|
||||
SharedMemory8, // TODO: Remove this and store type as a field on the Operation class itself.
|
||||
SharedMemory16, // TODO: Remove this and store type as a field on the Operation class itself.
|
||||
GlobalMemory,
|
||||
GlobalMemoryS8, // TODO: Remove this and store type as a field on the Operation class itself.
|
||||
GlobalMemoryS16, // TODO: Remove this and store type as a field on the Operation class itself.
|
||||
GlobalMemoryU8, // TODO: Remove this and store type as a field on the Operation class itself.
|
||||
GlobalMemoryU16, // TODO: Remove this and store type as a field on the Operation class itself.
|
||||
}
|
||||
|
||||
static class StorageKindExtensions
|
||||
{
|
||||
public static bool IsInputOrOutput(this StorageKind storageKind)
|
||||
{
|
||||
return storageKind is StorageKind.Input or
|
||||
StorageKind.InputPerPatch or
|
||||
StorageKind.Output or
|
||||
StorageKind.OutputPerPatch;
|
||||
}
|
||||
|
||||
public static bool IsOutput(this StorageKind storageKind)
|
||||
{
|
||||
return storageKind is StorageKind.Output or
|
||||
StorageKind.OutputPerPatch;
|
||||
}
|
||||
|
||||
public static bool IsPerPatch(this StorageKind storageKind)
|
||||
{
|
||||
return storageKind is StorageKind.InputPerPatch or
|
||||
StorageKind.OutputPerPatch;
|
||||
}
|
||||
}
|
||||
}
|
||||
32
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/TextureFlags.cs
vendored
Normal file
32
tools/vendor/ryujinx/src/Ryujinx.Graphics.Shader/IntermediateRepresentation/TextureFlags.cs
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
using System;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
|
||||
{
|
||||
[Flags]
|
||||
enum TextureFlags
|
||||
{
|
||||
None = 0,
|
||||
Bindless = 1 << 0,
|
||||
Gather = 1 << 1,
|
||||
Derivatives = 1 << 2,
|
||||
IntCoords = 1 << 3,
|
||||
LodBias = 1 << 4,
|
||||
LodLevel = 1 << 5,
|
||||
Offset = 1 << 6,
|
||||
Offsets = 1 << 7,
|
||||
Coherent = 1 << 8,
|
||||
|
||||
AtomicMask = 15 << 16,
|
||||
|
||||
Add = 0 << 16,
|
||||
Minimum = 1 << 16,
|
||||
Maximum = 2 << 16,
|
||||
Increment = 3 << 16,
|
||||
Decrement = 4 << 16,
|
||||
BitwiseAnd = 5 << 16,
|
||||
BitwiseOr = 6 << 16,
|
||||
BitwiseXor = 7 << 16,
|
||||
Swap = 8 << 16,
|
||||
CAS = 9 << 16,
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user