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