2 * Copyright © 2010 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
25 * \file ir_set_program_inouts.cpp
27 * Sets the InputsRead and OutputsWritten of Mesa programs.
29 * Additionally, for fragment shaders, sets the InterpQualifier array, the
30 * IsCentroid bitfield, and the UsesDFdy flag.
32 * Mesa programs (gl_program, not gl_shader_program) have a set of
33 * flags indicating which varyings are read and written. Computing
34 * which are actually read from some sort of backend code can be
35 * tricky when variable array indexing involved. So this pass
36 * provides support for setting InputsRead and OutputsWritten right
40 #include "main/core.h" /* for struct gl_program */
41 #include "program/hash_table.h"
43 #include "ir_visitor.h"
44 #include "glsl_types.h"
46 class ir_set_program_inouts_visitor
: public ir_hierarchical_visitor
{
48 ir_set_program_inouts_visitor(struct gl_program
*prog
,
49 bool is_fragment_shader
)
52 this->is_fragment_shader
= is_fragment_shader
;
53 this->ht
= hash_table_ctor(0,
54 hash_table_pointer_hash
,
55 hash_table_pointer_compare
);
57 ~ir_set_program_inouts_visitor()
59 hash_table_dtor(this->ht
);
62 virtual ir_visitor_status
visit_enter(ir_dereference_array
*);
63 virtual ir_visitor_status
visit_enter(ir_function_signature
*);
64 virtual ir_visitor_status
visit_enter(ir_expression
*);
65 virtual ir_visitor_status
visit_enter(ir_discard
*);
66 virtual ir_visitor_status
visit(ir_dereference_variable
*);
67 virtual ir_visitor_status
visit(ir_variable
*);
69 struct gl_program
*prog
;
70 struct hash_table
*ht
;
71 bool is_fragment_shader
;
75 mark(struct gl_program
*prog
, ir_variable
*var
, int offset
, int len
,
76 bool is_fragment_shader
)
78 /* As of GLSL 1.20, varyings can only be floats, floating-point
79 * vectors or matrices, or arrays of them. For Mesa programs using
80 * InputsRead/OutputsWritten, everything but matrices uses one
81 * slot, while matrices use a slot per column. Presumably
82 * something doing a more clever packing would use something other
83 * than InputsRead/OutputsWritten.
86 for (int i
= 0; i
< len
; i
++) {
87 GLbitfield64 bitfield
= BITFIELD64_BIT(var
->location
+ var
->index
+ offset
+ i
);
88 if (var
->mode
== ir_var_shader_in
) {
89 prog
->InputsRead
|= bitfield
;
90 if (is_fragment_shader
) {
91 gl_fragment_program
*fprog
= (gl_fragment_program
*) prog
;
92 fprog
->InterpQualifier
[var
->location
+ var
->index
+ offset
+ i
] =
93 (glsl_interp_qualifier
) var
->interpolation
;
95 fprog
->IsCentroid
|= bitfield
;
97 } else if (var
->mode
== ir_var_system_value
) {
98 prog
->SystemValuesRead
|= bitfield
;
100 prog
->OutputsWritten
|= bitfield
;
105 /* Default handler: Mark all the locations in the variable as used. */
107 ir_set_program_inouts_visitor::visit(ir_dereference_variable
*ir
)
109 if (hash_table_find(this->ht
, ir
->var
) == NULL
)
110 return visit_continue
;
112 if (ir
->type
->is_array()) {
113 mark(this->prog
, ir
->var
, 0,
114 ir
->type
->length
* ir
->type
->fields
.array
->matrix_columns
,
115 this->is_fragment_shader
);
117 mark(this->prog
, ir
->var
, 0, ir
->type
->matrix_columns
,
118 this->is_fragment_shader
);
121 return visit_continue
;
125 ir_set_program_inouts_visitor::visit_enter(ir_dereference_array
*ir
)
127 ir_dereference_variable
*deref_var
;
128 ir_constant
*index
= ir
->array_index
->as_constant();
129 deref_var
= ir
->array
->as_dereference_variable();
130 ir_variable
*var
= NULL
;
132 /* Check that we're dereferencing a shader in or out */
134 var
= (ir_variable
*)hash_table_find(this->ht
, deref_var
->var
);
139 if (deref_var
->type
->is_array() &&
140 deref_var
->type
->fields
.array
->is_matrix()) {
141 width
= deref_var
->type
->fields
.array
->matrix_columns
;
144 mark(this->prog
, var
, index
->value
.i
[0] * width
, width
,
145 this->is_fragment_shader
);
146 return visit_continue_with_parent
;
149 return visit_continue
;
153 ir_set_program_inouts_visitor::visit(ir_variable
*ir
)
155 if (ir
->mode
== ir_var_shader_in
||
156 ir
->mode
== ir_var_shader_out
||
157 ir
->mode
== ir_var_system_value
) {
158 hash_table_insert(this->ht
, ir
, ir
);
161 return visit_continue
;
165 ir_set_program_inouts_visitor::visit_enter(ir_function_signature
*ir
)
167 /* We don't want to descend into the function parameters and
168 * consider them as shader inputs or outputs.
170 visit_list_elements(this, &ir
->body
);
171 return visit_continue_with_parent
;
175 ir_set_program_inouts_visitor::visit_enter(ir_expression
*ir
)
177 if (is_fragment_shader
&& ir
->operation
== ir_unop_dFdy
) {
178 gl_fragment_program
*fprog
= (gl_fragment_program
*) prog
;
179 fprog
->UsesDFdy
= true;
181 return visit_continue
;
185 ir_set_program_inouts_visitor::visit_enter(ir_discard
*)
187 /* discards are only allowed in fragment shaders. */
188 assert(is_fragment_shader
);
190 gl_fragment_program
*fprog
= (gl_fragment_program
*) prog
;
191 fprog
->UsesKill
= true;
193 return visit_continue
;
197 do_set_program_inouts(exec_list
*instructions
, struct gl_program
*prog
,
198 bool is_fragment_shader
)
200 ir_set_program_inouts_visitor
v(prog
, is_fragment_shader
);
202 prog
->InputsRead
= 0;
203 prog
->OutputsWritten
= 0;
204 prog
->SystemValuesRead
= 0;
205 if (is_fragment_shader
) {
206 gl_fragment_program
*fprog
= (gl_fragment_program
*) prog
;
207 memset(fprog
->InterpQualifier
, 0, sizeof(fprog
->InterpQualifier
));
208 fprog
->IsCentroid
= 0;
209 fprog
->UsesDFdy
= false;
210 fprog
->UsesKill
= false;
212 visit_list_elements(&v
, instructions
);