WebGL1: Forbid `#extension: disable` after non-preprocessor tokens

[ShabbyX]

WebGL1 says:

In the WebGL API, #extension directives may always occur after non-preprocessor tokens in GLSL ES 1.00 shaders. The scope of #extension directives in GLSL ES 1.00 shaders is always the whole shader, and #extension directives that occur later override those seen earlier for the whole shader.

Can we restrict this such that extensions cannot be disabled later in the shader after they were enabled? It's not a useful scenario to support, and it can be complicated to validate, for example if the shader enables an extension, use it (and pass validation) then disable it at the end of the shader.

Optionally (and less ideally), we could disallow extension disables after non-preprocessor tokens only if that extension was previously enabled by the shader, so the shader can't bypass validation like:

#extension Foo: enable
    use_tokens_from_foo();
#extension Foo: disable

[kenrussell]

It seems reasonable to me to restrict the use of #extension Foo: disable constructs as much as possible, given how problematic they are. Could other working group members weigh in? @kkinnunen-apple @RafaelCintron @ladyhavoc

[kkinnunen-apple]

Proposal would need some more exact language? I'm fairly sure I understand what you mean, but just to confirm:

that extensions cannot be disabled later in the shader after they were enabled?

I think that's the use-case of the #extension specific_extension:disable, to disable something after being enabled? Conversely, there is no use in disabling an extension before it has been enabled?

If I understand correctly, this is proposed to still be a use-case:

#extension all : enable
#extension specific_extension : disable

void main() {
...
}

Is the problem specific to disable, or does it also reproduce in enable?

• The shader does not enable an extension
• The shader uses the extension
• The shader enables the extension

It would appear that same validation code needs to still exist here..

[kkinnunen-apple]

Also, I think Geoff voiced the concern in the double underscore case, that we should have a goal to not deviate from standard GLSL unless specifically needed.

[lexaknyazev]

I'd read the current spec language as if only the last used directive matters, i.e., actual validation is postponed until all preprocessing is done. So if a shader does

#extension Foo: enable
    use_tokens_from_foo();
#extension Foo: disable

then it's the same as

#extension Foo: disable
    use_tokens_from_foo();

[kkinnunen-apple]

I'd read the current spec language as if only the last used directive matters, i.e., actual validation is postponed until all preprocessing is done.

IIUC, that's what @ShabbyX is saying is the problem. E.g. it's inconvenient, as you cannot strictly process the AST nodes as they come.

[lexaknyazev]

you cannot strictly process the AST nodes as they come

It's not possible to fully parse AST before processing directives like #define or #ifdef. Why is #extension different?

[ShabbyX]

Also, I think Geoff voiced the concern in the double underscore case, that we should have a goal to not deviate from standard GLSL unless specifically needed.

Yes, I had the same concern. In this case, WebGL1 has deviated from standard GLSL with the rationale that drivers / apps are buggy. My proposal is to reduce this deviation.

If I understand correctly, this is proposed to still be a use-case:

#extension all : enable
#extension specific_extension : disable

Yes, that's fine. #extension directives before non-preprocessor tokens are supported and behave exactly as standard GLSL.

IIUC, that's what @ShabbyX is saying is the problem. E.g. it's inconvenient, as you cannot strictly process the AST nodes as they come.

So I wasn't even considering enable. That's definitely not how it's implemented in ANGLE today; we immediately validate symbols as we see them, so if an extension is enabled later, the shader still fails to compile if it uses it earlier. We should clarify the language that extension still needs to be enabled before it's used.

However, there are no safety issues with enable. There is however with disable because the shader can bypass validation.

Proposal would need some more exact language?

My proposal is something like this:

 The GLSL ES 1.00 [[GLES20GLSL]](https://registry.khronos.org/webgl/specs/latest/1.0/#refsGLES20GLSL)
 specification mandates that #extension directives must occur before any non-preprocessor tokens unless the
-extension specification says otherwise. In the WebGL API, #extension directives may always occur after
-non-preprocessor tokens in GLSL ES 1.00 shaders.
+extension specification says otherwise. In the WebGL API, #extension directives may occur after
+non-preprocessor tokens in GLSL ES 1.00 shaders if the behavior is not `disable`.