2
* Copyright © 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
25
#include "nir_builder.h"
27
/** @file nir_opt_undef.c
29
* Handles optimization of operations involving ssa_undef.
33
* Turn conditional selects between an undef and some other value into a move
34
* of that other value (on the assumption that the condition's going to be
35
* choosing the defined value). This reduces work after if flattening when
36
* each side of the if is defining a variable.
39
opt_undef_csel(nir_alu_instr *instr)
41
if (instr->op != nir_op_bcsel && instr->op != nir_op_fcsel)
44
assert(instr->dest.dest.is_ssa);
46
for (int i = 1; i <= 2; i++) {
47
if (!instr->src[i].src.is_ssa)
50
nir_instr *parent = instr->src[i].src.ssa->parent_instr;
51
if (parent->type != nir_instr_type_ssa_undef)
54
/* We can't just use nir_alu_src_copy, because we need the def/use
57
nir_instr_rewrite_src(&instr->instr, &instr->src[0].src,
58
instr->src[i == 1 ? 2 : 1].src);
59
nir_alu_src_copy(&instr->src[0], &instr->src[i == 1 ? 2 : 1]);
62
memset(&empty_src, 0, sizeof(empty_src));
63
nir_instr_rewrite_src(&instr->instr, &instr->src[1].src, empty_src);
64
nir_instr_rewrite_src(&instr->instr, &instr->src[2].src, empty_src);
65
instr->op = nir_op_mov;
74
* Replace vecN(undef, undef, ...) with a single undef.
77
opt_undef_vecN(nir_builder *b, nir_alu_instr *alu)
79
if (!nir_op_is_vec(alu->op))
82
assert(alu->dest.dest.is_ssa);
84
for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
85
if (!alu->src[i].src.is_ssa ||
86
alu->src[i].src.ssa->parent_instr->type != nir_instr_type_ssa_undef)
90
b->cursor = nir_before_instr(&alu->instr);
91
nir_ssa_def *undef = nir_ssa_undef(b, alu->dest.dest.ssa.num_components,
92
nir_dest_bit_size(alu->dest.dest));
93
nir_ssa_def_rewrite_uses(&alu->dest.dest.ssa, undef);
99
nir_get_undef_mask(nir_ssa_def *def)
101
nir_instr *instr = def->parent_instr;
103
if (instr->type == nir_instr_type_ssa_undef)
104
return BITSET_MASK(def->num_components);
106
if (instr->type != nir_instr_type_alu)
109
nir_alu_instr *alu = nir_instr_as_alu(instr);
112
if (nir_op_is_vec(alu->op)) {
113
for (int i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
114
if (alu->src[i].src.is_ssa &&
115
alu->src[i].src.ssa->parent_instr->type ==
116
nir_instr_type_ssa_undef) {
117
undef |= BITSET_MASK(nir_ssa_alu_instr_src_components(alu, i)) << i;
126
* Remove any store intrinsic writemask channels whose value is undefined (the
127
* existing value is a fine representation of "undefined").
130
opt_undef_store(nir_intrinsic_instr *intrin)
133
switch (intrin->intrinsic) {
134
case nir_intrinsic_store_deref:
137
case nir_intrinsic_store_output:
138
case nir_intrinsic_store_per_vertex_output:
139
case nir_intrinsic_store_per_primitive_output:
140
case nir_intrinsic_store_ssbo:
141
case nir_intrinsic_store_shared:
142
case nir_intrinsic_store_global:
143
case nir_intrinsic_store_scratch:
150
if (!intrin->src[arg_index].is_ssa)
153
nir_ssa_def *def = intrin->src[arg_index].ssa;
155
unsigned write_mask = nir_intrinsic_write_mask(intrin);
156
unsigned undef_mask = nir_get_undef_mask(def);
158
if (!(write_mask & undef_mask))
161
write_mask &= ~undef_mask;
163
nir_instr_remove(&intrin->instr);
165
nir_intrinsic_set_write_mask(intrin, write_mask);
171
nir_opt_undef_instr(nir_builder *b, nir_instr *instr, void *data)
173
if (instr->type == nir_instr_type_alu) {
174
nir_alu_instr *alu = nir_instr_as_alu(instr);
175
return opt_undef_csel(alu) || opt_undef_vecN(b, alu);
176
} else if (instr->type == nir_instr_type_intrinsic) {
177
nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
178
return opt_undef_store(intrin);
185
nir_opt_undef(nir_shader *shader)
187
return nir_shader_instructions_pass(shader,
189
nir_metadata_block_index |
190
nir_metadata_dominance,