scratchfoundation/bgfx
1
0
Fork 0
mirror of https://github.com/scratchfoundation/bgfx.git synced 2025-03-23 05:15:28 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Spir-V WIP.

Browse source
This commit is contained in:
Branimir Karadžić 2016-03-05 00:17:06 -08:00
parent 5fab86f3ef
commit e14c5b1c3e
8 changed files with 909 additions and 613 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/renderer_d3d11.cpp
View file

@ -3728,8 +3728,9 @@ BX_PRAGMA_DIAGNOSTIC_POP();
{ {
bx::MemoryReader rd(_code, _size); bx::MemoryReader rd(_code, _size);
bx::Error err;
DxbcContext dxbc; DxbcContext dxbc;
read(&rd, dxbc); read(&rd, dxbc, &err);
struct FindDepthOp struct FindDepthOp
{ {

7
src/renderer_d3d12.cpp
View file

@ -2238,7 +2238,8 @@ data.NumQualityLevels = 0;
bx::StaticMemoryBlockWriter wr(temp->data, temp->size); bx::StaticMemoryBlockWriter wr(temp->data, temp->size);
DxbcContext dxbc; DxbcContext dxbc;
read(&rd, dxbc); bx::Error err;
read(&rd, dxbc, &err);
bool patchShader = true; bool patchShader = true;
if (BX_ENABLED(BGFX_CONFIG_DEBUG) ) if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
@ -2246,7 +2247,7 @@ data.NumQualityLevels = 0;
union { uint32_t offset; void* ptr; } cast = { 0 }; union { uint32_t offset; void* ptr; } cast = { 0 };
filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr); filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr);
write(&wr, dxbc); write(&wr, dxbc, &err);
dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4); dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4);
@ -2280,7 +2281,7 @@ data.NumQualityLevels = 0;
uint32_t(program.m_vsh->m_size)/16 uint32_t(program.m_vsh->m_size)/16
}; };
filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr); filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr);
write(&wr, dxbc); write(&wr, dxbc, &err);
dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4); dxbcHash(temp->data + 20, temp->size - 20, temp->data + 4);
desc.PS.pShaderBytecode = temp->data; desc.PS.pShaderBytecode = temp->data;

92
src/shader_dx9bc.cpp
View file

@ -274,12 +274,12 @@ namespace bgfx
}; };
BX_STATIC_ASSERT(BX_COUNTOF(s_dx9bcDeclUsage) == Dx9bcDeclUsage::Count); BX_STATIC_ASSERT(BX_COUNTOF(s_dx9bcDeclUsage) == Dx9bcDeclUsage::Count);
int32_t read(bx::ReaderI* _reader, Dx9bcSubOperand& _subOperand) int32_t read(bx::ReaderI* _reader, Dx9bcSubOperand& _subOperand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
uint32_t token; uint32_t token;
size += bx::read(_reader, token); size += bx::read(_reader, token, _err);
_subOperand.type = Dx9bcOperandType::Enum( ( (token & UINT32_C(0x70000000) ) >> 28) _subOperand.type = Dx9bcOperandType::Enum( ( (token & UINT32_C(0x70000000) ) >> 28)
| ( (token & UINT32_C(0x00001800) ) >> 8) ); | ( (token & UINT32_C(0x00001800) ) >> 8) );
@ -289,7 +289,7 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const Dx9bcSubOperand& _subOperand) int32_t write(bx::WriterI* _writer, const Dx9bcSubOperand& _subOperand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
@ -298,17 +298,17 @@ namespace bgfx
token |= (_subOperand.type << 8) & UINT32_C(0x00001800); token |= (_subOperand.type << 8) & UINT32_C(0x00001800);
token |= _subOperand.regIndex & UINT32_C(0x000007ff); token |= _subOperand.regIndex & UINT32_C(0x000007ff);
token |= (_subOperand.swizzleBits << 16) & UINT32_C(0x00ff0000); token |= (_subOperand.swizzleBits << 16) & UINT32_C(0x00ff0000);
size += bx::write(_writer, token); size += bx::write(_writer, token, _err);
return size; return size;
} }
int32_t read(bx::ReaderI* _reader, Dx9bcOperand& _operand) int32_t read(bx::ReaderI* _reader, Dx9bcOperand& _operand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
uint32_t token; uint32_t token;
size += bx::read(_reader, token); size += bx::read(_reader, token, _err);
_operand.type = Dx9bcOperandType::Enum( ( (token & UINT32_C(0x70000000) ) >> 28) _operand.type = Dx9bcOperandType::Enum( ( (token & UINT32_C(0x70000000) ) >> 28)
| ( (token & UINT32_C(0x00001800) ) >> 8) ); | ( (token & UINT32_C(0x00001800) ) >> 8) );
@ -339,13 +339,13 @@ namespace bgfx
if (Dx9bcOperandAddrMode::Relative == _operand.addrMode) if (Dx9bcOperandAddrMode::Relative == _operand.addrMode)
{ {
size += read(_reader, _operand.subOperand); size += read(_reader, _operand.subOperand, _err);
} }
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const Dx9bcOperand& _operand) int32_t write(bx::WriterI* _writer, const Dx9bcOperand& _operand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
@ -354,22 +354,22 @@ namespace bgfx
token |= (_operand.type << 8) & UINT32_C(0x00001800); token |= (_operand.type << 8) & UINT32_C(0x00001800);
token |= _operand.regIndex & UINT32_C(0x000007ff); token |= _operand.regIndex & UINT32_C(0x000007ff);
token |= (_operand.addrMode << 13) & UINT32_C(0x00002000); token |= (_operand.addrMode << 13) & UINT32_C(0x00002000);
size += bx::write(_writer, token); size += bx::write(_writer, token, _err);
if (Dx9bcOperandAddrMode::Relative == _operand.addrMode) if (Dx9bcOperandAddrMode::Relative == _operand.addrMode)
{ {
size += write(_writer, _operand.subOperand); size += write(_writer, _operand.subOperand, _err);
} }
return size; return size;
} }
int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction) int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
uint32_t token; uint32_t token;
size += bx::read(_reader, token); size += bx::read(_reader, token, _err);
_instruction.opcode = Dx9bcOpcode::Enum( (token & UINT32_C(0x0000ffff) ) ); _instruction.opcode = Dx9bcOpcode::Enum( (token & UINT32_C(0x0000ffff) ) );
@ -395,7 +395,7 @@ namespace bgfx
for (int32_t ii = 0, num = _instruction.length-1; ii < num; ++ii) for (int32_t ii = 0, num = _instruction.length-1; ii < num; ++ii)
{ {
uint32_t tmp; uint32_t tmp;
size += bx::read(_reader, tmp); size += bx::read(_reader, tmp, _err);
} }
} }
@ -436,24 +436,24 @@ namespace bgfx
if (valuesBeforeOpcode if (valuesBeforeOpcode
&& 0 < info.numValues) && 0 < info.numValues)
{ {
size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t) ); size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t), _err);
} }
_instruction.operand[0].destination = true; _instruction.operand[0].destination = true;
switch (_instruction.numOperands) switch (_instruction.numOperands)
{ {
case 6: size += read(_reader, _instruction.operand[currOp++]); case 6: size += read(_reader, _instruction.operand[currOp++], _err);
case 5: size += read(_reader, _instruction.operand[currOp++]); case 5: size += read(_reader, _instruction.operand[currOp++], _err);
case 4: size += read(_reader, _instruction.operand[currOp++]); case 4: size += read(_reader, _instruction.operand[currOp++], _err);
case 3: size += read(_reader, _instruction.operand[currOp++]); case 3: size += read(_reader, _instruction.operand[currOp++], _err);
case 2: size += read(_reader, _instruction.operand[currOp++]); case 2: size += read(_reader, _instruction.operand[currOp++], _err);
case 1: size += read(_reader, _instruction.operand[currOp++]); case 1: size += read(_reader, _instruction.operand[currOp++], _err);
case 0: case 0:
if (!valuesBeforeOpcode if (!valuesBeforeOpcode
&& 0 < info.numValues) && 0 < info.numValues)
{ {
size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t) ); size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t), _err);
} }
break; break;
@ -469,7 +469,7 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction) int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
@ -477,17 +477,17 @@ namespace bgfx
token |= _instruction.opcode & UINT32_C(0x0000ffff); token |= _instruction.opcode & UINT32_C(0x0000ffff);
token |= (_instruction.specific << 16) & UINT32_C(0x00ff0000); token |= (_instruction.specific << 16) & UINT32_C(0x00ff0000);
token |= ( (_instruction.length - 1) << 24) & UINT32_C(0x0f000000); token |= ( (_instruction.length - 1) << 24) & UINT32_C(0x0f000000);
size += bx::write(_writer, token); size += bx::write(_writer, token, _err);
uint32_t currOp = 0; uint32_t currOp = 0;
switch (_instruction.numOperands) switch (_instruction.numOperands)
{ {
case 6: size += write(_writer, _instruction.operand[currOp++]); case 6: size += write(_writer, _instruction.operand[currOp++], _err);
case 5: size += write(_writer, _instruction.operand[currOp++]); case 5: size += write(_writer, _instruction.operand[currOp++], _err);
case 4: size += write(_writer, _instruction.operand[currOp++]); case 4: size += write(_writer, _instruction.operand[currOp++], _err);
case 3: size += write(_writer, _instruction.operand[currOp++]); case 3: size += write(_writer, _instruction.operand[currOp++], _err);
case 2: size += write(_writer, _instruction.operand[currOp++]); case 2: size += write(_writer, _instruction.operand[currOp++], _err);
case 1: size += write(_writer, _instruction.operand[currOp++]); case 1: size += write(_writer, _instruction.operand[currOp++], _err);
case 0: case 0:
break; break;
} }
@ -626,7 +626,7 @@ namespace bgfx
return size; return size;
} }
int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader) int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
int64_t offset = bx::seek(_reader); int64_t offset = bx::seek(_reader);
@ -634,7 +634,7 @@ namespace bgfx
for (;;) for (;;)
{ {
Dx9bcInstruction instruction; Dx9bcInstruction instruction;
int32_t length = read(_reader, instruction); int32_t length = read(_reader, instruction, _err);
size += length; size += length;
if (Dx9bcOpcode::Count > instruction.opcode) if (Dx9bcOpcode::Count > instruction.opcode)
@ -662,22 +662,22 @@ namespace bgfx
bx::seek(_reader, offset, bx::Whence::Begin); bx::seek(_reader, offset, bx::Whence::Begin);
_shader.byteCode.resize(size); _shader.byteCode.resize(size);
bx::read(_reader, _shader.byteCode.data(), size); bx::read(_reader, _shader.byteCode.data(), size, _err);
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader) int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader, bx::Error* _err)
{ {
BX_UNUSED(_writer, _shader); BX_UNUSED(_writer, _shader, _err);
return 0; return 0;
} }
int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _bc) int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _bc, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
size += bx::read(_reader, _bc.version); size += bx::read(_reader, _bc.version, _err);
bool pixelShader = (0xffff0000 == (_bc.version & 0xffff0000) ); bool pixelShader = (0xffff0000 == (_bc.version & 0xffff0000) );
uint32_t versionMajor = (_bc.version>>8)&0xff; uint32_t versionMajor = (_bc.version>>8)&0xff;
@ -689,27 +689,29 @@ namespace bgfx
, versionMinor , versionMinor
); );
size += read(_reader, _bc.shader); size += read(_reader, _bc.shader, _err);
return size; return size;
} }
int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dxbc) int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dxbc, bx::Error* _err)
{ {
BX_UNUSED(_writer, _dxbc); BX_UNUSED(_writer, _dxbc, _err);
return 0; return 0;
} }
void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData) void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData, bx::Error* _err)
{ {
BX_ERROR_SCOPE(_err);
bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) );
//BX_TRACE("parse %d", _src.byteCode.size()); bx::Error err;
for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;)
{ {
Dx9bcInstruction instruction; Dx9bcInstruction instruction;
uint32_t size = read(&reader, instruction); uint32_t size = read(&reader, instruction, _err);
BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size);
bool cont = _fn(token * sizeof(uint32_t), instruction, _userData); bool cont = _fn(token * sizeof(uint32_t), instruction, _userData);
@ -722,8 +724,10 @@ namespace bgfx
} }
} }
void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData) void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData, bx::Error* _err)
{ {
BX_ERROR_SCOPE(_err);
bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) );
bx::MemoryBlock mb(g_allocator); bx::MemoryBlock mb(g_allocator);
@ -732,7 +736,7 @@ namespace bgfx
for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;)
{ {
Dx9bcInstruction instruction; Dx9bcInstruction instruction;
uint32_t size = read(&reader, instruction); uint32_t size = read(&reader, instruction, _err);
BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size);
_fn(instruction, _userData); _fn(instruction, _userData);

16
src/shader_dx9bc.h
View file

@ -226,8 +226,8 @@ namespace bgfx
int32_t value[4]; int32_t value[4];
}; };
int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction); int32_t read(bx::ReaderI* _reader, Dx9bcInstruction& _instruction, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction); int32_t write(bx::WriterI* _writer, const Dx9bcInstruction& _instruction, bx::Error* _err);
int32_t toString(char* _out, int32_t _size, const Dx9bcInstruction& _instruction); int32_t toString(char* _out, int32_t _size, const Dx9bcInstruction& _instruction);
struct Dx9bcShader struct Dx9bcShader
@ -235,8 +235,8 @@ namespace bgfx
stl::vector<uint8_t> byteCode; stl::vector<uint8_t> byteCode;
}; };
int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader); int32_t read(bx::ReaderSeekerI* _reader, Dx9bcShader& _shader, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader); int32_t write(bx::WriterI* _writer, const Dx9bcShader& _shader, bx::Error* _err);
struct Dx9bc struct Dx9bc
{ {
@ -244,14 +244,14 @@ namespace bgfx
Dx9bcShader shader; Dx9bcShader shader;
}; };
int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _dx9bc); int32_t read(bx::ReaderSeekerI* _reader, Dx9bc& _dx9bc, bx::Error* _err);
int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dx9bc); int32_t write(bx::WriterSeekerI* _writer, const Dx9bc& _dx9bc, bx::Error* _err);
typedef bool (*Dx9bcParseFn)(uint32_t _offset, const Dx9bcInstruction& _instruction, void* _userData); typedef bool (*Dx9bcParseFn)(uint32_t _offset, const Dx9bcInstruction& _instruction, void* _userData);
void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData); void parse(const Dx9bcShader& _src, Dx9bcParseFn _fn, void* _userData, bx::Error* _err = NULL);
typedef void (*Dx9bcFilterFn)(Dx9bcInstruction& _instruction, void* _userData); typedef void (*Dx9bcFilterFn)(Dx9bcInstruction& _instruction, void* _userData);
void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData); void filter(Dx9bcShader& _dst, const Dx9bcShader& _src, Dx9bcFilterFn _fn, void* _userData, bx::Error* _err = NULL);
} // namespace bgfx } // namespace bgfx

237
src/shader_dxbc.cpp
View file

