src/mesa/slang/slang_ir.h

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2005-2008  Brian Paul   All Rights Reserved.
   5  * Copyright (C) 2009  VMware, Inc.   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  * \file slang_ir.h
  27  * Mesa GLSL Intermediate Representation tree types and constants.
  28  * \author Brian Paul
  29  */
  30
  31
  32 #ifndef SLANG_IR_H
  33 #define SLANG_IR_H
  34
  35
  36 #include "main/imports.h"
  37 #include "slang_compile.h"
  38 #include "slang_label.h"
  39 #include "main/mtypes.h"
  40
  41
  42 /**
  43  * Intermediate Representation opcodes
  44  */
  45 typedef enum
  46 {
  47    IR_NOP = 0,
  48    IR_SEQ,     /* sequence (eval left, then right) */
  49    IR_SCOPE,   /* new variable scope (one child) */
  50
  51    IR_LABEL,   /* target of a jump or cjump */
  52
  53    IR_COND,    /* conditional expression/predicate */
  54
  55    IR_IF,      /* high-level IF/then/else */
  56                /* Children[0] = conditional expression */
  57                /* Children[1] = if-true part */
  58                /* Children[2] = if-else part, or NULL */
  59
  60    IR_BEGIN_SUB, /* begin subroutine */
  61    IR_END_SUB,   /* end subroutine */
  62    IR_RETURN,    /* return from subroutine */
  63    IR_CALL,      /* call subroutine */
  64
  65    IR_LOOP,      /* high-level loop-begin / loop-end */
  66                  /* Children[0] = loop body */
  67                  /* Children[1] = loop tail code, or NULL */
  68
  69    IR_CONT,      /* continue loop */
  70                  /* n->Parent = ptr to parent IR_LOOP Node */
  71    IR_BREAK,     /* break loop */
  72
  73    IR_BREAK_IF_TRUE, /**< Children[0] = the condition expression */
  74    IR_CONT_IF_TRUE,
  75
  76    IR_COPY,       /**< assignment/copy */
  77    IR_MOVE,       /**< assembly MOV instruction */
  78
  79    /* vector ops: */
  80    IR_ADD,        /**< assembly ADD instruction */
  81    IR_SUB,
  82    IR_MUL,
  83    IR_DIV,
  84    IR_DOT4,
  85    IR_DOT3,
  86    IR_DOT2,
  87    IR_NRM4,
  88    IR_NRM3,
  89    IR_CROSS,   /* vec3 cross product */
  90    IR_LRP,
  91    IR_CLAMP,
  92    IR_MIN,
  93    IR_MAX,
  94    IR_CMP,     /* = (op0 < 0) ? op1 : op2 */
  95    IR_SEQUAL,  /* Set if args are equal (vector) */
  96    IR_SNEQUAL, /* Set if args are not equal (vector) */
  97    IR_SGE,     /* Set if greater or equal (vector) */
  98    IR_SGT,     /* Set if greater than (vector) */
  99    IR_SLE,     /* Set if less or equal (vector) */
 100    IR_SLT,     /* Set if less than (vector) */
 101    IR_POW,     /* x^y */
 102    IR_EXP,     /* e^x */
 103    IR_EXP2,    /* 2^x */
 104    IR_LOG2,    /* log base 2 */
 105    IR_RSQ,     /* 1/sqrt() */
 106    IR_RCP,     /* reciprocol */
 107    IR_FLOOR,
 108    IR_FRAC,
 109    IR_ABS,     /* absolute value */
 110    IR_NEG,     /* negate */
 111    IR_DDX,     /* derivative w.r.t. X */
 112    IR_DDY,     /* derivative w.r.t. Y */
 113    IR_SIN,     /* sine */
 114    IR_COS,     /* cosine */
 115    IR_NOISE1,  /* noise(x) */
 116    IR_NOISE2,  /* noise(x, y) */
 117    IR_NOISE3,  /* noise(x, y, z) */
 118    IR_NOISE4,  /* noise(x, y, z, w) */
 119
 120    IR_EQUAL,   /* boolean equality */
 121    IR_NOTEQUAL,/* boolean inequality */
 122    IR_NOT,     /* boolean not */
 123
 124    IR_VAR,     /* variable reference */
 125    IR_VAR_DECL,/* var declaration */
 126
 127    IR_ELEMENT, /* array element */
 128    IR_FIELD,   /* struct field */
 129    IR_SWIZZLE, /* swizzled storage access */
 130
 131    IR_TEX,     /* texture lookup */
 132    IR_TEXB,    /* texture lookup with LOD bias */
 133    IR_TEXP,    /* texture lookup with projection */
 134
 135    IR_TEX_SH,     /* texture lookup, shadow compare */
 136    IR_TEXB_SH,    /* texture lookup with LOD bias, shadow compare */
 137    IR_TEXP_SH,    /* texture lookup with projection, shadow compare */
 138
 139    IR_FLOAT,
 140    IR_I_TO_F,  /* int[4] to float[4] conversion */
 141    IR_F_TO_I,  /* float[4] to int[4] conversion */
 142
 143    IR_KILL,     /* fragment kill/discard */
 144
 145    IR_EMIT_VERTEX,  /* geometry shader: emit vertex */
 146    IR_END_PRIMITIVE /* geometry shader: end primitive */
 147 } slang_ir_opcode;
 148
 149
 150 /**
 151  * Describes where data/variables are stored in the various register files.
 152  *
 153  * In the simple case, the File, Index and Size fields indicate where
 154  * a variable is stored.  For example, a vec3 variable may be stored
 155  * as (File=PROGRAM_TEMPORARY, Index=6, Size=3).  Or, File[Index].
 156  * Or, a program input like color may be stored as
 157  * (File=PROGRAM_INPUT,Index=3,Size=4);
 158  *
 159  * For single-float values, the Swizzle field indicates which component
 160  * of the vector contains the float.
 161  *
 162  * If IsIndirect is set, the storage is accessed through an indirect
 163  * register lookup.  The value in question will be located at:
 164  *   File[Index + IndirectFile[IndirectIndex]]
 165  *
 166  * This is primary used for indexing arrays.  For example, consider this
 167  * GLSL code:
 168  *   uniform int i;
 169  *   float a[10];
 170  *   float x = a[i];
 171  *
 172  * here, storage for a[i] would be described by (File=PROGRAM_TEMPORAY,
 173  * Index=aPos, IndirectFile=PROGRAM_UNIFORM, IndirectIndex=iPos), which
 174  * would mean TEMP[aPos + UNIFORM[iPos]]
 175  */
 176 struct slang_ir_storage_
 177 {
 178    gl_register_file File;  /**< PROGRAM_TEMPORARY, PROGRAM_INPUT, etc */
 179    GLint Index;    /**< -1 means unallocated */
 180    GLint Size;     /**< number of floats or ints */
 181    GLuint Swizzle; /**< Swizzle AND writemask info */
 182    GLint RefCount; /**< Used during IR tree delete */
 183
 184    GLboolean RelAddr; /* we'll remove this eventually */
 185
 186    GLboolean IsIndirect;
 187    gl_register_file IndirectFile;
 188    GLint IndirectIndex;
 189    GLuint IndirectSwizzle;
 190    GLuint TexTarget;  /**< If File==PROGRAM_SAMPLER, one of TEXTURE_x_INDEX */
 191
 192    GLboolean Is2D;
 193    GLint Index2D;
 194
 195    /** If Parent is non-null, Index is relative to parent.
 196     * The other fields are ignored.
 197     */
 198    struct slang_ir_storage_ *Parent;
 199 };
 200
 201 typedef struct slang_ir_storage_ slang_ir_storage;
 202
 203
 204 /**
 205  * Intermediate Representation (IR) tree node
 206  * Basically a binary tree, but IR_LRP and IR_CLAMP have three children.
 207  */
 208 typedef struct slang_ir_node_
 209 {
 210    slang_ir_opcode Opcode;
 211    struct slang_ir_node_ *Children[3];
 212    slang_ir_storage *Store;  /**< location of result of this operation */
 213    GLint InstLocation;  /**< Location of instruction emitted for this node */
 214
 215    /** special fields depending on Opcode: */
 216    const char *Field;  /**< If Opcode == IR_FIELD */
 217    GLfloat Value[4];    /**< If Opcode == IR_FLOAT */
 218    slang_variable *Var;  /**< If Opcode == IR_VAR or IR_VAR_DECL */
 219    struct slang_ir_node_ *List;  /**< For various linked lists */
 220    struct slang_ir_node_ *Parent;  /**< Pointer to logical parent (ie. loop) */
 221    slang_label *Label;  /**< Used for branches */
 222    const char *Comment; /**< If Opcode == IR_COMMENT */
 223 } slang_ir_node;
 224
 225
 226
 227 /**
 228  * Assembly and IR info
 229  */
 230 typedef struct
 231 {
 232    slang_ir_opcode IrOpcode;
 233    const char *IrName;
 234    gl_inst_opcode InstOpcode;
 235    GLuint ResultSize, NumParams;
 236 } slang_ir_info;
 237
 238
 239
 240 extern const slang_ir_info *
 241 _slang_ir_info(slang_ir_opcode opcode);
 242
 243
 244 extern void
 245 _slang_init_ir_storage(slang_ir_storage *st,
 246                        gl_register_file file, GLint index, GLint size,
 247                        GLuint swizzle);
 248
 249 extern slang_ir_storage *
 250 _slang_new_ir_storage(gl_register_file file, GLint index, GLint size);
 251
 252
 253 extern slang_ir_storage *
 254 _slang_new_ir_storage_swz(gl_register_file file, GLint index, GLint size,
 255                           GLuint swizzle);
 256
 257 extern slang_ir_storage *
 258 _slang_new_ir_storage_2d(gl_register_file file, GLint index, GLint index2d,
 259                          GLint size, GLuint swizzle);
 260
 261 extern slang_ir_storage *
 262 _slang_new_ir_storage_relative(GLint index, GLint size,
 263                                slang_ir_storage *parent);
 264
 265
 266 extern slang_ir_storage *
 267 _slang_new_ir_storage_indirect(gl_register_file file,
 268                                GLint index,
 269                                GLint size,
 270                                gl_register_file indirectFile,
 271                                GLint indirectIndex,
 272                                GLuint indirectSwizzle);
 273
 274 extern slang_ir_storage *
 275 _slang_new_ir_storage_sampler(GLint sampNum, GLuint texTarget, GLint size);
 276
 277
 278 extern void
 279 _slang_copy_ir_storage(slang_ir_storage *dst, const slang_ir_storage *src);
 280
 281
 282 extern void
 283 _slang_free_ir_tree(slang_ir_node *n);
 284
 285
 286 extern void
 287 _slang_print_ir_tree(const slang_ir_node *n, int indent);
 288
 289
 290 #endif /* SLANG_IR_H */