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@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 */ 144typedef 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 */ 256struct 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 */ 296struct 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 */ 338struct 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 421extern void 422_mesa_init_instructions(struct prog_instruction *inst, GLuint count); 423 424extern struct prog_instruction * 425_mesa_alloc_instructions(GLuint numInst); 426 427extern struct prog_instruction * 428_mesa_realloc_instructions(struct prog_instruction *oldInst, 429 GLuint numOldInst, GLuint numNewInst); 430 431extern struct prog_instruction * 432_mesa_copy_instructions(struct prog_instruction *dest, 433 const struct prog_instruction *src, GLuint n); 434 435extern void 436_mesa_free_instructions(struct prog_instruction *inst, GLuint count); 437 438extern GLuint 439_mesa_num_inst_src_regs(gl_inst_opcode opcode); 440 441extern GLuint 442_mesa_num_inst_dst_regs(gl_inst_opcode opcode); 443 444extern GLboolean 445_mesa_is_tex_instruction(gl_inst_opcode opcode); 446 447extern GLboolean 448_mesa_check_soa_dependencies(const struct prog_instruction *inst); 449 450extern const char * 451_mesa_opcode_string(gl_inst_opcode opcode); 452 453 454#endif /* PROG_INSTRUCTION_H */ 455