2 * Copyright © 2014-2015 Broadcom
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 DEALINGS
26 /** @file nir_lower_alu_to_scalar.c
28 * Replaces nir_alu_instr operations with more than one channel used in the
29 * arguments with individual per-channel operations.
33 nir_alu_ssa_dest_init(nir_alu_instr
*instr
, unsigned num_components
)
35 nir_ssa_dest_init(&instr
->instr
, &instr
->dest
.dest
, num_components
, NULL
);
36 instr
->dest
.write_mask
= (1 << num_components
) - 1;
40 lower_reduction(nir_alu_instr
*instr
, nir_op chan_op
, nir_op merge_op
,
43 unsigned num_components
= nir_op_infos
[instr
->op
].input_sizes
[0];
45 nir_ssa_def
*last
= NULL
;
46 for (unsigned i
= 0; i
< num_components
; i
++) {
47 nir_alu_instr
*chan
= nir_alu_instr_create(mem_ctx
, chan_op
);
48 nir_alu_ssa_dest_init(chan
, 1);
49 nir_alu_src_copy(&chan
->src
[0], &instr
->src
[0], chan
);
50 chan
->src
[0].swizzle
[0] = chan
->src
[0].swizzle
[i
];
51 if (nir_op_infos
[chan_op
].num_inputs
> 1) {
52 assert(nir_op_infos
[chan_op
].num_inputs
== 2);
53 nir_alu_src_copy(&chan
->src
[1], &instr
->src
[1], chan
);
54 chan
->src
[1].swizzle
[0] = chan
->src
[1].swizzle
[i
];
57 nir_instr_insert_before(&instr
->instr
, &chan
->instr
);
60 last
= &chan
->dest
.dest
.ssa
;
62 nir_alu_instr
*merge
= nir_alu_instr_create(mem_ctx
, merge_op
);
63 nir_alu_ssa_dest_init(merge
, 1);
64 merge
->dest
.write_mask
= 1;
65 merge
->src
[0].src
= nir_src_for_ssa(last
);
66 merge
->src
[1].src
= nir_src_for_ssa(&chan
->dest
.dest
.ssa
);
67 nir_instr_insert_before(&instr
->instr
, &merge
->instr
);
68 last
= &merge
->dest
.dest
.ssa
;
72 assert(instr
->dest
.write_mask
== 1);
73 nir_ssa_def_rewrite_uses(&instr
->dest
.dest
.ssa
, nir_src_for_ssa(last
));
74 nir_instr_remove(&instr
->instr
);
78 lower_alu_instr_scalar(nir_alu_instr
*instr
, void *mem_ctx
)
80 unsigned num_src
= nir_op_infos
[instr
->op
].num_inputs
;
83 assert(instr
->dest
.dest
.is_ssa
);
84 assert(instr
->dest
.write_mask
!= 0);
86 #define LOWER_REDUCTION(name, chan, merge) \
90 lower_reduction(instr, chan, merge, mem_ctx); \
97 /* We don't need to scalarize these ops, they're the ones generated to
98 * group up outputs into a value that can be SSAed.
102 case nir_op_unpack_unorm_4x8
:
103 case nir_op_unpack_snorm_4x8
:
104 case nir_op_unpack_unorm_2x16
:
105 case nir_op_unpack_snorm_2x16
:
106 /* There is no scalar version of these ops, unless we were to break it
107 * down to bitshifts and math (which is definitely not intended).
111 case nir_op_unpack_half_2x16
:
112 /* We could split this into unpack_half_2x16_split_[xy], but should
117 LOWER_REDUCTION(nir_op_fdot
, nir_op_fmul
, nir_op_fadd
);
118 LOWER_REDUCTION(nir_op_ball_fequal
, nir_op_feq
, nir_op_iand
);
119 LOWER_REDUCTION(nir_op_ball_iequal
, nir_op_ieq
, nir_op_iand
);
120 LOWER_REDUCTION(nir_op_bany_fnequal
, nir_op_fne
, nir_op_ior
);
121 LOWER_REDUCTION(nir_op_bany_inequal
, nir_op_ine
, nir_op_ior
);
122 LOWER_REDUCTION(nir_op_fall_equal
, nir_op_seq
, nir_op_fand
);
123 LOWER_REDUCTION(nir_op_fany_nequal
, nir_op_sne
, nir_op_for
);
124 LOWER_REDUCTION(nir_op_ball
, nir_op_imov
, nir_op_iand
);
125 LOWER_REDUCTION(nir_op_bany
, nir_op_imov
, nir_op_ior
);
126 LOWER_REDUCTION(nir_op_fall
, nir_op_fmov
, nir_op_fand
);
127 LOWER_REDUCTION(nir_op_fany
, nir_op_fmov
, nir_op_for
);
133 if (instr
->dest
.dest
.ssa
.num_components
== 1)
136 unsigned num_components
= instr
->dest
.dest
.ssa
.num_components
;
137 static const nir_op nir_op_map
[] = {nir_op_vec2
, nir_op_vec3
, nir_op_vec4
};
138 nir_alu_instr
*vec_instr
=
139 nir_alu_instr_create(mem_ctx
, nir_op_map
[num_components
- 2]);
140 nir_alu_ssa_dest_init(vec_instr
, num_components
);
142 for (chan
= 0; chan
< 4; chan
++) {
143 if (!(instr
->dest
.write_mask
& (1 << chan
)))
146 nir_alu_instr
*lower
= nir_alu_instr_create(mem_ctx
, instr
->op
);
147 for (i
= 0; i
< num_src
; i
++) {
148 /* We only handle same-size-as-dest (input_sizes[] == 0) or scalar
149 * args (input_sizes[] == 1).
151 assert(nir_op_infos
[instr
->op
].input_sizes
[i
] < 2);
152 unsigned src_chan
= (nir_op_infos
[instr
->op
].input_sizes
[i
] == 1 ?
155 nir_alu_src_copy(&lower
->src
[i
], &instr
->src
[i
], lower
);
156 for (int j
= 0; j
< 4; j
++)
157 lower
->src
[i
].swizzle
[j
] = instr
->src
[i
].swizzle
[src_chan
];
160 nir_alu_ssa_dest_init(lower
, 1);
161 lower
->dest
.saturate
= instr
->dest
.saturate
;
162 vec_instr
->src
[chan
].src
= nir_src_for_ssa(&lower
->dest
.dest
.ssa
);
164 nir_instr_insert_before(&instr
->instr
, &lower
->instr
);
167 nir_instr_insert_before(&instr
->instr
, &vec_instr
->instr
);
169 nir_ssa_def_rewrite_uses(&instr
->dest
.dest
.ssa
,
170 nir_src_for_ssa(&vec_instr
->dest
.dest
.ssa
));
172 nir_instr_remove(&instr
->instr
);
176 lower_alu_to_scalar_block(nir_block
*block
, void *data
)
178 nir_foreach_instr_safe(block
, instr
) {
179 if (instr
->type
== nir_instr_type_alu
)
180 lower_alu_instr_scalar(nir_instr_as_alu(instr
), data
);
187 nir_lower_alu_to_scalar_impl(nir_function_impl
*impl
)
189 nir_foreach_block(impl
, lower_alu_to_scalar_block
, ralloc_parent(impl
));
193 nir_lower_alu_to_scalar(nir_shader
*shader
)
195 nir_foreach_overload(shader
, overload
) {
197 nir_lower_alu_to_scalar_impl(overload
->impl
);