1 /* -*- c++ -*- */
2 /*
3 * Copyright © 2010 Intel Corporation
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25 #pragma once
26 #ifndef IR_H
27 #define IR_H
28
29 #include <stdio.h>
30 #include <stdlib.h>
31
32 #include "c99_compat.h"
33 #include "util/ralloc.h"
34 #include "glsl_types.h"
35 #include "list.h"
36 #include "ir_visitor.h"
37 #include "ir_hierarchical_visitor.h"
38 #include "main/mtypes.h"
39 #include "main/macros.h"
40
41 #ifdef __cplusplus
42
43 /**
44 * \defgroup IR Intermediate representation nodes
45 *
46 * @{
47 */
48
49 /**
50 * Class tags
51 *
52 * Each concrete class derived from \c ir_instruction has a value in this
53 * enumerant. The value for the type is stored in \c ir_instruction::ir_type
54 * by the constructor. While using type tags is not very C++, it is extremely
55 * convenient. For example, during debugging you can simply inspect
56 * \c ir_instruction::ir_type to find out the actual type of the object.
57 *
58 * In addition, it is possible to use a switch-statement based on \c
59 * \c ir_instruction::ir_type to select different behavior for different object
60 * types. For functions that have only slight differences for several object
61 * types, this allows writing very straightforward, readable code.
62 */
63 enum ir_node_type {
64 ir_type_dereference_array,
65 ir_type_dereference_record,
66 ir_type_dereference_variable,
67 ir_type_constant,
68 ir_type_expression,
69 ir_type_swizzle,
70 ir_type_texture,
71 ir_type_variable,
72 ir_type_assignment,
73 ir_type_call,
74 ir_type_function,
75 ir_type_function_signature,
76 ir_type_if,
77 ir_type_loop,
78 ir_type_loop_jump,
79 ir_type_return,
80 ir_type_precision,
81 ir_type_typedecl,
82 ir_type_discard,
83 ir_type_emit_vertex,
84 ir_type_end_primitive,
85 ir_type_max, /**< maximum ir_type enum number, for validation */
86 ir_type_unset = ir_type_max
87 };
88
89
90 /**
91 * Base class of all IR instructions
92 */
93 class ir_instruction : public exec_node {
94 public:
95 enum ir_node_type ir_type;
96
97 /**
98 * GCC 4.7+ and clang warn when deleting an ir_instruction unless
99 * there's a virtual destructor present. Because we almost
100 * universally use ralloc for our memory management of
101 * ir_instructions, the destructor doesn't need to do any work.
102 */
~ir_instruction()103 virtual ~ir_instruction()
104 {
105 }
106
107 /** ir_print_visitor helper for debugging. */
108 void print(void) const;
109 void fprint(FILE *f) const;
110
111 virtual void accept(ir_visitor *) = 0;
112 virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0;
113 virtual ir_instruction *clone(void *mem_ctx,
114 struct hash_table *ht) const = 0;
115
116 /**
117 * \name IR instruction downcast functions
118 *
119 * These functions either cast the object to a derived class or return
120 * \c NULL if the object's type does not match the specified derived class.
121 * Additional downcast functions will be added as needed.
122 */
123 /*@{*/
as_rvalue()124 class ir_rvalue *as_rvalue()
125 {
126 if (ir_type == ir_type_dereference_array ||
127 ir_type == ir_type_dereference_record ||
128 ir_type == ir_type_dereference_variable ||
129 ir_type == ir_type_constant ||
130 ir_type == ir_type_expression ||
131 ir_type == ir_type_swizzle ||
132 ir_type == ir_type_texture)
133 return (class ir_rvalue *) this;
134 return NULL;
135 }
136
as_dereference()137 class ir_dereference *as_dereference()
138 {
139 if (ir_type == ir_type_dereference_array ||
140 ir_type == ir_type_dereference_record ||
141 ir_type == ir_type_dereference_variable)
142 return (class ir_dereference *) this;
143 return NULL;
144 }
145
as_jump()146 class ir_jump *as_jump()
147 {
148 if (ir_type == ir_type_loop_jump ||
149 ir_type == ir_type_return ||
150 ir_type == ir_type_discard)
151 return (class ir_jump *) this;
152 return NULL;
153 }
154
155 #define AS_CHILD(TYPE) \
156 class ir_##TYPE * as_##TYPE() \
157 { \
158 return ir_type == ir_type_##TYPE ? (ir_##TYPE *) this : NULL; \
159 }
160 AS_CHILD(variable)
161 AS_CHILD(function)
162 AS_CHILD(dereference_array)
163 AS_CHILD(dereference_variable)
164 AS_CHILD(dereference_record)
165 AS_CHILD(expression)
166 AS_CHILD(loop)
167 AS_CHILD(assignment)
168 AS_CHILD(call)
169 AS_CHILD(return)
170 AS_CHILD(if)
171 AS_CHILD(swizzle)
172 AS_CHILD(texture)
173 AS_CHILD(constant)
174 AS_CHILD(discard)
175 #undef AS_CHILD
176 /*@}*/
177
178 /**
179 * IR equality method: Return true if the referenced instruction would
180 * return the same value as this one.
181 *
182 * This intended to be used for CSE and algebraic optimizations, on rvalues
183 * in particular. No support for other instruction types (assignments,
184 * jumps, calls, etc.) is planned.
185 */
186 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
187
188 protected:
ir_instruction(enum ir_node_type t)189 ir_instruction(enum ir_node_type t)
190 : ir_type(t)
191 {
192 }
193
194 private:
ir_instruction()195 ir_instruction()
196 {
197 assert(!"Should not get here.");
198 }
199 };
200
201
202 /**
203 * The base class for all "values"/expression trees.
204 */
205 class ir_rvalue : public ir_instruction {
206 public:
207 const struct glsl_type *type;
208
209 virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const;
210
accept(ir_visitor * v)211 virtual void accept(ir_visitor *v)
212 {
213 v->visit(this);
214 }
215
216 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
217
218 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
219
220 ir_rvalue *as_rvalue_to_saturate();
221
is_lvalue()222 virtual bool is_lvalue() const
223 {
224 return false;
225 }
226
227 /**
228 * Get the variable that is ultimately referenced by an r-value
229 */
variable_referenced()230 virtual ir_variable *variable_referenced() const
231 {
232 return NULL;
233 }
234
235
236 /**
237 * If an r-value is a reference to a whole variable, get that variable
238 *
239 * \return
240 * Pointer to a variable that is completely dereferenced by the r-value. If
241 * the r-value is not a dereference or the dereference does not access the
242 * entire variable (i.e., it's just one array element, struct field), \c NULL
243 * is returned.
244 */
whole_variable_referenced()245 virtual ir_variable *whole_variable_referenced()
246 {
247 return NULL;
248 }
249
get_precision()250 glsl_precision get_precision() const { return precision; }
set_precision(glsl_precision prec)251 void set_precision (glsl_precision prec) { precision = prec; }
252
253 /**
254 * Determine if an r-value has the value zero
255 *
256 * The base implementation of this function always returns \c false. The
257 * \c ir_constant class over-rides this function to return \c true \b only
258 * for vector and scalar types that have all elements set to the value
259 * zero (or \c false for booleans).
260 *
261 * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one,
262 * ir_constant::is_basis
263 */
264 virtual bool is_zero() const;
265
266 /**
267 * Determine if an r-value has the value one
268 *
269 * The base implementation of this function always returns \c false. The
270 * \c ir_constant class over-rides this function to return \c true \b only
271 * for vector and scalar types that have all elements set to the value
272 * one (or \c true for booleans).
273 *
274 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one,
275 * ir_constant::is_basis
276 */
277 virtual bool is_one() const;
278
279 /**
280 * Determine if an r-value has the value negative one
281 *
282 * The base implementation of this function always returns \c false. The
283 * \c ir_constant class over-rides this function to return \c true \b only
284 * for vector and scalar types that have all elements set to the value
285 * negative one. For boolean types, the result is always \c false.
286 *
287 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one
288 * ir_constant::is_basis
289 */
290 virtual bool is_negative_one() const;
291
292 /**
293 * Determine if an r-value is a basis vector
294 *
295 * The base implementation of this function always returns \c false. The
296 * \c ir_constant class over-rides this function to return \c true \b only
297 * for vector and scalar types that have one element set to the value one,
298 * and the other elements set to the value zero. For boolean types, the
299 * result is always \c false.
300 *
301 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one,
302 * is_constant::is_negative_one
303 */
304 virtual bool is_basis() const;
305
306 /**
307 * Determine if an r-value is an unsigned integer constant which can be
308 * stored in 16 bits.
309 *
310 * \sa ir_constant::is_uint16_constant.
311 */
is_uint16_constant()312 virtual bool is_uint16_constant() const { return false; }
313
314 /**
315 * Return a generic value of error_type.
316 *
317 * Allocation will be performed with 'mem_ctx' as ralloc owner.
318 */
319 static ir_rvalue *error_value(void *mem_ctx);
320
321 protected:
322 ir_rvalue(enum ir_node_type t, glsl_precision precision);
323
324 glsl_precision precision;
325 };
326
327
328 /**
329 * Variable storage classes
330 */
331 enum ir_variable_mode {
332 ir_var_auto = 0, /**< Function local variables and globals. */
333 ir_var_uniform, /**< Variable declared as a uniform. */
334 ir_var_shader_in,
335 ir_var_shader_out,
336 ir_var_shader_inout,
337 ir_var_function_in,
338 ir_var_function_out,
339 ir_var_function_inout,
340 ir_var_const_in, /**< "in" param that must be a constant expression */
341 ir_var_system_value, /**< Ex: front-face, instance-id, etc. */
342 ir_var_temporary, /**< Temporary variable generated during compilation. */
343 ir_var_mode_count /**< Number of variable modes */
344 };
345
346 /**
347 * Enum keeping track of how a variable was declared. For error checking of
348 * the gl_PerVertex redeclaration rules.
349 */
350 enum ir_var_declaration_type {
351 /**
352 * Normal declaration (for most variables, this means an explicit
353 * declaration. Exception: temporaries are always implicitly declared, but
354 * they still use ir_var_declared_normally).
355 *
356 * Note: an ir_variable that represents a named interface block uses
357 * ir_var_declared_normally.
358 */
359 ir_var_declared_normally = 0,
360
361 /**
362 * Variable was explicitly declared (or re-declared) in an unnamed
363 * interface block.
364 */
365 ir_var_declared_in_block,
366
367 /**
368 * Variable is an implicitly declared built-in that has not been explicitly
369 * re-declared by the shader.
370 */
371 ir_var_declared_implicitly,
372 };
373
374 /**
375 * \brief Layout qualifiers for gl_FragDepth.
376 *
377 * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared
378 * with a layout qualifier.
379 */
380 enum ir_depth_layout {
381 ir_depth_layout_none, /**< No depth layout is specified. */
382 ir_depth_layout_any,
383 ir_depth_layout_greater,
384 ir_depth_layout_less,
385 ir_depth_layout_unchanged
386 };
387
388 /**
389 * \brief Convert depth layout qualifier to string.
390 */
391 const char*
392 depth_layout_string(ir_depth_layout layout);
393
394 /**
395 * Description of built-in state associated with a uniform
396 *
397 * \sa ir_variable::state_slots
398 */
399 struct ir_state_slot {
400 int tokens[5];
401 int swizzle;
402 };
403
404
405 /**
406 * Get the string value for an interpolation qualifier
407 *
408 * \return The string that would be used in a shader to specify \c
409 * mode will be returned.
410 *
411 * This function is used to generate error messages of the form "shader
412 * uses %s interpolation qualifier", so in the case where there is no
413 * interpolation qualifier, it returns "no".
414 *
415 * This function should only be used on a shader input or output variable.
416 */
417 const char *interpolation_string(unsigned interpolation);
418
419
420 class ir_variable : public ir_instruction {
421 public:
422 ir_variable(const struct glsl_type *, const char *, ir_variable_mode, glsl_precision);
423
424 virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const;
425
accept(ir_visitor * v)426 virtual void accept(ir_visitor *v)
427 {
428 v->visit(this);
429 }
430
431 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
432
433
434 /**
435 * Determine how this variable should be interpolated based on its
436 * interpolation qualifier (if present), whether it is gl_Color or
437 * gl_SecondaryColor, and whether flatshading is enabled in the current GL
438 * state.
439 *
440 * The return value will always be either INTERP_QUALIFIER_SMOOTH,
441 * INTERP_QUALIFIER_NOPERSPECTIVE, or INTERP_QUALIFIER_FLAT.
442 */
443 glsl_interp_qualifier determine_interpolation_mode(bool flat_shade);
444
445 /**
446 * Determine whether or not a variable is part of a uniform block.
447 */
is_in_uniform_block()448 inline bool is_in_uniform_block() const
449 {
450 return this->data.mode == ir_var_uniform && this->interface_type != NULL;
451 }
452
453 /**
454 * Determine whether or not a variable is the declaration of an interface
455 * block
456 *
457 * For the first declaration below, there will be an \c ir_variable named
458 * "instance" whose type and whose instance_type will be the same
459 * \cglsl_type. For the second declaration, there will be an \c ir_variable
460 * named "f" whose type is float and whose instance_type is B2.
461 *
462 * "instance" is an interface instance variable, but "f" is not.
463 *
464 * uniform B1 {
465 * float f;
466 * } instance;
467 *
468 * uniform B2 {
469 * float f;
470 * };
471 */
is_interface_instance()472 inline bool is_interface_instance() const
473 {
474 const glsl_type *const t = this->type;
475
476 return (t == this->interface_type)
477 || (t->is_array() && t->fields.array == this->interface_type);
478 }
479
480 /**
481 * Set this->interface_type on a newly created variable.
482 */
init_interface_type(const struct glsl_type * type)483 void init_interface_type(const struct glsl_type *type)
484 {
485 assert(this->interface_type == NULL);
486 this->interface_type = type;
487 if (this->is_interface_instance()) {
488 this->u.max_ifc_array_access =
489 rzalloc_array(this, unsigned, type->length);
490 }
491 }
492
493 /**
494 * Change this->interface_type on a variable that previously had a
495 * different, but compatible, interface_type. This is used during linking
496 * to set the size of arrays in interface blocks.
497 */
change_interface_type(const struct glsl_type * type)498 void change_interface_type(const struct glsl_type *type)
499 {
500 if (this->u.max_ifc_array_access != NULL) {
501 /* max_ifc_array_access has already been allocated, so make sure the
502 * new interface has the same number of fields as the old one.
503 */
504 assert(this->interface_type->length == type->length);
505 }
506 this->interface_type = type;
507 }
508
509 /**
510 * Change this->interface_type on a variable that previously had a
511 * different, and incompatible, interface_type. This is used during
512 * compilation to handle redeclaration of the built-in gl_PerVertex
513 * interface block.
514 */
reinit_interface_type(const struct glsl_type * type)515 void reinit_interface_type(const struct glsl_type *type)
516 {
517 if (this->u.max_ifc_array_access != NULL) {
518 #ifndef NDEBUG
519 /* Redeclaring gl_PerVertex is only allowed if none of the built-ins
520 * it defines have been accessed yet; so it's safe to throw away the
521 * old max_ifc_array_access pointer, since all of its values are
522 * zero.
523 */
524 for (unsigned i = 0; i < this->interface_type->length; i++)
525 assert(this->u.max_ifc_array_access[i] == 0);
526 #endif
527 ralloc_free(this->u.max_ifc_array_access);
528 this->u.max_ifc_array_access = NULL;
529 }
530 this->interface_type = NULL;
531 init_interface_type(type);
532 }
533
get_interface_type()534 const glsl_type *get_interface_type() const
535 {
536 return this->interface_type;
537 }
538
539 /**
540 * Get the max_ifc_array_access pointer
541 *
542 * A "set" function is not needed because the array is dynmically allocated
543 * as necessary.
544 */
get_max_ifc_array_access()545 inline unsigned *get_max_ifc_array_access()
546 {
547 assert(this->data._num_state_slots == 0);
548 return this->u.max_ifc_array_access;
549 }
550
get_num_state_slots()551 inline unsigned get_num_state_slots() const
552 {
553 assert(!this->is_interface_instance()
554 || this->data._num_state_slots == 0);
555 return this->data._num_state_slots;
556 }
557
set_num_state_slots(unsigned n)558 inline void set_num_state_slots(unsigned n)
559 {
560 assert(!this->is_interface_instance()
561 || n == 0);
562 this->data._num_state_slots = n;
563 }
564
get_state_slots()565 inline ir_state_slot *get_state_slots()
566 {
567 return this->is_interface_instance() ? NULL : this->u.state_slots;
568 }
569
get_state_slots()570 inline const ir_state_slot *get_state_slots() const
571 {
572 return this->is_interface_instance() ? NULL : this->u.state_slots;
573 }
574
allocate_state_slots(unsigned n)575 inline ir_state_slot *allocate_state_slots(unsigned n)
576 {
577 assert(!this->is_interface_instance());
578
579 this->u.state_slots = ralloc_array(this, ir_state_slot, n);
580 this->data._num_state_slots = 0;
581
582 if (this->u.state_slots != NULL)
583 this->data._num_state_slots = n;
584
585 return this->u.state_slots;
586 }
587
is_name_ralloced()588 inline bool is_name_ralloced() const
589 {
590 return this->name != ir_variable::tmp_name;
591 }
592
593 /**
594 * Enable emitting extension warnings for this variable
595 */
596 void enable_extension_warning(const char *extension);
597
598 /**
599 * Get the extension warning string for this variable
600 *
601 * If warnings are not enabled, \c NULL is returned.
602 */
603 const char *get_extension_warning() const;
604
605 /**
606 * Declared type of the variable
607 */
608 const struct glsl_type *type;
609
610 /**
611 * Declared name of the variable
612 */
613 const char *name;
614
615 struct ir_variable_data {
616
617 /**
618 * Is the variable read-only?
619 *
620 * This is set for variables declared as \c const, shader inputs,
621 * and uniforms.
622 */
623 unsigned read_only:1;
624 unsigned centroid:1;
625 unsigned sample:1;
626 unsigned invariant:1;
627 unsigned precise:1;
628
629 /**
630 * Has this variable been used for reading or writing?
631 *
632 * Several GLSL semantic checks require knowledge of whether or not a
633 * variable has been used. For example, it is an error to redeclare a
634 * variable as invariant after it has been used.
635 *
636 * This is only maintained in the ast_to_hir.cpp path, not in
637 * Mesa's fixed function or ARB program paths.
638 */
639 unsigned used:1;
640
641 /**
642 * Has this variable been statically assigned?
643 *
644 * This answers whether the variable was assigned in any path of
645 * the shader during ast_to_hir. This doesn't answer whether it is
646 * still written after dead code removal, nor is it maintained in
647 * non-ast_to_hir.cpp (GLSL parsing) paths.
648 */
649 unsigned assigned:1;
650
651 /**
652 * Enum indicating how the variable was declared. See
653 * ir_var_declaration_type.
654 *
655 * This is used to detect certain kinds of illegal variable redeclarations.
656 */
657 unsigned how_declared:2;
658
659 /**
660 * Storage class of the variable.
661 *
662 * \sa ir_variable_mode
663 */
664 unsigned mode:4;
665
666 /**
667 * Interpolation mode for shader inputs / outputs
668 *
669 * \sa ir_variable_interpolation
670 */
671 unsigned interpolation:2;
672
673 unsigned precision:2;
674
675 /**
676 * \name ARB_fragment_coord_conventions
677 * @{
678 */
679 unsigned origin_upper_left:1;
680 unsigned pixel_center_integer:1;
681 /*@}*/
682
683 /**
684 * Was the location explicitly set in the shader?
685 *
686 * If the location is explicitly set in the shader, it \b cannot be changed
687 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have
688 * no effect).
689 */
690 unsigned explicit_location:1;
691 unsigned explicit_index:1;
692
693 /**
694 * Was an initial binding explicitly set in the shader?
695 *
696 * If so, constant_value contains an integer ir_constant representing the
697 * initial binding point.
698 */
699 unsigned explicit_binding:1;
700
701 /**
702 * Does this variable have an initializer?
703 *
704 * This is used by the linker to cross-validiate initializers of global
705 * variables.
706 */
707 unsigned has_initializer:1;
708
709 /**
710 * Is this variable a generic output or input that has not yet been matched
711 * up to a variable in another stage of the pipeline?
712 *
713 * This is used by the linker as scratch storage while assigning locations
714 * to generic inputs and outputs.
715 */
716 unsigned is_unmatched_generic_inout:1;
717
718 /**
719 * If non-zero, then this variable may be packed along with other variables
720 * into a single varying slot, so this offset should be applied when
721 * accessing components. For example, an offset of 1 means that the x
722 * component of this variable is actually stored in component y of the
723 * location specified by \c location.
724 */
725 unsigned location_frac:2;
726
727 /**
728 * Layout of the matrix. Uses glsl_matrix_layout values.
729 */
730 unsigned matrix_layout:2;
731
732 /**
733 * Non-zero if this variable was created by lowering a named interface
734 * block which was not an array.
735 *
736 * Note that this variable and \c from_named_ifc_block_array will never
737 * both be non-zero.
738 */
739 unsigned from_named_ifc_block_nonarray:1;
740
741 /**
742 * Non-zero if this variable was created by lowering a named interface
743 * block which was an array.
744 *
745 * Note that this variable and \c from_named_ifc_block_nonarray will never
746 * both be non-zero.
747 */
748 unsigned from_named_ifc_block_array:1;
749
750 /**
751 * Non-zero if the variable must be a shader input. This is useful for
752 * constraints on function parameters.
753 */
754 unsigned must_be_shader_input:1;
755
756 /**
757 * Output index for dual source blending.
758 *
759 * \note
760 * The GLSL spec only allows the values 0 or 1 for the index in \b dual
761 * source blending.
762 */
763 unsigned index:1;
764
765 /**
766 * \brief Layout qualifier for gl_FragDepth.
767 *
768 * This is not equal to \c ir_depth_layout_none if and only if this
769 * variable is \c gl_FragDepth and a layout qualifier is specified.
770 */
771 ir_depth_layout depth_layout:3;
772
773 /**
774 * ARB_shader_image_load_store qualifiers.
775 */
776 unsigned image_read_only:1; /**< "readonly" qualifier. */
777 unsigned image_write_only:1; /**< "writeonly" qualifier. */
778 unsigned image_coherent:1;
779 unsigned image_volatile:1;
780 unsigned image_restrict:1;
781
782 /**
783 * Emit a warning if this variable is accessed.
784 */
785 private:
786 uint8_t warn_extension_index;
787
788 public:
789 /** Image internal format if specified explicitly, otherwise GL_NONE. */
790 uint16_t image_format;
791
792 private:
793 /**
794 * Number of state slots used
795 *
796 * \note
797 * This could be stored in as few as 7-bits, if necessary. If it is made
798 * smaller, add an assertion to \c ir_variable::allocate_state_slots to
799 * be safe.
800 */
801 uint16_t _num_state_slots;
802
803 public:
804 /**
805 * Initial binding point for a sampler, atomic, or UBO.
806 *
807 * For array types, this represents the binding point for the first element.
808 */
809 int16_t binding;
810
811 /**
812 * Storage location of the base of this variable
813 *
814 * The precise meaning of this field depends on the nature of the variable.
815 *
816 * - Vertex shader input: one of the values from \c gl_vert_attrib.
817 * - Vertex shader output: one of the values from \c gl_varying_slot.
818 * - Geometry shader input: one of the values from \c gl_varying_slot.
819 * - Geometry shader output: one of the values from \c gl_varying_slot.
820 * - Fragment shader input: one of the values from \c gl_varying_slot.
821 * - Fragment shader output: one of the values from \c gl_frag_result.
822 * - Uniforms: Per-stage uniform slot number for default uniform block.
823 * - Uniforms: Index within the uniform block definition for UBO members.
824 * - Other: This field is not currently used.
825 *
826 * If the variable is a uniform, shader input, or shader output, and the
827 * slot has not been assigned, the value will be -1.
828 */
829 int location;
830
831 /**
832 * Vertex stream output identifier.
833 */
834 unsigned stream;
835
836 /**
837 * Location an atomic counter is stored at.
838 */
839 struct {
840 unsigned offset;
841 } atomic;
842
843 /**
844 * Highest element accessed with a constant expression array index
845 *
846 * Not used for non-array variables.
847 */
848 unsigned max_array_access;
849
850 /**
851 * Allow (only) ir_variable direct access private members.
852 */
853 friend class ir_variable;
854 } data;
855
856 /**
857 * Value assigned in the initializer of a variable declared "const"
858 */
859 ir_constant *constant_value;
860
861 /**
862 * Constant expression assigned in the initializer of the variable
863 *
864 * \warning
865 * This field and \c ::constant_value are distinct. Even if the two fields
866 * refer to constants with the same value, they must point to separate
867 * objects.
868 */
869 ir_constant *constant_initializer;
870
871 private:
872 static const char *const warn_extension_table[];
873
874 union {
875 /**
876 * For variables which satisfy the is_interface_instance() predicate,
877 * this points to an array of integers such that if the ith member of
878 * the interface block is an array, max_ifc_array_access[i] is the
879 * maximum array element of that member that has been accessed. If the
880 * ith member of the interface block is not an array,
881 * max_ifc_array_access[i] is unused.
882 *
883 * For variables whose type is not an interface block, this pointer is
884 * NULL.
885 */
886 unsigned *max_ifc_array_access;
887
888 /**
889 * Built-in state that backs this uniform
890 *
891 * Once set at variable creation, \c state_slots must remain invariant.
892 *
893 * If the variable is not a uniform, \c _num_state_slots will be zero
894 * and \c state_slots will be \c NULL.
895 */
896 ir_state_slot *state_slots;
897 } u;
898
899 /**
900 * For variables that are in an interface block or are an instance of an
901 * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block.
902 *
903 * \sa ir_variable::location
904 */
905 const glsl_type *interface_type;
906
907 /**
908 * Name used for anonymous compiler temporaries
909 */
910 static const char tmp_name[];
911
912 public:
913 /**
914 * Should the construct keep names for ir_var_temporary variables?
915 *
916 * When this global is false, names passed to the constructor for
917 * \c ir_var_temporary variables will be dropped. Instead, the variable will
918 * be named "compiler_temp". This name will be in static storage.
919 *
920 * \warning
921 * \b NEVER change the mode of an \c ir_var_temporary.
922 *
923 * \warning
924 * This variable is \b not thread-safe. It is global, \b not
925 * per-context. It begins life false. A context can, at some point, make
926 * it true. From that point on, it will be true forever. This should be
927 * okay since it will only be set true while debugging.
928 */
929 static bool temporaries_allocate_names;
930 };
931
932 /**
933 * A function that returns whether a built-in function is available in the
934 * current shading language (based on version, ES or desktop, and extensions).
935 */
936 typedef bool (*builtin_available_predicate)(const _mesa_glsl_parse_state *);
937
938 /*@{*/
939 /**
940 * The representation of a function instance; may be the full definition or
941 * simply a prototype.
942 */
943 class ir_function_signature : public ir_instruction {
944 /* An ir_function_signature will be part of the list of signatures in
945 * an ir_function.
946 */
947 public:
948 ir_function_signature(const glsl_type *return_type, glsl_precision precision,
949 builtin_available_predicate builtin_avail = NULL);
950
951 virtual ir_function_signature *clone(void *mem_ctx,
952 struct hash_table *ht) const;
953 ir_function_signature *clone_prototype(void *mem_ctx,
954 struct hash_table *ht) const;
955
accept(ir_visitor * v)956 virtual void accept(ir_visitor *v)
957 {
958 v->visit(this);
959 }
960
961 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
962
963 /**
964 * Attempt to evaluate this function as a constant expression,
965 * given a list of the actual parameters and the variable context.
966 * Returns NULL for non-built-ins.
967 */
968 ir_constant *constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context);
969
970 /**
971 * Get the name of the function for which this is a signature
972 */
973 const char *function_name() const;
974
975 /**
976 * Get a handle to the function for which this is a signature
977 *
978 * There is no setter function, this function returns a \c const pointer,
979 * and \c ir_function_signature::_function is private for a reason. The
980 * only way to make a connection between a function and function signature
981 * is via \c ir_function::add_signature. This helps ensure that certain
982 * invariants (i.e., a function signature is in the list of signatures for
983 * its \c _function) are met.
984 *
985 * \sa ir_function::add_signature
986 */
function()987 inline const class ir_function *function() const
988 {
989 return this->_function;
990 }
991
992 /**
993 * Check whether the qualifiers match between this signature's parameters
994 * and the supplied parameter list. If not, returns the name of the first
995 * parameter with mismatched qualifiers (for use in error messages).
996 */
997 const char *qualifiers_match(exec_list *params);
998
999 /**
1000 * Replace the current parameter list with the given one. This is useful
1001 * if the current information came from a prototype, and either has invalid
1002 * or missing parameter names.
1003 */
1004 void replace_parameters(exec_list *new_params);
1005
1006 /**
1007 * Function return type.
1008 */
1009 const struct glsl_type *return_type;
1010
1011 glsl_precision precision;
1012
1013 /**
1014 * List of ir_variable of function parameters.
1015 *
1016 * This represents the storage. The paramaters passed in a particular
1017 * call will be in ir_call::actual_paramaters.
1018 */
1019 struct exec_list parameters;
1020
1021 /** Whether or not this function has a body (which may be empty). */
1022 unsigned is_defined:1;
1023
1024 /** Whether or not this function signature is a built-in. */
1025 bool is_builtin() const;
1026
1027 /**
1028 * Whether or not this function is an intrinsic to be implemented
1029 * by the driver.
1030 */
1031 bool is_intrinsic;
1032
1033 /** Whether or not a built-in is available for this shader. */
1034 bool is_builtin_available(const _mesa_glsl_parse_state *state) const;
1035
1036 /** Body of instructions in the function. */
1037 struct exec_list body;
1038
1039 private:
1040 /**
1041 * A function pointer to a predicate that answers whether a built-in
1042 * function is available in the current shader. NULL if not a built-in.
1043 */
1044 builtin_available_predicate builtin_avail;
1045
1046 /** Function of which this signature is one overload. */
1047 class ir_function *_function;
1048
1049 /** Function signature of which this one is a prototype clone */
1050 const ir_function_signature *origin;
1051
1052 friend class ir_function;
1053
1054 /**
1055 * Helper function to run a list of instructions for constant
1056 * expression evaluation.
1057 *
1058 * The hash table represents the values of the visible variables.
1059 * There are no scoping issues because the table is indexed on
1060 * ir_variable pointers, not variable names.
1061 *
1062 * Returns false if the expression is not constant, true otherwise,
1063 * and the value in *result if result is non-NULL.
1064 */
1065 bool constant_expression_evaluate_expression_list(const struct exec_list &body,
1066 struct hash_table *variable_context,
1067 ir_constant **result);
1068 };
1069
1070
1071 /**
1072 * Header for tracking multiple overloaded functions with the same name.
1073 * Contains a list of ir_function_signatures representing each of the
1074 * actual functions.
1075 */
1076 class ir_function : public ir_instruction {
1077 public:
1078 ir_function(const char *name);
1079
1080 virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;
1081
accept(ir_visitor * v)1082 virtual void accept(ir_visitor *v)
1083 {
1084 v->visit(this);
1085 }
1086
1087 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1088
add_signature(ir_function_signature * sig)1089 void add_signature(ir_function_signature *sig)
1090 {
1091 sig->_function = this;
1092 this->signatures.push_tail(sig);
1093 }
1094
1095 /**
1096 * Find a signature that matches a set of actual parameters, taking implicit
1097 * conversions into account. Also flags whether the match was exact.
1098 */
1099 ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
1100 const exec_list *actual_param,
1101 bool allow_builtins,
1102 bool *match_is_exact);
1103
1104 /**
1105 * Find a signature that matches a set of actual parameters, taking implicit
1106 * conversions into account.
1107 */
1108 ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
1109 const exec_list *actual_param,
1110 bool allow_builtins);
1111
1112 /**
1113 * Find a signature that exactly matches a set of actual parameters without
1114 * any implicit type conversions.
1115 */
1116 ir_function_signature *exact_matching_signature(_mesa_glsl_parse_state *state,
1117 const exec_list *actual_ps);
1118
1119 /**
1120 * Name of the function.
1121 */
1122 const char *name;
1123
1124 /** Whether or not this function has a signature that isn't a built-in. */
1125 bool has_user_signature();
1126
1127 /**
1128 * List of ir_function_signature for each overloaded function with this name.
1129 */
1130 struct exec_list signatures;
1131 };
1132
function_name()1133 inline const char *ir_function_signature::function_name() const
1134 {
1135 return this->_function->name;
1136 }
1137 /*@}*/
1138
1139
1140 /**
1141 * IR instruction representing high-level if-statements
1142 */
1143 class ir_if : public ir_instruction {
1144 public:
ir_if(ir_rvalue * condition)1145 ir_if(ir_rvalue *condition)
1146 : ir_instruction(ir_type_if), condition(condition)
1147 {
1148 }
1149
1150 virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;
1151
accept(ir_visitor * v)1152 virtual void accept(ir_visitor *v)
1153 {
1154 v->visit(this);
1155 }
1156
1157 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1158
1159 ir_rvalue *condition;
1160 /** List of ir_instruction for the body of the then branch */
1161 exec_list then_instructions;
1162 /** List of ir_instruction for the body of the else branch */
1163 exec_list else_instructions;
1164 };
1165
1166
1167 /**
1168 * IR instruction representing a high-level loop structure.
1169 */
1170 class ir_loop : public ir_instruction {
1171 public:
1172 ir_loop();
1173
1174 virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;
1175
accept(ir_visitor * v)1176 virtual void accept(ir_visitor *v)
1177 {
1178 v->visit(this);
1179 }
1180
1181 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1182
1183 /** List of ir_instruction that make up the body of the loop. */
1184 exec_list body_instructions;
1185 };
1186
1187
1188 class ir_assignment : public ir_instruction {
1189 public:
1190 ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL);
1191
1192 /**
1193 * Construct an assignment with an explicit write mask
1194 *
1195 * \note
1196 * Since a write mask is supplied, the LHS must already be a bare
1197 * \c ir_dereference. The cannot be any swizzles in the LHS.
1198 */
1199 ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition,
1200 unsigned write_mask);
1201
1202 virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
1203
1204 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
1205
accept(ir_visitor * v)1206 virtual void accept(ir_visitor *v)
1207 {
1208 v->visit(this);
1209 }
1210
1211 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1212
1213 /**
1214 * Get a whole variable written by an assignment
1215 *
1216 * If the LHS of the assignment writes a whole variable, the variable is
1217 * returned. Otherwise \c NULL is returned. Examples of whole-variable
1218 * assignment are:
1219 *
1220 * - Assigning to a scalar
1221 * - Assigning to all components of a vector
1222 * - Whole array (or matrix) assignment
1223 * - Whole structure assignment
1224 */
1225 ir_variable *whole_variable_written();
1226
1227 /**
1228 * Set the LHS of an assignment
1229 */
1230 void set_lhs(ir_rvalue *lhs);
1231
1232 /**
1233 * Left-hand side of the assignment.
1234 *
1235 * This should be treated as read only. If you need to set the LHS of an
1236 * assignment, use \c ir_assignment::set_lhs.
1237 */
1238 ir_dereference *lhs;
1239
1240 /**
1241 * Value being assigned
1242 */
1243 ir_rvalue *rhs;
1244
1245 /**
1246 * Optional condition for the assignment.
1247 */
1248 ir_rvalue *condition;
1249
1250
1251 /**
1252 * Component mask written
1253 *
1254 * For non-vector types in the LHS, this field will be zero. For vector
1255 * types, a bit will be set for each component that is written. Note that
1256 * for \c vec2 and \c vec3 types only the lower bits will ever be set.
1257 *
1258 * A partially-set write mask means that each enabled channel gets
1259 * the value from a consecutive channel of the rhs. For example,
1260 * to write just .xyw of gl_FrontColor with color:
1261 *
1262 * (assign (constant bool (1)) (xyw)
1263 * (var_ref gl_FragColor)
1264 * (swiz xyw (var_ref color)))
1265 */
1266 unsigned write_mask:4;
1267 };
1268
1269 /* Update ir_expression::get_num_operands() and operator_strs when
1270 * updating this list.
1271 */
1272 enum ir_expression_operation {
1273 ir_unop_bit_not,
1274 ir_unop_logic_not,
1275 ir_unop_neg,
1276 ir_unop_abs,
1277 ir_unop_sign,
1278 ir_unop_rcp,
1279 ir_unop_rsq,
1280 ir_unop_sqrt,
1281 ir_unop_normalize,
1282 ir_unop_exp, /**< Log base e on gentype */
1283 ir_unop_log, /**< Natural log on gentype */
1284 ir_unop_exp2,
1285 ir_unop_log2,
1286 ir_unop_f2i, /**< Float-to-integer conversion. */
1287 ir_unop_f2u, /**< Float-to-unsigned conversion. */
1288 ir_unop_i2f, /**< Integer-to-float conversion. */
1289 ir_unop_f2b, /**< Float-to-boolean conversion */
1290 ir_unop_b2f, /**< Boolean-to-float conversion */
1291 ir_unop_i2b, /**< int-to-boolean conversion */
1292 ir_unop_b2i, /**< Boolean-to-int conversion */
1293 ir_unop_u2f, /**< Unsigned-to-float conversion. */
1294 ir_unop_i2u, /**< Integer-to-unsigned conversion. */
1295 ir_unop_u2i, /**< Unsigned-to-integer conversion. */
1296 ir_unop_bitcast_i2f, /**< Bit-identical int-to-float "conversion" */
1297 ir_unop_bitcast_f2i, /**< Bit-identical float-to-int "conversion" */
1298 ir_unop_bitcast_u2f, /**< Bit-identical uint-to-float "conversion" */
1299 ir_unop_bitcast_f2u, /**< Bit-identical float-to-uint "conversion" */
1300 ir_unop_any,
1301
1302 /**
1303 * \name Unary floating-point rounding operations.
1304 */
1305 /*@{*/
1306 ir_unop_trunc,
1307 ir_unop_ceil,
1308 ir_unop_floor,
1309 ir_unop_fract,
1310 ir_unop_round_even,
1311 /*@}*/
1312
1313 /**
1314 * \name Trigonometric operations.
1315 */
1316 /*@{*/
1317 ir_unop_sin,
1318 ir_unop_cos,
1319 ir_unop_sin_reduced, /**< Reduced range sin. [-pi, pi] */
1320 ir_unop_cos_reduced, /**< Reduced range cos. [-pi, pi] */
1321 /*@}*/
1322
1323 /**
1324 * \name Partial derivatives.
1325 */
1326 /*@{*/
1327 ir_unop_dFdx,
1328 ir_unop_dFdx_coarse,
1329 ir_unop_dFdx_fine,
1330 ir_unop_dFdy,
1331 ir_unop_dFdy_coarse,
1332 ir_unop_dFdy_fine,
1333 /*@}*/
1334
1335 /**
1336 * \name Floating point pack and unpack operations.
1337 */
1338 /*@{*/
1339 ir_unop_pack_snorm_2x16,
1340 ir_unop_pack_snorm_4x8,
1341 ir_unop_pack_unorm_2x16,
1342 ir_unop_pack_unorm_4x8,
1343 ir_unop_pack_half_2x16,
1344 ir_unop_unpack_snorm_2x16,
1345 ir_unop_unpack_snorm_4x8,
1346 ir_unop_unpack_unorm_2x16,
1347 ir_unop_unpack_unorm_4x8,
1348 ir_unop_unpack_half_2x16,
1349 /*@}*/
1350
1351 /**
1352 * \name Lowered floating point unpacking operations.
1353 *
1354 * \see lower_packing_builtins_visitor::split_unpack_half_2x16
1355 */
1356 /*@{*/
1357 ir_unop_unpack_half_2x16_split_x,
1358 ir_unop_unpack_half_2x16_split_y,
1359 /*@}*/
1360
1361 /**
1362 * \name Bit operations, part of ARB_gpu_shader5.
1363 */
1364 /*@{*/
1365 ir_unop_bitfield_reverse,
1366 ir_unop_bit_count,
1367 ir_unop_find_msb,
1368 ir_unop_find_lsb,
1369 /*@}*/
1370
1371 ir_unop_saturate,
1372 ir_unop_noise,
1373
1374 /**
1375 * Interpolate fs input at centroid
1376 *
1377 * operand0 is the fs input.
1378 */
1379 ir_unop_interpolate_at_centroid,
1380
1381 /**
1382 * A sentinel marking the last of the unary operations.
1383 */
1384 ir_last_unop = ir_unop_interpolate_at_centroid,
1385
1386 ir_binop_add,
1387 ir_binop_sub,
1388 ir_binop_mul, /**< Floating-point or low 32-bit integer multiply. */
1389 ir_binop_imul_high, /**< Calculates the high 32-bits of a 64-bit multiply. */
1390 ir_binop_div,
1391
1392 /**
1393 * Returns the carry resulting from the addition of the two arguments.
1394 */
1395 /*@{*/
1396 ir_binop_carry,
1397 /*@}*/
1398
1399 /**
1400 * Returns the borrow resulting from the subtraction of the second argument
1401 * from the first argument.
1402 */
1403 /*@{*/
1404 ir_binop_borrow,
1405 /*@}*/
1406
1407 /**
1408 * Takes one of two combinations of arguments:
1409 *
1410 * - mod(vecN, vecN)
1411 * - mod(vecN, float)
1412 *
1413 * Does not take integer types.
1414 */
1415 ir_binop_mod,
1416
1417 /**
1418 * \name Binary comparison operators which return a boolean vector.
1419 * The type of both operands must be equal.
1420 */
1421 /*@{*/
1422 ir_binop_less,
1423 ir_binop_greater,
1424 ir_binop_lequal,
1425 ir_binop_gequal,
1426 ir_binop_equal,
1427 ir_binop_nequal,
1428 /**
1429 * Returns single boolean for whether all components of operands[0]
1430 * equal the components of operands[1].
1431 */
1432 ir_binop_all_equal,
1433 /**
1434 * Returns single boolean for whether any component of operands[0]
1435 * is not equal to the corresponding component of operands[1].
1436 */
1437 ir_binop_any_nequal,
1438 /*@}*/
1439
1440 /**
1441 * \name Bit-wise binary operations.
1442 */
1443 /*@{*/
1444 ir_binop_lshift,
1445 ir_binop_rshift,
1446 ir_binop_bit_and,
1447 ir_binop_bit_xor,
1448 ir_binop_bit_or,
1449 /*@}*/
1450
1451 ir_binop_logic_and,
1452 ir_binop_logic_xor,
1453 ir_binop_logic_or,
1454
1455 ir_binop_dot,
1456 ir_binop_min,
1457 ir_binop_max,
1458
1459 ir_binop_pow,
1460
1461 /**
1462 * \name Lowered floating point packing operations.
1463 *
1464 * \see lower_packing_builtins_visitor::split_pack_half_2x16
1465 */
1466 /*@{*/
1467 ir_binop_pack_half_2x16_split,
1468 /*@}*/
1469
1470 /**
1471 * \name First half of a lowered bitfieldInsert() operation.
1472 *
1473 * \see lower_instructions::bitfield_insert_to_bfm_bfi
1474 */
1475 /*@{*/
1476 ir_binop_bfm,
1477 /*@}*/
1478
1479 /**
1480 * Load a value the size of a given GLSL type from a uniform block.
1481 *
1482 * operand0 is the ir_constant uniform block index in the linked shader.
1483 * operand1 is a byte offset within the uniform block.
1484 */
1485 ir_binop_ubo_load,
1486
1487 /**
1488 * \name Multiplies a number by two to a power, part of ARB_gpu_shader5.
1489 */
1490 /*@{*/
1491 ir_binop_ldexp,
1492 /*@}*/
1493
1494 /**
1495 * Extract a scalar from a vector
1496 *
1497 * operand0 is the vector
1498 * operand1 is the index of the field to read from operand0
1499 */
1500 ir_binop_vector_extract,
1501
1502 /**
1503 * Interpolate fs input at offset
1504 *
1505 * operand0 is the fs input
1506 * operand1 is the offset from the pixel center
1507 */
1508 ir_binop_interpolate_at_offset,
1509
1510 /**
1511 * Interpolate fs input at sample position
1512 *
1513 * operand0 is the fs input
1514 * operand1 is the sample ID
1515 */
1516 ir_binop_interpolate_at_sample,
1517
1518 /**
1519 * A sentinel marking the last of the binary operations.
1520 */
1521 ir_last_binop = ir_binop_interpolate_at_sample,
1522
1523 /**
1524 * \name Fused floating-point multiply-add, part of ARB_gpu_shader5.
1525 */
1526 /*@{*/
1527 ir_triop_fma,
1528 /*@}*/
1529
1530 ir_triop_clamp,
1531 ir_triop_lrp,
1532
1533 /**
1534 * \name Conditional Select
1535 *
1536 * A vector conditional select instruction (like ?:, but operating per-
1537 * component on vectors).
1538 *
1539 * \see lower_instructions_visitor::ldexp_to_arith
1540 */
1541 /*@{*/
1542 ir_triop_csel,
1543 /*@}*/
1544
1545 /**
1546 * \name Second half of a lowered bitfieldInsert() operation.
1547 *
1548 * \see lower_instructions::bitfield_insert_to_bfm_bfi
1549 */
1550 /*@{*/
1551 ir_triop_bfi,
1552 /*@}*/
1553
1554 ir_triop_bitfield_extract,
1555
1556 /**
1557 * Generate a value with one field of a vector changed
1558 *
1559 * operand0 is the vector
1560 * operand1 is the value to write into the vector result
1561 * operand2 is the index in operand0 to be modified
1562 */
1563 ir_triop_vector_insert,
1564
1565 /**
1566 * A sentinel marking the last of the ternary operations.
1567 */
1568 ir_last_triop = ir_triop_vector_insert,
1569
1570 ir_quadop_bitfield_insert,
1571
1572 ir_quadop_vector,
1573
1574 /**
1575 * A sentinel marking the last of the ternary operations.
1576 */
1577 ir_last_quadop = ir_quadop_vector,
1578
1579 /**
1580 * A sentinel marking the last of all operations.
1581 */
1582 ir_last_opcode = ir_quadop_vector
1583 };
1584
1585 class ir_expression : public ir_rvalue {
1586 public:
1587 ir_expression(int op, const struct glsl_type *type,
1588 ir_rvalue *op0, ir_rvalue *op1 = NULL,
1589 ir_rvalue *op2 = NULL, ir_rvalue *op3 = NULL);
1590
1591 /**
1592 * Constructor for unary operation expressions
1593 */
1594 ir_expression(int op, ir_rvalue *);
1595
1596 /**
1597 * Constructor for binary operation expressions
1598 */
1599 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1);
1600
1601 /**
1602 * Constructor for ternary operation expressions
1603 */
1604 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1, ir_rvalue *op2);
1605
1606 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
1607
1608 virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const;
1609
1610 /**
1611 * Attempt to constant-fold the expression
1612 *
1613 * The "variable_context" hash table links ir_variable * to ir_constant *
1614 * that represent the variables' values. \c NULL represents an empty
1615 * context.
1616 *
1617 * If the expression cannot be constant folded, this method will return
1618 * \c NULL.
1619 */
1620 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
1621
1622 /**
1623 * Determine the number of operands used by an expression
1624 */
1625 static unsigned int get_num_operands(ir_expression_operation);
1626
1627 /**
1628 * Determine the number of operands used by an expression
1629 */
get_num_operands()1630 unsigned int get_num_operands() const
1631 {
1632 return (this->operation == ir_quadop_vector)
1633 ? this->type->vector_elements : get_num_operands(operation);
1634 }
1635
1636 /**
1637 * Return whether the expression operates on vectors horizontally.
1638 */
is_horizontal()1639 bool is_horizontal() const
1640 {
1641 return operation == ir_binop_all_equal ||
1642 operation == ir_binop_any_nequal ||
1643 operation == ir_unop_any ||
1644 operation == ir_binop_dot ||
1645 operation == ir_quadop_vector;
1646 }
1647
1648 /**
1649 * Return a string representing this expression's operator.
1650 */
1651 const char *operator_string();
1652
1653 /**
1654 * Return a string representing this expression's operator.
1655 */
1656 static const char *operator_string(ir_expression_operation);
1657
1658
1659 /**
1660 * Do a reverse-lookup to translate the given string into an operator.
1661 */
1662 static ir_expression_operation get_operator(const char *);
1663
accept(ir_visitor * v)1664 virtual void accept(ir_visitor *v)
1665 {
1666 v->visit(this);
1667 }
1668
1669 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1670
1671 ir_expression_operation operation;
1672 ir_rvalue *operands[4];
1673 };
1674
1675
1676 /**
1677 * HIR instruction representing a high-level function call, containing a list
1678 * of parameters and returning a value in the supplied temporary.
1679 */
1680 class ir_call : public ir_instruction {
1681 public:
ir_call(ir_function_signature * callee,ir_dereference_variable * return_deref,exec_list * actual_parameters)1682 ir_call(ir_function_signature *callee,
1683 ir_dereference_variable *return_deref,
1684 exec_list *actual_parameters)
1685 : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee)
1686 {
1687 assert(callee->return_type != NULL);
1688 actual_parameters->move_nodes_to(& this->actual_parameters);
1689 this->use_builtin = callee->is_builtin();
1690 }
1691
1692 virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
1693
1694 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
1695
accept(ir_visitor * v)1696 virtual void accept(ir_visitor *v)
1697 {
1698 v->visit(this);
1699 }
1700
1701 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1702
1703 /**
1704 * Get the name of the function being called.
1705 */
callee_name()1706 const char *callee_name() const
1707 {
1708 return callee->function_name();
1709 }
1710
1711 /**
1712 * Generates an inline version of the function before @ir,
1713 * storing the return value in return_deref.
1714 */
1715 void generate_inline(ir_instruction *ir);
1716
1717 /**
1718 * Storage for the function's return value.
1719 * This must be NULL if the return type is void.
1720 */
1721 ir_dereference_variable *return_deref;
1722
1723 /**
1724 * The specific function signature being called.
1725 */
1726 ir_function_signature *callee;
1727
1728 /* List of ir_rvalue of paramaters passed in this call. */
1729 exec_list actual_parameters;
1730
1731 /** Should this call only bind to a built-in function? */
1732 bool use_builtin;
1733 };
1734
1735
1736 /**
1737 * \name Jump-like IR instructions.
1738 *
1739 * These include \c break, \c continue, \c return, and \c discard.
1740 */
1741 /*@{*/
1742 class ir_jump : public ir_instruction {
1743 protected:
ir_jump(enum ir_node_type t)1744 ir_jump(enum ir_node_type t)
1745 : ir_instruction(t)
1746 {
1747 }
1748 };
1749
1750 class ir_return : public ir_jump {
1751 public:
ir_return()1752 ir_return()
1753 : ir_jump(ir_type_return), value(NULL)
1754 {
1755 }
1756
ir_return(ir_rvalue * value)1757 ir_return(ir_rvalue *value)
1758 : ir_jump(ir_type_return), value(value)
1759 {
1760 }
1761
1762 virtual ir_return *clone(void *mem_ctx, struct hash_table *) const;
1763
get_value()1764 ir_rvalue *get_value() const
1765 {
1766 return value;
1767 }
1768
accept(ir_visitor * v)1769 virtual void accept(ir_visitor *v)
1770 {
1771 v->visit(this);
1772 }
1773
1774 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1775
1776 ir_rvalue *value;
1777 };
1778
1779
1780 /**
1781 * Jump instructions used inside loops
1782 *
1783 * These include \c break and \c continue. The \c break within a loop is
1784 * different from the \c break within a switch-statement.
1785 *
1786 * \sa ir_switch_jump
1787 */
1788 class ir_loop_jump : public ir_jump {
1789 public:
1790 enum jump_mode {
1791 jump_break,
1792 jump_continue
1793 };
1794
ir_loop_jump(jump_mode mode)1795 ir_loop_jump(jump_mode mode)
1796 : ir_jump(ir_type_loop_jump)
1797 {
1798 this->mode = mode;
1799 }
1800
1801 virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const;
1802
accept(ir_visitor * v)1803 virtual void accept(ir_visitor *v)
1804 {
1805 v->visit(this);
1806 }
1807
1808 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1809
is_break()1810 bool is_break() const
1811 {
1812 return mode == jump_break;
1813 }
1814
is_continue()1815 bool is_continue() const
1816 {
1817 return mode == jump_continue;
1818 }
1819
1820 /** Mode selector for the jump instruction. */
1821 enum jump_mode mode;
1822 };
1823
1824 /**
1825 * IR instruction representing discard statements.
1826 */
1827 class ir_discard : public ir_jump {
1828 public:
ir_discard()1829 ir_discard()
1830 : ir_jump(ir_type_discard)
1831 {
1832 this->condition = NULL;
1833 }
1834
ir_discard(ir_rvalue * cond)1835 ir_discard(ir_rvalue *cond)
1836 : ir_jump(ir_type_discard)
1837 {
1838 this->condition = cond;
1839 }
1840
1841 virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const;
1842
accept(ir_visitor * v)1843 virtual void accept(ir_visitor *v)
1844 {
1845 v->visit(this);
1846 }
1847
1848 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1849
1850 ir_rvalue *condition;
1851 };
1852 /*@}*/
1853
1854
1855 /**
1856 * Texture sampling opcodes used in ir_texture
1857 */
1858 enum ir_texture_opcode {
1859 ir_tex, /**< Regular texture look-up */
1860 ir_txb, /**< Texture look-up with LOD bias */
1861 ir_txl, /**< Texture look-up with explicit LOD */
1862 ir_txd, /**< Texture look-up with partial derivatvies */
1863 ir_txf, /**< Texel fetch with explicit LOD */
1864 ir_txf_ms, /**< Multisample texture fetch */
1865 ir_txs, /**< Texture size */
1866 ir_lod, /**< Texture lod query */
1867 ir_tg4, /**< Texture gather */
1868 ir_query_levels /**< Texture levels query */
1869 };
1870
1871
1872 /**
1873 * IR instruction to sample a texture
1874 *
1875 * The specific form of the IR instruction depends on the \c mode value
1876 * selected from \c ir_texture_opcodes. In the printed IR, these will
1877 * appear as:
1878 *
1879 * Texel offset (0 or an expression)
1880 * |
1881 * v
1882 * (tex <type> <sampler> <coordinate> 0)
1883 * (txb <type> <sampler> <coordinate> 0 <bias>)
1884 * (txl <type> <sampler> <coordinate> 0 <lod>)
1885 * (txd <type> <sampler> <coordinate> 0 (dPdx dPdy))
1886 * (txf <type> <sampler> <coordinate> 0 <lod>)
1887 * (txf_ms
1888 * <type> <sampler> <coordinate> <sample_index>)
1889 * (txs <type> <sampler> <lod>)
1890 * (lod <type> <sampler> <coordinate>)
1891 * (tg4 <type> <sampler> <coordinate> <offset> <component>)
1892 * (query_levels <type> <sampler>)
1893 */
1894 class ir_texture : public ir_rvalue {
1895 public:
ir_texture(enum ir_texture_opcode op)1896 ir_texture(enum ir_texture_opcode op)
1897 : ir_rvalue(ir_type_texture, glsl_precision_low),
1898 op(op), sampler(NULL), coordinate(NULL),
1899 offset(NULL)
1900 {
1901 memset(&lod_info, 0, sizeof(lod_info));
1902 }
1903
1904 virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
1905
1906 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
1907
accept(ir_visitor * v)1908 virtual void accept(ir_visitor *v)
1909 {
1910 v->visit(this);
1911 }
1912
1913 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1914
1915 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
1916
1917 /**
1918 * Return a string representing the ir_texture_opcode.
1919 */
1920 const char *opcode_string();
1921
1922 /** Set the sampler and type. */
1923 void set_sampler(ir_dereference *sampler, const glsl_type *type);
1924
1925 static bool has_lod(const glsl_type *sampler_type);
1926
1927 /**
1928 * Do a reverse-lookup to translate a string into an ir_texture_opcode.
1929 */
1930 static ir_texture_opcode get_opcode(const char *);
1931
1932 enum ir_texture_opcode op;
1933
1934 /** Sampler to use for the texture access. */
1935 ir_dereference *sampler;
1936
1937 /** Texture coordinate to sample */
1938 ir_rvalue *coordinate;
1939
1940 /** Texel offset. */
1941 ir_rvalue *offset;
1942
1943 union {
1944 ir_rvalue *lod; /**< Floating point LOD */
1945 ir_rvalue *bias; /**< Floating point LOD bias */
1946 ir_rvalue *sample_index; /**< MSAA sample index */
1947 ir_rvalue *component; /**< Gather component selector */
1948 struct {
1949 ir_rvalue *dPdx; /**< Partial derivative of coordinate wrt X */
1950 ir_rvalue *dPdy; /**< Partial derivative of coordinate wrt Y */
1951 } grad;
1952 } lod_info;
1953 };
1954
1955
1956 struct ir_swizzle_mask {
1957 unsigned x:2;
1958 unsigned y:2;
1959 unsigned z:2;
1960 unsigned w:2;
1961
1962 /**
1963 * Number of components in the swizzle.
1964 */
1965 unsigned num_components:3;
1966
1967 /**
1968 * Does the swizzle contain duplicate components?
1969 *
1970 * L-value swizzles cannot contain duplicate components.
1971 */
1972 unsigned has_duplicates:1;
1973 };
1974
1975
1976 class ir_swizzle : public ir_rvalue {
1977 public:
1978 ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
1979 unsigned count);
1980
1981 ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count);
1982
1983 ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);
1984
1985 virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
1986
1987 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
1988
1989 /**
1990 * Construct an ir_swizzle from the textual representation. Can fail.
1991 */
1992 static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
1993
accept(ir_visitor * v)1994 virtual void accept(ir_visitor *v)
1995 {
1996 v->visit(this);
1997 }
1998
1999 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2000
2001 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
2002
is_lvalue()2003 bool is_lvalue() const
2004 {
2005 return val->is_lvalue() && !mask.has_duplicates;
2006 }
2007
2008 /**
2009 * Get the variable that is ultimately referenced by an r-value
2010 */
2011 virtual ir_variable *variable_referenced() const;
2012
2013 ir_rvalue *val;
2014 ir_swizzle_mask mask;
2015
2016 private:
2017 /**
2018 * Initialize the mask component of a swizzle
2019 *
2020 * This is used by the \c ir_swizzle constructors.
2021 */
2022 void init_mask(const unsigned *components, unsigned count);
2023 };
2024
2025
2026 class ir_dereference : public ir_rvalue {
2027 public:
2028 virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;
2029
2030 bool is_lvalue() const;
2031
2032 /**
2033 * Get the variable that is ultimately referenced by an r-value
2034 */
2035 virtual ir_variable *variable_referenced() const = 0;
2036
2037 protected:
ir_dereference(ir_node_type t,glsl_precision precision)2038 ir_dereference(ir_node_type t, glsl_precision precision) : ir_rvalue(t, precision) { }
2039 };
2040
2041
2042 class ir_dereference_variable : public ir_dereference {
2043 public:
2044 ir_dereference_variable(ir_variable *var);
2045
2046 virtual ir_dereference_variable *clone(void *mem_ctx,
2047 struct hash_table *) const;
2048
2049 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
2050
2051 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
2052
2053 /**
2054 * Get the variable that is ultimately referenced by an r-value
2055 */
variable_referenced()2056 virtual ir_variable *variable_referenced() const
2057 {
2058 return this->var;
2059 }
2060
whole_variable_referenced()2061 virtual ir_variable *whole_variable_referenced()
2062 {
2063 /* ir_dereference_variable objects always dereference the entire
2064 * variable. However, if this dereference is dereferenced by anything
2065 * else, the complete deferefernce chain is not a whole-variable
2066 * dereference. This method should only be called on the top most
2067 * ir_rvalue in a dereference chain.
2068 */
2069 return this->var;
2070 }
2071
accept(ir_visitor * v)2072 virtual void accept(ir_visitor *v)
2073 {
2074 v->visit(this);
2075 }
2076
2077 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2078
2079 /**
2080 * Object being dereferenced.
2081 */
2082 ir_variable *var;
2083 };
2084
2085
2086 class ir_dereference_array : public ir_dereference {
2087 public:
2088 ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index);
2089
2090 ir_dereference_array(ir_variable *var, ir_rvalue *array_index);
2091
2092 virtual ir_dereference_array *clone(void *mem_ctx,
2093 struct hash_table *) const;
2094
2095 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
2096
2097 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
2098
2099 /**
2100 * Get the variable that is ultimately referenced by an r-value
2101 */
variable_referenced()2102 virtual ir_variable *variable_referenced() const
2103 {
2104 return this->array->variable_referenced();
2105 }
2106
accept(ir_visitor * v)2107 virtual void accept(ir_visitor *v)
2108 {
2109 v->visit(this);
2110 }
2111
2112 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2113
2114 ir_rvalue *array;
2115 ir_rvalue *array_index;
2116
2117 private:
2118 void set_array(ir_rvalue *value);
2119 };
2120
2121
2122 class ir_dereference_record : public ir_dereference {
2123 public:
2124 ir_dereference_record(ir_rvalue *value, const char *field);
2125
2126 ir_dereference_record(ir_variable *var, const char *field);
2127
2128 virtual ir_dereference_record *clone(void *mem_ctx,
2129 struct hash_table *) const;
2130
2131 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
2132
2133 /**
2134 * Get the variable that is ultimately referenced by an r-value
2135 */
variable_referenced()2136 virtual ir_variable *variable_referenced() const
2137 {
2138 return this->record->variable_referenced();
2139 }
2140
accept(ir_visitor * v)2141 virtual void accept(ir_visitor *v)
2142 {
2143 v->visit(this);
2144 }
2145
2146 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2147
2148 ir_rvalue *record;
2149 const char *field;
2150 };
2151
2152
2153 /**
2154 * Data stored in an ir_constant
2155 */
2156 union ir_constant_data {
2157 unsigned u[16];
2158 int i[16];
2159 float f[16];
2160 bool b[16];
2161 };
2162
2163
2164 class ir_constant : public ir_rvalue {
2165 public:
2166 ir_constant(const struct glsl_type *type, const ir_constant_data *data, glsl_precision precision = glsl_precision_undefined);
2167 ir_constant(bool b, unsigned vector_elements=1);
2168 ir_constant(unsigned int u, unsigned vector_elements=1);
2169 ir_constant(int i, unsigned vector_elements=1);
2170 ir_constant(float f, unsigned vector_elements=1);
2171
2172 /**
2173 * Construct an ir_constant from a list of ir_constant values
2174 */
2175 ir_constant(const struct glsl_type *type, exec_list *values);
2176
2177 /**
2178 * Construct an ir_constant from a scalar component of another ir_constant
2179 *
2180 * The new \c ir_constant inherits the type of the component from the
2181 * source constant.
2182 *
2183 * \note
2184 * In the case of a matrix constant, the new constant is a scalar, \b not
2185 * a vector.
2186 */
2187 ir_constant(const ir_constant *c, unsigned i);
2188
2189 /**
2190 * Return a new ir_constant of the specified type containing all zeros.
2191 */
2192 static ir_constant *zero(void *mem_ctx, const glsl_type *type);
2193
2194 virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
2195
2196 virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);
2197
accept(ir_visitor * v)2198 virtual void accept(ir_visitor *v)
2199 {
2200 v->visit(this);
2201 }
2202
2203 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2204
2205 virtual bool equals(ir_instruction *ir, enum ir_node_type ignore = ir_type_unset);
2206
2207 /**
2208 * Get a particular component of a constant as a specific type
2209 *
2210 * This is useful, for example, to get a value from an integer constant
2211 * as a float or bool. This appears frequently when constructors are
2212 * called with all constant parameters.
2213 */
2214 /*@{*/
2215 bool get_bool_component(unsigned i) const;
2216 float get_float_component(unsigned i) const;
2217 int get_int_component(unsigned i) const;
2218 unsigned get_uint_component(unsigned i) const;
2219 /*@}*/
2220
2221 ir_constant *get_array_element(unsigned i) const;
2222
2223 ir_constant *get_record_field(const char *name);
2224
2225 /**
2226 * Copy the values on another constant at a given offset.
2227 *
2228 * The offset is ignored for array or struct copies, it's only for
2229 * scalars or vectors into vectors or matrices.
2230 *
2231 * With identical types on both sides and zero offset it's clone()
2232 * without creating a new object.
2233 */
2234
2235 void copy_offset(ir_constant *src, int offset);
2236
2237 /**
2238 * Copy the values on another constant at a given offset and
2239 * following an assign-like mask.
2240 *
2241 * The mask is ignored for scalars.
2242 *
2243 * Note that this function only handles what assign can handle,
2244 * i.e. at most a vector as source and a column of a matrix as
2245 * destination.
2246 */
2247
2248 void copy_masked_offset(ir_constant *src, int offset, unsigned int mask);
2249
2250 /**
2251 * Determine whether a constant has the same value as another constant
2252 *
2253 * \sa ir_constant::is_zero, ir_constant::is_one,
2254 * ir_constant::is_negative_one, ir_constant::is_basis
2255 */
2256 bool has_value(const ir_constant *) const;
2257
2258 /**
2259 * Return true if this ir_constant represents the given value.
2260 *
2261 * For vectors, this checks that each component is the given value.
2262 */
2263 virtual bool is_value(float f, int i) const;
2264 virtual bool is_zero() const;
2265 virtual bool is_one() const;
2266 virtual bool is_negative_one() const;
2267 virtual bool is_basis() const;
2268
2269 /**
2270 * Return true for constants that could be stored as 16-bit unsigned values.
2271 *
2272 * Note that this will return true even for signed integer ir_constants, as
2273 * long as the value is non-negative and fits in 16-bits.
2274 */
2275 virtual bool is_uint16_constant() const;
2276
2277 /**
2278 * Value of the constant.
2279 *
2280 * The field used to back the values supplied by the constant is determined
2281 * by the type associated with the \c ir_instruction. Constants may be
2282 * scalars, vectors, or matrices.
2283 */
2284 union ir_constant_data value;
2285
2286 /* Array elements */
2287 ir_constant **array_elements;
2288
2289 /* Structure fields */
2290 exec_list components;
2291
2292 private:
2293 /**
2294 * Parameterless constructor only used by the clone method
2295 */
2296 ir_constant(void);
2297 };
2298
2299
2300 class ir_precision_statement : public ir_instruction {
2301 public:
ir_precision_statement(const char * statement_to_store)2302 ir_precision_statement(const char *statement_to_store)
2303 : ir_instruction(ir_type_precision)
2304 {
2305 ir_type = ir_type_precision;
2306 precision_statement = statement_to_store;
2307 }
2308
2309 virtual ir_precision_statement *clone(void *mem_ctx, struct hash_table *) const;
2310
accept(ir_visitor * v)2311 virtual void accept(ir_visitor *v)
2312 {
2313 v->visit(this);
2314 }
2315
2316 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2317
2318 /**
2319 * Precision statement
2320 */
2321 const char *precision_statement;
2322 };
2323
2324
2325 class ir_typedecl_statement : public ir_instruction {
2326 public:
ir_typedecl_statement(const glsl_type * type_decl)2327 ir_typedecl_statement(const glsl_type* type_decl)
2328 : ir_instruction(ir_type_typedecl)
2329 {
2330 this->ir_type = ir_type_typedecl;
2331 this->type_decl = type_decl;
2332 }
2333
2334 virtual ir_typedecl_statement *clone(void *mem_ctx, struct hash_table *) const;
2335
accept(ir_visitor * v)2336 virtual void accept(ir_visitor *v)
2337 {
2338 v->visit(this);
2339 }
2340
2341 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2342
2343 const glsl_type* type_decl;
2344 };
2345
2346
2347
2348 /**
2349 * IR instruction to emit a vertex in a geometry shader.
2350 */
2351 class ir_emit_vertex : public ir_instruction {
2352 public:
ir_emit_vertex(ir_rvalue * stream)2353 ir_emit_vertex(ir_rvalue *stream)
2354 : ir_instruction(ir_type_emit_vertex),
2355 stream(stream)
2356 {
2357 assert(stream);
2358 }
2359
accept(ir_visitor * v)2360 virtual void accept(ir_visitor *v)
2361 {
2362 v->visit(this);
2363 }
2364
clone(void * mem_ctx,struct hash_table * ht)2365 virtual ir_emit_vertex *clone(void *mem_ctx, struct hash_table *ht) const
2366 {
2367 return new(mem_ctx) ir_emit_vertex(this->stream->clone(mem_ctx, ht));
2368 }
2369
2370 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2371
stream_id()2372 int stream_id() const
2373 {
2374 return stream->as_constant()->value.i[0];
2375 }
2376
2377 ir_rvalue *stream;
2378 };
2379
2380 /**
2381 * IR instruction to complete the current primitive and start a new one in a
2382 * geometry shader.
2383 */
2384 class ir_end_primitive : public ir_instruction {
2385 public:
ir_end_primitive(ir_rvalue * stream)2386 ir_end_primitive(ir_rvalue *stream)
2387 : ir_instruction(ir_type_end_primitive),
2388 stream(stream)
2389 {
2390 assert(stream);
2391 }
2392
accept(ir_visitor * v)2393 virtual void accept(ir_visitor *v)
2394 {
2395 v->visit(this);
2396 }
2397
clone(void * mem_ctx,struct hash_table * ht)2398 virtual ir_end_primitive *clone(void *mem_ctx, struct hash_table *ht) const
2399 {
2400 return new(mem_ctx) ir_end_primitive(this->stream->clone(mem_ctx, ht));
2401 }
2402
2403 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2404
stream_id()2405 int stream_id() const
2406 {
2407 return stream->as_constant()->value.i[0];
2408 }
2409
2410 ir_rvalue *stream;
2411 };
2412
2413 /*@}*/
2414
2415 /**
2416 * Apply a visitor to each IR node in a list
2417 */
2418 void
2419 visit_exec_list(exec_list *list, ir_visitor *visitor);
2420
2421 /**
2422 * Validate invariants on each IR node in a list
2423 */
2424 void validate_ir_tree(exec_list *instructions);
2425
2426 struct _mesa_glsl_parse_state;
2427 struct gl_shader_program;
2428
2429 /**
2430 * Detect whether an unlinked shader contains static recursion
2431 *
2432 * If the list of instructions is determined to contain static recursion,
2433 * \c _mesa_glsl_error will be called to emit error messages for each function
2434 * that is in the recursion cycle.
2435 */
2436 void
2437 detect_recursion_unlinked(struct _mesa_glsl_parse_state *state,
2438 exec_list *instructions);
2439
2440 /**
2441 * Detect whether a linked shader contains static recursion
2442 *
2443 * If the list of instructions is determined to contain static recursion,
2444 * \c link_error_printf will be called to emit error messages for each function
2445 * that is in the recursion cycle. In addition,
2446 * \c gl_shader_program::LinkStatus will be set to false.
2447 */
2448 void
2449 detect_recursion_linked(struct gl_shader_program *prog,
2450 exec_list *instructions);
2451
2452 /**
2453 * Make a clone of each IR instruction in a list
2454 *
2455 * \param in List of IR instructions that are to be cloned
2456 * \param out List to hold the cloned instructions
2457 */
2458 void
2459 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);
2460
2461 extern void
2462 _mesa_glsl_initialize_variables(exec_list *instructions,
2463 struct _mesa_glsl_parse_state *state);
2464
2465 extern void
2466 _mesa_glsl_initialize_builtin_functions();
2467
2468 extern ir_function_signature *
2469 _mesa_glsl_find_builtin_function(_mesa_glsl_parse_state *state,
2470 const char *name, exec_list *actual_parameters);
2471
2472 extern gl_shader *
2473 _mesa_glsl_get_builtin_function_shader(void);
2474
2475 extern void
2476 _mesa_glsl_release_builtin_functions(void);
2477
2478 extern void
2479 reparent_ir(exec_list *list, void *mem_ctx);
2480
2481 struct glsl_symbol_table;
2482
2483 extern void
2484 import_prototypes(const exec_list *source, exec_list *dest,
2485 struct glsl_symbol_table *symbols, void *mem_ctx);
2486
2487 extern void
2488 do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
2489 gl_shader_stage shader_stage);
2490
2491 extern glsl_precision
2492 precision_from_ir (ir_instruction* ir);
2493
2494
2495 extern glsl_precision higher_precision (ir_instruction* a, ir_instruction* b);
higher_precision(glsl_precision a,glsl_precision b)2496 static inline glsl_precision higher_precision (glsl_precision a, glsl_precision b)
2497 {
2498 return MIN2 (a, b);
2499 }
2500
2501 extern char *
2502 prototype_string(const glsl_type *return_type, const char *name,
2503 exec_list *parameters);
2504
2505 const char *
2506 mode_string(const ir_variable *var);
2507
2508 /**
2509 * Built-in / reserved GL variables names start with "gl_"
2510 */
2511 static inline bool
is_gl_identifier(const char * s)2512 is_gl_identifier(const char *s)
2513 {
2514 return s && s[0] == 'g' && s[1] == 'l' && s[2] == '_';
2515 }
2516
2517 extern "C" {
2518 #endif /* __cplusplus */
2519
2520 extern void _mesa_print_ir(FILE *f, struct exec_list *instructions,
2521 struct _mesa_glsl_parse_state *state);
2522
2523 extern void
2524 fprint_ir(FILE *f, const void *instruction);
2525
2526 #ifdef __cplusplus
2527 } /* extern "C" */
2528 #endif
2529
2530 unsigned
2531 vertices_per_prim(GLenum prim);
2532
2533 #endif /* IR_H */
2534