/*
* Copyright 2013 Vadim Girlin <vadimgirlin@gmail.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* on the rights to use, copy, modify, merge, publish, distribute, sub
* license, and/or sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Vadim Girlin
*/
#include "sb_bc.h"
#include "sb_shader.h"
#include "sb_pass.h"
namespace r600_sb {
bool node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool container_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool alu_group_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool alu_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool cf_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool fetch_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool region_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool repeat_node::accept(vpass& p, bool enter) {
return p.visit(*this, enter);
}
bool depart_node::accept(vpass& p, bool enter) {
return p.visit(*this, enter);
}
bool if_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool bb_node::accept(vpass& p, bool enter) { return p.visit(*this, enter); }
bool alu_packed_node::accept(vpass& p, bool enter) {
return p.visit(*this, enter);
}
void alu_packed_node::init_args(bool repl) {
alu_node *p = static_cast<alu_node*>(first);
assert(p->is_valid());
while (p) {
dst.insert(dst.end(), p->dst.begin(), p->dst.end());
src.insert(src.end(), p->src.begin(), p->src.end());
p = static_cast<alu_node*>(p->next);
}
value *replicated_value = NULL;
for (vvec::iterator I = dst.begin(), E = dst.end(); I != E; ++I) {
value *v = *I;
if (v) {
if (repl) {
if (replicated_value)
v->assign_source(replicated_value);
else
replicated_value = v;
}
v->def = this;
}
}
}
void container_node::insert_node_before(node* s, node* n) {
if (s->prev) {
node *sp = s->prev;
sp->next = n;
n->prev = sp;
n->next = s;
s->prev = n;
} else {
n->next = s;
s->prev = n;
first = n;
}
n->parent = this;
}
void container_node::insert_node_after(node* s, node* n) {
if (s->next) {
node *sn = s->next;
sn->prev = n;
n->next = sn;
n->prev = s;
s->next = n;
} else {
n->prev = s;
s->next = n;
last = n;
}
n->parent = this;
}
void container_node::move(iterator b, iterator e) {
assert(b != e);
container_node *source_container = b->parent;
node *l = source_container->cut(b, e);
first = last = l;
first->parent = this;
while (last->next) {
last = last->next;
last->parent = this;
}
}
node* container_node::cut(iterator b, iterator e) {
assert(!*b || b->parent == this);
assert(!*e || e->parent == this);
assert(b != e);
if (b->prev) {
b->prev->next = *e;
} else {
first = *e;
}
if (*e) {
e->prev->next = NULL;
e->prev = b->prev;
} else {
last->next = NULL;
last = b->prev;
}
b->prev = NULL;
return *b;
}
unsigned container_node::count() {
unsigned c = 0;
node *t = first;
while (t) {
t = t->next;
c++;
}
return c;
}
void container_node::remove_node(node *n) {
if (n->prev)
n->prev->next = n->next;
else
first = n->next;
if (n->next)
n->next->prev = n->prev;
else
last = n->prev;
n->parent = NULL;
}
void container_node::expand(container_node *n) {
if (!n->empty()) {
node *e0 = n->first;
node *e1 = n->last;
e0->prev = n->prev;
if (e0->prev) {
e0->prev->next = e0;
} else {
first = e0;
}
e1->next = n->next;
if (e1->next)
e1->next->prev = e1;
else
last = e1;
do {
e0->parent = this;
e0 = e0->next;
} while (e0 != e1->next);
} else
remove_node(n);
}
void container_node::push_back(node *n) {
if (last) {
last->next = n;
n->next = NULL;
n->prev = last;
last = n;
} else {
assert(!first);
first = last = n;
n->prev = n->next = NULL;
}
n->parent = this;
}
void container_node::push_front(node *n) {
if (first) {
first->prev = n;
n->prev = NULL;
n->next = first;
first = n;
} else {
assert(!last);
first = last = n;
n->prev = n->next = NULL;
}
n->parent = this;
}
void node::insert_before(node* n) {
parent->insert_node_before(this, n);
}
void node::insert_after(node* n) {
parent->insert_node_after(this, n);
}
void node::replace_with(node* n) {
n->prev = prev;
n->next = next;
n->parent = parent;
if (prev)
prev->next = n;
if (next)
next->prev = n;
if (parent->first == this)
parent->first = n;
if (parent->last == this)
parent->last = n;
parent = NULL;
next = prev = NULL;
}
void container_node::expand() {
parent->expand(this);
}
void node::remove() {parent->remove_node(this);
}
value_hash node::hash_src() {
value_hash h = 12345;
for (int k = 0, e = src.size(); k < e; ++k) {
value *s = src[k];
if (s)
h ^= (s->hash());
}
return h;
}
value_hash node::hash() {
if (parent && parent->subtype == NST_LOOP_PHI_CONTAINER)
return 47451;
return hash_src() ^ (subtype << 13) ^ (type << 3);
}
void r600_sb::container_node::append_from(container_node* c) {
if (!c->first)
return;
node *b = c->first;
if (last) {
last->next = c->first;
last->next->prev = last;
} else {
first = c->first;
}
last = c->last;
c->first = NULL;
c->last = NULL;
while (b) {
b->parent = this;
b = b->next;
}
}
bool node::fold_dispatch(expr_handler* ex) { return ex->fold(*this); }
bool container_node::fold_dispatch(expr_handler* ex) { return ex->fold(*this); }
bool alu_node::fold_dispatch(expr_handler* ex) { return ex->fold(*this); }
bool alu_packed_node::fold_dispatch(expr_handler* ex) { return ex->fold(*this); }
bool fetch_node::fold_dispatch(expr_handler* ex) { return ex->fold(*this); }
bool cf_node::fold_dispatch(expr_handler* ex) { return ex->fold(*this); }
unsigned alu_packed_node::get_slot_mask() {
unsigned mask = 0;
for (node_iterator I = begin(), E = end(); I != E; ++I)
mask |= 1 << static_cast<alu_node*>(*I)->bc.slot;
return mask;
}
void alu_packed_node::update_packed_items(sb_context &ctx) {
vvec::iterator SI(src.begin()), DI(dst.begin());
assert(first);
alu_node *c = static_cast<alu_node*>(first);
unsigned flags = c->bc.op_ptr->flags;
unsigned slot_flags = c->bc.slot_flags;
// fixup dst for instructions that replicate output
if (((flags & AF_REPL) && slot_flags == AF_4V) ||
(ctx.is_cayman() && slot_flags == AF_S)) {
value *swp[4] = {};
unsigned chan;
for (vvec::iterator I2 = dst.begin(), E2 = dst.end();
I2 != E2; ++I2) {
value *v = *I2;
if (v) {
chan = v->get_final_chan();
assert(!swp[chan] || swp[chan] == v);
swp[chan] = v;
}
}
chan = 0;
for (vvec::iterator I2 = dst.begin(), E2 = dst.end();
I2 != E2; ++I2, ++chan) {
*I2 = swp[chan];
}
}
for (node_iterator I = begin(), E = end(); I != E; ++I) {
alu_node *n = static_cast<alu_node*>(*I);
assert(n);
for (vvec::iterator I2 = n->src.begin(), E2 = n->src.end();
I2 != E2; ++I2, ++SI) {
*I2 = *SI;
}
for (vvec::iterator I2 = n->dst.begin(), E2 = n->dst.end();
I2 != E2; ++I2, ++DI) {
*I2 = *DI;
}
}
}
bool node::is_cf_op(unsigned op) {
if (!is_cf_inst())
return false;
cf_node *c = static_cast<cf_node*>(this);
return c->bc.op == op;
}
bool node::is_alu_op(unsigned op) {
if (!is_alu_inst())
return false;
alu_node *c = static_cast<alu_node*>(this);
return c->bc.op == op;
}
bool node::is_fetch_op(unsigned op) {
if (!is_fetch_inst())
return false;
fetch_node *c = static_cast<fetch_node*>(this);
return c->bc.op == op;
}
bool node::is_mova() {
if (!is_alu_inst())
return false;
alu_node *a = static_cast<alu_node*>(this);
return (a->bc.op_ptr->flags & AF_MOVA);
}
bool node::is_pred_set() {
if (!is_alu_inst())
return false;
alu_node *a = static_cast<alu_node*>(this);
return (a->bc.op_ptr->flags & AF_ANY_PRED);
}
unsigned node::cf_op_flags() {
assert(is_cf_inst());
cf_node *c = static_cast<cf_node*>(this);
return c->bc.op_ptr->flags;
}
unsigned node::alu_op_flags() {
assert(is_alu_inst());
alu_node *c = static_cast<alu_node*>(this);
return c->bc.op_ptr->flags;
}
unsigned node::fetch_op_flags() {
assert(is_fetch_inst());
fetch_node *c = static_cast<fetch_node*>(this);
return c->bc.op_ptr->flags;
}
unsigned node::alu_op_slot_flags() {
assert(is_alu_inst());
alu_node *c = static_cast<alu_node*>(this);
return c->bc.slot_flags;
}
region_node* node::get_parent_region() {
node *p = this;
while ((p = p->parent))
if (p->is_region())
return static_cast<region_node*>(p);
return NULL;
}
unsigned container_node::real_alu_count() {
unsigned c = 0;
node *t = first;
while (t) {
if (t->is_alu_inst())
++c;
else if (t->is_alu_packed())
c += static_cast<container_node*>(t)->count();
t = t->next;
}
return c;
}
void container_node::collect_stats(node_stats& s) {
for (node_iterator I = begin(), E = end(); I != E; ++I) {
node *n = *I;
if (n->is_container()) {
static_cast<container_node*>(n)->collect_stats(s);
}
if (n->is_alu_inst()) {
++s.alu_count;
alu_node *a = static_cast<alu_node*>(n);
if (a->bc.op_ptr->flags & AF_KILL)
++s.alu_kill_count;
else if (a->is_copy_mov())
++s.alu_copy_mov_count;
} else if (n->is_fetch_inst())
++s.fetch_count;
else if (n->is_cf_inst())
++s.cf_count;
else if (n->is_region()) {
++s.region_count;
region_node *r = static_cast<region_node*>(n);
if(r->is_loop())
++s.loop_count;
if (r->phi)
s.phi_count += r->phi->count();
if (r->loop_phi)
s.loop_phi_count += r->loop_phi->count();
}
else if (n->is_depart())
++s.depart_count;
else if (n->is_repeat())
++s.repeat_count;
else if (n->is_if())
++s.if_count;
}
}
void region_node::expand_depart(depart_node *d) {
depart_vec::iterator I = departs.begin() + d->dep_id, E;
I = departs.erase(I);
E = departs.end();
while (I != E) {
--(*I)->dep_id;
++I;
}
d->expand();
}
void region_node::expand_repeat(repeat_node *r) {
repeat_vec::iterator I = repeats.begin() + r->rep_id - 1, E;
I = repeats.erase(I);
E = repeats.end();
while (I != E) {
--(*I)->rep_id;
++I;
}
r->expand();
}
void node_stats::dump() {
sblog << " alu_count : " << alu_count << "\n";
sblog << " alu_kill_count : " << alu_kill_count << "\n";
sblog << " alu_copy_mov_count : " << alu_copy_mov_count << "\n";
sblog << " cf_count : " << cf_count << "\n";
sblog << " fetch_count : " << fetch_count << "\n";
sblog << " region_count : " << region_count << "\n";
sblog << " loop_count : " << loop_count << "\n";
sblog << " phi_count : " << phi_count << "\n";
sblog << " loop_phi_count : " << loop_phi_count << "\n";
sblog << " depart_count : " << depart_count << "\n";
sblog << " repeat_count : " << repeat_count << "\n";
sblog << " if_count : " << if_count << "\n";
}
unsigned alu_node::interp_param() {
if (!(bc.op_ptr->flags & AF_INTERP))
return 0;
unsigned param;
if (bc.op_ptr->src_count == 2) {
param = src[1]->select.sel();
} else {
param = src[0]->select.sel();
}
return param + 1;
}
alu_group_node* alu_node::get_alu_group_node() {
node *p = parent;
if (p) {
if (p->subtype == NST_ALU_PACKED_INST) {
assert(p->parent && p->parent->subtype == NST_ALU_GROUP);
p = p->parent;
}
return static_cast<alu_group_node*>(p);
}
return NULL;
}
} // namespace r600_sb