@ -552,7 +552,7 @@ namespace bgfx
#define DXBC_MAX_NAME_STRING 512 #define DXBC_MAX_NAME_STRING 512
int32_t readString(bx::ReaderSeekerI* _reader, int64_t _offset, char* _out, uint32_t _max = DXBC_MAX_NAME_STRING) int32_t readString(bx::ReaderSeekerI* _reader, int64_t _offset, char* _out, uint32_t _max, bx::Error* _err)
{ {
int64_t oldOffset = bx::seek(_reader); int64_t oldOffset = bx::seek(_reader);
bx::seek(_reader, _offset, bx::Whence::Begin); bx::seek(_reader, _offset, bx::Whence::Begin);
@ -562,7 +562,7 @@ namespace bgfx
for (uint32_t ii = 0; ii < _max-1; ++ii) for (uint32_t ii = 0; ii < _max-1; ++ii)
{ {
char ch; char ch;
size += bx::read(_reader, ch); size += bx::read(_reader, ch, _err);
*_out++ = ch; *_out++ = ch;
if ('\0' == ch) if ('\0' == ch)
@ -755,7 +755,7 @@ namespace bgfx
memcpy(_digest, hash, 16); memcpy(_digest, hash, 16);
} }
int32_t read(bx::ReaderI* _reader, DxbcSubOperand& _subOperand) int32_t read(bx::ReaderI* _reader, DxbcSubOperand& _subOperand, bx::Error* _err)
{ {
uint32_t token; uint32_t token;
int32_t size = 0; int32_t size = 0;
@ -773,7 +773,7 @@ namespace bgfx
// |+------------------------------- addressing mode 2 // |+------------------------------- addressing mode 2
// +-------------------------------- extended // +-------------------------------- extended
size += bx::read(_reader, token); size += bx::read(_reader, token, _err);
_subOperand.type = DxbcOperandType::Enum( (token & UINT32_C(0x000ff000) ) >> 12); _subOperand.type = DxbcOperandType::Enum( (token & UINT32_C(0x000ff000) ) >> 12);
_subOperand.numAddrModes = uint8_t( (token & UINT32_C(0x00300000) ) >> 20); _subOperand.numAddrModes = uint8_t( (token & UINT32_C(0x00300000) ) >> 20);
_subOperand.addrMode = uint8_t( (token & UINT32_C(0x01c00000) ) >> 22); _subOperand.addrMode = uint8_t( (token & UINT32_C(0x01c00000) ) >> 22);
@ -784,7 +784,7 @@ namespace bgfx
switch (_subOperand.addrMode) switch (_subOperand.addrMode)
{ {
case DxbcOperandAddrMode::Imm32: case DxbcOperandAddrMode::Imm32:
size += bx::read(_reader, _subOperand.regIndex); size += bx::read(_reader, _subOperand.regIndex, _err);
break; break;
case DxbcOperandAddrMode::Reg: case DxbcOperandAddrMode::Reg:
@ -796,7 +796,7 @@ namespace bgfx
case DxbcOperandAddrMode::RegImm32: case DxbcOperandAddrMode::RegImm32:
{ {
size += bx::read(_reader, _subOperand.regIndex); size += bx::read(_reader, _subOperand.regIndex, _err);
DxbcSubOperand subOperand; DxbcSubOperand subOperand;
size += read(_reader, subOperand); size += read(_reader, subOperand);
@ -805,8 +805,8 @@ namespace bgfx
case DxbcOperandAddrMode::RegImm64: case DxbcOperandAddrMode::RegImm64:
{ {
size += bx::read(_reader, _subOperand.regIndex); size += bx::read(_reader, _subOperand.regIndex, _err);
size += bx::read(_reader, _subOperand.regIndex); size += bx::read(_reader, _subOperand.regIndex, _err);
DxbcSubOperand subOperand; DxbcSubOperand subOperand;
size += read(_reader, subOperand); size += read(_reader, subOperand);
@ -821,7 +821,7 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const DxbcSubOperand& _subOperand) int32_t write(bx::WriterI* _writer, const DxbcSubOperand& _subOperand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
@ -832,12 +832,12 @@ namespace bgfx
token |= (_subOperand.mode << 2) & UINT32_C(0x0000000c); token |= (_subOperand.mode << 2) & UINT32_C(0x0000000c);
token |= (_subOperand.modeBits << 4) & UINT32_C(0x00000ff0); token |= (_subOperand.modeBits << 4) & UINT32_C(0x00000ff0);
token |= _subOperand.num & UINT32_C(0x00000003); token |= _subOperand.num & UINT32_C(0x00000003);
size += bx::write(_writer, token); size += bx::write(_writer, token, _err);
switch (_subOperand.addrMode) switch (_subOperand.addrMode)
{ {
case DxbcOperandAddrMode::Imm32: case DxbcOperandAddrMode::Imm32:
size += bx::write(_writer, _subOperand.regIndex); size += bx::write(_writer, _subOperand.regIndex, _err);
break; break;
case DxbcOperandAddrMode::Reg: case DxbcOperandAddrMode::Reg:
@ -849,7 +849,7 @@ namespace bgfx
case DxbcOperandAddrMode::RegImm32: case DxbcOperandAddrMode::RegImm32:
{ {
size += bx::write(_writer, _subOperand.regIndex); size += bx::write(_writer, _subOperand.regIndex, _err);
DxbcSubOperand subOperand; DxbcSubOperand subOperand;
size += write(_writer, subOperand); size += write(_writer, subOperand);
@ -858,8 +858,8 @@ namespace bgfx
case DxbcOperandAddrMode::RegImm64: case DxbcOperandAddrMode::RegImm64:
{ {
size += bx::write(_writer, _subOperand.regIndex); size += bx::write(_writer, _subOperand.regIndex, _err);
size += bx::write(_writer, _subOperand.regIndex); size += bx::write(_writer, _subOperand.regIndex, _err);
DxbcSubOperand subOperand; DxbcSubOperand subOperand;
size += write(_writer, subOperand); size += write(_writer, subOperand);
@ -874,12 +874,12 @@ namespace bgfx
return size; return size;
} }
int32_t read(bx::ReaderI* _reader, DxbcOperand& _operand) int32_t read(bx::ReaderI* _reader, DxbcOperand& _operand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
uint32_t token; uint32_t token;
size += bx::read(_reader, token); size += bx::read(_reader, token, _err);
// 0 1 2 3 // 0 1 2 3
// 76543210765432107654321076543210 // 76543210765432107654321076543210
@ -906,7 +906,7 @@ namespace bgfx
if (_operand.extended) if (_operand.extended)
{ {
size += bx::read(_reader, _operand.extBits); size += bx::read(_reader, _operand.extBits, _err);
} }
switch (_operand.type) switch (_operand.type)
@ -915,7 +915,7 @@ namespace bgfx
_operand.num = 2 == _operand.num ? 4 : _operand.num; _operand.num = 2 == _operand.num ? 4 : _operand.num;
for (uint32_t ii = 0; ii < _operand.num; ++ii) for (uint32_t ii = 0; ii < _operand.num; ++ii)
{ {
size += bx::read(_reader, _operand.un.imm32[ii]); size += bx::read(_reader, _operand.un.imm32[ii], _err);
} }
break; break;
@ -923,7 +923,7 @@ namespace bgfx
_operand.num = 2 == _operand.num ? 4 : _operand.num; _operand.num = 2 == _operand.num ? 4 : _operand.num;
for (uint32_t ii = 0; ii < _operand.num; ++ii) for (uint32_t ii = 0; ii < _operand.num; ++ii)
{ {
size += bx::read(_reader, _operand.un.imm64[ii]); size += bx::read(_reader, _operand.un.imm64[ii], _err);
} }
break; break;
@ -936,16 +936,16 @@ namespace bgfx
switch (_operand.addrMode[ii]) switch (_operand.addrMode[ii])
{ {
case DxbcOperandAddrMode::Imm32: case DxbcOperandAddrMode::Imm32:
size += bx::read(_reader, _operand.regIndex[ii]); size += bx::read(_reader, _operand.regIndex[ii], _err);
break; break;
case DxbcOperandAddrMode::Reg: case DxbcOperandAddrMode::Reg:
size += read(_reader, _operand.subOperand[ii]); size += read(_reader, _operand.subOperand[ii], _err);
break; break;
case DxbcOperandAddrMode::RegImm32: case DxbcOperandAddrMode::RegImm32:
size += bx::read(_reader, _operand.regIndex[ii]); size += bx::read(_reader, _operand.regIndex[ii], _err);
size += read(_reader, _operand.subOperand[ii]); size += read(_reader, _operand.subOperand[ii], _err);
break; break;
default: default:
@ -957,7 +957,7 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const DxbcOperand& _operand) int32_t write(bx::WriterI* _writer, const DxbcOperand& _operand, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
@ -973,7 +973,7 @@ namespace bgfx
token |= (4 == _operand.num ? 2 : _operand.num) & UINT32_C(0x00000003); token |= (4 == _operand.num ? 2 : _operand.num) & UINT32_C(0x00000003);
token |= ( (_operand.modeBits & "\x0f\xff\x03\x00"[_operand.mode]) << 4) & UINT32_C(0x00000ff0); token |= ( (_operand.modeBits & "\x0f\xff\x03\x00"[_operand.mode]) << 4) & UINT32_C(0x00000ff0);
size += bx::write(_writer, token); size += bx::write(_writer, token, _err);
if (_operand.extended) if (_operand.extended)
{ {
@ -985,14 +985,14 @@ namespace bgfx
case DxbcOperandType::Imm32: case DxbcOperandType::Imm32:
for (uint32_t ii = 0; ii < _operand.num; ++ii) for (uint32_t ii = 0; ii < _operand.num; ++ii)
{ {
size += bx::write(_writer, _operand.un.imm32[ii]); size += bx::write(_writer, _operand.un.imm32[ii], _err);
} }
break; break;
case DxbcOperandType::Imm64: case DxbcOperandType::Imm64:
for (uint32_t ii = 0; ii < _operand.num; ++ii) for (uint32_t ii = 0; ii < _operand.num; ++ii)
{ {
size += bx::write(_writer, _operand.un.imm64[ii]); size += bx::write(_writer, _operand.un.imm64[ii], _err);
} }
break; break;
@ -1005,16 +1005,16 @@ namespace bgfx
switch (_operand.addrMode[ii]) switch (_operand.addrMode[ii])
{ {
case DxbcOperandAddrMode::Imm32: case DxbcOperandAddrMode::Imm32:
size += bx::write(_writer, _operand.regIndex[ii]); size += bx::write(_writer, _operand.regIndex[ii], _err);
break; break;
case DxbcOperandAddrMode::Reg: case DxbcOperandAddrMode::Reg:
size += write(_writer, _operand.subOperand[ii]); size += write(_writer, _operand.subOperand[ii], _err);
break; break;
case DxbcOperandAddrMode::RegImm32: case DxbcOperandAddrMode::RegImm32:
size += bx::write(_writer, _operand.regIndex[ii]); size += bx::write(_writer, _operand.regIndex[ii], _err);
size += write(_writer, _operand.subOperand[ii]); size += write(_writer, _operand.subOperand[ii], _err);
break; break;
default: default:
@ -1026,12 +1026,12 @@ namespace bgfx
return size; return size;
} }
int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction) int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction, bx::Error* _err)
{ {
uint32_t size = 0; uint32_t size = 0;
uint32_t token; uint32_t token;
size += bx::read(_reader, token); size += bx::read(_reader, token, _err);
// 0 1 2 3 // 0 1 2 3
// 76543210765432107654321076543210 // 76543210765432107654321076543210
@ -1077,7 +1077,7 @@ namespace bgfx
for (uint32_t ii = 0, num = (_instruction.length-2)/4; ii < num; ++ii) for (uint32_t ii = 0, num = (_instruction.length-2)/4; ii < num; ++ii)
{ {
char temp[16]; char temp[16];
size += bx::read(_reader, temp, 16); size += bx::read(_reader, temp, 16, _err);
} }
} }
@ -1190,7 +1190,7 @@ namespace bgfx
uint32_t extBits; uint32_t extBits;
size += bx::read(_reader, extBits); size += bx::read(_reader, extBits);
extended = 0 != (extBits & UINT32_C(0x80000000) ); extended = 0 != (extBits & UINT32_C(0x80000000) );
_instruction.extended[ii] = DxbcInstruction::ExtendedType::Enum(extBits & UINT32_C(0x0000001f) ); _instruction.extended[ii ] = DxbcInstruction::ExtendedType::Enum(extBits & UINT32_C(0x0000001f) );
_instruction.extended[ii+1] = DxbcInstruction::ExtendedType::Count; _instruction.extended[ii+1] = DxbcInstruction::ExtendedType::Count;
switch (_instruction.extended[ii]) switch (_instruction.extended[ii])
@ -1244,7 +1244,7 @@ namespace bgfx
case DxbcOpcode::DCL_FUNCTION_TABLE: case DxbcOpcode::DCL_FUNCTION_TABLE:
{ {
uint32_t tableId; uint32_t tableId;
size += read(_reader, tableId); size += read(_reader, tableId, _err);
uint32_t num; uint32_t num;
size += read(_reader, num); size += read(_reader, num);
@ -1252,7 +1252,7 @@ namespace bgfx
for (uint32_t ii = 0; ii < num; ++ii) for (uint32_t ii = 0; ii < num; ++ii)
{ {
uint32_t bodyId; uint32_t bodyId;
size += read(_reader, bodyId); size += read(_reader, bodyId, _err);
} }
} }
break; break;
@ -1260,10 +1260,10 @@ namespace bgfx
case DxbcOpcode::DCL_INTERFACE: case DxbcOpcode::DCL_INTERFACE:
{ {
uint32_t interfaceId; uint32_t interfaceId;
size += read(_reader, interfaceId); size += read(_reader, interfaceId, _err);
uint32_t num; uint32_t num;
size += read(_reader, num); size += read(_reader, num, _err);
BX_CHECK(false, "not implemented."); BX_CHECK(false, "not implemented.");
} }
@ -1279,16 +1279,16 @@ namespace bgfx
_instruction.numOperands = info.numOperands; _instruction.numOperands = info.numOperands;
switch (info.numOperands) switch (info.numOperands)
{ {
case 6: size += read(_reader, _instruction.operand[currOp++]); case 6: size += read(_reader, _instruction.operand[currOp++], _err);
case 5: size += read(_reader, _instruction.operand[currOp++]); case 5: size += read(_reader, _instruction.operand[currOp++], _err);
case 4: size += read(_reader, _instruction.operand[currOp++]); case 4: size += read(_reader, _instruction.operand[currOp++], _err);
case 3: size += read(_reader, _instruction.operand[currOp++]); case 3: size += read(_reader, _instruction.operand[currOp++], _err);
case 2: size += read(_reader, _instruction.operand[currOp++]); case 2: size += read(_reader, _instruction.operand[currOp++], _err);
case 1: size += read(_reader, _instruction.operand[currOp++]); case 1: size += read(_reader, _instruction.operand[currOp++], _err);
case 0: case 0:
if (0 < info.numValues) if (0 < info.numValues)
{ {
size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t) ); size += read(_reader, _instruction.value, info.numValues*sizeof(uint32_t), _err);
} }
break; break;
@ -1304,7 +1304,7 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction) int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction, bx::Error* _err)
{ {
uint32_t token = 0; uint32_t token = 0;
token |= (_instruction.opcode ) & UINT32_C(0x000007ff); token |= (_instruction.opcode ) & UINT32_C(0x000007ff);
@ -1366,7 +1366,7 @@ namespace bgfx
uint32_t size =0; uint32_t size =0;
size += bx::write(_writer, token); size += bx::write(_writer, token);
;
for (uint32_t ii = 0; _instruction.extended[ii] != DxbcInstruction::ExtendedType::Count; ++ii) for (uint32_t ii = 0; _instruction.extended[ii] != DxbcInstruction::ExtendedType::Count; ++ii)
{ {
// 0 1 2 3 // 0 1 2 3
@ -1427,18 +1427,18 @@ namespace bgfx
break; break;
} }
size += bx::write(_writer, token); size += bx::write(_writer, token, _err);
} }
for (uint32_t ii = 0; ii < _instruction.numOperands; ++ii) for (uint32_t ii = 0; ii < _instruction.numOperands; ++ii)
{ {
size += write(_writer, _instruction.operand[ii]); size += write(_writer, _instruction.operand[ii], _err);
} }
const DxbcOpcodeInfo& info = s_dxbcOpcodeInfo[_instruction.opcode]; const DxbcOpcodeInfo& info = s_dxbcOpcodeInfo[_instruction.opcode];
if (0 < info.numValues) if (0 < info.numValues)
{ {
size += bx::write(_writer, _instruction.value, info.numValues*sizeof(uint32_t) ); size += bx::write(_writer, _instruction.value, info.numValues*sizeof(uint32_t), _err);
} }
return size; return size;
@ -1609,15 +1609,15 @@ namespace bgfx
return size; return size;
} }
int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature) int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
int64_t offset = bx::seek(_reader); int64_t offset = bx::seek(_reader);
uint32_t num; uint32_t num;
size += bx::read(_reader, num); size += bx::read(_reader, num, _err);
size += bx::read(_reader, _signature.key); size += bx::read(_reader, _signature.key, _err);
for (uint32_t ii = 0; ii < num; ++ii) for (uint32_t ii = 0; ii < num; ++ii)
{ {
@ -1627,20 +1627,20 @@ namespace bgfx
size += bx::read(_reader, nameOffset); size += bx::read(_reader, nameOffset);
char name[DXBC_MAX_NAME_STRING]; char name[DXBC_MAX_NAME_STRING];
readString(_reader, offset + nameOffset, name); readString(_reader, offset + nameOffset, name, DXBC_MAX_NAME_STRING, _err);
element.name = name; element.name = name;
size += bx::read(_reader, element.semanticIndex); size += bx::read(_reader, element.semanticIndex, _err);
size += bx::read(_reader, element.valueType); size += bx::read(_reader, element.valueType, _err);
size += bx::read(_reader, element.componentType); size += bx::read(_reader, element.componentType, _err);
size += bx::read(_reader, element.registerIndex); size += bx::read(_reader, element.registerIndex, _err);
size += bx::read(_reader, element.mask); size += bx::read(_reader, element.mask, _err);
size += bx::read(_reader, element.readWriteMask); size += bx::read(_reader, element.readWriteMask, _err);
size += bx::read(_reader, element.stream); size += bx::read(_reader, element.stream, _err);
// padding // padding
uint8_t padding; uint8_t padding;
size += bx::read(_reader, padding); size += bx::read(_reader, padding, _err);
_signature.elements.push_back(element); _signature.elements.push_back(element);
} }
@ -1648,13 +1648,13 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature) int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
const uint32_t num = uint32_t(_signature.elements.size() ); const uint32_t num = uint32_t(_signature.elements.size() );
size += bx::write(_writer, num); size += bx::write(_writer, num, _err);
size += bx::write(_writer, _signature.key); size += bx::write(_writer, _signature.key, _err);
typedef stl::unordered_map<stl::string, uint32_t> NameOffsetMap; typedef stl::unordered_map<stl::string, uint32_t> NameOffsetMap;
NameOffsetMap nom; NameOffsetMap nom;
@ -1669,7 +1669,7 @@ namespace bgfx
if (it == nom.end() ) if (it == nom.end() )
{ {
nom.insert(stl::make_pair(element.name, nameOffset) ); nom.insert(stl::make_pair(element.name, nameOffset) );
size += bx::write(_writer, nameOffset); size += bx::write(_writer, nameOffset, _err);
nameOffset += uint32_t(element.name.size() + 1); nameOffset += uint32_t(element.name.size() + 1);
} }
else else
@ -1677,15 +1677,14 @@ namespace bgfx
size += bx::write(_writer, it->second); size += bx::write(_writer, it->second);
} }
size += bx::write(_writer, element.semanticIndex); size += bx::write(_writer, element.semanticIndex, _err);
size += bx::write(_writer, element.valueType); size += bx::write(_writer, element.valueType, _err);
size += bx::write(_writer, element.componentType); size += bx::write(_writer, element.componentType, _err);
size += bx::write(_writer, element.registerIndex); size += bx::write(_writer, element.registerIndex, _err);
size += bx::write(_writer, element.mask); size += bx::write(_writer, element.mask, _err);
size += bx::write(_writer, element.readWriteMask); size += bx::write(_writer, element.readWriteMask, _err);
size += bx::write(_writer, element.stream); size += bx::write(_writer, element.stream, _err);
size += bx::write(_writer, pad); size += bx::write(_writer, pad, _err);
} }
uint32_t len = 0; uint32_t len = 0;
@ -1696,42 +1695,42 @@ namespace bgfx
if (it != nom.end() ) if (it != nom.end() )
{ {
nom.erase(it); nom.erase(it);
size += bx::write(_writer, element.name.c_str(), uint32_t(element.name.size() + 1) ); size += bx::write(_writer, element.name.c_str(), uint32_t(element.name.size() + 1), _err);
len += uint32_t(element.name.size() + 1); len += uint32_t(element.name.size() + 1);
} }
} }
// align 4 bytes // align 4 bytes
size += bx::writeRep(_writer, 0xab, (len+3)/4*4 - len); size += bx::writeRep(_writer, 0xab, (len+3)/4*4 - len, _err);
return size; return size;
} }
int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader) int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
size += bx::read(_reader, _shader.version); size += bx::read(_reader, _shader.version, _err);
uint32_t bcLength; uint32_t bcLength;
size += bx::read(_reader, bcLength); size += bx::read(_reader, bcLength, _err);
uint32_t len = (bcLength-2)*sizeof(uint32_t); uint32_t len = (bcLength-2)*sizeof(uint32_t);
_shader.byteCode.resize(len); _shader.byteCode.resize(len);
size += bx::read(_reader, _shader.byteCode.data(), len); size += bx::read(_reader, _shader.byteCode.data(), len, _err);
return size; return size;
} }
int32_t write(bx::WriterI* _writer, const DxbcShader& _shader) int32_t write(bx::WriterI* _writer, const DxbcShader& _shader, bx::Error* _err)
{ {
const uint32_t len = uint32_t(_shader.byteCode.size() ); const uint32_t len = uint32_t(_shader.byteCode.size() );
const uint32_t bcLength = len / sizeof(uint32_t) + 2; const uint32_t bcLength = len / sizeof(uint32_t) + 2;
int32_t size = 0; int32_t size = 0;
size += bx::write(_writer, _shader.version); size += bx::write(_writer, _shader.version, _err);
size += bx::write(_writer, bcLength); size += bx::write(_writer, bcLength, _err);
size += bx::write(_writer, _shader.byteCode.data(), len); size += bx::write(_writer, _shader.byteCode.data(), len, _err);
return size; return size;
} }
@ -1743,10 +1742,10 @@ namespace bgfx
#define DXBC_CHUNK_INPUT_SIGNATURE BX_MAKEFOURCC('I', 'S', 'G', 'N') #define DXBC_CHUNK_INPUT_SIGNATURE BX_MAKEFOURCC('I', 'S', 'G', 'N')
#define DXBC_CHUNK_OUTPUT_SIGNATURE BX_MAKEFOURCC('O', 'S', 'G', 'N') #define DXBC_CHUNK_OUTPUT_SIGNATURE BX_MAKEFOURCC('O', 'S', 'G', 'N')
int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc) int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
size += bx::read(_reader, _dxbc.header); size += bx::read(_reader, _dxbc.header, _err);
_dxbc.shader.shex = false; _dxbc.shader.shex = false;
for (uint32_t ii = 0; ii < _dxbc.header.numChunks; ++ii) for (uint32_t ii = 0; ii < _dxbc.header.numChunks; ++ii)
@ -1754,15 +1753,15 @@ namespace bgfx
bx::seek(_reader, sizeof(DxbcContext::Header) + ii*sizeof(uint32_t), bx::Whence::Begin); bx::seek(_reader, sizeof(DxbcContext::Header) + ii*sizeof(uint32_t), bx::Whence::Begin);
uint32_t chunkOffset; uint32_t chunkOffset;
size += bx::read(_reader, chunkOffset); size += bx::read(_reader, chunkOffset, _err);
bx::seek(_reader, chunkOffset, bx::Whence::Begin); bx::seek(_reader, chunkOffset, bx::Whence::Begin);
uint32_t fourcc; uint32_t fourcc;
size += bx::read(_reader, fourcc); size += bx::read(_reader, fourcc, _err);
uint32_t chunkSize; uint32_t chunkSize;
size += bx::read(_reader, chunkSize); size += bx::read(_reader, chunkSize, _err);
switch (fourcc) switch (fourcc)
{ {
@ -1771,18 +1770,18 @@ namespace bgfx
// fallthrough // fallthrough
case DXBC_CHUNK_SHADER: case DXBC_CHUNK_SHADER:
size += read(_reader, _dxbc.shader); size += read(_reader, _dxbc.shader, _err);
break; break;
case BX_MAKEFOURCC('I', 'S', 'G', '1'): case BX_MAKEFOURCC('I', 'S', 'G', '1'):
case DXBC_CHUNK_INPUT_SIGNATURE: case DXBC_CHUNK_INPUT_SIGNATURE:
size += read(_reader, _dxbc.inputSignature); size += read(_reader, _dxbc.inputSignature, _err);
break; break;
case BX_MAKEFOURCC('O', 'S', 'G', '1'): case BX_MAKEFOURCC('O', 'S', 'G', '1'):
case BX_MAKEFOURCC('O', 'S', 'G', '5'): case BX_MAKEFOURCC('O', 'S', 'G', '5'):
case DXBC_CHUNK_OUTPUT_SIGNATURE: case DXBC_CHUNK_OUTPUT_SIGNATURE:
size += read(_reader, _dxbc.outputSignature); size += read(_reader, _dxbc.outputSignature, _err);
break; break;
case BX_MAKEFOURCC('A', 'o', 'n', '9'): // Contains DX9BC for feature level 9.x (*s_4_0_level_9_*) shaders. case BX_MAKEFOURCC('A', 'o', 'n', '9'): // Contains DX9BC for feature level 9.x (*s_4_0_level_9_*) shaders.
@ -1816,43 +1815,43 @@ namespace bgfx
return size; return size;
} }
int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc) int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc, bx::Error* _err)
{ {
int32_t size = 0; int32_t size = 0;
int64_t dxbcOffset = bx::seek(_writer); int64_t dxbcOffset = bx::seek(_writer);
size += bx::write(_writer, DXBC_CHUNK_HEADER); size += bx::write(_writer, DXBC_CHUNK_HEADER);
size += bx::writeRep(_writer, 0, 16); size += bx::writeRep(_writer, 0, 16, _err);
size += bx::write(_writer, UINT32_C(1) ); size += bx::write(_writer, UINT32_C(1), _err);
int64_t sizeOffset = bx::seek(_writer); int64_t sizeOffset = bx::seek(_writer);
size += bx::writeRep(_writer, 0, 4); size += bx::writeRep(_writer, 0, 4, _err);
uint32_t numChunks = 3; uint32_t numChunks = 3;
size += bx::write(_writer, numChunks); size += bx::write(_writer, numChunks, _err);
int64_t chunksOffsets = bx::seek(_writer); int64_t chunksOffsets = bx::seek(_writer);
size += bx::writeRep(_writer, 0, numChunks*sizeof(uint32_t) ); size += bx::writeRep(_writer, 0, numChunks*sizeof(uint32_t), _err);
uint32_t chunkOffset[3]; uint32_t chunkOffset[3];
uint32_t chunkSize[3]; uint32_t chunkSize[3];
chunkOffset[0] = uint32_t(bx::seek(_writer) - dxbcOffset); chunkOffset[0] = uint32_t(bx::seek(_writer) - dxbcOffset);
size += write(_writer, DXBC_CHUNK_INPUT_SIGNATURE); size += write(_writer, DXBC_CHUNK_INPUT_SIGNATURE, _err);
size += write(_writer, UINT32_C(0) ); size += write(_writer, UINT32_C(0), _err);
chunkSize[0] = write(_writer, _dxbc.inputSignature); chunkSize[0] = write(_writer, _dxbc.inputSignature, _err);
chunkOffset[1] = uint32_t(bx::seek(_writer) - dxbcOffset); chunkOffset[1] = uint32_t(bx::seek(_writer) - dxbcOffset);
size += write(_writer, DXBC_CHUNK_OUTPUT_SIGNATURE); size += write(_writer, DXBC_CHUNK_OUTPUT_SIGNATURE, _err);
size += write(_writer, UINT32_C(0) ); size += write(_writer, UINT32_C(0), _err);
chunkSize[1] = write(_writer, _dxbc.outputSignature); chunkSize[1] = write(_writer, _dxbc.outputSignature, _err);
chunkOffset[2] = uint32_t(bx::seek(_writer) - dxbcOffset); chunkOffset[2] = uint32_t(bx::seek(_writer) - dxbcOffset);
size += write(_writer, _dxbc.shader.shex ? DXBC_CHUNK_SHADER_EX : DXBC_CHUNK_SHADER); size += write(_writer, _dxbc.shader.shex ? DXBC_CHUNK_SHADER_EX : DXBC_CHUNK_SHADER, _err);
size += write(_writer, UINT32_C(0) ); size += write(_writer, UINT32_C(0), _err);
chunkSize[2] = write(_writer, _dxbc.shader); chunkSize[2] = write(_writer, _dxbc.shader, _err);
size += 0 size += 0
+ chunkSize[0] + chunkSize[0]
@ -1863,15 +1862,15 @@ namespace bgfx
int64_t eof = bx::seek(_writer); int64_t eof = bx::seek(_writer);
bx::seek(_writer, sizeOffset, bx::Whence::Begin); bx::seek(_writer, sizeOffset, bx::Whence::Begin);
bx::write(_writer, size); bx::write(_writer, size, _err);
bx::seek(_writer, chunksOffsets, bx::Whence::Begin); bx::seek(_writer, chunksOffsets, bx::Whence::Begin);
bx::write(_writer, chunkOffset, sizeof(chunkOffset) ); bx::write(_writer, chunkOffset, sizeof(chunkOffset), _err);
for (uint32_t ii = 0; ii < BX_COUNTOF(chunkOffset); ++ii) for (uint32_t ii = 0; ii < BX_COUNTOF(chunkOffset); ++ii)
{ {
bx::seek(_writer, chunkOffset[ii]+4, bx::Whence::Begin); bx::seek(_writer, chunkOffset[ii]+4, bx::Whence::Begin);
bx::write(_writer, chunkSize[ii]); bx::write(_writer, chunkSize[ii], _err);
} }
bx::seek(_writer, eof, bx::Whence::Begin); bx::seek(_writer, eof, bx::Whence::Begin);
@ -1879,14 +1878,16 @@ namespace bgfx
return size; return size;
} }
void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData) void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData, bx::Error* _err)
{ {
BX_ERROR_SCOPE(_err);
bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) );
for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;)
{ {
DxbcInstruction instruction; DxbcInstruction instruction;
uint32_t size = read(&reader, instruction); uint32_t size = read(&reader, instruction, _err);
BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size);
bool cont = _fn(token * sizeof(uint32_t), instruction, _userData); bool cont = _fn(token * sizeof(uint32_t), instruction, _userData);
@ -1899,8 +1900,10 @@ namespace bgfx
} }
} }
void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData) void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData, bx::Error* _err)
{ {
BX_ERROR_SCOPE(_err);
bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) ); bx::MemoryReader reader(_src.byteCode.data(), uint32_t(_src.byteCode.size() ) );
bx::MemoryBlock mb(g_allocator); bx::MemoryBlock mb(g_allocator);
@ -1909,12 +1912,12 @@ namespace bgfx
for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;) for (uint32_t token = 0, numTokens = uint32_t(_src.byteCode.size() / sizeof(uint32_t) ); token < numTokens;)
{ {
DxbcInstruction instruction; DxbcInstruction instruction;
uint32_t size = read(&reader, instruction); uint32_t size = read(&reader, instruction, _err);
BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size); BX_CHECK(size/4 == instruction.length, "read %d, expected %d", size/4, instruction.length); BX_UNUSED(size);
_fn(instruction, _userData); _fn(instruction, _userData);
write(&writer, instruction); write(&writer, instruction, _err);
token += instruction.length; token += instruction.length;
} }

