aboutsummaryrefslogtreecommitdiff
path: root/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs
diff options
context:
space:
mode:
authorgdkchan <gab.dark.100@gmail.com>2019-04-17 20:57:08 -0300
committerjduncanator <1518948+jduncanator@users.noreply.github.com>2019-04-18 09:57:08 +1000
commit6b23a2c125b9c48b5ebea92716004ef68698bb0f (patch)
tree69332df6fbbd8e2bddc522ba682fcc5c7a69e101 /Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs
parentb2e88b04a85b41cc60af3485d88c90429e84a218 (diff)
New shader translator implementation (#654)
* Start implementing a new shader translator * Fix shift instructions and a typo * Small refactoring on StructuredProgram, move RemovePhis method to a separate class * Initial geometry shader support * Implement TLD4 * Fix -- There's no negation on FMUL32I * Add constant folding and algebraic simplification optimizations, nits * Some leftovers from constant folding * Avoid cast for constant assignments * Add a branch elimination pass, and misc small fixes * Remove redundant branches, add expression propagation and other improvements on the code * Small leftovers -- add missing break and continue, remove unused properties, other improvements * Add null check to handle empty block cases on block visitor * Add HADD2 and HMUL2 half float shader instructions * Optimize pack/unpack sequences, some fixes related to half float instructions * Add TXQ, TLD, TLDS and TLD4S shader texture instructions, and some support for bindless textures, some refactoring on codegen * Fix copy paste mistake that caused RZ to be ignored on the AST instruction * Add workaround for conditional exit, and fix half float instruction with constant buffer * Add missing 0.0 source for TLDS.LZ variants * Simplify the switch for TLDS.LZ * Texture instructions related fixes * Implement the HFMA instruction, and some misc. fixes * Enable constant folding on UnpackHalf2x16 instructions * Refactor HFMA to use OpCode* for opcode decoding rather than on the helper methods * Remove the old shader translator * Remove ShaderDeclInfo and other unused things * Add dual vertex shader support * Add ShaderConfig, used to pass shader type and maximum cbuffer size * Move and rename some instruction enums * Move texture instructions into a separate file * Move operand GetExpression and locals management to OperandManager * Optimize opcode decoding using a simple list and binary search * Add missing condition for do-while on goto elimination * Misc. fixes on texture instructions * Simplify TLDS switch * Address PR feedback, and a nit
Diffstat (limited to 'Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs')
-rw-r--r--Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs254
1 files changed, 254 insertions, 0 deletions
diff --git a/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs b/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs
new file mode 100644
index 00000000..f65631be
--- /dev/null
+++ b/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs
@@ -0,0 +1,254 @@
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.Shader.StructuredIr
+{
+ static class StructuredProgram
+ {
+ public static StructuredProgramInfo MakeStructuredProgram(BasicBlock[] blocks)
+ {
+ PhiFunctions.Remove(blocks);
+
+ StructuredProgramContext context = new StructuredProgramContext(blocks.Length);
+
+ for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
+ {
+ BasicBlock block = blocks[blkIndex];
+
+ context.EnterBlock(block);
+
+ foreach (INode node in block.Operations)
+ {
+ Operation operation = (Operation)node;
+
+ if (IsBranchInst(operation.Inst))
+ {
+ context.LeaveBlock(block, operation);
+ }
+ else
+ {
+ AddOperation(context, operation);
+ }
+ }
+ }
+
+ GotoElimination.Eliminate(context.GetGotos());
+
+ AstOptimizer.Optimize(context.Info);
+
+ return context.Info;
+ }
+
+ private static void AddOperation(StructuredProgramContext context, Operation operation)
+ {
+ Instruction inst = operation.Inst;
+
+ IAstNode[] sources = new IAstNode[operation.SourcesCount];
+
+ for (int index = 0; index < sources.Length; index++)
+ {
+ sources[index] = context.GetOperandUse(operation.GetSource(index));
+ }
+
+ if (operation.Dest != null)
+ {
+ AstOperand dest = context.GetOperandDef(operation.Dest);
+
+ if (inst == Instruction.LoadConstant)
+ {
+ Operand ldcSource = operation.GetSource(0);
+
+ if (ldcSource.Type != OperandType.Constant)
+ {
+ throw new InvalidOperationException("Found LDC with non-constant constant buffer slot.");
+ }
+
+ context.Info.CBuffers.Add(ldcSource.Value);
+ }
+
+ AstAssignment assignment;
+
+ //If all the sources are bool, it's better to use short-circuiting
+ //logical operations, rather than forcing a cast to int and doing
+ //a bitwise operation with the value, as it is likely to be used as
+ //a bool in the end.
+ if (IsBitwiseInst(inst) && AreAllSourceTypesEqual(sources, VariableType.Bool))
+ {
+ inst = GetLogicalFromBitwiseInst(inst);
+ }
+
+ bool isCondSel = inst == Instruction.ConditionalSelect;
+ bool isCopy = inst == Instruction.Copy;
+
+ if (isCondSel || isCopy)
+ {
+ VariableType type = GetVarTypeFromUses(operation.Dest);
+
+ if (isCondSel && type == VariableType.F32)
+ {
+ inst |= Instruction.FP;
+ }
+
+ dest.VarType = type;
+ }
+ else
+ {
+ dest.VarType = InstructionInfo.GetDestVarType(inst);
+ }
+
+ int componentMask = 1 << operation.ComponentIndex;
+
+ IAstNode source;
+
+ if (operation is TextureOperation texOp)
+ {
+ AstTextureOperation astTexOp = new AstTextureOperation(
+ inst,
+ texOp.Type,
+ texOp.Flags,
+ texOp.Handle,
+ componentMask,
+ sources);
+
+ context.Info.Samplers.Add(astTexOp);
+
+ source = astTexOp;
+ }
+ else if (!isCopy)
+ {
+ source = new AstOperation(inst, componentMask, sources);
+ }
+ else
+ {
+ source = sources[0];
+ }
+
+ assignment = new AstAssignment(dest, source);
+
+ context.AddNode(assignment);
+ }
+ else
+ {
+ context.AddNode(new AstOperation(inst, sources));
+ }
+ }
+
+ private static VariableType GetVarTypeFromUses(Operand dest)
+ {
+ HashSet<Operand> visited = new HashSet<Operand>();
+
+ Queue<Operand> pending = new Queue<Operand>();
+
+ bool Enqueue(Operand operand)
+ {
+ if (visited.Add(operand))
+ {
+ pending.Enqueue(operand);
+
+ return true;
+ }
+
+ return false;
+ }
+
+ Enqueue(dest);
+
+ while (pending.TryDequeue(out Operand operand))
+ {
+ foreach (INode useNode in operand.UseOps)
+ {
+ if (!(useNode is Operation operation))
+ {
+ continue;
+ }
+
+ if (operation.Inst == Instruction.Copy)
+ {
+ if (operation.Dest.Type == OperandType.LocalVariable)
+ {
+ if (Enqueue(operation.Dest))
+ {
+ break;
+ }
+ }
+ else
+ {
+ return OperandInfo.GetVarType(operation.Dest.Type);
+ }
+ }
+ else
+ {
+ for (int index = 0; index < operation.SourcesCount; index++)
+ {
+ if (operation.GetSource(index) == operand)
+ {
+ return InstructionInfo.GetSrcVarType(operation.Inst, index);
+ }
+ }
+ }
+ }
+ }
+
+ return VariableType.S32;
+ }
+
+ private static bool AreAllSourceTypesEqual(IAstNode[] sources, VariableType type)
+ {
+ foreach (IAstNode node in sources)
+ {
+ if (!(node is AstOperand operand))
+ {
+ return false;
+ }
+
+ if (operand.VarType != type)
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private static bool IsBranchInst(Instruction inst)
+ {
+ switch (inst)
+ {
+ case Instruction.Branch:
+ case Instruction.BranchIfFalse:
+ case Instruction.BranchIfTrue:
+ return true;
+ }
+
+ return false;
+ }
+
+ private static bool IsBitwiseInst(Instruction inst)
+ {
+ switch (inst)
+ {
+ case Instruction.BitwiseAnd:
+ case Instruction.BitwiseExclusiveOr:
+ case Instruction.BitwiseNot:
+ case Instruction.BitwiseOr:
+ return true;
+ }
+
+ return false;
+ }
+
+ private static Instruction GetLogicalFromBitwiseInst(Instruction inst)
+ {
+ switch (inst)
+ {
+ case Instruction.BitwiseAnd: return Instruction.LogicalAnd;
+ case Instruction.BitwiseExclusiveOr: return Instruction.LogicalExclusiveOr;
+ case Instruction.BitwiseNot: return Instruction.LogicalNot;
+ case Instruction.BitwiseOr: return Instruction.LogicalOr;
+ }
+
+ throw new ArgumentException($"Unexpected instruction \"{inst}\".");
+ }
+ }
+} \ No newline at end of file