/*
* 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
*/
#define VT_DEBUG 0
#if VT_DEBUG
#define VT_DUMP(q) do { q } while (0)
#else
#define VT_DUMP(q)
#endif
#include <cstring>
#include "sb_shader.h"
#include "sb_pass.h"
namespace r600_sb {
static const char * chans = "xyzw01?_";
sb_ostream& operator << (sb_ostream &o, value &v) {
bool dead = v.flags & VLF_DEAD;
if (dead)
o << "{";
switch (v.kind) {
case VLK_SPECIAL_REG: {
switch (v.select.sel()) {
case SV_AR_INDEX: o << "AR"; break;
case SV_ALU_PRED: o << "PR"; break;
case SV_EXEC_MASK: o << "EM"; break;
case SV_VALID_MASK: o << "VM"; break;
default: o << "???specialreg"; break;
}
break;
}
case VLK_REG:
o << "R" << v.select.sel() << "."
<< chans[v.select.chan()];
break;
case VLK_KCACHE: {
o << "C" << v.select.sel() << "." << chans[v.select.chan()];
}
break;
case VLK_CONST:
o << v.literal_value.f << "|";
o.print_zw_hex(v.literal_value.u, 8);
break;
case VLK_PARAM:
o << "Param" << (v.select.sel() - ALU_SRC_PARAM_OFFSET)
<< chans[v.select.chan()];
break;
case VLK_TEMP:
o << "t" << v.select.sel() - shader::temp_regid_offset;
break;
case VLK_REL_REG:
o << "A" << v.select;
o << "[";
o << *v.rel;
o << "]";
o << "_" << v.uid;
break;
case VLK_UNDEF:
o << "undef";
break;
default:
o << v.kind << "?????";
break;
}
if (v.version)
o << "." << v.version;
if (dead)
o << "}";
if (v.is_global())
o << "||";
if (v.is_fixed())
o << "F";
if (v.is_prealloc())
o << "P";
sel_chan g;
if (v.is_rel()) {
g = v.array->gpr;
} else {
g = v.gpr;
}
if (g) {
o << "@R" << g.sel() << "." << chans[g.chan()];
}
return o;
}
void value_table::add_value(value* v) {
if (v->gvn_source) {
return;
}
VT_DUMP(
sblog << "gvn add_value ";
dump::dump_val(v);
);
value_hash hash = v->hash();
vt_item & vti = hashtable[hash & size_mask];
vti.push_back(v);
++cnt;
if (v->def && ex.try_fold(v)) {
VT_DUMP(
sblog << " folded: ";
dump::dump_val(v->gvn_source);
sblog << "\n";
);
return;
}
int n = 0;
for (vt_item::iterator I = vti.begin(), E = vti.end(); I != E; ++I, ++n) {
value *c = *I;
if (c == v)
break;
if (expr_equal(c, v)) {
v->gvn_source = c->gvn_source;
VT_DUMP(
sblog << " found : equal to ";
dump::dump_val(v->gvn_source);
sblog << "\n";
);
return;
}
}
v->gvn_source = v;
VT_DUMP(
sblog << " added new\n";
);
}
value_hash value::hash() {
if (ghash)
return ghash;
if (is_rel())
ghash = rel_hash();
else if (def)
ghash = def->hash();
else
ghash = ((uintptr_t)this) | 1;
return ghash;
}
value_hash value::rel_hash() {
value_hash h = rel ? rel->hash() : 0;
h |= select << 10;
h |= array->hash();
return h;
}
bool value_table::expr_equal(value* l, value* r) {
return ex.equal(l, r);
}
void value_table::get_values(vvec& v) {
v.resize(cnt);
vvec::iterator T = v.begin();
for(vt_table::iterator I = hashtable.begin(), E = hashtable.end();
I != E; ++I) {
T = std::copy(I->begin(), I->end(), T);
}
}
void value::add_use(node* n, use_kind kind, int arg) {
if (0) {
sblog << "add_use ";
dump::dump_val(this);
sblog << " => ";
dump::dump_op(n);
sblog << " kind " << kind << " arg " << arg << "\n";
}
uses = new use_info(n, kind, arg, uses);
}
unsigned value::use_count() {
use_info *u = uses;
unsigned c = 0;
while (u) {
++c;
u = u->next;
}
return c;
}
bool value::is_global() {
if (chunk)
return chunk->is_global();
return flags & VLF_GLOBAL;
}
void value::set_global() {
assert(is_sgpr());
flags |= VLF_GLOBAL;
if (chunk)
chunk->set_global();
}
void value::set_prealloc() {
assert(is_sgpr());
flags |= VLF_PREALLOC;
if (chunk)
chunk->set_prealloc();
}
bool value::is_fixed() {
if (array && array->gpr)
return true;
if (chunk)
return chunk->is_fixed();
return flags & VLF_FIXED;
}
void value::fix() {
if (chunk)
chunk->fix();
flags |= VLF_FIXED;
}
bool value::is_prealloc() {
if (chunk)
return chunk->is_prealloc();
return flags & VLF_PREALLOC;
}
void value::delete_uses() {
use_info *u, *c = uses;
while (c) {
u = c->next;
delete c;
c = u;
}
uses = NULL;
}
void ra_constraint::update_values() {
for (vvec::iterator I = values.begin(), E = values.end(); I != E; ++I) {
assert(!(*I)->constraint);
(*I)->constraint = this;
}
}
void* sb_pool::allocate(unsigned sz) {
sz = (sz + SB_POOL_ALIGN - 1) & ~(SB_POOL_ALIGN - 1);
assert (sz < (block_size >> 6) && "too big allocation size for sb_pool");
unsigned offset = total_size % block_size;
unsigned capacity = block_size * blocks.size();
if (total_size + sz > capacity) {
total_size = capacity;
void * nb = malloc(block_size);
blocks.push_back(nb);
offset = 0;
}
total_size += sz;
return ((char*)blocks.back() + offset);
}
void sb_pool::free_all() {
for (block_vector::iterator I = blocks.begin(), E = blocks.end(); I != E;
++I) {
free(*I);
}
}
value* sb_value_pool::create(value_kind k, sel_chan regid,
unsigned ver) {
void* np = allocate(aligned_elt_size);
value *v = new (np) value(size(), k, regid, ver);
return v;
}
void sb_value_pool::delete_all() {
unsigned bcnt = blocks.size();
unsigned toffset = 0;
for (unsigned b = 0; b < bcnt; ++b) {
char *bstart = (char*)blocks[b];
for (unsigned offset = 0; offset < block_size;
offset += aligned_elt_size) {
((value*)(bstart + offset))->~value();
toffset += aligned_elt_size;
if (toffset >= total_size)
return;
}
}
}
bool sb_bitset::get(unsigned id) {
assert(id < bit_size);
unsigned w = id / bt_bits;
unsigned b = id % bt_bits;
return (data[w] >> b) & 1;
}
void sb_bitset::set(unsigned id, bool bit) {
assert(id < bit_size);
unsigned w = id / bt_bits;
unsigned b = id % bt_bits;
if (w >= data.size())
data.resize(w + 1);
if (bit)
data[w] |= (1 << b);
else
data[w] &= ~(1 << b);
}
inline bool sb_bitset::set_chk(unsigned id, bool bit) {
assert(id < bit_size);
unsigned w = id / bt_bits;
unsigned b = id % bt_bits;
basetype d = data[w];
basetype dn = (d & ~(1 << b)) | (bit << b);
bool r = (d != dn);
data[w] = r ? dn : data[w];
return r;
}
void sb_bitset::clear() {
std::fill(data.begin(), data.end(), 0);
}
void sb_bitset::resize(unsigned size) {
unsigned cur_data_size = data.size();
unsigned new_data_size = (size + bt_bits - 1) / bt_bits;
if (new_data_size != cur_data_size)
data.resize(new_data_size);
// make sure that new bits in the existing word are cleared
if (cur_data_size && size > bit_size && bit_size % bt_bits) {
basetype clear_mask = (~(basetype)0u) << (bit_size % bt_bits);
data[cur_data_size - 1] &= ~clear_mask;
}
bit_size = size;
}
unsigned sb_bitset::find_bit(unsigned start) {
assert(start < bit_size);
unsigned w = start / bt_bits;
unsigned b = start % bt_bits;
unsigned sz = data.size();
while (w < sz) {
basetype d = data[w] >> b;
if (d != 0) {
unsigned pos = __builtin_ctz(d) + b + w * bt_bits;
return pos;
}
b = 0;
++w;
}
return bit_size;
}
sb_value_set::iterator::iterator(shader& sh, sb_value_set* s, unsigned nb)
: vp(sh.get_value_pool()), s(s), nb(nb) {}
bool sb_value_set::add_set_checked(sb_value_set& s2) {
if (bs.size() < s2.bs.size())
bs.resize(s2.bs.size());
sb_bitset nbs = bs | s2.bs;
if (bs != nbs) {
bs.swap(nbs);
return true;
}
return false;
}
void r600_sb::sb_value_set::remove_set(sb_value_set& s2) {
bs.mask(s2.bs);
}
bool sb_value_set::add_val(value* v) {
assert(v);
if (bs.size() < v->uid)
bs.resize(v->uid + 32);
return bs.set_chk(v->uid - 1, 1);
}
bool sb_value_set::remove_vec(vvec& vv) {
bool modified = false;
for (vvec::iterator I = vv.begin(), E = vv.end(); I != E; ++I) {
if (*I)
modified |= remove_val(*I);
}
return modified;
}
void sb_value_set::clear() {
bs.clear();
}
bool sb_value_set::remove_val(value* v) {
assert(v);
if (bs.size() < v->uid)
return false;
return bs.set_chk(v->uid - 1, 0);
}
bool r600_sb::sb_value_set::add_vec(vvec& vv) {
bool modified = false;
for (vvec::iterator I = vv.begin(), E = vv.end(); I != E; ++I) {
value *v = *I;
if (v)
modified |= add_val(v);
}
return modified;
}
bool r600_sb::sb_value_set::contains(value* v) {
unsigned b = v->uid - 1;
if (b < bs.size())
return bs.get(v->uid - 1);
else
return false;
}
bool sb_value_set::empty() {
return bs.size() == 0 || bs.find_bit(0) == bs.size();
}
void sb_bitset::swap(sb_bitset& bs2) {
std::swap(data, bs2.data);
std::swap(bit_size, bs2.bit_size);
}
bool sb_bitset::operator ==(const sb_bitset& bs2) {
if (bit_size != bs2.bit_size)
return false;
for (unsigned i = 0, c = data.size(); i < c; ++i) {
if (data[i] != bs2.data[i])
return false;
}
return true;
}
sb_bitset& sb_bitset::operator &=(const sb_bitset& bs2) {
if (bit_size > bs2.bit_size) {
resize(bs2.bit_size);
}
for (unsigned i = 0, c = std::min(data.size(), bs2.data.size()); i < c;
++i) {
data[i] &= bs2.data[i];
}
return *this;
}
sb_bitset& sb_bitset::mask(const sb_bitset& bs2) {
if (bit_size < bs2.bit_size) {
resize(bs2.bit_size);
}
for (unsigned i = 0, c = data.size(); i < c;
++i) {
data[i] &= ~bs2.data[i];
}
return *this;
}
bool ra_constraint::check() {
assert(kind == CK_SAME_REG);
unsigned reg = 0;
for (vvec::iterator I = values.begin(), E = values.end(); I != E; ++I) {
value *v = *I;
if (!v)
continue;
if (!v->gpr)
return false;
if (reg == 0)
reg = v->gpr.sel() + 1;
else if (reg != v->gpr.sel() + 1)
return false;
if (v->is_chan_pinned()) {
if (v->pin_gpr.chan() != v->gpr.chan())
return false;
}
}
return true;
}
bool gpr_array::is_dead() {
return false;
}
} // namespace r600_sb