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