src/gallium/drivers/r600/sb/sb_bc_builder.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 <iostream>
  28 #include <sstream>
  29
  30 #include "sb_bc.h"
  31 #include "sb_shader.h"
  32 #include "sb_pass.h"
  33
  34 namespace r600_sb {
  35
  36 using std::cerr;
  37
  38 bc_builder::bc_builder(shader &s)
  39         : sh(s), ctx(s.get_ctx()), bb(ctx.hw_class_bit()), error(0) {}
  40
  41 int bc_builder::build() {
  42
  43         container_node *root = sh.root;
  44         int cf_cnt = 0;
  45
  46         // FIXME reserve total size to avoid reallocs
  47
  48         for (node_iterator it = root->begin(), end = root->end();
  49                         it != end; ++it) {
  50
  51                 cf_node *cf = static_cast<cf_node*>(*it);
  52                 assert(cf->is_cf_inst() || cf->is_alu_clause() || cf->is_fetch_clause());
  53
  54                 cf_op_flags flags = (cf_op_flags)cf->bc.op_ptr->flags;
  55
  56                 cf->bc.id = cf_cnt++;
  57
  58                 if (flags & CF_ALU) {
  59                         if (cf->bc.is_alu_extended())
  60                                 cf_cnt++;
  61                 }
  62         }
  63
  64         bb.set_size(cf_cnt << 1);
  65         bb.seek(cf_cnt << 1);
  66
  67         unsigned cf_pos = 0;
  68
  69         for (node_iterator I = root->begin(), end = root->end();
  70                         I != end; ++I) {
  71
  72                 cf_node *cf = static_cast<cf_node*>(*I);
  73                 cf_op_flags flags = (cf_op_flags)cf->bc.op_ptr->flags;
  74
  75                 if (flags & CF_ALU) {
  76                         bb.seek(bb.ndw());
  77                         cf->bc.addr = bb.ndw() >> 1;
  78                         build_alu_clause(cf);
  79                         cf->bc.count = (bb.ndw() >> 1) - cf->bc.addr - 1;
  80                 } else if (flags & CF_FETCH) {
  81                         bb.align(4);
  82                         bb.seek(bb.ndw());
  83                         cf->bc.addr = bb.ndw() >> 1;
  84                         build_fetch_clause(cf);
  85                         cf->bc.count = (((bb.ndw() >> 1) - cf->bc.addr) >> 1) - 1;
  86                 } else if (cf->jump_target) {
  87                         cf->bc.addr = cf->jump_target->bc.id;
  88                         if (cf->jump_after_target)
  89                                 cf->bc.addr += 1;
  90                 }
  91
  92                 bb.seek(cf_pos);
  93                 build_cf(cf);
  94                 cf_pos = bb.get_pos();
  95         }
  96
  97         if (sh.enable_dump) {
  98                 bc_dump(sh, cerr, &bb).run();
  99         }
 100
 101         return 0;
 102 }
 103
 104 int bc_builder::build_alu_clause(cf_node* n) {
 105         for (node_iterator I = n->begin(),      E = n->end();
 106                         I != E; ++I) {
 107
 108                 alu_group_node *g = static_cast<alu_group_node*>(*I);
 109                 assert(g->is_valid());
 110
 111                 build_alu_group(g);
 112         }
 113         return 0;
 114 }
 115
 116 int bc_builder::build_alu_group(alu_group_node* n) {
 117
 118         for (node_iterator I = n->begin(),      E = n->end();
 119                         I != E; ++I) {
 120
 121                 alu_node *a = static_cast<alu_node*>(*I);
 122                 assert(a->is_valid());
 123                 build_alu(a);
 124         }
 125
 126         for(int i = 0, ls = n->literals.size(); i < ls; ++i) {
 127                 bb << n->literals.at(i).u;
 128         }
 129
 130         bb.align(2);
 131         bb.seek(bb.ndw());
 132
 133         return 0;
 134 }
 135
 136 int bc_builder::build_fetch_clause(cf_node* n) {
 137         for (node_iterator I = n->begin(), E = n->end();
 138                         I != E; ++I) {
 139                 fetch_node *f = static_cast<fetch_node*>(*I);
 140
 141                 if (f->bc.op_ptr->flags & FF_VTX)
 142                         build_fetch_vtx(f);
 143                 else
 144                         build_fetch_tex(f);
 145         }
 146         return 0;
 147 }
 148
 149
 150 int bc_builder::build_cf(cf_node* n) {
 151         const bc_cf &bc = n->bc;
 152         const cf_op_info *cfop = bc.op_ptr;
 153
 154         if (cfop->flags & CF_ALU)
 155                 return build_cf_alu(n);
 156         if (cfop->flags & (CF_EXP | CF_MEM))
 157                 return build_cf_exp(n);
 158
 159         if (ctx.is_egcm()) {
 160                 bb << CF_WORD0_EGCM()
 161                                 .ADDR(bc.addr)
 162                                 .JUMPTABLE_SEL(bc.jumptable_sel);
 163
 164                 if (ctx.is_evergreen())
 165
 166                         bb << CF_WORD1_EG()
 167                                         .BARRIER(bc.barrier)
 168                                         .CF_CONST(bc.cf_const)
 169                                         .CF_INST(ctx.cf_opcode(bc.op))
 170                                         .COND(bc.cond)
 171                                         .COUNT(bc.count)
 172                                         .END_OF_PROGRAM(bc.end_of_program)
 173                                         .POP_COUNT(bc.pop_count)
 174                                         .VALID_PIXEL_MODE(bc.valid_pixel_mode)
 175                                         .WHOLE_QUAD_MODE(bc.whole_quad_mode);
 176
 177                 else //cayman
 178
 179                         bb << CF_WORD1_CM()
 180                                         .BARRIER(bc.barrier)
 181                                         .CF_CONST(bc.cf_const)
 182                                         .CF_INST(ctx.cf_opcode(bc.op))
 183                                         .COND(bc.cond)
 184                                         .COUNT(bc.count)
 185                                         .POP_COUNT(bc.pop_count)
 186                                         .VALID_PIXEL_MODE(bc.valid_pixel_mode);
 187         } else {
 188                 bb << CF_WORD0_R6R7()
 189                                 .ADDR(bc.addr);
 190
 191                 assert(bc.count < ctx.max_fetch);
 192
 193                 bb << CF_WORD1_R6R7()
 194                                 .BARRIER(bc.barrier)
 195                                 .CALL_COUNT(bc.call_count)
 196                                 .CF_CONST(bc.cf_const)
 197                                 .CF_INST(ctx.cf_opcode(bc.op))
 198                                 .COND(bc.cond)
 199                                 .COUNT(bc.count & 7)
 200                                 .COUNT_3(bc.count >> 3)
 201                                 .END_OF_PROGRAM(bc.end_of_program)
 202                                 .POP_COUNT(bc.pop_count)
 203                                 .VALID_PIXEL_MODE(bc.valid_pixel_mode)
 204                                 .WHOLE_QUAD_MODE(bc.whole_quad_mode);
 205         }
 206
 207         return 0;
 208 }
 209
 210 int bc_builder::build_cf_alu(cf_node* n) {
 211         const bc_cf &bc = n->bc;
 212
 213         assert(bc.count < 128);
 214
 215         if (n->bc.is_alu_extended()) {
 216                 assert(ctx.is_egcm());
 217
 218                 bb << CF_ALU_WORD0_EXT_EGCM()
 219                                 .KCACHE_BANK2(bc.kc[2].bank)
 220                                 .KCACHE_BANK3(bc.kc[3].bank)
 221                                 .KCACHE_BANK_INDEX_MODE0(bc.kc[0].index_mode)
 222                                 .KCACHE_BANK_INDEX_MODE1(bc.kc[1].index_mode)
 223                                 .KCACHE_BANK_INDEX_MODE2(bc.kc[2].index_mode)
 224                                 .KCACHE_BANK_INDEX_MODE3(bc.kc[3].index_mode)
 225                                 .KCACHE_MODE2(bc.kc[2].mode);
 226
 227                 bb << CF_ALU_WORD1_EXT_EGCM()
 228                                 .BARRIER(bc.barrier)
 229                                 .CF_INST(ctx.cf_opcode(CF_OP_ALU_EXT))
 230                                 .KCACHE_ADDR2(bc.kc[2].addr)
 231                                 .KCACHE_ADDR3(bc.kc[3].addr)
 232                                 .KCACHE_MODE3(bc.kc[3].mode);
 233         }
 234
 235         bb << CF_ALU_WORD0_ALL()
 236                         .ADDR(bc.addr)
 237                         .KCACHE_BANK0(bc.kc[0].bank)
 238                         .KCACHE_BANK1(bc.kc[1].bank)
 239                         .KCACHE_MODE0(bc.kc[0].mode);
 240
 241         assert(bc.count < 128);
 242
 243         if (ctx.is_r600())
 244                 bb << CF_ALU_WORD1_R6()
 245                                 .BARRIER(bc.barrier)
 246                                 .CF_INST(ctx.cf_opcode(bc.op))
 247                                 .COUNT(bc.count)
 248                                 .KCACHE_ADDR0(bc.kc[0].addr)
 249                                 .KCACHE_ADDR1(bc.kc[1].addr)
 250                                 .KCACHE_MODE1(bc.kc[1].mode)
 251                                 .USES_WATERFALL(bc.uses_waterfall)
 252                                 .WHOLE_QUAD_MODE(bc.whole_quad_mode);
 253         else
 254                 bb << CF_ALU_WORD1_R7EGCM()
 255                                 .ALT_CONST(bc.alt_const)
 256                                 .BARRIER(bc.barrier)
 257                                 .CF_INST(ctx.cf_opcode(bc.op))
 258                                 .COUNT(bc.count)
 259                                 .KCACHE_ADDR0(bc.kc[0].addr)
 260                                 .KCACHE_ADDR1(bc.kc[1].addr)
 261                                 .KCACHE_MODE1(bc.kc[1].mode)
 262                                 .WHOLE_QUAD_MODE(bc.whole_quad_mode);
 263
 264         return 0;
 265 }
 266
 267 int bc_builder::build_cf_exp(cf_node* n) {
 268         const bc_cf &bc = n->bc;
 269         const cf_op_info *cfop = bc.op_ptr;
 270
 271         if (cfop->flags & CF_RAT) {
 272                 assert(ctx.is_egcm());
 273
 274                 bb << CF_ALLOC_EXPORT_WORD0_RAT_EGCM()
 275                                 .ELEM_SIZE(bc.elem_size)
 276                                 .INDEX_GPR(bc.index_gpr)
 277                                 .RAT_ID(bc.rat_id)
 278                                 .RAT_INDEX_MODE(bc.rat_index_mode)
 279                                 .RAT_INST(bc.rat_inst)
 280                                 .RW_GPR(bc.rw_gpr)
 281                                 .RW_REL(bc.rw_rel)
 282                                 .TYPE(bc.type);
 283         } else {
 284
 285                 bb << CF_ALLOC_EXPORT_WORD0_ALL()
 286                                         .ARRAY_BASE(bc.array_base)
 287                                         .ELEM_SIZE(bc.elem_size)
 288                                         .INDEX_GPR(bc.index_gpr)
 289                                         .RW_GPR(bc.rw_gpr)
 290                                         .RW_REL(bc.rw_rel)
 291                                         .TYPE(bc.type);
 292         }
 293
 294         if (cfop->flags & CF_EXP) {
 295
 296                 if (!ctx.is_egcm())
 297                         bb << CF_ALLOC_EXPORT_WORD1_SWIZ_R6R7()
 298                                         .BARRIER(bc.barrier)
 299                                         .BURST_COUNT(bc.burst_count)
 300                                         .CF_INST(ctx.cf_opcode(bc.op))
 301                                         .END_OF_PROGRAM(bc.end_of_program)
 302                                         .SEL_X(bc.sel[0])
 303                                         .SEL_Y(bc.sel[1])
 304                                         .SEL_Z(bc.sel[2])
 305                                         .SEL_W(bc.sel[3])
 306                                         .VALID_PIXEL_MODE(bc.valid_pixel_mode)
 307                                         .WHOLE_QUAD_MODE(bc.whole_quad_mode);
 308
 309                 else if (ctx.is_evergreen())
 310                         bb << CF_ALLOC_EXPORT_WORD1_SWIZ_EG()
 311                                         .BARRIER(bc.barrier)
 312                                         .BURST_COUNT(bc.burst_count)
 313                                         .CF_INST(ctx.cf_opcode(bc.op))
 314                                         .END_OF_PROGRAM(bc.end_of_program)
 315                                         .MARK(bc.mark)
 316                                         .SEL_X(bc.sel[0])
 317                                         .SEL_Y(bc.sel[1])
 318                                         .SEL_Z(bc.sel[2])
 319                                         .SEL_W(bc.sel[3])
 320                                         .VALID_PIXEL_MODE(bc.valid_pixel_mode);
 321
 322                 else // cayman
 323                         bb << CF_ALLOC_EXPORT_WORD1_SWIZ_CM()
 324                                         .BARRIER(bc.barrier)
 325                                         .BURST_COUNT(bc.burst_count)
 326                                         .CF_INST(ctx.cf_opcode(bc.op))
 327                                         .MARK(bc.mark)
 328                                         .SEL_X(bc.sel[0])
 329                                         .SEL_Y(bc.sel[1])
 330                                         .SEL_Z(bc.sel[2])
 331                                         .SEL_W(bc.sel[3])
 332                                         .VALID_PIXEL_MODE(bc.valid_pixel_mode);
 333
 334         } else if (cfop->flags & CF_MEM) {
 335                 return build_cf_mem(n);
 336         }
 337
 338         return 0;
 339 }
 340
 341 int bc_builder::build_cf_mem(cf_node* n) {
 342         const bc_cf &bc = n->bc;
 343
 344         if (!ctx.is_egcm())
 345                 bb << CF_ALLOC_EXPORT_WORD1_BUF_R6R7()
 346                                 .ARRAY_SIZE(bc.array_size)
 347                                 .BARRIER(bc.barrier)
 348                                 .BURST_COUNT(bc.burst_count)
 349                                 .CF_INST(ctx.cf_opcode(bc.op))
 350                                 .COMP_MASK(bc.comp_mask)
 351                                 .END_OF_PROGRAM(bc.end_of_program)
 352                                 .VALID_PIXEL_MODE(bc.valid_pixel_mode)
 353                                 .WHOLE_QUAD_MODE(bc.whole_quad_mode);
 354
 355         else if (ctx.is_evergreen())
 356                 bb << CF_ALLOC_EXPORT_WORD1_BUF_EG()
 357                                 .ARRAY_SIZE(bc.array_size)
 358                                 .BARRIER(bc.barrier)
 359                                 .BURST_COUNT(bc.burst_count)
 360                                 .CF_INST(ctx.cf_opcode(bc.op))
 361                                 .COMP_MASK(bc.comp_mask)
 362                                 .END_OF_PROGRAM(bc.end_of_program)
 363                                 .MARK(bc.mark)
 364                                 .VALID_PIXEL_MODE(bc.valid_pixel_mode);
 365
 366         else // cayman
 367                 bb << CF_ALLOC_EXPORT_WORD1_BUF_CM()
 368                 .ARRAY_SIZE(bc.array_size)
 369                 .BARRIER(bc.barrier)
 370                 .BURST_COUNT(bc.burst_count)
 371                 .CF_INST(ctx.cf_opcode(bc.op))
 372                 .COMP_MASK(bc.comp_mask)
 373                 .MARK(bc.mark)
 374                 .VALID_PIXEL_MODE(bc.valid_pixel_mode);
 375
 376         return 0;
 377 }
 378
 379 int bc_builder::build_alu(alu_node* n) {
 380         const bc_alu &bc = n->bc;
 381         const alu_op_info *aop = bc.op_ptr;
 382
 383         bb << ALU_WORD0_ALL()
 384                         .INDEX_MODE(bc.index_mode)
 385                         .LAST(bc.last)
 386                         .PRED_SEL(bc.pred_sel)
 387                         .SRC0_SEL(bc.src[0].sel)
 388                         .SRC0_CHAN(bc.src[0].chan)
 389                         .SRC0_NEG(bc.src[0].neg)
 390                         .SRC0_REL(bc.src[0].rel)
 391                         .SRC1_SEL(bc.src[1].sel)
 392                         .SRC1_CHAN(bc.src[1].chan)
 393                         .SRC1_NEG(bc.src[1].neg)
 394                         .SRC1_REL(bc.src[1].rel);
 395
 396         if (aop->src_count<3) {
 397                 if (ctx.is_r600())
 398                         bb << ALU_WORD1_OP2_R6()
 399                                         .ALU_INST(ctx.alu_opcode(bc.op))
 400                                         .BANK_SWIZZLE(bc.bank_swizzle)
 401                                         .CLAMP(bc.clamp)
 402                                         .DST_GPR(bc.dst_gpr)
 403                                         .DST_CHAN(bc.dst_chan)
 404                                         .DST_REL(bc.dst_rel)
 405                                         .FOG_MERGE(bc.fog_merge)
 406                                         .OMOD(bc.omod)
 407                                         .SRC0_ABS(bc.src[0].abs)
 408                                         .SRC1_ABS(bc.src[1].abs)
 409                                         .UPDATE_EXEC_MASK(bc.update_exec_mask)
 410                                         .UPDATE_PRED(bc.update_pred)
 411                                         .WRITE_MASK(bc.write_mask);
 412                 else {
 413
 414                         if (ctx.is_cayman() && (aop->flags & AF_MOVA)) {
 415
 416                                 bb << ALU_WORD1_OP2_MOVA_CM()
 417                                                 .ALU_INST(ctx.alu_opcode(bc.op))
 418                                                 .BANK_SWIZZLE(bc.bank_swizzle)
 419                                                 .CLAMP(bc.clamp)
 420                                                 .MOVA_DST(bc.dst_gpr)
 421                                                 .DST_CHAN(bc.dst_chan)
 422                                                 .DST_REL(bc.dst_rel)
 423                                                 .OMOD(bc.omod)
 424                                                 .UPDATE_EXEC_MASK(bc.update_exec_mask)
 425                                                 .UPDATE_PRED(bc.update_pred)
 426                                                 .WRITE_MASK(bc.write_mask)
 427                                                 .SRC0_ABS(bc.src[0].abs)
 428                                                 .SRC1_ABS(bc.src[1].abs);
 429
 430                         } else if (ctx.is_cayman() && (aop->flags & (AF_PRED|AF_KILL))) {
 431                                 bb << ALU_WORD1_OP2_EXEC_MASK_CM()
 432                                                 .ALU_INST(ctx.alu_opcode(bc.op))
 433                                                 .BANK_SWIZZLE(bc.bank_swizzle)
 434                                                 .CLAMP(bc.clamp)
 435                                                 .DST_CHAN(bc.dst_chan)
 436                                                 .DST_REL(bc.dst_rel)
 437                                                 .EXECUTE_MASK_OP(bc.omod)
 438                                                 .UPDATE_EXEC_MASK(bc.update_exec_mask)
 439                                                 .UPDATE_PRED(bc.update_pred)
 440                                                 .WRITE_MASK(bc.write_mask)
 441                                                 .SRC0_ABS(bc.src[0].abs)
 442                                                 .SRC1_ABS(bc.src[1].abs);
 443
 444                         } else
 445                                 bb << ALU_WORD1_OP2_R7EGCM()
 446                                                 .ALU_INST(ctx.alu_opcode(bc.op))
 447                                                 .BANK_SWIZZLE(bc.bank_swizzle)
 448                                                 .CLAMP(bc.clamp)
 449                                                 .DST_GPR(bc.dst_gpr)
 450                                                 .DST_CHAN(bc.dst_chan)
 451                                                 .DST_REL(bc.dst_rel)
 452                                                 .OMOD(bc.omod)
 453                                                 .UPDATE_EXEC_MASK(bc.update_exec_mask)
 454                                                 .UPDATE_PRED(bc.update_pred)
 455                                                 .WRITE_MASK(bc.write_mask)
 456                                                 .SRC0_ABS(bc.src[0].abs)
 457                                                 .SRC1_ABS(bc.src[1].abs);
 458
 459                 }
 460         } else
 461                 bb << ALU_WORD1_OP3_ALL()
 462                                 .ALU_INST(ctx.alu_opcode(bc.op))
 463                                 .BANK_SWIZZLE(bc.bank_swizzle)
 464                                 .CLAMP(bc.clamp)
 465                                 .DST_GPR(bc.dst_gpr)
 466                                 .DST_CHAN(bc.dst_chan)
 467                                 .DST_REL(bc.dst_rel)
 468                                 .SRC2_SEL(bc.src[2].sel)
 469                                 .SRC2_CHAN(bc.src[2].chan)
 470                                 .SRC2_NEG(bc.src[2].neg)
 471                                 .SRC2_REL(bc.src[2].rel);
 472         return 0;
 473 }
 474
 475 int bc_builder::build_fetch_tex(fetch_node* n) {
 476         const bc_fetch &bc = n->bc;
 477         const fetch_op_info *fop = bc.op_ptr;
 478
 479         assert(!(fop->flags & FF_VTX));
 480
 481         if (ctx.is_r600())
 482                 bb << TEX_WORD0_R6()
 483                                 .BC_FRAC_MODE(bc.bc_frac_mode)
 484                                 .FETCH_WHOLE_QUAD(bc.fetch_whole_quad)
 485                                 .RESOURCE_ID(bc.resource_id)
 486                                 .SRC_GPR(bc.src_gpr)
 487                                 .SRC_REL(bc.src_rel)
 488                                 .TEX_INST(ctx.fetch_opcode(bc.op));
 489
 490         else if (ctx.is_r700())
 491                 bb << TEX_WORD0_R7()
 492                                 .ALT_CONST(bc.alt_const)
 493                                 .BC_FRAC_MODE(bc.bc_frac_mode)
 494                                 .FETCH_WHOLE_QUAD(bc.fetch_whole_quad)
 495                                 .RESOURCE_ID(bc.resource_id)
 496                                 .SRC_GPR(bc.src_gpr)
 497                                 .SRC_REL(bc.src_rel)
 498                                 .TEX_INST(ctx.fetch_opcode(bc.op));
 499
 500         else
 501                 bb << TEX_WORD0_EGCM()
 502                                 .ALT_CONST(bc.alt_const)
 503                                 .FETCH_WHOLE_QUAD(bc.fetch_whole_quad)
 504                                 .INST_MOD(bc.inst_mod)
 505                                 .RESOURCE_ID(bc.resource_id)
 506                                 .RESOURCE_INDEX_MODE(bc.resource_index_mode)
 507                                 .SAMPLER_INDEX_MODE(bc.sampler_index_mode)
 508                                 .SRC_GPR(bc.src_gpr)
 509                                 .SRC_REL(bc.src_rel)
 510                                 .TEX_INST(ctx.fetch_opcode(bc.op));
 511
 512         bb << TEX_WORD1_ALL()
 513                         .COORD_TYPE_X(bc.coord_type[0])
 514                         .COORD_TYPE_Y(bc.coord_type[1])
 515                         .COORD_TYPE_Z(bc.coord_type[2])
 516                         .COORD_TYPE_W(bc.coord_type[3])
 517                         .DST_GPR(bc.dst_gpr)
 518                         .DST_REL(bc.dst_rel)
 519                         .DST_SEL_X(bc.dst_sel[0])
 520                         .DST_SEL_Y(bc.dst_sel[1])
 521                         .DST_SEL_Z(bc.dst_sel[2])
 522                         .DST_SEL_W(bc.dst_sel[3])
 523                         .LOD_BIAS(bc.lod_bias);
 524
 525         bb << TEX_WORD2_ALL()
 526                         .OFFSET_X(bc.offset[0])
 527                         .OFFSET_Y(bc.offset[1])
 528                         .OFFSET_Z(bc.offset[2])
 529                         .SAMPLER_ID(bc.sampler_id)
 530                         .SRC_SEL_X(bc.src_sel[0])
 531                         .SRC_SEL_Y(bc.src_sel[1])
 532                         .SRC_SEL_Z(bc.src_sel[2])
 533                         .SRC_SEL_W(bc.src_sel[3]);
 534
 535         bb << 0;
 536         return 0;
 537 }
 538
 539 int bc_builder::build_fetch_vtx(fetch_node* n) {
 540         const bc_fetch &bc = n->bc;
 541         const fetch_op_info *fop = bc.op_ptr;
 542
 543         assert(fop->flags & FF_VTX);
 544
 545         if (!ctx.is_cayman())
 546                 bb << VTX_WORD0_R6R7EG()
 547                                 .BUFFER_ID(bc.resource_id)
 548                                 .FETCH_TYPE(bc.fetch_type)
 549                                 .FETCH_WHOLE_QUAD(bc.fetch_whole_quad)
 550                                 .MEGA_FETCH_COUNT(bc.mega_fetch_count)
 551                                 .SRC_GPR(bc.src_gpr)
 552                                 .SRC_REL(bc.src_rel)
 553                                 .SRC_SEL_X(bc.src_sel[0])
 554                                 .VC_INST(ctx.fetch_opcode(bc.op));
 555
 556         else
 557                 bb << VTX_WORD0_CM()
 558                                 .BUFFER_ID(bc.resource_id)
 559                                 .COALESCED_READ(bc.coalesced_read)
 560                                 .FETCH_TYPE(bc.fetch_type)
 561                                 .FETCH_WHOLE_QUAD(bc.fetch_whole_quad)
 562                                 .LDS_REQ(bc.lds_req)
 563                                 .SRC_GPR(bc.src_gpr)
 564                                 .SRC_REL(bc.src_rel)
 565                                 .SRC_SEL_X(bc.src_sel[0])
 566                                 .SRC_SEL_Y(bc.src_sel[1])
 567                                 .STRUCTURED_READ(bc.structured_read)
 568                                 .VC_INST(ctx.fetch_opcode(bc.op));
 569
 570         if (bc.op == FETCH_OP_SEMFETCH)
 571                 bb << VTX_WORD1_SEM_ALL()
 572                                 .DATA_FORMAT(bc.data_format)
 573                                 .DST_SEL_X(bc.dst_sel[0])
 574                                 .DST_SEL_Y(bc.dst_sel[1])
 575                                 .DST_SEL_Z(bc.dst_sel[2])
 576                                 .DST_SEL_W(bc.dst_sel[3])
 577                                 .FORMAT_COMP_ALL(bc.format_comp_all)
 578                                 .NUM_FORMAT_ALL(bc.num_format_all)
 579                                 .SEMANTIC_ID(bc.semantic_id)
 580                                 .SRF_MODE_ALL(bc.srf_mode_all)
 581                                 .USE_CONST_FIELDS(bc.use_const_fields);
 582         else
 583                 bb << VTX_WORD1_GPR_ALL()
 584                                 .DATA_FORMAT(bc.data_format)
 585                                 .DST_GPR(bc.dst_gpr)
 586                                 .DST_REL(bc.dst_rel)
 587                                 .DST_SEL_X(bc.dst_sel[0])
 588                                 .DST_SEL_Y(bc.dst_sel[1])
 589                                 .DST_SEL_Z(bc.dst_sel[2])
 590                                 .DST_SEL_W(bc.dst_sel[3])
 591                                 .FORMAT_COMP_ALL(bc.format_comp_all)
 592                                 .NUM_FORMAT_ALL(bc.num_format_all)
 593                                 .SRF_MODE_ALL(bc.srf_mode_all)
 594                                 .USE_CONST_FIELDS(bc.use_const_fields);
 595
 596         switch (ctx.hw_class) {
 597         case HW_CLASS_R600:
 598                 bb << VTX_WORD2_R6()
 599                                 .CONST_BUF_NO_STRIDE(bc.const_buf_no_stride)
 600                                 .ENDIAN_SWAP(bc.endian_swap)
 601                                 .MEGA_FETCH(bc.mega_fetch)
 602                                 .OFFSET(bc.offset[0]);
 603                 break;
 604         case HW_CLASS_R700:
 605                 bb << VTX_WORD2_R7()
 606                                 .ALT_CONST(bc.alt_const)
 607                                 .CONST_BUF_NO_STRIDE(bc.const_buf_no_stride)
 608                                 .ENDIAN_SWAP(bc.endian_swap)
 609                                 .MEGA_FETCH(bc.mega_fetch)
 610                                 .OFFSET(bc.offset[0]);
 611                 break;
 612         case HW_CLASS_EVERGREEN:
 613                 bb << VTX_WORD2_EG()
 614                                 .ALT_CONST(bc.alt_const)
 615                                 .BUFFER_INDEX_MODE(bc.resource_index_mode)
 616                                 .CONST_BUF_NO_STRIDE(bc.const_buf_no_stride)
 617                                 .ENDIAN_SWAP(bc.endian_swap)
 618                                 .MEGA_FETCH(bc.mega_fetch)
 619                                 .OFFSET(bc.offset[0]);
 620                 break;
 621         case HW_CLASS_CAYMAN:
 622                 bb << VTX_WORD2_CM()
 623                                 .ALT_CONST(bc.alt_const)
 624                                 .BUFFER_INDEX_MODE(bc.resource_index_mode)
 625                                 .CONST_BUF_NO_STRIDE(bc.const_buf_no_stride)
 626                                 .ENDIAN_SWAP(bc.endian_swap)
 627                                 .OFFSET(bc.offset[0]);
 628                 break;
 629         default:
 630                 assert(!"unknown hw class");
 631                 return -1;
 632         }
 633
 634         bb << 0;
 635         return 0;
 636 }
 637
 638 }