nir: define behavior of nir_op_bfm and nir_op_u/ibfe according to SM5 spec.
[mesa.git] / src / compiler / nir / nir_opt_algebraic.py
1 #
2 # Copyright (C) 2014 Intel Corporation
3 #
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:
10 #
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
13 # Software.
14 #
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 DEALINGS
21 # IN THE SOFTWARE.
22 #
23 # Authors:
24 # Jason Ekstrand (jason@jlekstrand.net)
25
26 from __future__ import print_function
27
28 from collections import OrderedDict
29 import nir_algebraic
30 from nir_opcodes import type_sizes
31 import itertools
32
33 # Convenience variables
34 a = 'a'
35 b = 'b'
36 c = 'c'
37 d = 'd'
38 e = 'e'
39
40 # Written in the form (<search>, <replace>) where <search> is an expression
41 # and <replace> is either an expression or a value. An expression is
42 # defined as a tuple of the form ([~]<op>, <src0>, <src1>, <src2>, <src3>)
43 # where each source is either an expression or a value. A value can be
44 # either a numeric constant or a string representing a variable name.
45 #
46 # If the opcode in a search expression is prefixed by a '~' character, this
47 # indicates that the operation is inexact. Such operations will only get
48 # applied to SSA values that do not have the exact bit set. This should be
49 # used by by any optimizations that are not bit-for-bit exact. It should not,
50 # however, be used for backend-requested lowering operations as those need to
51 # happen regardless of precision.
52 #
53 # Variable names are specified as "[#]name[@type][(cond)]" where "#" inicates
54 # that the given variable will only match constants and the type indicates that
55 # the given variable will only match values from ALU instructions with the
56 # given output type, and (cond) specifies an additional condition function
57 # (see nir_search_helpers.h).
58 #
59 # For constants, you have to be careful to make sure that it is the right
60 # type because python is unaware of the source and destination types of the
61 # opcodes.
62 #
63 # All expression types can have a bit-size specified. For opcodes, this
64 # looks like "op@32", for variables it is "a@32" or "a@uint32" to specify a
65 # type and size. In the search half of the expression this indicates that it
66 # should only match that particular bit-size. In the replace half of the
67 # expression this indicates that the constructed value should have that
68 # bit-size.
69
70 optimizations = [
71
72 (('imul', a, '#b@32(is_pos_power_of_two)'), ('ishl', a, ('find_lsb', b)), '!options->lower_bitshift'),
73 (('imul', a, '#b@32(is_neg_power_of_two)'), ('ineg', ('ishl', a, ('find_lsb', ('iabs', b)))), '!options->lower_bitshift'),
74 (('ishl', a, '#b@32'), ('imul', a, ('ishl', 1, b)), 'options->lower_bitshift'),
75
76 (('unpack_64_2x32_split_x', ('imul_2x32_64(is_used_once)', a, b)), ('imul', a, b)),
77 (('unpack_64_2x32_split_x', ('umul_2x32_64(is_used_once)', a, b)), ('imul', a, b)),
78 (('imul_2x32_64', a, b), ('pack_64_2x32_split', ('imul', a, b), ('imul_high', a, b)), 'options->lower_mul_2x32_64'),
79 (('umul_2x32_64', a, b), ('pack_64_2x32_split', ('imul', a, b), ('umul_high', a, b)), 'options->lower_mul_2x32_64'),
80 (('udiv', a, 1), a),
81 (('idiv', a, 1), a),
82 (('umod', a, 1), 0),
83 (('imod', a, 1), 0),
84 (('udiv', a, '#b@32(is_pos_power_of_two)'), ('ushr', a, ('find_lsb', b)), '!options->lower_bitshift'),
85 (('idiv', a, '#b@32(is_pos_power_of_two)'), ('imul', ('isign', a), ('ushr', ('iabs', a), ('find_lsb', b))), 'options->lower_idiv'),
86 (('idiv', a, '#b@32(is_neg_power_of_two)'), ('ineg', ('imul', ('isign', a), ('ushr', ('iabs', a), ('find_lsb', ('iabs', b))))), 'options->lower_idiv'),
87 (('umod', a, '#b(is_pos_power_of_two)'), ('iand', a, ('isub', b, 1))),
88
89 (('fneg', ('fneg', a)), a),
90 (('ineg', ('ineg', a)), a),
91 (('fabs', ('fabs', a)), ('fabs', a)),
92 (('fabs', ('fneg', a)), ('fabs', a)),
93 (('fabs', ('u2f', a)), ('u2f', a)),
94 (('iabs', ('iabs', a)), ('iabs', a)),
95 (('iabs', ('ineg', a)), ('iabs', a)),
96 (('f2b', ('fneg', a)), ('f2b', a)),
97 (('i2b', ('ineg', a)), ('i2b', a)),
98 (('~fadd', a, 0.0), a),
99 (('iadd', a, 0), a),
100 (('usadd_4x8', a, 0), a),
101 (('usadd_4x8', a, ~0), ~0),
102 (('~fadd', ('fmul', a, b), ('fmul', a, c)), ('fmul', a, ('fadd', b, c))),
103 (('iadd', ('imul', a, b), ('imul', a, c)), ('imul', a, ('iadd', b, c))),
104 (('~fadd', ('fneg', a), a), 0.0),
105 (('iadd', ('ineg', a), a), 0),
106 (('iadd', ('ineg', a), ('iadd', a, b)), b),
107 (('iadd', a, ('iadd', ('ineg', a), b)), b),
108 (('~fadd', ('fneg', a), ('fadd', a, b)), b),
109 (('~fadd', a, ('fadd', ('fneg', a), b)), b),
110 (('fadd', ('fsat', a), ('fsat', ('fneg', a))), ('fsat', ('fabs', a))),
111 (('~fmul', a, 0.0), 0.0),
112 (('imul', a, 0), 0),
113 (('umul_unorm_4x8', a, 0), 0),
114 (('umul_unorm_4x8', a, ~0), a),
115 (('fmul', a, 1.0), a),
116 (('imul', a, 1), a),
117 (('fmul', a, -1.0), ('fneg', a)),
118 (('imul', a, -1), ('ineg', a)),
119 # If a < 0: fsign(a)*a*a => -1*a*a => -a*a => abs(a)*a
120 # If a > 0: fsign(a)*a*a => 1*a*a => a*a => abs(a)*a
121 # If a == 0: fsign(a)*a*a => 0*0*0 => abs(0)*0
122 (('fmul', ('fsign', a), ('fmul', a, a)), ('fmul', ('fabs', a), a)),
123 (('fmul', ('fmul', ('fsign', a), a), a), ('fmul', ('fabs', a), a)),
124 (('~ffma', 0.0, a, b), b),
125 (('~ffma', a, b, 0.0), ('fmul', a, b)),
126 (('ffma', 1.0, a, b), ('fadd', a, b)),
127 (('ffma', -1.0, a, b), ('fadd', ('fneg', a), b)),
128 (('~flrp', a, b, 0.0), a),
129 (('~flrp', a, b, 1.0), b),
130 (('~flrp', a, a, b), a),
131 (('~flrp', 0.0, a, b), ('fmul', a, b)),
132
133 # flrp(a, a + b, c) => a + flrp(0, b, c) => a + (b * c)
134 (('~flrp', a, ('fadd(is_used_once)', a, b), c), ('fadd', ('fmul', b, c), a)),
135 (('~flrp@32', a, ('fadd', a, b), c), ('fadd', ('fmul', b, c), a), 'options->lower_flrp32'),
136 (('~flrp@64', a, ('fadd', a, b), c), ('fadd', ('fmul', b, c), a), 'options->lower_flrp64'),
137
138 (('~flrp@32', ('fadd', a, b), ('fadd', a, c), d), ('fadd', ('flrp', b, c, d), a), 'options->lower_flrp32'),
139 (('~flrp@64', ('fadd', a, b), ('fadd', a, c), d), ('fadd', ('flrp', b, c, d), a), 'options->lower_flrp64'),
140
141 (('~flrp@32', a, ('fmul(is_used_once)', a, b), c), ('fmul', ('flrp', 1.0, b, c), a), 'options->lower_flrp32'),
142 (('~flrp@64', a, ('fmul(is_used_once)', a, b), c), ('fmul', ('flrp', 1.0, b, c), a), 'options->lower_flrp64'),
143
144 (('~flrp', ('fmul(is_used_once)', a, b), ('fmul(is_used_once)', a, c), d), ('fmul', ('flrp', b, c, d), a)),
145
146 (('~flrp', a, b, ('b2f', 'c@1')), ('bcsel', c, b, a), 'options->lower_flrp32'),
147 (('~flrp', a, 0.0, c), ('fadd', ('fmul', ('fneg', a), c), a)),
148 (('ftrunc', a), ('bcsel', ('flt', a, 0.0), ('fneg', ('ffloor', ('fabs', a))), ('ffloor', ('fabs', a))), 'options->lower_ftrunc'),
149 (('ffloor', a), ('fsub', a, ('ffract', a)), 'options->lower_ffloor'),
150 (('fadd', a, ('fneg', ('ffract', a))), ('ffloor', a), '!options->lower_ffloor'),
151 (('ffract', a), ('fsub', a, ('ffloor', a)), 'options->lower_ffract'),
152 (('fceil', a), ('fneg', ('ffloor', ('fneg', a))), 'options->lower_fceil'),
153 (('~fadd', ('fmul', a, ('fadd', 1.0, ('fneg', ('b2f', 'c@1')))), ('fmul', b, ('b2f', c))), ('bcsel', c, b, a), 'options->lower_flrp32'),
154 (('~fadd@32', ('fmul', a, ('fadd', 1.0, ('fneg', c ) )), ('fmul', b, c )), ('flrp', a, b, c), '!options->lower_flrp32'),
155 (('~fadd@64', ('fmul', a, ('fadd', 1.0, ('fneg', c ) )), ('fmul', b, c )), ('flrp', a, b, c), '!options->lower_flrp64'),
156 # These are the same as the previous three rules, but it depends on
157 # 1-fsat(x) <=> fsat(1-x). See below.
158 (('~fadd@32', ('fmul', a, ('fsat', ('fadd', 1.0, ('fneg', c )))), ('fmul', b, ('fsat', c))), ('flrp', a, b, ('fsat', c)), '!options->lower_flrp32'),
159 (('~fadd@64', ('fmul', a, ('fsat', ('fadd', 1.0, ('fneg', c )))), ('fmul', b, ('fsat', c))), ('flrp', a, b, ('fsat', c)), '!options->lower_flrp64'),
160
161 (('~fadd', a, ('fmul', ('b2f', 'c@1'), ('fadd', b, ('fneg', a)))), ('bcsel', c, b, a), 'options->lower_flrp32'),
162 (('~fadd@32', a, ('fmul', c , ('fadd', b, ('fneg', a)))), ('flrp', a, b, c), '!options->lower_flrp32'),
163 (('~fadd@64', a, ('fmul', c , ('fadd', b, ('fneg', a)))), ('flrp', a, b, c), '!options->lower_flrp64'),
164 (('ffma', a, b, c), ('fadd', ('fmul', a, b), c), 'options->lower_ffma'),
165 (('~fadd', ('fmul', a, b), c), ('ffma', a, b, c), 'options->fuse_ffma'),
166
167 (('~fmul', ('fadd', ('iand', ('ineg', ('b2i32', 'a@bool')), ('fmul', b, c)), '#d'), '#e'),
168 ('bcsel', a, ('fmul', ('fadd', ('fmul', b, c), d), e), ('fmul', d, e))),
169
170 (('fdot4', ('vec4', a, b, c, 1.0), d), ('fdph', ('vec3', a, b, c), d)),
171 (('fdot4', ('vec4', a, 0.0, 0.0, 0.0), b), ('fmul', a, b)),
172 (('fdot4', ('vec4', a, b, 0.0, 0.0), c), ('fdot2', ('vec2', a, b), c)),
173 (('fdot4', ('vec4', a, b, c, 0.0), d), ('fdot3', ('vec3', a, b, c), d)),
174
175 (('fdot3', ('vec3', a, 0.0, 0.0), b), ('fmul', a, b)),
176 (('fdot3', ('vec3', a, b, 0.0), c), ('fdot2', ('vec2', a, b), c)),
177
178 # If x >= 0 and x <= 1: fsat(1 - x) == 1 - fsat(x) trivially
179 # If x < 0: 1 - fsat(x) => 1 - 0 => 1 and fsat(1 - x) => fsat(> 1) => 1
180 # If x > 1: 1 - fsat(x) => 1 - 1 => 0 and fsat(1 - x) => fsat(< 0) => 0
181 (('~fadd', ('fneg(is_used_once)', ('fsat(is_used_once)', 'a(is_not_fmul)')), 1.0), ('fsat', ('fadd', 1.0, ('fneg', a)))),
182
183 # (a * #b + #c) << #d
184 # ((a * #b) << #d) + (#c << #d)
185 # (a * (#b << #d)) + (#c << #d)
186 (('ishl', ('iadd', ('imul', a, '#b'), '#c'), '#d'),
187 ('iadd', ('imul', a, ('ishl', b, d)), ('ishl', c, d))),
188
189 # (a * #b) << #c
190 # a * (#b << #c)
191 (('ishl', ('imul', a, '#b'), '#c'), ('imul', a, ('ishl', b, c))),
192
193 # Comparison simplifications
194 (('~inot', ('flt', a, b)), ('fge', a, b)),
195 (('~inot', ('fge', a, b)), ('flt', a, b)),
196 (('~inot', ('feq', a, b)), ('fne', a, b)),
197 (('~inot', ('fne', a, b)), ('feq', a, b)),
198 (('inot', ('ilt', a, b)), ('ige', a, b)),
199 (('inot', ('ult', a, b)), ('uge', a, b)),
200 (('inot', ('ige', a, b)), ('ilt', a, b)),
201 (('inot', ('uge', a, b)), ('ult', a, b)),
202 (('inot', ('ieq', a, b)), ('ine', a, b)),
203 (('inot', ('ine', a, b)), ('ieq', a, b)),
204
205 # This helps some shaders because, after some optimizations, they end up
206 # with patterns like (-a < -b) || (b < a). In an ideal world, this sort of
207 # matching would be handled by CSE.
208 (('flt', ('fneg', a), ('fneg', b)), ('flt', b, a)),
209 (('fge', ('fneg', a), ('fneg', b)), ('fge', b, a)),
210 (('feq', ('fneg', a), ('fneg', b)), ('feq', b, a)),
211 (('fne', ('fneg', a), ('fneg', b)), ('fne', b, a)),
212 (('flt', ('fneg', a), -1.0), ('flt', 1.0, a)),
213 (('flt', -1.0, ('fneg', a)), ('flt', a, 1.0)),
214 (('fge', ('fneg', a), -1.0), ('fge', 1.0, a)),
215 (('fge', -1.0, ('fneg', a)), ('fge', a, 1.0)),
216 (('fne', ('fneg', a), -1.0), ('fne', 1.0, a)),
217 (('feq', -1.0, ('fneg', a)), ('feq', a, 1.0)),
218
219 (('flt', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('flt', a, b)),
220 (('flt', '#b(is_gt_0_and_lt_1)', ('fsat(is_used_once)', a)), ('flt', b, a)),
221 (('fge', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('fge', a, b)),
222 (('fge', '#b(is_gt_0_and_lt_1)', ('fsat(is_used_once)', a)), ('fge', b, a)),
223 (('feq', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('feq', a, b)),
224 (('fne', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('fne', a, b)),
225
226 (('fge', ('fsat(is_used_once)', a), 1.0), ('fge', a, 1.0)),
227 (('flt', ('fsat(is_used_once)', a), 1.0), ('flt', a, 1.0)),
228 (('fge', 0.0, ('fsat(is_used_once)', a)), ('fge', 0.0, a)),
229 (('flt', 0.0, ('fsat(is_used_once)', a)), ('flt', 0.0, a)),
230
231 # 0.0 >= b2f(a)
232 # b2f(a) <= 0.0
233 # b2f(a) == 0.0 because b2f(a) can only be 0 or 1
234 # inot(a)
235 (('fge', 0.0, ('b2f', 'a@1')), ('inot', a)),
236
237 (('fge', ('fneg', ('b2f', 'a@1')), 0.0), ('inot', a)),
238
239 (('fne', ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('ior', a, b)),
240 (('fne', ('fmax', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('ior', a, b)),
241 (('fne', ('bcsel', a, 1.0, ('b2f', 'b@1')) , 0.0), ('ior', a, b)),
242 (('fne', ('b2f', 'a@1'), ('fneg', ('b2f', 'b@1'))), ('ior', a, b)),
243 (('fne', ('fmul', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('iand', a, b)),
244 (('fne', ('fmin', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('iand', a, b)),
245 (('fne', ('bcsel', a, ('b2f', 'b@1'), 0.0) , 0.0), ('iand', a, b)),
246 (('fne', ('fadd', ('b2f', 'a@1'), ('fneg', ('b2f', 'b@1'))), 0.0), ('ixor', a, b)),
247 (('fne', ('b2f', 'a@1') , ('b2f', 'b@1') ), ('ixor', a, b)),
248 (('fne', ('fneg', ('b2f', 'a@1')), ('fneg', ('b2f', 'b@1'))), ('ixor', a, b)),
249 (('feq', ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('inot', ('ior', a, b))),
250 (('feq', ('fmax', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('inot', ('ior', a, b))),
251 (('feq', ('bcsel', a, 1.0, ('b2f', 'b@1')) , 0.0), ('inot', ('ior', a, b))),
252 (('feq', ('b2f', 'a@1'), ('fneg', ('b2f', 'b@1'))), ('inot', ('ior', a, b))),
253 (('feq', ('fmul', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('inot', ('iand', a, b))),
254 (('feq', ('fmin', ('b2f', 'a@1'), ('b2f', 'b@1')), 0.0), ('inot', ('iand', a, b))),
255 (('feq', ('bcsel', a, ('b2f', 'b@1'), 0.0) , 0.0), ('inot', ('iand', a, b))),
256 (('feq', ('fadd', ('b2f', 'a@1'), ('fneg', ('b2f', 'b@1'))), 0.0), ('ieq', a, b)),
257 (('feq', ('b2f', 'a@1') , ('b2f', 'b@1') ), ('ieq', a, b)),
258 (('feq', ('fneg', ('b2f', 'a@1')), ('fneg', ('b2f', 'b@1'))), ('ieq', a, b)),
259
260 # -(b2f(a) + b2f(b)) < 0
261 # 0 < b2f(a) + b2f(b)
262 # 0 != b2f(a) + b2f(b) b2f must be 0 or 1, so the sum is non-negative
263 # a || b
264 (('flt', ('fneg', ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1'))), 0.0), ('ior', a, b)),
265 (('flt', 0.0, ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1'))), ('ior', a, b)),
266
267 # -(b2f(a) + b2f(b)) >= 0
268 # 0 >= b2f(a) + b2f(b)
269 # 0 == b2f(a) + b2f(b) b2f must be 0 or 1, so the sum is non-negative
270 # !(a || b)
271 (('fge', ('fneg', ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1'))), 0.0), ('inot', ('ior', a, b))),
272 (('fge', 0.0, ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1'))), ('inot', ('ior', a, b))),
273
274 (('flt', a, ('fneg', a)), ('flt', a, 0.0)),
275 (('fge', a, ('fneg', a)), ('fge', a, 0.0)),
276
277 # Some optimizations (below) convert things like (a < b || c < b) into
278 # (min(a, c) < b). However, this interfers with the previous optimizations
279 # that try to remove comparisons with negated sums of b2f. This just
280 # breaks that apart.
281 (('flt', ('fmin', c, ('fneg', ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1')))), 0.0),
282 ('ior', ('flt', c, 0.0), ('ior', a, b))),
283
284 (('~flt', ('fadd', a, b), a), ('flt', b, 0.0)),
285 (('~fge', ('fadd', a, b), a), ('fge', b, 0.0)),
286 (('~feq', ('fadd', a, b), a), ('feq', b, 0.0)),
287 (('~fne', ('fadd', a, b), a), ('fne', b, 0.0)),
288
289 # Cannot remove the addition from ilt or ige due to overflow.
290 (('ieq', ('iadd', a, b), a), ('ieq', b, 0)),
291 (('ine', ('iadd', a, b), a), ('ine', b, 0)),
292
293 # fmin(-b2f(a), b) >= 0.0
294 # -b2f(a) >= 0.0 && b >= 0.0
295 # -b2f(a) == 0.0 && b >= 0.0 -b2f can only be 0 or -1, never >0
296 # b2f(a) == 0.0 && b >= 0.0
297 # a == False && b >= 0.0
298 # !a && b >= 0.0
299 #
300 # The fge in the second replacement is not a typo. I leave the proof that
301 # "fmin(-b2f(a), b) >= 0 <=> fmin(-b2f(a), b) == 0" as an exercise for the
302 # reader.
303 (('fge', ('fmin', ('fneg', ('b2f', 'a@1')), 'b@1'), 0.0), ('iand', ('inot', a), ('fge', b, 0.0))),
304 (('feq', ('fmin', ('fneg', ('b2f', 'a@1')), 'b@1'), 0.0), ('iand', ('inot', a), ('fge', b, 0.0))),
305
306 (('feq', ('b2f', 'a@1'), 0.0), ('inot', a)),
307 (('fne', ('b2f', 'a@1'), 0.0), a),
308 (('ieq', ('b2i', 'a@1'), 0), ('inot', a)),
309 (('ine', ('b2i', 'a@1'), 0), a),
310
311 (('fne', ('u2f', a), 0.0), ('ine', a, 0)),
312 (('feq', ('u2f', a), 0.0), ('ieq', a, 0)),
313 (('fge', ('u2f', a), 0.0), True),
314 (('fge', 0.0, ('u2f', a)), ('uge', 0, a)), # ieq instead?
315 (('flt', ('u2f', a), 0.0), False),
316 (('flt', 0.0, ('u2f', a)), ('ult', 0, a)), # ine instead?
317 (('fne', ('i2f', a), 0.0), ('ine', a, 0)),
318 (('feq', ('i2f', a), 0.0), ('ieq', a, 0)),
319 (('fge', ('i2f', a), 0.0), ('ige', a, 0)),
320 (('fge', 0.0, ('i2f', a)), ('ige', 0, a)),
321 (('flt', ('i2f', a), 0.0), ('ilt', a, 0)),
322 (('flt', 0.0, ('i2f', a)), ('ilt', 0, a)),
323
324 # 0.0 < fabs(a)
325 # fabs(a) > 0.0
326 # fabs(a) != 0.0 because fabs(a) must be >= 0
327 # a != 0.0
328 (('~flt', 0.0, ('fabs', a)), ('fne', a, 0.0)),
329
330 # -fabs(a) < 0.0
331 # fabs(a) > 0.0
332 (('~flt', ('fneg', ('fabs', a)), 0.0), ('fne', a, 0.0)),
333
334 # 0.0 >= fabs(a)
335 # 0.0 == fabs(a) because fabs(a) must be >= 0
336 # 0.0 == a
337 (('fge', 0.0, ('fabs', a)), ('feq', a, 0.0)),
338
339 # -fabs(a) >= 0.0
340 # 0.0 >= fabs(a)
341 (('fge', ('fneg', ('fabs', a)), 0.0), ('feq', a, 0.0)),
342
343 (('fmax', ('b2f(is_used_once)', 'a@1'), ('b2f', 'b@1')), ('b2f', ('ior', a, b))),
344 (('fmax', ('fneg(is_used_once)', ('b2f(is_used_once)', 'a@1')), ('fneg', ('b2f', 'b@1'))), ('fneg', ('b2f', ('ior', a, b)))),
345 (('fmin', ('b2f(is_used_once)', 'a@1'), ('b2f', 'b@1')), ('b2f', ('iand', a, b))),
346 (('fmin', ('fneg(is_used_once)', ('b2f(is_used_once)', 'a@1')), ('fneg', ('b2f', 'b@1'))), ('fneg', ('b2f', ('iand', a, b)))),
347
348 # fmin(b2f(a), b)
349 # bcsel(a, fmin(b2f(a), b), fmin(b2f(a), b))
350 # bcsel(a, fmin(b2f(True), b), fmin(b2f(False), b))
351 # bcsel(a, fmin(1.0, b), fmin(0.0, b))
352 #
353 # Since b is a constant, constant folding will eliminate the fmin and the
354 # fmax. If b is > 1.0, the bcsel will be replaced with a b2f.
355 (('fmin', ('b2f', 'a@1'), '#b'), ('bcsel', a, ('fmin', b, 1.0), ('fmin', b, 0.0))),
356
357 (('flt', ('fadd(is_used_once)', a, ('fneg', b)), 0.0), ('flt', a, b)),
358
359 (('fge', ('fneg', ('fabs', a)), 0.0), ('feq', a, 0.0)),
360 (('~bcsel', ('flt', b, a), b, a), ('fmin', a, b)),
361 (('~bcsel', ('flt', a, b), b, a), ('fmax', a, b)),
362 (('~bcsel', ('fge', a, b), b, a), ('fmin', a, b)),
363 (('~bcsel', ('fge', b, a), b, a), ('fmax', a, b)),
364 (('bcsel', ('i2b', a), b, c), ('bcsel', ('ine', a, 0), b, c)),
365 (('bcsel', ('inot', a), b, c), ('bcsel', a, c, b)),
366 (('bcsel', a, ('bcsel', a, b, c), d), ('bcsel', a, b, d)),
367 (('bcsel', a, b, ('bcsel', a, c, d)), ('bcsel', a, b, d)),
368 (('bcsel', a, ('bcsel', b, c, d), ('bcsel(is_used_once)', b, c, 'e')), ('bcsel', b, c, ('bcsel', a, d, 'e'))),
369 (('bcsel', a, ('bcsel(is_used_once)', b, c, d), ('bcsel', b, c, 'e')), ('bcsel', b, c, ('bcsel', a, d, 'e'))),
370 (('bcsel', a, ('bcsel', b, c, d), ('bcsel(is_used_once)', b, 'e', d)), ('bcsel', b, ('bcsel', a, c, 'e'), d)),
371 (('bcsel', a, ('bcsel(is_used_once)', b, c, d), ('bcsel', b, 'e', d)), ('bcsel', b, ('bcsel', a, c, 'e'), d)),
372 (('bcsel', a, True, b), ('ior', a, b)),
373 (('bcsel', a, a, b), ('ior', a, b)),
374 (('bcsel', a, b, False), ('iand', a, b)),
375 (('bcsel', a, b, a), ('iand', a, b)),
376 (('fmin', a, a), a),
377 (('fmax', a, a), a),
378 (('imin', a, a), a),
379 (('imax', a, a), a),
380 (('umin', a, a), a),
381 (('umax', a, a), a),
382 (('fmax', ('fmax', a, b), b), ('fmax', a, b)),
383 (('umax', ('umax', a, b), b), ('umax', a, b)),
384 (('imax', ('imax', a, b), b), ('imax', a, b)),
385 (('fmin', ('fmin', a, b), b), ('fmin', a, b)),
386 (('umin', ('umin', a, b), b), ('umin', a, b)),
387 (('imin', ('imin', a, b), b), ('imin', a, b)),
388 (('fmax', a, ('fneg', a)), ('fabs', a)),
389 (('imax', a, ('ineg', a)), ('iabs', a)),
390 (('fmin', a, ('fneg', a)), ('fneg', ('fabs', a))),
391 (('imin', a, ('ineg', a)), ('ineg', ('iabs', a))),
392 (('fmin', a, ('fneg', ('fabs', a))), ('fneg', ('fabs', a))),
393 (('imin', a, ('ineg', ('iabs', a))), ('ineg', ('iabs', a))),
394 (('fmin', a, ('fabs', a)), a),
395 (('imin', a, ('iabs', a)), a),
396 (('fmax', a, ('fneg', ('fabs', a))), a),
397 (('imax', a, ('ineg', ('iabs', a))), a),
398 (('fmax', a, ('fabs', a)), ('fabs', a)),
399 (('imax', a, ('iabs', a)), ('iabs', a)),
400 (('fmax', a, ('fneg', a)), ('fabs', a)),
401 (('imax', a, ('ineg', a)), ('iabs', a)),
402 (('~fmax', ('fabs', a), 0.0), ('fabs', a)),
403 (('~fmin', ('fmax', a, 0.0), 1.0), ('fsat', a), '!options->lower_fsat'),
404 (('~fmax', ('fmin', a, 1.0), 0.0), ('fsat', a), '!options->lower_fsat'),
405 (('~fmin', ('fmax', a, -1.0), 0.0), ('fneg', ('fsat', ('fneg', a))), '!options->lower_negate && !options->lower_fsat'),
406 (('~fmax', ('fmin', a, 0.0), -1.0), ('fneg', ('fsat', ('fneg', a))), '!options->lower_negate && !options->lower_fsat'),
407 (('fsat', ('fsign', a)), ('b2f', ('flt', 0.0, a))),
408 (('fsat', ('b2f', a)), ('b2f', a)),
409 (('fsat', a), ('fmin', ('fmax', a, 0.0), 1.0), 'options->lower_fsat'),
410 (('fsat', ('fsat', a)), ('fsat', a)),
411 (('fsat', ('fneg(is_used_once)', ('fadd(is_used_once)', a, b))), ('fsat', ('fadd', ('fneg', a), ('fneg', b))), '!options->lower_negate && !options->lower_fsat'),
412 (('fsat', ('fneg(is_used_once)', ('fmul(is_used_once)', a, b))), ('fsat', ('fmul', ('fneg', a), b)), '!options->lower_negate && !options->lower_fsat'),
413 (('fsat', ('fabs(is_used_once)', ('fmul(is_used_once)', a, b))), ('fsat', ('fmul', ('fabs', a), ('fabs', b))), '!options->lower_fsat'),
414 (('fmin', ('fmax', ('fmin', ('fmax', a, b), c), b), c), ('fmin', ('fmax', a, b), c)),
415 (('imin', ('imax', ('imin', ('imax', a, b), c), b), c), ('imin', ('imax', a, b), c)),
416 (('umin', ('umax', ('umin', ('umax', a, b), c), b), c), ('umin', ('umax', a, b), c)),
417 (('fmax', ('fsat', a), '#b@32(is_zero_to_one)'), ('fsat', ('fmax', a, b))),
418 (('fmin', ('fsat', a), '#b@32(is_zero_to_one)'), ('fsat', ('fmin', a, b))),
419 (('extract_u8', ('imin', ('imax', a, 0), 0xff), 0), ('imin', ('imax', a, 0), 0xff)),
420 (('~ior', ('flt(is_used_once)', a, b), ('flt', a, c)), ('flt', a, ('fmax', b, c))),
421 (('~ior', ('flt(is_used_once)', a, c), ('flt', b, c)), ('flt', ('fmin', a, b), c)),
422 (('~ior', ('fge(is_used_once)', a, b), ('fge', a, c)), ('fge', a, ('fmin', b, c))),
423 (('~ior', ('fge(is_used_once)', a, c), ('fge', b, c)), ('fge', ('fmax', a, b), c)),
424 (('~ior', ('flt', a, '#b'), ('flt', a, '#c')), ('flt', a, ('fmax', b, c))),
425 (('~ior', ('flt', '#a', c), ('flt', '#b', c)), ('flt', ('fmin', a, b), c)),
426 (('~ior', ('fge', a, '#b'), ('fge', a, '#c')), ('fge', a, ('fmin', b, c))),
427 (('~ior', ('fge', '#a', c), ('fge', '#b', c)), ('fge', ('fmax', a, b), c)),
428 (('~iand', ('flt(is_used_once)', a, b), ('flt', a, c)), ('flt', a, ('fmin', b, c))),
429 (('~iand', ('flt(is_used_once)', a, c), ('flt', b, c)), ('flt', ('fmax', a, b), c)),
430 (('~iand', ('fge(is_used_once)', a, b), ('fge', a, c)), ('fge', a, ('fmax', b, c))),
431 (('~iand', ('fge(is_used_once)', a, c), ('fge', b, c)), ('fge', ('fmin', a, b), c)),
432 (('~iand', ('flt', a, '#b'), ('flt', a, '#c')), ('flt', a, ('fmin', b, c))),
433 (('~iand', ('flt', '#a', c), ('flt', '#b', c)), ('flt', ('fmax', a, b), c)),
434 (('~iand', ('fge', a, '#b'), ('fge', a, '#c')), ('fge', a, ('fmax', b, c))),
435 (('~iand', ('fge', '#a', c), ('fge', '#b', c)), ('fge', ('fmin', a, b), c)),
436
437 (('ior', ('ilt(is_used_once)', a, b), ('ilt', a, c)), ('ilt', a, ('imax', b, c))),
438 (('ior', ('ilt(is_used_once)', a, c), ('ilt', b, c)), ('ilt', ('imin', a, b), c)),
439 (('ior', ('ige(is_used_once)', a, b), ('ige', a, c)), ('ige', a, ('imin', b, c))),
440 (('ior', ('ige(is_used_once)', a, c), ('ige', b, c)), ('ige', ('imax', a, b), c)),
441 (('ior', ('ult(is_used_once)', a, b), ('ult', a, c)), ('ult', a, ('umax', b, c))),
442 (('ior', ('ult(is_used_once)', a, c), ('ult', b, c)), ('ult', ('umin', a, b), c)),
443 (('ior', ('uge(is_used_once)', a, b), ('uge', a, c)), ('uge', a, ('umin', b, c))),
444 (('ior', ('uge(is_used_once)', a, c), ('uge', b, c)), ('uge', ('umax', a, b), c)),
445 (('iand', ('ilt(is_used_once)', a, b), ('ilt', a, c)), ('ilt', a, ('imin', b, c))),
446 (('iand', ('ilt(is_used_once)', a, c), ('ilt', b, c)), ('ilt', ('imax', a, b), c)),
447 (('iand', ('ige(is_used_once)', a, b), ('ige', a, c)), ('ige', a, ('imax', b, c))),
448 (('iand', ('ige(is_used_once)', a, c), ('ige', b, c)), ('ige', ('imin', a, b), c)),
449 (('iand', ('ult(is_used_once)', a, b), ('ult', a, c)), ('ult', a, ('umin', b, c))),
450 (('iand', ('ult(is_used_once)', a, c), ('ult', b, c)), ('ult', ('umax', a, b), c)),
451 (('iand', ('uge(is_used_once)', a, b), ('uge', a, c)), ('uge', a, ('umax', b, c))),
452 (('iand', ('uge(is_used_once)', a, c), ('uge', b, c)), ('uge', ('umin', a, b), c)),
453
454 # Common pattern like 'if (i == 0 || i == 1 || ...)'
455 (('ior', ('ieq', a, 0), ('ieq', a, 1)), ('uge', 1, a)),
456 (('ior', ('uge', 1, a), ('ieq', a, 2)), ('uge', 2, a)),
457 (('ior', ('uge', 2, a), ('ieq', a, 3)), ('uge', 3, a)),
458
459 # The (i2f32, ...) part is an open-coded fsign. When that is combined with
460 # the bcsel, it's basically copysign(1.0, a). There is no copysign in NIR,
461 # so emit an open-coded version of that.
462 (('bcsel@32', ('feq', a, 0.0), 1.0, ('i2f32', ('iadd', ('b2i32', ('flt', 0.0, 'a@32')), ('ineg', ('b2i32', ('flt', 'a@32', 0.0)))))),
463 ('ior', 0x3f800000, ('iand', a, 0x80000000))),
464
465 (('ior', a, ('ieq', a, False)), True),
466 (('ior', a, ('inot', a)), -1),
467
468 (('ine', ('ineg', ('b2i32', 'a@1')), ('ineg', ('b2i32', 'b@1'))), ('ine', a, b)),
469 (('b2i32', ('ine', 'a@1', 'b@1')), ('b2i32', ('ixor', a, b))),
470
471 (('iand', ('ieq', 'a@32', 0), ('ieq', 'b@32', 0)), ('ieq', ('ior', 'a@32', 'b@32'), 0)),
472
473 # These patterns can result when (a < b || a < c) => (a < min(b, c))
474 # transformations occur before constant propagation and loop-unrolling.
475 (('~flt', a, ('fmax', b, a)), ('flt', a, b)),
476 (('~flt', ('fmin', a, b), a), ('flt', b, a)),
477 (('~fge', a, ('fmin', b, a)), True),
478 (('~fge', ('fmax', a, b), a), True),
479 (('~flt', a, ('fmin', b, a)), False),
480 (('~flt', ('fmax', a, b), a), False),
481 (('~fge', a, ('fmax', b, a)), ('fge', a, b)),
482 (('~fge', ('fmin', a, b), a), ('fge', b, a)),
483
484 (('ilt', a, ('imax', b, a)), ('ilt', a, b)),
485 (('ilt', ('imin', a, b), a), ('ilt', b, a)),
486 (('ige', a, ('imin', b, a)), True),
487 (('ige', ('imax', a, b), a), True),
488 (('ult', a, ('umax', b, a)), ('ult', a, b)),
489 (('ult', ('umin', a, b), a), ('ult', b, a)),
490 (('uge', a, ('umin', b, a)), True),
491 (('uge', ('umax', a, b), a), True),
492 (('ilt', a, ('imin', b, a)), False),
493 (('ilt', ('imax', a, b), a), False),
494 (('ige', a, ('imax', b, a)), ('ige', a, b)),
495 (('ige', ('imin', a, b), a), ('ige', b, a)),
496 (('ult', a, ('umin', b, a)), False),
497 (('ult', ('umax', a, b), a), False),
498 (('uge', a, ('umax', b, a)), ('uge', a, b)),
499 (('uge', ('umin', a, b), a), ('uge', b, a)),
500 (('ult', a, ('iand', b, a)), False),
501 (('ult', ('ior', a, b), a), False),
502 (('uge', a, ('iand', b, a)), True),
503 (('uge', ('ior', a, b), a), True),
504
505 (('ilt', '#a', ('imax', '#b', c)), ('ior', ('ilt', a, b), ('ilt', a, c))),
506 (('ilt', ('imin', '#a', b), '#c'), ('ior', ('ilt', a, c), ('ilt', b, c))),
507 (('ige', '#a', ('imin', '#b', c)), ('ior', ('ige', a, b), ('ige', a, c))),
508 (('ige', ('imax', '#a', b), '#c'), ('ior', ('ige', a, c), ('ige', b, c))),
509 (('ult', '#a', ('umax', '#b', c)), ('ior', ('ult', a, b), ('ult', a, c))),
510 (('ult', ('umin', '#a', b), '#c'), ('ior', ('ult', a, c), ('ult', b, c))),
511 (('uge', '#a', ('umin', '#b', c)), ('ior', ('uge', a, b), ('uge', a, c))),
512 (('uge', ('umax', '#a', b), '#c'), ('ior', ('uge', a, c), ('uge', b, c))),
513 (('ilt', '#a', ('imin', '#b', c)), ('iand', ('ilt', a, b), ('ilt', a, c))),
514 (('ilt', ('imax', '#a', b), '#c'), ('iand', ('ilt', a, c), ('ilt', b, c))),
515 (('ige', '#a', ('imax', '#b', c)), ('iand', ('ige', a, b), ('ige', a, c))),
516 (('ige', ('imin', '#a', b), '#c'), ('iand', ('ige', a, c), ('ige', b, c))),
517 (('ult', '#a', ('umin', '#b', c)), ('iand', ('ult', a, b), ('ult', a, c))),
518 (('ult', ('umax', '#a', b), '#c'), ('iand', ('ult', a, c), ('ult', b, c))),
519 (('uge', '#a', ('umax', '#b', c)), ('iand', ('uge', a, b), ('uge', a, c))),
520 (('uge', ('umin', '#a', b), '#c'), ('iand', ('uge', a, c), ('uge', b, c))),
521
522 # Thanks to sign extension, the ishr(a, b) is negative if and only if a is
523 # negative.
524 (('bcsel', ('ilt', a, 0), ('ineg', ('ishr', a, b)), ('ishr', a, b)),
525 ('iabs', ('ishr', a, b))),
526 (('iabs', ('ishr', ('iabs', a), b)), ('ishr', ('iabs', a), b)),
527
528 (('fabs', ('slt', a, b)), ('slt', a, b)),
529 (('fabs', ('sge', a, b)), ('sge', a, b)),
530 (('fabs', ('seq', a, b)), ('seq', a, b)),
531 (('fabs', ('sne', a, b)), ('sne', a, b)),
532 (('slt', a, b), ('b2f', ('flt', a, b)), 'options->lower_scmp'),
533 (('sge', a, b), ('b2f', ('fge', a, b)), 'options->lower_scmp'),
534 (('seq', a, b), ('b2f', ('feq', a, b)), 'options->lower_scmp'),
535 (('sne', a, b), ('b2f', ('fne', a, b)), 'options->lower_scmp'),
536 (('fne', ('fneg', a), a), ('fne', a, 0.0)),
537 (('feq', ('fneg', a), a), ('feq', a, 0.0)),
538 # Emulating booleans
539 (('imul', ('b2i', 'a@1'), ('b2i', 'b@1')), ('b2i', ('iand', a, b))),
540 (('fmul', ('b2f', 'a@1'), ('b2f', 'b@1')), ('b2f', ('iand', a, b))),
541 (('fsat', ('fadd', ('b2f', 'a@1'), ('b2f', 'b@1'))), ('b2f', ('ior', a, b))),
542 (('iand', 'a@bool32', 1.0), ('b2f', a)),
543 # True/False are ~0 and 0 in NIR. b2i of True is 1, and -1 is ~0 (True).
544 (('ineg', ('b2i32', 'a@32')), a),
545 (('flt', ('fneg', ('b2f', 'a@1')), 0), a), # Generated by TGSI KILL_IF.
546 (('flt', ('fsub', 0.0, ('b2f', 'a@1')), 0), a), # Generated by TGSI KILL_IF.
547 # Comparison with the same args. Note that these are not done for
548 # the float versions because NaN always returns false on float
549 # inequalities.
550 (('ilt', a, a), False),
551 (('ige', a, a), True),
552 (('ieq', a, a), True),
553 (('ine', a, a), False),
554 (('ult', a, a), False),
555 (('uge', a, a), True),
556 # Logical and bit operations
557 (('fand', a, 0.0), 0.0),
558 (('iand', a, a), a),
559 (('iand', a, ~0), a),
560 (('iand', a, 0), 0),
561 (('ior', a, a), a),
562 (('ior', a, 0), a),
563 (('ior', a, True), True),
564 (('fxor', a, a), 0.0),
565 (('ixor', a, a), 0),
566 (('ixor', a, 0), a),
567 (('inot', ('inot', a)), a),
568 (('ior', ('iand', a, b), b), b),
569 (('ior', ('ior', a, b), b), ('ior', a, b)),
570 (('iand', ('ior', a, b), b), b),
571 (('iand', ('iand', a, b), b), ('iand', a, b)),
572 # DeMorgan's Laws
573 (('iand', ('inot', a), ('inot', b)), ('inot', ('ior', a, b))),
574 (('ior', ('inot', a), ('inot', b)), ('inot', ('iand', a, b))),
575 # Shift optimizations
576 (('ishl', 0, a), 0),
577 (('ishl', a, 0), a),
578 (('ishr', 0, a), 0),
579 (('ishr', a, 0), a),
580 (('ushr', 0, a), 0),
581 (('ushr', a, 0), a),
582 (('iand', 0xff, ('ushr@32', a, 24)), ('ushr', a, 24)),
583 (('iand', 0xffff, ('ushr@32', a, 16)), ('ushr', a, 16)),
584 # Exponential/logarithmic identities
585 (('~fexp2', ('flog2', a)), a), # 2^lg2(a) = a
586 (('~flog2', ('fexp2', a)), a), # lg2(2^a) = a
587 (('fpow', a, b), ('fexp2', ('fmul', ('flog2', a), b)), 'options->lower_fpow'), # a^b = 2^(lg2(a)*b)
588 (('~fexp2', ('fmul', ('flog2', a), b)), ('fpow', a, b), '!options->lower_fpow'), # 2^(lg2(a)*b) = a^b
589 (('~fexp2', ('fadd', ('fmul', ('flog2', a), b), ('fmul', ('flog2', c), d))),
590 ('~fmul', ('fpow', a, b), ('fpow', c, d)), '!options->lower_fpow'), # 2^(lg2(a) * b + lg2(c) + d) = a^b * c^d
591 (('~fexp2', ('fmul', ('flog2', a), 2.0)), ('fmul', a, a)),
592 (('~fexp2', ('fmul', ('flog2', a), 4.0)), ('fmul', ('fmul', a, a), ('fmul', a, a))),
593 (('~fpow', a, 1.0), a),
594 (('~fpow', a, 2.0), ('fmul', a, a)),
595 (('~fpow', a, 4.0), ('fmul', ('fmul', a, a), ('fmul', a, a))),
596 (('~fpow', 2.0, a), ('fexp2', a)),
597 (('~fpow', ('fpow', a, 2.2), 0.454545), a),
598 (('~fpow', ('fabs', ('fpow', a, 2.2)), 0.454545), ('fabs', a)),
599 (('~fsqrt', ('fexp2', a)), ('fexp2', ('fmul', 0.5, a))),
600 (('~frcp', ('fexp2', a)), ('fexp2', ('fneg', a))),
601 (('~frsq', ('fexp2', a)), ('fexp2', ('fmul', -0.5, a))),
602 (('~flog2', ('fsqrt', a)), ('fmul', 0.5, ('flog2', a))),
603 (('~flog2', ('frcp', a)), ('fneg', ('flog2', a))),
604 (('~flog2', ('frsq', a)), ('fmul', -0.5, ('flog2', a))),
605 (('~flog2', ('fpow', a, b)), ('fmul', b, ('flog2', a))),
606 (('~fmul', ('fexp2(is_used_once)', a), ('fexp2(is_used_once)', b)), ('fexp2', ('fadd', a, b))),
607 (('bcsel', ('flt', a, 0.0), 0.0, ('fsqrt', a)), ('fsqrt', ('fmax', a, 0.0))),
608 # Division and reciprocal
609 (('~fdiv', 1.0, a), ('frcp', a)),
610 (('fdiv', a, b), ('fmul', a, ('frcp', b)), 'options->lower_fdiv'),
611 (('~frcp', ('frcp', a)), a),
612 (('~frcp', ('fsqrt', a)), ('frsq', a)),
613 (('fsqrt', a), ('frcp', ('frsq', a)), 'options->lower_fsqrt'),
614 (('~frcp', ('frsq', a)), ('fsqrt', a), '!options->lower_fsqrt'),
615 # Boolean simplifications
616 (('i2b32(is_used_by_if)', a), ('ine32', a, 0)),
617 (('i2b1(is_used_by_if)', a), ('ine', a, 0)),
618 (('ieq', a, True), a),
619 (('ine(is_not_used_by_if)', a, True), ('inot', a)),
620 (('ine', a, False), a),
621 (('ieq(is_not_used_by_if)', a, False), ('inot', 'a')),
622 (('bcsel', a, True, False), a),
623 (('bcsel', a, False, True), ('inot', a)),
624 (('bcsel@32', a, 1.0, 0.0), ('b2f', a)),
625 (('bcsel@32', a, 0.0, 1.0), ('b2f', ('inot', a))),
626 (('bcsel@32', a, -1.0, -0.0), ('fneg', ('b2f', a))),
627 (('bcsel@32', a, -0.0, -1.0), ('fneg', ('b2f', ('inot', a)))),
628 (('bcsel', True, b, c), b),
629 (('bcsel', False, b, c), c),
630 (('bcsel', a, ('b2f(is_used_once)', 'b@32'), ('b2f', 'c@32')), ('b2f', ('bcsel', a, b, c))),
631
632 (('bcsel', a, b, b), b),
633 (('fcsel', a, b, b), b),
634
635 # D3D Boolean emulation
636 (('bcsel', a, -1, 0), ('ineg', ('b2i', 'a@1'))),
637 (('bcsel', a, 0, -1), ('ineg', ('b2i', ('inot', a)))),
638 (('iand', ('ineg', ('b2i', 'a@1')), ('ineg', ('b2i', 'b@1'))),
639 ('ineg', ('b2i', ('iand', a, b)))),
640 (('ior', ('ineg', ('b2i','a@1')), ('ineg', ('b2i', 'b@1'))),
641 ('ineg', ('b2i', ('ior', a, b)))),
642 (('ieq', ('ineg', ('b2i', 'a@1')), 0), ('inot', a)),
643 (('ieq', ('ineg', ('b2i', 'a@1')), -1), a),
644 (('ine', ('ineg', ('b2i', 'a@1')), 0), a),
645 (('ine', ('ineg', ('b2i', 'a@1')), -1), ('inot', a)),
646 (('iand', ('ineg', ('b2i', a)), 1.0), ('b2f', a)),
647
648 # SM5 32-bit shifts are defined to use the 5 least significant bits
649 (('ishl', 'a@32', ('iand', 31, b)), ('ishl', a, b)),
650 (('ishr', 'a@32', ('iand', 31, b)), ('ishr', a, b)),
651 (('ushr', 'a@32', ('iand', 31, b)), ('ushr', a, b)),
652
653 # Conversions
654 (('i2b32', ('b2i', 'a@32')), a),
655 (('f2i', ('ftrunc', a)), ('f2i', a)),
656 (('f2u', ('ftrunc', a)), ('f2u', a)),
657 (('i2b', ('ineg', a)), ('i2b', a)),
658 (('i2b', ('iabs', a)), ('i2b', a)),
659 (('fabs', ('b2f', a)), ('b2f', a)),
660 (('iabs', ('b2i', a)), ('b2i', a)),
661 (('inot', ('f2b1', a)), ('feq', a, 0.0)),
662
663 # Ironically, mark these as imprecise because removing the conversions may
664 # preserve more precision than doing the conversions (e.g.,
665 # uint(float(0x81818181u)) == 0x81818200).
666 (('~f2i32', ('i2f', 'a@32')), a),
667 (('~f2i32', ('u2f', 'a@32')), a),
668 (('~f2u32', ('i2f', 'a@32')), a),
669 (('~f2u32', ('u2f', 'a@32')), a),
670
671 # Section 5.4.1 (Conversion and Scalar Constructors) of the GLSL 4.60 spec
672 # says:
673 #
674 # It is undefined to convert a negative floating-point value to an
675 # uint.
676 #
677 # Assuming that (uint)some_float behaves like (uint)(int)some_float allows
678 # some optimizations in the i965 backend to proceed.
679 (('ige', ('f2u', a), b), ('ige', ('f2i', a), b)),
680 (('ige', b, ('f2u', a)), ('ige', b, ('f2i', a))),
681 (('ilt', ('f2u', a), b), ('ilt', ('f2i', a), b)),
682 (('ilt', b, ('f2u', a)), ('ilt', b, ('f2i', a))),
683
684 (('~fmin', ('fabs', a), 1.0), ('fsat', ('fabs', a)), '!options->lower_fsat'),
685
686 # The result of the multiply must be in [-1, 0], so the result of the ffma
687 # must be in [0, 1].
688 (('flt', ('fadd', ('fmul', ('fsat', a), ('fneg', ('fsat', a))), 1.0), 0.0), False),
689 (('flt', ('fadd', ('fneg', ('fmul', ('fsat', a), ('fsat', a))), 1.0), 0.0), False),
690 (('fmax', ('fadd', ('fmul', ('fsat', a), ('fneg', ('fsat', a))), 1.0), 0.0), ('fadd', ('fmul', ('fsat', a), ('fneg', ('fsat', a))), 1.0)),
691 (('fmax', ('fadd', ('fneg', ('fmul', ('fsat', a), ('fsat', a))), 1.0), 0.0), ('fadd', ('fneg', ('fmul', ('fsat', a), ('fsat', a))), 1.0)),
692
693 # Packing and then unpacking does nothing
694 (('unpack_64_2x32_split_x', ('pack_64_2x32_split', a, b)), a),
695 (('unpack_64_2x32_split_y', ('pack_64_2x32_split', a, b)), b),
696 (('pack_64_2x32_split', ('unpack_64_2x32_split_x', a),
697 ('unpack_64_2x32_split_y', a)), a),
698
699 # Byte extraction
700 (('ushr', 'a@16', 8), ('extract_u8', a, 1), '!options->lower_extract_byte'),
701 (('ushr', 'a@32', 24), ('extract_u8', a, 3), '!options->lower_extract_byte'),
702 (('ushr', 'a@64', 56), ('extract_u8', a, 7), '!options->lower_extract_byte'),
703 (('ishr', 'a@16', 8), ('extract_i8', a, 1), '!options->lower_extract_byte'),
704 (('ishr', 'a@32', 24), ('extract_i8', a, 3), '!options->lower_extract_byte'),
705 (('ishr', 'a@64', 56), ('extract_i8', a, 7), '!options->lower_extract_byte'),
706 (('iand', 0xff, a), ('extract_u8', a, 0), '!options->lower_extract_byte')
707 ]
708
709 # After the ('extract_u8', a, 0) pattern, above, triggers, there will be
710 # patterns like those below.
711 for op in ('ushr', 'ishr'):
712 optimizations.extend([(('extract_u8', (op, 'a@16', 8), 0), ('extract_u8', a, 1))])
713 optimizations.extend([(('extract_u8', (op, 'a@32', 8 * i), 0), ('extract_u8', a, i)) for i in range(1, 4)])
714 optimizations.extend([(('extract_u8', (op, 'a@64', 8 * i), 0), ('extract_u8', a, i)) for i in range(1, 8)])
715
716 optimizations.extend([(('extract_u8', ('extract_u16', a, 1), 0), ('extract_u8', a, 2))])
717
718 # After the ('extract_[iu]8', a, 3) patterns, above, trigger, there will be
719 # patterns like those below.
720 for op in ('extract_u8', 'extract_i8'):
721 optimizations.extend([((op, ('ishl', 'a@16', 8), 1), (op, a, 0))])
722 optimizations.extend([((op, ('ishl', 'a@32', 24 - 8 * i), 3), (op, a, i)) for i in range(2, -1, -1)])
723 optimizations.extend([((op, ('ishl', 'a@64', 56 - 8 * i), 7), (op, a, i)) for i in range(6, -1, -1)])
724
725 optimizations.extend([
726 # Word extraction
727 (('ushr', ('ishl', 'a@32', 16), 16), ('extract_u16', a, 0), '!options->lower_extract_word'),
728 (('ushr', 'a@32', 16), ('extract_u16', a, 1), '!options->lower_extract_word'),
729 (('ishr', ('ishl', 'a@32', 16), 16), ('extract_i16', a, 0), '!options->lower_extract_word'),
730 (('ishr', 'a@32', 16), ('extract_i16', a, 1), '!options->lower_extract_word'),
731 (('iand', 0xffff, a), ('extract_u16', a, 0), '!options->lower_extract_word'),
732
733 # Subtracts
734 (('~fsub', a, ('fsub', 0.0, b)), ('fadd', a, b)),
735 (('isub', a, ('isub', 0, b)), ('iadd', a, b)),
736 (('ussub_4x8', a, 0), a),
737 (('ussub_4x8', a, ~0), 0),
738 (('fsub', a, b), ('fadd', a, ('fneg', b)), 'options->lower_sub'),
739 (('isub', a, b), ('iadd', a, ('ineg', b)), 'options->lower_sub'),
740 (('fneg', a), ('fsub', 0.0, a), 'options->lower_negate'),
741 (('ineg', a), ('isub', 0, a), 'options->lower_negate'),
742 (('~fadd', a, ('fsub', 0.0, b)), ('fsub', a, b)),
743 (('iadd', a, ('isub', 0, b)), ('isub', a, b)),
744 (('fabs', ('fsub', 0.0, a)), ('fabs', a)),
745 (('iabs', ('isub', 0, a)), ('iabs', a)),
746
747 # Propagate negation up multiplication chains
748 (('fmul(is_used_by_non_fsat)', ('fneg', a), b), ('fneg', ('fmul', a, b))),
749 (('imul', ('ineg', a), b), ('ineg', ('imul', a, b))),
750
751 # Propagate constants up multiplication chains
752 (('~fmul(is_used_once)', ('fmul(is_used_once)', 'a(is_not_const)', 'b(is_not_const)'), '#c'), ('fmul', ('fmul', a, c), b)),
753 (('imul(is_used_once)', ('imul(is_used_once)', 'a(is_not_const)', 'b(is_not_const)'), '#c'), ('imul', ('imul', a, c), b)),
754 (('~fadd(is_used_once)', ('fadd(is_used_once)', 'a(is_not_const)', 'b(is_not_const)'), '#c'), ('fadd', ('fadd', a, c), b)),
755 (('iadd(is_used_once)', ('iadd(is_used_once)', 'a(is_not_const)', 'b(is_not_const)'), '#c'), ('iadd', ('iadd', a, c), b)),
756
757 # Reassociate constants in add/mul chains so they can be folded together.
758 # For now, we mostly only handle cases where the constants are separated by
759 # a single non-constant. We could do better eventually.
760 (('~fmul', '#a', ('fmul', 'b(is_not_const)', '#c')), ('fmul', ('fmul', a, c), b)),
761 (('imul', '#a', ('imul', 'b(is_not_const)', '#c')), ('imul', ('imul', a, c), b)),
762 (('~fadd', '#a', ('fadd', 'b(is_not_const)', '#c')), ('fadd', ('fadd', a, c), b)),
763 (('~fadd', '#a', ('fneg', ('fadd', 'b(is_not_const)', '#c'))), ('fadd', ('fadd', a, ('fneg', c)), ('fneg', b))),
764 (('iadd', '#a', ('iadd', 'b(is_not_const)', '#c')), ('iadd', ('iadd', a, c), b)),
765
766 # By definition...
767 (('bcsel', ('ige', ('find_lsb', a), 0), ('find_lsb', a), -1), ('find_lsb', a)),
768 (('bcsel', ('ige', ('ifind_msb', a), 0), ('ifind_msb', a), -1), ('ifind_msb', a)),
769 (('bcsel', ('ige', ('ufind_msb', a), 0), ('ufind_msb', a), -1), ('ufind_msb', a)),
770
771 (('bcsel', ('ine', a, 0), ('find_lsb', a), -1), ('find_lsb', a)),
772 (('bcsel', ('ine', a, 0), ('ifind_msb', a), -1), ('ifind_msb', a)),
773 (('bcsel', ('ine', a, 0), ('ufind_msb', a), -1), ('ufind_msb', a)),
774
775 (('bcsel', ('ine', a, -1), ('ifind_msb', a), -1), ('ifind_msb', a)),
776
777 # Misc. lowering
778 (('fmod@16', a, b), ('fsub', a, ('fmul', b, ('ffloor', ('fdiv', a, b)))), 'options->lower_fmod'),
779 (('fmod@32', a, b), ('fsub', a, ('fmul', b, ('ffloor', ('fdiv', a, b)))), 'options->lower_fmod'),
780 (('frem', a, b), ('fsub', a, ('fmul', b, ('ftrunc', ('fdiv', a, b)))), 'options->lower_fmod'),
781 (('uadd_carry@32', a, b), ('b2i', ('ult', ('iadd', a, b), a)), 'options->lower_uadd_carry'),
782 (('usub_borrow@32', a, b), ('b2i', ('ult', a, b)), 'options->lower_usub_borrow'),
783
784 (('bitfield_insert', 'base', 'insert', 'offset', 'bits'),
785 ('bcsel', ('ilt', 31, 'bits'), 'insert',
786 ('bfi', ('bfm', 'bits', 'offset'), 'insert', 'base')),
787 'options->lower_bitfield_insert'),
788 (('ihadd', a, b), ('iadd', ('iand', a, b), ('ishr', ('ixor', a, b), 1)), 'options->lower_hadd'),
789 (('uhadd', a, b), ('iadd', ('iand', a, b), ('ushr', ('ixor', a, b), 1)), 'options->lower_hadd'),
790 (('irhadd', a, b), ('isub', ('ior', a, b), ('ishr', ('ixor', a, b), 1)), 'options->lower_hadd'),
791 (('urhadd', a, b), ('isub', ('ior', a, b), ('ushr', ('ixor', a, b), 1)), 'options->lower_hadd'),
792 (('uadd_sat', a, b), ('bcsel', ('ult', ('iadd', a, b), a), -1, ('iadd', a, b)), 'options->lower_add_sat'),
793 (('usub_sat', a, b), ('bcsel', ('ult', a, b), 0, ('isub', a, b)), 'options->lower_add_sat'),
794
795 # Alternative lowering that doesn't rely on bfi.
796 (('bitfield_insert', 'base', 'insert', 'offset', 'bits'),
797 ('ior',
798 ('iand', 'base', ('inot', ('ishl', ('isub', ('ishl', 1, 'bits'), 1), 'offset'))),
799 ('iand', ('ishl', 'insert', 'offset'), ('ishl', ('isub', ('ishl', 1, 'bits'), 1), 'offset'))),
800 'options->lower_bitfield_insert_to_shifts'),
801
802 (('ibitfield_extract', 'value', 'offset', 'bits'),
803 ('bcsel', ('ilt', 31, 'bits'), 'value',
804 ('ibfe', 'value', 'offset', 'bits')),
805 'options->lower_bitfield_extract'),
806
807 (('ubitfield_extract', 'value', 'offset', 'bits'),
808 ('bcsel', ('ult', 31, 'bits'), 'value',
809 ('ubfe', 'value', 'offset', 'bits')),
810 'options->lower_bitfield_extract'),
811
812 (('ibitfield_extract', 'value', 'offset', 'bits'),
813 ('bcsel', ('ieq', 0, 'bits'),
814 0,
815 ('ishr',
816 ('ishl', 'value', ('isub', ('isub', 32, 'bits'), 'offset')),
817 ('isub', 32, 'bits'))),
818 'options->lower_bitfield_extract_to_shifts'),
819
820 (('ubitfield_extract', 'value', 'offset', 'bits'),
821 ('iand',
822 ('ushr', 'value', 'offset'),
823 ('bcsel', ('ieq', 'bits', 32),
824 0xffffffff,
825 ('isub', ('ishl', 1, 'bits'), 1))),
826 'options->lower_bitfield_extract_to_shifts'),
827
828 (('ifind_msb', 'value'),
829 ('ufind_msb', ('bcsel', ('ilt', 'value', 0), ('inot', 'value'), 'value')),
830 'options->lower_ifind_msb'),
831
832 (('find_lsb', 'value'),
833 ('ufind_msb', ('iand', 'value', ('ineg', 'value'))),
834 'options->lower_find_lsb'),
835
836 (('extract_i8', a, 'b@32'),
837 ('ishr', ('ishl', a, ('imul', ('isub', 3, b), 8)), 24),
838 'options->lower_extract_byte'),
839
840 (('extract_u8', a, 'b@32'),
841 ('iand', ('ushr', a, ('imul', b, 8)), 0xff),
842 'options->lower_extract_byte'),
843
844 (('extract_i16', a, 'b@32'),
845 ('ishr', ('ishl', a, ('imul', ('isub', 1, b), 16)), 16),
846 'options->lower_extract_word'),
847
848 (('extract_u16', a, 'b@32'),
849 ('iand', ('ushr', a, ('imul', b, 16)), 0xffff),
850 'options->lower_extract_word'),
851
852 (('pack_unorm_2x16', 'v'),
853 ('pack_uvec2_to_uint',
854 ('f2u32', ('fround_even', ('fmul', ('fsat', 'v'), 65535.0)))),
855 'options->lower_pack_unorm_2x16'),
856
857 (('pack_unorm_4x8', 'v'),
858 ('pack_uvec4_to_uint',
859 ('f2u32', ('fround_even', ('fmul', ('fsat', 'v'), 255.0)))),
860 'options->lower_pack_unorm_4x8'),
861
862 (('pack_snorm_2x16', 'v'),
863 ('pack_uvec2_to_uint',
864 ('f2i32', ('fround_even', ('fmul', ('fmin', 1.0, ('fmax', -1.0, 'v')), 32767.0)))),
865 'options->lower_pack_snorm_2x16'),
866
867 (('pack_snorm_4x8', 'v'),
868 ('pack_uvec4_to_uint',
869 ('f2i32', ('fround_even', ('fmul', ('fmin', 1.0, ('fmax', -1.0, 'v')), 127.0)))),
870 'options->lower_pack_snorm_4x8'),
871
872 (('unpack_unorm_2x16', 'v'),
873 ('fdiv', ('u2f32', ('vec2', ('extract_u16', 'v', 0),
874 ('extract_u16', 'v', 1))),
875 65535.0),
876 'options->lower_unpack_unorm_2x16'),
877
878 (('unpack_unorm_4x8', 'v'),
879 ('fdiv', ('u2f32', ('vec4', ('extract_u8', 'v', 0),
880 ('extract_u8', 'v', 1),
881 ('extract_u8', 'v', 2),
882 ('extract_u8', 'v', 3))),
883 255.0),
884 'options->lower_unpack_unorm_4x8'),
885
886 (('unpack_snorm_2x16', 'v'),
887 ('fmin', 1.0, ('fmax', -1.0, ('fdiv', ('i2f', ('vec2', ('extract_i16', 'v', 0),
888 ('extract_i16', 'v', 1))),
889 32767.0))),
890 'options->lower_unpack_snorm_2x16'),
891
892 (('unpack_snorm_4x8', 'v'),
893 ('fmin', 1.0, ('fmax', -1.0, ('fdiv', ('i2f', ('vec4', ('extract_i8', 'v', 0),
894 ('extract_i8', 'v', 1),
895 ('extract_i8', 'v', 2),
896 ('extract_i8', 'v', 3))),
897 127.0))),
898 'options->lower_unpack_snorm_4x8'),
899
900 (('isign', a), ('imin', ('imax', a, -1), 1), 'options->lower_isign'),
901 (('fsign', a), ('fsub', ('b2f', ('flt', 0.0, a)), ('b2f', ('flt', a, 0.0))), 'options->lower_fsign'),
902 ])
903
904 # bit_size dependent lowerings
905 for bit_size in [8, 16, 32, 64]:
906 # convenience constants
907 intmax = (1 << (bit_size - 1)) - 1
908 intmin = 1 << (bit_size - 1)
909
910 optimizations += [
911 (('iadd_sat@' + str(bit_size), a, b),
912 ('bcsel', ('ige', b, 1), ('bcsel', ('ilt', ('iadd', a, b), a), intmax, ('iadd', a, b)),
913 ('bcsel', ('ilt', a, ('iadd', a, b)), intmin, ('iadd', a, b))), 'options->lower_add_sat'),
914 (('isub_sat@' + str(bit_size), a, b),
915 ('bcsel', ('ilt', b, 0), ('bcsel', ('ilt', ('isub', a, b), a), intmax, ('isub', a, b)),
916 ('bcsel', ('ilt', a, ('isub', a, b)), intmin, ('isub', a, b))), 'options->lower_add_sat'),
917 ]
918
919 invert = OrderedDict([('feq', 'fne'), ('fne', 'feq'), ('fge', 'flt'), ('flt', 'fge')])
920
921 for left, right in itertools.combinations_with_replacement(invert.keys(), 2):
922 optimizations.append((('inot', ('ior(is_used_once)', (left, a, b), (right, c, d))),
923 ('iand', (invert[left], a, b), (invert[right], c, d))))
924 optimizations.append((('inot', ('iand(is_used_once)', (left, a, b), (right, c, d))),
925 ('ior', (invert[left], a, b), (invert[right], c, d))))
926
927 # Optimize x2bN(b2x(x)) -> x
928 for size in type_sizes('bool'):
929 aN = 'a@' + str(size)
930 f2bN = 'f2b' + str(size)
931 i2bN = 'i2b' + str(size)
932 optimizations.append(((f2bN, ('b2f', aN)), a))
933 optimizations.append(((i2bN, ('b2i', aN)), a))
934
935 # Optimize x2yN(b2x(x)) -> b2y
936 for x, y in itertools.product(['f', 'u', 'i'], ['f', 'u', 'i']):
937 if x != 'f' and y != 'f' and x != y:
938 continue
939
940 b2x = 'b2f' if x == 'f' else 'b2i'
941 b2y = 'b2f' if y == 'f' else 'b2i'
942 x2yN = '{}2{}'.format(x, y)
943 optimizations.append(((x2yN, (b2x, a)), (b2y, a)))
944
945 # Optimize away x2xN(a@N)
946 for t in ['int', 'uint', 'float']:
947 for N in type_sizes(t):
948 x2xN = '{0}2{0}{1}'.format(t[0], N)
949 aN = 'a@{0}'.format(N)
950 optimizations.append(((x2xN, aN), a))
951
952 # Optimize x2xN(y2yM(a@P)) -> y2yN(a) for integers
953 # In particular, we can optimize away everything except upcast of downcast and
954 # upcasts where the type differs from the other cast
955 for N, M in itertools.product(type_sizes('uint'), type_sizes('uint')):
956 if N < M:
957 # The outer cast is a down-cast. It doesn't matter what the size of the
958 # argument of the inner cast is because we'll never been in the upcast
959 # of downcast case. Regardless of types, we'll always end up with y2yN
960 # in the end.
961 for x, y in itertools.product(['i', 'u'], ['i', 'u']):
962 x2xN = '{0}2{0}{1}'.format(x, N)
963 y2yM = '{0}2{0}{1}'.format(y, M)
964 y2yN = '{0}2{0}{1}'.format(y, N)
965 optimizations.append(((x2xN, (y2yM, a)), (y2yN, a)))
966 elif N > M:
967 # If the outer cast is an up-cast, we have to be more careful about the
968 # size of the argument of the inner cast and with types. In this case,
969 # the type is always the type of type up-cast which is given by the
970 # outer cast.
971 for P in type_sizes('uint'):
972 # We can't optimize away up-cast of down-cast.
973 if M < P:
974 continue
975
976 # Because we're doing down-cast of down-cast, the types always have
977 # to match between the two casts
978 for x in ['i', 'u']:
979 x2xN = '{0}2{0}{1}'.format(x, N)
980 x2xM = '{0}2{0}{1}'.format(x, M)
981 aP = 'a@{0}'.format(P)
982 optimizations.append(((x2xN, (x2xM, aP)), (x2xN, a)))
983 else:
984 # The N == M case is handled by other optimizations
985 pass
986
987 def fexp2i(exp, bits):
988 # We assume that exp is already in the right range.
989 if bits == 16:
990 return ('i2i16', ('ishl', ('iadd', exp, 15), 10))
991 elif bits == 32:
992 return ('ishl', ('iadd', exp, 127), 23)
993 elif bits == 64:
994 return ('pack_64_2x32_split', 0, ('ishl', ('iadd', exp, 1023), 20))
995 else:
996 assert False
997
998 def ldexp(f, exp, bits):
999 # First, we clamp exp to a reasonable range. The maximum possible range
1000 # for a normal exponent is [-126, 127] and, throwing in denormals, you get
1001 # a maximum range of [-149, 127]. This means that we can potentially have
1002 # a swing of +-276. If you start with FLT_MAX, you actually have to do
1003 # ldexp(FLT_MAX, -278) to get it to flush all the way to zero. The GLSL
1004 # spec, on the other hand, only requires that we handle an exponent value
1005 # in the range [-126, 128]. This implementation is *mostly* correct; it
1006 # handles a range on exp of [-252, 254] which allows you to create any
1007 # value (including denorms if the hardware supports it) and to adjust the
1008 # exponent of any normal value to anything you want.
1009 if bits == 16:
1010 exp = ('imin', ('imax', exp, -28), 30)
1011 elif bits == 32:
1012 exp = ('imin', ('imax', exp, -252), 254)
1013 elif bits == 64:
1014 exp = ('imin', ('imax', exp, -2044), 2046)
1015 else:
1016 assert False
1017
1018 # Now we compute two powers of 2, one for exp/2 and one for exp-exp/2.
1019 # (We use ishr which isn't the same for -1, but the -1 case still works
1020 # since we use exp-exp/2 as the second exponent.) While the spec
1021 # technically defines ldexp as f * 2.0^exp, simply multiplying once doesn't
1022 # work with denormals and doesn't allow for the full swing in exponents
1023 # that you can get with normalized values. Instead, we create two powers
1024 # of two and multiply by them each in turn. That way the effective range
1025 # of our exponent is doubled.
1026 pow2_1 = fexp2i(('ishr', exp, 1), bits)
1027 pow2_2 = fexp2i(('isub', exp, ('ishr', exp, 1)), bits)
1028 return ('fmul', ('fmul', f, pow2_1), pow2_2)
1029
1030 optimizations += [
1031 (('ldexp@16', 'x', 'exp'), ldexp('x', 'exp', 16), 'options->lower_ldexp'),
1032 (('ldexp@32', 'x', 'exp'), ldexp('x', 'exp', 32), 'options->lower_ldexp'),
1033 (('ldexp@64', 'x', 'exp'), ldexp('x', 'exp', 64), 'options->lower_ldexp'),
1034 ]
1035
1036 # Unreal Engine 4 demo applications open-codes bitfieldReverse()
1037 def bitfield_reverse(u):
1038 step1 = ('ior', ('ishl', u, 16), ('ushr', u, 16))
1039 step2 = ('ior', ('ishl', ('iand', step1, 0x00ff00ff), 8), ('ushr', ('iand', step1, 0xff00ff00), 8))
1040 step3 = ('ior', ('ishl', ('iand', step2, 0x0f0f0f0f), 4), ('ushr', ('iand', step2, 0xf0f0f0f0), 4))
1041 step4 = ('ior', ('ishl', ('iand', step3, 0x33333333), 2), ('ushr', ('iand', step3, 0xcccccccc), 2))
1042 step5 = ('ior', ('ishl', ('iand', step4, 0x55555555), 1), ('ushr', ('iand', step4, 0xaaaaaaaa), 1))
1043
1044 return step5
1045
1046 optimizations += [(bitfield_reverse('x@32'), ('bitfield_reverse', 'x'))]
1047
1048 # For any float comparison operation, "cmp", if you have "a == a && a cmp b"
1049 # then the "a == a" is redundant because it's equivalent to "a is not NaN"
1050 # and, if a is a NaN then the second comparison will fail anyway.
1051 for op in ['flt', 'fge', 'feq']:
1052 optimizations += [
1053 (('iand', ('feq', a, a), (op, a, b)), (op, a, b)),
1054 (('iand', ('feq', a, a), (op, b, a)), (op, b, a)),
1055 ]
1056
1057 # Add optimizations to handle the case where the result of a ternary is
1058 # compared to a constant. This way we can take things like
1059 #
1060 # (a ? 0 : 1) > 0
1061 #
1062 # and turn it into
1063 #
1064 # a ? (0 > 0) : (1 > 0)
1065 #
1066 # which constant folding will eat for lunch. The resulting ternary will
1067 # further get cleaned up by the boolean reductions above and we will be
1068 # left with just the original variable "a".
1069 for op in ['flt', 'fge', 'feq', 'fne',
1070 'ilt', 'ige', 'ieq', 'ine', 'ult', 'uge']:
1071 optimizations += [
1072 ((op, ('bcsel', 'a', '#b', '#c'), '#d'),
1073 ('bcsel', 'a', (op, 'b', 'd'), (op, 'c', 'd'))),
1074 ((op, '#d', ('bcsel', a, '#b', '#c')),
1075 ('bcsel', 'a', (op, 'd', 'b'), (op, 'd', 'c'))),
1076 ]
1077
1078
1079 # For example, this converts things like
1080 #
1081 # 1 + mix(0, a - 1, condition)
1082 #
1083 # into
1084 #
1085 # mix(1, (a-1)+1, condition)
1086 #
1087 # Other optimizations will rearrange the constants.
1088 for op in ['fadd', 'fmul', 'iadd', 'imul']:
1089 optimizations += [
1090 ((op, ('bcsel(is_used_once)', a, '#b', c), '#d'), ('bcsel', a, (op, b, d), (op, c, d)))
1091 ]
1092
1093 # For derivatives in compute shaders, GLSL_NV_compute_shader_derivatives
1094 # states:
1095 #
1096 # If neither layout qualifier is specified, derivatives in compute shaders
1097 # return zero, which is consistent with the handling of built-in texture
1098 # functions like texture() in GLSL 4.50 compute shaders.
1099 for op in ['fddx', 'fddx_fine', 'fddx_coarse',
1100 'fddy', 'fddy_fine', 'fddy_coarse']:
1101 optimizations += [
1102 ((op, 'a'), 0.0, 'info->stage == MESA_SHADER_COMPUTE && info->cs.derivative_group == DERIVATIVE_GROUP_NONE')
1103 ]
1104
1105 # Some optimizations for ir3-specific instructions.
1106 optimizations += [
1107 # 'al * bl': If either 'al' or 'bl' is zero, return zero.
1108 (('umul_low', '#a(is_lower_half_zero)', 'b'), (0)),
1109 # '(ah * bl) << 16 + c': If either 'ah' or 'bl' is zero, return 'c'.
1110 (('imadsh_mix16', '#a@32(is_lower_half_zero)', 'b@32', 'c@32'), ('c')),
1111 (('imadsh_mix16', 'a@32', '#b@32(is_upper_half_zero)', 'c@32'), ('c')),
1112 ]
1113
1114 # This section contains "late" optimizations that should be run before
1115 # creating ffmas and calling regular optimizations for the final time.
1116 # Optimizations should go here if they help code generation and conflict
1117 # with the regular optimizations.
1118 before_ffma_optimizations = [
1119 # Propagate constants down multiplication chains
1120 (('~fmul(is_used_once)', ('fmul(is_used_once)', 'a(is_not_const)', '#b'), 'c(is_not_const)'), ('fmul', ('fmul', a, c), b)),
1121 (('imul(is_used_once)', ('imul(is_used_once)', 'a(is_not_const)', '#b'), 'c(is_not_const)'), ('imul', ('imul', a, c), b)),
1122 (('~fadd(is_used_once)', ('fadd(is_used_once)', 'a(is_not_const)', '#b'), 'c(is_not_const)'), ('fadd', ('fadd', a, c), b)),
1123 (('iadd(is_used_once)', ('iadd(is_used_once)', 'a(is_not_const)', '#b'), 'c(is_not_const)'), ('iadd', ('iadd', a, c), b)),
1124
1125 (('~fadd', ('fmul', a, b), ('fmul', a, c)), ('fmul', a, ('fadd', b, c))),
1126 (('iadd', ('imul', a, b), ('imul', a, c)), ('imul', a, ('iadd', b, c))),
1127 (('~fadd', ('fneg', a), a), 0.0),
1128 (('iadd', ('ineg', a), a), 0),
1129 (('iadd', ('ineg', a), ('iadd', a, b)), b),
1130 (('iadd', a, ('iadd', ('ineg', a), b)), b),
1131 (('~fadd', ('fneg', a), ('fadd', a, b)), b),
1132 (('~fadd', a, ('fadd', ('fneg', a), b)), b),
1133
1134 (('~flrp@32', ('fadd(is_used_once)', a, -1.0), ('fadd(is_used_once)', a, 1.0), d), ('fadd', ('flrp', -1.0, 1.0, d), a)),
1135 (('~flrp@32', ('fadd(is_used_once)', a, 1.0), ('fadd(is_used_once)', a, -1.0), d), ('fadd', ('flrp', 1.0, -1.0, d), a)),
1136 (('~flrp@32', ('fadd(is_used_once)', a, '#b'), ('fadd(is_used_once)', a, '#c'), d), ('fadd', ('fmul', d, ('fadd', c, ('fneg', b))), ('fadd', a, b))),
1137 ]
1138
1139 # This section contains "late" optimizations that should be run after the
1140 # regular optimizations have finished. Optimizations should go here if
1141 # they help code generation but do not necessarily produce code that is
1142 # more easily optimizable.
1143 late_optimizations = [
1144 # Most of these optimizations aren't quite safe when you get infinity or
1145 # Nan involved but the first one should be fine.
1146 (('flt', ('fadd', a, b), 0.0), ('flt', a, ('fneg', b))),
1147 (('flt', ('fneg', ('fadd', a, b)), 0.0), ('flt', ('fneg', a), b)),
1148 (('~fge', ('fadd', a, b), 0.0), ('fge', a, ('fneg', b))),
1149 (('~fge', ('fneg', ('fadd', a, b)), 0.0), ('fge', ('fneg', a), b)),
1150 (('~feq', ('fadd', a, b), 0.0), ('feq', a, ('fneg', b))),
1151 (('~fne', ('fadd', a, b), 0.0), ('fne', a, ('fneg', b))),
1152
1153 # nir_lower_to_source_mods will collapse this, but its existence during the
1154 # optimization loop can prevent other optimizations.
1155 (('fneg', ('fneg', a)), a),
1156
1157 # These are duplicated from the main optimizations table. The late
1158 # patterns that rearrange expressions like x - .5 < 0 to x < .5 can create
1159 # new patterns like these. The patterns that compare with zero are removed
1160 # because they are unlikely to be created in by anything in
1161 # late_optimizations.
1162 (('flt', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('flt', a, b)),
1163 (('flt', '#b(is_gt_0_and_lt_1)', ('fsat(is_used_once)', a)), ('flt', b, a)),
1164 (('fge', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('fge', a, b)),
1165 (('fge', '#b(is_gt_0_and_lt_1)', ('fsat(is_used_once)', a)), ('fge', b, a)),
1166 (('feq', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('feq', a, b)),
1167 (('fne', ('fsat(is_used_once)', a), '#b(is_gt_0_and_lt_1)'), ('fne', a, b)),
1168
1169 (('fge', ('fsat(is_used_once)', a), 1.0), ('fge', a, 1.0)),
1170 (('flt', ('fsat(is_used_once)', a), 1.0), ('flt', a, 1.0)),
1171
1172 (('~fge', ('fmin(is_used_once)', ('fadd(is_used_once)', a, b), ('fadd', c, d)), 0.0), ('iand', ('fge', a, ('fneg', b)), ('fge', c, ('fneg', d)))),
1173
1174 (('flt', ('fneg', a), ('fneg', b)), ('flt', b, a)),
1175 (('fge', ('fneg', a), ('fneg', b)), ('fge', b, a)),
1176 (('feq', ('fneg', a), ('fneg', b)), ('feq', b, a)),
1177 (('fne', ('fneg', a), ('fneg', b)), ('fne', b, a)),
1178 (('flt', ('fneg', a), -1.0), ('flt', 1.0, a)),
1179 (('flt', -1.0, ('fneg', a)), ('flt', a, 1.0)),
1180 (('fge', ('fneg', a), -1.0), ('fge', 1.0, a)),
1181 (('fge', -1.0, ('fneg', a)), ('fge', a, 1.0)),
1182 (('fne', ('fneg', a), -1.0), ('fne', 1.0, a)),
1183 (('feq', -1.0, ('fneg', a)), ('feq', a, 1.0)),
1184
1185 (('ior', a, a), a),
1186 (('iand', a, a), a),
1187
1188 (('~fadd', ('fneg(is_used_once)', ('fsat(is_used_once)', 'a(is_not_fmul)')), 1.0), ('fsat', ('fadd', 1.0, ('fneg', a)))),
1189
1190 (('fdot2', a, b), ('fdot_replicated2', a, b), 'options->fdot_replicates'),
1191 (('fdot3', a, b), ('fdot_replicated3', a, b), 'options->fdot_replicates'),
1192 (('fdot4', a, b), ('fdot_replicated4', a, b), 'options->fdot_replicates'),
1193 (('fdph', a, b), ('fdph_replicated', a, b), 'options->fdot_replicates'),
1194
1195 (('~flrp@32', ('fadd(is_used_once)', a, b), ('fadd(is_used_once)', a, c), d), ('fadd', ('flrp', b, c, d), a)),
1196 (('~flrp@64', ('fadd(is_used_once)', a, b), ('fadd(is_used_once)', a, c), d), ('fadd', ('flrp', b, c, d), a)),
1197
1198 (('~fadd@32', 1.0, ('fmul(is_used_once)', c , ('fadd', b, -1.0 ))), ('fadd', ('fadd', 1.0, ('fneg', c)), ('fmul', b, c)), 'options->lower_flrp32'),
1199 (('~fadd@64', 1.0, ('fmul(is_used_once)', c , ('fadd', b, -1.0 ))), ('fadd', ('fadd', 1.0, ('fneg', c)), ('fmul', b, c)), 'options->lower_flrp64'),
1200
1201 # we do these late so that we don't get in the way of creating ffmas
1202 (('fmin', ('fadd(is_used_once)', '#c', a), ('fadd(is_used_once)', '#c', b)), ('fadd', c, ('fmin', a, b))),
1203 (('fmax', ('fadd(is_used_once)', '#c', a), ('fadd(is_used_once)', '#c', b)), ('fadd', c, ('fmax', a, b))),
1204
1205 (('bcsel', a, 0, ('b2f32', ('inot', 'b@bool'))), ('b2f32', ('inot', ('ior', a, b)))),
1206 ]
1207
1208 print(nir_algebraic.AlgebraicPass("nir_opt_algebraic", optimizations).render())
1209 print(nir_algebraic.AlgebraicPass("nir_opt_algebraic_before_ffma",
1210 before_ffma_optimizations).render())
1211 print(nir_algebraic.AlgebraicPass("nir_opt_algebraic_late",
1212 late_optimizations).render())