mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-17 06:08:43 +02:00
366 lines
12 KiB
C#
366 lines
12 KiB
C#
|
using System.Collections.Generic;
|
|||
|
using System.Diagnostics;
|
|||
|
using System.IO;
|
|||
|
using static Spv.Specification;
|
|||
|
|
|||
|
namespace Spv.Generator
|
|||
|
{
|
|||
|
public partial class Module
|
|||
|
{
|
|||
|
// TODO: Register on SPIR-V registry.
|
|||
|
private const int GeneratorId = 0;
|
|||
|
|
|||
|
private readonly uint _version;
|
|||
|
|
|||
|
private uint _bound;
|
|||
|
|
|||
|
// Follow spec order here while keeping it as simple as possible.
|
|||
|
private List<Capability> _capabilities;
|
|||
|
private List<string> _extensions;
|
|||
|
private Dictionary<DeterministicStringKey, Instruction> _extInstImports;
|
|||
|
private AddressingModel _addressingModel;
|
|||
|
private MemoryModel _memoryModel;
|
|||
|
|
|||
|
private List<Instruction> _entrypoints;
|
|||
|
private List<Instruction> _executionModes;
|
|||
|
private List<Instruction> _debug;
|
|||
|
private List<Instruction> _annotations;
|
|||
|
|
|||
|
// In the declaration block.
|
|||
|
private Dictionary<TypeDeclarationKey, Instruction> _typeDeclarations;
|
|||
|
// In the declaration block.
|
|||
|
private List<Instruction> _globals;
|
|||
|
// In the declaration block.
|
|||
|
private Dictionary<ConstantKey, Instruction> _constants;
|
|||
|
// In the declaration block, for function that aren't defined in the module.
|
|||
|
private List<Instruction> _functionsDeclarations;
|
|||
|
|
|||
|
private List<Instruction> _functionsDefinitions;
|
|||
|
|
|||
|
private GeneratorPool<Instruction> _instPool;
|
|||
|
private GeneratorPool<LiteralInteger> _integerPool;
|
|||
|
|
|||
|
public Module(uint version, GeneratorPool<Instruction> instPool = null, GeneratorPool<LiteralInteger> integerPool = null)
|
|||
|
{
|
|||
|
_version = version;
|
|||
|
_bound = 1;
|
|||
|
_capabilities = new List<Capability>();
|
|||
|
_extensions = new List<string>();
|
|||
|
_extInstImports = new Dictionary<DeterministicStringKey, Instruction>();
|
|||
|
_addressingModel = AddressingModel.Logical;
|
|||
|
_memoryModel = MemoryModel.Simple;
|
|||
|
_entrypoints = new List<Instruction>();
|
|||
|
_executionModes = new List<Instruction>();
|
|||
|
_debug = new List<Instruction>();
|
|||
|
_annotations = new List<Instruction>();
|
|||
|
_typeDeclarations = new Dictionary<TypeDeclarationKey, Instruction>();
|
|||
|
_constants = new Dictionary<ConstantKey, Instruction>();
|
|||
|
_globals = new List<Instruction>();
|
|||
|
_functionsDeclarations = new List<Instruction>();
|
|||
|
_functionsDefinitions = new List<Instruction>();
|
|||
|
|
|||
|
_instPool = instPool ?? new GeneratorPool<Instruction>();
|
|||
|
_integerPool = integerPool ?? new GeneratorPool<LiteralInteger>();
|
|||
|
|
|||
|
LiteralInteger.RegisterPool(_integerPool);
|
|||
|
}
|
|||
|
|
|||
|
private uint GetNewId()
|
|||
|
{
|
|||
|
return _bound++;
|
|||
|
}
|
|||
|
|
|||
|
public void AddCapability(Capability capability)
|
|||
|
{
|
|||
|
_capabilities.Add(capability);
|
|||
|
}
|
|||
|
|
|||
|
public void AddExtension(string extension)
|
|||
|
{
|
|||
|
_extensions.Add(extension);
|
|||
|
}
|
|||
|
|
|||
|
public Instruction NewInstruction(Op opcode, uint id = Instruction.InvalidId, Instruction resultType = null)
|
|||
|
{
|
|||
|
var result = _instPool.Allocate();
|
|||
|
result.Set(opcode, id, resultType);
|
|||
|
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
public Instruction AddExtInstImport(string import)
|
|||
|
{
|
|||
|
var key = new DeterministicStringKey(import);
|
|||
|
|
|||
|
if (_extInstImports.TryGetValue(key, out Instruction extInstImport))
|
|||
|
{
|
|||
|
// Update the duplicate instance to use the good id so it ends up being encoded correctly.
|
|||
|
return extInstImport;
|
|||
|
}
|
|||
|
|
|||
|
Instruction instruction = NewInstruction(Op.OpExtInstImport);
|
|||
|
instruction.AddOperand(import);
|
|||
|
|
|||
|
instruction.SetId(GetNewId());
|
|||
|
|
|||
|
_extInstImports.Add(key, instruction);
|
|||
|
|
|||
|
return instruction;
|
|||
|
}
|
|||
|
|
|||
|
private void AddTypeDeclaration(Instruction instruction, bool forceIdAllocation)
|
|||
|
{
|
|||
|
var key = new TypeDeclarationKey(instruction);
|
|||
|
|
|||
|
if (!forceIdAllocation)
|
|||
|
{
|
|||
|
if (_typeDeclarations.TryGetValue(key, out Instruction typeDeclaration))
|
|||
|
{
|
|||
|
// Update the duplicate instance to use the good id so it ends up being encoded correctly.
|
|||
|
|
|||
|
instruction.SetId(typeDeclaration.Id);
|
|||
|
|
|||
|
return;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
instruction.SetId(GetNewId());
|
|||
|
|
|||
|
_typeDeclarations.Add(key, instruction);
|
|||
|
}
|
|||
|
|
|||
|
public void AddEntryPoint(ExecutionModel executionModel, Instruction function, string name, params Instruction[] interfaces)
|
|||
|
{
|
|||
|
Debug.Assert(function.Opcode == Op.OpFunction);
|
|||
|
|
|||
|
Instruction entryPoint = NewInstruction(Op.OpEntryPoint);
|
|||
|
|
|||
|
entryPoint.AddOperand(executionModel);
|
|||
|
entryPoint.AddOperand(function);
|
|||
|
entryPoint.AddOperand(name);
|
|||
|
entryPoint.AddOperand(interfaces);
|
|||
|
|
|||
|
_entrypoints.Add(entryPoint);
|
|||
|
}
|
|||
|
|
|||
|
public void AddExecutionMode(Instruction function, ExecutionMode mode, params Operand[] parameters)
|
|||
|
{
|
|||
|
Debug.Assert(function.Opcode == Op.OpFunction);
|
|||
|
|
|||
|
Instruction executionModeInstruction = NewInstruction(Op.OpExecutionMode);
|
|||
|
|
|||
|
executionModeInstruction.AddOperand(function);
|
|||
|
executionModeInstruction.AddOperand(mode);
|
|||
|
executionModeInstruction.AddOperand(parameters);
|
|||
|
|
|||
|
_executionModes.Add(executionModeInstruction);
|
|||
|
}
|
|||
|
|
|||
|
private void AddToFunctionDefinitions(Instruction instruction)
|
|||
|
{
|
|||
|
Debug.Assert(instruction.Opcode != Op.OpTypeInt);
|
|||
|
_functionsDefinitions.Add(instruction);
|
|||
|
}
|
|||
|
|
|||
|
private void AddAnnotation(Instruction annotation)
|
|||
|
{
|
|||
|
_annotations.Add(annotation);
|
|||
|
}
|
|||
|
|
|||
|
private void AddDebug(Instruction debug)
|
|||
|
{
|
|||
|
_debug.Add(debug);
|
|||
|
}
|
|||
|
|
|||
|
public void AddLabel(Instruction label)
|
|||
|
{
|
|||
|
Debug.Assert(label.Opcode == Op.OpLabel);
|
|||
|
|
|||
|
label.SetId(GetNewId());
|
|||
|
|
|||
|
AddToFunctionDefinitions(label);
|
|||
|
}
|
|||
|
|
|||
|
public void AddLocalVariable(Instruction variable)
|
|||
|
{
|
|||
|
// TODO: Ensure it has the local modifier.
|
|||
|
Debug.Assert(variable.Opcode == Op.OpVariable);
|
|||
|
|
|||
|
variable.SetId(GetNewId());
|
|||
|
|
|||
|
AddToFunctionDefinitions(variable);
|
|||
|
}
|
|||
|
|
|||
|
public void AddGlobalVariable(Instruction variable)
|
|||
|
{
|
|||
|
// TODO: Ensure it has the global modifier.
|
|||
|
// TODO: All constants opcodes (OpSpecXXX and the rest of the OpConstantXXX).
|
|||
|
Debug.Assert(variable.Opcode == Op.OpVariable);
|
|||
|
|
|||
|
variable.SetId(GetNewId());
|
|||
|
|
|||
|
_globals.Add(variable);
|
|||
|
}
|
|||
|
|
|||
|
private void AddConstant(Instruction constant)
|
|||
|
{
|
|||
|
Debug.Assert(constant.Opcode == Op.OpConstant ||
|
|||
|
constant.Opcode == Op.OpConstantFalse ||
|
|||
|
constant.Opcode == Op.OpConstantTrue ||
|
|||
|
constant.Opcode == Op.OpConstantNull ||
|
|||
|
constant.Opcode == Op.OpConstantComposite);
|
|||
|
|
|||
|
var key = new ConstantKey(constant);
|
|||
|
|
|||
|
if (_constants.TryGetValue(key, out Instruction global))
|
|||
|
{
|
|||
|
// Update the duplicate instance to use the good id so it ends up being encoded correctly.
|
|||
|
constant.SetId(global.Id);
|
|||
|
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
constant.SetId(GetNewId());
|
|||
|
|
|||
|
_constants.Add(key, constant);
|
|||
|
}
|
|||
|
|
|||
|
public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params Operand[] parameters)
|
|||
|
{
|
|||
|
Instruction result = NewInstruction(Op.OpExtInst, GetNewId(), resultType);
|
|||
|
|
|||
|
result.AddOperand(set);
|
|||
|
result.AddOperand(instruction);
|
|||
|
result.AddOperand(parameters);
|
|||
|
AddToFunctionDefinitions(result);
|
|||
|
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
public void SetMemoryModel(AddressingModel addressingModel, MemoryModel memoryModel)
|
|||
|
{
|
|||
|
_addressingModel = addressingModel;
|
|||
|
_memoryModel = memoryModel;
|
|||
|
}
|
|||
|
|
|||
|
// TODO: Find a way to make the auto generate one used.
|
|||
|
public Instruction OpenClPrintf(Instruction resultType, Instruction format, params Instruction[] additionalarguments)
|
|||
|
{
|
|||
|
Instruction result = NewInstruction(Op.OpExtInst, GetNewId(), resultType);
|
|||
|
|
|||
|
result.AddOperand(AddExtInstImport("OpenCL.std"));
|
|||
|
result.AddOperand((LiteralInteger)184);
|
|||
|
result.AddOperand(format);
|
|||
|
result.AddOperand(additionalarguments);
|
|||
|
AddToFunctionDefinitions(result);
|
|||
|
|
|||
|
return result;
|
|||
|
}
|
|||
|
|
|||
|
public byte[] Generate()
|
|||
|
{
|
|||
|
// Estimate the size needed for the generated code, to avoid expanding the MemoryStream.
|
|||
|
int sizeEstimate = 1024 + _functionsDefinitions.Count * 32;
|
|||
|
|
|||
|
using (MemoryStream stream = new MemoryStream(sizeEstimate))
|
|||
|
{
|
|||
|
BinaryWriter writer = new BinaryWriter(stream, System.Text.Encoding.ASCII);
|
|||
|
|
|||
|
// Header
|
|||
|
writer.Write(MagicNumber);
|
|||
|
writer.Write(_version);
|
|||
|
writer.Write(GeneratorId);
|
|||
|
writer.Write(_bound);
|
|||
|
writer.Write(0u);
|
|||
|
|
|||
|
// 1.
|
|||
|
foreach (Capability capability in _capabilities)
|
|||
|
{
|
|||
|
Instruction capabilityInstruction = NewInstruction(Op.OpCapability);
|
|||
|
|
|||
|
capabilityInstruction.AddOperand(capability);
|
|||
|
capabilityInstruction.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 2.
|
|||
|
foreach (string extension in _extensions)
|
|||
|
{
|
|||
|
Instruction extensionInstruction = NewInstruction(Op.OpExtension);
|
|||
|
|
|||
|
extensionInstruction.AddOperand(extension);
|
|||
|
extensionInstruction.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 3.
|
|||
|
foreach (Instruction extInstImport in _extInstImports.Values)
|
|||
|
{
|
|||
|
extInstImport.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 4.
|
|||
|
Instruction memoryModelInstruction = NewInstruction(Op.OpMemoryModel);
|
|||
|
memoryModelInstruction.AddOperand(_addressingModel);
|
|||
|
memoryModelInstruction.AddOperand(_memoryModel);
|
|||
|
memoryModelInstruction.Write(writer);
|
|||
|
|
|||
|
// 5.
|
|||
|
foreach (Instruction entrypoint in _entrypoints)
|
|||
|
{
|
|||
|
entrypoint.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 6.
|
|||
|
foreach (Instruction executionMode in _executionModes)
|
|||
|
{
|
|||
|
executionMode.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 7.
|
|||
|
// TODO: Order debug information correctly.
|
|||
|
foreach (Instruction debug in _debug)
|
|||
|
{
|
|||
|
debug.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 8.
|
|||
|
foreach (Instruction annotation in _annotations)
|
|||
|
{
|
|||
|
annotation.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// Ensure that everything is in the right order in the declarations section.
|
|||
|
List<Instruction> declarations = new List<Instruction>();
|
|||
|
declarations.AddRange(_typeDeclarations.Values);
|
|||
|
declarations.AddRange(_globals);
|
|||
|
declarations.AddRange(_constants.Values);
|
|||
|
declarations.Sort((Instruction x, Instruction y) => x.Id.CompareTo(y.Id));
|
|||
|
|
|||
|
// 9.
|
|||
|
foreach (Instruction declaration in declarations)
|
|||
|
{
|
|||
|
declaration.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 10.
|
|||
|
foreach (Instruction functionDeclaration in _functionsDeclarations)
|
|||
|
{
|
|||
|
functionDeclaration.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
// 11.
|
|||
|
foreach (Instruction functionDefinition in _functionsDefinitions)
|
|||
|
{
|
|||
|
functionDefinition.Write(writer);
|
|||
|
}
|
|||
|
|
|||
|
_instPool.Clear();
|
|||
|
_integerPool.Clear();
|
|||
|
|
|||
|
LiteralInteger.UnregisterPool();
|
|||
|
|
|||
|
return stream.ToArray();
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|