Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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.  
  355.