1/*
2 * Copyright © 2010 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24#ifndef GLSL_PARSER_EXTRAS_H
25#define GLSL_PARSER_EXTRAS_H
26
27/*
28 * Most of the definitions here only apply to C++
29 */
30#ifdef __cplusplus
31
32
33#include <stdlib.h>
34#include "glsl_symbol_table.h"
35
36/* THIS is a macro defined somewhere deep in the Windows MSVC header files.
37 * Undefine it here to avoid collision with the lexer's THIS token.
38 */
39#undef THIS
40
41struct gl_context;
42
43struct glsl_switch_state {
44   /** Temporary variables needed for switch statement. */
45   ir_variable *test_var;
46   ir_variable *is_fallthru_var;
47   class ast_switch_statement *switch_nesting_ast;
48
49   /** Used to detect if 'continue' was called inside a switch. */
50   ir_variable *continue_inside;
51
52   /** Used to set condition if 'default' label should be chosen. */
53   ir_variable *run_default;
54
55   /** Table of constant values already used in case labels */
56   struct hash_table *labels_ht;
57   class ast_case_label *previous_default;
58
59   bool is_switch_innermost; // if switch stmt is closest to break, ...
60};
61
62const char *
63glsl_compute_version_string(void *mem_ctx, bool is_es, unsigned version);
64
65typedef struct YYLTYPE {
66   int first_line;
67   int first_column;
68   int last_line;
69   int last_column;
70   unsigned source;
71   /* Path for ARB_shading_language_include include source */
72   char *path;
73} YYLTYPE;
74# define YYLTYPE_IS_DECLARED 1
75# define YYLTYPE_IS_TRIVIAL 1
76
77extern void _mesa_glsl_error(YYLTYPE *locp, _mesa_glsl_parse_state *state,
78                             const char *fmt, ...);
79
80
81struct _mesa_glsl_parse_state {
82   _mesa_glsl_parse_state(struct gl_context *_ctx, gl_shader_stage stage,
83                          void *mem_ctx);
84
85   DECLARE_RZALLOC_CXX_OPERATORS(_mesa_glsl_parse_state);
86
87   /**
88    * Generate a string representing the GLSL version currently being compiled
89    * (useful for error messages).
90    */
91   const char *get_version_string()
92   {
93      return glsl_compute_version_string(this, this->es_shader,
94                                         this->language_version);
95   }
96
97   /**
98    * Determine whether the current GLSL version is sufficiently high to
99    * support a certain feature.
100    *
101    * \param required_glsl_version is the desktop GLSL version that is
102    * required to support the feature, or 0 if no version of desktop GLSL
103    * supports the feature.
104    *
105    * \param required_glsl_es_version is the GLSL ES version that is required
106    * to support the feature, or 0 if no version of GLSL ES supports the
107    * feature.
108    */
109   bool is_version(unsigned required_glsl_version,
110                   unsigned required_glsl_es_version) const
111   {
112      unsigned required_version = this->es_shader ?
113         required_glsl_es_version : required_glsl_version;
114      unsigned this_version = this->forced_language_version
115         ? this->forced_language_version : this->language_version;
116      return required_version != 0
117         && this_version >= required_version;
118   }
119
120   bool check_version(unsigned required_glsl_version,
121                      unsigned required_glsl_es_version,
122                      YYLTYPE *locp, const char *fmt, ...) PRINTFLIKE(5, 6);
123
124   bool check_arrays_of_arrays_allowed(YYLTYPE *locp)
125   {
126      if (!(ARB_arrays_of_arrays_enable || is_version(430, 310))) {
127         const char *const requirement = this->es_shader
128            ? "GLSL ES 3.10"
129            : "GL_ARB_arrays_of_arrays or GLSL 4.30";
130         _mesa_glsl_error(locp, this,
131                          "%s required for defining arrays of arrays.",
132                          requirement);
133         return false;
134      }
135      return true;
136   }
137
138   bool check_precision_qualifiers_allowed(YYLTYPE *locp)
139   {
140      return check_version(130, 100, locp,
141                           "precision qualifiers are forbidden");
142   }
143
144   bool check_bitwise_operations_allowed(YYLTYPE *locp)
145   {
146      return EXT_gpu_shader4_enable ||
147             check_version(130, 300, locp, "bit-wise operations are forbidden");
148   }
149
150   bool check_explicit_attrib_stream_allowed(YYLTYPE *locp)
151   {
152      if (!this->has_explicit_attrib_stream()) {
153         const char *const requirement = "GL_ARB_gpu_shader5 extension or GLSL 4.00";
154
155         _mesa_glsl_error(locp, this, "explicit stream requires %s",
156                          requirement);
157         return false;
158      }
159
160      return true;
161   }
162
163   bool check_explicit_attrib_location_allowed(YYLTYPE *locp,
164                                               const ir_variable *var)
165   {
166      if (!this->has_explicit_attrib_location()) {
167         const char *const requirement = this->es_shader
168            ? "GLSL ES 3.00"
169            : "GL_ARB_explicit_attrib_location extension or GLSL 3.30";
170
171         _mesa_glsl_error(locp, this, "%s explicit location requires %s",
172                          mode_string(var), requirement);
173         return false;
174      }
175
176      return true;
177   }
178
179   bool check_separate_shader_objects_allowed(YYLTYPE *locp,
180                                              const ir_variable *var)
181   {
182      if (!this->has_separate_shader_objects()) {
183         const char *const requirement = this->es_shader
184            ? "GL_EXT_separate_shader_objects extension or GLSL ES 3.10"
185            : "GL_ARB_separate_shader_objects extension or GLSL 4.20";
186
187         _mesa_glsl_error(locp, this, "%s explicit location requires %s",
188                          mode_string(var), requirement);
189         return false;
190      }
191
192      return true;
193   }
194
195   bool check_explicit_uniform_location_allowed(YYLTYPE *locp,
196                                                const ir_variable *)
197   {
198      if (!this->has_explicit_attrib_location() ||
199          !this->has_explicit_uniform_location()) {
200         const char *const requirement = this->es_shader
201            ? "GLSL ES 3.10"
202            : "GL_ARB_explicit_uniform_location and either "
203              "GL_ARB_explicit_attrib_location or GLSL 3.30.";
204
205         _mesa_glsl_error(locp, this,
206                          "uniform explicit location requires %s",
207                          requirement);
208         return false;
209      }
210
211      return true;
212   }
213
214   bool has_atomic_counters() const
215   {
216      return ARB_shader_atomic_counters_enable || is_version(420, 310);
217   }
218
219   bool has_enhanced_layouts() const
220   {
221      return ARB_enhanced_layouts_enable || is_version(440, 0);
222   }
223
224   bool has_explicit_attrib_stream() const
225   {
226      return ARB_gpu_shader5_enable || is_version(400, 0);
227   }
228
229   bool has_explicit_attrib_location() const
230   {
231      return ARB_explicit_attrib_location_enable || is_version(330, 300);
232   }
233
234   bool has_explicit_uniform_location() const
235   {
236      return ARB_explicit_uniform_location_enable || is_version(430, 310);
237   }
238
239   bool has_uniform_buffer_objects() const
240   {
241      return ARB_uniform_buffer_object_enable || is_version(140, 300);
242   }
243
244   bool has_shader_storage_buffer_objects() const
245   {
246      return ARB_shader_storage_buffer_object_enable || is_version(430, 310);
247   }
248
249   bool has_separate_shader_objects() const
250   {
251      return ARB_separate_shader_objects_enable || is_version(410, 310)
252         || EXT_separate_shader_objects_enable;
253   }
254
255   bool has_double() const
256   {
257      return ARB_gpu_shader_fp64_enable || is_version(400, 0);
258   }
259
260   bool has_int64() const
261   {
262      return ARB_gpu_shader_int64_enable ||
263             AMD_gpu_shader_int64_enable;
264   }
265
266   bool has_420pack() const
267   {
268      return ARB_shading_language_420pack_enable || is_version(420, 0);
269   }
270
271   bool has_420pack_or_es31() const
272   {
273      return ARB_shading_language_420pack_enable || is_version(420, 310);
274   }
275
276   bool has_compute_shader() const
277   {
278      return ARB_compute_shader_enable || is_version(430, 310);
279   }
280
281   bool has_shader_io_blocks() const
282   {
283      /* The OES_geometry_shader_specification says:
284       *
285       *    "If the OES_geometry_shader extension is enabled, the
286       *     OES_shader_io_blocks extension is also implicitly enabled."
287       *
288       * The OES_tessellation_shader extension has similar wording.
289       */
290      return OES_shader_io_blocks_enable ||
291             EXT_shader_io_blocks_enable ||
292             OES_geometry_shader_enable ||
293             EXT_geometry_shader_enable ||
294             OES_tessellation_shader_enable ||
295             EXT_tessellation_shader_enable ||
296
297             is_version(150, 320);
298   }
299
300   bool has_geometry_shader() const
301   {
302      return OES_geometry_shader_enable || EXT_geometry_shader_enable ||
303             is_version(150, 320);
304   }
305
306   bool has_tessellation_shader() const
307   {
308      return ARB_tessellation_shader_enable ||
309             OES_tessellation_shader_enable ||
310             EXT_tessellation_shader_enable ||
311             is_version(400, 320);
312   }
313
314   bool has_clip_distance() const
315   {
316      return EXT_clip_cull_distance_enable || is_version(130, 0);
317   }
318
319   bool has_cull_distance() const
320   {
321      return EXT_clip_cull_distance_enable ||
322             ARB_cull_distance_enable ||
323             is_version(450, 0);
324   }
325
326   bool has_framebuffer_fetch() const
327   {
328      return EXT_shader_framebuffer_fetch_enable ||
329             EXT_shader_framebuffer_fetch_non_coherent_enable;
330   }
331
332   bool has_framebuffer_fetch_zs() const
333   {
334      return ARM_shader_framebuffer_fetch_depth_stencil_enable;
335   }
336
337   bool has_texture_cube_map_array() const
338   {
339      return ARB_texture_cube_map_array_enable ||
340             EXT_texture_cube_map_array_enable ||
341             OES_texture_cube_map_array_enable ||
342             is_version(400, 320);
343   }
344
345   bool has_shader_image_load_store() const
346   {
347      return ARB_shader_image_load_store_enable ||
348             EXT_shader_image_load_store_enable ||
349             is_version(420, 310);
350   }
351
352   bool has_bindless() const
353   {
354      return ARB_bindless_texture_enable;
355   }
356
357   bool has_image_load_formatted() const
358   {
359      return EXT_shader_image_load_formatted_enable;
360   }
361
362   bool has_implicit_conversions() const
363   {
364      return EXT_shader_implicit_conversions_enable ||
365             is_version(allow_glsl_120_subset_in_110 ? 110 : 120, 0);
366   }
367
368   bool has_implicit_int_to_uint_conversion() const
369   {
370      return ARB_gpu_shader5_enable ||
371             MESA_shader_integer_functions_enable ||
372             EXT_shader_implicit_conversions_enable ||
373             is_version(400, 0);
374   }
375
376   void set_valid_gl_and_glsl_versions(YYLTYPE *locp);
377
378   void process_version_directive(YYLTYPE *locp, int version,
379                                  const char *ident);
380
381   struct gl_context *const ctx; /* only to be used for debug callback. */
382   const struct gl_extensions *exts;
383   const struct gl_constants *consts;
384   gl_api api;
385   void *scanner;
386   exec_list translation_unit;
387   glsl_symbol_table *symbols;
388
389   void *linalloc;
390
391   unsigned num_supported_versions;
392   struct {
393      unsigned ver;
394      uint8_t gl_ver;
395      bool es;
396   } supported_versions[17];
397
398   bool es_shader;
399   bool compat_shader;
400   unsigned language_version;
401   unsigned forced_language_version;
402   /* Bitfield of ir_variable_mode to zero init */
403   uint32_t zero_init;
404   unsigned gl_version;
405   gl_shader_stage stage;
406
407   /**
408    * Default uniform layout qualifiers tracked during parsing.
409    * Currently affects uniform blocks and uniform buffer variables in
410    * those blocks.
411    */
412   struct ast_type_qualifier *default_uniform_qualifier;
413
414   /**
415    * Default shader storage layout qualifiers tracked during parsing.
416    * Currently affects shader storage blocks and shader storage buffer
417    * variables in those blocks.
418    */
419   struct ast_type_qualifier *default_shader_storage_qualifier;
420
421   /**
422    * Variables to track different cases if a fragment shader redeclares
423    * built-in variable gl_FragCoord.
424    *
425    * Note: These values are computed at ast_to_hir time rather than at parse
426    * time.
427    */
428   bool fs_redeclares_gl_fragcoord;
429   bool fs_origin_upper_left;
430   bool fs_pixel_center_integer;
431   bool fs_redeclares_gl_fragcoord_with_no_layout_qualifiers;
432
433   /**
434    * True if a geometry shader input primitive type or tessellation control
435    * output vertices were specified using a layout directive.
436    *
437    * Note: these values are computed at ast_to_hir time rather than at parse
438    * time.
439    */
440   bool gs_input_prim_type_specified;
441   bool tcs_output_vertices_specified;
442
443   /**
444    * Input layout qualifiers from GLSL 1.50 (geometry shader controls),
445    * and GLSL 4.00 (tessellation evaluation shader)
446    */
447   struct ast_type_qualifier *in_qualifier;
448
449   /**
450    * True if a compute shader input local size was specified using a layout
451    * directive.
452    *
453    * Note: this value is computed at ast_to_hir time rather than at parse
454    * time.
455    */
456   bool cs_input_local_size_specified;
457
458   /**
459    * If cs_input_local_size_specified is true, the local size that was
460    * specified.  Otherwise ignored.
461    */
462   unsigned cs_input_local_size[3];
463
464   /**
465    * True if a compute shader input local variable size was specified using
466    * a layout directive as specified by ARB_compute_variable_group_size.
467    */
468   bool cs_input_local_size_variable_specified;
469
470   /**
471    * Arrangement of invocations used to calculate derivatives in a compute
472    * shader.  From NV_compute_shader_derivatives.
473    */
474   enum gl_derivative_group cs_derivative_group;
475
476   /**
477    * True if a shader declare bindless_sampler/bindless_image, and
478    * respectively bound_sampler/bound_image at global scope as specified by
479    * ARB_bindless_texture.
480    */
481   bool bindless_sampler_specified;
482   bool bindless_image_specified;
483   bool bound_sampler_specified;
484   bool bound_image_specified;
485
486   /**
487    * Output layout qualifiers from GLSL 1.50 (geometry shader controls),
488    * and GLSL 4.00 (tessellation control shader).
489    */
490   struct ast_type_qualifier *out_qualifier;
491
492   /**
493    * Printable list of GLSL versions supported by the current context
494    *
495    * \note
496    * This string should probably be generated per-context instead of per
497    * invokation of the compiler.  This should be changed when the method of
498    * tracking supported GLSL versions changes.
499    */
500   const char *supported_version_string;
501
502   /**
503    * Implementation defined limits that affect built-in variables, etc.
504    *
505    * \sa struct gl_constants (in mtypes.h)
506    */
507   struct {
508      /* 1.10 */
509      unsigned MaxLights;
510      unsigned MaxClipPlanes;
511      unsigned MaxTextureUnits;
512      unsigned MaxTextureCoords;
513      unsigned MaxVertexAttribs;
514      unsigned MaxVertexUniformComponents;
515      unsigned MaxVertexTextureImageUnits;
516      unsigned MaxCombinedTextureImageUnits;
517      unsigned MaxTextureImageUnits;
518      unsigned MaxFragmentUniformComponents;
519
520      /* ARB_draw_buffers */
521      unsigned MaxDrawBuffers;
522
523      /* ARB_enhanced_layouts */
524      unsigned MaxTransformFeedbackBuffers;
525      unsigned MaxTransformFeedbackInterleavedComponents;
526
527      /* ARB_blend_func_extended */
528      unsigned MaxDualSourceDrawBuffers;
529
530      /* 3.00 ES */
531      int MinProgramTexelOffset;
532      int MaxProgramTexelOffset;
533
534      /* 1.50 */
535      unsigned MaxVertexOutputComponents;
536      unsigned MaxGeometryInputComponents;
537      unsigned MaxGeometryOutputComponents;
538      unsigned MaxGeometryShaderInvocations;
539      unsigned MaxFragmentInputComponents;
540      unsigned MaxGeometryTextureImageUnits;
541      unsigned MaxGeometryOutputVertices;
542      unsigned MaxGeometryTotalOutputComponents;
543      unsigned MaxGeometryUniformComponents;
544
545      /* ARB_shader_atomic_counters */
546      unsigned MaxVertexAtomicCounters;
547      unsigned MaxTessControlAtomicCounters;
548      unsigned MaxTessEvaluationAtomicCounters;
549      unsigned MaxGeometryAtomicCounters;
550      unsigned MaxFragmentAtomicCounters;
551      unsigned MaxCombinedAtomicCounters;
552      unsigned MaxAtomicBufferBindings;
553
554      /* These are also atomic counter related, but they weren't added to
555       * until atomic counters were added to core in GLSL 4.20 and GLSL ES
556       * 3.10.
557       */
558      unsigned MaxVertexAtomicCounterBuffers;
559      unsigned MaxTessControlAtomicCounterBuffers;
560      unsigned MaxTessEvaluationAtomicCounterBuffers;
561      unsigned MaxGeometryAtomicCounterBuffers;
562      unsigned MaxFragmentAtomicCounterBuffers;
563      unsigned MaxCombinedAtomicCounterBuffers;
564      unsigned MaxAtomicCounterBufferSize;
565
566      /* ARB_compute_shader */
567      unsigned MaxComputeAtomicCounterBuffers;
568      unsigned MaxComputeAtomicCounters;
569      unsigned MaxComputeImageUniforms;
570      unsigned MaxComputeTextureImageUnits;
571      unsigned MaxComputeUniformComponents;
572      unsigned MaxComputeWorkGroupCount[3];
573      unsigned MaxComputeWorkGroupSize[3];
574
575      /* ARB_shader_image_load_store */
576      unsigned MaxImageUnits;
577      unsigned MaxCombinedShaderOutputResources;
578      unsigned MaxImageSamples;
579      unsigned MaxVertexImageUniforms;
580      unsigned MaxTessControlImageUniforms;
581      unsigned MaxTessEvaluationImageUniforms;
582      unsigned MaxGeometryImageUniforms;
583      unsigned MaxFragmentImageUniforms;
584      unsigned MaxCombinedImageUniforms;
585
586      /* ARB_viewport_array */
587      unsigned MaxViewports;
588
589      /* ARB_tessellation_shader */
590      unsigned MaxPatchVertices;
591      unsigned MaxTessGenLevel;
592      unsigned MaxTessControlInputComponents;
593      unsigned MaxTessControlOutputComponents;
594      unsigned MaxTessControlTextureImageUnits;
595      unsigned MaxTessEvaluationInputComponents;
596      unsigned MaxTessEvaluationOutputComponents;
597      unsigned MaxTessEvaluationTextureImageUnits;
598      unsigned MaxTessPatchComponents;
599      unsigned MaxTessControlTotalOutputComponents;
600      unsigned MaxTessControlUniformComponents;
601      unsigned MaxTessEvaluationUniformComponents;
602
603      /* GL 4.5 / OES_sample_variables */
604      unsigned MaxSamples;
605   } Const;
606
607   /**
608    * During AST to IR conversion, pointer to current IR function
609    *
610    * Will be \c NULL whenever the AST to IR conversion is not inside a
611    * function definition.
612    */
613   class ir_function_signature *current_function;
614
615   /**
616    * During AST to IR conversion, pointer to the toplevel IR
617    * instruction list being generated.
618    */
619   exec_list *toplevel_ir;
620
621   /** Have we found a return statement in this function? */
622   bool found_return;
623
624   /** Have we found the interlock builtins in this function? */
625   bool found_begin_interlock;
626   bool found_end_interlock;
627
628   /** Was there an error during compilation? */
629   bool error;
630
631   /**
632    * Are all shader inputs / outputs invariant?
633    *
634    * This is set when the 'STDGL invariant(all)' pragma is used.
635    */
636   bool all_invariant;
637
638   /** Loop or switch statement containing the current instructions. */
639   class ast_iteration_statement *loop_nesting_ast;
640
641   struct glsl_switch_state switch_state;
642
643   /** List of structures defined in user code. */
644   const glsl_type **user_structures;
645   unsigned num_user_structures;
646
647   char *info_log;
648
649   /**
650    * Are warnings enabled?
651    *
652    * Emission of warngins is controlled by '#pragma warning(...)'.
653    */
654   bool warnings_enabled;
655
656   /**
657    * \name Enable bits for GLSL extensions
658    */
659   /*@{*/
660   /* ARB extensions go here, sorted alphabetically.
661    */
662   bool ARB_ES3_1_compatibility_enable;
663   bool ARB_ES3_1_compatibility_warn;
664   bool ARB_ES3_2_compatibility_enable;
665   bool ARB_ES3_2_compatibility_warn;
666   bool ARB_arrays_of_arrays_enable;
667   bool ARB_arrays_of_arrays_warn;
668   bool ARB_bindless_texture_enable;
669   bool ARB_bindless_texture_warn;
670   bool ARB_compatibility_enable;
671   bool ARB_compatibility_warn;
672   bool ARB_compute_shader_enable;
673   bool ARB_compute_shader_warn;
674   bool ARB_compute_variable_group_size_enable;
675   bool ARB_compute_variable_group_size_warn;
676   bool ARB_conservative_depth_enable;
677   bool ARB_conservative_depth_warn;
678   bool ARB_cull_distance_enable;
679   bool ARB_cull_distance_warn;
680   bool ARB_derivative_control_enable;
681   bool ARB_derivative_control_warn;
682   bool ARB_draw_buffers_enable;
683   bool ARB_draw_buffers_warn;
684   bool ARB_draw_instanced_enable;
685   bool ARB_draw_instanced_warn;
686   bool ARB_enhanced_layouts_enable;
687   bool ARB_enhanced_layouts_warn;
688   bool ARB_explicit_attrib_location_enable;
689   bool ARB_explicit_attrib_location_warn;
690   bool ARB_explicit_uniform_location_enable;
691   bool ARB_explicit_uniform_location_warn;
692   bool ARB_fragment_coord_conventions_enable;
693   bool ARB_fragment_coord_conventions_warn;
694   bool ARB_fragment_layer_viewport_enable;
695   bool ARB_fragment_layer_viewport_warn;
696   bool ARB_fragment_shader_interlock_enable;
697   bool ARB_fragment_shader_interlock_warn;
698   bool ARB_gpu_shader5_enable;
699   bool ARB_gpu_shader5_warn;
700   bool ARB_gpu_shader_fp64_enable;
701   bool ARB_gpu_shader_fp64_warn;
702   bool ARB_gpu_shader_int64_enable;
703   bool ARB_gpu_shader_int64_warn;
704   bool ARB_post_depth_coverage_enable;
705   bool ARB_post_depth_coverage_warn;
706   bool ARB_sample_shading_enable;
707   bool ARB_sample_shading_warn;
708   bool ARB_separate_shader_objects_enable;
709   bool ARB_separate_shader_objects_warn;
710   bool ARB_shader_atomic_counter_ops_enable;
711   bool ARB_shader_atomic_counter_ops_warn;
712   bool ARB_shader_atomic_counters_enable;
713   bool ARB_shader_atomic_counters_warn;
714   bool ARB_shader_ballot_enable;
715   bool ARB_shader_ballot_warn;
716   bool ARB_shader_bit_encoding_enable;
717   bool ARB_shader_bit_encoding_warn;
718   bool ARB_shader_clock_enable;
719   bool ARB_shader_clock_warn;
720   bool ARB_shader_draw_parameters_enable;
721   bool ARB_shader_draw_parameters_warn;
722   bool ARB_shader_group_vote_enable;
723   bool ARB_shader_group_vote_warn;
724   bool ARB_shader_image_load_store_enable;
725   bool ARB_shader_image_load_store_warn;
726   bool ARB_shader_image_size_enable;
727   bool ARB_shader_image_size_warn;
728   bool ARB_shader_precision_enable;
729   bool ARB_shader_precision_warn;
730   bool ARB_shader_stencil_export_enable;
731   bool ARB_shader_stencil_export_warn;
732   bool ARB_shader_storage_buffer_object_enable;
733   bool ARB_shader_storage_buffer_object_warn;
734   bool ARB_shader_subroutine_enable;
735   bool ARB_shader_subroutine_warn;
736   bool ARB_shader_texture_image_samples_enable;
737   bool ARB_shader_texture_image_samples_warn;
738   bool ARB_shader_texture_lod_enable;
739   bool ARB_shader_texture_lod_warn;
740   bool ARB_shader_viewport_layer_array_enable;
741   bool ARB_shader_viewport_layer_array_warn;
742   bool ARB_shading_language_420pack_enable;
743   bool ARB_shading_language_420pack_warn;
744   bool ARB_shading_language_include_enable;
745   bool ARB_shading_language_include_warn;
746   bool ARB_shading_language_packing_enable;
747   bool ARB_shading_language_packing_warn;
748   bool ARB_sparse_texture2_enable;
749   bool ARB_sparse_texture2_warn;
750   bool ARB_sparse_texture_clamp_enable;
751   bool ARB_sparse_texture_clamp_warn;
752   bool ARB_tessellation_shader_enable;
753   bool ARB_tessellation_shader_warn;
754   bool ARB_texture_cube_map_array_enable;
755   bool ARB_texture_cube_map_array_warn;
756   bool ARB_texture_gather_enable;
757   bool ARB_texture_gather_warn;
758   bool ARB_texture_multisample_enable;
759   bool ARB_texture_multisample_warn;
760   bool ARB_texture_query_levels_enable;
761   bool ARB_texture_query_levels_warn;
762   bool ARB_texture_query_lod_enable;
763   bool ARB_texture_query_lod_warn;
764   bool ARB_texture_rectangle_enable;
765   bool ARB_texture_rectangle_warn;
766   bool ARB_uniform_buffer_object_enable;
767   bool ARB_uniform_buffer_object_warn;
768   bool ARB_vertex_attrib_64bit_enable;
769   bool ARB_vertex_attrib_64bit_warn;
770   bool ARB_viewport_array_enable;
771   bool ARB_viewport_array_warn;
772
773   /* KHR extensions go here, sorted alphabetically.
774    */
775   bool KHR_blend_equation_advanced_enable;
776   bool KHR_blend_equation_advanced_warn;
777
778   /* OES extensions go here, sorted alphabetically.
779    */
780   bool OES_EGL_image_external_enable;
781   bool OES_EGL_image_external_warn;
782   bool OES_EGL_image_external_essl3_enable;
783   bool OES_EGL_image_external_essl3_warn;
784   bool OES_geometry_point_size_enable;
785   bool OES_geometry_point_size_warn;
786   bool OES_geometry_shader_enable;
787   bool OES_geometry_shader_warn;
788   bool OES_gpu_shader5_enable;
789   bool OES_gpu_shader5_warn;
790   bool OES_primitive_bounding_box_enable;
791   bool OES_primitive_bounding_box_warn;
792   bool OES_sample_variables_enable;
793   bool OES_sample_variables_warn;
794   bool OES_shader_image_atomic_enable;
795   bool OES_shader_image_atomic_warn;
796   bool OES_shader_io_blocks_enable;
797   bool OES_shader_io_blocks_warn;
798   bool OES_shader_multisample_interpolation_enable;
799   bool OES_shader_multisample_interpolation_warn;
800   bool OES_standard_derivatives_enable;
801   bool OES_standard_derivatives_warn;
802   bool OES_tessellation_point_size_enable;
803   bool OES_tessellation_point_size_warn;
804   bool OES_tessellation_shader_enable;
805   bool OES_tessellation_shader_warn;
806   bool OES_texture_3D_enable;
807   bool OES_texture_3D_warn;
808   bool OES_texture_buffer_enable;
809   bool OES_texture_buffer_warn;
810   bool OES_texture_cube_map_array_enable;
811   bool OES_texture_cube_map_array_warn;
812   bool OES_texture_storage_multisample_2d_array_enable;
813   bool OES_texture_storage_multisample_2d_array_warn;
814   bool OES_viewport_array_enable;
815   bool OES_viewport_array_warn;
816
817   /* All other extensions go here, sorted alphabetically.
818    */
819   bool AMD_conservative_depth_enable;
820   bool AMD_conservative_depth_warn;
821   bool AMD_gpu_shader_int64_enable;
822   bool AMD_gpu_shader_int64_warn;
823   bool AMD_shader_stencil_export_enable;
824   bool AMD_shader_stencil_export_warn;
825   bool AMD_shader_trinary_minmax_enable;
826   bool AMD_shader_trinary_minmax_warn;
827   bool AMD_texture_texture4_enable;
828   bool AMD_texture_texture4_warn;
829   bool AMD_vertex_shader_layer_enable;
830   bool AMD_vertex_shader_layer_warn;
831   bool AMD_vertex_shader_viewport_index_enable;
832   bool AMD_vertex_shader_viewport_index_warn;
833   bool ANDROID_extension_pack_es31a_enable;
834   bool ANDROID_extension_pack_es31a_warn;
835   bool ARM_shader_framebuffer_fetch_depth_stencil_enable;
836   bool ARM_shader_framebuffer_fetch_depth_stencil_warn;
837   bool EXT_blend_func_extended_enable;
838   bool EXT_blend_func_extended_warn;
839   bool EXT_clip_cull_distance_enable;
840   bool EXT_clip_cull_distance_warn;
841   bool EXT_demote_to_helper_invocation_enable;
842   bool EXT_demote_to_helper_invocation_warn;
843   bool EXT_draw_buffers_enable;
844   bool EXT_draw_buffers_warn;
845   bool EXT_draw_instanced_enable;
846   bool EXT_draw_instanced_warn;
847   bool EXT_frag_depth_enable;
848   bool EXT_frag_depth_warn;
849   bool EXT_geometry_point_size_enable;
850   bool EXT_geometry_point_size_warn;
851   bool EXT_geometry_shader_enable;
852   bool EXT_geometry_shader_warn;
853   bool EXT_gpu_shader4_enable;
854   bool EXT_gpu_shader4_warn;
855   bool EXT_gpu_shader5_enable;
856   bool EXT_gpu_shader5_warn;
857   bool EXT_primitive_bounding_box_enable;
858   bool EXT_primitive_bounding_box_warn;
859   bool EXT_separate_shader_objects_enable;
860   bool EXT_separate_shader_objects_warn;
861   bool EXT_shader_framebuffer_fetch_enable;
862   bool EXT_shader_framebuffer_fetch_warn;
863   bool EXT_shader_framebuffer_fetch_non_coherent_enable;
864   bool EXT_shader_framebuffer_fetch_non_coherent_warn;
865   bool EXT_shader_group_vote_enable;
866   bool EXT_shader_group_vote_warn;
867   bool EXT_shader_image_load_formatted_enable;
868   bool EXT_shader_image_load_formatted_warn;
869   bool EXT_shader_image_load_store_enable;
870   bool EXT_shader_image_load_store_warn;
871   bool EXT_shader_implicit_conversions_enable;
872   bool EXT_shader_implicit_conversions_warn;
873   bool EXT_shader_integer_mix_enable;
874   bool EXT_shader_integer_mix_warn;
875   bool EXT_shader_io_blocks_enable;
876   bool EXT_shader_io_blocks_warn;
877   bool EXT_shader_samples_identical_enable;
878   bool EXT_shader_samples_identical_warn;
879   bool EXT_tessellation_point_size_enable;
880   bool EXT_tessellation_point_size_warn;
881   bool EXT_tessellation_shader_enable;
882   bool EXT_tessellation_shader_warn;
883   bool EXT_texture_array_enable;
884   bool EXT_texture_array_warn;
885   bool EXT_texture_buffer_enable;
886   bool EXT_texture_buffer_warn;
887   bool EXT_texture_cube_map_array_enable;
888   bool EXT_texture_cube_map_array_warn;
889   bool EXT_texture_query_lod_enable;
890   bool EXT_texture_query_lod_warn;
891   bool EXT_texture_shadow_lod_enable;
892   bool EXT_texture_shadow_lod_warn;
893   bool INTEL_conservative_rasterization_enable;
894   bool INTEL_conservative_rasterization_warn;
895   bool INTEL_shader_atomic_float_minmax_enable;
896   bool INTEL_shader_atomic_float_minmax_warn;
897   bool INTEL_shader_integer_functions2_enable;
898   bool INTEL_shader_integer_functions2_warn;
899   bool MESA_shader_integer_functions_enable;
900   bool MESA_shader_integer_functions_warn;
901   bool NV_compute_shader_derivatives_enable;
902   bool NV_compute_shader_derivatives_warn;
903   bool NV_fragment_shader_interlock_enable;
904   bool NV_fragment_shader_interlock_warn;
905   bool NV_image_formats_enable;
906   bool NV_image_formats_warn;
907   bool NV_shader_atomic_float_enable;
908   bool NV_shader_atomic_float_warn;
909   bool NV_shader_atomic_int64_enable;
910   bool NV_shader_atomic_int64_warn;
911   bool NV_viewport_array2_enable;
912   bool NV_viewport_array2_warn;
913   /*@}*/
914
915   /** Extensions supported by the OpenGL implementation. */
916   const struct gl_extensions *extensions;
917
918   bool uses_builtin_functions;
919   bool fs_uses_gl_fragcoord;
920
921   /**
922    * For geometry shaders, size of the most recently seen input declaration
923    * that was a sized array, or 0 if no sized input array declarations have
924    * been seen.
925    *
926    * Unused for other shader types.
927    */
928   unsigned gs_input_size;
929
930   bool fs_early_fragment_tests;
931
932   bool fs_inner_coverage;
933
934   bool fs_post_depth_coverage;
935
936   bool fs_pixel_interlock_ordered;
937   bool fs_pixel_interlock_unordered;
938   bool fs_sample_interlock_ordered;
939   bool fs_sample_interlock_unordered;
940
941   unsigned fs_blend_support;
942
943   /**
944    * For tessellation control shaders, size of the most recently seen output
945    * declaration that was a sized array, or 0 if no sized output array
946    * declarations have been seen.
947    *
948    * Unused for other shader types.
949    */
950   unsigned tcs_output_size;
951
952   /** Atomic counter offsets by binding */
953   unsigned atomic_counter_offsets[MAX_COMBINED_ATOMIC_BUFFERS];
954
955   /** Whether gl_Layer output is viewport-relative. */
956   bool redeclares_gl_layer;
957   bool layer_viewport_relative;
958
959   bool allow_extension_directive_midshader;
960   bool allow_glsl_120_subset_in_110;
961   bool allow_builtin_variable_redeclaration;
962   bool ignore_write_to_readonly_var;
963
964   /**
965    * Known subroutine type declarations.
966    */
967   int num_subroutine_types;
968   ir_function **subroutine_types;
969
970   /**
971    * Functions that are associated with
972    * subroutine types.
973    */
974   int num_subroutines;
975   ir_function **subroutines;
976
977   /**
978    * field selection temporary parser storage -
979    * did the parser just parse a dot.
980    */
981   bool is_field;
982
983   /**
984    * seen values for clip/cull distance sizes
985    * so we can check totals aren't too large.
986    */
987   unsigned clip_dist_size, cull_dist_size;
988};
989
990# define YYLLOC_DEFAULT(Current, Rhs, N)                        \
991do {                                                            \
992   if (N)                                                       \
993   {                                                            \
994      (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;     \
995      (Current).first_column = YYRHSLOC(Rhs, 1).first_column;   \
996      (Current).last_line    = YYRHSLOC(Rhs, N).last_line;      \
997      (Current).last_column  = YYRHSLOC(Rhs, N).last_column;    \
998      (Current).path         = YYRHSLOC(Rhs, N).path;           \
999   }                                                            \
1000   else                                                         \
1001   {                                                            \
1002      (Current).first_line   = (Current).last_line =            \
1003         YYRHSLOC(Rhs, 0).last_line;                            \
1004      (Current).first_column = (Current).last_column =          \
1005         YYRHSLOC(Rhs, 0).last_column;                          \
1006      (Current).path = YYRHSLOC(Rhs, 0).path;                   \
1007   }                                                            \
1008   (Current).source = 0;                                        \
1009} while (0)
1010
1011/**
1012 * Emit a warning to the shader log
1013 *
1014 * \sa _mesa_glsl_error
1015 */
1016extern void _mesa_glsl_warning(const YYLTYPE *locp,
1017                               _mesa_glsl_parse_state *state,
1018                               const char *fmt, ...);
1019
1020extern void _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state,
1021                                  const char *string);
1022
1023extern void _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state);
1024
1025union YYSTYPE;
1026extern int _mesa_glsl_lexer_lex(union YYSTYPE *yylval, YYLTYPE *yylloc,
1027                                void *scanner);
1028
1029extern int _mesa_glsl_parse(struct _mesa_glsl_parse_state *);
1030
1031/**
1032 * Process elements of the #extension directive
1033 *
1034 * \return
1035 * If \c name and \c behavior are valid, \c true is returned.  Otherwise
1036 * \c false is returned.
1037 */
1038extern bool _mesa_glsl_process_extension(const char *name, YYLTYPE *name_locp,
1039                                         const char *behavior,
1040                                         YYLTYPE *behavior_locp,
1041                                         _mesa_glsl_parse_state *state);
1042
1043#endif /* __cplusplus */
1044
1045
1046/*
1047 * These definitions apply to C and C++
1048 */
1049#ifdef __cplusplus
1050extern "C" {
1051#endif
1052
1053struct glcpp_parser;
1054struct _mesa_glsl_parse_state;
1055
1056typedef void (*glcpp_extension_iterator)(
1057              struct _mesa_glsl_parse_state *state,
1058              void (*add_builtin_define)(struct glcpp_parser *, const char *, int),
1059              struct glcpp_parser *data,
1060              unsigned version,
1061              bool es);
1062
1063extern int glcpp_preprocess(void *ctx, const char **shader, char **info_log,
1064                            glcpp_extension_iterator extensions,
1065                            struct _mesa_glsl_parse_state *state,
1066                            struct gl_context *gl_ctx);
1067
1068extern void
1069_mesa_glsl_copy_symbols_from_table(struct exec_list *shader_ir,
1070                                   struct glsl_symbol_table *src,
1071                                   struct glsl_symbol_table *dest);
1072
1073#ifdef __cplusplus
1074}
1075#endif
1076
1077
1078#endif /* GLSL_PARSER_EXTRAS_H */
1079