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 opt_function_inlining.cpp
27 * Replaces calls to functions with the body of the function.
32 #include "ir_visitor.h"
33 #include "ir_function_inlining.h"
34 #include "ir_expression_flattening.h"
35 #include "glsl_types.h"
36 #include "program/hash_table.h"
39 do_sampler_replacement(exec_list
*instructions
,
41 ir_dereference
*deref
);
43 class ir_function_inlining_visitor
: public ir_hierarchical_visitor
{
45 ir_function_inlining_visitor()
50 virtual ~ir_function_inlining_visitor()
55 virtual ir_visitor_status
visit_enter(ir_expression
*);
56 virtual ir_visitor_status
visit_enter(ir_call
*);
57 virtual ir_visitor_status
visit_enter(ir_assignment
*);
58 virtual ir_visitor_status
visit_enter(ir_return
*);
59 virtual ir_visitor_status
visit_enter(ir_texture
*);
60 virtual ir_visitor_status
visit_enter(ir_swizzle
*);
67 automatic_inlining_predicate(ir_instruction
*ir
)
69 ir_call
*call
= ir
->as_call();
71 if (call
&& can_inline(call
))
78 do_function_inlining(exec_list
*instructions
)
80 ir_function_inlining_visitor v
;
82 do_expression_flattening(instructions
, automatic_inlining_predicate
);
90 replace_return_with_assignment(ir_instruction
*ir
, void *data
)
92 void *ctx
= talloc_parent(ir
);
93 ir_variable
*retval
= (ir_variable
*)data
;
94 ir_return
*ret
= ir
->as_return();
98 ir_rvalue
*lhs
= new(ctx
) ir_dereference_variable(retval
);
99 ret
->replace_with(new(ctx
) ir_assignment(lhs
, ret
->value
, NULL
));
101 /* un-valued return has to be the last return, or we shouldn't
102 * have reached here. (see can_inline()).
104 assert(ret
->next
->is_tail_sentinel());
111 ir_call::generate_inline(ir_instruction
*next_ir
)
113 void *ctx
= talloc_parent(this);
114 ir_variable
**parameters
;
117 ir_variable
*retval
= NULL
;
118 struct hash_table
*ht
;
120 ht
= hash_table_ctor(0, hash_table_pointer_hash
, hash_table_pointer_compare
);
123 foreach_iter(exec_list_iterator
, iter_sig
, this->callee
->parameters
)
126 parameters
= new ir_variable
*[num_parameters
];
128 /* Generate storage for the return value. */
129 if (this->callee
->return_type
) {
130 retval
= new(ctx
) ir_variable(this->callee
->return_type
, "_ret_val",
132 next_ir
->insert_before(retval
);
135 /* Generate the declarations for the parameters to our inlined code,
136 * and set up the mapping of real function body variables to ours.
139 exec_list_iterator sig_param_iter
= this->callee
->parameters
.iterator();
140 exec_list_iterator param_iter
= this->actual_parameters
.iterator();
141 for (i
= 0; i
< num_parameters
; i
++) {
142 ir_variable
*sig_param
= (ir_variable
*) sig_param_iter
.get();
143 ir_rvalue
*param
= (ir_rvalue
*) param_iter
.get();
145 /* Generate a new variable for the parameter. */
146 if (sig_param
->type
->base_type
== GLSL_TYPE_SAMPLER
) {
147 /* For samplers, we want the inlined sampler references
148 * referencing the passed in sampler variable, since that
149 * will have the location information, which an assignment of
150 * a sampler wouldn't. Fix it up below.
152 parameters
[i
] = NULL
;
154 parameters
[i
] = sig_param
->clone(ctx
, ht
);
155 parameters
[i
]->mode
= ir_var_auto
;
157 /* Remove the read-only decoration becuase we're going to write
158 * directly to this variable. If the cloned variable is left
159 * read-only and the inlined function is inside a loop, the loop
160 * analysis code will get confused.
162 parameters
[i
]->read_only
= false;
163 next_ir
->insert_before(parameters
[i
]);
166 /* Move the actual param into our param variable if it's an 'in' type. */
167 if (parameters
[i
] && (sig_param
->mode
== ir_var_in
||
168 sig_param
->mode
== ir_var_inout
)) {
169 ir_assignment
*assign
;
171 assign
= new(ctx
) ir_assignment(new(ctx
) ir_dereference_variable(parameters
[i
]),
173 next_ir
->insert_before(assign
);
176 sig_param_iter
.next();
180 exec_list new_instructions
;
182 /* Generate the inlined body of the function to a new list */
183 foreach_iter(exec_list_iterator
, iter
, callee
->body
) {
184 ir_instruction
*ir
= (ir_instruction
*)iter
.get();
185 ir_instruction
*new_ir
= ir
->clone(ctx
, ht
);
187 new_instructions
.push_tail(new_ir
);
188 visit_tree(new_ir
, replace_return_with_assignment
, retval
);
191 /* If any samplers were passed in, replace any deref of the sampler
192 * with a deref of the sampler argument.
194 param_iter
= this->actual_parameters
.iterator();
195 sig_param_iter
= this->callee
->parameters
.iterator();
196 for (i
= 0; i
< num_parameters
; i
++) {
197 ir_instruction
*const param
= (ir_instruction
*) param_iter
.get();
198 ir_variable
*sig_param
= (ir_variable
*) sig_param_iter
.get();
200 if (sig_param
->type
->base_type
== GLSL_TYPE_SAMPLER
) {
201 ir_dereference
*deref
= param
->as_dereference();
204 do_sampler_replacement(&new_instructions
, sig_param
, deref
);
207 sig_param_iter
.next();
210 /* Now push those new instructions in. */
211 foreach_iter(exec_list_iterator
, iter
, new_instructions
) {
212 ir_instruction
*ir
= (ir_instruction
*)iter
.get();
213 next_ir
->insert_before(ir
);
216 /* Copy back the value of any 'out' parameters from the function body
217 * variables to our own.
220 param_iter
= this->actual_parameters
.iterator();
221 sig_param_iter
= this->callee
->parameters
.iterator();
222 for (i
= 0; i
< num_parameters
; i
++) {
223 ir_instruction
*const param
= (ir_instruction
*) param_iter
.get();
224 const ir_variable
*const sig_param
= (ir_variable
*) sig_param_iter
.get();
226 /* Move our param variable into the actual param if it's an 'out' type. */
227 if (parameters
[i
] && (sig_param
->mode
== ir_var_out
||
228 sig_param
->mode
== ir_var_inout
)) {
229 ir_assignment
*assign
;
231 assign
= new(ctx
) ir_assignment(param
->clone(ctx
, NULL
)->as_rvalue(),
232 new(ctx
) ir_dereference_variable(parameters
[i
]),
234 next_ir
->insert_before(assign
);
238 sig_param_iter
.next();
241 delete [] parameters
;
246 return new(ctx
) ir_dereference_variable(retval
);
253 ir_function_inlining_visitor::visit_enter(ir_expression
*ir
)
256 return visit_continue_with_parent
;
261 ir_function_inlining_visitor::visit_enter(ir_return
*ir
)
264 return visit_continue_with_parent
;
269 ir_function_inlining_visitor::visit_enter(ir_texture
*ir
)
272 return visit_continue_with_parent
;
277 ir_function_inlining_visitor::visit_enter(ir_swizzle
*ir
)
280 return visit_continue_with_parent
;
285 ir_function_inlining_visitor::visit_enter(ir_call
*ir
)
287 if (can_inline(ir
)) {
288 /* If the call was part of some tree, then it should have been
289 * flattened out or we shouldn't have seen it because of a
290 * visit_continue_with_parent in this visitor.
292 assert(ir
== base_ir
);
294 (void) ir
->generate_inline(ir
);
296 this->progress
= true;
299 return visit_continue
;
304 ir_function_inlining_visitor::visit_enter(ir_assignment
*ir
)
306 ir_call
*call
= ir
->rhs
->as_call();
307 if (!call
|| !can_inline(call
))
308 return visit_continue
;
310 /* generates the parameter setup, function body, and returns the return
311 * value of the function
313 ir_rvalue
*rhs
= call
->generate_inline(ir
);
317 this->progress
= true;
319 return visit_continue
;
323 * Replaces references to the "sampler" variable with a clone of "deref."
325 * From the spec, samplers can appear in the tree as function
326 * (non-out) parameters and as the result of array indexing and
327 * structure field selection. In our builtin implementation, they
328 * also appear in the sampler field of an ir_tex instruction.
331 class ir_sampler_replacement_visitor
: public ir_hierarchical_visitor
{
333 ir_sampler_replacement_visitor(ir_variable
*sampler
, ir_dereference
*deref
)
335 this->sampler
= sampler
;
339 virtual ~ir_sampler_replacement_visitor()
343 virtual ir_visitor_status
visit_leave(ir_call
*);
344 virtual ir_visitor_status
visit_leave(ir_dereference_array
*);
345 virtual ir_visitor_status
visit_leave(ir_dereference_record
*);
346 virtual ir_visitor_status
visit_leave(ir_texture
*);
348 void replace_deref(ir_dereference
**deref
);
349 void replace_rvalue(ir_rvalue
**rvalue
);
351 ir_variable
*sampler
;
352 ir_dereference
*deref
;
356 ir_sampler_replacement_visitor::replace_deref(ir_dereference
**deref
)
358 ir_dereference_variable
*deref_var
= (*deref
)->as_dereference_variable();
359 if (deref_var
&& deref_var
->var
== this->sampler
) {
360 *deref
= this->deref
->clone(talloc_parent(*deref
), NULL
);
365 ir_sampler_replacement_visitor::replace_rvalue(ir_rvalue
**rvalue
)
370 ir_dereference
*deref
= (*rvalue
)->as_dereference();
375 replace_deref(&deref
);
380 ir_sampler_replacement_visitor::visit_leave(ir_texture
*ir
)
382 replace_deref(&ir
->sampler
);
384 return visit_continue
;
388 ir_sampler_replacement_visitor::visit_leave(ir_dereference_array
*ir
)
390 replace_rvalue(&ir
->array
);
391 return visit_continue
;
395 ir_sampler_replacement_visitor::visit_leave(ir_dereference_record
*ir
)
397 replace_rvalue(&ir
->record
);
398 return visit_continue
;
402 ir_sampler_replacement_visitor::visit_leave(ir_call
*ir
)
404 foreach_iter(exec_list_iterator
, iter
, *ir
) {
405 ir_rvalue
*param
= (ir_rvalue
*)iter
.get();
406 ir_rvalue
*new_param
= param
;
407 replace_rvalue(&new_param
);
409 if (new_param
!= param
) {
410 param
->replace_with(new_param
);
413 return visit_continue
;
417 do_sampler_replacement(exec_list
*instructions
,
418 ir_variable
*sampler
,
419 ir_dereference
*deref
)
421 ir_sampler_replacement_visitor
v(sampler
, deref
);
423 visit_list_elements(&v
, instructions
);