"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/drivers/i915/i915_debug_fp.c" (16 Sep 2020, 8820 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "i915_debug_fp.c" see the Fossies "Dox" file reference documentation.

    1 /**************************************************************************
    2  * 
    3  * Copyright 2003 VMware, Inc.
    4  * All Rights Reserved.
    5  * 
    6  * Permission is hereby granted, free of charge, to any person obtaining a
    7  * copy of this software and associated documentation files (the
    8  * "Software"), to deal in the Software without restriction, including
    9  * without limitation the rights to use, copy, modify, merge, publish,
   10  * distribute, sub license, and/or sell copies of the Software, and to
   11  * permit persons to whom the Software is furnished to do so, subject to
   12  * the following conditions:
   13  * 
   14  * The above copyright notice and this permission notice (including the
   15  * next paragraph) shall be included in all copies or substantial portions
   16  * 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
   20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
   21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
   22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   25  * 
   26  **************************************************************************/
   27 
   28 
   29 #include "i915_reg.h"
   30 #include "i915_debug.h"
   31 #include "i915_debug_private.h"
   32 #include "util/u_debug.h"
   33 
   34 
   35 static void
   36 PRINTF(
   37    struct debug_stream  *stream,
   38    const char           *fmt,
   39                         ... )
   40 {
   41    va_list  args;
   42 
   43    va_start( args, fmt );
   44    debug_vprintf( fmt, args );
   45    va_end( args );
   46 }
   47 
   48 
   49 static const char *opcodes[0x20] = {
   50    "NOP",
   51    "ADD",
   52    "MOV",
   53    "MUL",
   54    "MAD",
   55    "DP2ADD",
   56    "DP3",
   57    "DP4",
   58    "FRC",
   59    "RCP",
   60    "RSQ",
   61    "EXP",
   62    "LOG",
   63    "CMP",
   64    "MIN",
   65    "MAX",
   66    "FLR",
   67    "MOD",
   68    "TRC",
   69    "SGE",
   70    "SLT",
   71    "TEXLD",
   72    "TEXLDP",
   73    "TEXLDB",
   74    "TEXKILL",
   75    "DCL",
   76    "0x1a",
   77    "0x1b",
   78    "0x1c",
   79    "0x1d",
   80    "0x1e",
   81    "0x1f",
   82 };
   83 
   84 
   85 static const int args[0x20] = {
   86    0,                           /* 0 nop */
   87    2,                           /* 1 add */
   88    1,                           /* 2 mov */
   89    2,                           /* 3 m ul */
   90    3,                           /* 4 mad */
   91    3,                           /* 5 dp2add */
   92    2,                           /* 6 dp3 */
   93    2,                           /* 7 dp4 */
   94    1,                           /* 8 frc */
   95    1,                           /* 9 rcp */
   96    1,                           /* a rsq */
   97    1,                           /* b exp */
   98    1,                           /* c log */
   99    3,                           /* d cmp */
  100    2,                           /* e min */
  101    2,                           /* f max */
  102    1,                           /* 10 flr */
  103    1,                           /* 11 mod */
  104    1,                           /* 12 trc */
  105    2,                           /* 13 sge */
  106    2,                           /* 14 slt */
  107    1,
  108    1,
  109    1,
  110    1,
  111    0,
  112    0,
  113    0,
  114    0,
  115    0,
  116    0,
  117    0,
  118 };
  119 
  120 
  121 static const char *regname[0x8] = {
  122    "R",
  123    "T",
  124    "CONST",
  125    "S",
  126    "OC",
  127    "OD",
  128    "U",
  129    "UNKNOWN",
  130 };
  131 
  132 static void
  133 print_reg_type_nr(struct debug_stream *stream, unsigned type, unsigned nr)
  134 {
  135    switch (type) {
  136    case REG_TYPE_T:
  137       switch (nr) {
  138       case T_DIFFUSE:
  139          PRINTF(stream, "T_DIFFUSE");
  140          return;
  141       case T_SPECULAR:
  142          PRINTF(stream, "T_SPECULAR");
  143          return;
  144       case T_FOG_W:
  145          PRINTF(stream, "T_FOG_W");
  146          return;
  147       default:
  148          PRINTF(stream, "T_TEX%d", nr);
  149          return;
  150       }
  151    case REG_TYPE_OC:
  152       if (nr == 0) {
  153          PRINTF(stream, "oC");
  154          return;
  155       }
  156       break;
  157    case REG_TYPE_OD:
  158       if (nr == 0) {
  159          PRINTF(stream, "oD");
  160          return;
  161       }
  162       break;
  163    default:
  164       break;
  165    }
  166 
  167    PRINTF(stream, "%s[%d]", regname[type], nr);
  168 }
  169 
  170 #define REG_SWIZZLE_MASK 0x7777
  171 #define REG_NEGATE_MASK 0x8888
  172 
  173 #define REG_SWIZZLE_XYZW ((SRC_X << A2_SRC2_CHANNEL_X_SHIFT) |  \
  174               (SRC_Y << A2_SRC2_CHANNEL_Y_SHIFT) |  \
  175               (SRC_Z << A2_SRC2_CHANNEL_Z_SHIFT) |  \
  176               (SRC_W << A2_SRC2_CHANNEL_W_SHIFT))
  177 
  178 
  179 static void
  180 print_reg_neg_swizzle(struct debug_stream *stream, unsigned reg)
  181 {
  182    int i;
  183 
  184    if ((reg & REG_SWIZZLE_MASK) == REG_SWIZZLE_XYZW &&
  185        (reg & REG_NEGATE_MASK) == 0)
  186       return;
  187 
  188    PRINTF(stream, ".");
  189 
  190    for (i = 3; i >= 0; i--) {
  191       if (reg & (1 << ((i * 4) + 3)))
  192          PRINTF(stream, "-");
  193 
  194       switch ((reg >> (i * 4)) & 0x7) {
  195       case 0:
  196          PRINTF(stream, "x");
  197          break;
  198       case 1:
  199          PRINTF(stream, "y");
  200          break;
  201       case 2:
  202          PRINTF(stream, "z");
  203          break;
  204       case 3:
  205          PRINTF(stream, "w");
  206          break;
  207       case 4:
  208          PRINTF(stream, "0");
  209          break;
  210       case 5:
  211          PRINTF(stream, "1");
  212          break;
  213       default:
  214          PRINTF(stream, "?");
  215          break;
  216       }
  217    }
  218 }
  219 
  220 
  221 static void
  222 print_src_reg(struct debug_stream *stream, unsigned dword)
  223 {
  224    unsigned nr = (dword >> A2_SRC2_NR_SHIFT) & REG_NR_MASK;
  225    unsigned type = (dword >> A2_SRC2_TYPE_SHIFT) & REG_TYPE_MASK;
  226    print_reg_type_nr(stream, type, nr);
  227    print_reg_neg_swizzle(stream, dword);
  228 }
  229 
  230 
  231 static void
  232 print_dest_reg(struct debug_stream *stream, unsigned dword)
  233 {
  234    unsigned nr = (dword >> A0_DEST_NR_SHIFT) & REG_NR_MASK;
  235    unsigned type = (dword >> A0_DEST_TYPE_SHIFT) & REG_TYPE_MASK;
  236    print_reg_type_nr(stream, type, nr);
  237    if ((dword & A0_DEST_CHANNEL_ALL) == A0_DEST_CHANNEL_ALL)
  238       return;
  239    PRINTF(stream, ".");
  240    if (dword & A0_DEST_CHANNEL_X)
  241       PRINTF(stream, "x");
  242    if (dword & A0_DEST_CHANNEL_Y)
  243       PRINTF(stream, "y");
  244    if (dword & A0_DEST_CHANNEL_Z)
  245       PRINTF(stream, "z");
  246    if (dword & A0_DEST_CHANNEL_W)
  247       PRINTF(stream, "w");
  248 }
  249 
  250 
  251 #define GET_SRC0_REG(r0, r1) ((r0<<14)|(r1>>A1_SRC0_CHANNEL_W_SHIFT))
  252 #define GET_SRC1_REG(r0, r1) ((r0<<8)|(r1>>A2_SRC1_CHANNEL_W_SHIFT))
  253 #define GET_SRC2_REG(r)      (r)
  254 
  255 
  256 static void
  257 print_arith_op(struct debug_stream *stream, 
  258            unsigned opcode, const unsigned * program)
  259 {
  260    if (opcode != A0_NOP) {
  261       print_dest_reg(stream, program[0]);
  262       if (program[0] & A0_DEST_SATURATE)
  263          PRINTF(stream, " = SATURATE ");
  264       else
  265          PRINTF(stream, " = ");
  266    }
  267 
  268    PRINTF(stream, "%s ", opcodes[opcode]);
  269 
  270    print_src_reg(stream, GET_SRC0_REG(program[0], program[1]));
  271    if (args[opcode] == 1) {
  272       PRINTF(stream, "\n");
  273       return;
  274    }
  275 
  276    PRINTF(stream, ", ");
  277    print_src_reg(stream, GET_SRC1_REG(program[1], program[2]));
  278    if (args[opcode] == 2) {
  279       PRINTF(stream, "\n");
  280       return;
  281    }
  282 
  283    PRINTF(stream, ", ");
  284    print_src_reg(stream, GET_SRC2_REG(program[2]));
  285    PRINTF(stream, "\n");
  286    return;
  287 }
  288 
  289 
  290 static void
  291 print_tex_op(struct debug_stream *stream, 
  292          unsigned opcode, const unsigned * program)
  293 {
  294    print_dest_reg(stream, program[0] | A0_DEST_CHANNEL_ALL);
  295    PRINTF(stream, " = ");
  296 
  297    PRINTF(stream, "%s ", opcodes[opcode]);
  298 
  299    PRINTF(stream, "S[%d],", program[0] & T0_SAMPLER_NR_MASK);
  300 
  301    print_reg_type_nr(stream, 
  302              (program[1] >> T1_ADDRESS_REG_TYPE_SHIFT) &
  303                      REG_TYPE_MASK,
  304                      (program[1] >> T1_ADDRESS_REG_NR_SHIFT) & REG_NR_MASK);
  305    PRINTF(stream, "\n");
  306 }
  307 
  308 static void
  309 print_texkil_op(struct debug_stream *stream, 
  310                 unsigned opcode, const unsigned * program)
  311 {
  312    PRINTF(stream, "TEXKIL ");
  313 
  314    print_reg_type_nr(stream, 
  315              (program[1] >> T1_ADDRESS_REG_TYPE_SHIFT) &
  316                      REG_TYPE_MASK,
  317                      (program[1] >> T1_ADDRESS_REG_NR_SHIFT) & REG_NR_MASK);
  318    PRINTF(stream, "\n");
  319 }
  320 
  321 static void
  322 print_dcl_op(struct debug_stream *stream, 
  323          unsigned opcode, const unsigned * program)
  324 {
  325    PRINTF(stream, "%s ", opcodes[opcode]);
  326    print_dest_reg(stream, 
  327           program[0] | A0_DEST_CHANNEL_ALL);
  328    PRINTF(stream, "\n");
  329 }
  330 
  331 
  332 void
  333 i915_disassemble_program(struct debug_stream *stream, 
  334              const unsigned * program, unsigned sz)
  335 {
  336    unsigned i;
  337 
  338    PRINTF(stream, "\t\tBEGIN\n");
  339 
  340    assert((program[0] & 0x1ff) + 2 == sz);
  341 
  342    for (i = 1; i < sz; i += 3, program += 3) {
  343       unsigned opcode = program[0] & (0x1f << 24);
  344 
  345       PRINTF(stream, "\t\t");
  346 
  347       if ((int) opcode >= A0_NOP && opcode <= A0_SLT)
  348          print_arith_op(stream, opcode >> 24, program);
  349       else if (opcode >= T0_TEXLD && opcode < T0_TEXKILL)
  350          print_tex_op(stream, opcode >> 24, program);
  351       else if (opcode == T0_TEXKILL)
  352          print_texkil_op(stream, opcode >> 24, program);
  353       else if (opcode == D0_DCL)
  354          print_dcl_op(stream, opcode >> 24, program);
  355       else
  356          PRINTF(stream, "Unknown opcode 0x%x\n", opcode);
  357    }
  358 
  359    PRINTF(stream, "\t\tEND\n\n");
  360 }
  361 
  362