src/mesa/drivers/dri/r300/compiler/radeon_code.h

   1 /*
   2  * Copyright 2009 Nicolai Hähnle <nhaehnle@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 #ifndef RADEON_CODE_H
  24 #define RADEON_CODE_H
  25
  26 #include <stdint.h>
  27
  28 #define R300_PFS_MAX_ALU_INST     64
  29 #define R300_PFS_MAX_TEX_INST     32
  30 #define R300_PFS_MAX_TEX_INDIRECT 4
  31 #define R300_PFS_NUM_TEMP_REGS    32
  32 #define R300_PFS_NUM_CONST_REGS   32
  33
  34 #define R400_PFS_MAX_ALU_INST     512
  35 #define R400_PFS_MAX_TEX_INST     512
  36
  37 #define R500_PFS_MAX_INST         512
  38 #define R500_PFS_NUM_TEMP_REGS    128
  39 #define R500_PFS_NUM_CONST_REGS   256
  40 #define R500_PFS_MAX_BRANCH_DEPTH_FULL 32
  41 #define R500_PFS_MAX_BRANCH_DEPTH_PARTIAL 4
  42
  43
  44 #define STATE_R300_WINDOW_DIMENSION (STATE_INTERNAL_DRIVER+0)
  45
  46 enum {
  47         /**
  48          * External constants are constants whose meaning is unknown to this
  49          * compiler. For example, a Mesa gl_program's constants are turned
  50          * into external constants.
  51          */
  52         RC_CONSTANT_EXTERNAL = 0,
  53
  54         RC_CONSTANT_IMMEDIATE,
  55
  56         /**
  57          * Constant referring to state that is known by this compiler,
  58          * see RC_STATE_xxx, i.e. *not* arbitrary Mesa (or other) state.
  59          */
  60         RC_CONSTANT_STATE
  61 };
  62
  63 enum {
  64         RC_STATE_SHADOW_AMBIENT = 0,
  65
  66         RC_STATE_R300_WINDOW_DIMENSION,
  67         RC_STATE_R300_TEXRECT_FACTOR,
  68         RC_STATE_R300_TEXSCALE_FACTOR,
  69         RC_STATE_R300_VIEWPORT_SCALE,
  70         RC_STATE_R300_VIEWPORT_OFFSET
  71 };
  72
  73 struct rc_constant {
  74         unsigned Type:2; /**< RC_CONSTANT_xxx */
  75         unsigned Size:3;
  76
  77         union {
  78                 unsigned External;
  79                 float Immediate[4];
  80                 unsigned State[2];
  81         } u;
  82 };
  83
  84 struct rc_constant_list {
  85         struct rc_constant * Constants;
  86         unsigned Count;
  87
  88         unsigned _Reserved;
  89 };
  90
  91 void rc_constants_init(struct rc_constant_list * c);
  92 void rc_constants_copy(struct rc_constant_list * dst, struct rc_constant_list * src);
  93 void rc_constants_destroy(struct rc_constant_list * c);
  94 unsigned rc_constants_add(struct rc_constant_list * c, struct rc_constant * constant);
  95 unsigned rc_constants_add_state(struct rc_constant_list * c, unsigned state1, unsigned state2);
  96 unsigned rc_constants_add_immediate_vec4(struct rc_constant_list * c, const float * data);
  97 unsigned rc_constants_add_immediate_scalar(struct rc_constant_list * c, float data, unsigned * swizzle);
  98 void rc_constants_print(struct rc_constant_list * c);
  99
 100 /**
 101  * Compare functions.
 102  *
 103  * \note By design, RC_COMPARE_FUNC_xxx + GL_NEVER gives you
 104  * the correct GL compare function.
 105  */
 106 typedef enum {
 107         RC_COMPARE_FUNC_NEVER = 0,
 108         RC_COMPARE_FUNC_LESS,
 109         RC_COMPARE_FUNC_EQUAL,
 110         RC_COMPARE_FUNC_LEQUAL,
 111         RC_COMPARE_FUNC_GREATER,
 112         RC_COMPARE_FUNC_NOTEQUAL,
 113         RC_COMPARE_FUNC_GEQUAL,
 114         RC_COMPARE_FUNC_ALWAYS
 115 } rc_compare_func;
 116
 117 /**
 118  * Coordinate wrapping modes.
 119  *
 120  * These are not quite the same as their GL counterparts yet.
 121  */
 122 typedef enum {
 123         RC_WRAP_NONE = 0,
 124         RC_WRAP_REPEAT,
 125         RC_WRAP_MIRRORED_REPEAT,
 126         RC_WRAP_MIRRORED_CLAMP
 127 } rc_wrap_mode;
 128
 129 /**
 130  * Stores state that influences the compilation of a fragment program.
 131  */
 132 struct r300_fragment_program_external_state {
 133         struct {
 134                 /**
 135                  * This field contains swizzle for some lowering passes
 136                  * (shadow comparison, unorm->snorm conversion)
 137                  */
 138                 unsigned texture_swizzle:12;
 139
 140                 /**
 141                  * If the sampler is used as a shadow sampler,
 142                  * this field specifies the compare function.
 143                  *
 144                  * Otherwise, this field is \ref RC_COMPARE_FUNC_NEVER (aka 0).
 145                  * \sa rc_compare_func
 146                  */
 147                 unsigned texture_compare_func : 3;
 148
 149                 /**
 150                  * No matter what the sampler type is,
 151                  * this field turns it into a shadow sampler.
 152                  */
 153                 unsigned compare_mode_enabled : 1;
 154
 155                 /**
 156                  * If the sampler will receive non-normalized coords,
 157                  * this field is set. The scaling factor is given by
 158                  * RC_STATE_R300_TEXRECT_FACTOR.
 159                  */
 160                 unsigned non_normalized_coords : 1;
 161
 162                 /**
 163                  * This field specifies wrapping modes for the sampler.
 164                  *
 165                  * If this field is \ref RC_WRAP_NONE (aka 0), no wrapping maths
 166                  * will be performed on the coordinates.
 167                  */
 168                 unsigned wrap_mode : 3;
 169
 170                 /**
 171                  * The coords are scaled after applying the wrap mode emulation
 172                  * and right before texture fetch. The scaling factor is given by
 173                  * RC_STATE_R300_TEXSCALE_FACTOR. */
 174                 unsigned clamp_and_scale_before_fetch : 1;
 175
 176                 /**
 177                  * Fetch RGTC1_SNORM or LATC1_SNORM as UNORM and convert UNORM -> SNORM
 178                  * in the shader.
 179                  */
 180                 unsigned convert_unorm_to_snorm:1;
 181         } unit[16];
 182
 183         unsigned frag_clamp:1;
 184 };
 185
 186
 187
 188 struct r300_fragment_program_node {
 189         int tex_offset; /**< first tex instruction */
 190         int tex_end; /**< last tex instruction, relative to tex_offset */
 191         int alu_offset; /**< first ALU instruction */
 192         int alu_end; /**< last ALU instruction, relative to alu_offset */
 193         int flags;
 194 };
 195
 196 /**
 197  * Stores an R300 fragment program in its compiled-to-hardware form.
 198  */
 199 struct r300_fragment_program_code {
 200         struct {
 201                 unsigned int length; /**< total # of texture instructions used */
 202                 uint32_t inst[R400_PFS_MAX_TEX_INST];
 203         } tex;
 204
 205         struct {
 206                 unsigned int length; /**< total # of ALU instructions used */
 207                 struct {
 208                         uint32_t rgb_inst;
 209                         uint32_t rgb_addr;
 210                         uint32_t alpha_inst;
 211                         uint32_t alpha_addr;
 212                         uint32_t r400_ext_addr;
 213                 } inst[R400_PFS_MAX_ALU_INST];
 214         } alu;
 215
 216         uint32_t config; /* US_CONFIG */
 217         uint32_t pixsize; /* US_PIXSIZE */
 218         uint32_t code_offset; /* US_CODE_OFFSET */
 219         uint32_t r400_code_offset_ext; /* US_CODE_EXT */
 220         uint32_t code_addr[4]; /* US_CODE_ADDR */
 221         /*US_CODE_BANK.R390_MODE: Enables 512 instructions and 64 temporaries
 222          * for r400 cards */
 223         unsigned int r390_mode:1;
 224 };
 225
 226
 227 struct r500_fragment_program_code {
 228         struct {
 229                 uint32_t inst0;
 230                 uint32_t inst1;
 231                 uint32_t inst2;
 232                 uint32_t inst3;
 233                 uint32_t inst4;
 234                 uint32_t inst5;
 235         } inst[R500_PFS_MAX_INST];
 236
 237         int inst_end; /* Number of instructions - 1; also, last instruction to be executed */
 238
 239         int max_temp_idx;
 240
 241         uint32_t us_fc_ctrl;
 242
 243         uint32_t int_constants[32];
 244         uint32_t int_constant_count;
 245 };
 246
 247 struct rX00_fragment_program_code {
 248         union {
 249                 struct r300_fragment_program_code r300;
 250                 struct r500_fragment_program_code r500;
 251         } code;
 252
 253         unsigned writes_depth:1;
 254
 255         struct rc_constant_list constants;
 256         unsigned *constants_remap_table;
 257 };
 258
 259
 260 #define R300_VS_MAX_ALU         256
 261 #define R300_VS_MAX_ALU_DWORDS  (R300_VS_MAX_ALU * 4)
 262 #define R500_VS_MAX_ALU         1024
 263 #define R500_VS_MAX_ALU_DWORDS  (R500_VS_MAX_ALU * 4)
 264 #define R300_VS_MAX_TEMPS       32
 265 /* This is the max for all chipsets (r300-r500) */
 266 #define R300_VS_MAX_FC_OPS 16
 267 /* The r500 maximum depth is not just for loops, but any combination of loops
 268  * and subroutine jumps. */
 269 #define R500_VS_MAX_FC_DEPTH 8
 270 #define R300_VS_MAX_LOOP_DEPTH 1
 271
 272 #define VSF_MAX_INPUTS 32
 273 #define VSF_MAX_OUTPUTS 32
 274
 275 struct r300_vertex_program_code {
 276         int length;
 277         union {
 278                 uint32_t d[R500_VS_MAX_ALU_DWORDS];
 279                 float f[R500_VS_MAX_ALU_DWORDS];
 280         } body;
 281
 282         int pos_end;
 283         int num_temporaries;    /* Number of temp vars used by program */
 284         int inputs[VSF_MAX_INPUTS];
 285         int outputs[VSF_MAX_OUTPUTS];
 286
 287         struct rc_constant_list constants;
 288         unsigned *constants_remap_table;
 289
 290         uint32_t InputsRead;
 291         uint32_t OutputsWritten;
 292
 293         unsigned int num_fc_ops;
 294         uint32_t fc_ops;
 295         union {
 296                 uint32_t r300[R300_VS_MAX_FC_OPS];
 297                 struct {
 298                         uint32_t lw;
 299                         uint32_t uw;
 300                 } r500[R300_VS_MAX_FC_OPS];
 301         } fc_op_addrs;
 302         int32_t fc_loop_index[R300_VS_MAX_FC_OPS];
 303 };
 304
 305 #endif /* RADEON_CODE_H */
 306