src/gallium/drivers/cell/spu/spu_shuffle.h

   1 #ifndef SPU_SHUFFLE_H
   2 #define SPU_SHUFFLE_H
   3
   4 /*
   5  * Generate shuffle patterns with minimal fuss.
   6  *
   7  * Based on ideas from
   8  * http://www.insomniacgames.com/tech/articles/0408/files/shuffles.pdf
   9  *
  10  * A-P indicates 0-15th position in first vector
  11  * a-p indicates 0-15th position in second vector
  12  *
  13  * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
  14  * |00|01|02|03|04|05|06|07|08|09|0a|0b|0c|0d|0e|0f|
  15  * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
  16  * |          A|          B|          C|          D|
  17  * +-----+-----+-----+-----+-----+-----+-----+-----+
  18  * |    A|    B|    C|    D|    E|    F|    G|    H|
  19  * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
  20  * | A| B| C| D| E| F| G| H| I| J| K| L| M| N| O| P|
  21  * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
  22  *
  23  * x or X indicates 0xff
  24  * 8 indicates 0x80
  25  * 0 indicates 0x00
  26  *
  27  * The macros SHUFFLE4() SHUFFLE8() and SHUFFLE16() provide a const vector
  28  * unsigned char literal suitable for use with spu_shuffle().
  29  *
  30  * The macros SHUFB4() SHUFB8() and SHUFB16() provide a const qword vector
  31  * literal suitable for use with si_shufb().
  32  *
  33  *
  34  * For example :
  35  * SHUFB4(A,A,A,A)
  36  * expands to :
  37  * ((const qword){0,1,2,3,0,1,2,3,0,1,2,3,0,1,2,3})
  38  *
  39  * SHUFFLE8(A,B,a,b,C,c,8,8)
  40  * expands to :
  41  * ((const vector unsigned char){0x00,0x01,0x02,0x03,0x10,0x11,0x12,0x13,
  42  *                               0x04,0x05,0x14,0x15,0xe0,0xe0,0xe0,0xe0})
  43  *
  44  */
  45
  46 #include <spu_intrinsics.h>
  47
  48 #define SHUFFLE_PATTERN_4_A__  0x00, 0x01, 0x02, 0x03
  49 #define SHUFFLE_PATTERN_4_B__  0x04, 0x05, 0x06, 0x07
  50 #define SHUFFLE_PATTERN_4_C__  0x08, 0x09, 0x0a, 0x0b
  51 #define SHUFFLE_PATTERN_4_D__  0x0c, 0x0d, 0x0e, 0x0f
  52 #define SHUFFLE_PATTERN_4_a__  0x10, 0x11, 0x12, 0x13
  53 #define SHUFFLE_PATTERN_4_b__  0x14, 0x15, 0x16, 0x17
  54 #define SHUFFLE_PATTERN_4_c__  0x18, 0x19, 0x1a, 0x1b
  55 #define SHUFFLE_PATTERN_4_d__  0x1c, 0x1d, 0x1e, 0x1f
  56 #define SHUFFLE_PATTERN_4_X__  0xc0, 0xc0, 0xc0, 0xc0
  57 #define SHUFFLE_PATTERN_4_x__  0xc0, 0xc0, 0xc0, 0xc0
  58 #define SHUFFLE_PATTERN_4_0__  0x80, 0x80, 0x80, 0x80
  59 #define SHUFFLE_PATTERN_4_8__  0xe0, 0xe0, 0xe0, 0xe0
  60
  61 #define SHUFFLE_VECTOR_4__(A, B, C, D) \
  62    SHUFFLE_PATTERN_4_##A##__, \
  63    SHUFFLE_PATTERN_4_##B##__, \
  64    SHUFFLE_PATTERN_4_##C##__, \
  65    SHUFFLE_PATTERN_4_##D##__
  66
  67 #define SHUFFLE4(A, B, C, D) \
  68    ((const vector unsigned char){ \
  69       SHUFFLE_VECTOR_4__(A, B, C, D) \
  70    })
  71
  72 #define SHUFB4(A, B, C, D) \
  73    ((const qword){ \
  74       SHUFFLE_VECTOR_4__(A, B, C, D) \
  75    })
  76
  77
  78 #define SHUFFLE_PATTERN_8_A__  0x00, 0x01
  79 #define SHUFFLE_PATTERN_8_B__  0x02, 0x03
  80 #define SHUFFLE_PATTERN_8_C__  0x04, 0x05
  81 #define SHUFFLE_PATTERN_8_D__  0x06, 0x07
  82 #define SHUFFLE_PATTERN_8_E__  0x08, 0x09
  83 #define SHUFFLE_PATTERN_8_F__  0x0a, 0x0b
  84 #define SHUFFLE_PATTERN_8_G__  0x0c, 0x0d
  85 #define SHUFFLE_PATTERN_8_H__  0x0e, 0x0f
  86 #define SHUFFLE_PATTERN_8_a__  0x10, 0x11
  87 #define SHUFFLE_PATTERN_8_b__  0x12, 0x13
  88 #define SHUFFLE_PATTERN_8_c__  0x14, 0x15
  89 #define SHUFFLE_PATTERN_8_d__  0x16, 0x17
  90 #define SHUFFLE_PATTERN_8_e__  0x18, 0x19
  91 #define SHUFFLE_PATTERN_8_f__  0x1a, 0x1b
  92 #define SHUFFLE_PATTERN_8_g__  0x1c, 0x1d
  93 #define SHUFFLE_PATTERN_8_h__  0x1e, 0x1f
  94 #define SHUFFLE_PATTERN_8_X__  0xc0, 0xc0
  95 #define SHUFFLE_PATTERN_8_x__  0xc0, 0xc0
  96 #define SHUFFLE_PATTERN_8_0__  0x80, 0x80
  97 #define SHUFFLE_PATTERN_8_8__  0xe0, 0xe0
  98
  99
 100 #define SHUFFLE_VECTOR_8__(A, B, C, D, E, F, G, H) \
 101    SHUFFLE_PATTERN_8_##A##__, \
 102    SHUFFLE_PATTERN_8_##B##__, \
 103    SHUFFLE_PATTERN_8_##C##__, \
 104    SHUFFLE_PATTERN_8_##D##__, \
 105    SHUFFLE_PATTERN_8_##E##__, \
 106    SHUFFLE_PATTERN_8_##F##__, \
 107    SHUFFLE_PATTERN_8_##G##__, \
 108    SHUFFLE_PATTERN_8_##H##__
 109
 110 #define SHUFFLE8(A, B, C, D, E, F, G, H) \
 111    ((const vector unsigned char){ \
 112       SHUFFLE_VECTOR_8__(A, B, C, D, E, F, G, H) \
 113    })
 114
 115 #define SHUFB8(A, B, C, D, E, F, G, H) \
 116    ((const qword){ \
 117       SHUFFLE_VECTOR_8__(A, B, C, D, E, F, G, H) \
 118    })
 119
 120
 121 #define SHUFFLE_PATTERN_16_A__  0x00
 122 #define SHUFFLE_PATTERN_16_B__  0x01
 123 #define SHUFFLE_PATTERN_16_C__  0x02
 124 #define SHUFFLE_PATTERN_16_D__  0x03
 125 #define SHUFFLE_PATTERN_16_E__  0x04
 126 #define SHUFFLE_PATTERN_16_F__  0x05
 127 #define SHUFFLE_PATTERN_16_G__  0x06
 128 #define SHUFFLE_PATTERN_16_H__  0x07
 129 #define SHUFFLE_PATTERN_16_I__  0x08
 130 #define SHUFFLE_PATTERN_16_J__  0x09
 131 #define SHUFFLE_PATTERN_16_K__  0x0a
 132 #define SHUFFLE_PATTERN_16_L__  0x0b
 133 #define SHUFFLE_PATTERN_16_M__  0x0c
 134 #define SHUFFLE_PATTERN_16_N__  0x0d
 135 #define SHUFFLE_PATTERN_16_O__  0x0e
 136 #define SHUFFLE_PATTERN_16_P__  0x0f
 137 #define SHUFFLE_PATTERN_16_a__  0x10
 138 #define SHUFFLE_PATTERN_16_b__  0x11
 139 #define SHUFFLE_PATTERN_16_c__  0x12
 140 #define SHUFFLE_PATTERN_16_d__  0x13
 141 #define SHUFFLE_PATTERN_16_e__  0x14
 142 #define SHUFFLE_PATTERN_16_f__  0x15
 143 #define SHUFFLE_PATTERN_16_g__  0x16
 144 #define SHUFFLE_PATTERN_16_h__  0x17
 145 #define SHUFFLE_PATTERN_16_i__  0x18
 146 #define SHUFFLE_PATTERN_16_j__  0x19
 147 #define SHUFFLE_PATTERN_16_k__  0x1a
 148 #define SHUFFLE_PATTERN_16_l__  0x1b
 149 #define SHUFFLE_PATTERN_16_m__  0x1c
 150 #define SHUFFLE_PATTERN_16_n__  0x1d
 151 #define SHUFFLE_PATTERN_16_o__  0x1e
 152 #define SHUFFLE_PATTERN_16_p__  0x1f
 153 #define SHUFFLE_PATTERN_16_X__  0xc0
 154 #define SHUFFLE_PATTERN_16_x__  0xc0
 155 #define SHUFFLE_PATTERN_16_0__  0x80
 156 #define SHUFFLE_PATTERN_16_8__  0xe0
 157
 158 #define SHUFFLE_VECTOR_16__(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) \
 159    SHUFFLE_PATTERN_16_##A##__, \
 160    SHUFFLE_PATTERN_16_##B##__, \
 161    SHUFFLE_PATTERN_16_##C##__, \
 162    SHUFFLE_PATTERN_16_##D##__, \
 163    SHUFFLE_PATTERN_16_##E##__, \
 164    SHUFFLE_PATTERN_16_##F##__, \
 165    SHUFFLE_PATTERN_16_##G##__, \
 166    SHUFFLE_PATTERN_16_##H##__, \
 167    SHUFFLE_PATTERN_16_##I##__, \
 168    SHUFFLE_PATTERN_16_##J##__, \
 169    SHUFFLE_PATTERN_16_##K##__, \
 170    SHUFFLE_PATTERN_16_##L##__, \
 171    SHUFFLE_PATTERN_16_##M##__, \
 172    SHUFFLE_PATTERN_16_##N##__, \
 173    SHUFFLE_PATTERN_16_##O##__, \
 174    SHUFFLE_PATTERN_16_##P##__
 175
 176 #define SHUFFLE16(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) \
 177    ((const vector unsigned char){ \
 178       SHUFFLE_VECTOR_16__(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) \
 179    })
 180
 181 #define SHUFB16(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) \
 182    ((const qword){ \
 183       SHUFFLE_VECTOR_16__(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) \
 184    })
 185
 186 #endif