1
0
Fork 0
mirror of https://github.com/Ryujinx/Ryujinx.git synced 2024-12-24 21:16:02 +00:00
Ryujinx/Spv.Generator/Instruction.cs
Nicholas Rodine 80a879cb44
Fix SpirV parse failure (#3597)
* Added .ToString overrides, to help diagnose and debug SpirV generated code.

* Added Spirv to team shared dictionary, so the word will not show up as a warning.

* Fixed bug where we were creating invalid constants (bool 0i and float 0i)

* Update Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs

Co-authored-by: gdkchan <gab.dark.100@gmail.com>

* Update Spv.Generator/Instruction.cs

Co-authored-by: gdkchan <gab.dark.100@gmail.com>

* Adjusted spacing to match style of the rest of the code.

* Added handler for FP64(double) as well, for undefined aggregate types.

* Made the operand labels a static dictionary, to avoid re-allocation on each call.
Replaced Contains/Get with a TryGetValue, to reduce the number of dictionary lookups.

* Added newline between AllOperands and ToString().

Co-authored-by: gdkchan <gab.dark.100@gmail.com>
2022-08-18 01:49:43 +02:00

247 lines
6.7 KiB
C#

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
namespace Spv.Generator
{
public sealed class Instruction : Operand, IEquatable<Instruction>
{
public const uint InvalidId = uint.MaxValue;
public Specification.Op Opcode { get; private set; }
private Instruction _resultType;
private InstructionOperands _operands;
public uint Id { get; set; }
public Instruction() { }
public void Set(Specification.Op opcode, uint id = InvalidId, Instruction resultType = null)
{
Opcode = opcode;
Id = id;
_resultType = resultType;
_operands = new InstructionOperands();
}
public void SetId(uint id)
{
Id = id;
}
public OperandType Type => OperandType.Instruction;
public ushort GetTotalWordCount()
{
ushort result = WordCount;
if (Id != InvalidId)
{
result++;
}
if (_resultType != null)
{
result += _resultType.WordCount;
}
Span<Operand> operands = _operands.AsSpan();
for (int i = 0; i < operands.Length; i++)
{
result += operands[i].WordCount;
}
return result;
}
public ushort WordCount => 1;
public void AddOperand(Operand value)
{
Debug.Assert(value != null);
_operands.Add(value);
}
public void AddOperand(Operand[] value)
{
foreach (Operand instruction in value)
{
AddOperand(instruction);
}
}
public void AddOperand(LiteralInteger[] value)
{
foreach (LiteralInteger instruction in value)
{
AddOperand(instruction);
}
}
public void AddOperand(LiteralInteger value)
{
AddOperand((Operand)value);
}
public void AddOperand(Instruction[] value)
{
foreach (Instruction instruction in value)
{
AddOperand(instruction);
}
}
public void AddOperand(Instruction value)
{
AddOperand((Operand)value);
}
public void AddOperand(string value)
{
AddOperand(new LiteralString(value));
}
public void AddOperand<T>(T value) where T: Enum
{
AddOperand(LiteralInteger.CreateForEnum(value));
}
public void Write(BinaryWriter writer)
{
// Word 0
writer.Write((ushort)Opcode);
writer.Write(GetTotalWordCount());
_resultType?.WriteOperand(writer);
if (Id != InvalidId)
{
writer.Write(Id);
}
Span<Operand> operands = _operands.AsSpan();
for (int i = 0; i < operands.Length; i++)
{
operands[i].WriteOperand(writer);
}
}
public void WriteOperand(BinaryWriter writer)
{
Debug.Assert(Id != InvalidId);
if (Id == InvalidId)
{
string methodToCall;
if (Opcode == Specification.Op.OpVariable)
{
methodToCall = "AddLocalVariable or AddGlobalVariable";
}
else if (Opcode == Specification.Op.OpLabel)
{
methodToCall = "AddLabel";
}
else
{
throw new InvalidOperationException("Internal error");
}
throw new InvalidOperationException($"Id wasn't bound to the module, please make sure to call {methodToCall}");
}
writer.Write(Id);
}
public override bool Equals(object obj)
{
return obj is Instruction instruction && Equals(instruction);
}
public bool Equals(Instruction cmpObj)
{
bool result = Type == cmpObj.Type && Id == cmpObj.Id;
if (result)
{
if (_resultType != null && cmpObj._resultType != null)
{
result &= _resultType.Equals(cmpObj._resultType);
}
else if (_resultType != null || cmpObj._resultType != null)
{
return false;
}
}
if (result)
{
result &= EqualsContent(cmpObj);
}
return result;
}
public bool EqualsContent(Instruction cmpObj)
{
Span<Operand> thisOperands = _operands.AsSpan();
Span<Operand> cmpOperands = cmpObj._operands.AsSpan();
if (thisOperands.Length != cmpOperands.Length)
{
return false;
}
for (int i = 0; i < thisOperands.Length; i++)
{
if (!thisOperands[i].Equals(cmpOperands[i]))
{
return false;
}
}
return true;
}
public bool EqualsResultType(Instruction cmpObj)
{
return _resultType.Opcode == cmpObj._resultType.Opcode && _resultType.EqualsContent(cmpObj._resultType);
}
public int GetHashCodeContent()
{
return DeterministicHashCode.Combine<Operand>(_operands.AsSpan());
}
public int GetHashCodeResultType()
{
return DeterministicHashCode.Combine(_resultType.Opcode, _resultType.GetHashCodeContent());
}
public override int GetHashCode()
{
return DeterministicHashCode.Combine(Opcode, Id, _resultType, DeterministicHashCode.Combine<Operand>(_operands.AsSpan()));
}
public bool Equals(Operand obj)
{
return obj is Instruction instruction && Equals(instruction);
}
private static readonly Dictionary<Specification.Op, string[]> _operandLabels = new()
{
{ Specification.Op.OpConstant, new [] { "Value" } },
{ Specification.Op.OpTypeInt, new [] { "Width", "Signed" } },
{ Specification.Op.OpTypeFloat, new [] { "Width" } }
};
public override string ToString()
{
var labels = _operandLabels.TryGetValue(Opcode, out var opLabels) ? opLabels : Array.Empty<string>();
var result = _resultType == null ? string.Empty : $"{_resultType} ";
return $"{result}{Opcode}{_operands.ToString(labels)}";
}
}
}