sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Shader: Add SpirvDecoder

This commit is contained in:
Jérôme Leclercq 2021-04-04 20:29:23 +02:00
parent 5a63eb4d97
commit 09df5f389e
6 changed files with 194 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
include/Nazara/Shader/SpirvDecoder.hpp Normal file
View File

@ -0,0 +1,59 @@
// Copyright (C) 2020 Jérôme Leclercq
// This file is part of the "Nazara Engine - Shader generator"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_SPIRVDECODER_HPP
#define NAZARA_SPIRVDECODER_HPP
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Shader/Config.hpp>
#include <Nazara/Shader/SpirvData.hpp>
#include <functional>
#include <string>
#include <vector>
namespace Nz
{
class NAZARA_SHADER_API SpirvDecoder
{
public:
SpirvDecoder() = default;
SpirvDecoder(const SpirvDecoder&) = default;
SpirvDecoder(SpirvDecoder&&) = default;
~SpirvDecoder() = default;
void Decode(const UInt32* codepoints, std::size_t count);
SpirvDecoder& operator=(const SpirvDecoder&) = default;
SpirvDecoder& operator=(SpirvDecoder&&) = default;
protected:
struct SpirvHeader;
inline const UInt32* GetCurrentPtr() const;
virtual bool HandleHeader(const SpirvHeader& header);
virtual bool HandleOpcode(const SpirvInstruction& instruction, UInt32 wordCount) = 0;
std::string ReadString();
UInt32 ReadWord();
struct SpirvHeader
{
UInt32 generatorId;
UInt32 bound;
UInt32 schema;
UInt32 versionNumber;
};
private:
const UInt32* m_currentCodepoint;
const UInt32* m_codepointEnd;
};
}
#include <Nazara/Shader/SpirvDecoder.inl>
#endif

16
include/Nazara/Shader/SpirvDecoder.inl Normal file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2020 Jérôme Leclercq
// This file is part of the "Nazara Engine - Shader generator"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Shader/SpirvDecoder.hpp>
#include <Nazara/Shader/Debug.hpp>
namespace Nz
{
inline const UInt32* SpirvDecoder::GetCurrentPtr() const
{
return m_currentCodepoint;
}
}
#include <Nazara/Shader/DebugOff.hpp>

8
include/Nazara/Shader/SpirvPrinter.hpp
View File

