1 /**********************************************************
2 * Copyright 2008-2009 VMware, Inc. All rights reserved.
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:
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
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
24 **********************************************************/
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_math.h"
34 #include "util/u_memory.h"
35 #include "util/u_bitmask.h"
37 #include "svgadump/svga_shader_dump.h"
39 #include "svga_context.h"
40 #include "svga_tgsi.h"
41 #include "svga_tgsi_emit.h"
42 #include "svga_debug.h"
44 #include "svga_hw_reg.h"
45 #include "svga3d_shaderdefs.h"
48 /* Sinkhole used only in error conditions.
50 static char err_buf
[128];
53 static void svga_destroy_shader_emitter( struct svga_shader_emitter
*emit
)
55 if (emit
->buf
!= err_buf
)
61 static boolean
svga_shader_expand( struct svga_shader_emitter
*emit
)
64 unsigned newsize
= emit
->size
* 2;
66 if(emit
->buf
!= err_buf
)
67 new_buf
= REALLOC(emit
->buf
, emit
->size
, newsize
);
71 if (new_buf
== NULL
) {
74 emit
->size
= sizeof(err_buf
);
79 emit
->ptr
= new_buf
+ (emit
->ptr
- emit
->buf
);
84 static INLINE boolean
reserve( struct svga_shader_emitter
*emit
,
87 if (emit
->ptr
- emit
->buf
+ nr_dwords
* sizeof(unsigned) >= emit
->size
) {
88 if (!svga_shader_expand( emit
))
95 boolean
svga_shader_emit_dword( struct svga_shader_emitter
*emit
,
98 if (!reserve(emit
, 1))
101 *(unsigned *)emit
->ptr
= dword
;
102 emit
->ptr
+= sizeof dword
;
106 boolean
svga_shader_emit_dwords( struct svga_shader_emitter
*emit
,
107 const unsigned *dwords
,
110 if (!reserve(emit
, nr
))
113 memcpy( emit
->ptr
, dwords
, nr
* sizeof *dwords
);
114 emit
->ptr
+= nr
* sizeof *dwords
;
118 boolean
svga_shader_emit_opcode( struct svga_shader_emitter
*emit
,
121 SVGA3dShaderInstToken
*here
;
123 if (!reserve(emit
, 1))
126 here
= (SVGA3dShaderInstToken
*)emit
->ptr
;
127 here
->value
= opcode
;
129 if (emit
->insn_offset
) {
130 SVGA3dShaderInstToken
*prev
= (SVGA3dShaderInstToken
*)(emit
->buf
+
132 prev
->size
= (here
- prev
) - 1;
135 emit
->insn_offset
= emit
->ptr
- emit
->buf
;
136 emit
->ptr
+= sizeof(unsigned);
141 static boolean
svga_shader_emit_header( struct svga_shader_emitter
*emit
)
143 SVGA3dShaderVersion header
;
145 memset( &header
, 0, sizeof header
);
147 switch (emit
->unit
) {
148 case PIPE_SHADER_FRAGMENT
:
149 header
.value
= SVGA3D_PS_30
;
151 case PIPE_SHADER_VERTEX
:
152 header
.value
= SVGA3D_VS_30
;
156 return svga_shader_emit_dword( emit
, header
.value
);
161 * Use the shader info to generate a bitmask indicating which generic
162 * inputs are used by the shader. A set bit indicates that GENERIC[i]
166 svga_get_generic_inputs_mask(const struct tgsi_shader_info
*info
)
168 unsigned i
, mask
= 0x0;
170 for (i
= 0; i
< info
->num_inputs
; i
++) {
171 if (info
->input_semantic_name
[i
] == TGSI_SEMANTIC_GENERIC
) {
172 unsigned j
= info
->input_semantic_index
[i
];
173 assert(j
< sizeof(mask
) * 8);
183 * Given a mask of used generic variables (as returned by the above functions)
184 * fill in a table which maps those indexes to small integers.
185 * This table is used by the remap_generic_index() function in
186 * svga_tgsi_decl_sm30.c
187 * Example: if generics_mask = binary(1010) it means that GENERIC[1] and
188 * GENERIC[3] are used. The remap_table will contain:
191 * The remaining table entries will be filled in with the next unused
192 * generic index (in this example, 2).
195 svga_remap_generics(unsigned generics_mask
,
196 int8_t remap_table
[MAX_GENERIC_VARYING
])
198 /* Note texcoord[0] is reserved so start at 1 */
199 unsigned count
= 1, i
;
201 for (i
= 0; i
< MAX_GENERIC_VARYING
; i
++) {
205 /* for each bit set in generic_mask */
206 while (generics_mask
) {
207 unsigned index
= ffs(generics_mask
) - 1;
208 remap_table
[index
] = count
++;
209 generics_mask
&= ~(1 << index
);
212 for (i
= 0; i
< MAX_GENERIC_VARYING
; i
++) {
213 if (remap_table
[i
] == -1)
214 remap_table
[i
] = count
;
220 * Use the generic remap table to map a TGSI generic varying variable
221 * index to a small integer.
224 svga_remap_generic_index(const int8_t remap_table
[MAX_GENERIC_VARYING
],
227 assert(generic_index
< MAX_GENERIC_VARYING
);
229 if (generic_index
>= MAX_GENERIC_VARYING
) {
230 /* just don't return a random/garbage value */
231 generic_index
= MAX_GENERIC_VARYING
- 1;
234 return remap_table
[generic_index
];
238 /* Parse TGSI shader and translate to SVGA/DX9 serialized
241 * In this function SVGA shader is emitted to an in-memory buffer that
242 * can be dynamically grown. Once we've finished and know how large
243 * it is, it will be copied to a hardware buffer for upload.
245 static struct svga_shader_result
*
246 svga_tgsi_translate( const struct svga_shader
*shader
,
247 struct svga_compile_key key
,
250 struct svga_shader_result
*result
= NULL
;
251 struct svga_shader_emitter emit
;
253 memset(&emit
, 0, sizeof(emit
));
256 emit
.buf
= MALLOC(emit
.size
);
257 if (emit
.buf
== NULL
) {
265 tgsi_scan_shader( shader
->tokens
, &emit
.info
);
267 emit
.imm_start
= emit
.info
.file_max
[TGSI_FILE_CONSTANT
] + 1;
269 if (unit
== PIPE_SHADER_FRAGMENT
)
270 emit
.imm_start
+= key
.fkey
.num_unnormalized_coords
;
272 if (unit
== PIPE_SHADER_VERTEX
) {
273 emit
.imm_start
+= key
.vkey
.need_prescale
? 2 : 0;
274 emit
.imm_start
+= key
.vkey
.num_zero_stride_vertex_elements
;
277 emit
.nr_hw_float_const
= (emit
.imm_start
+ emit
.info
.file_max
[TGSI_FILE_IMMEDIATE
] + 1);
279 emit
.nr_hw_temp
= emit
.info
.file_max
[TGSI_FILE_TEMPORARY
] + 1;
280 emit
.in_main_func
= TRUE
;
282 if (!svga_shader_emit_header( &emit
))
285 if (!svga_shader_emit_instructions( &emit
, shader
->tokens
))
288 result
= CALLOC_STRUCT(svga_shader_result
);
292 result
->shader
= shader
;
293 result
->tokens
= (const unsigned *)emit
.buf
;
294 result
->nr_tokens
= (emit
.ptr
- emit
.buf
) / sizeof(unsigned);
295 memcpy(&result
->key
, &key
, sizeof key
);
296 result
->id
= UTIL_BITMASK_INVALID_INDEX
;
298 if (SVGA_DEBUG
& DEBUG_TGSI
)
300 debug_printf( "#####################################\n" );
301 debug_printf( "Shader %u below\n", shader
->id
);
302 tgsi_dump( shader
->tokens
, 0 );
303 if (SVGA_DEBUG
& DEBUG_TGSI
) {
304 debug_printf( "Shader %u compiled below\n", shader
->id
);
305 svga_shader_dump( result
->tokens
,
309 debug_printf( "#####################################\n" );
323 struct svga_shader_result
*
324 svga_translate_fragment_program( const struct svga_fragment_shader
*fs
,
325 const struct svga_fs_compile_key
*fkey
)
327 struct svga_compile_key key
;
329 memcpy(&key
.fkey
, fkey
, sizeof *fkey
);
331 memcpy(key
.generic_remap_table
, fs
->generic_remap_table
,
332 sizeof(fs
->generic_remap_table
));
334 return svga_tgsi_translate( &fs
->base
,
336 PIPE_SHADER_FRAGMENT
);
339 struct svga_shader_result
*
340 svga_translate_vertex_program( const struct svga_vertex_shader
*vs
,
341 const struct svga_vs_compile_key
*vkey
)
343 struct svga_compile_key key
;
345 memcpy(&key
.vkey
, vkey
, sizeof *vkey
);
347 /* Note: we could alternately store the remap table in the vkey but
348 * that would make it larger. We just regenerate it here instead.
350 svga_remap_generics(vkey
->fs_generic_inputs
, key
.generic_remap_table
);
352 return svga_tgsi_translate( &vs
->base
,
354 PIPE_SHADER_VERTEX
);
358 void svga_destroy_shader_result( struct svga_shader_result
*result
)
360 FREE((unsigned *)result
->tokens
);