src/gallium/drivers/svga/svga_tgsi.c

   1 /**********************************************************
   2  * Copyright 2008-2009 VMware, Inc.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  **********************************************************/
  25
  26
  27 #include "pipe/p_compiler.h"
  28 #include "pipe/p_shader_tokens.h"
  29 #include "pipe/p_defines.h"
  30 #include "tgsi/tgsi_parse.h"
  31 #include "tgsi/tgsi_dump.h"
  32 #include "tgsi/tgsi_scan.h"
  33 #include "util/u_memory.h"
  34 #include "util/u_bitmask.h"
  35
  36 #include "svgadump/svga_shader_dump.h"
  37
  38 #include "svga_context.h"
  39 #include "svga_tgsi.h"
  40 #include "svga_tgsi_emit.h"
  41 #include "svga_debug.h"
  42
  43 #include "svga_hw_reg.h"
  44 #include "svga3d_shaderdefs.h"
  45
  46
  47 /* Sinkhole used only in error conditions.
  48  */
  49 static char err_buf[128];
  50
  51 #if 0
  52 static void svga_destroy_shader_emitter( struct svga_shader_emitter *emit )
  53 {
  54    if (emit->buf != err_buf)
  55       FREE(emit->buf);
  56 }
  57 #endif
  58
  59
  60 static boolean svga_shader_expand( struct svga_shader_emitter *emit )
  61 {
  62    char *new_buf;
  63    unsigned newsize = emit->size * 2;
  64
  65    if(emit->buf != err_buf)
  66       new_buf = REALLOC(emit->buf, emit->size, newsize);
  67    else
  68       new_buf = NULL;
  69
  70    if (new_buf == NULL) {
  71       emit->ptr = err_buf;
  72       emit->buf = err_buf;
  73       emit->size = sizeof(err_buf);
  74       return FALSE;
  75    }
  76
  77    emit->size = newsize;
  78    emit->ptr = new_buf + (emit->ptr - emit->buf);
  79    emit->buf = new_buf;
  80    return TRUE;
  81 }
  82
  83 static INLINE boolean reserve(  struct svga_shader_emitter *emit,
  84                                 unsigned nr_dwords )
  85 {
  86    if (emit->ptr - emit->buf + nr_dwords * sizeof(unsigned) >= emit->size) {
  87       if (!svga_shader_expand( emit ))
  88          return FALSE;
  89    }
  90
  91    return TRUE;
  92 }
  93
  94 boolean svga_shader_emit_dword( struct svga_shader_emitter *emit,
  95                                 unsigned dword )
  96 {
  97    if (!reserve(emit, 1))
  98       return FALSE;
  99
 100    *(unsigned *)emit->ptr = dword;
 101    emit->ptr += sizeof dword;
 102    return TRUE;
 103 }
 104
 105 boolean svga_shader_emit_dwords( struct svga_shader_emitter *emit,
 106                                  const unsigned *dwords,
 107                                  unsigned nr )
 108 {
 109    if (!reserve(emit, nr))
 110       return FALSE;
 111
 112    memcpy( emit->ptr, dwords, nr * sizeof *dwords );
 113    emit->ptr += nr * sizeof *dwords;
 114    return TRUE;
 115 }
 116
 117 boolean svga_shader_emit_opcode( struct svga_shader_emitter *emit,
 118                                  unsigned opcode )
 119 {
 120    SVGA3dShaderInstToken *here;
 121
 122    if (!reserve(emit, 1))
 123       return FALSE;
 124
 125    here = (SVGA3dShaderInstToken *)emit->ptr;
 126    here->value = opcode;
 127
 128    if (emit->insn_offset) {
 129       SVGA3dShaderInstToken *prev = (SVGA3dShaderInstToken *)(emit->buf +
 130                                                               emit->insn_offset);
 131       prev->size = (here - prev) - 1;
 132    }
 133
 134    emit->insn_offset = emit->ptr - emit->buf;
 135    emit->ptr += sizeof(unsigned);
 136    return TRUE;
 137 }
 138
 139
 140 static boolean svga_shader_emit_header( struct svga_shader_emitter *emit )
 141 {
 142    SVGA3dShaderVersion header;
 143
 144    memset( &header, 0, sizeof header );
 145
 146    switch (emit->unit) {
 147    case PIPE_SHADER_FRAGMENT:
 148       header.value = SVGA3D_PS_30;
 149       break;
 150    case PIPE_SHADER_VERTEX:
 151       header.value = SVGA3D_VS_30;
 152       break;
 153    }
 154
 155    return svga_shader_emit_dword( emit, header.value );
 156 }
 157
 158
 159
 160
 161
 162 /* Parse TGSI shader and translate to SVGA/DX9 serialized
 163  * representation.
 164  *
 165  * In this function SVGA shader is emitted to an in-memory buffer that
 166  * can be dynamically grown.  Once we've finished and know how large
 167  * it is, it will be copied to a hardware buffer for upload.
 168  */
 169 static struct svga_shader_result *
 170 svga_tgsi_translate( const struct svga_shader *shader,
 171                      union svga_compile_key key,
 172                      unsigned unit )
 173 {
 174    struct svga_shader_result *result = NULL;
 175    struct svga_shader_emitter emit;
 176
 177    memset(&emit, 0, sizeof(emit));
 178
 179    emit.size = 1024;
 180    emit.buf = MALLOC(emit.size);
 181    if (emit.buf == NULL) {
 182       goto fail;
 183    }
 184
 185    emit.ptr = emit.buf;
 186    emit.unit = unit;
 187    emit.key = key;
 188
 189    tgsi_scan_shader( shader->tokens, &emit.info);
 190
 191    emit.imm_start = emit.info.file_max[TGSI_FILE_CONSTANT] + 1;
 192
 193    if (unit == PIPE_SHADER_FRAGMENT)
 194       emit.imm_start += key.fkey.num_unnormalized_coords;
 195
 196    if (unit == PIPE_SHADER_VERTEX) {
 197       emit.imm_start += key.vkey.need_prescale ? 2 : 0;
 198       emit.imm_start += key.vkey.num_zero_stride_vertex_elements;
 199    }
 200
 201    emit.nr_hw_float_const = (emit.imm_start + emit.info.file_max[TGSI_FILE_IMMEDIATE] + 1);
 202
 203    emit.nr_hw_temp = emit.info.file_max[TGSI_FILE_TEMPORARY] + 1;
 204    emit.in_main_func = TRUE;
 205
 206    if (!svga_shader_emit_header( &emit ))
 207       goto fail;
 208
 209    if (!svga_shader_emit_instructions( &emit, shader->tokens ))
 210       goto fail;
 211
 212    result = CALLOC_STRUCT(svga_shader_result);
 213    if (result == NULL)
 214       goto fail;
 215
 216    result->shader = shader;
 217    result->tokens = (const unsigned *)emit.buf;
 218    result->nr_tokens = (emit.ptr - emit.buf) / sizeof(unsigned);
 219    memcpy(&result->key, &key, sizeof key);
 220    result->id = UTIL_BITMASK_INVALID_INDEX;
 221
 222    if (SVGA_DEBUG & DEBUG_TGSI)
 223    {
 224       debug_printf( "#####################################\n" );
 225       debug_printf( "Shader %u below\n", shader->id );
 226       tgsi_dump( shader->tokens, 0 );
 227       if (SVGA_DEBUG & DEBUG_TGSI) {
 228          debug_printf( "Shader %u compiled below\n", shader->id );
 229          svga_shader_dump( result->tokens,
 230                            result->nr_tokens ,
 231                            FALSE );
 232       }
 233       debug_printf( "#####################################\n" );
 234    }
 235
 236    return result;
 237
 238 fail:
 239    FREE(result);
 240    FREE(emit.buf);
 241    return NULL;
 242 }
 243
 244
 245
 246
 247 struct svga_shader_result *
 248 svga_translate_fragment_program( const struct svga_fragment_shader *fs,
 249                                  const struct svga_fs_compile_key *fkey )
 250 {
 251    union svga_compile_key key;
 252    memcpy(&key.fkey, fkey, sizeof *fkey);
 253
 254    return svga_tgsi_translate( &fs->base,
 255                                key,
 256                                PIPE_SHADER_FRAGMENT );
 257 }
 258
 259 struct svga_shader_result *
 260 svga_translate_vertex_program( const struct svga_vertex_shader *vs,
 261                                const struct svga_vs_compile_key *vkey )
 262 {
 263    union svga_compile_key key;
 264    memcpy(&key.vkey, vkey, sizeof *vkey);
 265
 266    return svga_tgsi_translate( &vs->base,
 267                                key,
 268                                PIPE_SHADER_VERTEX );
 269 }
 270
 271
 272 void svga_destroy_shader_result( struct svga_shader_result *result )
 273 {
 274    FREE((unsigned *)result->tokens);
 275    FREE(result);
 276 }
 277