@ -9,12 +9,13 @@
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Shader/Config.hpp>
#include <Nazara/Shader/SpirvDecoder.hpp>
#include <string>
#include <vector>
namespace Nz
{
class NAZARA_SHADER_API SpirvPrinter
class NAZARA_SHADER_API SpirvPrinter : SpirvDecoder
{
public:
struct Settings;
@ -39,9 +40,8 @@ namespace Nz
};
private:
void AppendInstruction();
std::string ReadString();
UInt32 ReadWord();
bool HandleHeader(const SpirvHeader& header) override;
bool HandleOpcode(const SpirvInstruction& instruction, UInt32 wordCount) override;
struct State;

4
include/Nazara/Shader/SpirvWriter.hpp
View File

@ -9,8 +9,8 @@
#include <Nazara/Prerequisites.hpp>
#include <Nazara/Shader/Config.hpp>
#include <Nazara/Shader/ShaderAstCache.hpp>
#include <Nazara/Shader/ShaderConstantValue.hpp>
#include <Nazara/Shader/ShaderNodes.hpp>
#include <Nazara/Shader/ShaderWriter.hpp>
#include <Nazara/Shader/SpirvConstantCache.hpp>
#include <string>
@ -90,9 +90,7 @@ namespace Nz
struct Context
{
ShaderAst::AstCache cache;
const States* states = nullptr;
std::vector<SpirvBlock> functionBlocks;
};
struct ExtVar

87
src/Nazara/Shader/SpirvDecoder.cpp Normal file
View File

@ -0,0 +1,87 @@
// Copyright (C) 2020 Jérôme Leclercq
// This file is part of the "Nazara Engine - Shader generator"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Shader/SpirvDecoder.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/StackArray.hpp>
#include <Nazara/Shader/SpirvData.hpp>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <Nazara/Shader/Debug.hpp>
namespace Nz
{
void SpirvDecoder::Decode(const UInt32* codepoints, std::size_t count)
{
m_currentCodepoint = codepoints;
m_codepointEnd = codepoints + count;
UInt32 magicNumber = ReadWord();
if (magicNumber != SpirvMagicNumber)
throw std::runtime_error("invalid Spir-V: magic number didn't match");
UInt32 versionNumber = ReadWord();
if (versionNumber > SpirvVersion)
throw std::runtime_error("Spir-V is more recent than decoder, dismissing");
SpirvHeader header;
header.generatorId = ReadWord();
header.bound = ReadWord();
header.schema = ReadWord();
header.versionNumber = versionNumber;
if (!HandleHeader(header))
return;
while (m_currentCodepoint < m_codepointEnd)
{
UInt32 firstWord = ReadWord();
UInt16 wordCount = static_cast<UInt16>((firstWord >> 16) & 0xFFFF);
UInt16 opcode = static_cast<UInt16>(firstWord & 0xFFFF);
const SpirvInstruction* inst = GetInstructionData(opcode);
if (!inst)
throw std::runtime_error("invalid instruction");
if (!HandleOpcode(*inst, wordCount))
break;
m_currentCodepoint += wordCount - 1;
}
}
bool SpirvDecoder::HandleHeader(const SpirvHeader& /*header*/)
{
return true;
}
std::string SpirvDecoder::ReadString()
{
std::string str;
for (;;)
{
UInt32 value = ReadWord();
for (std::size_t j = 0; j < 4; ++j)
{
char c = static_cast<char>((value >> (j * 8)) & 0xFF);
if (c == '\0')
return str;
str.push_back(c);
}
}
}
UInt32 SpirvDecoder::ReadWord()
{
if (m_currentCodepoint >= m_codepointEnd)
throw std::runtime_error("unexpected end of stream");
return *m_currentCodepoint++;
}
}

110
src/Nazara/Shader/SpirvPrinter.cpp
View File

@ -21,10 +21,7 @@ namespace Nz
{
}
const UInt32* codepoints;
std::size_t resultOffset;
std::size_t index = 0;
std::size_t count;
std::ostringstream stream;
const Settings& settings;
};
@ -32,71 +29,49 @@ namespace Nz
std::string SpirvPrinter::Print(const UInt32* codepoints, std::size_t count, const Settings& settings)
{
State state(settings);
state.codepoints = codepoints;
state.count = count;
m_currentState = &state;
CallOnExit resetOnExit([&] { m_currentState = nullptr; });
UInt32 magicNumber = ReadWord();
if (magicNumber != SpirvMagicNumber)
throw std::runtime_error("invalid Spir-V: magic number didn't match");
if (m_currentState->settings.printHeader)
m_currentState->stream << "Spir-V module\n";
UInt32 versionNumber = ReadWord();
if (versionNumber > SpirvVersion)
throw std::runtime_error("Spir-V is more recent than printer, dismissing");
UInt8 majorVersion = ((versionNumber) >> 16) & 0xFF;
UInt8 minorVersion = ((versionNumber) >> 8) & 0xFF;
UInt32 generatorId = ReadWord();
UInt32 bound = ReadWord();
UInt32 schema = ReadWord();
state.resultOffset = std::snprintf(nullptr, 0, "%%%u = ", bound);
if (m_currentState->settings.printHeader)
{
m_currentState->stream << "Version " + std::to_string(+majorVersion) << "." << std::to_string(+minorVersion) << "\n";
m_currentState->stream << "Generator: " << std::to_string(generatorId) << "\n";
m_currentState->stream << "Bound: " << std::to_string(bound) << "\n";
m_currentState->stream << "Schema: " << std::to_string(schema) << "\n";
}
while (m_currentState->index < m_currentState->count)
AppendInstruction();
Decode(codepoints, count);
return m_currentState->stream.str();
}
void SpirvPrinter::AppendInstruction()
bool SpirvPrinter::HandleHeader(const SpirvHeader& header)
{
std::size_t startIndex = m_currentState->index;
UInt8 majorVersion = ((header.versionNumber) >> 16) & 0xFF;
UInt8 minorVersion = ((header.versionNumber) >> 8) & 0xFF;
UInt32 firstWord = ReadWord();
m_currentState->resultOffset = std::snprintf(nullptr, 0, "%%%u = ", header.bound);
UInt16 wordCount = static_cast<UInt16>((firstWord >> 16) & 0xFFFF);
UInt16 opcode = static_cast<UInt16>(firstWord & 0xFFFF);
if (m_currentState->settings.printHeader)
{
m_currentState->stream << "Version " + std::to_string(+majorVersion) << "." << std::to_string(+minorVersion) << "\n";
m_currentState->stream << "Generator: " << std::to_string(header.generatorId) << "\n";
m_currentState->stream << "Bound: " << std::to_string(header.bound) << "\n";
m_currentState->stream << "Schema: " << std::to_string(header.schema) << "\n";
}
const SpirvInstruction* inst = GetInstructionData(opcode);
if (!inst)
throw std::runtime_error("invalid instruction");
return true;
}
bool SpirvPrinter::HandleOpcode(const SpirvInstruction& instruction, UInt32 wordCount)
{
const UInt32* startPtr = GetCurrentPtr();
if (m_currentState->settings.printParameters)
{
std::ostringstream instructionStream;
instructionStream << inst->name;
instructionStream << instruction.name;
UInt32 resultId = 0;
std::size_t currentOperand = 0;
std::size_t instructionEnd = startIndex + wordCount;
while (m_currentState->index < instructionEnd)
const UInt32* endPtr = startPtr + wordCount;
while (GetCurrentPtr() < endPtr)
{
const SpirvInstruction::Operand* operand = &inst->operands[currentOperand];
const SpirvInstruction::Operand* operand = &instruction.operands[currentOperand];
if (operand->kind != SpirvOperandKind::IdResult)
{
@ -181,7 +156,7 @@ namespace Nz
break;
}
case SpirvOperandKind::PairLiteralIntegerIdRef:
{
ReadWord();
@ -210,13 +185,12 @@ namespace Nz
default:
break;
}
}
else
resultId = ReadWord();
if (currentOperand < inst->minOperandCount - 1)
if (currentOperand < instruction.minOperandCount - 1)
currentOperand++;
}
@ -231,42 +205,12 @@ namespace Nz
m_currentState->stream << instructionStream.str();
}
else
{
m_currentState->stream << inst->name;
m_currentState->index += wordCount - 1;
if (m_currentState->index > m_currentState->count)
throw std::runtime_error("unexpected end of stream");
}
m_currentState->stream << instruction.name;
m_currentState->stream << "\n";
assert(m_currentState->index == startIndex + wordCount);
}
assert(GetCurrentPtr() == startPtr + wordCount);
std::string SpirvPrinter::ReadString()
{
std::string str;
for (;;)
{
UInt32 value = ReadWord();
for (std::size_t j = 0; j < 4; ++j)
{
char c = static_cast<char>((value >> (j * 8)) & 0xFF);
if (c == '\0')
return str;
str.push_back(c);
}
}
}
UInt32 SpirvPrinter::ReadWord()
{
if (m_currentState->index >= m_currentState->count)
throw std::runtime_error("unexpected end of stream");
return m_currentState->codepoints[m_currentState->index++];
return true;
}
}