Commit Graph
9074 Commits
Author SHA1 Message Date
Erich Gubler ded2e7f9f1 refactor(naga): use workspace version of ron 2025-03-26 16:03:03 -04:00
teoxoy 9a2b5fdb70 abstract away usage of scratch space for buffer barriers and unique index iterators 2025-03-26 18:26:31 +00:00
teoxoy 3705928273 [validate_draw] refactor out an is_bit_set function 2025-03-26 18:26:31 +00:00
teoxoy 7d15c511de move indirect validation code to its own folder
rename items appropriately
internalize indirect buffer bind groups
2025-03-26 18:26:31 +00:00
teoxoy ef622c1061 validate multi draw indirect calls 2025-03-26 18:26:31 +00:00
teoxoy 2ab3b6da8d guarantee DownlevelFlags::COMPUTE_SHADERS when DownlevelFlags::INDIRECT_EXECUTION is enabled 2025-03-26 18:26:31 +00:00
teoxoy a2878db5f2 add indirect_buffer_offsets test 2025-03-26 18:26:31 +00:00
teoxoy 0285e60984 Replace the indirect-validation feature with InstanceFlags::VALIDATION_INDIRECT_CALL.
With the only caveat that device creation will now panic if the `wgsl` feature is not enabled, `InstanceFlags::VALIDATION_INDIRECT_CALL` is set and the device supports `DownlevelFlags::INDIRECT_EXECUTION`.
2025-03-26 18:26:31 +00:00
teoxoy 53c2d15e0b implement indirect draw validation 2025-03-26 18:26:31 +00:00
Andy Leiserson 90afc88e76 [naga] Gracefully handle span lookup with no module source (#7390)
Fixes #7165
2025-03-26 11:19:11 -04:00
Jamie Nicol e037f4bc48 [naga wgsl-in] Implement unary negation during const evaluation for Literal::F64 (#7431)
This not being implemented made it impossible to express negative f64
literals. This is now fixed, and we've added a test.
2025-03-26 08:18:52 -04:00
Jamie Nicol 7e0e1e2803 [naga wgsl-in] Clamp negative f16 values to 0 when converting to unsigned integers during const evaluation (#7421)
This avoids a panic due to f16::to_u32()/f16::to_u64() returning None
when the value of the f16 is <= -1.0. The correct behaviour when
converting from a floating point to an integer when the value is out
of range is to clamp to the nearest value that is representable in
both the source and destination type. ie zero for negative numbers.
2025-03-26 09:04:56 +00:00
Jim Blandy 61b70cfdb1 [naga] Check the type of ImageQuery::Size's level parameter. (#7426)
Require that the `level` operand of an `ImageQuery::Size` expression
is `i32` or `u32`, per spec.

Without this fix, the following WGSL:

    @group(0) @binding(0)
    var t: texture_1d<f32>;
    fn f() -> u32 {
      return textureDimensions(t, false);
    }

produces the following invalid HLSL:

    Texture1D<float4> t : register(t0);

    uint NagaMipDimensions1D(Texture1D<float4> tex, uint mip_level)
    {
        uint4 ret;
        tex.GetDimensions(mip_level, ret.x, ret.y);
        return ret.x;
    }

    uint f()
    {
        return NagaMipDimensions1D(t, false);
    }
2025-03-26 03:38:38 +00:00
Zachary Harrold 175b66c796 Update codespan-reporting to 0.12 (#7398)
* Update `codespan-reporting` to 0.12

* Use explicit path for `term::termcolor`

* Revert changes to `Cargo.lock`
2025-03-26 02:10:30 +00:00
Jamie Nicol 7b6ff5f554 [naga wgsl-out] Represent min value i64 literals as -9223372036854775807li - 1li (#7424)
ie the second-most negative value minus 1.

The most negative value of an integer type is not directly expressible
in WGSL, as it relies on applying the unary negation operator to a
value which is one larger than the largest value representable by the
type.

To avoid this issue for i32, we negate the required value as an
AbstractInt before converting to i32. AbstractInt, being 64 bits, is
capable of representing the maximum i32 value + 1.

However, for i64 this is not the case. Instead this patch makes us
express the mimimum i64 value as the second most negative i64 value,
minus 1, ie `-9223372036854775807li - 1li`, thereby avoiding the
issue.
2025-03-25 14:36:14 -04:00
sagudev 94dd3a7dc7 Fix some cfg guards (#7418)
All guards should actually refer to `wgpu_core` instead of `native`

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
2025-03-25 08:25:59 -04:00
Erich Gubler 299079fb69 chore: remove unnecessarily allow'd unused_braces (#7416) 2025-03-24 22:23:24 +00:00
Erich Gubler 958528fb14 fix(wgsl-in): increase brace limit to 127 (#7412) 2025-03-24 21:43:21 +00:00
Erich Gubler 97dbdc7d75 fix(wgsl-in): allow f16s in overrides (#7411) 2025-03-24 16:06:27 -04:00
Jim Blandy f0ff173f82 [naga] Implement constant evaluation for the cross builtin. (#7404)
Add support for `naga::ir::MathFunction::Cross` to
`naga::proc::constant_evaluator`.

In the tests:

- Change `naga/tests/in/wgsl/cross.wgsl` to use more interesting
  argument values. Rather than passing the same vector twice, which
  yields a cross product of zero, pass in the x and y unit vectors,
  whose cross product is the z unit vector. Update snapshot output.

- Replace `validation::bad_cross_builtin_args` with a new test,
  `builtin_cross_product_args`, that is written more in the style of
  the other tests in this module, and does not depend on the WGSL
  front end. Because this PR changes the behavior of the constant
  evaluator, this test stopped behaving as expected.

- In `wgsl_errors::check`, move a `panic!` out of a closure so that
  the `#[track_caller]` attribute works properly.
2025-03-24 10:55:22 +01:00
Christian Legnitto 10cd1ccd8c [spv_in] Finish emitter after function arguments (#7397)
Fixes https://github.com/gfx-rs/wgpu/issues/7358.
2025-03-24 10:36:30 +01:00
Bruce Mitchener ccaf9a84f8 Fix clippy::implicit_saturating_sub lints (#7395) 2025-03-22 13:17:34 -04:00
Bruce Mitchener edd0ef80af Fix clippy::manual_repeat_n lints (#7394) 2025-03-22 16:18:34 +00:00
Erich Gubler 1e172b2e14 test: repair multi-instance tests (#7388) 2025-03-21 13:25:31 -04:00
Connor Fitzgerald c37a005f63 Make target defaults align with "butterfly" target set (#7379) 2025-03-21 11:41:06 -04:00
Jamie NicolandErich Gubler 894d0369b5 [naga spv-out msl-out hlsl-out] Make infinite loop workaround count down instead of up (#7372)
[naga spv-out msl-out hlsl-out] Make infinite loop workaround count down instead of up

To avoid generating code containing infinite loops, and therefore
incurring the wrath of undefined behaviour, we insert a counter into
each loop that will break after 2^64 iterations. This was previously
implemented as two u32 variables counting up from zero.

We have been informed that this construct can cause certain Intel
drivers to hang. Instead, we must count down from u32::MAX. Counting
down is more fun, anyway.

Co-authored-by: Erich Gubler <erichdongubler@gmail.com>
2025-03-21 08:24:17 +00:00
Bruce Mitchener f89ede7cd8 [doc] Fix unbalanced backticks (#7385) 2025-03-21 03:03:37 +00:00
Bruce Mitchener b7e7d7ce7a Fix clippy::manual_contains lints (#7384) 2025-03-20 21:55:52 -04:00
Andy Leiserson ebf87526dd [doc] Correct the doc comment for Expression::FunctionArgument (#7382) 2025-03-20 19:29:44 -04:00
Jamie Nicol 3bbd97cf0d [naga wgsl-in] Allow explicit cast from AbstractFloat to integer types (#7377)
And from either AbstractFloat or AbstractInt to bool.

AbstractFloat to integer was presumably not implemented as *automatic*
conversion between those types is not allowed. However, explicit
conversions (for example `i32(1.0)`) are allowed, and are implemented
during const evaluation using the same code path in
ConstantEvaluator::cast().

The integer conversion constructors treat AbstractFloats as any other
floating point type, meaning we must follow the scalar floating point
to integral conversion algorithm [1]. This specifies:

    To convert a floating point scalar value X to an integer scalar
    type T:
    * If X is a NaN, the result is an indeterminate value in T.
    * If X is exactly representable in the target type T, then the
      result is that value.
    * Otherwise, the result is the value in T closest to truncate(X)
      and also exactly representable in the original floating point
      type.

Fortunately a rust cast satisfies all these conditions apart from the
result being exactly representable in the original floating point
type. However, as i32::MIN, i32::MAX, u32::MIN, and u32::MAX are all
representable by f64 (the underlying type of AbstractFloat), this is
not an issue.

For i64 and u64 using a rust cast will not meet that requirement, but
as these types are not present in the WGSL spec we are free to ignore
that.

[1] https://www.w3.org/TR/WGSL/#floating-point-conversion
2025-03-20 15:28:30 -04:00
Connor Fitzgerald 79a5cd557c Remove vestigial snapshot outputs (#7380) 2025-03-20 15:21:18 -04:00
Connor Fitzgerald db4cb26858 Allow overriding instance flags in tests (#7374) 2025-03-20 11:35:54 -04:00
Jamie Nicol 187e1a6967 [naga wgsl-in] Reject vector constructors with incorrect number of components during const evaluation.
A vector constructor with multiple arguments is represented in IR as a
Compose expression. These can be nested, for example due to code such
as this: `vec4(1, vec3(2, vec2(3, 4)))`. The total number of
components of each argument must match the vector size, meaning
`vec4(1, 2, 3, 4, 5)` is invalid. The validation pass already catches
such occurences. However, validation runs after constant evaluation,
meaning this can cause issues if the expression is evaluated as part
of a const expression.

When applying an operation to a vector compose during const
evaluation, we typically "flatten" the vector using the function
`proc::flatten_compose()`. This silently truncates the list of
components to the size implied by the type, meaning invalid code is
accepted.

This patch validates that the total number of components in a Compose
expression, once flattened, matches the size implied by the type. We
do so once as each expression is registered to avoid needing to handle
this each time the expression is used in a const expression.

For nested compose expressions, the inner expressions will be registed
before the outer ones. This means we can trust that the size implied
by the inner expression's type is correct, as it will have already
been validated, and can therefore avoid recursing through each nested
expression when registering the outer expression.
2025-03-20 12:24:31 +00:00
Connor Fitzgerald 4687973c9a Use bytemuck instead of slice::from_raw_parts for transmutes (#7376) 2025-03-19 22:05:21 -04:00
c6286791fe feat: implement F16 support in shaders (#5701)
Co-authored-by: FL33TW00D <fleetwoodpersonal@gmail.com>
Co-authored-by: Connor Fitzgerald <connorwadefitzgerald@gmail.com>
Co-authored-by: ErichDonGubler <erichdongubler@gmail.com>
2025-03-19 16:26:50 +00:00
Kevin Reid b912232188 [naga] Make Level::next() public.
It doesn’t make sense to have `Level` public but not `Level::next()`.
2025-03-19 12:11:01 -04:00
Erich Gubler 47c72fa943 fix(wgsl-in,const-eval): use {float}::round_ties_even instead of polyfill for round 2025-03-19 11:21:57 -04:00
Jim Blandy 45b0df6adf [naga wgsl-in] Tweak logging in front::wgsl::lower::conversion. 2025-03-19 11:21:02 -04:00
Jim Blandy e82f52135b [naga wgsl-in] Use common type-formatting code.
Remove the `naga::front::wgsl::to_wgsl` module. Instead, use the
implementations of `naga::common::wgsl`'s `TryToWgsl` and
`TypeContext` traits.
2025-03-19 11:21:02 -04:00
Jim Blandy 3ec38a0a15 [naga wgsl] Add TryToWgsl::to_wgsl_for_diagnostics.
Add a new method to the `naga::common::wgsl::TryToWgsl` trait,
`to_wgsl_for_diagnostics`, which always returns a `String`, falling
back to the `Debug` representation of the type if necessary.

Provide a custom implementation for `Scalar` that shows abstract types
in a reasonable way.
2025-03-19 11:21:02 -04:00
Jim Blandy 62d49918fd [naga wgsl] Provide defaults for TypeContext non-WGSL methods.
Provide default implementations for the `write_non_wgsl_inner` and
`write_non_wgsl_scalar` methods of `naga::common::wgsl::TypeContext`.

We will be implementing this trait for various types in the WGSL front
end and the validator, and almost all of these applications will need
basically identical implementations of these methods.
2025-03-19 11:21:02 -04:00
Jim Blandy 13b8036b89 [naga wgsl] Add string creation methods to TypeContext.
Add new default methods, `type_to_string`, `type_inner_to_string`, and
`resolution_to_string` to the `naga::common::wgsl::TypeResolution`
trait, for generating WGSL source strings from these types.
2025-03-19 11:21:02 -04:00
Jim Blandy e17c0bdc17 [naga wgsl] Fix generics on naga::common::wgsl::TypeContext.
In `naga::common::wgsl::types`, move the type parameter `<W: Write>`
from the `TypeContext` trait itself to the individual methods of the
trait. It is very unlikely for Naga to need to be able to implement
`TypeContext`, but only for one particular kind of output stream.

The motivation for this change is that the old parameterization makes
it awkward to provide utility methods for generating `String`s on the
trait, which we do in subsequent commits. In order to write to a
`String`, such utility methods need `Self` to implement
`TypeContext<String>`, so you can add bounds to the methods like this:

    fn type_to_string(..., out: &mut W) -> ...
        where Self: TypeContext<String>
    {
        ... self.write(..., &mut string_buf)?;
    }

That will compile, but if you try to actually call it, Rust gets
confused. Remember, the above is not a method on
`TypeContext<String>`, it's a method on `TypeContext<W>` that uses
`TypeContext<String>` internally. So when you write
`ctx.type_to_string(...)`, Rust needs to decide whether `ctx`
implements `TypeContext<W>` for some completely unspecified `W`, and
asks for type annotations.

You could supply type annotations, but this would be basically
supplying some never-used type that implements `core::fmt::Write`.
Instead of

    ctx.type_to_string(handle)

you'd have to write

    TypeContext::<String>::type_to_string(ctx, handle)

which is dumb.

(I don't *think* this explanation belongs in the code, since it's an
explanation of a design *not* used, replaced by a design that's pretty
natural --- so I'll leave it here.)
2025-03-19 11:21:02 -04:00
Jim Blandy fc6d6c6483 [naga wgsl] Add write_type_resolution method to TypeContext.
Add a new default method, `write_type_resolution`, to the
`naga::common::wgsl::TypeResolution` trait, for writing
`TypeResolution` values as WGSL.
2025-03-19 11:21:02 -04:00
Jim Blandy 3b401670ae [naga wgsl-in] Clean up use directives in front::wgsl::error.
Put the `use` directives at the top of `front::wgsl::error` in the
usual order:
- identifiers defined by this crate itself
- identifiers defined  by other crates
- identifiers from the standard library

This commit should cause no change in behavior.
2025-03-19 11:21:02 -04:00
Jim Blandy 026628a739 [naga wgsl] Make formatting of non-WGSL types more flexible.
Extend the `naga::common::wgsl::TypeContext` trait with new methods,
`write_non_wgsl_inner` and `write_non_wgsl_scalar`, which are called
when `write_type`, `write_type_inner`, or `write_scalar` are presented
with Naga IR that cannot be expressed in WGSL. Delegating these cases
lets most uses of `unreachable!` be removed.

In the WGSL backend, implement `write_non_wgsl_inner` and
`write_non_wgsl_scalar` to call `unreachable!`, preserving existing
behavior.
2025-03-19 11:21:02 -04:00
Jim Blandy 2c4d2693f0 [naga wgsl] Move Scalar formatting into its own function.
In `naga::common::wgsl::types`, remove `unwrap_to_wgsl` from
`try_write_type_inner` and replace its uses with calls to a new trait
method, `write_scalar`, with a default definition. This should have no
effect on externally visible behavior, but it makes subsequent commits
easier to read.
2025-03-19 11:21:02 -04:00
Jim Blandy a79111922a [naga wgsl] Move guts of TypeInner formatting to a function.
Move the guts of the `naga::common::wgsl::TypeContext` trait's
`write_type_inner` method into a new function, `try_write_type_inner`,
private to the module.

This commit is only code motion; there should be no change to
behavior. Subsequent commits will introduce a private error type, with
the new function serving as a `try` block.
2025-03-19 11:21:02 -04:00
Jim Blandy 84cbf28ed9 [naga wgsl] Move ToWgsl and TryToWgsl into their own module.
In `naga::common::wgsl`, move the `ToWgsl` and `TryToWgsl` trait
definitions and impls into their own submodule, `to_wgsl`.

This change is only code motion; there should be no change in
behavior.
2025-03-19 11:21:02 -04:00
Jim Blandy bcb0f7ef3e [naga wgsl] Move diagnostics definitions into their own module.
In `naga::common::wgsl`, move `DisplayFilterableTriggeringRule` and
diagnostics-related impls into a new sub-module, `diagonostics`.

This change is only code motion; there should be no change in
behavior.
2025-03-19 11:21:02 -04:00