tree ac58cf161dd8ec6254eaf41227f110dddb010bef
parent 46492aa45ae5da92eb1ec8a8051d6a4a98df70af
author Karol Herbst <karolherbst@gmail.com> 1651584182 +0200
committer GitHub <noreply@github.com> 1651584182 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJicSy2CRBK7hj4Ov3rIwAAqtsIAKPew+7NMCwDcLc2O5dk3uMP
 pa/keMkq7XTjpcqLjI2yKy5fwIjbqezfyiPf1T+bDpo7dGaDQ/6nUq5vGRTg/X2p
 vpGjVo7PZ58dFRGFWh2fkowrTO8qwi6UWDFolkp4nvRNHNFSVLVQKyF7XOSMpK+D
 rHoV9MvtPxzIyWCxlrHL0Evn4rnwK8BhVZl82QxQmrlgbBNQ//TSk5ERMEXk+BRg
 h5eowC4mylZq1T/fqL8+adL2VeR4vROXNpmAbFDzeq0UZZytfxyZOke+5ttoG+0J
 xym+3mKbqeuaa1P46BSlvCKzM6xF2FK20UGTIBcMz1yNPNgilAPywYzZIGe4RrQ=
 =G4i4
 -----END PGP SIGNATURE-----
 

linker: Recalculate interface variables (#4784)

* linker: Recalculate interface variables

By resolving extern symbols Entry Points might access variables they
hadn't declared before.

* test/linker: add test to verify linked spir-vs importing functions validate

Without the fix Validate will complain about:

"ERROR: 9: Interface variable id <5> is used by entry point 'bar' id <1>, but is not listed as an interface\n  %5 = OpVariable %_ptr_Input_v3uint Input\n"