Detect corrupted shader.

src/bgfx_p.h

@@ -3402,9 +3402,9 @@ namespace bgfx
 
 			if (!err.isOk() )
 			{
-				ShaderHandle invalid = BGFX_INVALID_HANDLE;
+				BX_TRACE("Couldn't read shader signature!");
 				release(_mem);
-				return invalid;
+				return BGFX_INVALID_HANDLE;
 			}
 
 			if (BGFX_CHUNK_MAGIC_CSH != magic
@@ -3417,9 +3417,8 @@ namespace bgfx
 					, ( (uint8_t*)&magic)[2]
 					, ( (uint8_t*)&magic)[3]
 					);
-				ShaderHandle invalid = BGFX_INVALID_HANDLE;
 				release(_mem);
-				return invalid;
+				return BGFX_INVALID_HANDLE;
 			}
 
 			const uint32_t shaderHash = bx::hash<bx::HashMurmur2A>(_mem->data, _mem->size);
@@ -3432,74 +3431,80 @@ namespace bgfx
 				return handle;
 			}
 
-			ShaderHandle handle = { m_shaderHandle.alloc() };
+			uint32_t iohash;
+			bx::read(&reader, iohash, &err);
 
-			BX_WARN(isValid(handle), "Failed to allocate shader handle.");
-			if (isValid(handle) )
+			uint16_t count;
+			bx::read(&reader, count, &err);
+
+			if (!err.isOk() )
 			{
-				bool ok = m_shaderHashMap.insert(shaderHash, handle.idx);
-				BX_CHECK(ok, "Shader already exists!"); BX_UNUSED(ok);
+				BX_TRACE("Corrupted shader binary!");
+				release(_mem);
+				return BGFX_INVALID_HANDLE;
+			}
 
-				uint32_t iohash;
-				bx::read(&reader, iohash);
+			ShaderHandle handle = { m_shaderHandle.alloc() };
 
-				uint16_t count;
-				bx::read(&reader, count);
+			if (!isValid(handle) )
+			{
+				BX_TRACE("Failed to allocate shader handle.");
+				release(_mem);
+				return BGFX_INVALID_HANDLE;
+			}
 
-				ShaderRef& sr = m_shaderRef[handle.idx];
-				sr.m_refCount = 1;
-				sr.m_hash     = iohash;
-				sr.m_num      = 0;
-				sr.m_uniforms = NULL;
+			bool ok = m_shaderHashMap.insert(shaderHash, handle.idx);
+			BX_CHECK(ok, "Shader already exists!"); BX_UNUSED(ok);
 
-				UniformHandle* uniforms = (UniformHandle*)alloca(count*sizeof(UniformHandle) );
+			ShaderRef& sr = m_shaderRef[handle.idx];
+			sr.m_refCount = 1;
+			sr.m_hash     = iohash;
+			sr.m_num      = 0;
+			sr.m_uniforms = NULL;
 
-				for (uint32_t ii = 0; ii < count; ++ii)
-				{
-					uint8_t nameSize = 0;
-					bx::read(&reader, nameSize);
+			UniformHandle* uniforms = (UniformHandle*)alloca(count*sizeof(UniformHandle) );
 
-					char name[256];
-					bx::read(&reader, &name, nameSize);
-					name[nameSize] = '\0';
+			for (uint32_t ii = 0; ii < count; ++ii)
+			{
+				uint8_t nameSize = 0;
+				bx::read(&reader, nameSize, &err);
 
-					uint8_t type = 0;
-					bx::read(&reader, type);
-					type &= ~BGFX_UNIFORM_MASK;
+				char name[256];
+				bx::read(&reader, &name, nameSize, &err);
+				name[nameSize] = '\0';
 
-					uint8_t num;
-					bx::read(&reader, num);
+				uint8_t type = 0;
+				bx::read(&reader, type, &err);
+				type &= ~BGFX_UNIFORM_MASK;
 
-					uint16_t regIndex;
-					bx::read(&reader, regIndex);
+				uint8_t num;
+				bx::read(&reader, num, &err);
 
-					uint16_t regCount;
-					bx::read(&reader, regCount);
+				uint16_t regIndex;
+				bx::read(&reader, regIndex, &err);
 
-					PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
-					if (PredefinedUniform::Count == predefined)
-					{
-						uniforms[sr.m_num] = createUniform(name, UniformType::Enum(type), regCount);
-						sr.m_num++;
-					}
-				}
+				uint16_t regCount;
+				bx::read(&reader, regCount, &err);
 
-				if (0 != sr.m_num)
+				PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
+				if (PredefinedUniform::Count == predefined)
 				{
-					uint32_t size = sr.m_num*sizeof(UniformHandle);
-					sr.m_uniforms = (UniformHandle*)BX_ALLOC(g_allocator, size);
-					bx::memCopy(sr.m_uniforms, uniforms, size);
+					uniforms[sr.m_num] = createUniform(name, UniformType::Enum(type), regCount);
+					sr.m_num++;
 				}
-
-				CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateShader);
-				cmdbuf.write(handle);
-				cmdbuf.write(_mem);
 			}
-			else
+
+			if (0 != sr.m_num)
 			{
-				release(_mem);
+				uint32_t size = sr.m_num*sizeof(UniformHandle);
+				sr.m_uniforms = (UniformHandle*)BX_ALLOC(g_allocator, size);
+				bx::memCopy(sr.m_uniforms, uniforms, size);
 			}
 
+			CommandBuffer& cmdbuf = getCommandBuffer(CommandBuffer::CreateShader);
+			cmdbuf.write(handle);
+			cmdbuf.write(_mem);
+
 			return handle;
 		}