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 #include "eg_sq.h" // V_SQ_CF_INDEX_0/1
  31
  32 namespace r600_sb {
  33
  34 static const char* chans = "xyzw01?_";
  35
  36 static const char* vec_bs[] = {
  37                 "VEC_012", "VEC_021", "VEC_120", "VEC_102", "VEC_201", "VEC_210"
  38 };
  39
  40 static const char* scl_bs[] = {
  41                 "SCL_210", "SCL_122", "SCL_212", "SCL_221"
  42 };
  43
  44
  45 bool bc_dump::visit(cf_node& n, bool enter) {
  46         if (enter) {
  47
  48                 id = n.bc.id << 1;
  49
  50                 if ((n.bc.op_ptr->flags & CF_ALU) && n.bc.is_alu_extended()) {
  51                         dump_dw(id, 2);
  52                         id += 2;
  53                         sblog << "\n";
  54                 }
  55
  56                 dump_dw(id, 2);
  57                 dump(n);
  58
  59                 if (n.bc.op_ptr->flags & CF_CLAUSE) {
  60                         id = n.bc.addr << 1;
  61                         new_group = 1;
  62                 }
  63         }
  64         return true;
  65 }
  66
  67 bool bc_dump::visit(alu_node& n, bool enter) {
  68         if (enter) {
  69                 sblog << " ";
  70                 dump_dw(id, 2);
  71
  72                 if (new_group) {
  73                         sblog.print_w(++group_index, 5);
  74                         sblog << " ";
  75                 } else
  76                         sblog << "      ";
  77
  78                 dump(n);
  79                 id += 2;
  80
  81                 new_group = n.bc.last;
  82         } else {
  83                 if (n.bc.last) {
  84                         alu_group_node *g =
  85                                         static_cast<alu_group_node*>(n.get_alu_group_node());
  86                         assert(g);
  87                         for (unsigned k = 0; k < g->literals.size(); ++k) {
  88                                 sblog << " ";
  89                                 dump_dw(id, 1);
  90                                 id += 1;
  91                                 sblog << "\n";
  92                         }
  93
  94                         id = (id + 1) & ~1u;
  95                 }
  96         }
  97
  98         return false;
  99 }
 100
 101 bool bc_dump::visit(fetch_node& n, bool enter) {
 102         if (enter) {
 103                 sblog << " ";
 104                 dump_dw(id, 3);
 105                 dump(n);
 106                 id += 4;
 107         }
 108         return false;
 109 }
 110
 111 static void fill_to(sb_ostringstream &s, int pos) {
 112         int l = s.str().length();
 113         if (l < pos)
 114                 s << std::string(pos-l, ' ');
 115 }
 116
 117 void bc_dump::dump(cf_node& n) {
 118         sb_ostringstream s;
 119         s << n.bc.op_ptr->name;
 120
 121         if (n.bc.op_ptr->flags & CF_EXP) {
 122                 static const char *exp_type[] = {"PIXEL", "POS  ", "PARAM"};
 123
 124                 fill_to(s, 18);
 125                 s << " " << exp_type[n.bc.type] << " ";
 126
 127                 if (n.bc.burst_count) {
 128                         sb_ostringstream s2;
 129                         s2 << n.bc.array_base << "-" << n.bc.array_base + n.bc.burst_count;
 130                         s.print_wl(s2.str(), 5);
 131                         s << " R" << n.bc.rw_gpr << "-" <<
 132                                         n.bc.rw_gpr + n.bc.burst_count << ".";
 133                 } else {
 134                         s.print_wl(n.bc.array_base, 5);
 135                         s << " R" << n.bc.rw_gpr << ".";
 136                 }
 137
 138                 for (int k = 0; k < 4; ++k)
 139                         s << chans[n.bc.sel[k]];
 140
 141         } else if (n.bc.op_ptr->flags & CF_MEM) {
 142                 static const char *exp_type[] = {"WRITE", "WRITE_IND", "WRITE_ACK",
 143                                 "WRITE_IND_ACK"};
 144                 fill_to(s, 18);
 145                 s << " " << exp_type[n.bc.type] << " ";
 146                 s.print_wl(n.bc.array_base, 5);
 147                 s << " R" << n.bc.rw_gpr << ".";
 148                 for (int k = 0; k < 4; ++k)
 149                         s << ((n.bc.comp_mask & (1 << k)) ? chans[k] : '_');
 150
 151                 if ((n.bc.op_ptr->flags & CF_RAT) && (n.bc.type & 1)) {
 152                         s << ", @R" << n.bc.index_gpr << ".xyz";
 153                 }
 154                 if ((n.bc.op_ptr->flags & CF_MEM) && (n.bc.type & 1)) {
 155                         s << ", @R" << n.bc.index_gpr << ".x";
 156                 }
 157
 158                 s << "  ES:" << n.bc.elem_size;
 159
 160                 if (n.bc.mark)
 161                         s << " MARK";
 162
 163         } else {
 164
 165                 if (n.bc.op_ptr->flags & CF_CLAUSE) {
 166                         s << " " << n.bc.count+1;
 167                 }
 168
 169                 s << " @" << (n.bc.addr << 1);
 170
 171                 if (n.bc.op_ptr->flags & CF_ALU) {
 172                         static const char *index_mode[] = {"", " CF_INDEX_0", " CF_INDEX_1"};
 173
 174                         for (int k = 0; k < 4; ++k) {
 175                                 bc_kcache &kc = n.bc.kc[k];
 176                                 if (kc.mode) {
 177                                         s << " KC" << k << "[CB" << kc.bank << ":" <<
 178                                                         (kc.addr << 4) << "-" <<
 179                                                         (((kc.addr + kc.mode) << 4) - 1) << index_mode[kc.index_mode] << "]";
 180                                 }
 181                         }
 182                 }
 183
 184                 if (n.bc.cond)
 185                         s << " CND:" << n.bc.cond;
 186
 187                 if (n.bc.pop_count)
 188                         s << " POP:" << n.bc.pop_count;
 189
 190                 if (n.bc.count && (n.bc.op_ptr->flags & CF_EMIT))
 191                         s << " STREAM" << n.bc.count;
 192         }
 193
 194         if (!n.bc.barrier)
 195                 s << "  NO_BARRIER";
 196
 197         if (n.bc.valid_pixel_mode)
 198                 s << "  VPM";
 199
 200         if (n.bc.whole_quad_mode)
 201                 s << "  WQM";
 202
 203         if (n.bc.end_of_program)
 204                 s << "  EOP";
 205
 206         sblog << s.str() << "\n";
 207 }
 208
 209
 210 static void print_sel(sb_ostream &s, int sel, int rel, int index_mode,
 211                       int need_brackets) {
 212         if (rel && index_mode >= 5 && sel < 128)
 213                 s << "G";
 214         if (rel || need_brackets) {
 215                 s << "[";
 216         }
 217         s << sel;
 218         if (rel) {
 219                 if (index_mode == 0 || index_mode == 6)
 220                         s << "+AR";
 221                 else if (index_mode == 4)
 222                         s << "+AL";
 223         }
 224         if (rel || need_brackets) {
 225                 s << "]";
 226         }
 227 }
 228
 229 static void print_dst(sb_ostream &s, bc_alu &alu)
 230 {
 231         unsigned sel = alu.dst_gpr;
 232         char reg_char = 'R';
 233         if (sel >= 128 - 4) { // clause temporary gpr
 234                 sel -= 128 - 4;
 235                 reg_char = 'T';
 236         }
 237
 238         if (alu.write_mask || (alu.op_ptr->src_count == 3 && alu.op < LDS_OP2_LDS_ADD)) {
 239                 s << reg_char;
 240                 print_sel(s, sel, alu.dst_rel, alu.index_mode, 0);
 241         } else {
 242                 s << "__";
 243         }
 244         s << ".";
 245         s << chans[alu.dst_chan];
 246 }
 247
 248 static void print_src(sb_ostream &s, bc_alu &alu, unsigned idx)
 249 {
 250         bc_alu_src *src = &alu.src[idx];
 251         unsigned sel = src->sel, need_sel = 1, need_chan = 1, need_brackets = 0;
 252
 253         if (src->neg)
 254                 s <<"-";
 255         if (src->abs)
 256                 s <<"|";
 257
 258         if (sel < 128 - 4) {
 259                 s << "R";
 260         } else if (sel < 128) {
 261                 s << "T";
 262                 sel -= 128 - 4;
 263         } else if (sel < 160) {
 264                 s << "KC0";
 265                 need_brackets = 1;
 266                 sel -= 128;
 267         } else if (sel < 192) {
 268                 s << "KC1";
 269                 need_brackets = 1;
 270                 sel -= 160;
 271         } else if (sel >= 448) {
 272                 s << "Param";
 273                 sel -= 448;
 274         } else if (sel >= 288) {
 275                 s << "KC3";
 276                 need_brackets = 1;
 277                 sel -= 288;
 278         } else if (sel >= 256) {
 279                 s << "KC2";
 280                 need_brackets = 1;
 281                 sel -= 256;
 282         } else {
 283                 need_sel = 0;
 284                 need_chan = 0;
 285                 switch (sel) {
 286                 case ALU_SRC_LDS_OQ_A:
 287                         s << "LDS_OQ_A";
 288                         need_chan = 1;
 289                         break;
 290                 case ALU_SRC_LDS_OQ_B:
 291                         s << "LDS_OQ_B";
 292                         need_chan = 1;
 293                         break;
 294                 case ALU_SRC_LDS_OQ_A_POP:
 295                         s << "LDS_OQ_A_POP";
 296                         need_chan = 1;
 297                         break;
 298                 case ALU_SRC_LDS_OQ_B_POP:
 299                         s << "LDS_OQ_B_POP";
 300                         need_chan = 1;
 301                         break;
 302                 case ALU_SRC_LDS_DIRECT_A:
 303                         s << "LDS_A["; s.print_zw_hex(src->value.u, 8); s << "]";
 304                         break;
 305                 case ALU_SRC_LDS_DIRECT_B:
 306                         s << "LDS_B["; s.print_zw_hex(src->value.u, 8); s << "]";
 307                         break;
 308                 case ALU_SRC_PS:
 309                         s << "PS";
 310                         break;
 311                 case ALU_SRC_PV:
 312                         s << "PV";
 313                         need_chan = 1;
 314                         break;
 315                 case ALU_SRC_LITERAL:
 316                         s << "[0x";
 317                         s.print_zw_hex(src->value.u, 8);
 318                         s << " " << src->value.f << "]";
 319                         need_chan = 1;
 320                         break;
 321                 case ALU_SRC_0_5:
 322                         s << "0.5";
 323                         break;
 324                 case ALU_SRC_M_1_INT:
 325                         s << "-1";
 326                         break;
 327                 case ALU_SRC_1_INT:
 328                         s << "1";
 329                         break;
 330                 case ALU_SRC_1:
 331                         s << "1.0";
 332                         break;
 333                 case ALU_SRC_0:
 334                         s << "0";
 335                         break;
 336                 case ALU_SRC_MASK_LO:
 337                         s << "MASK_LO";
 338                         break;
 339                 case ALU_SRC_MASK_HI:
 340                         s << "MASK_HI";
 341                         break;
 342                 case ALU_SRC_HW_WAVE_ID:
 343                         s << "HW_WAVE_ID";
 344                         break;
 345                 case ALU_SRC_SIMD_ID:
 346                         s << "SIMD_ID";
 347                         break;
 348                 case ALU_SRC_SE_ID:
 349                         s << "SE_ID";
 350                         break;
 351                 default:
 352                         s << "??IMM_" <<  sel;
 353                         break;
 354                 }
 355         }
 356
 357         if (need_sel)
 358                 print_sel(s, sel, src->rel, alu.index_mode, need_brackets);
 359
 360         if (need_chan) {
 361                 s << "." << chans[src->chan];
 362         }
 363
 364         if (src->abs)
 365                 s << "|";
 366 }
 367 void bc_dump::dump(alu_node& n) {
 368         sb_ostringstream s;
 369         static const char *omod_str[] = {"","*2","*4","/2"};
 370         static const char *slots = "xyzwt";
 371
 372         s << (n.bc.update_exec_mask ? "M" : " ");
 373         s << (n.bc.update_pred ? "P" : " ");
 374         s << " ";
 375         s << (n.bc.pred_sel>=2 ? (n.bc.pred_sel == 2 ? "0" : "1") : " ");
 376         s << " ";
 377
 378         s << slots[n.bc.slot] << ": ";
 379
 380         s << n.bc.op_ptr->name << omod_str[n.bc.omod] << (n.bc.clamp ? "_sat" : "");
 381         fill_to(s, 26);
 382         s << " ";
 383
 384         print_dst(s, n.bc);
 385         for (int k = 0; k < n.bc.op_ptr->src_count; ++k) {
 386                 s << (k ? ", " : ",  ");
 387                 print_src(s, n.bc, k);
 388         }
 389
 390         if (n.bc.bank_swizzle) {
 391                 fill_to(s, 55);
 392                 if (n.bc.slot == SLOT_TRANS)
 393                         s << "  " << scl_bs[n.bc.bank_swizzle];
 394                 else
 395                         s << "  " << vec_bs[n.bc.bank_swizzle];
 396         }
 397
 398         if (ctx.is_cayman()) {
 399                 if (n.bc.op == ALU_OP1_MOVA_INT) {
 400                         static const char *mova_str[] = { " AR_X", " PC", " CF_IDX0", " CF_IDX1",
 401                                 " Unknown MOVA_INT dest" };
 402                         s << mova_str[std::min(n.bc.dst_gpr, 4u)];  // CM_V_SQ_MOVA_DST_AR_*
 403                 }
 404         }
 405
 406         if (n.bc.lds_idx_offset) {
 407                 s << " IDX_OFFSET:" << n.bc.lds_idx_offset;
 408         }
 409
 410         sblog << s.str() << "\n";
 411 }
 412
 413 int bc_dump::init() {
 414         sb_ostringstream s;
 415         s << "===== SHADER #" << sh.id;
 416
 417         if (sh.optimized)
 418                 s << " OPT";
 419
 420         s << " ";
 421
 422         std::string target = std::string(" ") +
 423                         sh.get_full_target_name() + " =====";
 424
 425         while (s.str().length() + target.length() < 80)
 426                 s << "=";
 427
 428         s << target;
 429
 430         sblog << "\n" << s.str() << "\n";
 431
 432         s.clear();
 433
 434         if (bc_data) {
 435                 s << "===== " << ndw << " dw ===== " << sh.ngpr
 436                                 << " gprs ===== " << sh.nstack << " stack ";
 437         }
 438
 439         while (s.str().length() < 80)
 440                 s << "=";
 441
 442         sblog << s.str() << "\n";
 443
 444         return 0;
 445 }
 446
 447 int bc_dump::done() {
 448         sb_ostringstream s;
 449         s << "===== SHADER_END ";
 450
 451         while (s.str().length() < 80)
 452                 s << "=";
 453
 454         sblog << s.str() << "\n\n";
 455
 456         return 0;
 457 }
 458
 459 bc_dump::bc_dump(shader& s, bytecode* bc)  :
 460         vpass(s), bc_data(), ndw(), id(),
 461         new_group(), group_index() {
 462
 463         if (bc) {
 464                 bc_data = bc->data();
 465                 ndw = bc->ndw();
 466         }
 467 }
 468
 469 void bc_dump::dump(fetch_node& n) {
 470         sb_ostringstream s;
 471         static const char * fetch_type[] = {"VERTEX", "INSTANCE", ""};
 472         unsigned gds = n.bc.op_ptr->flags & FF_GDS;
 473         bool gds_has_ret = gds && n.bc.op >= FETCH_OP_GDS_ADD_RET &&
 474                 n.bc.op <= FETCH_OP_GDS_USHORT_READ_RET;
 475         bool show_dst = !gds || (gds && gds_has_ret);
 476
 477         s << n.bc.op_ptr->name;
 478         fill_to(s, 20);
 479
 480         if (show_dst) {
 481                 s << "R";
 482                 print_sel(s, n.bc.dst_gpr, n.bc.dst_rel, INDEX_LOOP, 0);
 483                 s << ".";
 484                 for (int k = 0; k < 4; ++k)
 485                         s << chans[n.bc.dst_sel[k]];
 486                 s << ", ";
 487         }
 488
 489         s << "R";
 490         print_sel(s, n.bc.src_gpr, n.bc.src_rel, INDEX_LOOP, 0);
 491         s << ".";
 492
 493         unsigned vtx = n.bc.op_ptr->flags & FF_VTX;
 494         unsigned num_src_comp = gds ? 3 : vtx ? ctx.is_cayman() ? 2 : 1 : 4;
 495
 496         for (unsigned k = 0; k < num_src_comp; ++k)
 497                 s << chans[n.bc.src_sel[k]];
 498
 499         if (vtx && n.bc.offset[0]) {
 500                 s << " + " << n.bc.offset[0] << "b ";
 501         }
 502
 503         if (!gds)
 504                 s << ",   RID:" << n.bc.resource_id;
 505
 506         if (gds) {
 507                 s << " UAV:" << n.bc.uav_id;
 508                 if (n.bc.uav_index_mode)
 509                         s << " UAV:SQ_CF_INDEX_" << (n.bc.uav_index_mode - V_SQ_CF_INDEX_0);
 510                 if (n.bc.bcast_first_req)
 511                         s << " BFQ";
 512                 if (n.bc.alloc_consume)
 513                         s << " AC";
 514         } else if (vtx) {
 515                 s << "  " << fetch_type[n.bc.fetch_type];
 516                 if (!ctx.is_cayman() && n.bc.mega_fetch_count)
 517                         s << " MFC:" << n.bc.mega_fetch_count;
 518                 if (n.bc.fetch_whole_quad)
 519                         s << " FWQ";
 520                 if (ctx.is_egcm() && n.bc.resource_index_mode)
 521                         s << " RIM:SQ_CF_INDEX_" << (n.bc.resource_index_mode - V_SQ_CF_INDEX_0);
 522                 if (ctx.is_egcm() && n.bc.sampler_index_mode)
 523                         s << " SID:SQ_CF_INDEX_" << (n.bc.sampler_index_mode - V_SQ_CF_INDEX_0);
 524
 525                 s << " UCF:" << n.bc.use_const_fields
 526                                 << " FMT(DTA:" << n.bc.data_format
 527                                 << " NUM:" << n.bc.num_format_all
 528                                 << " COMP:" << n.bc.format_comp_all
 529                                 << " MODE:" << n.bc.srf_mode_all << ")";
 530         } else {
 531                 s << ", SID:" << n.bc.sampler_id;
 532                 if (n.bc.lod_bias)
 533                         s << " LB:" << n.bc.lod_bias;
 534                 s << " CT:";
 535                 for (unsigned k = 0; k < 4; ++k)
 536                         s << (n.bc.coord_type[k] ? "N" : "U");
 537                 for (unsigned k = 0; k < 3; ++k)
 538                         if (n.bc.offset[k])
 539                                 s << " O" << chans[k] << ":" << n.bc.offset[k];
 540                 if (ctx.is_egcm() && n.bc.resource_index_mode)
 541                         s << " RIM:SQ_CF_INDEX_" << (n.bc.resource_index_mode - V_SQ_CF_INDEX_0);
 542                 if (ctx.is_egcm() && n.bc.sampler_index_mode)
 543                         s << " SID:SQ_CF_INDEX_" << (n.bc.sampler_index_mode - V_SQ_CF_INDEX_0);
 544         }
 545
 546         if (n.bc.op_ptr->flags & FF_MEM) {
 547                 s << ", ELEM_SIZE:" << n.bc.elem_size;
 548                 if (n.bc.uncached)
 549                         s << ", UNCACHED";
 550                 if (n.bc.indexed)
 551                         s << ", INDEXED";
 552                 if (n.bc.burst_count)
 553                         s << ", BURST_COUNT:" << n.bc.burst_count;
 554                 s << ", ARRAY_BASE:" << n.bc.array_base;
 555                 s << ", ARRAY_SIZE:" << n.bc.array_size;
 556         }
 557
 558         sblog << s.str() << "\n";
 559 }
 560
 561 void bc_dump::dump_dw(unsigned dw_id, unsigned count) {
 562         if (!bc_data)
 563                 return;
 564
 565         assert(dw_id + count <= ndw);
 566
 567         sblog.print_zw(dw_id, 4);
 568         sblog << "  ";
 569         while (count--) {
 570                 sblog.print_zw_hex(bc_data[dw_id++], 8);
 571                 sblog << " ";
 572         }
 573 }
 574
 575 } // namespace r600_sb