1 /* 2 * Mesa 3-D graphics library 3 * Version: 7.3 4 * 5 * Copyright (C) 1999-2008 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 (at) 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_AND, /* */ 151 OPCODE_ARA, /* 2 */ 152 OPCODE_ARL, /* X X X */ 153 OPCODE_ARL_NV, /* 2 */ 154 OPCODE_ARR, /* 2 */ 155 OPCODE_BGNLOOP, /* opt */ 156 OPCODE_BGNSUB, /* opt */ 157 OPCODE_BRA, /* 2 */ 158 OPCODE_BRK, /* 2 opt */ 159 OPCODE_CAL, /* 2 2 opt */ 160 OPCODE_CMP, /* X X */ 161 OPCODE_CONT, /* opt */ 162 OPCODE_COS, /* X 2 X X */ 163 OPCODE_DDX, /* X X */ 164 OPCODE_DDY, /* X X */ 165 OPCODE_DP2, /* 2 X */ 166 OPCODE_DP2A, /* 2 */ 167 OPCODE_DP3, /* X X X X X */ 168 OPCODE_DP4, /* X X X X X */ 169 OPCODE_DPH, /* X X 1.1 */ 170 OPCODE_DST, /* X X X X */ 171 OPCODE_ELSE, /* opt */ 172 OPCODE_EMIT_VERTEX,/* X */ 173 OPCODE_END, /* X X X X opt */ 174 OPCODE_END_PRIMITIVE,/* X */ 175 OPCODE_ENDIF, /* opt */ 176 OPCODE_ENDLOOP, /* opt */ 177 OPCODE_ENDSUB, /* opt */ 178 OPCODE_EX2, /* X X 2 X X */ 179 OPCODE_EXP, /* X X */ 180 OPCODE_FLR, /* X X 2 X X */ 181 OPCODE_FRC, /* X X 2 X X */ 182 OPCODE_IF, /* opt */ 183 OPCODE_KIL, /* X X */ 184 OPCODE_KIL_NV, /* X X */ 185 OPCODE_LG2, /* X X 2 X X */ 186 OPCODE_LIT, /* X X X X */ 187 OPCODE_LOG, /* X X */ 188 OPCODE_LRP, /* X X */ 189 OPCODE_MAD, /* X X X X X */ 190 OPCODE_MAX, /* X X X X X */ 191 OPCODE_MIN, /* X X X X X */ 192 OPCODE_MOV, /* X X X X X */ 193 OPCODE_MUL, /* X X X X X */ 194 OPCODE_NOISE1, /* X */ 195 OPCODE_NOISE2, /* X */ 196 OPCODE_NOISE3, /* X */ 197 OPCODE_NOISE4, /* X */ 198 OPCODE_NOT, /* */ 199 OPCODE_NRM3, /* */ 200 OPCODE_NRM4, /* */ 201 OPCODE_OR, /* */ 202 OPCODE_PK2H, /* X */ 203 OPCODE_PK2US, /* X */ 204 OPCODE_PK4B, /* X */ 205 OPCODE_PK4UB, /* X */ 206 OPCODE_POW, /* X X X X */ 207 OPCODE_POPA, /* 3 */ 208 OPCODE_PRINT, /* X X */ 209 OPCODE_PUSHA, /* 3 */ 210 OPCODE_RCC, /* 1.1 */ 211 OPCODE_RCP, /* X X X X X */ 212 OPCODE_RET, /* 2 2 opt */ 213 OPCODE_RFL, /* X X */ 214 OPCODE_RSQ, /* X X X X X */ 215 OPCODE_SCS, /* X X */ 216 OPCODE_SEQ, /* 2 X X */ 217 OPCODE_SFL, /* 2 X */ 218 OPCODE_SGE, /* X X X X X */ 219 OPCODE_SGT, /* 2 X X */ 220 OPCODE_SIN, /* X 2 X X */ 221 OPCODE_SLE, /* 2 X X */ 222 OPCODE_SLT, /* X X X X X */ 223 OPCODE_SNE, /* 2 X X */ 224 OPCODE_SSG, /* 2 X */ 225 OPCODE_STR, /* 2 X */ 226 OPCODE_SUB, /* X X 1.1 X X */ 227 OPCODE_SWZ, /* X X X */ 228 OPCODE_TEX, /* X 3 X X */ 229 OPCODE_TXB, /* X 3 X */ 230 OPCODE_TXD, /* X X */ 231 OPCODE_TXL, /* 3 2 X */ 232 OPCODE_TXP, /* X X */ 233 OPCODE_TXP_NV, /* 3 X */ 234 OPCODE_TRUNC, /* X */ 235 OPCODE_UP2H, /* X */ 236 OPCODE_UP2US, /* X */ 237 OPCODE_UP4B, /* X */ 238 OPCODE_UP4UB, /* X */ 239 OPCODE_X2D, /* X */ 240 OPCODE_XOR, /* */ 241 OPCODE_XPD, /* X X */ 242 MAX_OPCODE 243 } gl_inst_opcode; 244 245 246 /** 247 * Number of bits for the src/dst register Index field. 248 * This limits the size of temp/uniform register files. 249 */ 250 #define INST_INDEX_BITS 12 251 252 253 /** 254 * Instruction source register. 255 */ 256 struct prog_src_register 257 { 258 GLuint File:4; /**< One of the PROGRAM_* register file values. */ 259 GLint Index:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit. 260 * May be negative for relative addressing. 261 */ 262 GLuint Swizzle:12; 263 GLuint RelAddr:1; 264 265 /** Take the component-wise absolute value */ 266 GLuint Abs:1; 267 268 /** 269 * Post-Abs negation. 270 * This will either be NEGATE_NONE or NEGATE_XYZW, except for the SWZ 271 * instruction which allows per-component negation. 272 */ 273 GLuint Negate:4; 274 275 /** 276 * Is the register two-dimensional. 277 * Two dimensional registers are of the 278 * REGISTER[index][index2] format. 279 * They are used by the geometry shaders where 280 * the first index is the index within an array 281 * and the second index is the semantic of the 282 * array, e.g. gl_PositionIn[index] would become 283 * INPUT[index][gl_PositionIn] 284 */ 285 GLuint HasIndex2:1; 286 GLuint RelAddr2:1; 287 GLint Index2:(INST_INDEX_BITS+1); /**< Extra bit here for sign bit. 288 * May be negative for relative 289 * addressing. */ 290 }; 291 292 293 /** 294 * Instruction destination register. 295 */ 296 struct prog_dst_register 297 { 298 GLuint File:4; /**< One of the PROGRAM_* register file values */ 299 GLuint Index:INST_INDEX_BITS; /**< Unsigned, never negative */ 300 GLuint WriteMask:4; 301 GLuint RelAddr:1; 302 303 /** 304 * \name Conditional destination update control. 305 * 306 * \since 307 * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2, 308 * NV_vertex_program2_option. 309 */ 310 /*@{*/ 311 /** 312 * Takes one of the 9 possible condition values (EQ, FL, GT, GE, LE, LT, 313 * NE, TR, or UN). Dest reg is only written to if the matching 314 * (swizzled) condition code value passes. When a conditional update mask 315 * is not specified, this will be \c COND_TR. 316 */ 317 GLuint CondMask:4; 318 319 /** 320 * Condition code swizzle value. 321 */ 322 GLuint CondSwizzle:12; 323 324 /** 325 * Selects the condition code register to use for conditional destination 326 * update masking. In NV_fragmnet_program or NV_vertex_program2 mode, only 327 * condition code register 0 is available. In NV_vertex_program3 mode, 328 * condition code registers 0 and 1 are available. 329 */ 330 GLuint CondSrc:1; 331 /*@}*/ 332 }; 333 334 335 /** 336 * Vertex/fragment program instruction. 337 */ 338 struct prog_instruction 339 { 340 gl_inst_opcode Opcode; 341 struct prog_src_register SrcReg[3]; 342 struct prog_dst_register DstReg; 343 344 /** 345 * Indicates that the instruction should update the condition code 346 * register. 347 * 348 * \since 349 * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2, 350 * NV_vertex_program2_option. 351 */ 352 GLuint CondUpdate:1; 353 354 /** 355 * If prog_instruction::CondUpdate is \c GL_TRUE, this value selects the 356 * condition code register that is to be updated. 357 * 358 * In GL_NV_fragment_program or GL_NV_vertex_program2 mode, only condition 359 * code register 0 is available. In GL_NV_vertex_program3 mode, condition 360 * code registers 0 and 1 are available. 361 * 362 * \since 363 * NV_fragment_program, NV_fragment_program_option, NV_vertex_program2, 364 * NV_vertex_program2_option. 365 */ 366 GLuint CondDst:1; 367 368 /** 369 * Saturate each value of the vectored result to the range [0,1] or the 370 * range [-1,1]. \c SSAT mode (i.e., saturation to the range [-1,1]) is 371 * only available in NV_fragment_program2 mode. 372 * Value is one of the SATURATE_* tokens. 373 * 374 * \since 375 * NV_fragment_program, NV_fragment_program_option, NV_vertex_program3. 376 */ 377 GLuint SaturateMode:2; 378 379 /** 380 * Per-instruction selectable precision: FLOAT32, FLOAT16, FIXED12. 381 * 382 * \since 383 * NV_fragment_program, NV_fragment_program_option. 384 */ 385 GLuint Precision:3; 386 387 /** 388 * \name Extra fields for TEX, TXB, TXD, TXL, TXP instructions. 389 */ 390 /*@{*/ 391 /** Source texture unit. */ 392 GLuint TexSrcUnit:5; 393 394 /** Source texture target, one of TEXTURE_{1D,2D,3D,CUBE,RECT}_INDEX */ 395 GLuint TexSrcTarget:4; 396 397 /** True if tex instruction should do shadow comparison */ 398 GLuint TexShadow:1; 399 /*@}*/ 400 401 /** 402 * For BRA and CAL instructions, the location to jump to. 403 * For BGNLOOP, points to ENDLOOP (and vice-versa). 404 * For BRK, points to ENDLOOP 405 * For IF, points to ELSE or ENDIF. 406 * For ELSE, points to ENDIF. 407 */ 408 GLint BranchTarget; 409 410 /** for debugging purposes */ 411 const char *Comment; 412 413 /** Arbitrary data. Used for OPCODE_PRINT and some drivers */ 414 void *Data; 415 416 /** for driver use (try to remove someday) */ 417 GLint Aux; 418 }; 419 420 421 extern void 422 _mesa_init_instructions(struct prog_instruction *inst, GLuint count); 423 424 extern struct prog_instruction * 425 _mesa_alloc_instructions(GLuint numInst); 426 427 extern struct prog_instruction * 428 _mesa_realloc_instructions(struct prog_instruction *oldInst, 429 GLuint numOldInst, GLuint numNewInst); 430 431 extern struct prog_instruction * 432 _mesa_copy_instructions(struct prog_instruction *dest, 433 const struct prog_instruction *src, GLuint n); 434 435 extern void 436 _mesa_free_instructions(struct prog_instruction *inst, GLuint count); 437 438 extern GLuint 439 _mesa_num_inst_src_regs(gl_inst_opcode opcode); 440 441 extern GLuint 442 _mesa_num_inst_dst_regs(gl_inst_opcode opcode); 443 444 extern GLboolean 445 _mesa_is_tex_instruction(gl_inst_opcode opcode); 446 447 extern GLboolean 448 _mesa_check_soa_dependencies(const struct prog_instruction *inst); 449 450 extern const char * 451 _mesa_opcode_string(gl_inst_opcode opcode); 452 453 454 #endif /* PROG_INSTRUCTION_H */ 455
