3 # Copyright (C) 2014 Intel Corporation
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
12 # The above copyright notice and this permission notice (including the next
13 # paragraph) shall be included in all copies or substantial portions of the
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25 # Jason Ekstrand (jason@jlekstrand.net)
33 # Represents a set of variables, each with a unique id
37 self
.ids
= itertools
.count()
38 self
.immutable
= False;
40 def __getitem__(self
, name
):
41 if name
not in self
.names
:
42 assert not self
.immutable
, "Unknown replacement variable: " + name
43 self
.names
[name
] = self
.ids
.next()
45 return self
.names
[name
]
52 def create(val
, name_base
, varset
):
53 if isinstance(val
, tuple):
54 return Expression(val
, name_base
, varset
)
55 elif isinstance(val
, Expression
):
57 elif isinstance(val
, (str, unicode)):
58 return Variable(val
, name_base
, varset
)
59 elif isinstance(val
, (bool, int, long, float)):
60 return Constant(val
, name_base
)
62 __template
= mako
.template
.Template("""
63 static const ${val.c_type} ${val.name} = {
65 % if isinstance(val, Constant):
66 ${val.type()}, { ${hex(val)} /* ${val.value} */ },
67 % elif isinstance(val, Variable):
68 ${val.index}, /* ${val.var_name} */
69 ${'true' if val.is_constant else 'false'},
70 ${val.type() or 'nir_type_invalid' },
71 % elif isinstance(val, Expression):
72 ${'true' if val.inexact else 'false'},
74 { ${', '.join(src.c_ptr for src in val.sources)} },
78 def __init__(self
, name
, type_str
):
80 self
.type_str
= type_str
84 return "nir_search_value_" + self
.type_str
88 return "nir_search_" + self
.type_str
92 return "&{0}.value".format(self
.name
)
95 return self
.__template
.render(val
=self
,
98 Expression
=Expression
)
100 class Constant(Value
):
101 def __init__(self
, val
, name
):
102 Value
.__init
__(self
, name
, "constant")
106 if isinstance(self
.value
, (bool)):
107 return 'NIR_TRUE' if self
.value
else 'NIR_FALSE'
108 if isinstance(self
.value
, (int, long)):
109 return hex(self
.value
)
110 elif isinstance(self
.value
, float):
111 return hex(struct
.unpack('Q', struct
.pack('d', self
.value
))[0])
116 if isinstance(self
.value
, (bool)):
117 return "nir_type_bool32"
118 elif isinstance(self
.value
, (int, long)):
119 return "nir_type_int"
120 elif isinstance(self
.value
, float):
121 return "nir_type_float"
123 _var_name_re
= re
.compile(r
"(?P<const>#)?(?P<name>\w+)(?:@(?P<type>\w+))?")
125 class Variable(Value
):
126 def __init__(self
, val
, name
, varset
):
127 Value
.__init
__(self
, name
, "variable")
129 m
= _var_name_re
.match(val
)
130 assert m
and m
.group('name') is not None
132 self
.var_name
= m
.group('name')
133 self
.is_constant
= m
.group('const') is not None
134 self
.required_type
= m
.group('type')
136 if self
.required_type
is not None:
137 assert self
.required_type
in ('float', 'bool', 'int', 'unsigned')
139 self
.index
= varset
[self
.var_name
]
142 if self
.required_type
== 'bool':
143 return "nir_type_bool32"
144 elif self
.required_type
in ('int', 'unsigned'):
145 return "nir_type_int"
146 elif self
.required_type
== 'float':
147 return "nir_type_float"
149 _opcode_re
= re
.compile(r
"(?P<inexact>~)?(?P<opcode>\w+)")
151 class Expression(Value
):
152 def __init__(self
, expr
, name_base
, varset
):
153 Value
.__init
__(self
, name_base
, "expression")
154 assert isinstance(expr
, tuple)
156 m
= _opcode_re
.match(expr
[0])
157 assert m
and m
.group('opcode') is not None
159 self
.opcode
= m
.group('opcode')
160 self
.inexact
= m
.group('inexact') is not None
161 self
.sources
= [ Value
.create(src
, "{0}_{1}".format(name_base
, i
), varset
)
162 for (i
, src
) in enumerate(expr
[1:]) ]
165 srcs
= "\n".join(src
.render() for src
in self
.sources
)
166 return srcs
+ super(Expression
, self
).render()
168 _optimization_ids
= itertools
.count()
170 condition_list
= ['true']
172 class SearchAndReplace(object):
173 def __init__(self
, transform
):
174 self
.id = _optimization_ids
.next()
176 search
= transform
[0]
177 replace
= transform
[1]
178 if len(transform
) > 2:
179 self
.condition
= transform
[2]
181 self
.condition
= 'true'
183 if self
.condition
not in condition_list
:
184 condition_list
.append(self
.condition
)
185 self
.condition_index
= condition_list
.index(self
.condition
)
188 if isinstance(search
, Expression
):
191 self
.search
= Expression(search
, "search{0}".format(self
.id), varset
)
195 if isinstance(replace
, Value
):
196 self
.replace
= replace
198 self
.replace
= Value
.create(replace
, "replace{0}".format(self
.id), varset
)
200 _algebraic_pass_template
= mako
.template
.Template("""
202 #include "nir_search.h"
204 #ifndef NIR_OPT_ALGEBRAIC_STRUCT_DEFS
205 #define NIR_OPT_ALGEBRAIC_STRUCT_DEFS
208 const nir_search_expression *search;
209 const nir_search_value *replace;
210 unsigned condition_offset;
216 const bool *condition_flags;
221 % for (opcode, xform_list) in xform_dict.iteritems():
222 % for xform in xform_list:
223 ${xform.search.render()}
224 ${xform.replace.render()}
227 static const struct transform ${pass_name}_${opcode}_xforms[] = {
228 % for xform in xform_list:
229 { &${xform.search.name}, ${xform.replace.c_ptr}, ${xform.condition_index} },
235 ${pass_name}_block(nir_block *block, void *void_state)
237 struct opt_state *state = void_state;
239 nir_foreach_instr_reverse_safe(block, instr) {
240 if (instr->type != nir_instr_type_alu)
243 nir_alu_instr *alu = nir_instr_as_alu(instr);
244 if (!alu->dest.dest.is_ssa)
248 % for opcode in xform_dict.keys():
249 case nir_op_${opcode}:
250 for (unsigned i = 0; i < ARRAY_SIZE(${pass_name}_${opcode}_xforms); i++) {
251 const struct transform *xform = &${pass_name}_${opcode}_xforms[i];
252 if (state->condition_flags[xform->condition_offset] &&
253 nir_replace_instr(alu, xform->search, xform->replace,
255 state->progress = true;
270 ${pass_name}_impl(nir_function_impl *impl, const bool *condition_flags)
272 struct opt_state state;
274 state.mem_ctx = ralloc_parent(impl);
275 state.progress = false;
276 state.condition_flags = condition_flags;
278 nir_foreach_block_reverse(impl, ${pass_name}_block, &state);
281 nir_metadata_preserve(impl, nir_metadata_block_index |
282 nir_metadata_dominance);
284 return state.progress;
289 ${pass_name}(nir_shader *shader)
291 bool progress = false;
292 bool condition_flags[${len(condition_list)}];
293 const nir_shader_compiler_options *options = shader->options;
296 % for index, condition in enumerate(condition_list):
297 condition_flags[${index}] = ${condition};
300 nir_foreach_function(shader, function) {
302 progress |= ${pass_name}_impl(function->impl, condition_flags);
309 class AlgebraicPass(object):
310 def __init__(self
, pass_name
, transforms
):
312 self
.pass_name
= pass_name
314 for xform
in transforms
:
315 if not isinstance(xform
, SearchAndReplace
):
316 xform
= SearchAndReplace(xform
)
318 if xform
.search
.opcode
not in self
.xform_dict
:
319 self
.xform_dict
[xform
.search
.opcode
] = []
321 self
.xform_dict
[xform
.search
.opcode
].append(xform
)
324 return _algebraic_pass_template
.render(pass_name
=self
.pass_name
,
325 xform_dict
=self
.xform_dict
,
326 condition_list
=condition_list
)