src/mesa/pipe/tgsi/util/tgsi_util.c

   1 #include "pipe/p_util.h"
   2 #include "pipe/p_shader_tokens.h"
   3 #include "tgsi_parse.h"
   4 #include "tgsi_build.h"
   5 #include "tgsi_util.h"
   6
   7 union pointer_hack
   8 {
   9    void *pointer;
  10    unsigned long long uint64;
  11 };
  12
  13 void *
  14 tgsi_align_128bit(
  15    void *unaligned )
  16 {
  17    union pointer_hack ph;
  18
  19    ph.uint64 = 0;
  20    ph.pointer = unaligned;
  21    ph.uint64 = (ph.uint64 + 15) & ~15;
  22    return ph.pointer;
  23 }
  24
  25 unsigned
  26 tgsi_util_get_src_register_swizzle(
  27    const struct tgsi_src_register *reg,
  28    unsigned component )
  29 {
  30    switch( component ) {
  31    case 0:
  32       return reg->SwizzleX;
  33    case 1:
  34       return reg->SwizzleY;
  35    case 2:
  36       return reg->SwizzleZ;
  37    case 3:
  38       return reg->SwizzleW;
  39    default:
  40       assert( 0 );
  41    }
  42    return 0;
  43 }
  44
  45 unsigned
  46 tgsi_util_get_src_register_extswizzle(
  47    const struct tgsi_src_register_ext_swz *reg,
  48    unsigned component )
  49 {
  50    switch( component ) {
  51    case 0:
  52       return reg->ExtSwizzleX;
  53    case 1:
  54       return reg->ExtSwizzleY;
  55    case 2:
  56       return reg->ExtSwizzleZ;
  57    case 3:
  58       return reg->ExtSwizzleW;
  59    default:
  60       assert( 0 );
  61    }
  62    return 0;
  63 }
  64
  65 unsigned
  66 tgsi_util_get_full_src_register_extswizzle(
  67    const struct tgsi_full_src_register  *reg,
  68    unsigned component )
  69 {
  70    unsigned swizzle;
  71
  72    /*
  73     * First, calculate  the   extended swizzle for a given channel. This will give
  74     * us either a channel index into the simple swizzle or  a constant 1 or   0.
  75     */
  76    swizzle = tgsi_util_get_src_register_extswizzle(
  77       &reg->SrcRegisterExtSwz,
  78       component );
  79
  80    assert (TGSI_SWIZZLE_X == TGSI_EXTSWIZZLE_X);
  81    assert (TGSI_SWIZZLE_Y == TGSI_EXTSWIZZLE_Y);
  82    assert (TGSI_SWIZZLE_Z == TGSI_EXTSWIZZLE_Z);
  83    assert (TGSI_SWIZZLE_W == TGSI_EXTSWIZZLE_W);
  84    assert (TGSI_EXTSWIZZLE_ZERO > TGSI_SWIZZLE_W);
  85    assert (TGSI_EXTSWIZZLE_ONE > TGSI_SWIZZLE_W);
  86
  87    /*
  88     * Second, calculate the simple  swizzle  for   the   unswizzled channel index.
  89     * Leave the constants intact, they are   not   affected by the   simple swizzle.
  90     */
  91    if( swizzle <= TGSI_SWIZZLE_W ) {
  92       swizzle = tgsi_util_get_src_register_swizzle(
  93          &reg->SrcRegister,
  94          component );
  95    }
  96
  97    return swizzle;
  98 }
  99
 100 void
 101 tgsi_util_set_src_register_swizzle(
 102    struct tgsi_src_register *reg,
 103    unsigned swizzle,
 104    unsigned component )
 105 {
 106    switch( component ) {
 107    case 0:
 108       reg->SwizzleX = swizzle;
 109       break;
 110    case 1:
 111       reg->SwizzleY = swizzle;
 112       break;
 113    case 2:
 114       reg->SwizzleZ = swizzle;
 115       break;
 116    case 3:
 117       reg->SwizzleW = swizzle;
 118       break;
 119    default:
 120       assert( 0 );
 121    }
 122 }
 123
 124 void
 125 tgsi_util_set_src_register_extswizzle(
 126    struct tgsi_src_register_ext_swz *reg,
 127    unsigned swizzle,
 128    unsigned component )
 129 {
 130    switch( component ) {
 131    case 0:
 132       reg->ExtSwizzleX = swizzle;
 133       break;
 134    case 1:
 135       reg->ExtSwizzleY = swizzle;
 136       break;
 137    case 2:
 138       reg->ExtSwizzleZ = swizzle;
 139       break;
 140    case 3:
 141       reg->ExtSwizzleW = swizzle;
 142       break;
 143    default:
 144       assert( 0 );
 145    }
 146 }
 147
 148 unsigned
 149 tgsi_util_get_src_register_extnegate(
 150    const  struct tgsi_src_register_ext_swz *reg,
 151    unsigned component )
 152 {
 153    switch( component ) {
 154    case 0:
 155       return reg->NegateX;
 156    case 1:
 157       return reg->NegateY;
 158    case 2:
 159       return reg->NegateZ;
 160    case 3:
 161       return reg->NegateW;
 162    default:
 163       assert( 0 );
 164    }
 165    return 0;
 166 }
 167
 168 void
 169 tgsi_util_set_src_register_extnegate(
 170    struct tgsi_src_register_ext_swz *reg,
 171    unsigned negate,
 172    unsigned component )
 173 {
 174    switch( component ) {
 175    case 0:
 176       reg->NegateX = negate;
 177       break;
 178    case 1:
 179       reg->NegateY = negate;
 180       break;
 181    case 2:
 182       reg->NegateZ = negate;
 183       break;
 184    case 3:
 185       reg->NegateW = negate;
 186       break;
 187    default:
 188       assert( 0 );
 189    }
 190 }
 191
 192 unsigned
 193 tgsi_util_get_full_src_register_sign_mode(
 194    const struct  tgsi_full_src_register *reg,
 195    unsigned component )
 196 {
 197    unsigned sign_mode;
 198
 199    if( reg->SrcRegisterExtMod.Absolute ) {
 200       /* Consider only the post-abs negation. */
 201
 202       if( reg->SrcRegisterExtMod.Negate ) {
 203          sign_mode = TGSI_UTIL_SIGN_SET;
 204       }
 205       else {
 206          sign_mode = TGSI_UTIL_SIGN_CLEAR;
 207       }
 208    }
 209    else {
 210       /* Accumulate the three negations. */
 211
 212       unsigned negate;
 213
 214       negate = reg->SrcRegister.Negate;
 215       if( tgsi_util_get_src_register_extnegate( &reg->SrcRegisterExtSwz, component ) ) {
 216          negate = !negate;
 217       }
 218       if( reg->SrcRegisterExtMod.Negate ) {
 219          negate = !negate;
 220       }
 221
 222       if( negate ) {
 223          sign_mode = TGSI_UTIL_SIGN_TOGGLE;
 224       }
 225       else {
 226          sign_mode = TGSI_UTIL_SIGN_KEEP;
 227       }
 228    }
 229
 230    return sign_mode;
 231 }
 232
 233 void
 234 tgsi_util_set_full_src_register_sign_mode(
 235    struct tgsi_full_src_register *reg,
 236    unsigned sign_mode )
 237 {
 238    reg->SrcRegisterExtSwz.NegateX = 0;
 239    reg->SrcRegisterExtSwz.NegateY = 0;
 240    reg->SrcRegisterExtSwz.NegateZ = 0;
 241    reg->SrcRegisterExtSwz.NegateW = 0;
 242
 243    switch (sign_mode)
 244    {
 245    case TGSI_UTIL_SIGN_CLEAR:
 246       reg->SrcRegister.Negate = 0;
 247       reg->SrcRegisterExtMod.Absolute = 1;
 248       reg->SrcRegisterExtMod.Negate = 0;
 249       break;
 250
 251    case TGSI_UTIL_SIGN_SET:
 252       reg->SrcRegister.Negate = 0;
 253       reg->SrcRegisterExtMod.Absolute = 1;
 254       reg->SrcRegisterExtMod.Negate = 1;
 255       break;
 256
 257    case TGSI_UTIL_SIGN_TOGGLE:
 258       reg->SrcRegister.Negate = 1;
 259       reg->SrcRegisterExtMod.Absolute = 0;
 260       reg->SrcRegisterExtMod.Negate = 0;
 261       break;
 262
 263    case TGSI_UTIL_SIGN_KEEP:
 264       reg->SrcRegister.Negate = 0;
 265       reg->SrcRegisterExtMod.Absolute = 0;
 266       reg->SrcRegisterExtMod.Negate = 0;
 267       break;
 268
 269    default:
 270       assert( 0 );
 271    }
 272 }
 273