src/gallium/auxiliary/tgsi/tgsi_util.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_debug.h"
  29 #include "pipe/p_shader_tokens.h"
  30 #include "tgsi_parse.h"
  31 #include "tgsi_util.h"
  32 #include "tgsi_exec.h"
  33
  34 union pointer_hack
  35 {
  36    void *pointer;
  37    uint64_t uint64;
  38 };
  39
  40 void *
  41 tgsi_align_128bit(
  42    void *unaligned )
  43 {
  44    union pointer_hack ph;
  45
  46    ph.uint64 = 0;
  47    ph.pointer = unaligned;
  48    ph.uint64 = (ph.uint64 + 15) & ~15;
  49    return ph.pointer;
  50 }
  51
  52 unsigned
  53 tgsi_util_get_src_register_swizzle(
  54    const struct tgsi_src_register *reg,
  55    unsigned component )
  56 {
  57    switch (component) {
  58    case TGSI_CHAN_X:
  59       return reg->SwizzleX;
  60    case TGSI_CHAN_Y:
  61       return reg->SwizzleY;
  62    case TGSI_CHAN_Z:
  63       return reg->SwizzleZ;
  64    case TGSI_CHAN_W:
  65       return reg->SwizzleW;
  66    default:
  67       assert(0);
  68    }
  69    return 0;
  70 }
  71
  72
  73 unsigned
  74 tgsi_util_get_full_src_register_swizzle(
  75    const struct tgsi_full_src_register  *reg,
  76    unsigned component )
  77 {
  78    return tgsi_util_get_src_register_swizzle(
  79       &reg->Register,
  80       component );
  81 }
  82
  83 void
  84 tgsi_util_set_src_register_swizzle(
  85    struct tgsi_src_register *reg,
  86    unsigned swizzle,
  87    unsigned component )
  88 {
  89    switch( component ) {
  90    case 0:
  91       reg->SwizzleX = swizzle;
  92       break;
  93    case 1:
  94       reg->SwizzleY = swizzle;
  95       break;
  96    case 2:
  97       reg->SwizzleZ = swizzle;
  98       break;
  99    case 3:
 100       reg->SwizzleW = swizzle;
 101       break;
 102    default:
 103       assert( 0 );
 104    }
 105 }
 106
 107 unsigned
 108 tgsi_util_get_full_src_register_sign_mode(
 109    const struct  tgsi_full_src_register *reg,
 110    unsigned component )
 111 {
 112    unsigned sign_mode;
 113
 114    if( reg->Register.Absolute ) {
 115       /* Consider only the post-abs negation. */
 116
 117       if( reg->Register.Negate ) {
 118          sign_mode = TGSI_UTIL_SIGN_SET;
 119       }
 120       else {
 121          sign_mode = TGSI_UTIL_SIGN_CLEAR;
 122       }
 123    }
 124    else {
 125       if( reg->Register.Negate ) {
 126          sign_mode = TGSI_UTIL_SIGN_TOGGLE;
 127       }
 128       else {
 129          sign_mode = TGSI_UTIL_SIGN_KEEP;
 130       }
 131    }
 132
 133    return sign_mode;
 134 }
 135
 136 void
 137 tgsi_util_set_full_src_register_sign_mode(
 138    struct tgsi_full_src_register *reg,
 139    unsigned sign_mode )
 140 {
 141    switch (sign_mode)
 142    {
 143    case TGSI_UTIL_SIGN_CLEAR:
 144       reg->Register.Negate = 0;
 145       reg->Register.Absolute = 1;
 146       break;
 147
 148    case TGSI_UTIL_SIGN_SET:
 149       reg->Register.Absolute = 1;
 150       reg->Register.Negate = 1;
 151       break;
 152
 153    case TGSI_UTIL_SIGN_TOGGLE:
 154       reg->Register.Negate = 1;
 155       reg->Register.Absolute = 0;
 156       break;
 157
 158    case TGSI_UTIL_SIGN_KEEP:
 159       reg->Register.Negate = 0;
 160       reg->Register.Absolute = 0;
 161       break;
 162
 163    default:
 164       assert( 0 );
 165    }
 166 }
 167
 168 /**
 169  * Determine which channels of the specificed src register are effectively
 170  * used by this instruction.
 171  */
 172 unsigned
 173 tgsi_util_get_inst_usage_mask(const struct tgsi_full_instruction *inst,
 174                               unsigned src_idx)
 175 {
 176    const struct tgsi_full_src_register *src = &inst->Src[src_idx];
 177    unsigned write_mask = inst->Dst[0].Register.WriteMask;
 178    unsigned read_mask;
 179    unsigned usage_mask;
 180    unsigned chan;
 181
 182    switch (inst->Instruction.Opcode) {
 183    case TGSI_OPCODE_MOV:
 184    case TGSI_OPCODE_ARL:
 185    case TGSI_OPCODE_ARR:
 186    case TGSI_OPCODE_RCP:
 187    case TGSI_OPCODE_MUL:
 188    case TGSI_OPCODE_DIV:
 189    case TGSI_OPCODE_ADD:
 190    case TGSI_OPCODE_MIN:
 191    case TGSI_OPCODE_MAX:
 192    case TGSI_OPCODE_SLT:
 193    case TGSI_OPCODE_SGE:
 194    case TGSI_OPCODE_MAD:
 195    case TGSI_OPCODE_SUB:
 196    case TGSI_OPCODE_LRP:
 197    case TGSI_OPCODE_FMA:
 198    case TGSI_OPCODE_FRC:
 199    case TGSI_OPCODE_CEIL:
 200    case TGSI_OPCODE_CLAMP:
 201    case TGSI_OPCODE_FLR:
 202    case TGSI_OPCODE_ROUND:
 203    case TGSI_OPCODE_POW:
 204    case TGSI_OPCODE_ABS:
 205    case TGSI_OPCODE_COS:
 206    case TGSI_OPCODE_SIN:
 207    case TGSI_OPCODE_DDX:
 208    case TGSI_OPCODE_DDY:
 209    case TGSI_OPCODE_SEQ:
 210    case TGSI_OPCODE_SGT:
 211    case TGSI_OPCODE_SLE:
 212    case TGSI_OPCODE_SNE:
 213    case TGSI_OPCODE_SSG:
 214    case TGSI_OPCODE_CMP:
 215    case TGSI_OPCODE_TRUNC:
 216    case TGSI_OPCODE_NOT:
 217    case TGSI_OPCODE_AND:
 218    case TGSI_OPCODE_OR:
 219    case TGSI_OPCODE_XOR:
 220    case TGSI_OPCODE_SAD:
 221    case TGSI_OPCODE_FSEQ:
 222    case TGSI_OPCODE_FSGE:
 223    case TGSI_OPCODE_FSLT:
 224    case TGSI_OPCODE_FSNE:
 225    case TGSI_OPCODE_F2I:
 226    case TGSI_OPCODE_IDIV:
 227    case TGSI_OPCODE_IMAX:
 228    case TGSI_OPCODE_IMIN:
 229    case TGSI_OPCODE_INEG:
 230    case TGSI_OPCODE_ISGE:
 231    case TGSI_OPCODE_ISHR:
 232    case TGSI_OPCODE_ISLT:
 233    case TGSI_OPCODE_F2U:
 234    case TGSI_OPCODE_U2F:
 235    case TGSI_OPCODE_UADD:
 236    case TGSI_OPCODE_UDIV:
 237    case TGSI_OPCODE_UMAD:
 238    case TGSI_OPCODE_UMAX:
 239    case TGSI_OPCODE_UMIN:
 240    case TGSI_OPCODE_UMOD:
 241    case TGSI_OPCODE_UMUL:
 242    case TGSI_OPCODE_USEQ:
 243    case TGSI_OPCODE_USGE:
 244    case TGSI_OPCODE_USHR:
 245    case TGSI_OPCODE_USLT:
 246    case TGSI_OPCODE_USNE:
 247    case TGSI_OPCODE_IMUL_HI:
 248    case TGSI_OPCODE_UMUL_HI:
 249    case TGSI_OPCODE_DDX_FINE:
 250    case TGSI_OPCODE_DDY_FINE:
 251       /* Channel-wise operations */
 252       read_mask = write_mask;
 253       break;
 254
 255    case TGSI_OPCODE_EX2:
 256    case TGSI_OPCODE_LG2:
 257       read_mask = TGSI_WRITEMASK_X;
 258       break;
 259
 260    case TGSI_OPCODE_SCS:
 261       read_mask = write_mask & TGSI_WRITEMASK_XY ? TGSI_WRITEMASK_X : 0;
 262       break;
 263
 264    case TGSI_OPCODE_EXP:
 265    case TGSI_OPCODE_LOG:
 266       read_mask = write_mask & TGSI_WRITEMASK_XYZ ? TGSI_WRITEMASK_X : 0;
 267       break;
 268
 269    case TGSI_OPCODE_DP2A:
 270       read_mask = src_idx == 2 ? TGSI_WRITEMASK_X : TGSI_WRITEMASK_XY;
 271       break;
 272
 273    case TGSI_OPCODE_DP2:
 274       read_mask = TGSI_WRITEMASK_XY;
 275       break;
 276
 277    case TGSI_OPCODE_DP3:
 278       read_mask = TGSI_WRITEMASK_XYZ;
 279       break;
 280
 281    case TGSI_OPCODE_DP4:
 282       read_mask = TGSI_WRITEMASK_XYZW;
 283       break;
 284
 285    case TGSI_OPCODE_DPH:
 286       read_mask = src_idx == 0 ? TGSI_WRITEMASK_XYZ : TGSI_WRITEMASK_XYZW;
 287       break;
 288
 289    case TGSI_OPCODE_TEX:
 290    case TGSI_OPCODE_TXD:
 291    case TGSI_OPCODE_TXB:
 292    case TGSI_OPCODE_TXL:
 293    case TGSI_OPCODE_TXP:
 294       if (src_idx == 0) {
 295          /* Note that the SHADOW variants use the Z component too */
 296          switch (inst->Texture.Texture) {
 297          case TGSI_TEXTURE_1D:
 298             read_mask = TGSI_WRITEMASK_X;
 299             break;
 300          case TGSI_TEXTURE_SHADOW1D:
 301             read_mask = TGSI_WRITEMASK_XZ;
 302             break;
 303          case TGSI_TEXTURE_1D_ARRAY:
 304          case TGSI_TEXTURE_2D:
 305          case TGSI_TEXTURE_RECT:
 306             read_mask = TGSI_WRITEMASK_XY;
 307             break;
 308          case TGSI_TEXTURE_SHADOW1D_ARRAY:
 309          case TGSI_TEXTURE_SHADOW2D:
 310          case TGSI_TEXTURE_SHADOWRECT:
 311          case TGSI_TEXTURE_2D_ARRAY:
 312          case TGSI_TEXTURE_3D:
 313          case TGSI_TEXTURE_CUBE:
 314          case TGSI_TEXTURE_2D_MSAA:
 315             read_mask = TGSI_WRITEMASK_XYZ;
 316             break;
 317          case TGSI_TEXTURE_SHADOW2D_ARRAY:
 318          case TGSI_TEXTURE_CUBE_ARRAY:
 319          case TGSI_TEXTURE_SHADOWCUBE:
 320          case TGSI_TEXTURE_2D_ARRAY_MSAA:
 321          case TGSI_TEXTURE_SHADOWCUBE_ARRAY:
 322             read_mask = TGSI_WRITEMASK_XYZW;
 323             break;
 324          default:
 325             assert(0);
 326             read_mask = 0;
 327          }
 328
 329          if (inst->Instruction.Opcode != TGSI_OPCODE_TEX) {
 330             read_mask |= TGSI_WRITEMASK_W;
 331          }
 332       } else {
 333          /* A safe approximation */
 334          read_mask = TGSI_WRITEMASK_XYZW;
 335       }
 336       break;
 337
 338    default:
 339       /* Assume all channels are read */
 340       read_mask = TGSI_WRITEMASK_XYZW;
 341       break;
 342    }
 343
 344    usage_mask = 0;
 345    for (chan = 0; chan < 4; ++chan) {
 346       if (read_mask & (1 << chan)) {
 347          usage_mask |= 1 << tgsi_util_get_full_src_register_swizzle(src, chan);
 348       }
 349    }
 350
 351    return usage_mask;
 352 }
 353
 354 /**
 355  * Convert a tgsi_ind_register into a tgsi_src_register
 356  */
 357 struct tgsi_src_register
 358 tgsi_util_get_src_from_ind(const struct tgsi_ind_register *reg)
 359 {
 360    struct tgsi_src_register src = { 0 };
 361
 362    src.File = reg->File;
 363    src.Index = reg->Index;
 364    src.SwizzleX = reg->Swizzle;
 365    src.SwizzleY = reg->Swizzle;
 366    src.SwizzleZ = reg->Swizzle;
 367    src.SwizzleW = reg->Swizzle;
 368
 369    return src;
 370 }
 371
 372 /**
 373  * Return the dimension of the texture coordinates (layer included for array
 374  * textures), as well as the location of the shadow reference value or the
 375  * sample index.
 376  */
 377 int
 378 tgsi_util_get_texture_coord_dim(unsigned tgsi_tex)
 379 {
 380    /*
 381     * Depending on the texture target, (src0.xyzw, src1.x) is interpreted
 382     * differently:
 383     *
 384     *   (s, X, X, X, X),               for BUFFER
 385     *   (s, X, X, X, X),               for 1D
 386     *   (s, t, X, X, X),               for 2D, RECT
 387     *   (s, t, r, X, X),               for 3D, CUBE
 388     *
 389     *   (s, layer, X, X, X),           for 1D_ARRAY
 390     *   (s, t, layer, X, X),           for 2D_ARRAY
 391     *   (s, t, r, layer, X),           for CUBE_ARRAY
 392     *
 393     *   (s, X, shadow, X, X),          for SHADOW1D
 394     *   (s, t, shadow, X, X),          for SHADOW2D, SHADOWRECT
 395     *   (s, t, r, shadow, X),          for SHADOWCUBE
 396     *
 397     *   (s, layer, shadow, X, X),      for SHADOW1D_ARRAY
 398     *   (s, t, layer, shadow, X),      for SHADOW2D_ARRAY
 399     *   (s, t, r, layer, shadow),      for SHADOWCUBE_ARRAY
 400     *
 401     *   (s, t, sample, X, X),          for 2D_MSAA
 402     *   (s, t, layer, sample, X),      for 2D_ARRAY_MSAA
 403     */
 404    switch (tgsi_tex) {
 405    case TGSI_TEXTURE_BUFFER:
 406    case TGSI_TEXTURE_1D:
 407    case TGSI_TEXTURE_SHADOW1D:
 408       return 1;
 409    case TGSI_TEXTURE_2D:
 410    case TGSI_TEXTURE_RECT:
 411    case TGSI_TEXTURE_1D_ARRAY:
 412    case TGSI_TEXTURE_SHADOW2D:
 413    case TGSI_TEXTURE_SHADOWRECT:
 414    case TGSI_TEXTURE_SHADOW1D_ARRAY:
 415    case TGSI_TEXTURE_2D_MSAA:
 416       return 2;
 417    case TGSI_TEXTURE_3D:
 418    case TGSI_TEXTURE_CUBE:
 419    case TGSI_TEXTURE_2D_ARRAY:
 420    case TGSI_TEXTURE_SHADOWCUBE:
 421    case TGSI_TEXTURE_SHADOW2D_ARRAY:
 422    case TGSI_TEXTURE_2D_ARRAY_MSAA:
 423       return 3;
 424    case TGSI_TEXTURE_CUBE_ARRAY:
 425    case TGSI_TEXTURE_SHADOWCUBE_ARRAY:
 426       return 4;
 427    default:
 428       assert(!"unknown texture target");
 429       return 0;
 430    }
 431 }
 432
 433
 434 /**
 435  * Given a TGSI_TEXTURE_x target, return the src register index for the
 436  * shadow reference coordinate.
 437  */
 438 int
 439 tgsi_util_get_shadow_ref_src_index(unsigned tgsi_tex)
 440 {
 441    switch (tgsi_tex) {
 442    case TGSI_TEXTURE_SHADOW1D:
 443    case TGSI_TEXTURE_SHADOW2D:
 444    case TGSI_TEXTURE_SHADOWRECT:
 445    case TGSI_TEXTURE_SHADOW1D_ARRAY:
 446       return 2;
 447    case TGSI_TEXTURE_SHADOWCUBE:
 448    case TGSI_TEXTURE_SHADOW2D_ARRAY:
 449    case TGSI_TEXTURE_2D_MSAA:
 450    case TGSI_TEXTURE_2D_ARRAY_MSAA:
 451       return 3;
 452    case TGSI_TEXTURE_SHADOWCUBE_ARRAY:
 453       return 4;
 454    default:
 455       /* no shadow nor sample */
 456       return -1;
 457    }
 458 }
 459
 460
 461 boolean
 462 tgsi_is_shadow_target(unsigned target)
 463 {
 464    switch (target) {
 465    case TGSI_TEXTURE_SHADOW1D:
 466    case TGSI_TEXTURE_SHADOW2D:
 467    case TGSI_TEXTURE_SHADOWRECT:
 468    case TGSI_TEXTURE_SHADOW1D_ARRAY:
 469    case TGSI_TEXTURE_SHADOW2D_ARRAY:
 470    case TGSI_TEXTURE_SHADOWCUBE:
 471    case TGSI_TEXTURE_SHADOWCUBE_ARRAY:
 472       return TRUE;
 473    default:
 474       return FALSE;
 475    }
 476 }