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_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"
37 #include "hash_table.h"
40 class ir_function_inlining_visitor
: public ir_hierarchical_visitor
{
42 ir_function_inlining_visitor()
47 virtual ~ir_function_inlining_visitor()
52 virtual ir_visitor_status
visit_enter(ir_expression
*);
53 virtual ir_visitor_status
visit_enter(ir_call
*);
54 virtual ir_visitor_status
visit_enter(ir_assignment
*);
55 virtual ir_visitor_status
visit_enter(ir_return
*);
56 virtual ir_visitor_status
visit_enter(ir_texture
*);
57 virtual ir_visitor_status
visit_enter(ir_swizzle
*);
63 unsigned int hash_func(const void *key
)
65 return (unsigned int)(uintptr_t)key
;
68 int hash_compare_func(const void *key1
, const void *key2
)
70 return key1
== key2
? 0 : 1;
74 automatic_inlining_predicate(ir_instruction
*ir
)
76 ir_call
*call
= ir
->as_call();
78 if (call
&& can_inline(call
))
85 do_function_inlining(exec_list
*instructions
)
87 ir_function_inlining_visitor v
;
89 do_expression_flattening(instructions
, automatic_inlining_predicate
);
97 replace_return_with_assignment(ir_instruction
*ir
, void *data
)
99 void *ctx
= talloc_parent(ir
);
100 ir_variable
*retval
= (ir_variable
*)data
;
101 ir_return
*ret
= ir
->as_return();
105 ir_rvalue
*lhs
= new(ctx
) ir_dereference_variable(retval
);
106 ret
->insert_before(new(ctx
) ir_assignment(lhs
, ret
->value
, NULL
));
109 /* un-valued return has to be the last return, or we shouldn't
110 * have reached here. (see can_inline()).
112 assert(!ret
->next
->is_tail_sentinal());
118 ir_call::generate_inline(ir_instruction
*next_ir
)
120 void *ctx
= talloc_parent(this);
121 ir_variable
**parameters
;
124 ir_variable
*retval
= NULL
;
125 struct hash_table
*ht
;
127 ht
= hash_table_ctor(0, hash_func
, hash_compare_func
);
130 foreach_iter(exec_list_iterator
, iter_sig
, this->callee
->parameters
)
133 parameters
= new ir_variable
*[num_parameters
];
135 /* Generate storage for the return value. */
136 if (this->callee
->return_type
) {
137 retval
= new(ctx
) ir_variable(this->callee
->return_type
, "__retval");
138 next_ir
->insert_before(retval
);
141 /* Generate the declarations for the parameters to our inlined code,
142 * and set up the mapping of real function body variables to ours.
145 exec_list_iterator sig_param_iter
= this->callee
->parameters
.iterator();
146 exec_list_iterator param_iter
= this->actual_parameters
.iterator();
147 for (i
= 0; i
< num_parameters
; i
++) {
148 const ir_variable
*const sig_param
= (ir_variable
*) sig_param_iter
.get();
149 ir_rvalue
*param
= (ir_rvalue
*) param_iter
.get();
151 /* Generate a new variable for the parameter. */
152 parameters
[i
] = (ir_variable
*)sig_param
->clone(ht
);
153 parameters
[i
]->mode
= ir_var_auto
;
154 next_ir
->insert_before(parameters
[i
]);
156 /* Move the actual param into our param variable if it's an 'in' type. */
157 if (sig_param
->mode
== ir_var_in
||
158 sig_param
->mode
== ir_var_inout
) {
159 ir_assignment
*assign
;
161 assign
= new(ctx
) ir_assignment(new(ctx
) ir_dereference_variable(parameters
[i
]),
163 next_ir
->insert_before(assign
);
166 sig_param_iter
.next();
170 /* Generate the inlined body of the function. */
171 foreach_iter(exec_list_iterator
, iter
, callee
->body
) {
172 ir_instruction
*ir
= (ir_instruction
*)iter
.get();
173 ir_instruction
*new_ir
= ir
->clone(ht
);
175 next_ir
->insert_before(new_ir
);
176 visit_tree(new_ir
, replace_return_with_assignment
, retval
);
179 /* Copy back the value of any 'out' parameters from the function body
180 * variables to our own.
183 param_iter
= this->actual_parameters
.iterator();
184 for (i
= 0; i
< num_parameters
; i
++) {
185 ir_instruction
*const param
= (ir_instruction
*) param_iter
.get();
187 /* Move our param variable into the actual param if it's an 'out' type. */
188 if (parameters
[i
]->mode
== ir_var_out
||
189 parameters
[i
]->mode
== ir_var_inout
) {
190 ir_assignment
*assign
;
192 assign
= new(ctx
) ir_assignment(param
->as_rvalue(),
193 new(ctx
) ir_dereference_variable(parameters
[i
]),
195 next_ir
->insert_before(assign
);
201 delete [] parameters
;
206 return new(ctx
) ir_dereference_variable(retval
);
213 ir_function_inlining_visitor::visit_enter(ir_expression
*ir
)
216 return visit_continue_with_parent
;
221 ir_function_inlining_visitor::visit_enter(ir_return
*ir
)
224 return visit_continue_with_parent
;
229 ir_function_inlining_visitor::visit_enter(ir_texture
*ir
)
232 return visit_continue_with_parent
;
237 ir_function_inlining_visitor::visit_enter(ir_swizzle
*ir
)
240 return visit_continue_with_parent
;
245 ir_function_inlining_visitor::visit_enter(ir_call
*ir
)
247 if (can_inline(ir
)) {
248 (void) ir
->generate_inline(ir
);
250 this->progress
= true;
253 return visit_continue
;
258 ir_function_inlining_visitor::visit_enter(ir_assignment
*ir
)
260 ir_call
*call
= ir
->rhs
->as_call();
261 if (!call
|| !can_inline(call
))
262 return visit_continue
;
264 /* generates the parameter setup, function body, and returns the return
265 * value of the function
267 ir_rvalue
*rhs
= call
->generate_inline(ir
);
271 this->progress
= true;
273 return visit_continue
;