src/mesa/shader/prog_instruction.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.3
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR 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 /**
  42  * Swizzle indexes.
  43  * Do not change!
  44  */
  45 /*@{*/
  46 #define SWIZZLE_X    0
  47 #define SWIZZLE_Y    1
  48 #define SWIZZLE_Z    2
  49 #define SWIZZLE_W    3
  50 #define SWIZZLE_ZERO 4   /**< For SWZ instruction only */
  51 #define SWIZZLE_ONE  5   /**< For SWZ instruction only */
  52 #define SWIZZLE_NIL  7   /**< used during shader code gen (undefined value) */
  53 /*@}*/
  54
  55 #define MAKE_SWIZZLE4(a,b,c,d) (((a)<<0) | ((b)<<3) | ((c)<<6) | ((d)<<9))
  56 #define SWIZZLE_NOOP           MAKE_SWIZZLE4(0,1,2,3)
  57 #define GET_SWZ(swz, idx)      (((swz) >> ((idx)*3)) & 0x7)
  58 #define GET_BIT(msk, idx)      (((msk) >> (idx)) & 0x1)
  59
  60 #define SWIZZLE_XXXX MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X)
  61 #define SWIZZLE_YYYY MAKE_SWIZZLE4(SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y)
  62 #define SWIZZLE_ZZZZ MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z)
  63 #define SWIZZLE_WWWW MAKE_SWIZZLE4(SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
  64
  65
  66 /**
  67  * Writemask values, 1 bit per component.
  68  */
  69 /*@{*/
  70 #define WRITEMASK_X     0x1
  71 #define WRITEMASK_Y     0x2
  72 #define WRITEMASK_XY    0x3
  73 #define WRITEMASK_Z     0x4
  74 #define WRITEMASK_XZ    0x5
  75 #define WRITEMASK_YZ    0x6
  76 #define WRITEMASK_XYZ   0x7
  77 #define WRITEMASK_W     0x8
  78 #define WRITEMASK_XW    0x9
  79 #define WRITEMASK_YW    0xa
  80 #define WRITEMASK_XYW   0xb
  81 #define WRITEMASK_ZW    0xc
  82 #define WRITEMASK_XZW   0xd
  83 #define WRITEMASK_YZW   0xe
  84 #define WRITEMASK_XYZW  0xf
  85 /*@}*/
  86
  87
  88 /**
  89  * Condition codes
  90  */
  91 /*@{*/
  92 #define COND_GT  1  /**< greater than zero */
  93 #define COND_EQ  2  /**< equal to zero */
  94 #define COND_LT  3  /**< less than zero */
  95 #define COND_UN  4  /**< unordered (NaN) */
  96 #define COND_GE  5  /**< greater then or equal to zero */
  97 #define COND_LE  6  /**< less then or equal to zero */
  98 #define COND_NE  7  /**< not equal to zero */
  99 #define COND_TR  8  /**< always true */
 100 #define COND_FL  9  /**< always false */
 101 /*@}*/
 102
 103
 104 /**
 105  * Instruction precision for GL_NV_fragment_program
 106  */
 107 /*@{*/
 108 #define FLOAT32  0x1
 109 #define FLOAT16  0x2
 110 #define FIXED12  0x4
 111 /*@}*/
 112
 113
 114 /**
 115  * Saturation modes when storing values.
 116  */
 117 /*@{*/
 118 #define SATURATE_OFF            0
 119 #define SATURATE_ZERO_ONE       1
 120 #define SATURATE_PLUS_MINUS_ONE 2
 121 /*@}*/
 122
 123
 124 /**
 125  * Per-component negation masks
 126  */
 127 /*@{*/
 128 #define NEGATE_X    0x1
 129 #define NEGATE_Y    0x2
 130 #define NEGATE_Z    0x4
 131 #define NEGATE_W    0x8
 132 #define NEGATE_XYZW 0xf
 133 #define NEGATE_NONE 0x0
 134 /*@}*/
 135
 136
 137 /**
 138  * Program instruction opcodes, for both vertex and fragment programs.
 139  * \note changes to this opcode list must be reflected in t_vb_arbprogram.c
 140  */
 141 typedef enum prog_opcode {
 142                      /* ARB_vp   ARB_fp   NV_vp   NV_fp     GLSL */
 143                      /*------------------------------------------*/
 144    OPCODE_NOP = 0,   /*                                      X   */
 145    OPCODE_ABS,       /*   X        X       1.1               X   */
 146    OPCODE_ADD,       /*   X        X       X       X         X   */
 147    OPCODE_ARA,       /*                    2                     */
 148    OPCODE_ARL,       /*   X                X                     */
 149    OPCODE_ARL_NV,    /*                    2                     */
 150    OPCODE_ARR,       /*                    2                     */
 151    OPCODE_BGNLOOP,   /*                                     opt  */
 152    OPCODE_BGNSUB,    /*                                     opt  */
 153    OPCODE_BRA,       /*                    2                 X   */
 154    OPCODE_BRK,       /*                    2                opt  */
 155    OPCODE_CAL,       /*                    2       2             */
 156    OPCODE_CMP,       /*            X                             */
 157    OPCODE_CONT,      /*                                     opt  */
 158    OPCODE_COS,       /*            X       2       X         X   */
 159    OPCODE_DDX,       /*                            X         X   */
 160    OPCODE_DDY,       /*                            X         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,      /*                                      X   */
 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                 X   */
 172    OPCODE_FLR,       /*   X        X       2       X         X   */
 173    OPCODE_FRC,       /*   X        X       2       X         X   */
 174    OPCODE_IF,        /*                                     opt  */
 175    OPCODE_INT,       /*                                      X   */
 176    OPCODE_KIL,       /*            X                             */
 177    OPCODE_KIL_NV,    /*                            X         X   */
 178    OPCODE_LG2,       /*   X        X       2       X         X   */
 179    OPCODE_LIT,       /*   X        X       X       X             */
 180    OPCODE_LOG,       /*   X                X                 X   */
 181    OPCODE_LRP,       /*            X               X             */
 182    OPCODE_MAD,       /*   X        X       X       X         X   */
 183    OPCODE_MAX,       /*   X        X       X       X         X   */
 184    OPCODE_MIN,       /*   X        X       X       X         X   */
 185    OPCODE_MOV,       /*   X        X       X       X         X   */
 186    OPCODE_MUL,       /*   X        X       X       X         X   */
 187    OPCODE_NOISE1,    /*                                      X   */
 188    OPCODE_NOISE2,    /*                                      X   */
 189    OPCODE_NOISE3,    /*                                      X   */
 190    OPCODE_NOISE4,    /*                                      X   */
 191    OPCODE_PK2H,      /*                            X             */
 192    OPCODE_PK2US,     /*                            X             */
 193    OPCODE_PK4B,      /*                            X             */
 194    OPCODE_PK4UB,     /*                            X             */
 195    OPCODE_POW,       /*   X        X               X         X   */
 196    OPCODE_POPA,      /*                    3                     */
 197    OPCODE_PRINT,     /*                    X       X             */
 198    OPCODE_PUSHA,     /*                    3                     */
 199    OPCODE_RCC,       /*                    1.1                   */
 200    OPCODE_RCP,       /*   X        X       X       X         X   */
 201    OPCODE_RET,       /*                    2       2             */
 202    OPCODE_RFL,       /*            X               X             */
 203    OPCODE_RSQ,       /*   X        X       X       X         X   */
 204    OPCODE_SCS,       /*            X                             */
 205    OPCODE_SEQ,       /*                    2       X         X   */
 206    OPCODE_SFL,       /*                    2       X             */
 207    OPCODE_SGE,       /*   X        X       X       X         X   */
 208    OPCODE_SGT,       /*                    2       X         X   */
 209    OPCODE_SIN,       /*            X       2       X         X   */
 210    OPCODE_SLE,       /*                    2       X         X   */
 211    OPCODE_SLT,       /*   X        X       X       X         X   */
 212    OPCODE_SNE,       /*                    2       X         X   */
 213    OPCODE_SSG,       /*                    2                     */
 214    OPCODE_STR,       /*                    2       X             */
 215    OPCODE_SUB,       /*   X        X       1.1     X         X   */
 216    OPCODE_SWZ,       /*   X        X                             */
 217    OPCODE_TEX,       /*            X       3       X         X   */
 218    OPCODE_TXB,       /*            X       3                 X   */
 219    OPCODE_TXD,       /*                            X         X   */
 220    OPCODE_TXL,       /*                    3       2         X   */
 221    OPCODE_TXP,       /*            X                         X   */
 222    OPCODE_TXP_NV,    /*                    3       X             */
 223    OPCODE_UP2H,      /*                            X             */
 224    OPCODE_UP2US,     /*                            X             */
 225    OPCODE_UP4B,      /*                            X             */
 226    OPCODE_UP4UB,     /*                            X             */
 227    OPCODE_X2D,       /*                            X             */
 228    OPCODE_XPD,       /*   X        X                         X   */
 229    MAX_OPCODE
 230 } gl_inst_opcode;
 231
 232
 233 /**
 234  * Instruction source register.
 235  */
 236 struct prog_src_register
 237 {
 238    GLuint File:4;       /**< One of the PROGRAM_* register file values. */
 239    GLint Index:9;       /**< May be negative for relative addressing. */
 240    GLuint Swizzle:12;
 241    GLuint RelAddr:1;
 242
 243    /**
 244     * \name Source register "sign" control.
 245     *
 246     * The ARB and NV extensions allow varrying degrees of control over the
 247     * sign of the source vector components.  These values allow enough control
 248     * for all flavors of the extensions.
 249     */
 250    /*@{*/
 251    /**
 252     * Per-component negation for the SWZ instruction.  For non-SWZ
 253     * instructions the only possible values are NEGATE_XYZW and NEGATE_NONE.
 254     *
 255     * \since
 256     * ARB_vertex_program, ARB_fragment_program
 257     */
 258    GLuint NegateBase:4;
 259
 260    /**
 261     * Take the component-wise absolute value.
 262     *
 263     * \since
 264     * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
 265     * NV_vertex_program2_option.
 266     */
 267    GLuint Abs:1;
 268
 269    /**
 270     * Post-absolute value negation (all components).
 271     */
 272    GLuint NegateAbs:1;
 273    /*@}*/
 274 };
 275
 276
 277 /**
 278  * Instruction destination register.
 279  */
 280 struct prog_dst_register
 281 {
 282    /**
 283     * One of the PROGRAM_* register file values.
 284     */
 285    GLuint File:4;
 286
 287    GLuint Index:8;
 288    GLuint WriteMask:4;
 289
 290    /**
 291     * \name Conditional destination update control.
 292     *
 293     * \since
 294     * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
 295     * NV_vertex_program2_option.
 296     */
 297    /*@{*/
 298    /**
 299     * Takes one of the 9 possible condition values (EQ, FL, GT, GE, LE, LT,
 300     * NE, TR, or UN).  Destination update is enabled if the matching
 301     * (swizzled) condition code value passes.  When a conditional update mask
 302     * is not specified, this will be \c COND_TR.
 303     */
 304    GLuint CondMask:4;
 305
 306    /**
 307     * Condition code swizzle value.
 308     */
 309    GLuint CondSwizzle:12;
 310
 311    /**
 312     * Selects the condition code register to use for conditional destination
 313     * update masking.  In NV_fragmnet_program or NV_vertex_program2 mode, only
 314     * condition code register 0 is available.  In NV_vertex_program3 mode,
 315     * condition code registers 0 and 1 are available.
 316     */
 317    GLuint CondSrc:1;
 318    /*@}*/
 319
 320    GLuint pad:31;
 321 };
 322
 323
 324 /**
 325  * Vertex/fragment program instruction.
 326  */
 327 struct prog_instruction
 328 {
 329    gl_inst_opcode Opcode;
 330 #if FEATURE_MESA_program_debug
 331    GLshort StringPos;
 332 #endif
 333    /**
 334     * Arbitrary data.  Used for the PRINT, CAL, and BRA instructions.
 335     */
 336    void *Data;
 337
 338    struct prog_src_register SrcReg[3];
 339    struct prog_dst_register DstReg;
 340
 341    /**
 342     * Indicates that the instruction should update the condition code
 343     * register.
 344     *
 345     * \since
 346     * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
 347     * NV_vertex_program2_option.
 348     */
 349    GLuint CondUpdate:1;
 350
 351    /**
 352     * If prog_instruction::CondUpdate is \c GL_TRUE, this value selects the
 353     * condition code register that is to be updated.
 354     *
 355     * In GL_NV_fragment_program or GL_NV_vertex_program2 mode, only condition
 356     * code register 0 is available.  In GL_NV_vertex_program3 mode, condition
 357     * code registers 0 and 1 are available.
 358     *
 359     * \since
 360     * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2,
 361     * NV_vertex_program2_option.
 362     */
 363    GLuint CondDst:1;
 364
 365    /**
 366     * Saturate each value of the vectored result to the range [0,1] or the
 367     * range [-1,1].  \c SSAT mode (i.e., saturation to the range [-1,1]) is
 368     * only available in NV_fragment_program2 mode.
 369     * Value is one of the SATURATE_* tokens.
 370     *
 371     * \since
 372     * NV_fragment_program, NV_fragment_program_option, NV_vertex_program3.
 373     */
 374    GLuint SaturateMode:2;
 375
 376    /**
 377     * Per-instruction selectable precision.
 378     *
 379     * \since
 380     * NV_fragment_program, NV_fragment_program_option.
 381     */
 382    GLuint Precision:3;
 383
 384    /**
 385     * \name Texture source controls.
 386     *
 387     * The texture source controls are only used with the \c TEX, \c TXD,
 388     * \c TXL, and \c TXP instructions.
 389     *
 390     * \since
 391     * ARB_fragment_program, NV_fragment_program, NV_vertex_program3.
 392     */
 393    /*@{*/
 394    /**
 395     * Source texture unit.  OpenGL supports a maximum of 32 texture
 396     * units.
 397     */
 398    GLuint TexSrcUnit:5;
 399
 400    /**
 401     * Source texture target, one of TEXTURE_{1D,2D,3D,CUBE,RECT}_INDEX.
 402     */
 403    GLuint TexSrcTarget:3;
 404    /*@}*/
 405
 406    /**
 407     * For BRA and CAL instructions, the location to jump to.
 408     * For BGNLOOP, points to ENDLOOP (and vice-versa).
 409     * For BRK, points to BGNLOOP (which points to ENDLOOP).
 410     * For IF, points to else or endif.
 411     * For ELSE, points to endif.
 412     */
 413    GLint BranchTarget;
 414
 415    /**
 416     * For TEX instructions in shaders, the sampler to use for the
 417     * texture lookup.
 418     */
 419    GLint Sampler;
 420
 421    const char *Comment;
 422 };
 423
 424
 425 extern void
 426 _mesa_init_instructions(struct prog_instruction *inst, GLuint count);
 427
 428 extern struct prog_instruction *
 429 _mesa_alloc_instructions(GLuint numInst);
 430
 431 extern struct prog_instruction *
 432 _mesa_realloc_instructions(struct prog_instruction *oldInst,
 433                            GLuint numOldInst, GLuint numNewInst);
 434
 435 extern struct prog_instruction *
 436 _mesa_copy_instructions(struct prog_instruction *dest,
 437                         const struct prog_instruction *src, GLuint n);
 438
 439 extern GLuint
 440 _mesa_num_inst_src_regs(gl_inst_opcode opcode);
 441
 442 extern const char *
 443 _mesa_opcode_string(gl_inst_opcode opcode);
 444
 445
 446 #endif /* PROG_INSTRUCTION_H */