Commit 40ca129e authored by Jason Ekstrand's avatar Jason Ekstrand
Browse files

nir: Rename parallel_copy_copy to parallel_copy_entry and add a foreach macro



parallel_copy_copy was a silly name.  Also, things were getting long and
annoying, so I added a foreach macro.  For historical reasons, several of
the original iterations over parallel copy entries in from_ssa used the
_safe variants of the loop.  However, all of these no longer ever remove an
entry so it's ok to make them all use the normal iterator.
Reviewed-by: default avatarConnor Abbott <cwabbott0@gmail.com>
parent 1b720c6e
......@@ -474,7 +474,7 @@ nir_parallel_copy_instr_create(void *mem_ctx)
nir_parallel_copy_instr *instr = ralloc(mem_ctx, nir_parallel_copy_instr);
instr_init(&instr->instr, nir_instr_type_parallel_copy);
exec_list_make_empty(&instr->copies);
exec_list_make_empty(&instr->entries);
return instr;
}
......@@ -1413,8 +1413,8 @@ static bool
visit_parallel_copy_dest(nir_parallel_copy_instr *instr,
nir_foreach_dest_cb cb, void *state)
{
foreach_list_typed(nir_parallel_copy_copy, copy, node, &instr->copies) {
if (!cb(&copy->dest, state))
nir_foreach_parallel_copy_entry(instr, entry) {
if (!cb(&entry->dest, state))
return false;
}
......@@ -1596,8 +1596,8 @@ static bool
visit_parallel_copy_src(nir_parallel_copy_instr *instr,
nir_foreach_src_cb cb, void *state)
{
foreach_list_typed(nir_parallel_copy_copy, copy, node, &instr->copies) {
if (!visit_src(&copy->src, cb, state))
nir_foreach_parallel_copy_entry(instr, entry) {
if (!visit_src(&entry->src, cb, state))
return false;
}
......
......@@ -962,11 +962,20 @@ typedef struct {
struct exec_node node;
nir_src src;
nir_dest dest;
} nir_parallel_copy_copy;
} nir_parallel_copy_entry;
#define nir_foreach_parallel_copy_entry(pcopy, entry) \
foreach_list_typed(nir_parallel_copy_entry, entry, node, &(pcopy)->entries)
typedef struct {
nir_instr instr;
struct exec_list copies;
/* A list of nir_parallel_copy_entry's. The sources of all of the
* entries are copied to the corresponding destinations "in parallel".
* In other words, if we have two entries: a -> b and b -> a, the values
* get swapped.
*/
struct exec_list entries;
} nir_parallel_copy_instr;
NIR_DEFINE_CAST(nir_instr_as_alu, nir_instr, nir_alu_instr, instr)
......
......@@ -348,22 +348,22 @@ isolate_phi_nodes_block(nir_block *block, void *void_state)
get_parallel_copy_at_end_of_block(src->pred);
assert(pcopy);
nir_parallel_copy_copy *copy = ralloc(state->dead_ctx,
nir_parallel_copy_copy);
exec_list_push_tail(&pcopy->copies, &copy->node);
nir_parallel_copy_entry *entry = ralloc(state->dead_ctx,
nir_parallel_copy_entry);
exec_list_push_tail(&pcopy->entries, &entry->node);
copy->src = nir_src_copy(src->src, state->dead_ctx);
entry->src = nir_src_copy(src->src, state->dead_ctx);
_mesa_set_add(src->src.ssa->uses,
_mesa_hash_pointer(&pcopy->instr), &pcopy->instr);
copy->dest.is_ssa = true;
nir_ssa_def_init(&pcopy->instr, &copy->dest.ssa,
entry->dest.is_ssa = true;
nir_ssa_def_init(&pcopy->instr, &entry->dest.ssa,
phi->dest.ssa.num_components, src->src.ssa->name);
struct set_entry *entry = _mesa_set_search(src->src.ssa->uses,
_mesa_hash_pointer(instr),
instr);
if (entry)
struct set_entry *use_entry =
_mesa_set_search(src->src.ssa->uses,
_mesa_hash_pointer(instr), instr);
if (use_entry)
/* It is possible that a phi node can use the same source twice
* but for different basic blocks. If that happens, entry will
* be NULL because we already deleted it. This is safe
......@@ -371,28 +371,28 @@ isolate_phi_nodes_block(nir_block *block, void *void_state)
* all of the sources of the phi from their respective use sets
* and moved them to the parallel copy definitions.
*/
_mesa_set_remove(src->src.ssa->uses, entry);
_mesa_set_remove(src->src.ssa->uses, use_entry);
src->src.ssa = &copy->dest.ssa;
_mesa_set_add(copy->dest.ssa.uses, _mesa_hash_pointer(instr), instr);
src->src.ssa = &entry->dest.ssa;
_mesa_set_add(entry->dest.ssa.uses, _mesa_hash_pointer(instr), instr);
}
nir_parallel_copy_copy *copy = ralloc(state->dead_ctx,
nir_parallel_copy_copy);
exec_list_push_tail(&block_pcopy->copies, &copy->node);
nir_parallel_copy_entry *entry = ralloc(state->dead_ctx,
nir_parallel_copy_entry);
exec_list_push_tail(&block_pcopy->entries, &entry->node);
copy->dest.is_ssa = true;
nir_ssa_def_init(&block_pcopy->instr, &copy->dest.ssa,
entry->dest.is_ssa = true;
nir_ssa_def_init(&block_pcopy->instr, &entry->dest.ssa,
phi->dest.ssa.num_components, phi->dest.ssa.name);
nir_src copy_dest_src = {
.ssa = &copy->dest.ssa,
nir_src entry_dest_src = {
.ssa = &entry->dest.ssa,
.is_ssa = true,
};
nir_ssa_def_rewrite_uses(&phi->dest.ssa, copy_dest_src, state->mem_ctx);
nir_ssa_def_rewrite_uses(&phi->dest.ssa, entry_dest_src, state->mem_ctx);
copy->src.is_ssa = true;
copy->src.ssa = &phi->dest.ssa;
entry->src.is_ssa = true;
entry->src.ssa = &phi->dest.ssa;
_mesa_set_add(phi->dest.ssa.uses,
_mesa_hash_pointer(&block_pcopy->instr),
&block_pcopy->instr);
......@@ -431,22 +431,22 @@ static void
agressive_coalesce_parallel_copy(nir_parallel_copy_instr *pcopy,
struct from_ssa_state *state)
{
foreach_list_typed_safe(nir_parallel_copy_copy, copy, node, &pcopy->copies) {
if (!copy->src.is_ssa)
nir_foreach_parallel_copy_entry(pcopy, entry) {
if (!entry->src.is_ssa)
continue;
/* Since load_const instructions are SSA only, we can't replace their
* destinations with registers and, therefore, can't coalesce them.
*/
if (copy->src.ssa->parent_instr->type == nir_instr_type_load_const)
if (entry->src.ssa->parent_instr->type == nir_instr_type_load_const)
continue;
/* Don't try and coalesce these */
if (copy->dest.ssa.num_components != copy->src.ssa->num_components)
if (entry->dest.ssa.num_components != entry->src.ssa->num_components)
continue;
merge_node *src_node = get_merge_node(copy->src.ssa, state);
merge_node *dest_node = get_merge_node(&copy->dest.ssa, state);
merge_node *src_node = get_merge_node(entry->src.ssa, state);
merge_node *dest_node = get_merge_node(&entry->dest.ssa, state);
if (src_node->set == dest_node->set)
continue;
......@@ -672,9 +672,9 @@ resolve_parallel_copy(nir_parallel_copy_instr *pcopy,
struct from_ssa_state *state)
{
unsigned num_copies = 0;
foreach_list_typed_safe(nir_parallel_copy_copy, copy, node, &pcopy->copies) {
nir_foreach_parallel_copy_entry(pcopy, entry) {
/* Sources may be SSA */
if (!copy->src.is_ssa && copy->src.reg.reg == copy->dest.reg.reg)
if (!entry->src.is_ssa && entry->src.reg.reg == entry->dest.reg.reg)
continue;
num_copies++;
......@@ -710,23 +710,23 @@ resolve_parallel_copy(nir_parallel_copy_instr *pcopy,
* - Predicessors are recorded from sources and destinations
*/
int num_vals = 0;
foreach_list_typed(nir_parallel_copy_copy, copy, node, &pcopy->copies) {
nir_foreach_parallel_copy_entry(pcopy, entry) {
/* Sources may be SSA */
if (!copy->src.is_ssa && copy->src.reg.reg == copy->dest.reg.reg)
if (!entry->src.is_ssa && entry->src.reg.reg == entry->dest.reg.reg)
continue;
int src_idx = -1;
for (int i = 0; i < num_vals; ++i) {
if (nir_srcs_equal(values[i], copy->src))
if (nir_srcs_equal(values[i], entry->src))
src_idx = i;
}
if (src_idx < 0) {
src_idx = num_vals++;
values[src_idx] = copy->src;
values[src_idx] = entry->src;
}
nir_src dest_src = {
.reg.reg = copy->dest.reg.reg,
.reg.reg = entry->dest.reg.reg,
.reg.indirect = NULL,
.reg.base_offset = 0,
.is_ssa = false,
......
......@@ -575,13 +575,13 @@ print_parallel_copy_instr(nir_parallel_copy_instr *instr, FILE *fp)
{
bool first = true;
fprintf(fp, "pcopy: ");
foreach_list_typed(nir_parallel_copy_copy, copy, node, &instr->copies) {
nir_foreach_parallel_copy_entry(instr, entry) {
if (!first)
fprintf(fp, "; ");
print_dest(&copy->dest, fp);
print_dest(&entry->dest, fp);
fprintf(fp, " = ");
print_src(&copy->src, fp);
print_src(&entry->src, fp);
first = false;
}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment