2 * Copyright © 2016 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 "nir_builder.h"
26 #include "nir_deref.h"
29 emit_load_store_deref(nir_builder
*b
, nir_intrinsic_instr
*orig_instr
,
30 nir_deref_instr
*parent
,
31 nir_deref_instr
**deref_arr
,
32 nir_ssa_def
**dest
, nir_ssa_def
*src
);
35 emit_indirect_load_store_deref(nir_builder
*b
, nir_intrinsic_instr
*orig_instr
,
36 nir_deref_instr
*parent
,
37 nir_deref_instr
**deref_arr
,
39 nir_ssa_def
**dest
, nir_ssa_def
*src
)
42 if (start
== end
- 1) {
43 emit_load_store_deref(b
, orig_instr
,
44 nir_build_deref_array_imm(b
, parent
, start
),
45 deref_arr
+ 1, dest
, src
);
47 int mid
= start
+ (end
- start
) / 2;
49 nir_ssa_def
*then_dest
, *else_dest
;
51 nir_deref_instr
*deref
= *deref_arr
;
52 assert(deref
->deref_type
== nir_deref_type_array
);
54 nir_push_if(b
, nir_ilt(b
, deref
->arr
.index
.ssa
, nir_imm_intN_t(b
, mid
, parent
->dest
.ssa
.bit_size
)));
55 emit_indirect_load_store_deref(b
, orig_instr
, parent
, deref_arr
,
56 start
, mid
, &then_dest
, src
);
57 nir_push_else(b
, NULL
);
58 emit_indirect_load_store_deref(b
, orig_instr
, parent
, deref_arr
,
59 mid
, end
, &else_dest
, src
);
63 *dest
= nir_if_phi(b
, then_dest
, else_dest
);
68 emit_load_store_deref(nir_builder
*b
, nir_intrinsic_instr
*orig_instr
,
69 nir_deref_instr
*parent
,
70 nir_deref_instr
**deref_arr
,
71 nir_ssa_def
**dest
, nir_ssa_def
*src
)
73 for (; *deref_arr
; deref_arr
++) {
74 nir_deref_instr
*deref
= *deref_arr
;
75 if (deref
->deref_type
== nir_deref_type_array
&&
76 !nir_src_is_const(deref
->arr
.index
)) {
77 int length
= glsl_get_length(parent
->type
);
79 emit_indirect_load_store_deref(b
, orig_instr
, parent
, deref_arr
,
80 0, length
, dest
, src
);
84 parent
= nir_build_deref_follower(b
, parent
, deref
);
87 /* We reached the end of the deref chain. Emit the instruction */
88 assert(*deref_arr
== NULL
);
91 /* This is a load instruction */
92 nir_intrinsic_instr
*load
=
93 nir_intrinsic_instr_create(b
->shader
, orig_instr
->intrinsic
);
94 load
->num_components
= orig_instr
->num_components
;
96 load
->src
[0] = nir_src_for_ssa(&parent
->dest
.ssa
);
98 /* Copy over any other sources. This is needed for interp_deref_at */
100 i
< nir_intrinsic_infos
[orig_instr
->intrinsic
].num_srcs
; i
++)
101 nir_src_copy(&load
->src
[i
], &orig_instr
->src
[i
], load
);
103 nir_ssa_dest_init(&load
->instr
, &load
->dest
,
104 orig_instr
->dest
.ssa
.num_components
,
105 orig_instr
->dest
.ssa
.bit_size
, NULL
);
106 nir_builder_instr_insert(b
, &load
->instr
);
107 *dest
= &load
->dest
.ssa
;
109 assert(orig_instr
->intrinsic
== nir_intrinsic_store_deref
);
110 nir_store_deref(b
, parent
, src
, nir_intrinsic_write_mask(orig_instr
));
115 lower_indirect_derefs_block(nir_block
*block
, nir_builder
*b
,
116 nir_variable_mode modes
)
118 bool progress
= false;
120 nir_foreach_instr_safe(instr
, block
) {
121 if (instr
->type
!= nir_instr_type_intrinsic
)
124 nir_intrinsic_instr
*intrin
= nir_instr_as_intrinsic(instr
);
125 if (intrin
->intrinsic
!= nir_intrinsic_load_deref
&&
126 intrin
->intrinsic
!= nir_intrinsic_interp_deref_at_centroid
&&
127 intrin
->intrinsic
!= nir_intrinsic_interp_deref_at_sample
&&
128 intrin
->intrinsic
!= nir_intrinsic_interp_deref_at_offset
&&
129 intrin
->intrinsic
!= nir_intrinsic_store_deref
)
132 nir_deref_instr
*deref
= nir_src_as_deref(intrin
->src
[0]);
134 /* Walk the deref chain back to the base and look for indirects */
135 bool has_indirect
= false;
136 nir_deref_instr
*base
= deref
;
137 while (base
&& base
->deref_type
!= nir_deref_type_var
) {
138 if (base
->deref_type
== nir_deref_type_array
&&
139 !nir_src_is_const(base
->arr
.index
))
142 base
= nir_deref_instr_parent(base
);
145 if (!has_indirect
|| !base
)
148 /* Only lower variables whose mode is in the mask, or compact
149 * array variables. (We can't handle indirects on tightly packed
150 * scalar arrays, so we need to lower them regardless.)
152 if (!(modes
& base
->var
->data
.mode
) && !base
->var
->data
.compact
)
155 b
->cursor
= nir_instr_remove(&intrin
->instr
);
158 nir_deref_path_init(&path
, deref
, NULL
);
159 assert(path
.path
[0] == base
);
161 if (intrin
->intrinsic
== nir_intrinsic_store_deref
) {
162 assert(intrin
->src
[1].is_ssa
);
163 emit_load_store_deref(b
, intrin
, base
, &path
.path
[1],
164 NULL
, intrin
->src
[1].ssa
);
167 emit_load_store_deref(b
, intrin
, base
, &path
.path
[1],
169 nir_ssa_def_rewrite_uses(&intrin
->dest
.ssa
, nir_src_for_ssa(result
));
172 nir_deref_path_finish(&path
);
181 lower_indirects_impl(nir_function_impl
*impl
, nir_variable_mode modes
)
184 nir_builder_init(&builder
, impl
);
185 bool progress
= false;
187 nir_foreach_block_safe(block
, impl
) {
188 progress
|= lower_indirect_derefs_block(block
, &builder
, modes
);
192 nir_metadata_preserve(impl
, nir_metadata_none
);
197 /** Lowers indirect variable loads/stores to direct loads/stores.
199 * The pass works by replacing any indirect load or store with an if-ladder
200 * that does a binary search on the array index.
203 nir_lower_indirect_derefs(nir_shader
*shader
, nir_variable_mode modes
)
205 bool progress
= false;
207 nir_foreach_function(function
, shader
) {
209 progress
= lower_indirects_impl(function
->impl
, modes
) || progress
;