3 * Copyright © 2010 Intel Corporation
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:
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
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.
33 #include "glsl_types.h"
35 #include "ir_visitor.h"
36 #include "ir_hierarchical_visitor.h"
37 #include "main/mtypes.h"
40 * \defgroup IR Intermediate representation nodes
48 * Each concrete class derived from \c ir_instruction has a value in this
49 * enumerant. The value for the type is stored in \c ir_instruction::ir_type
50 * by the constructor. While using type tags is not very C++, it is extremely
51 * convenient. For example, during debugging you can simply inspect
52 * \c ir_instruction::ir_type to find out the actual type of the object.
54 * In addition, it is possible to use a switch-statement based on \c
55 * \c ir_instruction::ir_type to select different behavior for different object
56 * types. For functions that have only slight differences for several object
57 * types, this allows writing very straightforward, readable code.
61 * Zero is unused so that the IR validator can detect cases where
62 * \c ir_instruction::ir_type has not been initialized.
69 ir_type_dereference_array,
70 ir_type_dereference_record,
71 ir_type_dereference_variable,
75 ir_type_function_signature,
82 ir_type_max /**< maximum ir_type enum number, for validation */
86 * Base class of all IR instructions
88 class ir_instruction : public exec_node {
90 enum ir_node_type ir_type;
92 /** ir_print_visitor helper for debugging. */
93 void print(void) const;
95 virtual void accept(ir_visitor *) = 0;
96 virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0;
97 virtual ir_instruction *clone(void *mem_ctx,
98 struct hash_table *ht) const = 0;
101 * \name IR instruction downcast functions
103 * These functions either cast the object to a derived class or return
104 * \c NULL if the object's type does not match the specified derived class.
105 * Additional downcast functions will be added as needed.
108 virtual class ir_variable * as_variable() { return NULL; }
109 virtual class ir_function * as_function() { return NULL; }
110 virtual class ir_dereference * as_dereference() { return NULL; }
111 virtual class ir_dereference_array * as_dereference_array() { return NULL; }
112 virtual class ir_dereference_variable *as_dereference_variable() { return NULL; }
113 virtual class ir_expression * as_expression() { return NULL; }
114 virtual class ir_rvalue * as_rvalue() { return NULL; }
115 virtual class ir_loop * as_loop() { return NULL; }
116 virtual class ir_assignment * as_assignment() { return NULL; }
117 virtual class ir_call * as_call() { return NULL; }
118 virtual class ir_return * as_return() { return NULL; }
119 virtual class ir_if * as_if() { return NULL; }
120 virtual class ir_swizzle * as_swizzle() { return NULL; }
121 virtual class ir_constant * as_constant() { return NULL; }
122 virtual class ir_discard * as_discard() { return NULL; }
128 ir_type = ir_type_unset;
134 * The base class for all "values"/expression trees.
136 class ir_rvalue : public ir_instruction {
138 const struct glsl_type *type;
140 virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const;
142 virtual void accept(ir_visitor *v)
147 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
149 virtual ir_constant *constant_expression_value();
151 virtual ir_rvalue * as_rvalue()
156 ir_rvalue *as_rvalue_to_saturate();
158 virtual bool is_lvalue() const
164 * Get the variable that is ultimately referenced by an r-value
166 virtual ir_variable *variable_referenced() const
173 * If an r-value is a reference to a whole variable, get that variable
176 * Pointer to a variable that is completely dereferenced by the r-value. If
177 * the r-value is not a dereference or the dereference does not access the
178 * entire variable (i.e., it's just one array element, struct field), \c NULL
181 virtual ir_variable *whole_variable_referenced()
187 * Determine if an r-value has the value zero
189 * The base implementation of this function always returns \c false. The
190 * \c ir_constant class over-rides this function to return \c true \b only
191 * for vector and scalar types that have all elements set to the value
192 * zero (or \c false for booleans).
194 * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one
196 virtual bool is_zero() const;
199 * Determine if an r-value has the value one
201 * The base implementation of this function always returns \c false. The
202 * \c ir_constant class over-rides this function to return \c true \b only
203 * for vector and scalar types that have all elements set to the value
204 * one (or \c true for booleans).
206 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one
208 virtual bool is_one() const;
211 * Determine if an r-value has the value negative one
213 * The base implementation of this function always returns \c false. The
214 * \c ir_constant class over-rides this function to return \c true \b only
215 * for vector and scalar types that have all elements set to the value
216 * negative one. For boolean times, the result is always \c false.
218 * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one
220 virtual bool is_negative_one() const;
224 * Return a generic value of error_type.
226 * Allocation will be performed with 'mem_ctx' as ralloc owner.
228 static ir_rvalue *error_value(void *mem_ctx);
236 * Variable storage classes
238 enum ir_variable_mode {
239 ir_var_auto = 0, /**< Function local variables and globals. */
240 ir_var_uniform, /**< Variable declared as a uniform. */
244 ir_var_const_in, /**< "in" param that must be a constant expression */
245 ir_var_system_value, /**< Ex: front-face, instance-id, etc. */
246 ir_var_temporary /**< Temporary variable generated during compilation. */
250 * \brief Layout qualifiers for gl_FragDepth.
252 * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared
253 * with a layout qualifier.
255 enum ir_depth_layout {
256 ir_depth_layout_none, /**< No depth layout is specified. */
258 ir_depth_layout_greater,
259 ir_depth_layout_less,
260 ir_depth_layout_unchanged
264 * \brief Convert depth layout qualifier to string.
267 depth_layout_string(ir_depth_layout layout);
270 * Description of built-in state associated with a uniform
272 * \sa ir_variable::state_slots
274 struct ir_state_slot {
279 class ir_variable : public ir_instruction {
281 ir_variable(const struct glsl_type *, const char *, ir_variable_mode);
283 virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const;
285 virtual ir_variable *as_variable()
290 virtual void accept(ir_visitor *v)
295 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
299 * Get the string value for the interpolation qualifier
301 * \return The string that would be used in a shader to specify \c
302 * mode will be returned.
304 * This function is used to generate error messages of the form "shader
305 * uses %s interpolation qualifier", so in the case where there is no
306 * interpolation qualifier, it returns "no".
308 * This function should only be used on a shader input or output variable.
310 const char *interpolation_string() const;
313 * Determine how this variable should be interpolated based on its
314 * interpolation qualifier (if present), whether it is gl_Color or
315 * gl_SecondaryColor, and whether flatshading is enabled in the current GL
318 * The return value will always be either INTERP_QUALIFIER_SMOOTH,
319 * INTERP_QUALIFIER_NOPERSPECTIVE, or INTERP_QUALIFIER_FLAT.
321 glsl_interp_qualifier determine_interpolation_mode(bool flat_shade);
324 * Declared type of the variable
326 const struct glsl_type *type;
329 * Delcared name of the variable
334 * Highest element accessed with a constant expression array index
336 * Not used for non-array variables.
338 unsigned max_array_access;
341 * Is the variable read-only?
343 * This is set for variables declared as \c const, shader inputs,
346 unsigned read_only:1;
348 unsigned invariant:1;
351 * Has this variable been used for reading or writing?
353 * Several GLSL semantic checks require knowledge of whether or not a
354 * variable has been used. For example, it is an error to redeclare a
355 * variable as invariant after it has been used.
360 * Storage class of the variable.
362 * \sa ir_variable_mode
367 * Interpolation mode for shader inputs / outputs
369 * \sa ir_variable_interpolation
371 unsigned interpolation:2;
374 * \name ARB_fragment_coord_conventions
377 unsigned origin_upper_left:1;
378 unsigned pixel_center_integer:1;
382 * Was the location explicitly set in the shader?
384 * If the location is explicitly set in the shader, it \b cannot be changed
385 * by the linker or by the API (e.g., calls to \c glBindAttribLocation have
388 unsigned explicit_location:1;
391 * Does this variable have an initializer?
393 * This is used by the linker to cross-validiate initializers of global
396 unsigned has_initializer:1;
399 * \brief Layout qualifier for gl_FragDepth.
401 * This is not equal to \c ir_depth_layout_none if and only if this
402 * variable is \c gl_FragDepth and a layout qualifier is specified.
404 ir_depth_layout depth_layout;
407 * Storage location of the base of this variable
409 * The precise meaning of this field depends on the nature of the variable.
411 * - Vertex shader input: one of the values from \c gl_vert_attrib.
412 * - Vertex shader output: one of the values from \c gl_vert_result.
413 * - Fragment shader input: one of the values from \c gl_frag_attrib.
414 * - Fragment shader output: one of the values from \c gl_frag_result.
415 * - Uniforms: Per-stage uniform slot number.
416 * - Other: This field is not currently used.
418 * If the variable is a uniform, shader input, or shader output, and the
419 * slot has not been assigned, the value will be -1.
424 * output index for dual source blending.
429 * Built-in state that backs this uniform
431 * Once set at variable creation, \c state_slots must remain invariant.
432 * This is because, ideally, this array would be shared by all clones of
433 * this variable in the IR tree. In other words, we'd really like for it
434 * to be a fly-weight.
436 * If the variable is not a uniform, \c num_state_slots will be zero and
437 * \c state_slots will be \c NULL.
440 unsigned num_state_slots; /**< Number of state slots used */
441 ir_state_slot *state_slots; /**< State descriptors. */
445 * Emit a warning if this variable is accessed.
447 const char *warn_extension;
450 * Value assigned in the initializer of a variable declared "const"
452 ir_constant *constant_value;
455 * Constant expression assigned in the initializer of the variable
458 * This field and \c ::constant_value are distinct. Even if the two fields
459 * refer to constants with the same value, they must point to separate
462 ir_constant *constant_initializer;
468 * The representation of a function instance; may be the full definition or
469 * simply a prototype.
471 class ir_function_signature : public ir_instruction {
472 /* An ir_function_signature will be part of the list of signatures in
476 ir_function_signature(const glsl_type *return_type);
478 virtual ir_function_signature *clone(void *mem_ctx,
479 struct hash_table *ht) const;
480 ir_function_signature *clone_prototype(void *mem_ctx,
481 struct hash_table *ht) const;
483 virtual void accept(ir_visitor *v)
488 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
491 * Attempt to evaluate this function as a constant expression, given
492 * a list of the actual parameters. Returns NULL for non-built-ins.
494 ir_constant *constant_expression_value(exec_list *actual_parameters);
497 * Get the name of the function for which this is a signature
499 const char *function_name() const;
502 * Get a handle to the function for which this is a signature
504 * There is no setter function, this function returns a \c const pointer,
505 * and \c ir_function_signature::_function is private for a reason. The
506 * only way to make a connection between a function and function signature
507 * is via \c ir_function::add_signature. This helps ensure that certain
508 * invariants (i.e., a function signature is in the list of signatures for
509 * its \c _function) are met.
511 * \sa ir_function::add_signature
513 inline const class ir_function *function() const
515 return this->_function;
519 * Check whether the qualifiers match between this signature's parameters
520 * and the supplied parameter list. If not, returns the name of the first
521 * parameter with mismatched qualifiers (for use in error messages).
523 const char *qualifiers_match(exec_list *params);
526 * Replace the current parameter list with the given one. This is useful
527 * if the current information came from a prototype, and either has invalid
528 * or missing parameter names.
530 void replace_parameters(exec_list *new_params);
533 * Function return type.
535 * \note This discards the optional precision qualifier.
537 const struct glsl_type *return_type;
540 * List of ir_variable of function parameters.
542 * This represents the storage. The paramaters passed in a particular
543 * call will be in ir_call::actual_paramaters.
545 struct exec_list parameters;
547 /** Whether or not this function has a body (which may be empty). */
548 unsigned is_defined:1;
550 /** Whether or not this function signature is a built-in. */
551 unsigned is_builtin:1;
553 /** Body of instructions in the function. */
554 struct exec_list body;
557 /** Function of which this signature is one overload. */
558 class ir_function *_function;
560 friend class ir_function;
565 * Header for tracking multiple overloaded functions with the same name.
566 * Contains a list of ir_function_signatures representing each of the
569 class ir_function : public ir_instruction {
571 ir_function(const char *name);
573 virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;
575 virtual ir_function *as_function()
580 virtual void accept(ir_visitor *v)
585 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
587 void add_signature(ir_function_signature *sig)
589 sig->_function = this;
590 this->signatures.push_tail(sig);
594 * Get an iterator for the set of function signatures
596 exec_list_iterator iterator()
598 return signatures.iterator();
602 * Find a signature that matches a set of actual parameters, taking implicit
603 * conversions into account. Also flags whether the match was exact.
605 ir_function_signature *matching_signature(const exec_list *actual_param,
606 bool *match_is_exact);
609 * Find a signature that matches a set of actual parameters, taking implicit
610 * conversions into account.
612 ir_function_signature *matching_signature(const exec_list *actual_param);
615 * Find a signature that exactly matches a set of actual parameters without
616 * any implicit type conversions.
618 ir_function_signature *exact_matching_signature(const exec_list *actual_ps);
621 * Name of the function.
625 /** Whether or not this function has a signature that isn't a built-in. */
626 bool has_user_signature();
629 * List of ir_function_signature for each overloaded function with this name.
631 struct exec_list signatures;
634 inline const char *ir_function_signature::function_name() const
636 return this->_function->name;
642 * IR instruction representing high-level if-statements
644 class ir_if : public ir_instruction {
646 ir_if(ir_rvalue *condition)
647 : condition(condition)
649 ir_type = ir_type_if;
652 virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;
654 virtual ir_if *as_if()
659 virtual void accept(ir_visitor *v)
664 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
666 ir_rvalue *condition;
667 /** List of ir_instruction for the body of the then branch */
668 exec_list then_instructions;
669 /** List of ir_instruction for the body of the else branch */
670 exec_list else_instructions;
675 * IR instruction representing a high-level loop structure.
677 class ir_loop : public ir_instruction {
681 virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;
683 virtual void accept(ir_visitor *v)
688 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
690 virtual ir_loop *as_loop()
696 * Get an iterator for the instructions of the loop body
698 exec_list_iterator iterator()
700 return body_instructions.iterator();
703 /** List of ir_instruction that make up the body of the loop. */
704 exec_list body_instructions;
707 * \name Loop counter and controls
709 * Represents a loop like a FORTRAN \c do-loop.
712 * If \c from and \c to are the same value, the loop will execute once.
715 ir_rvalue *from; /** Value of the loop counter on the first
716 * iteration of the loop.
718 ir_rvalue *to; /** Value of the loop counter on the last
719 * iteration of the loop.
721 ir_rvalue *increment;
722 ir_variable *counter;
725 * Comparison operation in the loop terminator.
727 * If any of the loop control fields are non-\c NULL, this field must be
728 * one of \c ir_binop_less, \c ir_binop_greater, \c ir_binop_lequal,
729 * \c ir_binop_gequal, \c ir_binop_equal, or \c ir_binop_nequal.
736 class ir_assignment : public ir_instruction {
738 ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL);
741 * Construct an assignment with an explicit write mask
744 * Since a write mask is supplied, the LHS must already be a bare
745 * \c ir_dereference. The cannot be any swizzles in the LHS.
747 ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition,
748 unsigned write_mask);
750 virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
752 virtual ir_constant *constant_expression_value();
754 virtual void accept(ir_visitor *v)
759 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
761 virtual ir_assignment * as_assignment()
767 * Get a whole variable written by an assignment
769 * If the LHS of the assignment writes a whole variable, the variable is
770 * returned. Otherwise \c NULL is returned. Examples of whole-variable
773 * - Assigning to a scalar
774 * - Assigning to all components of a vector
775 * - Whole array (or matrix) assignment
776 * - Whole structure assignment
778 ir_variable *whole_variable_written();
781 * Set the LHS of an assignment
783 void set_lhs(ir_rvalue *lhs);
786 * Left-hand side of the assignment.
788 * This should be treated as read only. If you need to set the LHS of an
789 * assignment, use \c ir_assignment::set_lhs.
794 * Value being assigned
799 * Optional condition for the assignment.
801 ir_rvalue *condition;
805 * Component mask written
807 * For non-vector types in the LHS, this field will be zero. For vector
808 * types, a bit will be set for each component that is written. Note that
809 * for \c vec2 and \c vec3 types only the lower bits will ever be set.
811 * A partially-set write mask means that each enabled channel gets
812 * the value from a consecutive channel of the rhs. For example,
813 * to write just .xyw of gl_FrontColor with color:
815 * (assign (constant bool (1)) (xyw)
816 * (var_ref gl_FragColor)
817 * (swiz xyw (var_ref color)))
819 unsigned write_mask:4;
822 /* Update ir_expression::num_operands() and operator_strs when
823 * updating this list.
825 enum ir_expression_operation {
834 ir_unop_exp, /**< Log base e on gentype */
835 ir_unop_log, /**< Natural log on gentype */
838 ir_unop_f2i, /**< Float-to-integer conversion. */
839 ir_unop_i2f, /**< Integer-to-float conversion. */
840 ir_unop_f2b, /**< Float-to-boolean conversion */
841 ir_unop_b2f, /**< Boolean-to-float conversion */
842 ir_unop_i2b, /**< int-to-boolean conversion */
843 ir_unop_b2i, /**< Boolean-to-int conversion */
844 ir_unop_u2f, /**< Unsigned-to-float conversion. */
845 ir_unop_i2u, /**< Integer-to-unsigned conversion. */
846 ir_unop_u2i, /**< Unsigned-to-integer conversion. */
850 * \name Unary floating-point rounding operations.
861 * \name Trigonometric operations.
866 ir_unop_sin_reduced, /**< Reduced range sin. [-pi, pi] */
867 ir_unop_cos_reduced, /**< Reduced range cos. [-pi, pi] */
871 * \name Partial derivatives.
881 * A sentinel marking the last of the unary operations.
883 ir_last_unop = ir_unop_noise,
891 * Takes one of two combinations of arguments:
896 * Does not take integer types.
901 * \name Binary comparison operators which return a boolean vector.
902 * The type of both operands must be equal.
912 * Returns single boolean for whether all components of operands[0]
913 * equal the components of operands[1].
917 * Returns single boolean for whether any component of operands[0]
918 * is not equal to the corresponding component of operands[1].
924 * \name Bit-wise binary operations.
945 * A sentinel marking the last of the binary operations.
947 ir_last_binop = ir_binop_pow,
952 * A sentinel marking the last of all operations.
954 ir_last_opcode = ir_last_binop
957 class ir_expression : public ir_rvalue {
960 * Constructor for unary operation expressions
962 ir_expression(int op, const struct glsl_type *type, ir_rvalue *);
963 ir_expression(int op, ir_rvalue *);
966 * Constructor for binary operation expressions
968 ir_expression(int op, const struct glsl_type *type,
969 ir_rvalue *, ir_rvalue *);
970 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1);
973 * Constructor for quad operator expressions
975 ir_expression(int op, const struct glsl_type *type,
976 ir_rvalue *, ir_rvalue *, ir_rvalue *, ir_rvalue *);
978 virtual ir_expression *as_expression()
983 virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const;
986 * Attempt to constant-fold the expression
988 * If the expression cannot be constant folded, this method will return
991 virtual ir_constant *constant_expression_value();
994 * Determine the number of operands used by an expression
996 static unsigned int get_num_operands(ir_expression_operation);
999 * Determine the number of operands used by an expression
1001 unsigned int get_num_operands() const
1003 return (this->operation == ir_quadop_vector)
1004 ? this->type->vector_elements : get_num_operands(operation);
1008 * Return a string representing this expression's operator.
1010 const char *operator_string();
1013 * Return a string representing this expression's operator.
1015 static const char *operator_string(ir_expression_operation);
1019 * Do a reverse-lookup to translate the given string into an operator.
1021 static ir_expression_operation get_operator(const char *);
1023 virtual void accept(ir_visitor *v)
1028 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1030 ir_expression_operation operation;
1031 ir_rvalue *operands[4];
1036 * HIR instruction representing a high-level function call, containing a list
1037 * of parameters and returning a value in the supplied temporary.
1039 class ir_call : public ir_instruction {
1041 ir_call(ir_function_signature *callee,
1042 ir_dereference_variable *return_deref,
1043 exec_list *actual_parameters)
1044 : return_deref(return_deref), callee(callee)
1046 ir_type = ir_type_call;
1047 assert(callee->return_type != NULL);
1048 actual_parameters->move_nodes_to(& this->actual_parameters);
1049 this->use_builtin = callee->is_builtin;
1052 virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
1054 virtual ir_constant *constant_expression_value();
1056 virtual ir_call *as_call()
1061 virtual void accept(ir_visitor *v)
1066 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1069 * Get an iterator for the set of acutal parameters
1071 exec_list_iterator iterator()
1073 return actual_parameters.iterator();
1077 * Get the name of the function being called.
1079 const char *callee_name() const
1081 return callee->function_name();
1085 * Generates an inline version of the function before @ir,
1086 * storing the return value in return_deref.
1088 void generate_inline(ir_instruction *ir);
1091 * Storage for the function's return value.
1092 * This must be NULL if the return type is void.
1094 ir_dereference_variable *return_deref;
1097 * The specific function signature being called.
1099 ir_function_signature *callee;
1101 /* List of ir_rvalue of paramaters passed in this call. */
1102 exec_list actual_parameters;
1104 /** Should this call only bind to a built-in function? */
1110 * \name Jump-like IR instructions.
1112 * These include \c break, \c continue, \c return, and \c discard.
1115 class ir_jump : public ir_instruction {
1119 ir_type = ir_type_unset;
1123 class ir_return : public ir_jump {
1128 this->ir_type = ir_type_return;
1131 ir_return(ir_rvalue *value)
1134 this->ir_type = ir_type_return;
1137 virtual ir_return *clone(void *mem_ctx, struct hash_table *) const;
1139 virtual ir_return *as_return()
1144 ir_rvalue *get_value() const
1149 virtual void accept(ir_visitor *v)
1154 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1161 * Jump instructions used inside loops
1163 * These include \c break and \c continue. The \c break within a loop is
1164 * different from the \c break within a switch-statement.
1166 * \sa ir_switch_jump
1168 class ir_loop_jump : public ir_jump {
1175 ir_loop_jump(jump_mode mode)
1177 this->ir_type = ir_type_loop_jump;
1182 virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const;
1184 virtual void accept(ir_visitor *v)
1189 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1191 bool is_break() const
1193 return mode == jump_break;
1196 bool is_continue() const
1198 return mode == jump_continue;
1201 /** Mode selector for the jump instruction. */
1202 enum jump_mode mode;
1204 /** Loop containing this break instruction. */
1209 * IR instruction representing discard statements.
1211 class ir_discard : public ir_jump {
1215 this->ir_type = ir_type_discard;
1216 this->condition = NULL;
1219 ir_discard(ir_rvalue *cond)
1221 this->ir_type = ir_type_discard;
1222 this->condition = cond;
1225 virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const;
1227 virtual void accept(ir_visitor *v)
1232 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1234 virtual ir_discard *as_discard()
1239 ir_rvalue *condition;
1245 * Texture sampling opcodes used in ir_texture
1247 enum ir_texture_opcode {
1248 ir_tex, /**< Regular texture look-up */
1249 ir_txb, /**< Texture look-up with LOD bias */
1250 ir_txl, /**< Texture look-up with explicit LOD */
1251 ir_txd, /**< Texture look-up with partial derivatvies */
1252 ir_txf, /**< Texel fetch with explicit LOD */
1253 ir_txs /**< Texture size */
1258 * IR instruction to sample a texture
1260 * The specific form of the IR instruction depends on the \c mode value
1261 * selected from \c ir_texture_opcodes. In the printed IR, these will
1264 * Texel offset (0 or an expression)
1265 * | Projection divisor
1266 * | | Shadow comparitor
1269 * (tex <type> <sampler> <coordinate> 0 1 ( ))
1270 * (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>)
1271 * (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>)
1272 * (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy))
1273 * (txf <type> <sampler> <coordinate> 0 <lod>)
1274 * (txs <type> <sampler> <lod>)
1276 class ir_texture : public ir_rvalue {
1278 ir_texture(enum ir_texture_opcode op)
1279 : op(op), projector(NULL), shadow_comparitor(NULL), offset(NULL)
1281 this->ir_type = ir_type_texture;
1284 virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
1286 virtual ir_constant *constant_expression_value();
1288 virtual void accept(ir_visitor *v)
1293 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1296 * Return a string representing the ir_texture_opcode.
1298 const char *opcode_string();
1300 /** Set the sampler and type. */
1301 void set_sampler(ir_dereference *sampler, const glsl_type *type);
1304 * Do a reverse-lookup to translate a string into an ir_texture_opcode.
1306 static ir_texture_opcode get_opcode(const char *);
1308 enum ir_texture_opcode op;
1310 /** Sampler to use for the texture access. */
1311 ir_dereference *sampler;
1313 /** Texture coordinate to sample */
1314 ir_rvalue *coordinate;
1317 * Value used for projective divide.
1319 * If there is no projective divide (the common case), this will be
1320 * \c NULL. Optimization passes should check for this to point to a constant
1321 * of 1.0 and replace that with \c NULL.
1323 ir_rvalue *projector;
1326 * Coordinate used for comparison on shadow look-ups.
1328 * If there is no shadow comparison, this will be \c NULL. For the
1329 * \c ir_txf opcode, this *must* be \c NULL.
1331 ir_rvalue *shadow_comparitor;
1333 /** Texel offset. */
1337 ir_rvalue *lod; /**< Floating point LOD */
1338 ir_rvalue *bias; /**< Floating point LOD bias */
1340 ir_rvalue *dPdx; /**< Partial derivative of coordinate wrt X */
1341 ir_rvalue *dPdy; /**< Partial derivative of coordinate wrt Y */
1347 struct ir_swizzle_mask {
1354 * Number of components in the swizzle.
1356 unsigned num_components:3;
1359 * Does the swizzle contain duplicate components?
1361 * L-value swizzles cannot contain duplicate components.
1363 unsigned has_duplicates:1;
1367 class ir_swizzle : public ir_rvalue {
1369 ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
1372 ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count);
1374 ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);
1376 virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
1378 virtual ir_constant *constant_expression_value();
1380 virtual ir_swizzle *as_swizzle()
1386 * Construct an ir_swizzle from the textual representation. Can fail.
1388 static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
1390 virtual void accept(ir_visitor *v)
1395 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1397 bool is_lvalue() const
1399 return val->is_lvalue() && !mask.has_duplicates;
1403 * Get the variable that is ultimately referenced by an r-value
1405 virtual ir_variable *variable_referenced() const;
1408 ir_swizzle_mask mask;
1412 * Initialize the mask component of a swizzle
1414 * This is used by the \c ir_swizzle constructors.
1416 void init_mask(const unsigned *components, unsigned count);
1420 class ir_dereference : public ir_rvalue {
1422 virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;
1424 virtual ir_dereference *as_dereference()
1429 bool is_lvalue() const;
1432 * Get the variable that is ultimately referenced by an r-value
1434 virtual ir_variable *variable_referenced() const = 0;
1438 class ir_dereference_variable : public ir_dereference {
1440 ir_dereference_variable(ir_variable *var);
1442 virtual ir_dereference_variable *clone(void *mem_ctx,
1443 struct hash_table *) const;
1445 virtual ir_constant *constant_expression_value();
1447 virtual ir_dereference_variable *as_dereference_variable()
1453 * Get the variable that is ultimately referenced by an r-value
1455 virtual ir_variable *variable_referenced() const
1460 virtual ir_variable *whole_variable_referenced()
1462 /* ir_dereference_variable objects always dereference the entire
1463 * variable. However, if this dereference is dereferenced by anything
1464 * else, the complete deferefernce chain is not a whole-variable
1465 * dereference. This method should only be called on the top most
1466 * ir_rvalue in a dereference chain.
1471 virtual void accept(ir_visitor *v)
1476 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1479 * Object being dereferenced.
1485 class ir_dereference_array : public ir_dereference {
1487 ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index);
1489 ir_dereference_array(ir_variable *var, ir_rvalue *array_index);
1491 virtual ir_dereference_array *clone(void *mem_ctx,
1492 struct hash_table *) const;
1494 virtual ir_constant *constant_expression_value();
1496 virtual ir_dereference_array *as_dereference_array()
1502 * Get the variable that is ultimately referenced by an r-value
1504 virtual ir_variable *variable_referenced() const
1506 return this->array->variable_referenced();
1509 virtual void accept(ir_visitor *v)
1514 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1517 ir_rvalue *array_index;
1520 void set_array(ir_rvalue *value);
1524 class ir_dereference_record : public ir_dereference {
1526 ir_dereference_record(ir_rvalue *value, const char *field);
1528 ir_dereference_record(ir_variable *var, const char *field);
1530 virtual ir_dereference_record *clone(void *mem_ctx,
1531 struct hash_table *) const;
1533 virtual ir_constant *constant_expression_value();
1536 * Get the variable that is ultimately referenced by an r-value
1538 virtual ir_variable *variable_referenced() const
1540 return this->record->variable_referenced();
1543 virtual void accept(ir_visitor *v)
1548 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1556 * Data stored in an ir_constant
1558 union ir_constant_data {
1566 class ir_constant : public ir_rvalue {
1568 ir_constant(const struct glsl_type *type, const ir_constant_data *data);
1569 ir_constant(bool b);
1570 ir_constant(unsigned int u);
1572 ir_constant(float f);
1575 * Construct an ir_constant from a list of ir_constant values
1577 ir_constant(const struct glsl_type *type, exec_list *values);
1580 * Construct an ir_constant from a scalar component of another ir_constant
1582 * The new \c ir_constant inherits the type of the component from the
1586 * In the case of a matrix constant, the new constant is a scalar, \b not
1589 ir_constant(const ir_constant *c, unsigned i);
1592 * Return a new ir_constant of the specified type containing all zeros.
1594 static ir_constant *zero(void *mem_ctx, const glsl_type *type);
1596 virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
1598 virtual ir_constant *constant_expression_value();
1600 virtual ir_constant *as_constant()
1605 virtual void accept(ir_visitor *v)
1610 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
1613 * Get a particular component of a constant as a specific type
1615 * This is useful, for example, to get a value from an integer constant
1616 * as a float or bool. This appears frequently when constructors are
1617 * called with all constant parameters.
1620 bool get_bool_component(unsigned i) const;
1621 float get_float_component(unsigned i) const;
1622 int get_int_component(unsigned i) const;
1623 unsigned get_uint_component(unsigned i) const;
1626 ir_constant *get_array_element(unsigned i) const;
1628 ir_constant *get_record_field(const char *name);
1631 * Determine whether a constant has the same value as another constant
1633 * \sa ir_constant::is_zero, ir_constant::is_one,
1634 * ir_constant::is_negative_one
1636 bool has_value(const ir_constant *) const;
1638 virtual bool is_zero() const;
1639 virtual bool is_one() const;
1640 virtual bool is_negative_one() const;
1643 * Value of the constant.
1645 * The field used to back the values supplied by the constant is determined
1646 * by the type associated with the \c ir_instruction. Constants may be
1647 * scalars, vectors, or matrices.
1649 union ir_constant_data value;
1651 /* Array elements */
1652 ir_constant **array_elements;
1654 /* Structure fields */
1655 exec_list components;
1659 * Parameterless constructor only used by the clone method
1667 * Apply a visitor to each IR node in a list
1670 visit_exec_list(exec_list *list, ir_visitor *visitor);
1673 * Validate invariants on each IR node in a list
1675 void validate_ir_tree(exec_list *instructions);
1677 struct _mesa_glsl_parse_state;
1678 struct gl_shader_program;
1681 * Detect whether an unlinked shader contains static recursion
1683 * If the list of instructions is determined to contain static recursion,
1684 * \c _mesa_glsl_error will be called to emit error messages for each function
1685 * that is in the recursion cycle.
1688 detect_recursion_unlinked(struct _mesa_glsl_parse_state *state,
1689 exec_list *instructions);
1692 * Detect whether a linked shader contains static recursion
1694 * If the list of instructions is determined to contain static recursion,
1695 * \c link_error_printf will be called to emit error messages for each function
1696 * that is in the recursion cycle. In addition,
1697 * \c gl_shader_program::LinkStatus will be set to false.
1700 detect_recursion_linked(struct gl_shader_program *prog,
1701 exec_list *instructions);
1704 * Make a clone of each IR instruction in a list
1706 * \param in List of IR instructions that are to be cloned
1707 * \param out List to hold the cloned instructions
1710 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);
1713 _mesa_glsl_initialize_variables(exec_list *instructions,
1714 struct _mesa_glsl_parse_state *state);
1717 _mesa_glsl_initialize_functions(_mesa_glsl_parse_state *state);
1720 _mesa_glsl_release_functions(void);
1723 reparent_ir(exec_list *list, void *mem_ctx);
1725 struct glsl_symbol_table;
1728 import_prototypes(const exec_list *source, exec_list *dest,
1729 struct glsl_symbol_table *symbols, void *mem_ctx);
1732 ir_has_call(ir_instruction *ir);
1735 do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
1736 bool is_fragment_shader);
1739 prototype_string(const glsl_type *return_type, const char *name,
1740 exec_list *parameters);