src/gallium/drivers/r600/sb/sb_bc_dump.cpp

   1 /*
   2  * Copyright 2013 Vadim Girlin <vadimgirlin@gmail.com>
   3  *
   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  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  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
  13  * Software.
  14  *
  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 NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *      Vadim Girlin
  25  */
  26
  27 #include "sb_bc.h"
  28 #include "sb_shader.h"
  29 #include "sb_pass.h"
  30
  31 namespace r600_sb {
  32
  33 static const char* chans = "xyzw01?_";
  34
  35 static const char* vec_bs[] = {
  36                 "VEC_012", "VEC_021", "VEC_120", "VEC_102", "VEC_201", "VEC_210"
  37 };
  38
  39 static const char* scl_bs[] = {
  40                 "SCL_210", "SCL_122", "SCL_212", "SCL_221"
  41 };
  42
  43
  44 bool bc_dump::visit(cf_node& n, bool enter) {
  45         if (enter) {
  46
  47                 id = n.bc.id << 1;
  48
  49                 if ((n.bc.op_ptr->flags & CF_ALU) && n.bc.is_alu_extended()) {
  50                         dump_dw(id, 2);
  51                         id += 2;
  52                         sblog << "\n";
  53                 }
  54
  55                 dump_dw(id, 2);
  56                 dump(n);
  57
  58                 if (n.bc.op_ptr->flags & CF_CLAUSE) {
  59                         id = n.bc.addr << 1;
  60                         new_group = 1;
  61                 }
  62         }
  63         return true;
  64 }
  65
  66 bool bc_dump::visit(alu_node& n, bool enter) {
  67         if (enter) {
  68                 sblog << " ";
  69                 dump_dw(id, 2);
  70
  71                 if (new_group) {
  72                         sblog.print_w(++group_index, 5);
  73                         sblog << " ";
  74                 } else
  75                         sblog << "      ";
  76
  77                 dump(n);
  78                 id += 2;
  79
  80                 new_group = n.bc.last;
  81         } else {
  82                 if (n.bc.last) {
  83                         alu_group_node *g =
  84                                         static_cast<alu_group_node*>(n.get_alu_group_node());
  85                         assert(g);
  86                         for (unsigned k = 0; k < g->literals.size(); ++k) {
  87                                 sblog << " ";
  88                                 dump_dw(id, 1);
  89                                 id += 1;
  90                                 sblog << "\n";
  91                         }
  92
  93                         id = (id + 1) & ~1u;
  94                 }
  95         }
  96
  97         return false;
  98 }
  99
 100 bool bc_dump::visit(fetch_node& n, bool enter) {
 101         if (enter) {
 102                 sblog << " ";
 103                 dump_dw(id, 3);
 104                 dump(n);
 105                 id += 4;
 106         }
 107         return false;
 108 }
 109
 110 static void fill_to(sb_ostringstream &s, int pos) {
 111         int l = s.str().length();
 112         if (l < pos)
 113                 s << std::string(pos-l, ' ');
 114 }
 115
 116 void bc_dump::dump(cf_node& n) {
 117         sb_ostringstream s;
 118         s << n.bc.op_ptr->name;
 119
 120         if (n.bc.op_ptr->flags & CF_EXP) {
 121                 static const char *exp_type[] = {"PIXEL", "POS  ", "PARAM"};
 122
 123                 fill_to(s, 18);
 124                 s << " " << exp_type[n.bc.type] << " ";
 125
 126                 if (n.bc.burst_count) {
 127                         sb_ostringstream s2;
 128                         s2 << n.bc.array_base << "-" << n.bc.array_base + n.bc.burst_count;
 129                         s.print_wl(s2.str(), 5);
 130                         s << " R" << n.bc.rw_gpr << "-" <<
 131                                         n.bc.rw_gpr + n.bc.burst_count << ".";
 132                 } else {
 133                         s.print_wl(n.bc.array_base, 5);
 134                         s << " R" << n.bc.rw_gpr << ".";
 135                 }
 136
 137                 for (int k = 0; k < 4; ++k)
 138                         s << chans[n.bc.sel[k]];
 139
 140         } else if (n.bc.op_ptr->flags & CF_MEM) {
 141                 static const char *exp_type[] = {"WRITE", "WRITE_IND", "WRITE_ACK",
 142                                 "WRITE_IND_ACK"};
 143                 fill_to(s, 18);
 144                 s << " " << exp_type[n.bc.type] << " ";
 145                 s.print_wl(n.bc.array_base, 5);
 146                 s << " R" << n.bc.rw_gpr << ".";
 147                 for (int k = 0; k < 4; ++k)
 148                         s << ((n.bc.comp_mask & (1 << k)) ? chans[k] : '_');
 149
 150                 if ((n.bc.op_ptr->flags & CF_RAT) && (n.bc.type & 1)) {
 151                         s << ", @R" << n.bc.index_gpr << ".xyz";
 152                 }
 153                 if ((n.bc.op_ptr->flags & CF_MEM) && (n.bc.type & 1)) {
 154                         s << ", @R" << n.bc.index_gpr << ".x";
 155                 }
 156
 157                 s << "  ES:" << n.bc.elem_size;
 158
 159         } else {
 160
 161                 if (n.bc.op_ptr->flags & CF_CLAUSE) {
 162                         s << " " << n.bc.count+1;
 163                 }
 164
 165                 s << " @" << (n.bc.addr << 1);
 166
 167                 if (n.bc.op_ptr->flags & CF_ALU) {
 168
 169                         for (int k = 0; k < 4; ++k) {
 170                                 bc_kcache &kc = n.bc.kc[k];
 171                                 if (kc.mode) {
 172                                         s << " KC" << k << "[CB" << kc.bank << ":" <<
 173                                                         (kc.addr << 4) << "-" <<
 174                                                         (((kc.addr + kc.mode) << 4) - 1) << "]";
 175                                 }
 176                         }
 177                 }
 178
 179                 if (n.bc.cond)
 180                         s << " CND:" << n.bc.cond;
 181
 182                 if (n.bc.pop_count)
 183                         s << " POP:" << n.bc.pop_count;
 184         }
 185
 186         if (!n.bc.barrier)
 187                 s << "  NO_BARRIER";
 188
 189         if (n.bc.valid_pixel_mode)
 190                 s << "  VPM";
 191
 192         if (n.bc.whole_quad_mode)
 193                 s << "  WQM";
 194
 195         if (n.bc.end_of_program)
 196                 s << "  EOP";
 197
 198         sblog << s.str() << "\n";
 199 }
 200
 201
 202 static void print_sel(sb_ostream &s, int sel, int rel, int index_mode,
 203                       int need_brackets) {
 204         if (rel && index_mode >= 5 && sel < 128)
 205                 s << "G";
 206         if (rel || need_brackets) {
 207                 s << "[";
 208         }
 209         s << sel;
 210         if (rel) {
 211                 if (index_mode == 0 || index_mode == 6)
 212                         s << "+AR";
 213                 else if (index_mode == 4)
 214                         s << "+AL";
 215         }
 216         if (rel || need_brackets) {
 217                 s << "]";
 218         }
 219 }
 220
 221 static void print_dst(sb_ostream &s, bc_alu &alu)
 222 {
 223         unsigned sel = alu.dst_gpr;
 224         char reg_char = 'R';
 225         if (sel >= 128 - 4) { // clause temporary gpr
 226                 sel -= 128 - 4;
 227                 reg_char = 'T';
 228         }
 229
 230         if (alu.write_mask || alu.op_ptr->src_count == 3) {
 231                 s << reg_char;
 232                 print_sel(s, sel, alu.dst_rel, alu.index_mode, 0);
 233         } else {
 234                 s << "__";
 235         }
 236         s << ".";
 237         s << chans[alu.dst_chan];
 238 }
 239
 240 static void print_src(sb_ostream &s, bc_alu &alu, unsigned idx)
 241 {
 242         bc_alu_src *src = &alu.src[idx];
 243         unsigned sel = src->sel, need_sel = 1, need_chan = 1, need_brackets = 0;
 244
 245         if (src->neg)
 246                 s <<"-";
 247         if (src->abs)
 248                 s <<"|";
 249
 250         if (sel < 128 - 4) {
 251                 s << "R";
 252         } else if (sel < 128) {
 253                 s << "T";
 254                 sel -= 128 - 4;
 255         } else if (sel < 160) {
 256                 s << "KC0";
 257                 need_brackets = 1;
 258                 sel -= 128;
 259         } else if (sel < 192) {
 260                 s << "KC1";
 261                 need_brackets = 1;
 262                 sel -= 160;
 263         } else if (sel >= 448) {
 264                 s << "Param";
 265                 sel -= 448;
 266         } else if (sel >= 288) {
 267                 s << "KC3";
 268                 need_brackets = 1;
 269                 sel -= 288;
 270         } else if (sel >= 256) {
 271                 s << "KC2";
 272                 need_brackets = 1;
 273                 sel -= 256;
 274         } else {
 275                 need_sel = 0;
 276                 need_chan = 0;
 277                 switch (sel) {
 278                 case ALU_SRC_PS:
 279                         s << "PS";
 280                         break;
 281                 case ALU_SRC_PV:
 282                         s << "PV";
 283                         need_chan = 1;
 284                         break;
 285                 case ALU_SRC_LITERAL:
 286                         s << "[0x";
 287                         s.print_zw_hex(src->value.u, 8);
 288                         s << " " << src->value.f << "]";
 289                         need_chan = 1;
 290                         break;
 291                 case ALU_SRC_0_5:
 292                         s << "0.5";
 293                         break;
 294                 case ALU_SRC_M_1_INT:
 295                         s << "-1";
 296                         break;
 297                 case ALU_SRC_1_INT:
 298                         s << "1";
 299                         break;
 300                 case ALU_SRC_1:
 301                         s << "1.0";
 302                         break;
 303                 case ALU_SRC_0:
 304                         s << "0";
 305                         break;
 306                 default:
 307                         s << "??IMM_" <<  sel;
 308                         break;
 309                 }
 310         }
 311
 312         if (need_sel)
 313                 print_sel(s, sel, src->rel, alu.index_mode, need_brackets);
 314
 315         if (need_chan) {
 316                 s << "." << chans[src->chan];
 317         }
 318
 319         if (src->abs)
 320                 s << "|";
 321 }
 322 void bc_dump::dump(alu_node& n) {
 323         sb_ostringstream s;
 324         static const char *omod_str[] = {"","*2","*4","/2"};
 325         static const char *slots = "xyzwt";
 326
 327         s << (n.bc.update_exec_mask ? "M" : " ");
 328         s << (n.bc.update_pred ? "P" : " ");
 329         s << " ";
 330         s << (n.bc.pred_sel>=2 ? (n.bc.pred_sel == 2 ? "0" : "1") : " ");
 331         s << " ";
 332
 333         s << slots[n.bc.slot] << ": ";
 334
 335         s << n.bc.op_ptr->name << omod_str[n.bc.omod] << (n.bc.clamp ? "_sat" : "");
 336         fill_to(s, 26);
 337         s << " ";
 338
 339         print_dst(s, n.bc);
 340         for (int k = 0; k < n.bc.op_ptr->src_count; ++k) {
 341                 s << (k ? ", " : ",  ");
 342                 print_src(s, n.bc, k);
 343         }
 344
 345         if (n.bc.bank_swizzle) {
 346                 fill_to(s, 55);
 347                 if (n.bc.slot == SLOT_TRANS)
 348                         s << "  " << scl_bs[n.bc.bank_swizzle];
 349                 else
 350                         s << "  " << vec_bs[n.bc.bank_swizzle];
 351         }
 352
 353         sblog << s.str() << "\n";
 354 }
 355
 356 int bc_dump::init() {
 357         sb_ostringstream s;
 358         s << "===== SHADER #" << sh.id;
 359
 360         if (sh.optimized)
 361                 s << " OPT";
 362
 363         s << " ";
 364
 365         std::string target = std::string(" ") +
 366                         sh.get_full_target_name() + " =====";
 367
 368         while (s.str().length() + target.length() < 80)
 369                 s << "=";
 370
 371         s << target;
 372
 373         sblog << "\n" << s.str() << "\n";
 374
 375         s.clear();
 376
 377         if (bc_data) {
 378                 s << "===== " << ndw << " dw ===== " << sh.ngpr
 379                                 << " gprs ===== " << sh.nstack << " stack ";
 380         }
 381
 382         while (s.str().length() < 80)
 383                 s << "=";
 384
 385         sblog << s.str() << "\n";
 386
 387         return 0;
 388 }
 389
 390 int bc_dump::done() {
 391         sb_ostringstream s;
 392         s << "===== SHADER_END ";
 393
 394         while (s.str().length() < 80)
 395                 s << "=";
 396
 397         sblog << s.str() << "\n\n";
 398
 399         return 0;
 400 }
 401
 402 bc_dump::bc_dump(shader& s, bytecode* bc)  :
 403         vpass(s), bc_data(), ndw(), id(),
 404         new_group(), group_index() {
 405
 406         if (bc) {
 407                 bc_data = bc->data();
 408                 ndw = bc->ndw();
 409         }
 410 }
 411
 412 void bc_dump::dump(fetch_node& n) {
 413         sb_ostringstream s;
 414         static const char * fetch_type[] = {"VERTEX", "INSTANCE", ""};
 415
 416         s << n.bc.op_ptr->name;
 417         fill_to(s, 20);
 418
 419         s << "R";
 420         print_sel(s, n.bc.dst_gpr, n.bc.dst_rel, INDEX_LOOP, 0);
 421         s << ".";
 422         for (int k = 0; k < 4; ++k)
 423                 s << chans[n.bc.dst_sel[k]];
 424         s << ", ";
 425
 426         s << "R";
 427         print_sel(s, n.bc.src_gpr, n.bc.src_rel, INDEX_LOOP, 0);
 428         s << ".";
 429
 430         unsigned vtx = n.bc.op_ptr->flags & FF_VTX;
 431         unsigned num_src_comp = vtx ? ctx.is_cayman() ? 2 : 1 : 4;
 432
 433         for (unsigned k = 0; k < num_src_comp; ++k)
 434                 s << chans[n.bc.src_sel[k]];
 435
 436         if (vtx && n.bc.offset[0]) {
 437                 s << " + " << n.bc.offset[0] << "b ";
 438         }
 439
 440         s << ",   RID:" << n.bc.resource_id;
 441
 442         if (vtx) {
 443                 s << "  " << fetch_type[n.bc.fetch_type];
 444                 if (!ctx.is_cayman() && n.bc.mega_fetch_count)
 445                         s << " MFC:" << n.bc.mega_fetch_count;
 446                 if (n.bc.fetch_whole_quad)
 447                         s << " FWQ";
 448                 s << " UCF:" << n.bc.use_const_fields
 449                                 << " FMT(DTA:" << n.bc.data_format
 450                                 << " NUM:" << n.bc.num_format_all
 451                                 << " COMP:" << n.bc.format_comp_all
 452                                 << " MODE:" << n.bc.srf_mode_all << ")";
 453         } else {
 454                 s << ", SID:" << n.bc.sampler_id;
 455                 if (n.bc.lod_bias)
 456                         s << " LB:" << n.bc.lod_bias;
 457                 s << " CT:";
 458                 for (unsigned k = 0; k < 4; ++k)
 459                         s << (n.bc.coord_type[k] ? "N" : "U");
 460                 for (unsigned k = 0; k < 3; ++k)
 461                         if (n.bc.offset[k])
 462                                 s << " O" << chans[k] << ":" << n.bc.offset[k];
 463         }
 464
 465         sblog << s.str() << "\n";
 466 }
 467
 468 void bc_dump::dump_dw(unsigned dw_id, unsigned count) {
 469         if (!bc_data)
 470                 return;
 471
 472         assert(dw_id + count <= ndw);
 473
 474         sblog.print_zw(dw_id, 4);
 475         sblog << "  ";
 476         while (count--) {
 477                 sblog.print_zw_hex(bc_data[dw_id++], 8);
 478                 sblog << " ";
 479         }
 480 }
 481
 482 } // namespace r600_sb