Subversion Repositories Kolibri OS

/*

 * Copyright 2013 Vadim Girlin 

 *

 * 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 {

static const char* chans = "xyzw01?_";

static const char* vec_bs[] = {

		"VEC_012", "VEC_021", "VEC_120", "VEC_102", "VEC_201", "VEC_210"

};

static const char* scl_bs[] = {

		"SCL_210", "SCL_122", "SCL_212", "SCL_221"

};

bool bc_dump::visit(cf_node& n, bool enter) {

	if (enter) {

		id = n.bc.id << 1;

		if ((n.bc.op_ptr->flags & CF_ALU) && n.bc.is_alu_extended()) {

			dump_dw(id, 2);

			id += 2;

			sblog << "\n";

		}

		dump_dw(id, 2);

		dump(n);

		if (n.bc.op_ptr->flags & CF_CLAUSE) {

			id = n.bc.addr << 1;

			new_group = 1;

		}

	}

	return true;

}

bool bc_dump::visit(alu_node& n, bool enter) {

	if (enter) {

		sblog << " ";

		dump_dw(id, 2);

		if (new_group) {

			sblog.print_w(++group_index, 5);

			sblog << " ";

		} else

			sblog << "      ";

		dump(n);

		id += 2;

		new_group = n.bc.last;

	} else {

		if (n.bc.last) {

			alu_group_node *g =

					static_cast(n.get_alu_group_node());

			assert(g);

			for (unsigned k = 0; k < g->literals.size(); ++k) {

				sblog << " ";

				dump_dw(id, 1);

				id += 1;

				sblog << "\n";

			}

			id = (id + 1) & ~1u;

		}

	}

	return false;

}

bool bc_dump::visit(fetch_node& n, bool enter) {

	if (enter) {

		sblog << " ";

		dump_dw(id, 3);

		dump(n);

		id += 4;

	}

	return false;

}

static void fill_to(sb_ostringstream &s, int pos) {

	int l = s.str().length();

	if (l < pos)

		s << std::string(pos-l, ' ');

}

void bc_dump::dump(cf_node& n) {

	sb_ostringstream s;

	s << n.bc.op_ptr->name;

	if (n.bc.op_ptr->flags & CF_EXP) {

		static const char *exp_type[] = {"PIXEL", "POS  ", "PARAM"};

		fill_to(s, 18);

		s << " " << exp_type[n.bc.type] << " ";

		if (n.bc.burst_count) {

			sb_ostringstream s2;

			s2 << n.bc.array_base << "-" << n.bc.array_base + n.bc.burst_count;

			s.print_wl(s2.str(), 5);

			s << " R" << n.bc.rw_gpr << "-" <<

					n.bc.rw_gpr + n.bc.burst_count << ".";

		} else {

			s.print_wl(n.bc.array_base, 5);

			s << " R" << n.bc.rw_gpr << ".";

		}

		for (int k = 0; k < 4; ++k)

			s << chans[n.bc.sel[k]];

	} else if (n.bc.op_ptr->flags & (CF_STRM | CF_RAT)) {

		static const char *exp_type[] = {"WRITE", "WRITE_IND", "WRITE_ACK",

				"WRITE_IND_ACK"};

		fill_to(s, 18);

		s << " " << exp_type[n.bc.type] << " ";

		s.print_wl(n.bc.array_base, 5);

		s << " R" << n.bc.rw_gpr << ".";

		for (int k = 0; k < 4; ++k)

			s << ((n.bc.comp_mask & (1 << k)) ? chans[k] : '_');

		if ((n.bc.op_ptr->flags & CF_RAT) && (n.bc.type & 1)) {

			s << ", @R" << n.bc.index_gpr << ".xyz";

		}

		s << "  ES:" << n.bc.elem_size;

	} else {

		if (n.bc.op_ptr->flags & CF_CLAUSE) {

			s << " " << n.bc.count+1;

		}

		s << " @" << (n.bc.addr << 1);

		if (n.bc.op_ptr->flags & CF_ALU) {

			for (int k = 0; k < 4; ++k) {

				bc_kcache &kc = n.bc.kc[k];

				if (kc.mode) {

					s << " KC" << k << "[CB" << kc.bank << ":" <<

							(kc.addr << 4) << "-" <<

							(((kc.addr + kc.mode) << 4) - 1) << "]";

				}

			}

		}

		if (n.bc.cond)

			s << " CND:" << n.bc.pop_count;

		if (n.bc.pop_count)

			s << " POP:" << n.bc.pop_count;

	}

	if (!n.bc.barrier)

		s << "  NO_BARRIER";

	if (n.bc.valid_pixel_mode)

		s << "  VPM";

	if (n.bc.whole_quad_mode)

		s << "  WQM";

	if (n.bc.end_of_program)

		s << "  EOP";

	sblog << s.str() << "\n";

}

static void print_sel(sb_ostream &s, int sel, int rel, int index_mode,

                      int need_brackets) {

	if (rel && index_mode >= 5 && sel < 128)

		s << "G";

	if (rel || need_brackets) {

		s << "[";

	}

	s << sel;

	if (rel) {

		if (index_mode == 0 || index_mode == 6)

			s << "+AR";

		else if (index_mode == 4)

			s << "+AL";

	}

	if (rel || need_brackets) {

		s << "]";

	}

}

static void print_dst(sb_ostream &s, bc_alu &alu)

{

	unsigned sel = alu.dst_gpr;

	char reg_char = 'R';

	if (sel >= 128 - 4) { // clause temporary gpr

		sel -= 128 - 4;

		reg_char = 'T';

	}

	if (alu.write_mask || alu.op_ptr->src_count == 3) {

		s << reg_char;

		print_sel(s, sel, alu.dst_rel, alu.index_mode, 0);

	} else {

		s << "__";

	}

	s << ".";

	s << chans[alu.dst_chan];

}

static void print_src(sb_ostream &s, bc_alu &alu, unsigned idx)

{

	bc_alu_src *src = &alu.src[idx];

	unsigned sel = src->sel, need_sel = 1, need_chan = 1, need_brackets = 0;

	if (src->neg)

		s <<"-";

	if (src->abs)

		s <<"|";

	if (sel < 128 - 4) {

		s << "R";

	} else if (sel < 128) {

		s << "T";

		sel -= 128 - 4;

	} else if (sel < 160) {

		s << "KC0";

		need_brackets = 1;

		sel -= 128;

	} else if (sel < 192) {

		s << "KC1";

		need_brackets = 1;

		sel -= 160;

	} else if (sel >= 448) {

		s << "Param";

		sel -= 448;

	} else if (sel >= 288) {

		s << "KC3";

		need_brackets = 1;

		sel -= 288;

	} else if (sel >= 256) {

		s << "KC2";

		need_brackets = 1;

		sel -= 256;

	} else {

		need_sel = 0;

		need_chan = 0;

		switch (sel) {

		case ALU_SRC_PS:

			s << "PS";

			break;

		case ALU_SRC_PV:

			s << "PV";

			need_chan = 1;

			break;

		case ALU_SRC_LITERAL:

			s << "[0x";

			s.print_zw_hex(src->value.u, 8);

			s << " " << src->value.f << "]";

			need_chan = 1;

			break;

		case ALU_SRC_0_5:

			s << "0.5";

			break;

		case ALU_SRC_M_1_INT:

			s << "-1";

			break;

		case ALU_SRC_1_INT:

			s << "1";

			break;

		case ALU_SRC_1:

			s << "1.0";

			break;

		case ALU_SRC_0:

			s << "0";

			break;

		default:

			s << "??IMM_" <<  sel;

			break;

		}

	}

	if (need_sel)

		print_sel(s, sel, src->rel, alu.index_mode, need_brackets);

	if (need_chan) {

		s << "." << chans[src->chan];

	}

	if (src->abs)

		s << "|";

}

void bc_dump::dump(alu_node& n) {

	sb_ostringstream s;

	static const char *omod_str[] = {"","*2","*4","/2"};

	static const char *slots = "xyzwt";

	s << (n.bc.update_exec_mask ? "M" : " ");

	s << (n.bc.update_pred ? "P" : " ");

	s << " ";

	s << (n.bc.pred_sel>=2 ? (n.bc.pred_sel == 2 ? "0" : "1") : " ");

	s << " ";

	s << slots[n.bc.slot] << ": ";

	s << n.bc.op_ptr->name << omod_str[n.bc.omod] << (n.bc.clamp ? "_sat" : "");

	fill_to(s, 26);

	s << " ";

	print_dst(s, n.bc);

	for (int k = 0; k < n.bc.op_ptr->src_count; ++k) {

		s << (k ? ", " : ",  ");

		print_src(s, n.bc, k);

	}

	if (n.bc.bank_swizzle) {

		fill_to(s, 55);

		if (n.bc.slot == SLOT_TRANS)

			s << "  " << scl_bs[n.bc.bank_swizzle];

		else

			s << "  " << vec_bs[n.bc.bank_swizzle];

	}

	sblog << s.str() << "\n";

}

int bc_dump::init() {

	sb_ostringstream s;

	s << "===== SHADER #" << sh.id;

	if (sh.optimized)

		s << " OPT";

	s << " ";

	std::string target = std::string(" ") +

			sh.get_full_target_name() + " =====";

	while (s.str().length() + target.length() < 80)

		s << "=";

	s << target;

	sblog << "\n" << s.str() << "\n";

	s.clear();

	if (bc_data) {

		s << "===== " << ndw << " dw ===== " << sh.ngpr

				<< " gprs ===== " << sh.nstack << " stack ";

	}

	while (s.str().length() < 80)

		s << "=";

	sblog << s.str() << "\n";

	return 0;

}

int bc_dump::done() {

	sb_ostringstream s;

	s << "===== SHADER_END ";

	while (s.str().length() < 80)

		s << "=";

	sblog << s.str() << "\n\n";

	return 0;

}

bc_dump::bc_dump(shader& s, bytecode* bc)  :

	vpass(s), bc_data(), ndw(), id(),

	new_group(), group_index() {

	if (bc) {

		bc_data = bc->data();

		ndw = bc->ndw();

	}

}

void bc_dump::dump(fetch_node& n) {

	sb_ostringstream s;

	static const char * fetch_type[] = {"VERTEX", "INSTANCE", ""};

	s << n.bc.op_ptr->name;

	fill_to(s, 20);

	s << "R";

	print_sel(s, n.bc.dst_gpr, n.bc.dst_rel, INDEX_LOOP, 0);

	s << ".";

	for (int k = 0; k < 4; ++k)

		s << chans[n.bc.dst_sel[k]];

	s << ", ";

	s << "R";

	print_sel(s, n.bc.src_gpr, n.bc.src_rel, INDEX_LOOP, 0);

	s << ".";

	unsigned vtx = n.bc.op_ptr->flags & FF_VTX;

	unsigned num_src_comp = vtx ? ctx.is_cayman() ? 2 : 1 : 4;

	for (unsigned k = 0; k < num_src_comp; ++k)

		s << chans[n.bc.src_sel[k]];

	if (vtx && n.bc.offset[0]) {

		s << " + " << n.bc.offset[0] << "b ";

	}

	s << ",   RID:" << n.bc.resource_id;

	if (vtx) {

		s << "  " << fetch_type[n.bc.fetch_type];

		if (!ctx.is_cayman() && n.bc.mega_fetch_count)

			s << " MFC:" << n.bc.mega_fetch_count;

		if (n.bc.fetch_whole_quad)

			s << " FWQ";

		s << " UCF:" << n.bc.use_const_fields

				<< " FMT(DTA:" << n.bc.data_format

				<< " NUM:" << n.bc.num_format_all

				<< " COMP:" << n.bc.format_comp_all

				<< " MODE:" << n.bc.srf_mode_all << ")";

	} else {

		s << ", SID:" << n.bc.sampler_id;

		if (n.bc.lod_bias)

			s << " LB:" << n.bc.lod_bias;

		s << " CT:";

		for (unsigned k = 0; k < 4; ++k)

			s << (n.bc.coord_type[k] ? "N" : "U");

		for (unsigned k = 0; k < 3; ++k)

			if (n.bc.offset[k])

				s << " O" << chans[k] << ":" << n.bc.offset[k];

	}

	sblog << s.str() << "\n";

}

void bc_dump::dump_dw(unsigned dw_id, unsigned count) {

	if (!bc_data)

		return;

	assert(dw_id + count <= ndw);

	sblog.print_zw(dw_id, 4);

	sblog << "  ";

	while (count--) {

		sblog.print_zw_hex(bc_data[dw_id++], 8);

		sblog << " ";

	}

}

} // namespace r600_sb