2 * Copyright © 2019 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 DEALINGS
25 #include "util/bitset.h"
28 set_type(unsigned idx
, nir_alu_type type
, BITSET_WORD
*float_types
,
29 BITSET_WORD
*int_types
, bool *progress
)
31 switch (nir_alu_type_get_base_type(type
)) {
35 if (int_types
&& !BITSET_TEST(int_types
, idx
)) {
37 BITSET_SET(int_types
, idx
);
42 if (float_types
&& !BITSET_TEST(float_types
, idx
)) {
44 BITSET_SET(float_types
, idx
);
49 unreachable("Invalid base nir_alu_type");
54 copy_types(unsigned a
, unsigned b
, BITSET_WORD
*float_types
,
55 BITSET_WORD
*int_types
, bool *progress
)
57 /* If the bits do not agree then one of them is set but not both. Flag
58 * progress and set both bits.
60 if (float_types
&& (BITSET_TEST(float_types
, a
) !=
61 BITSET_TEST(float_types
, b
))) {
63 BITSET_SET(float_types
, a
);
64 BITSET_SET(float_types
, b
);
67 if (int_types
&& (BITSET_TEST(int_types
, a
) !=
68 BITSET_TEST(int_types
, b
))) {
70 BITSET_SET(int_types
, a
);
71 BITSET_SET(int_types
, b
);
75 /** Gather up ALU types for SSA values
77 * This pass attempts to determine, for each SSA value, the type of data (int
78 * or float) that will be stored in it. The pass is greedy in the sense that
79 * it just assigns intness or floatness to types without any attempt to sort
80 * out the interesting cases where a given type may be both.
82 * The output of the pass is a pair of bitsets which has the intness or
83 * floatness of each SSA value recorded by index. It is the responsibility of
84 * the caller to index the SSA defs using nir_index_ssa_defs and allocate the
85 * bitsets. Either bitset is allowed to be NULL in which case no data is
86 * recorded for that type.
89 nir_gather_ssa_types(nir_function_impl
*impl
,
90 BITSET_WORD
*float_types
,
91 BITSET_WORD
*int_types
)
97 nir_foreach_block(block
, impl
) {
98 nir_foreach_instr(instr
, block
) {
99 switch (instr
->type
) {
100 case nir_instr_type_alu
: {
101 nir_alu_instr
*alu
= nir_instr_as_alu(instr
);
102 assert(alu
->dest
.dest
.is_ssa
);
103 const nir_op_info
*info
= &nir_op_infos
[alu
->op
];
110 for (unsigned i
= 0; i
< info
->num_inputs
; i
++) {
111 assert(alu
->src
[i
].src
.is_ssa
);
112 copy_types(alu
->src
[i
].src
.ssa
->index
,
113 alu
->dest
.dest
.ssa
.index
,
114 float_types
, int_types
, &progress
);
120 set_type(alu
->src
[0].src
.ssa
->index
, nir_type_bool
,
121 float_types
, int_types
, &progress
);
122 copy_types(alu
->src
[1].src
.ssa
->index
,
123 alu
->dest
.dest
.ssa
.index
,
124 float_types
, int_types
, &progress
);
125 copy_types(alu
->src
[2].src
.ssa
->index
,
126 alu
->dest
.dest
.ssa
.index
,
127 float_types
, int_types
, &progress
);
131 for (unsigned i
= 0; i
< info
->num_inputs
; i
++) {
132 assert(alu
->src
[i
].src
.is_ssa
);
133 set_type(alu
->src
[i
].src
.ssa
->index
, info
->input_types
[i
],
134 float_types
, int_types
, &progress
);
136 set_type(alu
->dest
.dest
.ssa
.index
, info
->output_type
,
137 float_types
, int_types
, &progress
);
142 case nir_instr_type_tex
: {
143 nir_tex_instr
*tex
= nir_instr_as_tex(instr
);
144 for (unsigned i
= 0; i
< tex
->num_srcs
; i
++) {
145 assert(tex
->src
[i
].src
.is_ssa
);
146 set_type(tex
->src
[i
].src
.ssa
->index
,
147 nir_tex_instr_src_type(tex
, i
),
148 float_types
, int_types
, &progress
);
150 assert(tex
->dest
.is_ssa
);
151 set_type(tex
->dest
.ssa
.index
, tex
->dest_type
,
152 float_types
, int_types
, &progress
);
156 case nir_instr_type_intrinsic
: {
157 nir_intrinsic_instr
*intrin
= nir_instr_as_intrinsic(instr
);
158 /* We could go nuts here, but we'll just handle a few simple
159 * cases and let everything else be untyped.
161 switch (intrin
->intrinsic
) {
162 case nir_intrinsic_load_deref
: {
163 nir_deref_instr
*deref
= nir_src_as_deref(intrin
->src
[0]);
165 assert(intrin
->dest
.is_ssa
);
166 set_type(intrin
->dest
.ssa
.index
,
167 nir_get_nir_type_for_glsl_type(deref
->type
),
168 float_types
, int_types
, &progress
);
172 case nir_intrinsic_store_deref
: {
173 nir_deref_instr
*deref
= nir_src_as_deref(intrin
->src
[0]);
175 assert(intrin
->src
[1].is_ssa
);
176 set_type(intrin
->src
[1].ssa
->index
,
177 nir_get_nir_type_for_glsl_type(deref
->type
),
178 float_types
, int_types
, &progress
);
183 /* For the most part, we leave other intrinsics alone. Most
184 * of them don't matter in OpenGL ES 2.0 drivers anyway.
185 * However, we should at least check if this is some sort of
186 * IO intrinsic and flag it's offset and index sources.
188 nir_src
*offset_src
= nir_get_io_offset_src(intrin
);
190 assert(offset_src
->is_ssa
);
191 set_type(offset_src
->ssa
->index
, nir_type_int
,
192 float_types
, int_types
, &progress
);
200 case nir_instr_type_phi
: {
201 nir_phi_instr
*phi
= nir_instr_as_phi(instr
);
202 assert(phi
->dest
.is_ssa
);
203 nir_foreach_phi_src(src
, phi
) {
204 assert(src
->src
.is_ssa
);
205 copy_types(src
->src
.ssa
->index
, phi
->dest
.ssa
.index
,
206 float_types
, int_types
, &progress
);