X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fir.h;h=1fce272756e5d607cdfdb1fdb718ed658c9fef65;hb=d3073f58c17d8675a2ecdd5dfa83e5520c78e1a8;hp=eb9e6cdf0e2638d93977b4e71b960025848af466;hpb=443a7e4e9a360acbc3e662c098be436f180bf81d;p=mesa.git diff --git a/src/glsl/ir.h b/src/glsl/ir.h index eb9e6cdf0e2..1fce272756e 100644 --- a/src/glsl/ir.h +++ b/src/glsl/ir.h @@ -29,19 +29,37 @@ #include #include -extern "C" { -#include -} - +#include "ralloc.h" +#include "glsl_types.h" #include "list.h" #include "ir_visitor.h" #include "ir_hierarchical_visitor.h" -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) -#endif +/** + * \defgroup IR Intermediate representation nodes + * + * @{ + */ +/** + * Class tags + * + * Each concrete class derived from \c ir_instruction has a value in this + * enumerant. The value for the type is stored in \c ir_instruction::ir_type + * by the constructor. While using type tags is not very C++, it is extremely + * convenient. For example, during debugging you can simply inspect + * \c ir_instruction::ir_type to find out the actual type of the object. + * + * In addition, it is possible to use a switch-statement based on \c + * \c ir_instruction::ir_type to select different behavior for different object + * types. For functions that have only slight differences for several object + * types, this allows writing very straightforward, readable code. + */ enum ir_node_type { + /** + * Zero is unused so that the IR validator can detect cases where + * \c ir_instruction::ir_type has not been initialized. + */ ir_type_unset, ir_type_variable, ir_type_assignment, @@ -101,6 +119,7 @@ public: virtual class ir_if * as_if() { return NULL; } virtual class ir_swizzle * as_swizzle() { return NULL; } virtual class ir_constant * as_constant() { return NULL; } + virtual class ir_discard * as_discard() { return NULL; } /*@}*/ protected: @@ -123,6 +142,8 @@ public: return this; } + ir_rvalue *as_rvalue_to_saturate(); + virtual bool is_lvalue() { return false; @@ -151,17 +172,57 @@ public: return NULL; } + /** + * Determine if an r-value has the value zero + * + * The base implementation of this function always returns \c false. The + * \c ir_constant class over-rides this function to return \c true \b only + * for vector and scalar types that have all elements set to the value + * zero (or \c false for booleans). + * + * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one + */ + virtual bool is_zero() const; + + /** + * Determine if an r-value has the value one + * + * The base implementation of this function always returns \c false. The + * \c ir_constant class over-rides this function to return \c true \b only + * for vector and scalar types that have all elements set to the value + * one (or \c true for booleans). + * + * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one + */ + virtual bool is_one() const; + + /** + * Determine if an r-value has the value negative one + * + * The base implementation of this function always returns \c false. The + * \c ir_constant class over-rides this function to return \c true \b only + * for vector and scalar types that have all elements set to the value + * negative one. For boolean times, the result is always \c false. + * + * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one + */ + virtual bool is_negative_one() const; + protected: ir_rvalue(); }; +/** + * Variable storage classes + */ enum ir_variable_mode { - ir_var_auto = 0, - ir_var_uniform, + ir_var_auto = 0, /**< Function local variables and globals. */ + ir_var_uniform, /**< Variable declared as a uniform. */ ir_var_in, ir_var_out, ir_var_inout, + ir_var_system_value, /**< Ex: front-face, instance-id, etc. */ ir_var_temporary /**< Temporary variable generated during compilation. */ }; @@ -171,6 +232,25 @@ enum ir_variable_interpolation { ir_var_noperspective }; +/** + * \brief Layout qualifiers for gl_FragDepth. + * + * The AMD_conservative_depth extension allows gl_FragDepth to be redeclared + * with a layout qualifier. + */ +enum ir_depth_layout { + ir_depth_layout_none, /**< No depth layout is specified. */ + ir_depth_layout_any, + ir_depth_layout_greater, + ir_depth_layout_less, + ir_depth_layout_unchanged +}; + +/** + * \brief Convert depth layout qualifier to string. + */ +const char* +depth_layout_string(ir_depth_layout layout); class ir_variable : public ir_instruction { public: @@ -209,6 +289,9 @@ public: */ unsigned component_slots() const; + /** + * Delcared name of the variable + */ const char *name; /** @@ -218,11 +301,37 @@ public: */ unsigned max_array_access; + /** + * Is the variable read-only? + * + * This is set for variables declared as \c const, shader inputs, + * and uniforms. + */ unsigned read_only:1; unsigned centroid:1; unsigned invariant:1; + /** + * Has this variable been used for reading or writing? + * + * Several GLSL semantic checks require knowledge of whether or not a + * variable has been used. For example, it is an error to redeclare a + * variable as invariant after it has been used. + */ + unsigned used:1; + + /** + * Storage class of the variable. + * + * \sa ir_variable_mode + */ unsigned mode:3; + + /** + * Interpolation mode for shader inputs / outputs + * + * \sa ir_variable_interpolation + */ unsigned interpolation:2; /** @@ -233,9 +342,30 @@ public: */ unsigned array_lvalue:1; - /* ARB_fragment_coord_conventions */ + /** + * \name ARB_fragment_coord_conventions + * @{ + */ unsigned origin_upper_left:1; unsigned pixel_center_integer:1; + /*@}*/ + + /** + * \brief Layout qualifier for gl_FragDepth. + * + * This is not equal to \c ir_depth_layout_none if and only if this + * variable is \c gl_FragDepth and a layout qualifier is specified. + */ + ir_depth_layout depth_layout; + + /** + * Was the location explicitly set in the shader? + * + * If the location is explicitly set in the shader, it \b cannot be changed + * by the linker or by the API (e.g., calls to \c glBindAttribLocation have + * no effect). + */ + unsigned explicit_location:1; /** * Storage location of the base of this variable @@ -280,6 +410,8 @@ public: virtual ir_function_signature *clone(void *mem_ctx, struct hash_table *ht) const; + ir_function_signature *clone_prototype(void *mem_ctx, + struct hash_table *ht) const; virtual void accept(ir_visitor *v) { @@ -343,7 +475,7 @@ public: unsigned is_defined:1; /** Whether or not this function signature is a built-in. */ - unsigned is_built_in:1; + unsigned is_builtin:1; /** Body of instructions in the function. */ struct exec_list body; @@ -410,6 +542,9 @@ public: */ const char *name; + /** Whether or not this function has a signature that isn't a built-in. */ + bool has_user_signature(); + /** * List of ir_function_signature for each overloaded function with this name. */ @@ -461,10 +596,7 @@ public: */ class ir_loop : public ir_instruction { public: - ir_loop() : from(NULL), to(NULL), increment(NULL), counter(NULL) - { - ir_type = ir_type_loop; - } + ir_loop(); virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const; @@ -493,12 +625,30 @@ public: /** * \name Loop counter and controls + * + * Represents a loop like a FORTRAN \c do-loop. + * + * \note + * If \c from and \c to are the same value, the loop will execute once. */ /*@{*/ - ir_rvalue *from; - ir_rvalue *to; + ir_rvalue *from; /** Value of the loop counter on the first + * iteration of the loop. + */ + ir_rvalue *to; /** Value of the loop counter on the last + * iteration of the loop. + */ ir_rvalue *increment; ir_variable *counter; + + /** + * Comparison operation in the loop terminator. + * + * If any of the loop control fields are non-\c NULL, this field must be + * one of \c ir_binop_less, \c ir_binop_greater, \c ir_binop_lequal, + * \c ir_binop_gequal, \c ir_binop_equal, or \c ir_binop_nequal. + */ + int cmp; /*@}*/ }; @@ -577,6 +727,14 @@ public: * For non-vector types in the LHS, this field will be zero. For vector * types, a bit will be set for each component that is written. Note that * for \c vec2 and \c vec3 types only the lower bits will ever be set. + * + * A partially-set write mask means that each enabled channel gets + * the value from a consecutive channel of the rhs. For example, + * to write just .xyw of gl_FrontColor with color: + * + * (assign (constant bool (1)) (xyw) + * (var_ref gl_FragColor) + * (swiz xyw (var_ref color))) */ unsigned write_mask:4; }; @@ -604,6 +762,7 @@ enum ir_expression_operation { ir_unop_i2b, /**< int-to-boolean conversion */ ir_unop_b2i, /**< Boolean-to-int conversion */ ir_unop_u2f, /**< Unsigned-to-float conversion. */ + ir_unop_any, /** * \name Unary floating-point rounding operations. @@ -613,6 +772,7 @@ enum ir_expression_operation { ir_unop_ceil, ir_unop_floor, ir_unop_fract, + ir_unop_round_even, /*@}*/ /** @@ -621,6 +781,8 @@ enum ir_expression_operation { /*@{*/ ir_unop_sin, ir_unop_cos, + ir_unop_sin_reduced, /**< Reduced range sin. [-pi, pi] */ + ir_unop_cos_reduced, /**< Reduced range cos. [-pi, pi] */ /*@}*/ /** @@ -631,6 +793,13 @@ enum ir_expression_operation { ir_unop_dFdy, /*@}*/ + ir_unop_noise, + + /** + * A sentinel marking the last of the unary operations. + */ + ir_last_unop = ir_unop_noise, + ir_binop_add, ir_binop_sub, ir_binop_mul, @@ -647,23 +816,26 @@ enum ir_expression_operation { ir_binop_mod, /** - * \name Binary comparison operators + * \name Binary comparison operators which return a boolean vector. + * The type of both operands must be equal. */ /*@{*/ ir_binop_less, ir_binop_greater, ir_binop_lequal, ir_binop_gequal, + ir_binop_equal, + ir_binop_nequal, /** * Returns single boolean for whether all components of operands[0] * equal the components of operands[1]. */ - ir_binop_equal, + ir_binop_all_equal, /** * Returns single boolean for whether any component of operands[0] * is not equal to the corresponding component of operands[1]. */ - ir_binop_nequal, + ir_binop_any_nequal, /*@}*/ /** @@ -682,17 +854,44 @@ enum ir_expression_operation { ir_binop_logic_or, ir_binop_dot, - ir_binop_cross, ir_binop_min, ir_binop_max, - ir_binop_pow + ir_binop_pow, + + /** + * A sentinel marking the last of the binary operations. + */ + ir_last_binop = ir_binop_pow, + + ir_quadop_vector, + + /** + * A sentinel marking the last of all operations. + */ + ir_last_opcode = ir_last_binop }; class ir_expression : public ir_rvalue { public: + /** + * Constructor for unary operation expressions + */ + ir_expression(int op, const struct glsl_type *type, ir_rvalue *); + ir_expression(int op, ir_rvalue *); + + /** + * Constructor for binary operation expressions + */ ir_expression(int op, const struct glsl_type *type, ir_rvalue *, ir_rvalue *); + ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1); + + /** + * Constructor for quad operator expressions + */ + ir_expression(int op, const struct glsl_type *type, + ir_rvalue *, ir_rvalue *, ir_rvalue *, ir_rvalue *); virtual ir_expression *as_expression() { @@ -701,12 +900,26 @@ public: virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const; + /** + * Attempt to constant-fold the expression + * + * If the expression cannot be constant folded, this method will return + * \c NULL. + */ virtual ir_constant *constant_expression_value(); + /** + * Determine the number of operands used by an expression + */ static unsigned int get_num_operands(ir_expression_operation); + + /** + * Determine the number of operands used by an expression + */ unsigned int get_num_operands() const { - return get_num_operands(operation); + return (this->operation == ir_quadop_vector) + ? this->type->vector_elements : get_num_operands(operation); } /** @@ -714,6 +927,12 @@ public: */ const char *operator_string(); + /** + * Return a string representing this expression's operator. + */ + static const char *operator_string(ir_expression_operation); + + /** * Do a reverse-lookup to translate the given string into an operator. */ @@ -727,7 +946,7 @@ public: virtual ir_visitor_status accept(ir_hierarchical_visitor *); ir_expression_operation operation; - ir_rvalue *operands[2]; + ir_rvalue *operands[4]; }; @@ -764,7 +983,7 @@ public: /** * Get a generic ir_call object when an error occurs * - * Any allocation will be performed with 'ctx' as talloc owner. + * Any allocation will be performed with 'ctx' as ralloc owner. */ static ir_call *get_error_instruction(void *ctx); @@ -784,6 +1003,9 @@ public: return callee->function_name(); } + /** + * Get the function signature bound to this function call + */ ir_function_signature *get_callee() { return callee; @@ -939,6 +1161,11 @@ public: virtual ir_visitor_status accept(ir_hierarchical_visitor *); + virtual ir_discard *as_discard() + { + return this; + } + ir_rvalue *condition; }; /*@}*/ @@ -948,11 +1175,11 @@ public: * Texture sampling opcodes used in ir_texture */ enum ir_texture_opcode { - ir_tex, /* Regular texture look-up */ - ir_txb, /* Texture look-up with LOD bias */ - ir_txl, /* Texture look-up with explicit LOD */ - ir_txd, /* Texture look-up with partial derivatvies */ - ir_txf /* Texel fetch with explicit LOD */ + ir_tex, /**< Regular texture look-up */ + ir_txb, /**< Texture look-up with LOD bias */ + ir_txl, /**< Texture look-up with explicit LOD */ + ir_txd, /**< Texture look-up with partial derivatvies */ + ir_txf /**< Texel fetch with explicit LOD */ }; @@ -1330,9 +1557,16 @@ public: /** * Determine whether a constant has the same value as another constant + * + * \sa ir_constant::is_zero, ir_constant::is_one, + * ir_constant::is_negative_one */ bool has_value(const ir_constant *) const; + virtual bool is_zero() const; + virtual bool is_one() const; + virtual bool is_negative_one() const; + /** * Value of the constant. * @@ -1355,9 +1589,17 @@ private: ir_constant(void); }; +/*@}*/ + +/** + * Apply a visitor to each IR node in a list + */ void visit_exec_list(exec_list *list, ir_visitor *visitor); +/** + * Validate invariants on each IR node in a list + */ void validate_ir_tree(exec_list *instructions); /** @@ -1374,8 +1616,7 @@ _mesa_glsl_initialize_variables(exec_list *instructions, struct _mesa_glsl_parse_state *state); extern void -_mesa_glsl_initialize_functions(exec_list *instructions, - struct _mesa_glsl_parse_state *state); +_mesa_glsl_initialize_functions(_mesa_glsl_parse_state *state); extern void _mesa_glsl_release_functions(void); @@ -1383,11 +1624,11 @@ _mesa_glsl_release_functions(void); extern void reparent_ir(exec_list *list, void *mem_ctx); -class glsl_symbol_table; +struct glsl_symbol_table; extern void import_prototypes(const exec_list *source, exec_list *dest, - class glsl_symbol_table *symbols, void *mem_ctx); + struct glsl_symbol_table *symbols, void *mem_ctx); extern bool ir_has_call(ir_instruction *ir);