X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fir.h;h=ddfaf3614aed3287467e8d62cc6e9d8c96402030;hb=f2475ca424f7e001be50f64dafa5700f6603d684;hp=50a9d6e1991909da16f2f8dcfdd5fafd83cc1340;hpb=ecc6a26a3d602e8b649c441077e005dfeb77aff2;p=mesa.git diff --git a/src/glsl/ir.h b/src/glsl/ir.h index 50a9d6e1991..ddfaf3614ae 100644 --- a/src/glsl/ir.h +++ b/src/glsl/ir.h @@ -34,6 +34,7 @@ #include "list.h" #include "ir_visitor.h" #include "ir_hierarchical_visitor.h" +#include "main/mtypes.h" /** * \defgroup IR Intermediate representation nodes @@ -87,7 +88,6 @@ enum ir_node_type { class ir_instruction : public exec_node { public: enum ir_node_type ir_type; - const struct glsl_type *type; /** ir_print_visitor helper for debugging. */ void print(void) const; @@ -126,16 +126,27 @@ protected: ir_instruction() { ir_type = ir_type_unset; - type = NULL; } }; +/** + * The base class for all "values"/expression trees. + */ class ir_rvalue : public ir_instruction { public: - virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const = 0; + const struct glsl_type *type; + + virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const; - virtual ir_constant *constant_expression_value() = 0; + virtual void accept(ir_visitor *v) + { + v->visit(this); + } + + virtual ir_visitor_status accept(ir_hierarchical_visitor *); + + virtual ir_constant *constant_expression_value(); virtual ir_rvalue * as_rvalue() { @@ -144,7 +155,7 @@ public: ir_rvalue *as_rvalue_to_saturate(); - virtual bool is_lvalue() + virtual bool is_lvalue() const { return false; } @@ -152,7 +163,7 @@ public: /** * Get the variable that is ultimately referenced by an r-value */ - virtual ir_variable *variable_referenced() + virtual ir_variable *variable_referenced() const { return NULL; } @@ -208,6 +219,14 @@ public: */ virtual bool is_negative_one() const; + + /** + * Return a generic value of error_type. + * + * Allocation will be performed with 'mem_ctx' as ralloc owner. + */ + static ir_rvalue *error_value(void *mem_ctx); + protected: ir_rvalue(); }; @@ -227,16 +246,10 @@ enum ir_variable_mode { ir_var_temporary /**< Temporary variable generated during compilation. */ }; -enum ir_variable_interpolation { - ir_var_smooth = 0, - ir_var_flat, - ir_var_noperspective -}; - /** * \brief Layout qualifiers for gl_FragDepth. * - * The AMD_conservative_depth extension allows gl_FragDepth to be redeclared + * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared * with a layout qualifier. */ enum ir_depth_layout { @@ -288,17 +301,29 @@ public: * \return The string that would be used in a shader to specify \c * mode will be returned. * + * This function is used to generate error messages of the form "shader + * uses %s interpolation qualifier", so in the case where there is no + * interpolation qualifier, it returns "no". + * * This function should only be used on a shader input or output variable. */ const char *interpolation_string() const; /** - * Calculate the number of slots required to hold this variable + * Determine how this variable should be interpolated based on its + * interpolation qualifier (if present), whether it is gl_Color or + * gl_SecondaryColor, and whether flatshading is enabled in the current GL + * state. * - * This is used to determine how many uniform or varying locations a variable - * occupies. The count is in units of floating point components. + * The return value will always be either INTERP_QUALIFIER_SMOOTH, + * INTERP_QUALIFIER_NOPERSPECTIVE, or INTERP_QUALIFIER_FLAT. */ - unsigned component_slots() const; + glsl_interp_qualifier determine_interpolation_mode(bool flat_shade); + + /** + * Declared type of the variable + */ + const struct glsl_type *type; /** * Delcared name of the variable @@ -328,9 +353,22 @@ public: * 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. + * + * This is only maintained in the ast_to_hir.cpp path, not in + * Mesa's fixed function or ARB program paths. */ unsigned used:1; + /** + * Has this variable been statically assigned? + * + * This answers whether the variable was assigned in any path of + * the shader during ast_to_hir. This doesn't answer whether it is + * still written after dead code removal, nor is it maintained in + * non-ast_to_hir.cpp (GLSL parsing) paths. + */ + unsigned assigned:1; + /** * Storage class of the variable. * @@ -345,14 +383,6 @@ public: */ unsigned interpolation:2; - /** - * Flag that the whole array is assignable - * - * In GLSL 1.20 and later whole arrays are assignable (and comparable for - * equality). This flag enables this behavior. - */ - unsigned array_lvalue:1; - /** * \name ARB_fragment_coord_conventions * @{ @@ -361,14 +391,6 @@ public: 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? * @@ -377,6 +399,23 @@ public: * no effect). */ unsigned explicit_location:1; + unsigned explicit_index:1; + + /** + * Does this variable have an initializer? + * + * This is used by the linker to cross-validiate initializers of global + * variables. + */ + unsigned has_initializer: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; /** * Storage location of the base of this variable @@ -395,6 +434,11 @@ public: */ int location; + /** + * output index for dual source blending. + */ + int index; + /** * Built-in state that backs this uniform * @@ -420,6 +464,16 @@ public: * Value assigned in the initializer of a variable declared "const" */ ir_constant *constant_value; + + /** + * Constant expression assigned in the initializer of the variable + * + * \warning + * This field and \c ::constant_value are distinct. Even if the two fields + * refer to constants with the same value, they must point to separate + * objects. + */ + ir_constant *constant_initializer; }; @@ -447,6 +501,12 @@ public: virtual ir_visitor_status accept(ir_hierarchical_visitor *); + /** + * Attempt to evaluate this function as a constant expression, given + * a list of the actual parameters. Returns NULL for non-built-ins. + */ + ir_constant *constant_expression_value(exec_list *actual_parameters); + /** * Get the name of the function for which this is a signature */ @@ -552,6 +612,13 @@ public: return signatures.iterator(); } + /** + * Find a signature that matches a set of actual parameters, taking implicit + * conversions into account. Also flags whether the match was exact. + */ + ir_function_signature *matching_signature(const exec_list *actual_param, + bool *match_is_exact); + /** * Find a signature that matches a set of actual parameters, taking implicit * conversions into account. @@ -980,16 +1047,18 @@ public: /** - * IR instruction representing a function call + * HIR instruction representing a high-level function call, containing a list + * of parameters and returning a value in the supplied temporary. */ -class ir_call : public ir_rvalue { +class ir_call : public ir_instruction { public: - ir_call(ir_function_signature *callee, exec_list *actual_parameters) - : callee(callee) + ir_call(ir_function_signature *callee, + ir_dereference_variable *return_deref, + exec_list *actual_parameters) + : return_deref(return_deref), callee(callee) { ir_type = ir_type_call; assert(callee->return_type != NULL); - type = callee->return_type; actual_parameters->move_nodes_to(& this->actual_parameters); this->use_builtin = callee->is_builtin; } @@ -1010,13 +1079,6 @@ public: virtual ir_visitor_status accept(ir_hierarchical_visitor *); - /** - * Get a generic ir_call object when an error occurs - * - * Any allocation will be performed with 'ctx' as ralloc owner. - */ - static ir_call *get_error_instruction(void *ctx); - /** * Get an iterator for the set of acutal parameters */ @@ -1034,38 +1096,27 @@ public: } /** - * Get the function signature bound to this function call + * Generates an inline version of the function before @ir, + * storing the return value in return_deref. */ - ir_function_signature *get_callee() - { - return callee; - } + void generate_inline(ir_instruction *ir); /** - * Set the function call target + * Storage for the function's return value. + * This must be NULL if the return type is void. */ - void set_callee(ir_function_signature *sig); + ir_dereference_variable *return_deref; /** - * Generates an inline version of the function before @ir, - * returning the return value of the function. + * The specific function signature being called. */ - ir_rvalue *generate_inline(ir_instruction *ir); + ir_function_signature *callee; /* List of ir_rvalue of paramaters passed in this call. */ exec_list actual_parameters; /** Should this call only bind to a built-in function? */ bool use_builtin; - -private: - ir_call() - : callee(NULL) - { - this->ir_type = ir_type_call; - } - - ir_function_signature *callee; }; @@ -1212,7 +1263,8 @@ enum ir_texture_opcode { 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_txf, /**< Texel fetch with explicit LOD */ + ir_txs /**< Texture size */ }; @@ -1233,6 +1285,7 @@ enum ir_texture_opcode { * (txl 0 1 ( ) ) * (txd 0 1 ( ) (dPdx dPdy)) * (txf 0 ) + * (txs ) */ class ir_texture : public ir_rvalue { public: @@ -1355,7 +1408,7 @@ public: virtual ir_visitor_status accept(ir_hierarchical_visitor *); - bool is_lvalue() + bool is_lvalue() const { return val->is_lvalue() && !mask.has_duplicates; } @@ -1363,7 +1416,7 @@ public: /** * Get the variable that is ultimately referenced by an r-value */ - virtual ir_variable *variable_referenced(); + virtual ir_variable *variable_referenced() const; ir_rvalue *val; ir_swizzle_mask mask; @@ -1387,12 +1440,12 @@ public: return this; } - bool is_lvalue(); + bool is_lvalue() const; /** * Get the variable that is ultimately referenced by an r-value */ - virtual ir_variable *variable_referenced() = 0; + virtual ir_variable *variable_referenced() const = 0; }; @@ -1413,7 +1466,7 @@ public: /** * Get the variable that is ultimately referenced by an r-value */ - virtual ir_variable *variable_referenced() + virtual ir_variable *variable_referenced() const { return this->var; } @@ -1462,7 +1515,7 @@ public: /** * Get the variable that is ultimately referenced by an r-value */ - virtual ir_variable *variable_referenced() + virtual ir_variable *variable_referenced() const { return this->array->variable_referenced(); } @@ -1496,7 +1549,7 @@ public: /** * Get the variable that is ultimately referenced by an r-value */ - virtual ir_variable *variable_referenced() + virtual ir_variable *variable_referenced() const { return this->record->variable_referenced(); } @@ -1693,7 +1746,8 @@ extern bool ir_has_call(ir_instruction *ir); extern void -do_set_program_inouts(exec_list *instructions, struct gl_program *prog); +do_set_program_inouts(exec_list *instructions, struct gl_program *prog, + bool is_fragment_shader); extern char * prototype_string(const glsl_type *return_type, const char *name,