2 * Copyright © 2018 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 #include "util/u_math.h"
32 struct split_var_state
{
36 nir_function_impl
*impl
;
38 nir_variable
*base_var
;
44 const struct glsl_type
*type
;
52 static const struct glsl_type
*
53 wrap_type_in_array(const struct glsl_type
*type
,
54 const struct glsl_type
*array_type
)
56 if (!glsl_type_is_array(array_type
))
59 const struct glsl_type
*elem_type
=
60 wrap_type_in_array(type
, glsl_get_array_element(array_type
));
61 return glsl_array_type(elem_type
, glsl_get_length(array_type
));
65 num_array_levels_in_array_of_vector_type(const struct glsl_type
*type
)
69 if (glsl_type_is_array_or_matrix(type
)) {
71 type
= glsl_get_array_element(type
);
72 } else if (glsl_type_is_vector_or_scalar(type
)) {
75 /* Not an array of vectors */
82 init_field_for_type(struct field
*field
, struct field
*parent
,
83 const struct glsl_type
*type
,
85 struct split_var_state
*state
)
87 *field
= (struct field
) {
92 const struct glsl_type
*struct_type
= glsl_without_array(type
);
93 if (glsl_type_is_struct(struct_type
)) {
94 field
->num_fields
= glsl_get_length(struct_type
),
95 field
->fields
= ralloc_array(state
->mem_ctx
, struct field
,
97 for (unsigned i
= 0; i
< field
->num_fields
; i
++) {
98 char *field_name
= NULL
;
100 field_name
= ralloc_asprintf(state
->mem_ctx
, "%s_%s", name
,
101 glsl_get_struct_elem_name(struct_type
, i
));
103 field_name
= ralloc_asprintf(state
->mem_ctx
, "{unnamed %s}_%s",
104 glsl_get_type_name(struct_type
),
105 glsl_get_struct_elem_name(struct_type
, i
));
107 init_field_for_type(&field
->fields
[i
], field
,
108 glsl_get_struct_field(struct_type
, i
),
112 const struct glsl_type
*var_type
= type
;
113 for (struct field
*f
= field
->parent
; f
; f
= f
->parent
)
114 var_type
= wrap_type_in_array(var_type
, f
->type
);
116 nir_variable_mode mode
= state
->base_var
->data
.mode
;
117 if (mode
== nir_var_local
) {
118 field
->var
= nir_local_variable_create(state
->impl
, var_type
, name
);
120 field
->var
= nir_variable_create(state
->shader
, mode
, var_type
, name
);
126 split_var_list_structs(nir_shader
*shader
,
127 nir_function_impl
*impl
,
128 struct exec_list
*vars
,
129 struct hash_table
*var_field_map
,
132 struct split_var_state state
= {
138 struct exec_list split_vars
;
139 exec_list_make_empty(&split_vars
);
141 /* To avoid list confusion (we'll be adding things as we split variables),
142 * pull all of the variables we plan to split off of the list
144 nir_foreach_variable_safe(var
, vars
) {
145 if (!glsl_type_is_struct(glsl_without_array(var
->type
)))
148 exec_node_remove(&var
->node
);
149 exec_list_push_tail(&split_vars
, &var
->node
);
152 nir_foreach_variable(var
, &split_vars
) {
153 state
.base_var
= var
;
155 struct field
*root_field
= ralloc(mem_ctx
, struct field
);
156 init_field_for_type(root_field
, NULL
, var
->type
, var
->name
, &state
);
157 _mesa_hash_table_insert(var_field_map
, var
, root_field
);
160 return !exec_list_is_empty(&split_vars
);
164 split_struct_derefs_impl(nir_function_impl
*impl
,
165 struct hash_table
*var_field_map
,
166 nir_variable_mode modes
,
170 nir_builder_init(&b
, impl
);
172 nir_foreach_block(block
, impl
) {
173 nir_foreach_instr_safe(instr
, block
) {
174 if (instr
->type
!= nir_instr_type_deref
)
177 nir_deref_instr
*deref
= nir_instr_as_deref(instr
);
178 if (!(deref
->mode
& modes
))
181 /* Clean up any dead derefs we find lying around. They may refer to
182 * variables we're planning to split.
184 if (nir_deref_instr_remove_if_unused(deref
))
187 if (!glsl_type_is_vector_or_scalar(deref
->type
))
190 nir_variable
*base_var
= nir_deref_instr_get_variable(deref
);
191 struct hash_entry
*entry
=
192 _mesa_hash_table_search(var_field_map
, base_var
);
196 struct field
*root_field
= entry
->data
;
199 nir_deref_path_init(&path
, deref
, mem_ctx
);
201 struct field
*tail_field
= root_field
;
202 for (unsigned i
= 0; path
.path
[i
]; i
++) {
203 if (path
.path
[i
]->deref_type
!= nir_deref_type_struct
)
207 assert(glsl_type_is_struct(path
.path
[i
- 1]->type
));
208 assert(path
.path
[i
- 1]->type
==
209 glsl_without_array(tail_field
->type
));
211 tail_field
= &tail_field
->fields
[path
.path
[i
]->strct
.index
];
213 nir_variable
*split_var
= tail_field
->var
;
215 nir_deref_instr
*new_deref
= NULL
;
216 for (unsigned i
= 0; path
.path
[i
]; i
++) {
217 nir_deref_instr
*p
= path
.path
[i
];
218 b
.cursor
= nir_after_instr(&p
->instr
);
220 switch (p
->deref_type
) {
221 case nir_deref_type_var
:
222 assert(new_deref
== NULL
);
223 new_deref
= nir_build_deref_var(&b
, split_var
);
226 case nir_deref_type_array
:
227 case nir_deref_type_array_wildcard
:
228 new_deref
= nir_build_deref_follower(&b
, new_deref
, p
);
231 case nir_deref_type_struct
:
232 /* Nothing to do; we're splitting structs */
236 unreachable("Invalid deref type in path");
240 assert(new_deref
->type
== deref
->type
);
241 nir_ssa_def_rewrite_uses(&deref
->dest
.ssa
,
242 nir_src_for_ssa(&new_deref
->dest
.ssa
));
243 nir_deref_instr_remove_if_unused(deref
);
248 /** A pass for splitting structs into multiple variables
250 * This pass splits arrays of structs into multiple variables, one for each
251 * (possibly nested) structure member. After this pass completes, no
252 * variables of the given mode will contain a struct type.
255 nir_split_struct_vars(nir_shader
*shader
, nir_variable_mode modes
)
257 void *mem_ctx
= ralloc_context(NULL
);
258 struct hash_table
*var_field_map
=
259 _mesa_hash_table_create(mem_ctx
, _mesa_hash_pointer
,
260 _mesa_key_pointer_equal
);
262 assert((modes
& (nir_var_global
| nir_var_local
)) == modes
);
264 bool has_global_splits
= false;
265 if (modes
& nir_var_global
) {
266 has_global_splits
= split_var_list_structs(shader
, NULL
,
268 var_field_map
, mem_ctx
);
271 bool progress
= false;
272 nir_foreach_function(function
, shader
) {
276 bool has_local_splits
= false;
277 if (modes
& nir_var_local
) {
278 has_local_splits
= split_var_list_structs(shader
, function
->impl
,
279 &function
->impl
->locals
,
280 var_field_map
, mem_ctx
);
283 if (has_global_splits
|| has_local_splits
) {
284 split_struct_derefs_impl(function
->impl
, var_field_map
,
287 nir_metadata_preserve(function
->impl
, nir_metadata_block_index
|
288 nir_metadata_dominance
);
293 ralloc_free(mem_ctx
);
298 struct array_level_info
{
304 /* Only set if this is the tail end of the splitting */
308 struct array_split
*splits
;
311 struct array_var_info
{
312 nir_variable
*base_var
;
314 const struct glsl_type
*split_var_type
;
317 struct array_split root_split
;
320 struct array_level_info levels
[0];
324 init_var_list_array_infos(struct exec_list
*vars
,
325 struct hash_table
*var_info_map
,
328 bool has_array
= false;
330 nir_foreach_variable(var
, vars
) {
331 int num_levels
= num_array_levels_in_array_of_vector_type(var
->type
);
335 struct array_var_info
*info
=
336 rzalloc_size(mem_ctx
, sizeof(*info
) +
337 num_levels
* sizeof(info
->levels
[0]));
339 info
->base_var
= var
;
340 info
->num_levels
= num_levels
;
342 const struct glsl_type
*type
= var
->type
;
343 for (int i
= 0; i
< num_levels
; i
++) {
344 info
->levels
[i
].array_len
= glsl_get_length(type
);
345 type
= glsl_get_array_element(type
);
347 /* All levels start out initially as split */
348 info
->levels
[i
].split
= true;
351 _mesa_hash_table_insert(var_info_map
, var
, info
);
358 static struct array_var_info
*
359 get_array_var_info(nir_variable
*var
,
360 struct hash_table
*var_info_map
)
362 struct hash_entry
*entry
=
363 _mesa_hash_table_search(var_info_map
, var
);
364 return entry
? entry
->data
: NULL
;
367 static struct array_var_info
*
368 get_array_deref_info(nir_deref_instr
*deref
,
369 struct hash_table
*var_info_map
,
370 nir_variable_mode modes
)
372 if (!(deref
->mode
& modes
))
375 return get_array_var_info(nir_deref_instr_get_variable(deref
),
380 mark_array_deref_used(nir_deref_instr
*deref
,
381 struct hash_table
*var_info_map
,
382 nir_variable_mode modes
,
385 struct array_var_info
*info
=
386 get_array_deref_info(deref
, var_info_map
, modes
);
391 nir_deref_path_init(&path
, deref
, mem_ctx
);
393 /* Walk the path and look for indirects. If we have an array deref with an
394 * indirect, mark the given level as not being split.
396 for (unsigned i
= 0; i
< info
->num_levels
; i
++) {
397 nir_deref_instr
*p
= path
.path
[i
+ 1];
398 if (p
->deref_type
== nir_deref_type_array
&&
399 nir_src_as_const_value(p
->arr
.index
) == NULL
)
400 info
->levels
[i
].split
= false;
405 mark_array_usage_impl(nir_function_impl
*impl
,
406 struct hash_table
*var_info_map
,
407 nir_variable_mode modes
,
410 nir_foreach_block(block
, impl
) {
411 nir_foreach_instr(instr
, block
) {
412 if (instr
->type
!= nir_instr_type_intrinsic
)
415 nir_intrinsic_instr
*intrin
= nir_instr_as_intrinsic(instr
);
416 switch (intrin
->intrinsic
) {
417 case nir_intrinsic_copy_deref
:
418 mark_array_deref_used(nir_src_as_deref(intrin
->src
[1]),
419 var_info_map
, modes
, mem_ctx
);
422 case nir_intrinsic_load_deref
:
423 case nir_intrinsic_store_deref
:
424 mark_array_deref_used(nir_src_as_deref(intrin
->src
[0]),
425 var_info_map
, modes
, mem_ctx
);
436 create_split_array_vars(struct array_var_info
*var_info
,
438 struct array_split
*split
,
441 nir_function_impl
*impl
,
444 while (level
< var_info
->num_levels
&& !var_info
->levels
[level
].split
) {
445 name
= ralloc_asprintf(mem_ctx
, "%s[*]", name
);
449 if (level
== var_info
->num_levels
) {
450 /* We add parens to the variable name so it looks like "(foo[2][*])" so
451 * that further derefs will look like "(foo[2][*])[ssa_6]"
453 name
= ralloc_asprintf(mem_ctx
, "(%s)", name
);
455 nir_variable_mode mode
= var_info
->base_var
->data
.mode
;
456 if (mode
== nir_var_local
) {
457 split
->var
= nir_local_variable_create(impl
,
458 var_info
->split_var_type
, name
);
460 split
->var
= nir_variable_create(shader
, mode
,
461 var_info
->split_var_type
, name
);
464 assert(var_info
->levels
[level
].split
);
465 split
->num_splits
= var_info
->levels
[level
].array_len
;
466 split
->splits
= rzalloc_array(mem_ctx
, struct array_split
,
468 for (unsigned i
= 0; i
< split
->num_splits
; i
++) {
469 create_split_array_vars(var_info
, level
+ 1, &split
->splits
[i
],
470 ralloc_asprintf(mem_ctx
, "%s[%d]", name
, i
),
471 shader
, impl
, mem_ctx
);
477 split_var_list_arrays(nir_shader
*shader
,
478 nir_function_impl
*impl
,
479 struct exec_list
*vars
,
480 struct hash_table
*var_info_map
,
483 struct exec_list split_vars
;
484 exec_list_make_empty(&split_vars
);
486 nir_foreach_variable_safe(var
, vars
) {
487 struct array_var_info
*info
= get_array_var_info(var
, var_info_map
);
491 bool has_split
= false;
492 const struct glsl_type
*split_type
=
493 glsl_without_array_or_matrix(var
->type
);
494 for (int i
= info
->num_levels
- 1; i
>= 0; i
--) {
495 if (info
->levels
[i
].split
) {
500 /* If the original type was a matrix type, we'd like to keep that so
501 * we don't convert matrices into arrays.
503 if (i
== info
->num_levels
- 1 &&
504 glsl_type_is_matrix(glsl_without_array(var
->type
))) {
505 split_type
= glsl_matrix_type(glsl_get_base_type(split_type
),
506 glsl_get_components(split_type
),
507 info
->levels
[i
].array_len
);
509 split_type
= glsl_array_type(split_type
, info
->levels
[i
].array_len
);
514 info
->split_var_type
= split_type
;
515 /* To avoid list confusion (we'll be adding things as we split
516 * variables), pull all of the variables we plan to split off of the
517 * main variable list.
519 exec_node_remove(&var
->node
);
520 exec_list_push_tail(&split_vars
, &var
->node
);
522 assert(split_type
== var
->type
);
523 /* If we're not modifying this variable, delete the info so we skip
524 * it faster in later passes.
526 _mesa_hash_table_remove_key(var_info_map
, var
);
530 nir_foreach_variable(var
, &split_vars
) {
531 struct array_var_info
*info
= get_array_var_info(var
, var_info_map
);
532 create_split_array_vars(info
, 0, &info
->root_split
, var
->name
,
533 shader
, impl
, mem_ctx
);
536 return !exec_list_is_empty(&split_vars
);
540 deref_has_split_wildcard(nir_deref_path
*path
,
541 struct array_var_info
*info
)
546 assert(path
->path
[0]->var
== info
->base_var
);
547 for (unsigned i
= 0; i
< info
->num_levels
; i
++) {
548 if (path
->path
[i
+ 1]->deref_type
== nir_deref_type_array_wildcard
&&
549 info
->levels
[i
].split
)
557 array_path_is_out_of_bounds(nir_deref_path
*path
,
558 struct array_var_info
*info
)
563 assert(path
->path
[0]->var
== info
->base_var
);
564 for (unsigned i
= 0; i
< info
->num_levels
; i
++) {
565 nir_deref_instr
*p
= path
->path
[i
+ 1];
566 if (p
->deref_type
== nir_deref_type_array_wildcard
)
569 nir_const_value
*const_index
= nir_src_as_const_value(p
->arr
.index
);
570 if (const_index
&& const_index
->u32
[0] >= info
->levels
[i
].array_len
)
578 emit_split_copies(nir_builder
*b
,
579 struct array_var_info
*dst_info
, nir_deref_path
*dst_path
,
580 unsigned dst_level
, nir_deref_instr
*dst
,
581 struct array_var_info
*src_info
, nir_deref_path
*src_path
,
582 unsigned src_level
, nir_deref_instr
*src
)
584 nir_deref_instr
*dst_p
, *src_p
;
586 while ((dst_p
= dst_path
->path
[dst_level
+ 1])) {
587 if (dst_p
->deref_type
== nir_deref_type_array_wildcard
)
590 dst
= nir_build_deref_follower(b
, dst
, dst_p
);
594 while ((src_p
= src_path
->path
[src_level
+ 1])) {
595 if (src_p
->deref_type
== nir_deref_type_array_wildcard
)
598 src
= nir_build_deref_follower(b
, src
, src_p
);
602 if (src_p
== NULL
|| dst_p
== NULL
) {
603 assert(src_p
== NULL
&& dst_p
== NULL
);
604 nir_copy_deref(b
, dst
, src
);
606 assert(dst_p
->deref_type
== nir_deref_type_array_wildcard
&&
607 src_p
->deref_type
== nir_deref_type_array_wildcard
);
609 if ((dst_info
&& dst_info
->levels
[dst_level
].split
) ||
610 (src_info
&& src_info
->levels
[src_level
].split
)) {
611 /* There are no indirects at this level on one of the source or the
612 * destination so we are lowering it.
614 assert(glsl_get_length(dst_path
->path
[dst_level
]->type
) ==
615 glsl_get_length(src_path
->path
[src_level
]->type
));
616 unsigned len
= glsl_get_length(dst_path
->path
[dst_level
]->type
);
617 for (unsigned i
= 0; i
< len
; i
++) {
618 nir_ssa_def
*idx
= nir_imm_int(b
, i
);
619 emit_split_copies(b
, dst_info
, dst_path
, dst_level
+ 1,
620 nir_build_deref_array(b
, dst
, idx
),
621 src_info
, src_path
, src_level
+ 1,
622 nir_build_deref_array(b
, src
, idx
));
625 /* Neither side is being split so we just keep going */
626 emit_split_copies(b
, dst_info
, dst_path
, dst_level
+ 1,
627 nir_build_deref_array_wildcard(b
, dst
),
628 src_info
, src_path
, src_level
+ 1,
629 nir_build_deref_array_wildcard(b
, src
));
635 split_array_copies_impl(nir_function_impl
*impl
,
636 struct hash_table
*var_info_map
,
637 nir_variable_mode modes
,
641 nir_builder_init(&b
, impl
);
643 nir_foreach_block(block
, impl
) {
644 nir_foreach_instr_safe(instr
, block
) {
645 if (instr
->type
!= nir_instr_type_intrinsic
)
648 nir_intrinsic_instr
*copy
= nir_instr_as_intrinsic(instr
);
649 if (copy
->intrinsic
!= nir_intrinsic_copy_deref
)
652 nir_deref_instr
*dst_deref
= nir_src_as_deref(copy
->src
[0]);
653 nir_deref_instr
*src_deref
= nir_src_as_deref(copy
->src
[1]);
655 struct array_var_info
*dst_info
=
656 get_array_deref_info(dst_deref
, var_info_map
, modes
);
657 struct array_var_info
*src_info
=
658 get_array_deref_info(src_deref
, var_info_map
, modes
);
660 if (!src_info
&& !dst_info
)
663 nir_deref_path dst_path
, src_path
;
664 nir_deref_path_init(&dst_path
, dst_deref
, mem_ctx
);
665 nir_deref_path_init(&src_path
, src_deref
, mem_ctx
);
667 if (!deref_has_split_wildcard(&dst_path
, dst_info
) &&
668 !deref_has_split_wildcard(&src_path
, src_info
))
671 b
.cursor
= nir_instr_remove(©
->instr
);
673 emit_split_copies(&b
, dst_info
, &dst_path
, 0, dst_path
.path
[0],
674 src_info
, &src_path
, 0, src_path
.path
[0]);
680 split_array_access_impl(nir_function_impl
*impl
,
681 struct hash_table
*var_info_map
,
682 nir_variable_mode modes
,
686 nir_builder_init(&b
, impl
);
688 nir_foreach_block(block
, impl
) {
689 nir_foreach_instr_safe(instr
, block
) {
690 if (instr
->type
== nir_instr_type_deref
) {
691 /* Clean up any dead derefs we find lying around. They may refer
692 * to variables we're planning to split.
694 nir_deref_instr
*deref
= nir_instr_as_deref(instr
);
695 if (deref
->mode
& modes
)
696 nir_deref_instr_remove_if_unused(deref
);
700 if (instr
->type
!= nir_instr_type_intrinsic
)
703 nir_intrinsic_instr
*intrin
= nir_instr_as_intrinsic(instr
);
704 if (intrin
->intrinsic
!= nir_intrinsic_load_deref
&&
705 intrin
->intrinsic
!= nir_intrinsic_store_deref
&&
706 intrin
->intrinsic
!= nir_intrinsic_copy_deref
)
709 const unsigned num_derefs
=
710 intrin
->intrinsic
== nir_intrinsic_copy_deref
? 2 : 1;
712 for (unsigned d
= 0; d
< num_derefs
; d
++) {
713 nir_deref_instr
*deref
= nir_src_as_deref(intrin
->src
[d
]);
715 struct array_var_info
*info
=
716 get_array_deref_info(deref
, var_info_map
, modes
);
721 nir_deref_path_init(&path
, deref
, mem_ctx
);
723 b
.cursor
= nir_before_instr(&intrin
->instr
);
725 if (array_path_is_out_of_bounds(&path
, info
)) {
726 /* If one of the derefs is out-of-bounds, we just delete the
727 * instruction. If a destination is out of bounds, then it may
728 * have been in-bounds prior to shrinking so we don't want to
729 * accidentally stomp something. However, we've already proven
730 * that it will never be read so it's safe to delete. If a
731 * source is out of bounds then it is loading random garbage.
732 * For loads, we replace their uses with an undef instruction
733 * and for copies we just delete the copy since it was writing
734 * undefined garbage anyway and we may as well leave the random
735 * garbage in the destination alone.
737 if (intrin
->intrinsic
== nir_intrinsic_load_deref
) {
739 nir_ssa_undef(&b
, intrin
->dest
.ssa
.num_components
,
740 intrin
->dest
.ssa
.bit_size
);
741 nir_ssa_def_rewrite_uses(&intrin
->dest
.ssa
,
744 nir_instr_remove(&intrin
->instr
);
745 for (unsigned i
= 0; i
< num_derefs
; i
++)
746 nir_deref_instr_remove_if_unused(nir_src_as_deref(intrin
->src
[i
]));
750 struct array_split
*split
= &info
->root_split
;
751 for (unsigned i
= 0; i
< info
->num_levels
; i
++) {
752 if (info
->levels
[i
].split
) {
753 nir_deref_instr
*p
= path
.path
[i
+ 1];
754 unsigned index
= nir_src_as_const_value(p
->arr
.index
)->u32
[0];
755 assert(index
< info
->levels
[i
].array_len
);
756 split
= &split
->splits
[index
];
759 assert(!split
->splits
&& split
->var
);
761 nir_deref_instr
*new_deref
= nir_build_deref_var(&b
, split
->var
);
762 for (unsigned i
= 0; i
< info
->num_levels
; i
++) {
763 if (!info
->levels
[i
].split
) {
764 new_deref
= nir_build_deref_follower(&b
, new_deref
,
768 assert(new_deref
->type
== deref
->type
);
770 /* Rewrite the deref source to point to the split one */
771 nir_instr_rewrite_src(&intrin
->instr
, &intrin
->src
[d
],
772 nir_src_for_ssa(&new_deref
->dest
.ssa
));
773 nir_deref_instr_remove_if_unused(deref
);
779 /** A pass for splitting arrays of vectors into multiple variables
781 * This pass looks at arrays (possibly multiple levels) of vectors (not
782 * structures or other types) and tries to split them into piles of variables,
783 * one for each array element. The heuristic used is simple: If a given array
784 * level is never used with an indirect, that array level will get split.
786 * This pass probably could handles structures easily enough but making a pass
787 * that could see through an array of structures of arrays would be difficult
788 * so it's best to just run nir_split_struct_vars first.
791 nir_split_array_vars(nir_shader
*shader
, nir_variable_mode modes
)
793 void *mem_ctx
= ralloc_context(NULL
);
794 struct hash_table
*var_info_map
=
795 _mesa_hash_table_create(mem_ctx
, _mesa_hash_pointer
,
796 _mesa_key_pointer_equal
);
798 assert((modes
& (nir_var_global
| nir_var_local
)) == modes
);
800 bool has_global_array
= false;
801 if (modes
& nir_var_global
) {
802 has_global_array
= init_var_list_array_infos(&shader
->globals
,
803 var_info_map
, mem_ctx
);
806 bool has_any_array
= false;
807 nir_foreach_function(function
, shader
) {
811 bool has_local_array
= false;
812 if (modes
& nir_var_local
) {
813 has_local_array
= init_var_list_array_infos(&function
->impl
->locals
,
814 var_info_map
, mem_ctx
);
817 if (has_global_array
|| has_local_array
) {
818 has_any_array
= true;
819 mark_array_usage_impl(function
->impl
, var_info_map
, modes
, mem_ctx
);
823 /* If we failed to find any arrays of arrays, bail early. */
824 if (!has_any_array
) {
825 ralloc_free(mem_ctx
);
829 bool has_global_splits
= false;
830 if (modes
& nir_var_global
) {
831 has_global_splits
= split_var_list_arrays(shader
, NULL
,
833 var_info_map
, mem_ctx
);
836 bool progress
= false;
837 nir_foreach_function(function
, shader
) {
841 bool has_local_splits
= false;
842 if (modes
& nir_var_local
) {
843 has_local_splits
= split_var_list_arrays(shader
, function
->impl
,
844 &function
->impl
->locals
,
845 var_info_map
, mem_ctx
);
848 if (has_global_splits
|| has_local_splits
) {
849 split_array_copies_impl(function
->impl
, var_info_map
, modes
, mem_ctx
);
850 split_array_access_impl(function
->impl
, var_info_map
, modes
, mem_ctx
);
852 nir_metadata_preserve(function
->impl
, nir_metadata_block_index
|
853 nir_metadata_dominance
);
858 ralloc_free(mem_ctx
);
863 struct array_level_usage
{
866 /* The value UINT_MAX will be used to indicate an indirect */
868 unsigned max_written
;
870 /* True if there is a copy that isn't to/from a shrinkable array */
871 bool has_external_copy
;
872 struct set
*levels_copied
;
875 struct vec_var_usage
{
876 /* Convenience set of all components this variable has */
877 nir_component_mask_t all_comps
;
879 nir_component_mask_t comps_read
;
880 nir_component_mask_t comps_written
;
882 nir_component_mask_t comps_kept
;
884 /* True if there is a copy that isn't to/from a shrinkable vector */
885 bool has_external_copy
;
886 struct set
*vars_copied
;
889 struct array_level_usage levels
[0];
892 static struct vec_var_usage
*
893 get_vec_var_usage(nir_variable
*var
,
894 struct hash_table
*var_usage_map
,
895 bool add_usage_entry
, void *mem_ctx
)
897 struct hash_entry
*entry
= _mesa_hash_table_search(var_usage_map
, var
);
901 if (!add_usage_entry
)
904 /* Check to make sure that we are working with an array of vectors. We
905 * don't bother to shrink single vectors because we figure that we can
906 * clean it up better with SSA than by inserting piles of vecN instructions
907 * to compact results.
909 int num_levels
= num_array_levels_in_array_of_vector_type(var
->type
);
911 return NULL
; /* Not an array of vectors */
913 struct vec_var_usage
*usage
=
914 rzalloc_size(mem_ctx
, sizeof(*usage
) +
915 num_levels
* sizeof(usage
->levels
[0]));
917 usage
->num_levels
= num_levels
;
918 const struct glsl_type
*type
= var
->type
;
919 for (unsigned i
= 0; i
< num_levels
; i
++) {
920 usage
->levels
[i
].array_len
= glsl_get_length(type
);
921 type
= glsl_get_array_element(type
);
923 assert(glsl_type_is_vector_or_scalar(type
));
925 usage
->all_comps
= (1 << glsl_get_components(type
)) - 1;
927 _mesa_hash_table_insert(var_usage_map
, var
, usage
);
932 static struct vec_var_usage
*
933 get_vec_deref_usage(nir_deref_instr
*deref
,
934 struct hash_table
*var_usage_map
,
935 nir_variable_mode modes
,
936 bool add_usage_entry
, void *mem_ctx
)
938 if (!(deref
->mode
& modes
))
941 return get_vec_var_usage(nir_deref_instr_get_variable(deref
),
942 var_usage_map
, add_usage_entry
, mem_ctx
);
946 mark_deref_used(nir_deref_instr
*deref
,
947 nir_component_mask_t comps_read
,
948 nir_component_mask_t comps_written
,
949 nir_deref_instr
*copy_deref
,
950 struct hash_table
*var_usage_map
,
951 nir_variable_mode modes
,
954 if (!(deref
->mode
& modes
))
957 nir_variable
*var
= nir_deref_instr_get_variable(deref
);
959 struct vec_var_usage
*usage
=
960 get_vec_var_usage(var
, var_usage_map
, true, mem_ctx
);
964 usage
->comps_read
|= comps_read
& usage
->all_comps
;
965 usage
->comps_written
|= comps_written
& usage
->all_comps
;
967 struct vec_var_usage
*copy_usage
= NULL
;
969 copy_usage
= get_vec_deref_usage(copy_deref
, var_usage_map
, modes
,
972 if (usage
->vars_copied
== NULL
) {
973 usage
->vars_copied
= _mesa_set_create(mem_ctx
, _mesa_hash_pointer
,
974 _mesa_key_pointer_equal
);
976 _mesa_set_add(usage
->vars_copied
, copy_usage
);
978 usage
->has_external_copy
= true;
983 nir_deref_path_init(&path
, deref
, mem_ctx
);
985 nir_deref_path copy_path
;
987 nir_deref_path_init(©_path
, copy_deref
, mem_ctx
);
990 for (unsigned i
= 0; i
< usage
->num_levels
; i
++) {
991 struct array_level_usage
*level
= &usage
->levels
[i
];
992 nir_deref_instr
*deref
= path
.path
[i
+ 1];
993 assert(deref
->deref_type
== nir_deref_type_array
||
994 deref
->deref_type
== nir_deref_type_array_wildcard
);
997 if (deref
->deref_type
== nir_deref_type_array
) {
998 nir_const_value
*const_index
=
999 nir_src_as_const_value(deref
->arr
.index
);
1000 max_used
= const_index
? const_index
->u32
[0] : UINT_MAX
;
1002 /* For wildcards, we read or wrote the whole thing. */
1003 assert(deref
->deref_type
== nir_deref_type_array_wildcard
);
1004 max_used
= level
->array_len
- 1;
1007 /* Match each wildcard level with the level on copy_usage */
1008 for (; copy_path
.path
[copy_i
+ 1]; copy_i
++) {
1009 if (copy_path
.path
[copy_i
+ 1]->deref_type
==
1010 nir_deref_type_array_wildcard
)
1013 struct array_level_usage
*copy_level
=
1014 ©_usage
->levels
[copy_i
++];
1016 if (level
->levels_copied
== NULL
) {
1017 level
->levels_copied
=
1018 _mesa_set_create(mem_ctx
, _mesa_hash_pointer
,
1019 _mesa_key_pointer_equal
);
1021 _mesa_set_add(level
->levels_copied
, copy_level
);
1023 /* We have a wildcard and it comes from a variable we aren't
1024 * tracking; flag it and we'll know to not shorten this array.
1026 level
->has_external_copy
= true;
1031 level
->max_written
= MAX2(level
->max_written
, max_used
);
1033 level
->max_read
= MAX2(level
->max_read
, max_used
);
1038 src_is_load_deref(nir_src src
, nir_src deref_src
)
1041 assert(deref_src
.is_ssa
);
1043 if (src
.ssa
->parent_instr
->type
!= nir_instr_type_intrinsic
)
1046 nir_intrinsic_instr
*load
= nir_instr_as_intrinsic(src
.ssa
->parent_instr
);
1047 if (load
->intrinsic
!= nir_intrinsic_load_deref
)
1050 assert(load
->src
[0].is_ssa
);
1052 return load
->src
[0].ssa
== deref_src
.ssa
;
1055 /* Returns all non-self-referential components of a store instruction. A
1056 * component is self-referential if it comes from the same component of a load
1057 * instruction on the same deref. If the only data in a particular component
1058 * of a variable came directly from that component then it's undefined. The
1059 * only way to get defined data into a component of a variable is for it to
1060 * get written there by something outside or from a different component.
1062 * This is a fairly common pattern in shaders that come from either GLSL IR or
1063 * GLSLang because both glsl_to_nir and GLSLang implement write-masking with
1066 static nir_component_mask_t
1067 get_non_self_referential_store_comps(nir_intrinsic_instr
*store
)
1069 nir_component_mask_t comps
= nir_intrinsic_write_mask(store
);
1071 assert(store
->src
[1].is_ssa
);
1072 nir_instr
*src_instr
= store
->src
[1].ssa
->parent_instr
;
1073 if (src_instr
->type
!= nir_instr_type_alu
)
1076 nir_alu_instr
*src_alu
= nir_instr_as_alu(src_instr
);
1078 if (src_alu
->op
== nir_op_imov
||
1079 src_alu
->op
== nir_op_fmov
) {
1080 /* If it's just a swizzle of a load from the same deref, discount any
1081 * channels that don't move in the swizzle.
1083 if (src_is_load_deref(src_alu
->src
[0].src
, store
->src
[0])) {
1084 for (unsigned i
= 0; i
< NIR_MAX_VEC_COMPONENTS
; i
++) {
1085 if (src_alu
->src
[0].swizzle
[i
] == i
)
1086 comps
&= ~(1u << i
);
1089 } else if (src_alu
->op
== nir_op_vec2
||
1090 src_alu
->op
== nir_op_vec3
||
1091 src_alu
->op
== nir_op_vec4
) {
1092 /* If it's a vec, discount any channels that are just loads from the
1093 * same deref put in the same spot.
1095 for (unsigned i
= 0; i
< nir_op_infos
[src_alu
->op
].num_inputs
; i
++) {
1096 if (src_is_load_deref(src_alu
->src
[i
].src
, store
->src
[0]) &&
1097 src_alu
->src
[i
].swizzle
[0] == i
)
1098 comps
&= ~(1u << i
);
1106 find_used_components_impl(nir_function_impl
*impl
,
1107 struct hash_table
*var_usage_map
,
1108 nir_variable_mode modes
,
1111 nir_foreach_block(block
, impl
) {
1112 nir_foreach_instr(instr
, block
) {
1113 if (instr
->type
!= nir_instr_type_intrinsic
)
1116 nir_intrinsic_instr
*intrin
= nir_instr_as_intrinsic(instr
);
1117 switch (intrin
->intrinsic
) {
1118 case nir_intrinsic_load_deref
:
1119 mark_deref_used(nir_src_as_deref(intrin
->src
[0]),
1120 nir_ssa_def_components_read(&intrin
->dest
.ssa
), 0,
1121 NULL
, var_usage_map
, modes
, mem_ctx
);
1124 case nir_intrinsic_store_deref
:
1125 mark_deref_used(nir_src_as_deref(intrin
->src
[0]),
1126 0, get_non_self_referential_store_comps(intrin
),
1127 NULL
, var_usage_map
, modes
, mem_ctx
);
1130 case nir_intrinsic_copy_deref
: {
1131 /* Just mark everything used for copies. */
1132 nir_deref_instr
*dst
= nir_src_as_deref(intrin
->src
[0]);
1133 nir_deref_instr
*src
= nir_src_as_deref(intrin
->src
[1]);
1134 mark_deref_used(dst
, 0, ~0, src
, var_usage_map
, modes
, mem_ctx
);
1135 mark_deref_used(src
, ~0, 0, dst
, var_usage_map
, modes
, mem_ctx
);
1147 shrink_vec_var_list(struct exec_list
*vars
,
1148 struct hash_table
*var_usage_map
)
1150 /* Initialize the components kept field of each variable. This is the
1151 * AND of the components written and components read. If a component is
1152 * written but never read, it's dead. If it is read but never written,
1153 * then all values read are undefined garbage and we may as well not read
1156 * The same logic applies to the array length. We make the array length
1157 * the minimum needed required length between read and write and plan to
1158 * discard any OOB access. The one exception here is indirect writes
1159 * because we don't know where they will land and we can't shrink an array
1160 * with indirect writes because previously in-bounds writes may become
1161 * out-of-bounds and have undefined behavior.
1163 * Also, if we have a copy that to/from something we can't shrink, we need
1164 * to leave components and array_len of any wildcards alone.
1166 nir_foreach_variable(var
, vars
) {
1167 struct vec_var_usage
*usage
=
1168 get_vec_var_usage(var
, var_usage_map
, false, NULL
);
1172 assert(usage
->comps_kept
== 0);
1173 if (usage
->has_external_copy
)
1174 usage
->comps_kept
= usage
->all_comps
;
1176 usage
->comps_kept
= usage
->comps_read
& usage
->comps_written
;
1178 for (unsigned i
= 0; i
< usage
->num_levels
; i
++) {
1179 struct array_level_usage
*level
= &usage
->levels
[i
];
1180 assert(level
->array_len
> 0);
1182 if (level
->max_written
== UINT_MAX
|| level
->has_external_copy
)
1183 continue; /* Can't shrink */
1185 unsigned max_used
= MIN2(level
->max_read
, level
->max_written
);
1186 level
->array_len
= MIN2(max_used
, level
->array_len
- 1) + 1;
1190 /* In order for variable copies to work, we have to have the same data type
1191 * on the source and the destination. In order to satisfy this, we run a
1192 * little fixed-point algorithm to transitively ensure that we get enough
1193 * components and array elements for this to hold for all copies.
1197 fp_progress
= false;
1198 nir_foreach_variable(var
, vars
) {
1199 struct vec_var_usage
*var_usage
=
1200 get_vec_var_usage(var
, var_usage_map
, false, NULL
);
1201 if (!var_usage
|| !var_usage
->vars_copied
)
1204 struct set_entry
*copy_entry
;
1205 set_foreach(var_usage
->vars_copied
, copy_entry
) {
1206 struct vec_var_usage
*copy_usage
= (void *)copy_entry
->key
;
1207 if (copy_usage
->comps_kept
!= var_usage
->comps_kept
) {
1208 nir_component_mask_t comps_kept
=
1209 (var_usage
->comps_kept
| copy_usage
->comps_kept
);
1210 var_usage
->comps_kept
= comps_kept
;
1211 copy_usage
->comps_kept
= comps_kept
;
1216 for (unsigned i
= 0; i
< var_usage
->num_levels
; i
++) {
1217 struct array_level_usage
*var_level
= &var_usage
->levels
[i
];
1218 if (!var_level
->levels_copied
)
1221 set_foreach(var_level
->levels_copied
, copy_entry
) {
1222 struct array_level_usage
*copy_level
= (void *)copy_entry
->key
;
1223 if (var_level
->array_len
!= copy_level
->array_len
) {
1224 unsigned array_len
=
1225 MAX2(var_level
->array_len
, copy_level
->array_len
);
1226 var_level
->array_len
= array_len
;
1227 copy_level
->array_len
= array_len
;
1233 } while (fp_progress
);
1235 bool vars_shrunk
= false;
1236 nir_foreach_variable_safe(var
, vars
) {
1237 struct vec_var_usage
*usage
=
1238 get_vec_var_usage(var
, var_usage_map
, false, NULL
);
1242 bool shrunk
= false;
1243 const struct glsl_type
*vec_type
= var
->type
;
1244 for (unsigned i
= 0; i
< usage
->num_levels
; i
++) {
1245 /* If we've reduced the array to zero elements at some level, just
1246 * set comps_kept to 0 and delete the variable.
1248 if (usage
->levels
[i
].array_len
== 0) {
1249 usage
->comps_kept
= 0;
1253 assert(usage
->levels
[i
].array_len
<= glsl_get_length(vec_type
));
1254 if (usage
->levels
[i
].array_len
< glsl_get_length(vec_type
))
1256 vec_type
= glsl_get_array_element(vec_type
);
1258 assert(glsl_type_is_vector_or_scalar(vec_type
));
1260 assert(usage
->comps_kept
== (usage
->comps_kept
& usage
->all_comps
));
1261 if (usage
->comps_kept
!= usage
->all_comps
)
1264 if (usage
->comps_kept
== 0) {
1265 /* This variable is dead, remove it */
1267 exec_node_remove(&var
->node
);
1272 /* This variable doesn't need to be shrunk. Remove it from the
1273 * hash table so later steps will ignore it.
1275 _mesa_hash_table_remove_key(var_usage_map
, var
);
1279 /* Build the new var type */
1280 unsigned new_num_comps
= util_bitcount(usage
->comps_kept
);
1281 const struct glsl_type
*new_type
=
1282 glsl_vector_type(glsl_get_base_type(vec_type
), new_num_comps
);
1283 for (int i
= usage
->num_levels
- 1; i
>= 0; i
--) {
1284 assert(usage
->levels
[i
].array_len
> 0);
1285 /* If the original type was a matrix type, we'd like to keep that so
1286 * we don't convert matrices into arrays.
1288 if (i
== usage
->num_levels
- 1 &&
1289 glsl_type_is_matrix(glsl_without_array(var
->type
)) &&
1290 new_num_comps
> 1 && usage
->levels
[i
].array_len
> 1) {
1291 new_type
= glsl_matrix_type(glsl_get_base_type(new_type
),
1293 usage
->levels
[i
].array_len
);
1295 new_type
= glsl_array_type(new_type
, usage
->levels
[i
].array_len
);
1298 var
->type
= new_type
;
1307 vec_deref_is_oob(nir_deref_instr
*deref
,
1308 struct vec_var_usage
*usage
)
1310 nir_deref_path path
;
1311 nir_deref_path_init(&path
, deref
, NULL
);
1314 for (unsigned i
= 0; i
< usage
->num_levels
; i
++) {
1315 nir_deref_instr
*p
= path
.path
[i
+ 1];
1316 if (p
->deref_type
== nir_deref_type_array_wildcard
)
1319 nir_const_value
*const_index
= nir_src_as_const_value(p
->arr
.index
);
1320 if (const_index
&& const_index
->u32
[0] >= usage
->levels
[i
].array_len
) {
1326 nir_deref_path_finish(&path
);
1332 vec_deref_is_dead_or_oob(nir_deref_instr
*deref
,
1333 struct hash_table
*var_usage_map
,
1334 nir_variable_mode modes
)
1336 struct vec_var_usage
*usage
=
1337 get_vec_deref_usage(deref
, var_usage_map
, modes
, false, NULL
);
1341 return usage
->comps_kept
== 0 || vec_deref_is_oob(deref
, usage
);
1345 shrink_vec_var_access_impl(nir_function_impl
*impl
,
1346 struct hash_table
*var_usage_map
,
1347 nir_variable_mode modes
)
1350 nir_builder_init(&b
, impl
);
1352 nir_foreach_block(block
, impl
) {
1353 nir_foreach_instr_safe(instr
, block
) {
1354 switch (instr
->type
) {
1355 case nir_instr_type_deref
: {
1356 nir_deref_instr
*deref
= nir_instr_as_deref(instr
);
1357 if (!(deref
->mode
& modes
))
1360 /* Clean up any dead derefs we find lying around. They may refer
1361 * to variables we've deleted.
1363 if (nir_deref_instr_remove_if_unused(deref
))
1366 /* Update the type in the deref to keep the types consistent as
1367 * you walk down the chain. We don't need to check if this is one
1368 * of the derefs we're shrinking because this is a no-op if it
1369 * isn't. The worst that could happen is that we accidentally fix
1372 if (deref
->deref_type
== nir_deref_type_var
) {
1373 deref
->type
= deref
->var
->type
;
1374 } else if (deref
->deref_type
== nir_deref_type_array
||
1375 deref
->deref_type
== nir_deref_type_array_wildcard
) {
1376 nir_deref_instr
*parent
= nir_deref_instr_parent(deref
);
1377 assert(glsl_type_is_array(parent
->type
) ||
1378 glsl_type_is_matrix(parent
->type
));
1379 deref
->type
= glsl_get_array_element(parent
->type
);
1384 case nir_instr_type_intrinsic
: {
1385 nir_intrinsic_instr
*intrin
= nir_instr_as_intrinsic(instr
);
1387 /* If we have a copy whose source or destination has been deleted
1388 * because we determined the variable was dead, then we just
1389 * delete the copy instruction. If the source variable was dead
1390 * then it was writing undefined garbage anyway and if it's the
1391 * destination variable that's dead then the write isn't needed.
1393 if (intrin
->intrinsic
== nir_intrinsic_copy_deref
) {
1394 nir_deref_instr
*dst
= nir_src_as_deref(intrin
->src
[0]);
1395 nir_deref_instr
*src
= nir_src_as_deref(intrin
->src
[1]);
1396 if (vec_deref_is_dead_or_oob(dst
, var_usage_map
, modes
) ||
1397 vec_deref_is_dead_or_oob(src
, var_usage_map
, modes
)) {
1398 nir_instr_remove(&intrin
->instr
);
1399 nir_deref_instr_remove_if_unused(dst
);
1400 nir_deref_instr_remove_if_unused(src
);
1405 if (intrin
->intrinsic
!= nir_intrinsic_load_deref
&&
1406 intrin
->intrinsic
!= nir_intrinsic_store_deref
)
1409 nir_deref_instr
*deref
= nir_src_as_deref(intrin
->src
[0]);
1410 if (!(deref
->mode
& modes
))
1413 struct vec_var_usage
*usage
=
1414 get_vec_deref_usage(deref
, var_usage_map
, modes
, false, NULL
);
1418 if (usage
->comps_kept
== 0 || vec_deref_is_oob(deref
, usage
)) {
1419 if (intrin
->intrinsic
== nir_intrinsic_load_deref
) {
1421 nir_ssa_undef(&b
, intrin
->dest
.ssa
.num_components
,
1422 intrin
->dest
.ssa
.bit_size
);
1423 nir_ssa_def_rewrite_uses(&intrin
->dest
.ssa
,
1424 nir_src_for_ssa(u
));
1426 nir_instr_remove(&intrin
->instr
);
1427 nir_deref_instr_remove_if_unused(deref
);
1431 if (intrin
->intrinsic
== nir_intrinsic_load_deref
) {
1432 b
.cursor
= nir_after_instr(&intrin
->instr
);
1434 nir_ssa_def
*undef
=
1435 nir_ssa_undef(&b
, 1, intrin
->dest
.ssa
.bit_size
);
1436 nir_ssa_def
*vec_srcs
[NIR_MAX_VEC_COMPONENTS
];
1438 for (unsigned i
= 0; i
< intrin
->num_components
; i
++) {
1439 if (usage
->comps_kept
& (1u << i
))
1440 vec_srcs
[i
] = nir_channel(&b
, &intrin
->dest
.ssa
, c
++);
1442 vec_srcs
[i
] = undef
;
1444 nir_ssa_def
*vec
= nir_vec(&b
, vec_srcs
, intrin
->num_components
);
1446 nir_ssa_def_rewrite_uses_after(&intrin
->dest
.ssa
,
1447 nir_src_for_ssa(vec
),
1450 /* The SSA def is now only used by the swizzle. It's safe to
1451 * shrink the number of components.
1453 assert(list_length(&intrin
->dest
.ssa
.uses
) == c
);
1454 intrin
->num_components
= c
;
1455 intrin
->dest
.ssa
.num_components
= c
;
1457 nir_component_mask_t write_mask
=
1458 nir_intrinsic_write_mask(intrin
);
1460 unsigned swizzle
[NIR_MAX_VEC_COMPONENTS
];
1461 nir_component_mask_t new_write_mask
= 0;
1463 for (unsigned i
= 0; i
< intrin
->num_components
; i
++) {
1464 if (usage
->comps_kept
& (1u << i
)) {
1466 if (write_mask
& (1u << i
))
1467 new_write_mask
|= 1u << c
;
1472 b
.cursor
= nir_before_instr(&intrin
->instr
);
1474 nir_ssa_def
*swizzled
=
1475 nir_swizzle(&b
, intrin
->src
[1].ssa
, swizzle
, c
, false);
1477 /* Rewrite to use the compacted source */
1478 nir_instr_rewrite_src(&intrin
->instr
, &intrin
->src
[1],
1479 nir_src_for_ssa(swizzled
));
1480 nir_intrinsic_set_write_mask(intrin
, new_write_mask
);
1481 intrin
->num_components
= c
;
1494 function_impl_has_vars_with_modes(nir_function_impl
*impl
,
1495 nir_variable_mode modes
)
1497 nir_shader
*shader
= impl
->function
->shader
;
1499 if ((modes
& nir_var_global
) && !exec_list_is_empty(&shader
->globals
))
1502 if ((modes
& nir_var_local
) && !exec_list_is_empty(&impl
->locals
))
1508 /** Attempt to shrink arrays of vectors
1510 * This pass looks at variables which contain a vector or an array (possibly
1511 * multiple dimensions) of vectors and attempts to lower to a smaller vector
1512 * or array. If the pass can prove that a component of a vector (or array of
1513 * vectors) is never really used, then that component will be removed.
1514 * Similarly, the pass attempts to shorten arrays based on what elements it
1515 * can prove are never read or never contain valid data.
1518 nir_shrink_vec_array_vars(nir_shader
*shader
, nir_variable_mode modes
)
1520 assert((modes
& (nir_var_global
| nir_var_local
)) == modes
);
1522 void *mem_ctx
= ralloc_context(NULL
);
1524 struct hash_table
*var_usage_map
=
1525 _mesa_hash_table_create(mem_ctx
, _mesa_hash_pointer
,
1526 _mesa_key_pointer_equal
);
1528 bool has_vars_to_shrink
= false;
1529 nir_foreach_function(function
, shader
) {
1530 if (!function
->impl
)
1533 /* Don't even bother crawling the IR if we don't have any variables.
1534 * Given that this pass deletes any unused variables, it's likely that
1535 * we will be in this scenario eventually.
1537 if (function_impl_has_vars_with_modes(function
->impl
, modes
)) {
1538 has_vars_to_shrink
= true;
1539 find_used_components_impl(function
->impl
, var_usage_map
,
1543 if (!has_vars_to_shrink
) {
1544 ralloc_free(mem_ctx
);
1548 bool globals_shrunk
= false;
1549 if (modes
& nir_var_global
)
1550 globals_shrunk
= shrink_vec_var_list(&shader
->globals
, var_usage_map
);
1552 bool progress
= false;
1553 nir_foreach_function(function
, shader
) {
1554 if (!function
->impl
)
1557 bool locals_shrunk
= false;
1558 if (modes
& nir_var_local
) {
1559 locals_shrunk
= shrink_vec_var_list(&function
->impl
->locals
,
1563 if (globals_shrunk
|| locals_shrunk
) {
1564 shrink_vec_var_access_impl(function
->impl
, var_usage_map
, modes
);
1566 nir_metadata_preserve(function
->impl
, nir_metadata_block_index
|
1567 nir_metadata_dominance
);
1572 ralloc_free(mem_ctx
);