20
src/shader_dxbc.h
View file

@ -540,8 +540,8 @@ namespace bgfx
DxbcOperand operand[6]; DxbcOperand operand[6];
}; };
int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction); int32_t read(bx::ReaderI* _reader, DxbcInstruction& _instruction, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction); int32_t write(bx::WriterI* _writer, const DxbcInstruction& _instruction, bx::Error* _err);
int32_t toString(char* _out, int32_t _size, const DxbcInstruction& _instruction); int32_t toString(char* _out, int32_t _size, const DxbcInstruction& _instruction);
struct DxbcSignature struct DxbcSignature
@ -562,8 +562,8 @@ namespace bgfx
stl::vector<Element> elements; stl::vector<Element> elements;
}; };
int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature); int32_t read(bx::ReaderSeekerI* _reader, DxbcSignature& _signature, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature); int32_t write(bx::WriterI* _writer, const DxbcSignature& _signature, bx::Error* _err);
struct DxbcShader struct DxbcShader
{ {
@ -572,14 +572,14 @@ namespace bgfx
bool shex; bool shex;
}; };
int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader); int32_t read(bx::ReaderSeekerI* _reader, DxbcShader& _shader, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const DxbcShader& _shader); int32_t write(bx::WriterI* _writer, const DxbcShader& _shader, bx::Error* _err);
typedef bool (*DxbcParseFn)(uint32_t _offset, const DxbcInstruction& _instruction, void* _userData); typedef bool (*DxbcParseFn)(uint32_t _offset, const DxbcInstruction& _instruction, void* _userData);
void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData); void parse(const DxbcShader& _src, DxbcParseFn _fn, void* _userData, bx::Error* _err = NULL);
typedef void (*DxbcFilterFn)(DxbcInstruction& _instruction, void* _userData); typedef void (*DxbcFilterFn)(DxbcInstruction& _instruction, void* _userData);
void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData); void filter(DxbcShader& _dst, const DxbcShader& _src, DxbcFilterFn _fn, void* _userData, bx::Error* _err = NULL);
struct DxbcContext struct DxbcContext
{ {
@ -598,8 +598,8 @@ namespace bgfx
DxbcShader shader; DxbcShader shader;
}; };
int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc); int32_t read(bx::ReaderSeekerI* _reader, DxbcContext& _dxbc, bx::Error* _err);
int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc); int32_t write(bx::WriterSeekerI* _writer, const DxbcContext& _dxbc, bx::Error* _err);
/// Calculate DXBC hash from data. /// Calculate DXBC hash from data.
void dxbcHash(const void* _data, uint32_t _size, void* _digest); void dxbcHash(const void* _data, uint32_t _size, void* _digest);

