src/mesa/program/prog_instruction.h

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2008  Brian Paul   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 "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /**
  27  * \file prog_instruction.h
  28  *
  29  * Vertex/fragment program instruction datatypes and constants.
  30  *
  31  * \author Brian Paul
  32  * \author Keith Whitwell
  33  * \author Ian Romanick <idr@us.ibm.com>
  34  */
  35
  36
  37 #ifndef PROG_INSTRUCTION_H
  38 #define PROG_INSTRUCTION_H
  39
  40
  41 #include "main/glheader.h"
  42
  43
  44 /**
  45  * Swizzle indexes.
  46  * Do not change!
  47  */
  48 /*@{*/
  49 #define SWIZZLE_X    0
  50 #define SWIZZLE_Y    1
  51 #define SWIZZLE_Z    2
  52 #define SWIZZLE_W    3
  53 #define SWIZZLE_ZERO 4   /**< For SWZ instruction only */
  54 #define SWIZZLE_ONE  5   /**< For SWZ instruction only */
  55 #define SWIZZLE_NIL  7   /**< used during shader code gen (undefined value) */
  56 /*@}*/
  57
  58 #define MAKE_SWIZZLE4(a,b,c,d) (((a)<<0) | ((b)<<3) | ((c)<<6) | ((d)<<9))
  59 #define SWIZZLE_NOOP           MAKE_SWIZZLE4(0,1,2,3)
  60 #define GET_SWZ(swz, idx)      (((swz) >> ((idx)*3)) & 0x7)
  61 #define GET_BIT(msk, idx)      (((msk) >> (idx)) & 0x1)
  62
  63 #define SWIZZLE_XYZW MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W)
  64 #define SWIZZLE_XXXX MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X)
  65 #define SWIZZLE_YYYY MAKE_SWIZZLE4(SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y)
  66 #define SWIZZLE_ZZZZ MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z)
  67 #define SWIZZLE_WWWW MAKE_SWIZZLE4(SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
  68
  69
  70 /**
  71  * Writemask values, 1 bit per component.
  72  */
  73 /*@{*/
  74 #define WRITEMASK_X     0x1
  75 #define WRITEMASK_Y     0x2
  76 #define WRITEMASK_XY    0x3
  77 #define WRITEMASK_Z     0x4
  78 #define WRITEMASK_XZ    0x5
  79 #define WRITEMASK_YZ    0x6
  80 #define WRITEMASK_XYZ   0x7
  81 #define WRITEMASK_W     0x8
  82 #define WRITEMASK_XW    0x9
  83 #define WRITEMASK_YW    0xa
  84 #define WRITEMASK_XYW   0xb
  85 #define WRITEMASK_ZW    0xc
  86 #define WRITEMASK_XZW   0xd
  87 #define WRITEMASK_YZW   0xe
  88 #define WRITEMASK_XYZW  0xf
  89 /*@}*/
  90
  91
  92 /**
  93  * Condition codes
  94  */
  95 /*@{*/
  96 #define COND_GT  1  /**< greater than zero */
  97 #define COND_EQ  2  /**< equal to zero */
  98 #define COND_LT  3  /**< less than zero */
  99 #define COND_UN  4  /**< unordered (NaN) */
 100 #define COND_GE  5  /**< greater than or equal to zero */
 101 #define COND_LE  6  /**< less than or equal to zero */
 102 #define COND_NE  7  /**< not equal to zero */
 103 #define COND_TR  8  /**< always true */
 104 #define COND_FL  9  /**< always false */
 105 /*@}*/
 106
 107
 108 /**
 109  * Instruction precision for GL_NV_fragment_program
 110  */
 111 /*@{*/
 112 #define FLOAT32  0x1
 113 #define FLOAT16  0x2
 114 #define FIXED12  0x4
 115 /*@}*/
 116
 117
 118 /**
 119  * Saturation modes when storing values.
 120  */
 121 /*@{*/
 122 #define SATURATE_OFF            0
 123 #define SATURATE_ZERO_ONE       1
 124 /*@}*/
 125
 126
 127 /**
 128  * Per-component negation masks
 129  */
 130 /*@{*/
 131 #define NEGATE_X    0x1
 132 #define NEGATE_Y    0x2
 133 #define NEGATE_Z    0x4
 134 #define NEGATE_W    0x8
 135 #define NEGATE_XYZ  0x7
 136 #define NEGATE_XYZW 0xf
 137 #define NEGATE_NONE 0x0
 138 /*@}*/
 139
 140
 141 /**
 142  * Program instruction opcodes for vertex, fragment and geometry programs.
 143  */
 144 typedef enum prog_opcode {
 145                      /* ARB_vp   ARB_fp   NV_vp   NV_fp     GLSL */
 146                      /*------------------------------------------*/
 147    OPCODE_NOP = 0,   /*                                      X   */
 148    OPCODE_ABS,       /*   X        X       1.1               X   */
 149    OPCODE_ADD,       /*   X        X       X       X         X   */
 150    OPCODE_ARL,       /*   X                X                 X   */
 151    OPCODE_BGNLOOP,   /*                                     opt  */
 152    OPCODE_BGNSUB,    /*                                     opt  */
 153    OPCODE_BRK,       /*                    2                opt  */
 154    OPCODE_CAL,       /*                    2       2        opt  */
 155    OPCODE_CMP,       /*            X                         X   */
 156    OPCODE_CONT,      /*                                     opt  */
 157    OPCODE_COS,       /*            X       2       X         X   */
 158    OPCODE_DDX,       /*                            X         X   */
 159    OPCODE_DDY,       /*                            X         X   */
 160    OPCODE_DP2,       /*                            2         X   */
 161    OPCODE_DP3,       /*   X        X       X       X         X   */
 162    OPCODE_DP4,       /*   X        X       X       X         X   */
 163    OPCODE_DPH,       /*   X        X       1.1                   */
 164    OPCODE_DST,       /*   X        X       X       X             */
 165    OPCODE_ELSE,      /*                                     opt  */
 166    OPCODE_END,       /*   X        X       X       X        opt  */
 167    OPCODE_ENDIF,     /*                                     opt  */
 168    OPCODE_ENDLOOP,   /*                                     opt  */
 169    OPCODE_ENDSUB,    /*                                     opt  */
 170    OPCODE_EX2,       /*   X        X       2       X         X   */
 171    OPCODE_EXP,       /*   X                X                     */
 172    OPCODE_FLR,       /*   X        X       2       X         X   */
 173    OPCODE_FRC,       /*   X        X       2       X         X   */
 174    OPCODE_IF,        /*                                     opt  */
 175    OPCODE_KIL,       /*            X                         X   */
 176    OPCODE_KIL_NV,    /*                            X         X   */
 177    OPCODE_LG2,       /*   X        X       2       X         X   */
 178    OPCODE_LIT,       /*   X        X       X       X             */
 179    OPCODE_LOG,       /*   X                X                     */
 180    OPCODE_LRP,       /*            X               X             */
 181    OPCODE_MAD,       /*   X        X       X       X         X   */
 182    OPCODE_MAX,       /*   X        X       X       X         X   */
 183    OPCODE_MIN,       /*   X        X       X       X         X   */
 184    OPCODE_MOV,       /*   X        X       X       X         X   */
 185    OPCODE_MUL,       /*   X        X       X       X         X   */
 186    OPCODE_NOISE1,    /*                                      X   */
 187    OPCODE_NOISE2,    /*                                      X   */
 188    OPCODE_NOISE3,    /*                                      X   */
 189    OPCODE_NOISE4,    /*                                      X   */
 190    OPCODE_PK2H,      /*                            X             */
 191    OPCODE_PK2US,     /*                            X             */
 192    OPCODE_PK4B,      /*                            X             */
 193    OPCODE_PK4UB,     /*                            X             */
 194    OPCODE_POW,       /*   X        X               X         X   */
 195    OPCODE_RCP,       /*   X        X       X       X         X   */
 196    OPCODE_RET,       /*                    2       2        opt  */
 197    OPCODE_RFL,       /*                            X             */
 198    OPCODE_RSQ,       /*   X        X       X       X         X   */
 199    OPCODE_SCS,       /*            X                         X   */
 200    OPCODE_SEQ,       /*                    2       X         X   */
 201    OPCODE_SFL,       /*                    2       X             */
 202    OPCODE_SGE,       /*   X        X       X       X         X   */
 203    OPCODE_SGT,       /*                    2       X         X   */
 204    OPCODE_SIN,       /*            X       2       X         X   */
 205    OPCODE_SLE,       /*                    2       X         X   */
 206    OPCODE_SLT,       /*   X        X       X       X         X   */
 207    OPCODE_SNE,       /*                    2       X         X   */
 208    OPCODE_SSG,       /*                    2                 X   */
 209    OPCODE_STR,       /*                    2       X             */
 210    OPCODE_SUB,       /*   X        X       1.1     X         X   */
 211    OPCODE_SWZ,       /*   X        X                         X   */
 212    OPCODE_TEX,       /*            X       3       X         X   */
 213    OPCODE_TXB,       /*            X       3                 X   */
 214    OPCODE_TXD,       /*                            X         X   */
 215    OPCODE_TXL,       /*                    3       2         X   */
 216    OPCODE_TXP,       /*            X                         X   */
 217    OPCODE_TXP_NV,    /*                    3       X             */
 218    OPCODE_TRUNC,     /*                                      X   */
 219    OPCODE_UP2H,      /*                            X             */
 220    OPCODE_UP2US,     /*                            X             */
 221    OPCODE_UP4B,      /*                            X             */
 222    OPCODE_UP4UB,     /*                            X             */
 223    OPCODE_X2D,       /*                            X             */
 224    OPCODE_XPD,       /*   X        X                             */
 225    MAX_OPCODE
 226 } gl_inst_opcode;
 227
 228
 229 /**
 230  * Number of bits for the src/dst register Index field.
 231  * This limits the size of temp/uniform register files.
 232  */
 233 #define INST_INDEX_BITS 12
 234
 235
 236 /**
 237  * Instruction source register.
 238  */
 239 struct prog_src_register
 240 {
 241    GLuint File:4;       /**< One of the PROGRAM_* register file values. */
 242    GLint Index:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit.
 243                                      * May be negative for relative addressing.
 244                                      */
 245    GLuint Swizzle:12;
 246    GLuint RelAddr:1;
 247
 248    /** Take the component-wise absolute value */
 249    GLuint Abs:1;
 250
 251    /**
 252     * Post-Abs negation.
 253     * This will either be NEGATE_NONE or NEGATE_XYZW, except for the SWZ
 254     * instruction which allows per-component negation.
 255     */
 256    GLuint Negate:4;
 257
 258    /**
 259     * Is the register two-dimensional.
 260     * Two dimensional registers are of the
 261     * REGISTER[index][index2] format.
 262     * They are used by the geometry shaders where
 263     * the first index is the index within an array
 264     * and the second index is the semantic of the
 265     * array, e.g. gl_PositionIn[index] would become
 266     * INPUT[index][gl_PositionIn]
 267     */
 268    GLuint HasIndex2:1;
 269    GLuint RelAddr2:1;
 270    GLint Index2:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit.
 271                                        * May be negative for relative
 272                                        * addressing. */
 273 };
 274
 275
 276 /**
 277  * Instruction destination register.
 278  */
 279 struct prog_dst_register
 280 {
 281    GLuint File:4;      /**< One of the PROGRAM_* register file values */
 282    GLuint Index:INST_INDEX_BITS;  /**< Unsigned, never negative */
 283    GLuint WriteMask:4;
 284    GLuint RelAddr:1;
 285
 286    /**
 287     * \name Conditional destination update control.
 288     *
 289     * \since
 290     * NV_fragment_program_option, NV_vertex_program2, NV_vertex_program2_option.
 291     */
 292    /*@{*/
 293    /**
 294     * Takes one of the 9 possible condition values (EQ, FL, GT, GE, LE, LT,
 295     * NE, TR, or UN).  Dest reg is only written to if the matching
 296     * (swizzled) condition code value passes.  When a conditional update mask
 297     * is not specified, this will be \c COND_TR.
 298     */
 299    GLuint CondMask:4;
 300
 301    /**
 302     * Condition code swizzle value.
 303     */
 304    GLuint CondSwizzle:12;
 305 };
 306
 307
 308 /**
 309  * Vertex/fragment program instruction.
 310  */
 311 struct prog_instruction
 312 {
 313    gl_inst_opcode Opcode;
 314    struct prog_src_register SrcReg[3];
 315    struct prog_dst_register DstReg;
 316
 317    /**
 318     * Indicates that the instruction should update the condition code
 319     * register.
 320     *
 321     * \since
 322     * NV_fragment_program_option, NV_vertex_program2, NV_vertex_program2_option.
 323     */
 324    GLuint CondUpdate:1;
 325
 326    /**
 327     * If prog_instruction::CondUpdate is \c GL_TRUE, this value selects the
 328     * condition code register that is to be updated.
 329     *
 330     * In GL_NV_fragment_program or GL_NV_vertex_program2 mode, only condition
 331     * code register 0 is available.  In GL_NV_vertex_program3 mode, condition
 332     * code registers 0 and 1 are available.
 333     *
 334     * \since
 335     * NV_fragment_program_option, NV_vertex_program2, NV_vertex_program2_option.
 336     */
 337    GLuint CondDst:1;
 338
 339    /**
 340     * Saturate each value of the vectored result to the range [0,1] or the
 341     * range [-1,1].  \c SSAT mode (i.e., saturation to the range [-1,1]) is
 342     * only available in NV_fragment_program2 mode.
 343     * Value is one of the SATURATE_* tokens.
 344     *
 345     * \since
 346     * NV_fragment_program_option, NV_vertex_program3.
 347     */
 348    GLuint SaturateMode:2;
 349
 350    /**
 351     * Per-instruction selectable precision: FLOAT32, FLOAT16, FIXED12.
 352     *
 353     * \since
 354     * NV_fragment_program_option.
 355     */
 356    GLuint Precision:3;
 357
 358    /**
 359     * \name Extra fields for TEX, TXB, TXD, TXL, TXP instructions.
 360     */
 361    /*@{*/
 362    /** Source texture unit. */
 363    GLuint TexSrcUnit:5;
 364
 365    /** Source texture target, one of TEXTURE_{1D,2D,3D,CUBE,RECT}_INDEX */
 366    GLuint TexSrcTarget:4;
 367
 368    /** True if tex instruction should do shadow comparison */
 369    GLuint TexShadow:1;
 370    /*@}*/
 371
 372    /**
 373     * For BRA and CAL instructions, the location to jump to.
 374     * For BGNLOOP, points to ENDLOOP (and vice-versa).
 375     * For BRK, points to ENDLOOP
 376     * For IF, points to ELSE or ENDIF.
 377     * For ELSE, points to ENDIF.
 378     */
 379    GLint BranchTarget;
 380
 381    /** for debugging purposes */
 382    const char *Comment;
 383
 384    /** for driver use (try to remove someday) */
 385    GLint Aux;
 386 };
 387
 388
 389 #ifdef __cplusplus
 390 extern "C" {
 391 #endif
 392
 393 extern void
 394 _mesa_init_instructions(struct prog_instruction *inst, GLuint count);
 395
 396 extern struct prog_instruction *
 397 _mesa_alloc_instructions(GLuint numInst);
 398
 399 extern struct prog_instruction *
 400 _mesa_realloc_instructions(struct prog_instruction *oldInst,
 401                            GLuint numOldInst, GLuint numNewInst);
 402
 403 extern struct prog_instruction *
 404 _mesa_copy_instructions(struct prog_instruction *dest,
 405                         const struct prog_instruction *src, GLuint n);
 406
 407 extern void
 408 _mesa_free_instructions(struct prog_instruction *inst, GLuint count);
 409
 410 extern GLuint
 411 _mesa_num_inst_src_regs(gl_inst_opcode opcode);
 412
 413 extern GLuint
 414 _mesa_num_inst_dst_regs(gl_inst_opcode opcode);
 415
 416 extern GLboolean
 417 _mesa_is_tex_instruction(gl_inst_opcode opcode);
 418
 419 extern GLboolean
 420 _mesa_check_soa_dependencies(const struct prog_instruction *inst);
 421
 422 extern const char *
 423 _mesa_opcode_string(gl_inst_opcode opcode);
 424
 425
 426 #ifdef __cplusplus
 427 } /* extern "C" */
 428 #endif
 429
 430 #endif /* PROG_INSTRUCTION_H */