workbench/libs/mesa/src/mesa/program/prog_instruction.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.3
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  * Copyright (C) 1999-2009  VMware, Inc.  All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 #include "main/glheader.h"
  28 #include "main/imports.h"
  29 #include "main/mtypes.h"
  30 #include "prog_instruction.h"
  31
  32
  33 /**
  34  * Initialize program instruction fields to defaults.
  35  * \param inst  first instruction to initialize
  36  * \param count  number of instructions to initialize
  37  */
  38 void
  39 _mesa_init_instructions(struct prog_instruction *inst, GLuint count)
  40 {
  41    GLuint i;
  42
  43    memset(inst, 0, count * sizeof(struct prog_instruction));
  44
  45    for (i = 0; i < count; i++) {
  46       inst[i].SrcReg[0].File = PROGRAM_UNDEFINED;
  47       inst[i].SrcReg[0].Swizzle = SWIZZLE_NOOP;
  48       inst[i].SrcReg[1].File = PROGRAM_UNDEFINED;
  49       inst[i].SrcReg[1].Swizzle = SWIZZLE_NOOP;
  50       inst[i].SrcReg[2].File = PROGRAM_UNDEFINED;
  51       inst[i].SrcReg[2].Swizzle = SWIZZLE_NOOP;
  52
  53       inst[i].DstReg.File = PROGRAM_UNDEFINED;
  54       inst[i].DstReg.WriteMask = WRITEMASK_XYZW;
  55       inst[i].DstReg.CondMask = COND_TR;
  56       inst[i].DstReg.CondSwizzle = SWIZZLE_NOOP;
  57
  58       inst[i].SaturateMode = SATURATE_OFF;
  59       inst[i].Precision = FLOAT32;
  60    }
  61 }
  62
  63
  64 /**
  65  * Allocate an array of program instructions.
  66  * \param numInst  number of instructions
  67  * \return pointer to instruction memory
  68  */
  69 struct prog_instruction *
  70 _mesa_alloc_instructions(GLuint numInst)
  71 {
  72    return (struct prog_instruction *)
  73       calloc(1, numInst * sizeof(struct prog_instruction));
  74 }
  75
  76
  77 /**
  78  * Reallocate memory storing an array of program instructions.
  79  * This is used when we need to append additional instructions onto an
  80  * program.
  81  * \param oldInst  pointer to first of old/src instructions
  82  * \param numOldInst  number of instructions at <oldInst>
  83  * \param numNewInst  desired size of new instruction array.
  84  * \return  pointer to start of new instruction array.
  85  */
  86 struct prog_instruction *
  87 _mesa_realloc_instructions(struct prog_instruction *oldInst,
  88                            GLuint numOldInst, GLuint numNewInst)
  89 {
  90    struct prog_instruction *newInst;
  91
  92    newInst = (struct prog_instruction *)
  93       _mesa_realloc(oldInst,
  94                     numOldInst * sizeof(struct prog_instruction),
  95                     numNewInst * sizeof(struct prog_instruction));
  96
  97    return newInst;
  98 }
  99
 100
 101 /**
 102  * Copy an array of program instructions.
 103  * \param dest  pointer to destination.
 104  * \param src  pointer to source.
 105  * \param n  number of instructions to copy.
 106  * \return pointer to destination.
 107  */
 108 struct prog_instruction *
 109 _mesa_copy_instructions(struct prog_instruction *dest,
 110                         const struct prog_instruction *src, GLuint n)
 111 {
 112    GLuint i;
 113    memcpy(dest, src, n * sizeof(struct prog_instruction));
 114    for (i = 0; i < n; i++) {
 115       if (src[i].Comment)
 116          dest[i].Comment = _mesa_strdup(src[i].Comment);
 117    }
 118    return dest;
 119 }
 120
 121
 122 /**
 123  * Free an array of instructions
 124  */
 125 void
 126 _mesa_free_instructions(struct prog_instruction *inst, GLuint count)
 127 {
 128    GLuint i;
 129    for (i = 0; i < count; i++) {
 130       if (inst[i].Data)
 131          free(inst[i].Data);
 132       if (inst[i].Comment)
 133          free((char *) inst[i].Comment);
 134    }
 135    free(inst);
 136 }
 137
 138
 139 /**
 140  * Basic info about each instruction
 141  */
 142 struct instruction_info
 143 {
 144    gl_inst_opcode Opcode;
 145    const char *Name;
 146    GLuint NumSrcRegs;
 147    GLuint NumDstRegs;
 148 };
 149
 150 /**
 151  * Instruction info
 152  * \note Opcode should equal array index!
 153  */
 154 static const struct instruction_info InstInfo[MAX_OPCODE] = {
 155    { OPCODE_NOP,    "NOP",     0, 0 },
 156    { OPCODE_ABS,    "ABS",     1, 1 },
 157    { OPCODE_ADD,    "ADD",     2, 1 },
 158    { OPCODE_AND,    "AND",     2, 1 },
 159    { OPCODE_ARA,    "ARA",     1, 1 },
 160    { OPCODE_ARL,    "ARL",     1, 1 },
 161    { OPCODE_ARL_NV, "ARL_NV",  1, 1 },
 162    { OPCODE_ARR,    "ARL",     1, 1 },
 163    { OPCODE_BGNLOOP,"BGNLOOP", 0, 0 },
 164    { OPCODE_BGNSUB, "BGNSUB",  0, 0 },
 165    { OPCODE_BRA,    "BRA",     0, 0 },
 166    { OPCODE_BRK,    "BRK",     0, 0 },
 167    { OPCODE_CAL,    "CAL",     0, 0 },
 168    { OPCODE_CMP,    "CMP",     3, 1 },
 169    { OPCODE_CONT,   "CONT",    0, 0 },
 170    { OPCODE_COS,    "COS",     1, 1 },
 171    { OPCODE_DDX,    "DDX",     1, 1 },
 172    { OPCODE_DDY,    "DDY",     1, 1 },
 173    { OPCODE_DP2,    "DP2",     2, 1 },
 174    { OPCODE_DP2A,   "DP2A",    3, 1 },
 175    { OPCODE_DP3,    "DP3",     2, 1 },
 176    { OPCODE_DP4,    "DP4",     2, 1 },
 177    { OPCODE_DPH,    "DPH",     2, 1 },
 178    { OPCODE_DST,    "DST",     2, 1 },
 179    { OPCODE_ELSE,   "ELSE",    0, 0 },
 180    { OPCODE_EMIT_VERTEX,   "EMIT_VERTEX",    0, 0 },
 181    { OPCODE_END,    "END",     0, 0 },
 182    { OPCODE_END_PRIMITIVE,    "END_PRIMITIVE",     0, 0 },
 183    { OPCODE_ENDIF,  "ENDIF",   0, 0 },
 184    { OPCODE_ENDLOOP,"ENDLOOP", 0, 0 },
 185    { OPCODE_ENDSUB, "ENDSUB",  0, 0 },
 186    { OPCODE_EX2,    "EX2",     1, 1 },
 187    { OPCODE_EXP,    "EXP",     1, 1 },
 188    { OPCODE_FLR,    "FLR",     1, 1 },
 189    { OPCODE_FRC,    "FRC",     1, 1 },
 190    { OPCODE_IF,     "IF",      1, 0 },
 191    { OPCODE_KIL,    "KIL",     1, 0 },
 192    { OPCODE_KIL_NV, "KIL_NV",  0, 0 },
 193    { OPCODE_LG2,    "LG2",     1, 1 },
 194    { OPCODE_LIT,    "LIT",     1, 1 },
 195    { OPCODE_LOG,    "LOG",     1, 1 },
 196    { OPCODE_LRP,    "LRP",     3, 1 },
 197    { OPCODE_MAD,    "MAD",     3, 1 },
 198    { OPCODE_MAX,    "MAX",     2, 1 },
 199    { OPCODE_MIN,    "MIN",     2, 1 },
 200    { OPCODE_MOV,    "MOV",     1, 1 },
 201    { OPCODE_MUL,    "MUL",     2, 1 },
 202    { OPCODE_NOISE1, "NOISE1",  1, 1 },
 203    { OPCODE_NOISE2, "NOISE2",  1, 1 },
 204    { OPCODE_NOISE3, "NOISE3",  1, 1 },
 205    { OPCODE_NOISE4, "NOISE4",  1, 1 },
 206    { OPCODE_NOT,    "NOT",     1, 1 },
 207    { OPCODE_NRM3,   "NRM3",    1, 1 },
 208    { OPCODE_NRM4,   "NRM4",    1, 1 },
 209    { OPCODE_OR,     "OR",      2, 1 },
 210    { OPCODE_PK2H,   "PK2H",    1, 1 },
 211    { OPCODE_PK2US,  "PK2US",   1, 1 },
 212    { OPCODE_PK4B,   "PK4B",    1, 1 },
 213    { OPCODE_PK4UB,  "PK4UB",   1, 1 },
 214    { OPCODE_POW,    "POW",     2, 1 },
 215    { OPCODE_POPA,   "POPA",    0, 0 },
 216    { OPCODE_PRINT,  "PRINT",   1, 0 },
 217    { OPCODE_PUSHA,  "PUSHA",   0, 0 },
 218    { OPCODE_RCC,    "RCC",     1, 1 },
 219    { OPCODE_RCP,    "RCP",     1, 1 },
 220    { OPCODE_RET,    "RET",     0, 0 },
 221    { OPCODE_RFL,    "RFL",     1, 1 },
 222    { OPCODE_RSQ,    "RSQ",     1, 1 },
 223    { OPCODE_SCS,    "SCS",     1, 1 },
 224    { OPCODE_SEQ,    "SEQ",     2, 1 },
 225    { OPCODE_SFL,    "SFL",     0, 1 },
 226    { OPCODE_SGE,    "SGE",     2, 1 },
 227    { OPCODE_SGT,    "SGT",     2, 1 },
 228    { OPCODE_SIN,    "SIN",     1, 1 },
 229    { OPCODE_SLE,    "SLE",     2, 1 },
 230    { OPCODE_SLT,    "SLT",     2, 1 },
 231    { OPCODE_SNE,    "SNE",     2, 1 },
 232    { OPCODE_SSG,    "SSG",     1, 1 },
 233    { OPCODE_STR,    "STR",     0, 1 },
 234    { OPCODE_SUB,    "SUB",     2, 1 },
 235    { OPCODE_SWZ,    "SWZ",     1, 1 },
 236    { OPCODE_TEX,    "TEX",     1, 1 },
 237    { OPCODE_TXB,    "TXB",     1, 1 },
 238    { OPCODE_TXD,    "TXD",     3, 1 },
 239    { OPCODE_TXL,    "TXL",     1, 1 },
 240    { OPCODE_TXP,    "TXP",     1, 1 },
 241    { OPCODE_TXP_NV, "TXP_NV",  1, 1 },
 242    { OPCODE_TRUNC,  "TRUNC",   1, 1 },
 243    { OPCODE_UP2H,   "UP2H",    1, 1 },
 244    { OPCODE_UP2US,  "UP2US",   1, 1 },
 245    { OPCODE_UP4B,   "UP4B",    1, 1 },
 246    { OPCODE_UP4UB,  "UP4UB",   1, 1 },
 247    { OPCODE_X2D,    "X2D",     3, 1 },
 248    { OPCODE_XOR,    "XOR",     2, 1 },
 249    { OPCODE_XPD,    "XPD",     2, 1 }
 250 };
 251
 252
 253 /**
 254  * Return the number of src registers for the given instruction/opcode.
 255  */
 256 GLuint
 257 _mesa_num_inst_src_regs(gl_inst_opcode opcode)
 258 {
 259    ASSERT(opcode < MAX_OPCODE);
 260    ASSERT(opcode == InstInfo[opcode].Opcode);
 261    ASSERT(OPCODE_XPD == InstInfo[OPCODE_XPD].Opcode);
 262    return InstInfo[opcode].NumSrcRegs;
 263 }
 264
 265
 266 /**
 267  * Return the number of dst registers for the given instruction/opcode.
 268  */
 269 GLuint
 270 _mesa_num_inst_dst_regs(gl_inst_opcode opcode)
 271 {
 272    ASSERT(opcode < MAX_OPCODE);
 273    ASSERT(opcode == InstInfo[opcode].Opcode);
 274    ASSERT(OPCODE_XPD == InstInfo[OPCODE_XPD].Opcode);
 275    return InstInfo[opcode].NumDstRegs;
 276 }
 277
 278
 279 GLboolean
 280 _mesa_is_tex_instruction(gl_inst_opcode opcode)
 281 {
 282    return (opcode == OPCODE_TEX ||
 283            opcode == OPCODE_TXB ||
 284            opcode == OPCODE_TXD ||
 285            opcode == OPCODE_TXL ||
 286            opcode == OPCODE_TXP);
 287 }
 288
 289
 290 /**
 291  * Check if there's a potential src/dst register data dependency when
 292  * using SOA execution.
 293  * Example:
 294  *   MOV T, T.yxwz;
 295  * This would expand into:
 296  *   MOV t0, t1;
 297  *   MOV t1, t0;
 298  *   MOV t2, t3;
 299  *   MOV t3, t2;
 300  * The second instruction will have the wrong value for t0 if executed as-is.
 301  */
 302 GLboolean
 303 _mesa_check_soa_dependencies(const struct prog_instruction *inst)
 304 {
 305    GLuint i, chan;
 306
 307    if (inst->DstReg.WriteMask == WRITEMASK_X ||
 308        inst->DstReg.WriteMask == WRITEMASK_Y ||
 309        inst->DstReg.WriteMask == WRITEMASK_Z ||
 310        inst->DstReg.WriteMask == WRITEMASK_W ||
 311        inst->DstReg.WriteMask == 0x0) {
 312       /* no chance of data dependency */
 313       return GL_FALSE;
 314    }
 315
 316    /* loop over src regs */
 317    for (i = 0; i < 3; i++) {
 318       if (inst->SrcReg[i].File == inst->DstReg.File &&
 319           inst->SrcReg[i].Index == inst->DstReg.Index) {
 320          /* loop over dest channels */
 321          GLuint channelsWritten = 0x0;
 322          for (chan = 0; chan < 4; chan++) {
 323             if (inst->DstReg.WriteMask & (1 << chan)) {
 324                /* check if we're reading a channel that's been written */
 325                GLuint swizzle = GET_SWZ(inst->SrcReg[i].Swizzle, chan);
 326                if (swizzle <= SWIZZLE_W &&
 327                    (channelsWritten & (1 << swizzle))) {
 328                   return GL_TRUE;
 329                }
 330
 331                channelsWritten |= (1 << chan);
 332             }
 333          }
 334       }
 335    }
 336    return GL_FALSE;
 337 }
 338
 339
 340 /**
 341  * Return string name for given program opcode.
 342  */
 343 const char *
 344 _mesa_opcode_string(gl_inst_opcode opcode)
 345 {
 346    if (opcode < MAX_OPCODE)
 347       return InstInfo[opcode].Name;
 348    else {
 349       static char s[20];
 350       _mesa_snprintf(s, sizeof(s), "OP%u", opcode);
 351       return s;
 352    }
 353 }
 354