2 * Copyright (C) 2020 Collabora, Ltd.
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 FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 /* NIR creates vectors as vecN ops, which we represent by a synthetic
27 * BI_COMBINE instruction, e.g.:
29 * v = combine x, y, z, w
31 * These combines need to be lowered by the pass in this file. Fix a given
32 * source at component c.
34 * First suppose the source is SSA. If it is also scalar, then we may rewrite
35 * the destination of the generating instruction (unique by SSA+scalar) to
36 * write to v.c, and rewrite each of its uses to swizzle out .c instead of .x
37 * (the original by scalar). If it is vector, there are two cases. If the
38 * component c is `x`, we are accessing v.x, and each of the succeeding
39 * components y, z... up to the last component of the vector are accessed
40 * sequentially, then we may perform the same rewrite. If this is not the case,
41 * rewriting would require more complex vector features, so we fallback on a
44 * Otherwise is the source is not SSA, we also fallback on a move. We could
49 bi_combine_mov32(bi_context
*ctx
, bi_instruction
*parent
, unsigned comp
, unsigned R
)
51 bi_instruction move
= {
54 .dest_type
= nir_type_uint32
,
56 .src
= { parent
->src
[comp
] },
57 .src_types
= { nir_type_uint32
},
58 .swizzle
= { { parent
->swizzle
[comp
][0] } }
61 bi_emit_before(ctx
, parent
, move
);
64 /* Gets the instruction generating a given source. Combine lowering is
65 * accidentally O(n^2) right now because this function is O(n) instead of O(1).
66 * If this pass is slow, this cost can be avoided in favour for better
69 static bi_instruction
*
70 bi_get_parent(bi_context
*ctx
, unsigned idx
)
72 bi_foreach_instr_global(ctx
, ins
) {
80 /* Rewrites uses of an index. Again, this could be O(n) to the program but is
81 * currently O(nc) to the program and number of combines, so the pass becomes
82 * effectively O(n^2). Better bookkeeping would bring down to linear if that's
86 bi_rewrite_uses(bi_context
*ctx
,
87 unsigned old
, unsigned oldc
,
88 unsigned new, unsigned newc
)
90 bi_foreach_instr_global(ctx
, ins
) {
91 bi_foreach_src(ins
, s
) {
92 if (ins
->src
[s
] != old
) continue;
94 for (unsigned i
= 0; i
< 16; ++i
)
95 ins
->swizzle
[s
][i
] += (newc
- oldc
);
102 /* Checks if we have a nicely aligned vector prefix */
105 bi_is_aligned_vec32(bi_instruction
*combine
, unsigned s
, bi_instruction
*io
,
108 /* We only support prefixes */
112 if (!(bi_class_props
[io
->type
] & BI_VECTOR
))
115 if (nir_alu_type_get_type_size(combine
->dest_type
) != 32)
118 if (nir_alu_type_get_type_size(io
->dest_type
) != 32)
121 unsigned components
= io
->vector_channels
;
123 /* Are we contiguous like that? */
125 for (unsigned i
= 0; i
< components
; ++i
) {
126 if (combine
->src
[i
] != io
->dest
)
129 if (combine
->swizzle
[i
][0] != i
)
133 /* We're good to go */
139 /* Tries to lower a given source of a combine to an appropriate rewrite,
140 * returning true if successful, and false with no changes otherwise. */
143 bi_lower_combine_src(bi_context
*ctx
, bi_instruction
*ins
, unsigned s
, unsigned R
,
146 unsigned src
= ins
->src
[s
];
148 /* We currently only handle SSA */
150 if (!src
) return false;
151 if (src
& (BIR_SPECIAL
| BIR_IS_REG
)) return false;
153 /* We are SSA. Lookup the generating instruction. */
154 unsigned bytes
= nir_alu_type_get_type_size(ins
->dest_type
) / 8;
156 bi_instruction
*parent
= bi_get_parent(ctx
, src
,
157 0xF << (ins
->swizzle
[s
][0] * bytes
));
159 if (!parent
) return false;
161 /* We have a parent instuction, sanity check the typesize */
162 unsigned pbytes
= nir_alu_type_get_type_size(parent
->dest_type
) / 8;
163 if (pbytes
!= bytes
) return false;
165 bool scalar
= parent
->vector_channels
!= 0;
166 if (!(scalar
|| bi_is_aligned_vec(ins
, s
, parent
, vec_count
))) return false;
168 if (!bi_shift_mask(parent
, bytes
* s
)) return false;
169 bi_rewrite_uses(ctx
, parent
->dest
, 0, R
, s
);
176 bi_lower_combine(bi_context
*ctx
, bi_block
*block
)
178 bi_foreach_instr_in_block_safe(block
, ins
) {
179 if (ins
->type
!= BI_COMBINE
) continue;
181 unsigned R
= bi_make_temp_reg(ctx
);
183 bi_foreach_src(ins
, s
) {
184 /* We're done early for vec2/3 */
189 unsigned vec_count
= 0;
191 if (bi_lower_combine_src(ctx
, ins
, s
, R
, &vec_count
)) {
192 /* Skip vectored sources */
194 s
+= (vec_count
- 1);
196 bi_insert_combine_mov(ctx
, ins
, s
, R
);
199 bi_combine_mov32(ctx
, ins
, s
, R
);
203 bi_rewrite_uses(ctx
, ins
->dest
, 0, R
, 0);
204 bi_remove_instruction(ins
);