tree 61fa7a1742d0201254229d1c85c486692658f692
parent 2a1217513e1c5d881718c2a7f2afb951e1fe6305
author Danylo Piliaiev <danylo.piliaiev@globallogic.com> 1595862041 +0300
committer Marge Bot <eric+marge@anholt.net> 1597243337 +0000

anv/nir: Unify inputs_read/outputs_written between geometry stages

inputs_read/outputs_written are used for a shader stage to
determine the layout of input and output storage. Adjacent stages must
agree on the layout, so adjacent input/output bitfields must match.

Most of the time, cross-stage optimizations make that happen anyway,
but there are some cases (with special values like clip distances and
point size) where this doesn't happen.

Fixes crashes in dEQP-VK.subgroups.*.framebuffer.*_tess_eval

Closes: https://gitlab.freedesktop.org/mesa/mesa/-/issues/3210
Cc: <mesa-stable@lists.freedesktop.org>
Signed-off-by: Danylo Piliaiev <danylo.piliaiev@globallogic.com>
Reviewed-by: Tapani Pälli <tapani.palli@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6102>
