diff --git a/CHANGELOG.md b/CHANGELOG.md index 251962536..e86529c4a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -161,6 +161,7 @@ By @sagudev in [#10115](https://github.com/gfx-rs/wgpu/pull/10115). - Reject return types on compute shader entrypoints. By @ErichDonGubler in [#10026](https://github.com/gfx-rs/wgpu/pull/10026). - Reject `@location(…)`s in compute shaders. By @ErichDonGubler in [#10026](https://github.com/gfx-rs/wgpu/pull/10026). - Correctly emit primitive_index for the SPIR-V backend, handling mesh and raytracing shaders. Before, you could not use primitive_index with these shader types. An enable primitive_index statement is still required in wgsl shaders, in addition to enable wgpu_mesh_shader/enable wgpu_ray_tracing_pipeline. By @JMS55 in [#10153](https://github.com/gfx-rs/wgpu/pull/10153). +- Prevent invalid IR from being generated when using a ray query in a loop. By @Vecvec in [#9945](https://github.com/gfx-rs/wgpu/pull/9945) #### DX12 diff --git a/naga/src/back/dot/mod.rs b/naga/src/back/dot/mod.rs index 4cb3ef817..4f6ee7cb1 100644 --- a/naga/src/back/dot/mod.rs +++ b/naga/src/back/dot/mod.rs @@ -305,6 +305,7 @@ impl StatementGraph { "RayQueryConfirmIntersection" } crate::RayQueryFunction::Terminate => "RayQueryTerminate", + crate::RayQueryFunction::Begin => "RayQueryVariableUsageBegins", } } S::SubgroupBallot { result, predicate } => { diff --git a/naga/src/back/hlsl/writer.rs b/naga/src/back/hlsl/writer.rs index 1f5f2c558..6032a4f16 100644 --- a/naga/src/back/hlsl/writer.rs +++ b/naga/src/back/hlsl/writer.rs @@ -2911,6 +2911,11 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> { RayQueryFunction::Terminate => { self.write_terminate(module, level, query, &tracker_expr_name, func_ctx)?; } + RayQueryFunction::Begin => { + if self.options.ray_query_initialization_tracking { + writeln!(self.out, "{level}{tracker_expr_name} = 0u;")?; + } + } } } Statement::SubgroupBallot { result, predicate } => { diff --git a/naga/src/back/msl/ray.rs b/naga/src/back/msl/ray.rs index 05ae6fc8c..68680123e 100644 --- a/naga/src/back/msl/ray.rs +++ b/naga/src/back/msl/ray.rs @@ -526,6 +526,14 @@ impl Writer { writeln!(self.out, "{level}}}")?; } } + // Reset the initialization tracker to have no flags set which is equivalent to having + // a new variable as nothing else should be used if the ray query is marked as + // uninitialized. + crate::RayQueryFunction::Begin => { + if context.expression.ray_query_initialization_tracking { + writeln!(self.out, "{level}{tracker_expr_name} = 0u;")?; + } + } } Ok(()) diff --git a/naga/src/back/pipeline_constants.rs b/naga/src/back/pipeline_constants.rs index 29a3fc34f..090547bb3 100644 --- a/naga/src/back/pipeline_constants.rs +++ b/naga/src/back/pipeline_constants.rs @@ -905,6 +905,7 @@ fn adjust_stmt(new_pos: &HandleVec>, stmt: &mut S } crate::RayQueryFunction::ConfirmIntersection => {} crate::RayQueryFunction::Terminate => {} + crate::RayQueryFunction::Begin => {} } } Statement::CooperativeStore { diff --git a/naga/src/back/spv/ray/query.rs b/naga/src/back/spv/ray/query.rs index 673c24079..69bd50d26 100644 --- a/naga/src/back/spv/ray/query.rs +++ b/naga/src/back/spv/ray/query.rs @@ -1584,6 +1584,21 @@ impl BlockContext<'_> { &[query_id, tracker_ids.initialized_tracker], )); } + crate::RayQueryFunction::Begin => { + // Reset the ray query initialization tracker to zero as this is equivalent to it being a new variable. + // If initialization tracking is disabled, then the previous state doesn't matter as it is UB. + if self.writer.ray_query_initialization_tracking { + let zero_value = self + .writer + .get_constant_scalar(crate::Literal::U32(RayQueryPoint::empty().bits())); + + block.body.push(Instruction::store( + tracker_ids.initialized_tracker, + zero_value, + None, + )); + } + } } } diff --git a/naga/src/compact/statements.rs b/naga/src/compact/statements.rs index 4b9dd13c8..6016bdb21 100644 --- a/naga/src/compact/statements.rs +++ b/naga/src/compact/statements.rs @@ -218,6 +218,7 @@ impl FunctionTracer<'_> { } Qf::ConfirmIntersection => {} Qf::Terminate => {} + Qf::Begin => {} } } } @@ -456,6 +457,7 @@ impl FunctionMap { } Qf::ConfirmIntersection => {} Qf::Terminate => {} + Qf::Begin => {} } } } diff --git a/naga/src/front/wgsl/error.rs b/naga/src/front/wgsl/error.rs index 74231394e..ce1d62b32 100644 --- a/naga/src/front/wgsl/error.rs +++ b/naga/src/front/wgsl/error.rs @@ -603,6 +603,7 @@ pub(crate) enum Error<'a> { UnexpectedExprForTypeExpression(Span), MissingIncomingPayload(Span), UnterminatedBlockComment(Span), + RayQueryWithInitializer(Span), } impl From for Error<'_> { @@ -1682,6 +1683,14 @@ impl<'a> Error<'a> { message: "unterminated block comment".into(), notes: vec![], }, + Error::RayQueryWithInitializer(span) => ParseError { + message: "Ray query with initialize".into(), + labels: vec![( + *span, + "variables with type `ray_query` are special and so cannot have initializers".into(), + )], + notes: vec![], + }, } } } diff --git a/naga/src/front/wgsl/lower/mod.rs b/naga/src/front/wgsl/lower/mod.rs index 856190e00..aad76daa5 100644 --- a/naga/src/front/wgsl/lower/mod.rs +++ b/naga/src/front/wgsl/lower/mod.rs @@ -1860,6 +1860,18 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { ctx.named_expressions .insert(initializer, (l.name.name.to_string(), l.name.span)); + if matches!( + ctx.module.types[ty].inner, + crate::TypeInner::RayQuery { .. } + ) { + // If a `let` variable is a ray query, it must be invalid as a `let` + // must have an initializer (it is also pretty useless as all other + // operations are disallowed, or require write-able variables). + return Err(Box::new(Error::RayQueryWithInitializer( + ctx.function.expressions.get_span(initializer), + ))); + } + return Ok(()); } ast::LocalDecl::Var(ref v) => { @@ -1916,27 +1928,59 @@ impl<'source, 'temp> Lowerer<'source, 'temp> { let handle = ctx .as_expression(block, &mut emitter) .interrupt_emitter(ir::Expression::LocalVariable(var), Span::UNDEFINED)?; - let initializer = if is_inside_loop { - match initializer { - Some(initializer) => Some(initializer), - None => Some( - ctx.as_expression(block, &mut emitter) - .append_expression(ir::Expression::ZeroValue(ty), stmt.span)?, - ), - } - } else { - initializer - }; + block.extend(emitter.finish(&ctx.function.expressions)); ctx.local_table .insert(v.handle, Declared::Runtime(Typed::Reference(handle))); - match initializer { - Some(initializer) => ir::Statement::Store { - pointer: handle, - value: initializer, - }, - None => return Ok(()), + match ctx.module.types[ty].inner { + crate::TypeInner::RayQuery { .. } => { + // Initializers are disallowed for ray queries as any store is disallowed. + // However, in loops ray queries need to be reset using a special piece of + // IR. + + // Because we have a special case for ray queries, and initializers are always + // disallowed for ray queries, we remove them here. This prevents having to + // special-case them and then just emitting invalid IR anyway and gives a + // clearer error message. + if let Some(expr) = initializer { + return Err(Box::new(Error::RayQueryWithInitializer( + ctx.function.expressions.get_span(expr), + ))); + } + + if is_inside_loop { + ir::Statement::RayQuery { + query: handle, + fun: ir::RayQueryFunction::Begin, + } + } else { + return Ok(()); + } + } + _ => { + let initializer = if is_inside_loop { + match initializer { + Some(initializer) => Some(initializer), + None => Some( + ctx.as_expression(block, &mut emitter).append_expression( + ir::Expression::ZeroValue(ty), + stmt.span, + )?, + ), + } + } else { + initializer + }; + + match initializer { + Some(initializer) => ir::Statement::Store { + pointer: handle, + value: initializer, + }, + None => return Ok(()), + } + } } } ast::LocalDecl::Const(ref c) => { diff --git a/naga/src/ir/mod.rs b/naga/src/ir/mod.rs index d8f5c961f..5bd099a7f 100644 --- a/naga/src/ir/mod.rs +++ b/naga/src/ir/mod.rs @@ -2005,6 +2005,14 @@ pub enum RayQueryFunction { ConfirmIntersection, Terminate, + + /// Resets a variable's to appear as though it was previously unused. + /// + /// For most types in variables which don't have initialisers, a zero store + /// is fine when resetting a variable in a loop (as functions always have + /// their variables outside all blocks while wgsl and others can have blocks + /// in loops) but ray queries cannot be stored to nor can be zero initialized. + Begin, } //TODO: consider removing `Clone`. It's not valid to clone `Statement::Emit` anyway. diff --git a/naga/src/valid/analyzer.rs b/naga/src/valid/analyzer.rs index 8fc998747..02751d976 100644 --- a/naga/src/valid/analyzer.rs +++ b/naga/src/valid/analyzer.rs @@ -1142,6 +1142,7 @@ impl FunctionInfo { } crate::RayQueryFunction::ConfirmIntersection => {} crate::RayQueryFunction::Terminate => {} + crate::RayQueryFunction::Begin => {} } FunctionUniformity::new() } diff --git a/naga/src/valid/expression.rs b/naga/src/valid/expression.rs index 18188200e..9e3cf6ba9 100644 --- a/naga/src/valid/expression.rs +++ b/naga/src/valid/expression.rs @@ -525,6 +525,9 @@ impl super::Validator { if !mod_info[ty].contains(TypeFlags::CONSTRUCTIBLE) { return Err(ExpressionError::InvalidZeroValue(ty)); } + if matches!(module.types[ty].inner, crate::TypeInner::RayQuery { .. }) { + return Err(ExpressionError::InvalidZeroValue(ty)); + } ShaderStages::all() } E::Compose { ref components, ty } => { diff --git a/naga/src/valid/function.rs b/naga/src/valid/function.rs index 953388bdf..47e54f8bb 100644 --- a/naga/src/valid/function.rs +++ b/naga/src/valid/function.rs @@ -85,6 +85,8 @@ pub enum LocalVariableError { InitializerType, #[error("Initializer is not a const or override expression")] NonConstOrOverrideInitializer, + #[error("Local variable has a type `ray_query` and so cannot be initialized.")] + RayQueryWithInitializeExpression, } #[derive(Clone, Debug, thiserror::Error)] @@ -236,6 +238,8 @@ pub enum FunctionError { MismatchedPayloadType(Handle, Handle), #[error("The payload passed to `traceRay` must be a pointer directly to a global variable")] PayloadPointerNotGlobal, + #[error("Tried to store to pointer {0:?} which is a ray query and so cannot be assigned to")] + RayQueryStore(Handle), } bitflags::bitflags! { @@ -1095,6 +1099,13 @@ impl super::Validator { let good = if let Some(&Ti::Atomic(ref scalar)) = pointer_base_ty { // The Naga IR allows storing a scalar to an atomic. *value_ty == Ti::Scalar(*scalar) + } else if let Some(&Ti::RayQuery { .. }) = pointer_base_ty { + return Err(FunctionError::RayQueryStore(pointer) + .with_span_context(( + context.expressions.get_span(pointer), + format!("this pointer has a base type of {pointer_base_ty:?} which cannot be stored to"), + )) + .with_span(span, "store to a type which is not allowed to be stored to")); } else if let Some(tr) = pointer_base_tr { context.compare_types(value_tr, &tr) } else { @@ -1577,6 +1588,7 @@ impl super::Validator { } crate::RayQueryFunction::ConfirmIntersection => {} crate::RayQueryFunction::Terminate => {} + crate::RayQueryFunction::Begin => {} } } S::SubgroupBallot { result, predicate } => { @@ -1813,6 +1825,10 @@ impl super::Validator { if !local_expr_kind.is_const_or_override(init) { return Err(LocalVariableError::NonConstOrOverrideInitializer); } + + if matches!(gctx.types[var.ty].inner, crate::TypeInner::RayQuery { .. }) { + return Err(LocalVariableError::RayQueryWithInitializeExpression); + } } Ok(()) diff --git a/naga/src/valid/handles.rs b/naga/src/valid/handles.rs index 88c1bf4b6..3ed62c4d5 100644 --- a/naga/src/valid/handles.rs +++ b/naga/src/valid/handles.rs @@ -824,6 +824,7 @@ impl super::Validator { } crate::RayQueryFunction::ConfirmIntersection => {} crate::RayQueryFunction::Terminate => {} + crate::RayQueryFunction::Begin => {} } Ok(()) } diff --git a/naga/tests/in/wgsl/9890-no-rq-hoist.toml b/naga/tests/in/wgsl/9890-no-rq-hoist.toml new file mode 100644 index 000000000..c6a898f51 --- /dev/null +++ b/naga/tests/in/wgsl/9890-no-rq-hoist.toml @@ -0,0 +1,8 @@ +capabilities = "RAY_QUERY" +targets = "METAL | SPIRV | HLSL" + +[msl] +lang_version = [2, 4] + +[hlsl] +shader_model = "V6_5" diff --git a/naga/tests/in/wgsl/9890-no-rq-hoist.wgsl b/naga/tests/in/wgsl/9890-no-rq-hoist.wgsl new file mode 100644 index 000000000..06b681f5b --- /dev/null +++ b/naga/tests/in/wgsl/9890-no-rq-hoist.wgsl @@ -0,0 +1,12 @@ +enable wgpu_ray_query; + +@group(0) @binding(0) var acc: acceleration_structure; + +@compute @workgroup_size(1) +fn main() { + for (var i: u32 = 0u; i < 4u; i++) { + var sq: ray_query; + rayQueryInitialize(&sq, acc, RayDesc(0x01u, 0xFFu, 0.001, 1000.0, vec3(f32(i)), vec3(0.0, -1.0, 0.0))); + rayQueryProceed(&sq); + } +} \ No newline at end of file diff --git a/naga/tests/naga/wgsl_errors.rs b/naga/tests/naga/wgsl_errors.rs index 4a4ee7f8e..635e7b96e 100644 --- a/naga/tests/naga/wgsl_errors.rs +++ b/naga/tests/naga/wgsl_errors.rs @@ -5748,3 +5748,70 @@ fn user_locations_not_accepted_in_compute_entry_point_arguments() { ) } } + +#[test] +fn ray_query_store() { + // ray queries cannot be stored to despite them being a `var` + check_validation! { + r#" + enable wgpu_ray_query; + + @compute @workgroup_size(1) + fn main() { + var rq: ray_query; + var rq_2: ray_query; + rq = rq_2; + } + "#: + Err(naga::valid::ValidationError::EntryPoint { + stage: naga::ShaderStage::Compute, + source: naga::valid::EntryPointError::Function( + naga::valid::FunctionError::RayQueryStore(_) + ), + .. + }), + Capabilities::RAY_QUERY + } +} + +#[test] +fn ray_query_initializer() { + // ray queries cannot have initializers + check_validation! { + r#" + enable wgpu_ray_query; + + @compute @workgroup_size(1) + fn main() { + var rq: ray_query = ray_query(); + } + "#: + Err(naga::valid::ValidationError::EntryPoint { + stage: naga::ShaderStage::Compute, + source: naga::valid::EntryPointError::Function( + naga::valid::FunctionError::LocalVariable { + source: naga::valid::LocalVariableError::RayQueryWithInitializeExpression, + .. + }, + ), + .. + }), + Capabilities::RAY_QUERY + } +} + +#[test] +fn ray_query_let() { + check_error_matches( + " + enable wgpu_ray_query; + + @compute @workgroup_size(1) + fn main() { + var rq: ray_query; + let _rq_1 = rq; + } + ", + "Ray query with initialize", + ); +} diff --git a/naga/tests/out/hlsl/wgsl-9890-no-rq-hoist.hlsl b/naga/tests/out/hlsl/wgsl-9890-no-rq-hoist.hlsl new file mode 100644 index 000000000..f5059b334 --- /dev/null +++ b/naga/tests/out/hlsl/wgsl-9890-no-rq-hoist.hlsl @@ -0,0 +1,98 @@ +struct RayDesc_ { + uint flags; + uint cull_mask; + float tmin; + float tmax; + float3 origin; + int _pad5_0; + float3 dir; + int _end_pad_0; +}; + +RayDesc RayDescFromRayDesc_(RayDesc_ arg0) { + RayDesc ret = (RayDesc)0; + ret.Origin = arg0.origin; + ret.TMin = arg0.tmin; + ret.Direction = arg0.dir; + ret.TMax = arg0.tmax; + return ret; +} + +RaytracingAccelerationStructure acc : register(t0); + +RayDesc_ ConstructRayDesc_(uint arg0, uint arg1, float arg2, float arg3, float3 arg4, float3 arg5) { + RayDesc_ ret = (RayDesc_)0; + ret.flags = arg0; + ret.cull_mask = arg1; + ret.tmin = arg2; + ret.tmax = arg3; + ret.origin = arg4; + ret.dir = arg5; + return ret; +} + +[numthreads(1, 1, 1)] +void main() +{ + uint i = 0u; + RayQuery sq; + uint naga_query_init_tracker_for_sq = 0; + + uint2 loop_bound = uint2(4294967295u, 4294967295u); + bool loop_init = true; + while(true) { + if (all(loop_bound == uint2(0u, 0u))) { break; } + loop_bound -= uint2(loop_bound.y == 0u, 1u); + if (!loop_init) { + uint _e21 = i; + i = (_e21 + 1u); + } + loop_init = false; + uint _e2 = i; + if ((_e2 < 4u)) { + } else { + break; + } + { + naga_query_init_tracker_for_sq = 0u; + uint _e9 = i; + { + RayDesc_ naga_desc = ConstructRayDesc_(1u, 255u, 0.001, 1000.0, (float(_e9)).xxx, float3(0.0, -1.0, 0.0)); + float naga_tmin = naga_desc.tmin; + float naga_tmax = naga_desc.tmax; + float3 naga_origin = naga_desc.origin; + float3 naga_dir = naga_desc.dir; + uint naga_flags = naga_desc.flags; + bool naga_tmin_valid = (naga_tmin >= 0.0) && (naga_tmin <= naga_tmax) && !(((asuint(naga_tmin) & 2139095040) == 2139095040) && ((asuint(naga_tmin) & 0x7fffff) != 0)); + bool naga_tmax_valid = !(((asuint(naga_tmax) & 2139095040) == 2139095040) && ((asuint(naga_tmax) & 0x7fffff) != 0)); + bool naga_origin_valid = !any((((asuint(naga_origin) & 2139095040) == 2139095040) && ((asuint(naga_origin) & 0x7fffff) != 0))); + bool naga_dir_valid = !any((((asuint(naga_dir) & 2139095040) == 2139095040) && ((asuint(naga_dir) & 0x7fffff) != 0))); + bool naga_contains_opaque = ((naga_flags & 1) == 1); + bool naga_contains_no_opaque = ((naga_flags & 2) == 2); + bool naga_contains_cull_opaque = ((naga_flags & 64) == 64); + bool naga_contains_cull_no_opaque = ((naga_flags & 128) == 128); + bool naga_contains_cull_front = ((naga_flags & 32) == 32); + bool naga_contains_cull_back = ((naga_flags & 16) == 16); + bool naga_contains_skip_triangles = ((naga_flags & 256) == 256); + bool naga_contains_skip_aabbs = ((naga_flags & 512) == 512); + bool naga_contains_skip_triangles_aabbs = (naga_contains_skip_aabbs && naga_contains_skip_triangles) ; + bool naga_contains_skip_triangles_cull = (naga_contains_cull_front && naga_contains_skip_triangles) || (naga_contains_cull_front && naga_contains_cull_back) || (naga_contains_cull_back && naga_contains_skip_triangles) ; + bool naga_contains_multiple_opaque = (naga_contains_cull_no_opaque && naga_contains_opaque) || (naga_contains_cull_no_opaque && naga_contains_no_opaque) || (naga_contains_cull_no_opaque && naga_contains_cull_opaque) || (naga_contains_cull_opaque && naga_contains_opaque) || (naga_contains_cull_opaque && naga_contains_no_opaque) || (naga_contains_no_opaque && naga_contains_opaque) ; + if (naga_tmin_valid && naga_tmax_valid && naga_origin_valid && naga_dir_valid && !(naga_contains_skip_triangles_aabbs || naga_contains_skip_triangles_cull || naga_contains_multiple_opaque)) { + naga_query_init_tracker_for_sq = naga_query_init_tracker_for_sq | 1; + sq.TraceRayInline(acc, naga_desc.flags, naga_desc.cull_mask, RayDescFromRayDesc_(naga_desc)); + } + } + bool _e19 = false; + { + bool naga_has_initialized = ((naga_query_init_tracker_for_sq & 1) == 1); + bool naga_has_finished = ((naga_query_init_tracker_for_sq & 4) == 4); + if (naga_has_initialized && !naga_has_finished) { + _e19 = sq.Proceed(); + naga_query_init_tracker_for_sq = naga_query_init_tracker_for_sq | 2; + if (!_e19) { naga_query_init_tracker_for_sq = naga_query_init_tracker_for_sq | 4; } + }} + } + } + return; +} diff --git a/naga/tests/out/hlsl/wgsl-9890-no-rq-hoist.ron b/naga/tests/out/hlsl/wgsl-9890-no-rq-hoist.ron new file mode 100644 index 000000000..d0d1aaaa0 --- /dev/null +++ b/naga/tests/out/hlsl/wgsl-9890-no-rq-hoist.ron @@ -0,0 +1,16 @@ +( + vertex:[ + ], + fragment:[ + ], + compute:[ + ( + entry_point:"main", + target_profile:"cs_6_5", + ), + ], + task:[ + ], + mesh:[ + ], +) diff --git a/naga/tests/out/msl/wgsl-9890-no-rq-hoist.metal b/naga/tests/out/msl/wgsl-9890-no-rq-hoist.metal new file mode 100644 index 000000000..7cb2a4761 --- /dev/null +++ b/naga/tests/out/msl/wgsl-9890-no-rq-hoist.metal @@ -0,0 +1,77 @@ +// language: metal2.4 +#include +#include + +using metal::uint; + +struct RayDesc { + uint flags; + uint cull_mask; + float tmin; + float tmax; + metal::float3 origin; + metal::float3 dir; +}; + +[[max_total_threads_per_threadgroup(1)]] kernel void main_( + metal::raytracing::instance_acceleration_structure acc [[user(fake0)]] +) { + uint i = 0u; + metal::raytracing::intersection_query sq = {}; + uint naga_query_init_tracker_for_sq = 0u; + float naga_query_tmax_tracker_for_sq = 0.0; + uint2 loop_bound = uint2(4294967295u); + bool loop_init = true; + while(true) { + if (metal::all(loop_bound == uint2(0u))) { break; } + loop_bound -= uint2(loop_bound.y == 0u, 1u); + if (!loop_init) { + uint _e21 = i; + i = _e21 + 1u; + } + loop_init = false; + uint _e2 = i; + if (_e2 < 4u) { + } else { + break; + } + { + naga_query_init_tracker_for_sq = 0u; + uint _e9 = i; + RayDesc _e18 = RayDesc {1u, 255u, 0.001, 1000.0, metal::float3(static_cast(_e9)), metal::float3(0.0, -1.0, 0.0)}; + { + RayDesc desc = _e18; + metal::raytracing::intersection_params params; + metal::raytracing::opacity_cull_mode cull_mode = + (desc.flags & 64) != 0 ? metal::raytracing::opacity_cull_mode::opaque : ( + (desc.flags & 128) != 0 ? metal::raytracing::opacity_cull_mode::non_opaque : metal::raytracing::opacity_cull_mode::none + ); + params.set_opacity_cull_mode(cull_mode); + bool force_opacity = cull_mode == metal::raytracing::opacity_cull_mode::none; + if (force_opacity) { + params.force_opacity( + (desc.flags & 1) != 0 ? metal::raytracing::forced_opacity::opaque : ( + (desc.flags & 2) != 0 ? metal::raytracing::forced_opacity::non_opaque : metal::raytracing::forced_opacity::none + ) + ); + } + params.accept_any_intersection((desc.flags & 4) != 0); + metal::raytracing::ray ray = metal::raytracing::ray(desc.origin, desc.dir, desc.tmin, desc.tmax); + bool invalid_nan_infs = ((as_type(desc.origin.x) & 2139095040) == 2139095040) || ((as_type(desc.origin.y) & 2139095040) == 2139095040) || ((as_type(desc.origin.z) & 2139095040) == 2139095040) || ((as_type(desc.dir.x) & 2139095040) == 2139095040) || ((as_type(desc.dir.y) & 2139095040) == 2139095040) || ((as_type(desc.dir.z) & 2139095040) == 2139095040) || ((as_type(desc.tmin) & 2139095040) == 2139095040) || (((as_type(desc.tmax) & 2139095040) == 2139095040) && ((as_type(desc.tmax) & 0x7fffff) != 0)); + bool invalid_t = (desc.tmin > desc.tmax) || (desc.tmin < 0.0); + bool invalid_dir = metal::all(metal::abs(desc.dir) == 0.0); + if (!(invalid_dir || invalid_t || invalid_nan_infs)) { + sq.reset(ray,acc, desc.cull_mask, params); + naga_query_init_tracker_for_sq = 1; + naga_query_tmax_tracker_for_sq = desc.tmax; + } + } + bool _e19 = false; + if (((naga_query_init_tracker_for_sq & 1) == 1) && !((naga_query_init_tracker_for_sq & 4) == 4)) { + _e19 = sq.next(); + naga_query_init_tracker_for_sq = naga_query_init_tracker_for_sq | (_e19 ? 2: 6); + } + } + } + return; +} diff --git a/naga/tests/out/spv/wgsl-9890-no-rq-hoist.spvasm b/naga/tests/out/spv/wgsl-9890-no-rq-hoist.spvasm new file mode 100644 index 000000000..d90817c91 --- /dev/null +++ b/naga/tests/out/spv/wgsl-9890-no-rq-hoist.spvasm @@ -0,0 +1,223 @@ +; SPIR-V +; Version: 1.1 +; Generator: rspirv +; Bound: 171 +OpCapability Shader +OpCapability RayQueryKHR +OpExtension "SPV_KHR_ray_query" +%1 = OpExtInstImport "GLSL.std.450" +OpMemoryModel Logical GLSL450 +OpEntryPoint GLCompute %12 "main" +OpExecutionMode %12 LocalSize 1 1 1 +OpMemberDecorate %8 0 Offset 0 +OpMemberDecorate %8 1 Offset 4 +OpMemberDecorate %8 2 Offset 8 +OpMemberDecorate %8 3 Offset 12 +OpMemberDecorate %8 4 Offset 16 +OpMemberDecorate %8 5 Offset 32 +OpDecorate %9 DescriptorSet 0 +OpDecorate %9 Binding 0 +%2 = OpTypeVoid +%3 = OpTypeAccelerationStructureKHR +%4 = OpTypeInt 32 0 +%5 = OpTypeRayQueryKHR +%6 = OpTypeFloat 32 +%7 = OpTypeVector %6 3 +%8 = OpTypeStruct %4 %4 %6 %6 %7 %7 +%10 = OpTypePointer UniformConstant %3 +%9 = OpVariable %10 UniformConstant +%13 = OpTypeFunction %2 +%15 = OpConstant %4 0 +%16 = OpConstant %4 4 +%17 = OpConstant %4 1 +%18 = OpConstant %4 255 +%19 = OpConstant %6 0.001 +%20 = OpConstant %6 1000 +%21 = OpConstant %6 0 +%22 = OpConstant %6 -1 +%23 = OpConstantComposite %7 %21 %22 %21 +%25 = OpTypePointer Function %4 +%27 = OpTypePointer Function %5 +%29 = OpTypePointer Function %6 +%36 = OpTypeVector %4 2 +%37 = OpTypePointer Function %36 +%38 = OpTypeBool +%39 = OpTypeVector %38 2 +%40 = OpConstantComposite %36 %15 %15 +%41 = OpConstant %4 4294967295 +%42 = OpConstantComposite %36 %41 %41 +%64 = OpTypeFunction %2 %27 %3 %8 %25 %29 +%72 = OpTypeVector %38 3 +%93 = OpConstant %4 256 +%96 = OpConstant %4 512 +%101 = OpConstant %4 16 +%104 = OpConstant %4 32 +%115 = OpConstant %4 2 +%118 = OpConstant %4 64 +%121 = OpConstant %4 128 +%147 = OpTypePointer Function %38 +%148 = OpTypeFunction %38 %27 %25 +%154 = OpConstantFalse %38 +%165 = OpConstant %4 6 +%65 = OpFunction %2 None %64 +%66 = OpFunctionParameter %27 +%67 = OpFunctionParameter %3 +%68 = OpFunctionParameter %8 +%69 = OpFunctionParameter %25 +%70 = OpFunctionParameter %29 +%71 = OpLabel +%73 = OpCompositeExtract %4 %68 0 +%74 = OpCompositeExtract %4 %68 1 +%75 = OpCompositeExtract %6 %68 2 +%76 = OpCompositeExtract %6 %68 3 +%77 = OpCompositeExtract %7 %68 4 +%78 = OpCompositeExtract %7 %68 5 +%79 = OpFOrdLessThanEqual %38 %75 %76 +%80 = OpFOrdGreaterThanEqual %38 %75 %21 +%81 = OpIsInf %72 %77 +%82 = OpAny %38 %81 +%83 = OpIsNan %72 %77 +%84 = OpAny %38 %83 +%85 = OpLogicalOr %38 %84 %82 +%86 = OpLogicalNot %38 %85 +%87 = OpIsInf %72 %78 +%88 = OpAny %38 %87 +%89 = OpIsNan %72 %78 +%90 = OpAny %38 %89 +%91 = OpLogicalOr %38 %90 %88 +%92 = OpLogicalNot %38 %91 +%94 = OpBitwiseAnd %4 %73 %93 +%95 = OpINotEqual %38 %94 %15 +%97 = OpBitwiseAnd %4 %73 %96 +%98 = OpINotEqual %38 %97 %15 +%99 = OpLogicalAnd %38 %98 %95 +%100 = OpLogicalNot %38 %99 +%102 = OpBitwiseAnd %4 %73 %101 +%103 = OpINotEqual %38 %102 %15 +%105 = OpBitwiseAnd %4 %73 %104 +%106 = OpINotEqual %38 %105 %15 +%107 = OpLogicalAnd %38 %106 %95 +%108 = OpLogicalAnd %38 %106 %103 +%109 = OpLogicalAnd %38 %103 %95 +%110 = OpLogicalOr %38 %109 %107 +%111 = OpLogicalOr %38 %110 %108 +%112 = OpLogicalNot %38 %111 +%113 = OpBitwiseAnd %4 %73 %17 +%114 = OpINotEqual %38 %113 %15 +%116 = OpBitwiseAnd %4 %73 %115 +%117 = OpINotEqual %38 %116 %15 +%119 = OpBitwiseAnd %4 %73 %118 +%120 = OpINotEqual %38 %119 %15 +%122 = OpBitwiseAnd %4 %73 %121 +%123 = OpINotEqual %38 %122 %15 +%124 = OpLogicalAnd %38 %123 %114 +%125 = OpLogicalAnd %38 %123 %117 +%126 = OpLogicalAnd %38 %123 %120 +%127 = OpLogicalAnd %38 %120 %114 +%128 = OpLogicalAnd %38 %120 %117 +%129 = OpLogicalAnd %38 %117 %114 +%130 = OpLogicalOr %38 %129 %124 +%131 = OpLogicalOr %38 %130 %125 +%132 = OpLogicalOr %38 %131 %126 +%133 = OpLogicalOr %38 %132 %127 +%134 = OpLogicalOr %38 %133 %128 +%135 = OpLogicalNot %38 %134 +%136 = OpLogicalAnd %38 %135 %79 +%137 = OpLogicalAnd %38 %136 %80 +%138 = OpLogicalAnd %38 %137 %86 +%139 = OpLogicalAnd %38 %138 %92 +%140 = OpLogicalAnd %38 %139 %100 +%141 = OpLogicalAnd %38 %140 %112 +OpStore %70 %76 +OpSelectionMerge %142 None +OpBranchConditional %141 %144 %143 +%144 = OpLabel +OpRayQueryInitializeKHR %66 %67 %73 %74 %77 %75 %78 %76 +OpStore %69 %17 +OpBranch %142 +%143 = OpLabel +OpBranch %142 +%142 = OpLabel +OpReturn +OpFunctionEnd +%149 = OpFunction %38 None %148 +%150 = OpFunctionParameter %27 +%151 = OpFunctionParameter %25 +%152 = OpLabel +%153 = OpVariable %147 Function %154 +%155 = OpLoad %4 %151 +%158 = OpBitwiseAnd %4 %155 %17 +%159 = OpINotEqual %38 %158 %15 +%160 = OpBitwiseAnd %4 %155 %16 +%161 = OpINotEqual %38 %160 %15 +%162 = OpLogicalNot %38 %161 +%163 = OpLogicalAnd %38 %162 %159 +OpSelectionMerge %156 None +OpBranchConditional %163 %157 %156 +%157 = OpLabel +%164 = OpRayQueryProceedKHR %38 %150 +OpStore %153 %164 +%166 = OpSelect %4 %164 %115 %165 +%167 = OpBitwiseOr %4 %155 %166 +OpStore %151 %167 +OpBranch %156 +%156 = OpLabel +%168 = OpLoad %38 %153 +OpReturnValue %168 +OpFunctionEnd +%12 = OpFunction %2 None %13 +%11 = OpLabel +%24 = OpVariable %25 Function %15 +%26 = OpVariable %27 Function +%28 = OpVariable %25 Function %15 +%30 = OpVariable %29 Function %21 +%43 = OpVariable %37 Function %42 +%14 = OpLoad %3 %9 +OpBranch %31 +%31 = OpLabel +OpBranch %32 +%32 = OpLabel +OpLoopMerge %33 %35 None +OpBranch %44 +%44 = OpLabel +%45 = OpLoad %36 %43 +%46 = OpIEqual %39 %40 %45 +%47 = OpAll %38 %46 +OpSelectionMerge %48 None +OpBranchConditional %47 %33 %48 +%48 = OpLabel +%49 = OpCompositeExtract %4 %45 1 +%50 = OpIEqual %38 %49 %15 +%51 = OpSelect %4 %50 %17 %15 +%52 = OpCompositeConstruct %36 %51 %17 +%53 = OpISub %36 %45 %52 +OpStore %43 %53 +OpBranch %34 +%34 = OpLabel +%54 = OpLoad %4 %24 +%55 = OpULessThan %38 %54 %16 +OpSelectionMerge %56 None +OpBranchConditional %55 %56 %57 +%57 = OpLabel +OpBranch %33 +%56 = OpLabel +OpBranch %58 +%58 = OpLabel +OpStore %28 %15 +%60 = OpLoad %4 %24 +%61 = OpConvertUToF %6 %60 +%62 = OpCompositeConstruct %7 %61 %61 %61 +%63 = OpCompositeConstruct %8 %17 %18 %19 %20 %62 %23 +%145 = OpFunctionCall %2 %65 %26 %14 %63 %28 %30 +%146 = OpFunctionCall %38 %149 %26 %28 +OpBranch %59 +%59 = OpLabel +OpBranch %35 +%35 = OpLabel +%169 = OpLoad %4 %24 +%170 = OpIAdd %4 %169 %17 +OpStore %24 %170 +OpBranch %32 +%33 = OpLabel +OpReturn +OpFunctionEnd \ No newline at end of file diff --git a/naga/tests/out/spv/wgsl-9890-no-rq-hoist.spvasm.glsl b/naga/tests/out/spv/wgsl-9890-no-rq-hoist.spvasm.glsl new file mode 100644 index 000000000..547c63dc0 --- /dev/null +++ b/naga/tests/out/spv/wgsl-9890-no-rq-hoist.spvasm.glsl @@ -0,0 +1,74 @@ +#version 460 +#extension GL_EXT_ray_query : require +layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in; + +struct _8 +{ + uint _m0; + uint _m1; + float _m2; + float _m3; + vec3 _m4; + vec3 _m5; +}; + +layout(set = 0, binding = 0) uniform accelerationStructureEXT _9; + +void _65(rayQueryEXT _66, accelerationStructureEXT _67, _8 _68, inout uint _69, out float _70) +{ + bool _95 = (_68._m0 & 256u) != 0u; + bool _103 = (_68._m0 & 16u) != 0u; + bool _106 = (_68._m0 & 32u) != 0u; + bool _114 = (_68._m0 & 1u) != 0u; + bool _117 = (_68._m0 & 2u) != 0u; + bool _120 = (_68._m0 & 64u) != 0u; + bool _123 = (_68._m0 & 128u) != 0u; + _70 = _68._m3; + if (((((((!((((((_117 && _114) || (_123 && _114)) || (_123 && _117)) || (_123 && _120)) || (_120 && _114)) || (_120 && _117))) && (_68._m2 <= _68._m3)) && (_68._m2 >= 0.0)) && (!(any(isnan(_68._m4)) || any(isinf(_68._m4))))) && (!(any(isnan(_68._m5)) || any(isinf(_68._m5))))) && (!(((_68._m0 & 512u) != 0u) && _95))) && (!(((_103 && _95) || (_106 && _95)) || (_106 && _103)))) + { + rayQueryInitializeEXT(_66, _67, _68._m0, _68._m1, _68._m4, _68._m2, _68._m5, _68._m3); + _69 = 1u; + } + else + { + } +} + +bool _149(rayQueryEXT _150, inout uint _151) +{ + bool _153 = false; + if ((!((_151 & 4u) != 0u)) && ((_151 & 1u) != 0u)) + { + bool _164 = rayQueryProceedEXT(_150); + _153 = _164; + _151 |= (_164 ? 2u : 6u); + } + return _153; +} + +void main() +{ + uint _24 = 0u; + uint _28 = 0u; + float _30 = 0.0; + uvec2 _43 = uvec2(4294967295u); + rayQueryEXT _26; + for (;;) + { + if (all(equal(uvec2(0u), _43))) + { + break; + } + _43 -= uvec2(uint(_43.y == 0u), 1u); + if (!(_24 < 4u)) + { + break; + } + _28 = 0u; + _65(_26, _9, _8(1u, 255u, 0.001000000047497451305389404296875, 1000.0, vec3(float(_24)), vec3(0.0, -1.0, 0.0)), _28, _30); + bool _146 = _149(_26, _28); + _24++; + continue; + } +} +