From 9af58bbe14cdd05f1e1e8028df7e5cc43e413c4c Mon Sep 17 00:00:00 2001 From: Ryan Harrison Date: Wed, 15 Jan 2020 14:56:22 +0000 Subject: [PATCH] Return errors in ExtractSpirvInfo instead of sending to the device BUG=dawn:274 Change-Id: Ieeaffdd356a6f2174a39a8098b306c36d10ef9e7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15100 Reviewed-by: Corentin Wallez Commit-Queue: Ryan Harrison --- src/dawn_native/ShaderModule.cpp | 310 +++++++++----------- src/dawn_native/ShaderModule.h | 8 +- src/dawn_native/d3d12/ShaderModuleD3D12.cpp | 4 +- src/dawn_native/metal/ShaderModuleMTL.mm | 4 +- src/dawn_native/null/DeviceNull.cpp | 4 +- src/dawn_native/opengl/ShaderModuleGL.cpp | 2 +- src/dawn_native/vulkan/ShaderModuleVk.cpp | 4 +- 7 files changed, 159 insertions(+), 177 deletions(-) diff --git a/src/dawn_native/ShaderModule.cpp b/src/dawn_native/ShaderModule.cpp index 1cb3f217a6..605b055fec 100644 --- a/src/dawn_native/ShaderModule.cpp +++ b/src/dawn_native/ShaderModule.cpp @@ -119,20 +119,19 @@ namespace dawn_native { UNREACHABLE(); } - // TODO(rharrison): Convert this to ResultOrError once ExtractSPIRVInfo turns an error - SingleShaderStage ToSingleShaderStage(shaderc_spvc_execution_model execution_model) { + ResultOrError ToSingleShaderStage( + shaderc_spvc_execution_model execution_model) { switch (execution_model) { case shaderc_spvc_execution_model_vertex: - return SingleShaderStage::Vertex; + return {SingleShaderStage::Vertex}; case shaderc_spvc_execution_model_fragment: - return SingleShaderStage::Fragment; + return {SingleShaderStage::Fragment}; case shaderc_spvc_execution_model_glcompute: - return SingleShaderStage::Compute; + return {SingleShaderStage::Compute}; default: - // This will be converted to an error return when the whole - // calling stack is changed to passing errors. UNREACHABLE(); - return SingleShaderStage::Vertex; + return DAWN_VALIDATION_ERROR( + "Attempted to convert invalid spvc execution model to SingleShaderStage"); } } } // anonymous namespace @@ -198,45 +197,40 @@ namespace dawn_native { return new ShaderModuleBase(device, ObjectBase::kError); } - void ShaderModuleBase::ExtractSpirvInfo(const spirv_cross::Compiler& compiler) { + MaybeError ShaderModuleBase::ExtractSpirvInfo(const spirv_cross::Compiler& compiler) { ASSERT(!IsError()); if (GetDevice()->IsToggleEnabled(Toggle::UseSpvc)) { - ExtractSpirvInfoWithSpvc(compiler); + DAWN_TRY(ExtractSpirvInfoWithSpvc()); } else { - ExtractSpirvInfoWithSpirvCross(compiler); + DAWN_TRY(ExtractSpirvInfoWithSpirvCross(compiler)); } + return {}; } - void ShaderModuleBase::ExtractSpirvInfoWithSpvc(const spirv_cross::Compiler& compiler) { + MaybeError ShaderModuleBase::ExtractSpirvInfoWithSpvc() { shaderc_spvc_execution_model execution_model; - if (!CheckSpvcSuccess(mSpvcContext.GetExecutionModel(&execution_model), - "Unable to get execution model for shader.")) { - return; - } + DAWN_TRY(CheckSpvcSuccess(mSpvcContext.GetExecutionModel(&execution_model), + "Unable to get execution model for shader.")); - mExecutionModel = ToSingleShaderStage(execution_model); + DAWN_TRY_ASSIGN(mExecutionModel, ToSingleShaderStage(execution_model)); size_t push_constant_buffers_count; - if (!CheckSpvcSuccess(mSpvcContext.GetPushConstantBufferCount(&push_constant_buffers_count), - "Unable to get push constant buffer count for shader.")) { - return; - } + DAWN_TRY( + CheckSpvcSuccess(mSpvcContext.GetPushConstantBufferCount(&push_constant_buffers_count), + "Unable to get push constant buffer count for shader.")); // TODO(rharrison): This should be handled by spirv-val pass in spvc, // but need to confirm. if (push_constant_buffers_count > 0) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Push constants aren't supported."); - return; + return DAWN_VALIDATION_ERROR("Push constants aren't supported."); } // Fill in bindingInfo with the SPIRV bindings - auto ExtractResourcesBinding = [this](std::vector bindings) { + auto ExtractResourcesBinding = + [this](std::vector bindings) -> MaybeError { for (const auto& binding : bindings) { if (binding.binding >= kMaxBindingsPerGroup || binding.set >= kMaxBindGroups) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Binding over limits in the SPIRV"); - continue; + return DAWN_VALIDATION_ERROR("Binding over limits in the SPIRV"); } BindingInfo* info = &mBindingInfo[binding.set][binding.binding]; @@ -251,108 +245,90 @@ namespace dawn_native { } info->type = ToWGPUBindingType(binding.binding_type); } + return {}; }; std::vector resource_bindings; - if (!CheckSpvcSuccess(mSpvcContext.GetBindingInfo( - shaderc_spvc_shader_resource_uniform_buffers, - shaderc_spvc_binding_type_uniform_buffer, &resource_bindings), - "Unable to get binding info for uniform buffers from shader")) { - return; - } - ExtractResourcesBinding(resource_bindings); + DAWN_TRY(CheckSpvcSuccess(mSpvcContext.GetBindingInfo( + shaderc_spvc_shader_resource_uniform_buffers, + shaderc_spvc_binding_type_uniform_buffer, &resource_bindings), + "Unable to get binding info for uniform buffers from shader")); + DAWN_TRY(ExtractResourcesBinding(resource_bindings)); - if (!CheckSpvcSuccess(mSpvcContext.GetBindingInfo( - shaderc_spvc_shader_resource_separate_images, - shaderc_spvc_binding_type_sampled_texture, &resource_bindings), - "Unable to get binding info for sampled textures from shader")) { - return; - } - ExtractResourcesBinding(resource_bindings); + DAWN_TRY(CheckSpvcSuccess( + mSpvcContext.GetBindingInfo(shaderc_spvc_shader_resource_separate_images, + shaderc_spvc_binding_type_sampled_texture, + &resource_bindings), + "Unable to get binding info for sampled textures from shader")); + DAWN_TRY(ExtractResourcesBinding(resource_bindings)); - if (!CheckSpvcSuccess( - mSpvcContext.GetBindingInfo(shaderc_spvc_shader_resource_separate_samplers, - shaderc_spvc_binding_type_sampler, &resource_bindings), - "Unable to get binding info for samples from shader")) { - return; - } - ExtractResourcesBinding(resource_bindings); + DAWN_TRY(CheckSpvcSuccess( + mSpvcContext.GetBindingInfo(shaderc_spvc_shader_resource_separate_samplers, + shaderc_spvc_binding_type_sampler, &resource_bindings), + "Unable to get binding info for samples from shader")); + DAWN_TRY(ExtractResourcesBinding(resource_bindings)); - if (!CheckSpvcSuccess(mSpvcContext.GetBindingInfo( - shaderc_spvc_shader_resource_storage_buffers, - shaderc_spvc_binding_type_storage_buffer, &resource_bindings), - "Unable to get binding info for storage buffers from shader")) { - return; - } - ExtractResourcesBinding(resource_bindings); + DAWN_TRY(CheckSpvcSuccess(mSpvcContext.GetBindingInfo( + shaderc_spvc_shader_resource_storage_buffers, + shaderc_spvc_binding_type_storage_buffer, &resource_bindings), + "Unable to get binding info for storage buffers from shader")); + DAWN_TRY(ExtractResourcesBinding(resource_bindings)); std::vector input_stage_locations; - if (!CheckSpvcSuccess(mSpvcContext.GetInputStageLocationInfo(&input_stage_locations), - "Unable to get input stage location information from shader")) { - input_stage_locations.clear(); - return; - } + DAWN_TRY(CheckSpvcSuccess(mSpvcContext.GetInputStageLocationInfo(&input_stage_locations), + "Unable to get input stage location information from shader")); for (const auto& input : input_stage_locations) { if (mExecutionModel == SingleShaderStage::Vertex) { if (input.location >= kMaxVertexAttributes) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Attribute location over limits in the SPIRV"); - return; + return DAWN_VALIDATION_ERROR("Attribute location over limits in the SPIRV"); } mUsedVertexAttributes.set(input.location); } else if (mExecutionModel == SingleShaderStage::Fragment) { // Without a location qualifier on vertex inputs, spirv_cross::CompilerMSL gives // them all the location 0, causing a compile error. if (!input.has_location) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Need location qualifier on fragment input"); - return; + return DAWN_VALIDATION_ERROR("Need location qualifier on fragment input"); } } } std::vector output_stage_locations; - if (!CheckSpvcSuccess(mSpvcContext.GetOutputStageLocationInfo(&output_stage_locations), - "Unable to get output stage location information from shader")) { - output_stage_locations.clear(); - return; - } + DAWN_TRY(CheckSpvcSuccess(mSpvcContext.GetOutputStageLocationInfo(&output_stage_locations), + "Unable to get output stage location information from shader")); for (const auto& output : output_stage_locations) { if (mExecutionModel == SingleShaderStage::Vertex) { // Without a location qualifier on vertex outputs, spirv_cross::CompilerMSL // gives them all the location 0, causing a compile error. if (!output.has_location) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Need location qualifier on vertex output"); - return; + return DAWN_VALIDATION_ERROR("Need location qualifier on vertex output"); } } else if (mExecutionModel == SingleShaderStage::Fragment) { if (output.location >= kMaxColorAttachments) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Fragment output location over limits in the SPIRV"); - return; + return DAWN_VALIDATION_ERROR( + "Fragment output location over limits in the SPIRV"); } } } if (mExecutionModel == SingleShaderStage::Fragment) { std::vector output_types; - if (!CheckSpvcSuccess(mSpvcContext.GetOutputStageTypeInfo(&output_types), - "Unable to get output stage type information from shader")) { - output_stage_locations.clear(); - return; - } + DAWN_TRY(CheckSpvcSuccess(mSpvcContext.GetOutputStageTypeInfo(&output_types), + "Unable to get output stage type information from shader")); for (const auto& output : output_types) { - ASSERT(output.type != shaderc_spvc_texture_format_type_other); + if (output.type == shaderc_spvc_texture_format_type_other) { + return DAWN_VALIDATION_ERROR("Unexpected Fragment output type"); + } mFragmentOutputFormatBaseTypes[output.location] = ToDawnFormatType(output.type); } } + return {}; } - void ShaderModuleBase::ExtractSpirvInfoWithSpirvCross(const spirv_cross::Compiler& compiler) { + MaybeError ShaderModuleBase::ExtractSpirvInfoWithSpirvCross( + const spirv_cross::Compiler& compiler) { // TODO(cwallez@chromium.org): make errors here creation errors // currently errors here do not prevent the shadermodule from being used const auto& resources = compiler.get_shader_resources(); @@ -369,86 +345,91 @@ namespace dawn_native { break; default: UNREACHABLE(); + return DAWN_VALIDATION_ERROR("Unexpected shader execution model"); } if (resources.push_constant_buffers.size() > 0) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Push constants aren't supported."); + return DAWN_VALIDATION_ERROR("Push constants aren't supported."); } // Fill in bindingInfo with the SPIRV bindings auto ExtractResourcesBinding = [this](const spirv_cross::SmallVector& resources, - const spirv_cross::Compiler& compiler, wgpu::BindingType bindingType) { - for (const auto& resource : resources) { - ASSERT(compiler.get_decoration_bitset(resource.id).get(spv::DecorationBinding)); - ASSERT(compiler.get_decoration_bitset(resource.id) - .get(spv::DecorationDescriptorSet)); - - uint32_t binding = compiler.get_decoration(resource.id, spv::DecorationBinding); - uint32_t set = - compiler.get_decoration(resource.id, spv::DecorationDescriptorSet); - - if (binding >= kMaxBindingsPerGroup || set >= kMaxBindGroups) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Binding over limits in the SPIRV"); - continue; - } - - BindingInfo* info = &mBindingInfo[set][binding]; - *info = {}; - info->used = true; - info->id = resource.id; - info->base_type_id = resource.base_type_id; - switch (bindingType) { - case wgpu::BindingType::SampledTexture: { - spirv_cross::SPIRType::ImageType imageType = - compiler.get_type(info->base_type_id).image; - spirv_cross::SPIRType::BaseType textureComponentType = - compiler.get_type(imageType.type).basetype; - - info->multisampled = imageType.ms; - info->textureDimension = - SpirvDimToTextureViewDimension(imageType.dim, imageType.arrayed); - info->textureComponentType = - SpirvCrossBaseTypeToFormatType(textureComponentType); - info->type = bindingType; - } break; - case wgpu::BindingType::StorageBuffer: { - // Differentiate between readonly storage bindings and writable ones - // based on the NonWritable decoration - spirv_cross::Bitset flags = - compiler.get_buffer_block_flags(resource.id); - if (flags.get(spv::DecorationNonWritable)) { - info->type = wgpu::BindingType::ReadonlyStorageBuffer; - } else { - info->type = wgpu::BindingType::StorageBuffer; - } - } break; - default: - info->type = bindingType; - } + const spirv_cross::Compiler& compiler, + wgpu::BindingType bindingType) -> MaybeError { + for (const auto& resource : resources) { + if (!compiler.get_decoration_bitset(resource.id).get(spv::DecorationBinding)) { + return DAWN_VALIDATION_ERROR("No Binding decoration set for resource"); } - }; - ExtractResourcesBinding(resources.uniform_buffers, compiler, - wgpu::BindingType::UniformBuffer); - ExtractResourcesBinding(resources.separate_images, compiler, - wgpu::BindingType::SampledTexture); - ExtractResourcesBinding(resources.separate_samplers, compiler, wgpu::BindingType::Sampler); - ExtractResourcesBinding(resources.storage_buffers, compiler, - wgpu::BindingType::StorageBuffer); + if (!compiler.get_decoration_bitset(resource.id) + .get(spv::DecorationDescriptorSet)) { + return DAWN_VALIDATION_ERROR("No Descriptor Decoration set for resource"); + } + + uint32_t binding = compiler.get_decoration(resource.id, spv::DecorationBinding); + uint32_t set = compiler.get_decoration(resource.id, spv::DecorationDescriptorSet); + + if (binding >= kMaxBindingsPerGroup || set >= kMaxBindGroups) { + return DAWN_VALIDATION_ERROR("Binding over limits in the SPIRV"); + } + + BindingInfo* info = &mBindingInfo[set][binding]; + *info = {}; + info->used = true; + info->id = resource.id; + info->base_type_id = resource.base_type_id; + switch (bindingType) { + case wgpu::BindingType::SampledTexture: { + spirv_cross::SPIRType::ImageType imageType = + compiler.get_type(info->base_type_id).image; + spirv_cross::SPIRType::BaseType textureComponentType = + compiler.get_type(imageType.type).basetype; + + info->multisampled = imageType.ms; + info->textureDimension = + SpirvDimToTextureViewDimension(imageType.dim, imageType.arrayed); + info->textureComponentType = + SpirvCrossBaseTypeToFormatType(textureComponentType); + info->type = bindingType; + } break; + case wgpu::BindingType::StorageBuffer: { + // Differentiate between readonly storage bindings and writable ones + // based on the NonWritable decoration + spirv_cross::Bitset flags = compiler.get_buffer_block_flags(resource.id); + if (flags.get(spv::DecorationNonWritable)) { + info->type = wgpu::BindingType::ReadonlyStorageBuffer; + } else { + info->type = wgpu::BindingType::StorageBuffer; + } + } break; + default: + info->type = bindingType; + } + } + return {}; + }; + + DAWN_TRY(ExtractResourcesBinding(resources.uniform_buffers, compiler, + wgpu::BindingType::UniformBuffer)); + DAWN_TRY(ExtractResourcesBinding(resources.separate_images, compiler, + wgpu::BindingType::SampledTexture)); + DAWN_TRY(ExtractResourcesBinding(resources.separate_samplers, compiler, + wgpu::BindingType::Sampler)); + DAWN_TRY(ExtractResourcesBinding(resources.storage_buffers, compiler, + wgpu::BindingType::StorageBuffer)); // Extract the vertex attributes if (mExecutionModel == SingleShaderStage::Vertex) { for (const auto& attrib : resources.stage_inputs) { - ASSERT(compiler.get_decoration_bitset(attrib.id).get(spv::DecorationLocation)); + if (!(compiler.get_decoration_bitset(attrib.id).get(spv::DecorationLocation))) { + return DAWN_VALIDATION_ERROR( + "Unable to find Location decoration for Vertex input"); + } uint32_t location = compiler.get_decoration(attrib.id, spv::DecorationLocation); if (location >= kMaxVertexAttributes) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Attribute location over limits in the SPIRV"); - return; + return DAWN_VALIDATION_ERROR("Attribute location over limits in the SPIRV"); } mUsedVertexAttributes.set(location); @@ -458,9 +439,7 @@ namespace dawn_native { // them all the location 0, causing a compile error. for (const auto& attrib : resources.stage_outputs) { if (!compiler.get_decoration_bitset(attrib.id).get(spv::DecorationLocation)) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Need location qualifier on vertex output"); - return; + return DAWN_VALIDATION_ERROR("Need location qualifier on vertex output"); } } } @@ -470,31 +449,34 @@ namespace dawn_native { // them all the location 0, causing a compile error. for (const auto& attrib : resources.stage_inputs) { if (!compiler.get_decoration_bitset(attrib.id).get(spv::DecorationLocation)) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Need location qualifier on fragment input"); - return; + return DAWN_VALIDATION_ERROR("Need location qualifier on fragment input"); } } for (const auto& fragmentOutput : resources.stage_outputs) { - ASSERT( - compiler.get_decoration_bitset(fragmentOutput.id).get(spv::DecorationLocation)); + if (!compiler.get_decoration_bitset(fragmentOutput.id) + .get(spv::DecorationLocation)) { + return DAWN_VALIDATION_ERROR( + "Unable to find Location decoration for Fragment output"); + } uint32_t location = compiler.get_decoration(fragmentOutput.id, spv::DecorationLocation); if (location >= kMaxColorAttachments) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, - "Fragment output location over limits in the SPIRV"); - return; + return DAWN_VALIDATION_ERROR( + "Fragment output location over limits in the SPIRV"); } spirv_cross::SPIRType::BaseType shaderFragmentOutputBaseType = compiler.get_type(fragmentOutput.base_type_id).basetype; Format::Type formatType = SpirvCrossBaseTypeToFormatType(shaderFragmentOutputBaseType); - ASSERT(formatType != Format::Type::Other); + if (formatType == Format::Type::Other) { + return DAWN_VALIDATION_ERROR("Unexpected Fragment output type"); + }; mFragmentOutputFormatBaseTypes[location] = formatType; } } + return {}; } const ShaderModuleBase::ModuleBindingInfo& ShaderModuleBase::GetBindingInfo() const { @@ -600,12 +582,12 @@ namespace dawn_native { return a->mCode == b->mCode; } - bool ShaderModuleBase::CheckSpvcSuccess(shaderc_spvc_status status, const char* error_msg) { + MaybeError ShaderModuleBase::CheckSpvcSuccess(shaderc_spvc_status status, + const char* error_msg) { if (status != shaderc_spvc_status_success) { - GetDevice()->HandleError(wgpu::ErrorType::Validation, error_msg); - return false; + DAWN_VALIDATION_ERROR(error_msg); } - return true; + return {}; } } // namespace dawn_native diff --git a/src/dawn_native/ShaderModule.h b/src/dawn_native/ShaderModule.h index 9a6bcccc51..8d23d8c3d8 100644 --- a/src/dawn_native/ShaderModule.h +++ b/src/dawn_native/ShaderModule.h @@ -46,7 +46,7 @@ namespace dawn_native { static ShaderModuleBase* MakeError(DeviceBase* device); - void ExtractSpirvInfo(const spirv_cross::Compiler& compiler); + MaybeError ExtractSpirvInfo(const spirv_cross::Compiler& compiler); struct BindingInfo { // The SPIRV ID of the resource. @@ -91,10 +91,10 @@ namespace dawn_native { // Different implementations reflection into the shader depending on // whether using spvc, or directly accessing spirv-cross. - void ExtractSpirvInfoWithSpvc(const spirv_cross::Compiler& compiler); - void ExtractSpirvInfoWithSpirvCross(const spirv_cross::Compiler& compiler); + MaybeError ExtractSpirvInfoWithSpvc(); + MaybeError ExtractSpirvInfoWithSpirvCross(const spirv_cross::Compiler& compiler); - bool CheckSpvcSuccess(shaderc_spvc_status status, const char* error_msg); + MaybeError CheckSpvcSuccess(shaderc_spvc_status status, const char* error_msg); // TODO(cwallez@chromium.org): The code is only stored for deduplication. We could maybe // store a cryptographic hash of the code instead? diff --git a/src/dawn_native/d3d12/ShaderModuleD3D12.cpp b/src/dawn_native/d3d12/ShaderModuleD3D12.cpp index 0e5c2ef18f..1ffb87031b 100644 --- a/src/dawn_native/d3d12/ShaderModuleD3D12.cpp +++ b/src/dawn_native/d3d12/ShaderModuleD3D12.cpp @@ -60,10 +60,10 @@ namespace dawn_native { namespace d3d12 { spirv_cross::Compiler* compiler = reinterpret_cast(mSpvcContext.GetCompiler()); - ExtractSpirvInfo(*compiler); + DAWN_TRY(ExtractSpirvInfo(*compiler)); } else { spirv_cross::CompilerHLSL compiler(descriptor->code, descriptor->codeSize); - ExtractSpirvInfo(compiler); + DAWN_TRY(ExtractSpirvInfo(compiler)); } return {}; } diff --git a/src/dawn_native/metal/ShaderModuleMTL.mm b/src/dawn_native/metal/ShaderModuleMTL.mm index 5248b7d0fd..89e68f3181 100644 --- a/src/dawn_native/metal/ShaderModuleMTL.mm +++ b/src/dawn_native/metal/ShaderModuleMTL.mm @@ -84,10 +84,10 @@ namespace dawn_native { namespace metal { spirv_cross::CompilerMSL* compiler = reinterpret_cast(mSpvcContext.GetCompiler()); - ExtractSpirvInfo(*compiler); + DAWN_TRY(ExtractSpirvInfo(*compiler)); } else { spirv_cross::CompilerMSL compiler(mSpirv); - ExtractSpirvInfo(compiler); + DAWN_TRY(ExtractSpirvInfo(compiler)); } return {}; } diff --git a/src/dawn_native/null/DeviceNull.cpp b/src/dawn_native/null/DeviceNull.cpp index fd7ef2eb06..be074b6b77 100644 --- a/src/dawn_native/null/DeviceNull.cpp +++ b/src/dawn_native/null/DeviceNull.cpp @@ -138,10 +138,10 @@ namespace dawn_native { namespace null { spirv_cross::Compiler* compiler = reinterpret_cast(context.GetCompiler()); - module->ExtractSpirvInfo(*compiler); + DAWN_TRY(module->ExtractSpirvInfo(*compiler)); } else { spirv_cross::Compiler compiler(descriptor->code, descriptor->codeSize); - module->ExtractSpirvInfo(compiler); + DAWN_TRY(module->ExtractSpirvInfo(compiler)); } return module; } diff --git a/src/dawn_native/opengl/ShaderModuleGL.cpp b/src/dawn_native/opengl/ShaderModuleGL.cpp index da173b5cb2..14996e7d26 100644 --- a/src/dawn_native/opengl/ShaderModuleGL.cpp +++ b/src/dawn_native/opengl/ShaderModuleGL.cpp @@ -122,7 +122,7 @@ namespace dawn_native { namespace opengl { compiler->set_common_options(options); } - ExtractSpirvInfo(*compiler); + DAWN_TRY(ExtractSpirvInfo(*compiler)); const auto& bindingInfo = GetBindingInfo(); diff --git a/src/dawn_native/vulkan/ShaderModuleVk.cpp b/src/dawn_native/vulkan/ShaderModuleVk.cpp index 96e31270d5..da48202968 100644 --- a/src/dawn_native/vulkan/ShaderModuleVk.cpp +++ b/src/dawn_native/vulkan/ShaderModuleVk.cpp @@ -49,10 +49,10 @@ namespace dawn_native { namespace vulkan { spirv_cross::Compiler* compiler = reinterpret_cast(mSpvcContext.GetCompiler()); - ExtractSpirvInfo(*compiler); + DAWN_TRY(ExtractSpirvInfo(*compiler)); } else { spirv_cross::Compiler compiler(descriptor->code, descriptor->codeSize); - ExtractSpirvInfo(compiler); + DAWN_TRY(ExtractSpirvInfo(compiler)); } VkShaderModuleCreateInfo createInfo;