2 * Copyright © 2010 Intel Corporation
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:
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
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.
27 ast_type_specifier::print(void) const
32 printf("%s ", type_name);
35 if (array_specifier) {
36 array_specifier->print();
41 ast_fully_specified_type::has_qualifiers(_mesa_glsl_parse_state *state) const
43 /* 'subroutine' isnt a real qualifier. */
44 ast_type_qualifier subroutine_only;
45 subroutine_only.flags.i = 0;
46 subroutine_only.flags.q.subroutine = 1;
47 subroutine_only.flags.q.subroutine_def = 1;
48 if (state->has_explicit_uniform_location()) {
49 subroutine_only.flags.q.explicit_index = 1;
51 return (this->qualifier.flags.i & ~subroutine_only.flags.i) != 0;
54 bool ast_type_qualifier::has_interpolation() const
56 return this->flags.q.smooth
58 || this->flags.q.noperspective;
62 ast_type_qualifier::has_layout() const
64 return this->flags.q.origin_upper_left
65 || this->flags.q.pixel_center_integer
66 || this->flags.q.depth_any
67 || this->flags.q.depth_greater
68 || this->flags.q.depth_less
69 || this->flags.q.depth_unchanged
70 || this->flags.q.std140
71 || this->flags.q.std430
72 || this->flags.q.shared
73 || this->flags.q.column_major
74 || this->flags.q.row_major
75 || this->flags.q.packed
76 || this->flags.q.explicit_align
77 || this->flags.q.explicit_component
78 || this->flags.q.explicit_location
79 || this->flags.q.explicit_image_format
80 || this->flags.q.explicit_index
81 || this->flags.q.explicit_binding
82 || this->flags.q.explicit_offset
83 || this->flags.q.explicit_stream
84 || this->flags.q.explicit_xfb_buffer
85 || this->flags.q.explicit_xfb_offset
86 || this->flags.q.explicit_xfb_stride;
90 ast_type_qualifier::has_storage() const
92 return this->flags.q.constant
93 || this->flags.q.attribute
94 || this->flags.q.varying
97 || this->flags.q.uniform
98 || this->flags.q.buffer
99 || this->flags.q.shared_storage;
103 ast_type_qualifier::has_auxiliary_storage() const
105 return this->flags.q.centroid
106 || this->flags.q.sample
107 || this->flags.q.patch;
111 * This function merges both duplicate identifies within a single layout and
112 * multiple layout qualifiers on a single variable declaration. The
113 * is_single_layout_merge param is used differentiate between the two.
116 ast_type_qualifier::merge_qualifier(YYLTYPE *loc,
117 _mesa_glsl_parse_state *state,
118 const ast_type_qualifier &q,
119 bool is_single_layout_merge)
121 ast_type_qualifier ubo_mat_mask;
122 ubo_mat_mask.flags.i = 0;
123 ubo_mat_mask.flags.q.row_major = 1;
124 ubo_mat_mask.flags.q.column_major = 1;
126 ast_type_qualifier ubo_layout_mask;
127 ubo_layout_mask.flags.i = 0;
128 ubo_layout_mask.flags.q.std140 = 1;
129 ubo_layout_mask.flags.q.packed = 1;
130 ubo_layout_mask.flags.q.shared = 1;
131 ubo_layout_mask.flags.q.std430 = 1;
133 ast_type_qualifier ubo_binding_mask;
134 ubo_binding_mask.flags.i = 0;
135 ubo_binding_mask.flags.q.explicit_binding = 1;
136 ubo_binding_mask.flags.q.explicit_offset = 1;
138 ast_type_qualifier stream_layout_mask;
139 stream_layout_mask.flags.i = 0;
140 stream_layout_mask.flags.q.stream = 1;
142 /* FIXME: We should probably do interface and function param validation
145 ast_type_qualifier input_layout_mask;
146 input_layout_mask.flags.i = 0;
147 input_layout_mask.flags.q.centroid = 1;
148 /* Function params can have constant */
149 input_layout_mask.flags.q.constant = 1;
150 input_layout_mask.flags.q.explicit_component = 1;
151 input_layout_mask.flags.q.explicit_location = 1;
152 input_layout_mask.flags.q.flat = 1;
153 input_layout_mask.flags.q.in = 1;
154 input_layout_mask.flags.q.invariant = 1;
155 input_layout_mask.flags.q.noperspective = 1;
156 input_layout_mask.flags.q.origin_upper_left = 1;
157 /* Function params 'inout' will set this */
158 input_layout_mask.flags.q.out = 1;
159 input_layout_mask.flags.q.patch = 1;
160 input_layout_mask.flags.q.pixel_center_integer = 1;
161 input_layout_mask.flags.q.precise = 1;
162 input_layout_mask.flags.q.sample = 1;
163 input_layout_mask.flags.q.smooth = 1;
165 /* Uniform block layout qualifiers get to overwrite each
166 * other (rightmost having priority), while all other
167 * qualifiers currently don't allow duplicates.
169 ast_type_qualifier allowed_duplicates_mask;
170 allowed_duplicates_mask.flags.i =
171 ubo_mat_mask.flags.i |
172 ubo_layout_mask.flags.i |
173 ubo_binding_mask.flags.i;
175 /* Geometry shaders can have several layout qualifiers
176 * assigning different stream values.
178 if (state->stage == MESA_SHADER_GEOMETRY)
179 allowed_duplicates_mask.flags.i |=
180 stream_layout_mask.flags.i;
182 if (is_single_layout_merge && !state->has_enhanced_layouts() &&
183 (this->flags.i & q.flags.i & ~allowed_duplicates_mask.flags.i) != 0) {
184 _mesa_glsl_error(loc, state,
185 "duplicate layout qualifiers used");
189 if (q.flags.q.prim_type) {
190 if (this->flags.q.prim_type && this->prim_type != q.prim_type) {
191 _mesa_glsl_error(loc, state,
192 "conflicting primitive type qualifiers used");
195 this->prim_type = q.prim_type;
198 if (q.flags.q.max_vertices) {
199 if (this->max_vertices) {
200 this->max_vertices->merge_qualifier(q.max_vertices);
202 this->max_vertices = q.max_vertices;
206 if (q.flags.q.subroutine_def) {
207 if (this->flags.q.subroutine_def) {
208 _mesa_glsl_error(loc, state,
209 "conflicting subroutine qualifiers used");
211 this->subroutine_list = q.subroutine_list;
215 if (q.flags.q.invocations) {
216 if (this->invocations) {
217 this->invocations->merge_qualifier(q.invocations);
219 this->invocations = q.invocations;
223 if (state->stage == MESA_SHADER_GEOMETRY &&
224 state->has_explicit_attrib_stream()) {
225 if (!this->flags.q.explicit_stream) {
226 if (q.flags.q.stream) {
227 this->flags.q.stream = 1;
228 this->stream = q.stream;
229 } else if (!this->flags.q.stream && this->flags.q.out) {
230 /* Assign default global stream value */
231 this->flags.q.stream = 1;
232 this->stream = state->out_qualifier->stream;
237 if (state->has_enhanced_layouts()) {
238 if (!this->flags.q.explicit_xfb_buffer) {
239 if (q.flags.q.xfb_buffer) {
240 this->flags.q.xfb_buffer = 1;
241 this->xfb_buffer = q.xfb_buffer;
242 } else if (!this->flags.q.xfb_buffer && this->flags.q.out) {
243 /* Assign global xfb_buffer value */
244 this->flags.q.xfb_buffer = 1;
245 this->xfb_buffer = state->out_qualifier->xfb_buffer;
249 if (q.flags.q.explicit_xfb_stride)
250 this->xfb_stride = q.xfb_stride;
252 /* Merge all we xfb_stride qualifiers into the global out */
253 if (q.flags.q.explicit_xfb_stride || this->flags.q.xfb_stride) {
255 /* Set xfb_stride flag to 0 to avoid adding duplicates every time
258 this->flags.q.xfb_stride = 0;
261 if (process_qualifier_constant(state, loc, "xfb_buffer",
262 this->xfb_buffer, &buff_idx)) {
263 if (state->out_qualifier->out_xfb_stride[buff_idx]) {
264 state->out_qualifier->out_xfb_stride[buff_idx]->merge_qualifier(
265 new(state) ast_layout_expression(*loc, this->xfb_stride));
267 state->out_qualifier->out_xfb_stride[buff_idx] =
268 new(state) ast_layout_expression(*loc, this->xfb_stride);
274 if (q.flags.q.vertices) {
275 if (this->vertices) {
276 this->vertices->merge_qualifier(q.vertices);
278 this->vertices = q.vertices;
282 if (q.flags.q.vertex_spacing) {
283 if (this->flags.q.vertex_spacing && this->vertex_spacing != q.vertex_spacing) {
284 _mesa_glsl_error(loc, state,
285 "conflicting vertex spacing used");
288 this->vertex_spacing = q.vertex_spacing;
291 if (q.flags.q.ordering) {
292 if (this->flags.q.ordering && this->ordering != q.ordering) {
293 _mesa_glsl_error(loc, state,
294 "conflicting ordering used");
297 this->ordering = q.ordering;
300 if (q.flags.q.point_mode) {
301 if (this->flags.q.point_mode && this->point_mode != q.point_mode) {
302 _mesa_glsl_error(loc, state,
303 "conflicting point mode used");
306 this->point_mode = q.point_mode;
309 if ((q.flags.i & ubo_mat_mask.flags.i) != 0)
310 this->flags.i &= ~ubo_mat_mask.flags.i;
311 if ((q.flags.i & ubo_layout_mask.flags.i) != 0)
312 this->flags.i &= ~ubo_layout_mask.flags.i;
314 for (int i = 0; i < 3; i++) {
315 if (q.flags.q.local_size & (1 << i)) {
316 if (this->local_size[i]) {
317 this->local_size[i]->merge_qualifier(q.local_size[i]);
319 this->local_size[i] = q.local_size[i];
324 this->flags.i |= q.flags.i;
326 if (this->flags.q.in &&
327 (this->flags.i & ~input_layout_mask.flags.i) != 0) {
328 _mesa_glsl_error(loc, state,
329 "invalid input layout qualifier used");
333 if (q.flags.q.explicit_align)
334 this->align = q.align;
336 if (q.flags.q.explicit_location)
337 this->location = q.location;
339 if (q.flags.q.explicit_index)
340 this->index = q.index;
342 if (q.flags.q.explicit_component)
343 this->component = q.component;
345 if (q.flags.q.explicit_binding)
346 this->binding = q.binding;
348 if (q.flags.q.explicit_offset || q.flags.q.explicit_xfb_offset)
349 this->offset = q.offset;
351 if (q.precision != ast_precision_none)
352 this->precision = q.precision;
354 if (q.flags.q.explicit_image_format) {
355 this->image_format = q.image_format;
356 this->image_base_type = q.image_base_type;
363 ast_type_qualifier::merge_out_qualifier(YYLTYPE *loc,
364 _mesa_glsl_parse_state *state,
365 const ast_type_qualifier &q,
366 ast_node* &node, bool create_node)
368 void *mem_ctx = state;
369 const bool r = this->merge_qualifier(loc, state, q, false);
370 ast_type_qualifier valid_out_mask;
371 valid_out_mask.flags.i = 0;
373 if (state->stage == MESA_SHADER_GEOMETRY) {
374 if (q.flags.q.prim_type) {
375 /* Make sure this is a valid output primitive type. */
376 switch (q.prim_type) {
379 case GL_TRIANGLE_STRIP:
382 _mesa_glsl_error(loc, state, "invalid geometry shader output "
388 /* Allow future assigments of global out's stream id value */
389 this->flags.q.explicit_stream = 0;
391 valid_out_mask.flags.q.stream = 1;
392 valid_out_mask.flags.q.explicit_stream = 1;
393 valid_out_mask.flags.q.explicit_xfb_buffer = 1;
394 valid_out_mask.flags.q.xfb_buffer = 1;
395 valid_out_mask.flags.q.explicit_xfb_stride = 1;
396 valid_out_mask.flags.q.xfb_stride = 1;
397 valid_out_mask.flags.q.max_vertices = 1;
398 valid_out_mask.flags.q.prim_type = 1;
399 } else if (state->stage == MESA_SHADER_TESS_CTRL) {
401 node = new(mem_ctx) ast_tcs_output_layout(*loc);
403 valid_out_mask.flags.q.vertices = 1;
404 valid_out_mask.flags.q.explicit_xfb_buffer = 1;
405 valid_out_mask.flags.q.xfb_buffer = 1;
406 valid_out_mask.flags.q.explicit_xfb_stride = 1;
407 valid_out_mask.flags.q.xfb_stride = 1;
408 } else if (state->stage == MESA_SHADER_TESS_EVAL ||
409 state->stage == MESA_SHADER_VERTEX) {
410 valid_out_mask.flags.q.explicit_xfb_buffer = 1;
411 valid_out_mask.flags.q.xfb_buffer = 1;
412 valid_out_mask.flags.q.explicit_xfb_stride = 1;
413 valid_out_mask.flags.q.xfb_stride = 1;
415 _mesa_glsl_error(loc, state, "out layout qualifiers only valid in "
416 "geometry, tessellation and vertex shaders");
420 /* Allow future assigments of global out's */
421 this->flags.q.explicit_xfb_buffer = 0;
422 this->flags.q.explicit_xfb_stride = 0;
424 /* Generate an error when invalid input layout qualifiers are used. */
425 if ((q.flags.i & ~valid_out_mask.flags.i) != 0) {
426 _mesa_glsl_error(loc, state,
427 "invalid output layout qualifiers used");
435 ast_type_qualifier::merge_in_qualifier(YYLTYPE *loc,
436 _mesa_glsl_parse_state *state,
437 const ast_type_qualifier &q,
438 ast_node* &node, bool create_node)
440 void *mem_ctx = state;
441 bool create_gs_ast = false;
442 bool create_cs_ast = false;
443 ast_type_qualifier valid_in_mask;
444 valid_in_mask.flags.i = 0;
446 switch (state->stage) {
447 case MESA_SHADER_TESS_EVAL:
448 if (q.flags.q.prim_type) {
449 /* Make sure this is a valid input primitive type. */
450 switch (q.prim_type) {
456 _mesa_glsl_error(loc, state,
457 "invalid tessellation evaluation "
458 "shader input primitive type");
463 valid_in_mask.flags.q.prim_type = 1;
464 valid_in_mask.flags.q.vertex_spacing = 1;
465 valid_in_mask.flags.q.ordering = 1;
466 valid_in_mask.flags.q.point_mode = 1;
468 case MESA_SHADER_GEOMETRY:
469 if (q.flags.q.prim_type) {
470 /* Make sure this is a valid input primitive type. */
471 switch (q.prim_type) {
474 case GL_LINES_ADJACENCY:
476 case GL_TRIANGLES_ADJACENCY:
479 _mesa_glsl_error(loc, state,
480 "invalid geometry shader input primitive type");
486 q.flags.q.prim_type &&
487 !state->in_qualifier->flags.q.prim_type;
489 valid_in_mask.flags.q.prim_type = 1;
490 valid_in_mask.flags.q.invocations = 1;
492 case MESA_SHADER_FRAGMENT:
493 valid_in_mask.flags.q.early_fragment_tests = 1;
495 case MESA_SHADER_COMPUTE:
497 q.flags.q.local_size != 0 &&
498 state->in_qualifier->flags.q.local_size == 0;
500 valid_in_mask.flags.q.local_size = 7;
503 _mesa_glsl_error(loc, state,
504 "input layout qualifiers only valid in "
505 "geometry, fragment and compute shaders");
509 /* Generate an error when invalid input layout qualifiers are used. */
510 if ((q.flags.i & ~valid_in_mask.flags.i) != 0) {
511 _mesa_glsl_error(loc, state,
512 "invalid input layout qualifiers used");
516 /* Input layout qualifiers can be specified multiple
517 * times in separate declarations, as long as they match.
519 if (this->flags.q.prim_type) {
520 if (q.flags.q.prim_type &&
521 this->prim_type != q.prim_type) {
522 _mesa_glsl_error(loc, state,
523 "conflicting input primitive %s specified",
524 state->stage == MESA_SHADER_GEOMETRY ?
527 } else if (q.flags.q.prim_type) {
528 state->in_qualifier->flags.q.prim_type = 1;
529 state->in_qualifier->prim_type = q.prim_type;
532 if (q.flags.q.invocations) {
533 this->flags.q.invocations = 1;
534 if (this->invocations) {
535 this->invocations->merge_qualifier(q.invocations);
537 this->invocations = q.invocations;
541 if (q.flags.q.early_fragment_tests) {
542 state->fs_early_fragment_tests = true;
545 if (this->flags.q.vertex_spacing) {
546 if (q.flags.q.vertex_spacing &&
547 this->vertex_spacing != q.vertex_spacing) {
548 _mesa_glsl_error(loc, state,
549 "conflicting vertex spacing specified");
551 } else if (q.flags.q.vertex_spacing) {
552 this->flags.q.vertex_spacing = 1;
553 this->vertex_spacing = q.vertex_spacing;
556 if (this->flags.q.ordering) {
557 if (q.flags.q.ordering &&
558 this->ordering != q.ordering) {
559 _mesa_glsl_error(loc, state,
560 "conflicting ordering specified");
562 } else if (q.flags.q.ordering) {
563 this->flags.q.ordering = 1;
564 this->ordering = q.ordering;
567 if (this->flags.q.point_mode) {
568 if (q.flags.q.point_mode &&
569 this->point_mode != q.point_mode) {
570 _mesa_glsl_error(loc, state,
571 "conflicting point mode specified");
573 } else if (q.flags.q.point_mode) {
574 this->flags.q.point_mode = 1;
575 this->point_mode = q.point_mode;
580 node = new(mem_ctx) ast_gs_input_layout(*loc, q.prim_type);
581 } else if (create_cs_ast) {
582 node = new(mem_ctx) ast_cs_input_layout(*loc, q.local_size);
590 * Check if the current type qualifier has any illegal flags.
592 * If so, print an error message, followed by a list of illegal flags.
594 * \param message The error message to print.
595 * \param allowed_flags A list of valid flags.
598 ast_type_qualifier::validate_flags(YYLTYPE *loc,
599 _mesa_glsl_parse_state *state,
601 const ast_type_qualifier &allowed_flags)
603 ast_type_qualifier bad;
604 bad.flags.i = this->flags.i & ~allowed_flags.flags.i;
605 if (bad.flags.i == 0)
608 _mesa_glsl_error(loc, state,
610 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
611 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
612 "%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
614 bad.flags.q.invariant ? " invariant" : "",
615 bad.flags.q.precise ? " precise" : "",
616 bad.flags.q.constant ? " constant" : "",
617 bad.flags.q.attribute ? " attribute" : "",
618 bad.flags.q.varying ? " varying" : "",
619 bad.flags.q.in ? " in" : "",
620 bad.flags.q.out ? " out" : "",
621 bad.flags.q.centroid ? " centroid" : "",
622 bad.flags.q.sample ? " sample" : "",
623 bad.flags.q.patch ? " patch" : "",
624 bad.flags.q.uniform ? " uniform" : "",
625 bad.flags.q.buffer ? " buffer" : "",
626 bad.flags.q.shared_storage ? " shared_storage" : "",
627 bad.flags.q.smooth ? " smooth" : "",
628 bad.flags.q.flat ? " flat" : "",
629 bad.flags.q.noperspective ? " noperspective" : "",
630 bad.flags.q.origin_upper_left ? " origin_upper_left" : "",
631 bad.flags.q.pixel_center_integer ? " pixel_center_integer" : "",
632 bad.flags.q.explicit_align ? " align" : "",
633 bad.flags.q.explicit_location ? " location" : "",
634 bad.flags.q.explicit_index ? " index" : "",
635 bad.flags.q.explicit_binding ? " binding" : "",
636 bad.flags.q.explicit_offset ? " offset" : "",
637 bad.flags.q.depth_any ? " depth_any" : "",
638 bad.flags.q.depth_greater ? " depth_greater" : "",
639 bad.flags.q.depth_less ? " depth_less" : "",
640 bad.flags.q.depth_unchanged ? " depth_unchanged" : "",
641 bad.flags.q.std140 ? " std140" : "",
642 bad.flags.q.std430 ? " std430" : "",
643 bad.flags.q.shared ? " shared" : "",
644 bad.flags.q.packed ? " packed" : "",
645 bad.flags.q.column_major ? " column_major" : "",
646 bad.flags.q.row_major ? " row_major" : "",
647 bad.flags.q.prim_type ? " prim_type" : "",
648 bad.flags.q.max_vertices ? " max_vertices" : "",
649 bad.flags.q.local_size ? " local_size" : "",
650 bad.flags.q.early_fragment_tests ? " early_fragment_tests" : "",
651 bad.flags.q.explicit_image_format ? " image_format" : "",
652 bad.flags.q.coherent ? " coherent" : "",
653 bad.flags.q._volatile ? " _volatile" : "",
654 bad.flags.q.restrict_flag ? " restrict_flag" : "",
655 bad.flags.q.read_only ? " read_only" : "",
656 bad.flags.q.write_only ? " write_only" : "",
657 bad.flags.q.invocations ? " invocations" : "",
658 bad.flags.q.stream ? " stream" : "",
659 bad.flags.q.explicit_stream ? " stream" : "",
660 bad.flags.q.explicit_xfb_offset ? " xfb_offset" : "",
661 bad.flags.q.xfb_buffer ? " xfb_buffer" : "",
662 bad.flags.q.explicit_xfb_buffer ? " xfb_buffer" : "",
663 bad.flags.q.xfb_stride ? " xfb_stride" : "",
664 bad.flags.q.explicit_xfb_stride ? " xfb_stride" : "",
665 bad.flags.q.vertex_spacing ? " vertex_spacing" : "",
666 bad.flags.q.ordering ? " ordering" : "",
667 bad.flags.q.point_mode ? " point_mode" : "",
668 bad.flags.q.vertices ? " vertices" : "",
669 bad.flags.q.subroutine ? " subroutine" : "",
670 bad.flags.q.subroutine_def ? " subroutine_def" : "");
675 ast_layout_expression::process_qualifier_constant(struct _mesa_glsl_parse_state *state,
676 const char *qual_indentifier,
681 bool first_pass = true;
687 for (exec_node *node = layout_const_expressions.head;
688 !node->is_tail_sentinel(); node = node->next) {
690 exec_list dummy_instructions;
691 ast_node *const_expression = exec_node_data(ast_node, node, link);
693 ir_rvalue *const ir = const_expression->hir(&dummy_instructions, state);
695 ir_constant *const const_int = ir->constant_expression_value();
696 if (const_int == NULL || !const_int->type->is_integer()) {
697 YYLTYPE loc = const_expression->get_location();
698 _mesa_glsl_error(&loc, state, "%s must be an integral constant "
699 "expression", qual_indentifier);
703 if (const_int->value.i[0] < min_value) {
704 YYLTYPE loc = const_expression->get_location();
705 _mesa_glsl_error(&loc, state, "%s layout qualifier is invalid "
706 "(%d < %d)", qual_indentifier,
707 const_int->value.i[0], min_value);
711 if (!first_pass && *value != const_int->value.u[0]) {
712 YYLTYPE loc = const_expression->get_location();
713 _mesa_glsl_error(&loc, state, "%s layout qualifier does not "
714 "match previous declaration (%d vs %d)",
715 qual_indentifier, *value, const_int->value.i[0]);
719 *value = const_int->value.u[0];
722 /* If the location is const (and we've verified that
723 * it is) then no instructions should have been emitted
724 * when we converted it to HIR. If they were emitted,
725 * then either the location isn't const after all, or
726 * we are emitting unnecessary instructions.
728 assert(dummy_instructions.is_empty());
735 process_qualifier_constant(struct _mesa_glsl_parse_state *state,
737 const char *qual_indentifier,
738 ast_expression *const_expression,
741 exec_list dummy_instructions;
743 if (const_expression == NULL) {
748 ir_rvalue *const ir = const_expression->hir(&dummy_instructions, state);
750 ir_constant *const const_int = ir->constant_expression_value();
751 if (const_int == NULL || !const_int->type->is_integer()) {
752 _mesa_glsl_error(loc, state, "%s must be an integral constant "
753 "expression", qual_indentifier);
757 if (const_int->value.i[0] < 0) {
758 _mesa_glsl_error(loc, state, "%s layout qualifier is invalid (%d < 0)",
759 qual_indentifier, const_int->value.u[0]);
763 /* If the location is const (and we've verified that
764 * it is) then no instructions should have been emitted
765 * when we converted it to HIR. If they were emitted,
766 * then either the location isn't const after all, or
767 * we are emitting unnecessary instructions.
769 assert(dummy_instructions.is_empty());
771 *value = const_int->value.u[0];