981
src/shader_spirv.cpp
View file

File diff suppressed because it is too large Load diff

166
src/shader_spirv.h
View file

@ -8,11 +8,14 @@
#include <bx/readerwriter.h> #include <bx/readerwriter.h>
BX_ERROR_RESULT(BGFX_SHADER_SPIRV_INVALID_HEADER, BX_MAKEFOURCC('S', 'H', 0, 1) );
BX_ERROR_RESULT(BGFX_SHADER_SPIRV_INVALID_INSTRUCTION, BX_MAKEFOURCC('S', 'H', 0, 2) );
namespace bgfx namespace bgfx
{ {
// Reference: https://www.khronos.org/registry/spir-v/specs/1.0/SPIRV.html // Reference: https://www.khronos.org/registry/spir-v/specs/1.0/SPIRV.html
struct SpirvOpcode struct SpvOpcode
{ {
enum Enum enum Enum
{ {
@ -25,13 +28,16 @@ namespace bgfx
MemberName, MemberName,
String, String,
Line, Line,
Invalid9,
Extension, Extension,
ExtInstImport, ExtInstImport,
ExtInst, ExtInst,
Invalid13,
MemoryModel, MemoryModel,
EntryPoint, EntryPoint,
ExecutionMode, ExecutionMode,
Capability, Capability,
Invalid18,
TypeVoid, TypeVoid,
TypeBool, TypeBool,
TypeInt, TypeInt,
@ -53,21 +59,25 @@ namespace bgfx
TypeQueue, TypeQueue,
TypePipe, TypePipe,
TypeForwardPointer, TypeForwardPointer,
Invalid40,
ConstantTrue, ConstantTrue,
ConstantFalse, ConstantFalse,
Constant, Constant,
ConstantComposite, ConstantComposite,
ConstantSampler, ConstantSampler,
ConstantNull, ConstantNull,
Invalid47,
SpecConstantTrue, SpecConstantTrue,
SpecConstantFalse, SpecConstantFalse,
SpecConstant, SpecConstant,
SpecConstantComposite, SpecConstantComposite,
SpecConstantOp, SpecConstantOp,
Invalid53,
Function, Function,
FunctionParameter, FunctionParameter,
FunctionEnd, FunctionEnd,
FunctionCall, FunctionCall,
Invalid58,
Variable, Variable,
ImageTexelPointer, ImageTexelPointer,
Load, Load,
@ -85,6 +95,7 @@ namespace bgfx
DecorationGroup, DecorationGroup,
GroupDecorate, GroupDecorate,
GroupMemberDecorate, GroupMemberDecorate,
Invalid76,
VectorExtractDynamic, VectorExtractDynamic,
VectorInsertDynamic, VectorInsertDynamic,
VectorShuffle, VectorShuffle,
@ -93,6 +104,7 @@ namespace bgfx
CompositeInsert, CompositeInsert,
CopyObject, CopyObject,
Transpose, Transpose,
Invalid85,
SampledImage, SampledImage,
ImageSampleImplicitLod, ImageSampleImplicitLod,
ImageSampleExplicitLod, ImageSampleExplicitLod,
@ -115,6 +127,7 @@ namespace bgfx
ImageQueryLod, ImageQueryLod,
ImageQueryLevels, ImageQueryLevels,
ImageQuerySamples, ImageQuerySamples,
Invalid108,
ConvertFToU, ConvertFToU,
ConvertFToS, ConvertFToS,
ConvertSToF, ConvertSToF,
@ -131,6 +144,7 @@ namespace bgfx
GenericCastToPtr, GenericCastToPtr,
GenericCastToPtrExplicit, GenericCastToPtrExplicit,
Bitcast, Bitcast,
Invalid125,
SNegate, SNegate,
FNegate, FNegate,
IAdd, IAdd,
@ -158,6 +172,7 @@ namespace bgfx
ISubBorrow, ISubBorrow,
UMulExtended, UMulExtended,
SMulExtended, SMulExtended,
Invalid153,
Any, Any,
All, All,
IsNan, IsNan,
@ -196,6 +211,8 @@ namespace bgfx
FUnordLessThanEqual, FUnordLessThanEqual,
FOrdGreaterThanEqual, FOrdGreaterThanEqual,
FUnordGreaterThanEqual, FUnordGreaterThanEqual,
Invalid192,
Invalid193,
ShiftRightLogical, ShiftRightLogical,
ShiftRightArithmetic, ShiftRightArithmetic,
ShiftLeftLogical, ShiftLeftLogical,
@ -208,6 +225,7 @@ namespace bgfx
BitFieldUExtract, BitFieldUExtract,
BitReverse, BitReverse,
BitCount, BitCount,
Invalid206,
DPdx, DPdx,
DPdy, DPdy,
Fwidth, Fwidth,
@ -217,12 +235,17 @@ namespace bgfx
DPdxCoarse, DPdxCoarse,
DPdyCoarse, DPdyCoarse,
FwidthCoarse, FwidthCoarse,
Invalid216,
Invalid217,
EmitVertex, EmitVertex,
EndPrimitive, EndPrimitive,
EmitStreamVertex, EmitStreamVertex,
EndStreamPrimitive, EndStreamPrimitive,
Invalid222,
Invalid223,
ControlBarrier, ControlBarrier,
MemoryBarrier, MemoryBarrier,
Invalid226,
AtomicLoad, AtomicLoad,
AtomicStore, AtomicStore,
AtomicExchange, AtomicExchange,
@ -239,6 +262,8 @@ namespace bgfx
AtomicAnd, AtomicAnd,
AtomicOr, AtomicOr,
AtomicXor, AtomicXor,
Invalid243,
Invalid244,
Phi, Phi,
LoopMerge, LoopMerge,
SelectionMerge, SelectionMerge,
@ -252,6 +277,7 @@ namespace bgfx
Unreachable, Unreachable,
LifetimeStart, LifetimeStart,
LifetimeStop, LifetimeStop,
Invalid258,
GroupAsyncCopy, GroupAsyncCopy,
GroupWaitEvents, GroupWaitEvents,
GroupAll, GroupAll,
@ -265,6 +291,8 @@ namespace bgfx
GroupFMax, GroupFMax,
GroupUMax, GroupUMax,
GroupSMax, GroupSMax,
Invalid272,
Invalid273,
ReadPipe, ReadPipe,
WritePipe, WritePipe,
ReservedReadPipe, ReservedReadPipe,
@ -280,6 +308,8 @@ namespace bgfx
GroupReserveWritePipePackets, GroupReserveWritePipePackets,
GroupCommitReadPipe, GroupCommitReadPipe,
GroupCommitWritePipe, GroupCommitWritePipe,
Invalid289,
Invalid290,
EnqueueMarker, EnqueueMarker,
EnqueueKernel, EnqueueKernel,
GetKernelNDrangeSubGroupCount, GetKernelNDrangeSubGroupCount,
@ -360,10 +390,12 @@ namespace bgfx
SubgroupLocalInvocationId, SubgroupLocalInvocationId,
VertexIndex, VertexIndex,
InstanceIndex, InstanceIndex,
Count
}; };
}; };
struct SpirvExecutionModel struct SpvExecutionModel
{ {
enum Enum enum Enum
{ {
@ -379,7 +411,19 @@ namespace bgfx
}; };
}; };
struct SpirvMemoryModel struct SpvAddressingModel
{
enum Enum
{
Logical,
Physical32,
Physical64,
Count
};
};
struct SpvMemoryModel
{ {
enum Enum enum Enum
{ {
@ -391,7 +435,7 @@ namespace bgfx
}; };
}; };
struct SpirvStorageClass struct SpvStorageClass
{ {
enum Enum enum Enum
{ {
@ -407,10 +451,12 @@ namespace bgfx
PushConstant, PushConstant,
AtomicCounter, AtomicCounter,
Image, Image,
Count
}; };
}; };
struct SpirvResourceDim struct SpvResourceDim
{ {
enum Enum enum Enum
{ {
@ -424,7 +470,7 @@ namespace bgfx
}; };
}; };
struct SpirvDecoration struct SpvDecoration
{ {
enum Enum enum Enum
{ {
@ -476,52 +522,90 @@ namespace bgfx
}; };
}; };
struct SpirvOperand struct SpvOperand
{ {
}; enum Enum
struct SpirvInstruction
{
SpirvOpcode::Enum opcode;
uint16_t length;
uint8_t numOperands;
SpirvOperand operand[6];
union
{ {
struct ResultTypeId AccessQualifier,
{ AddressingModel,
uint32_t resultType; Base,
uint32_t id; Capability,
}; Component,
ComponentType,
Composite,
Condition,
Coordinate,
Decoration,
Dim,
Dref,
ExecutionModel,
Function,
FunctionControl,
Id,
IdRep,
ImageFormat,
ImageOperands,
LiteralNumber,
LiteralRep,
LiteralString,
Matrix,
MemoryAccess,
MemoryModel,
Object,
Pointer,
SampledType,
SampledImage,
SamplerAddressingMode,
SamplerFilterMode,
Scalar,
SourceLanguage,
StorageClass,
StructureType,
Vector,
ResultTypeId constant; Count
ResultTypeId constantComposite; };
uint32_t value[8]; Enum type;
} un; uint32_t data[4];
uint32_t target;
stl::string literalString;
}; };
int32_t read(bx::ReaderI* _reader, SpirvInstruction& _instruction); struct SpvInstruction
int32_t write(bx::WriterI* _writer, const SpirvInstruction& _instruction); {
int32_t toString(char* _out, int32_t _size, const SpirvInstruction& _instruction); SpvOpcode::Enum opcode;
uint16_t length;
uint16_t numOperands;
struct SpirvShader uint32_t type;
uint32_t result;
bool hasType;
bool hasResult;
SpvOperand operand[8];
};
int32_t read(bx::ReaderI* _reader, SpvInstruction& _instruction, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const SpvInstruction& _instruction, bx::Error* _err);
int32_t toString(char* _out, int32_t _size, const SpvInstruction& _instruction);
struct SpvShader
{ {
stl::vector<uint8_t> byteCode; stl::vector<uint8_t> byteCode;
}; };
int32_t read(bx::ReaderSeekerI* _reader, SpirvShader& _shader); int32_t read(bx::ReaderSeekerI* _reader, SpvShader& _shader, bx::Error* _err);
int32_t write(bx::WriterI* _writer, const SpirvShader& _shader); int32_t write(bx::WriterI* _writer, const SpvShader& _shader, bx::Error* _err);
typedef bool (*SpirvParseFn)(uint32_t _offset, const SpirvInstruction& _instruction, void* _userData); typedef bool (*SpirvParseFn)(uint32_t _offset, const SpvInstruction& _instruction, void* _userData);
void parse(const SpirvShader& _src, SpirvParseFn _fn, void* _userData); void parse(const SpvShader& _src, SpirvParseFn _fn, void* _userData, bx::Error* _err = NULL);
typedef void (*SpirvFilterFn)(SpirvInstruction& _instruction, void* _userData); typedef void (*SpirvFilterFn)(SpvInstruction& _instruction, void* _userData);
void filter(SpirvShader& _dst, const SpirvShader& _src, SpirvFilterFn _fn, void* _userData); void filter(SpvShader& _dst, const SpvShader& _src, SpirvFilterFn _fn, void* _userData, bx::Error* _err = NULL);
struct Spirv struct SpirV
{ {
struct Header struct Header
{ {
@ -533,11 +617,11 @@ namespace bgfx
}; };
Header header; Header header;
SpirvShader shader; SpvShader shader;
}; };
int32_t read(bx::ReaderSeekerI* _reader, Spirv& _spirv); int32_t read(bx::ReaderSeekerI* _reader, SpirV& _spirv, bx::Error* _err);
int32_t write(bx::WriterSeekerI* _writer, const Spirv& _spirv); int32_t write(bx::WriterSeekerI* _writer, const SpirV& _spirv, bx::Error* _err);
} // namespace bgfx } // namespace bgfx