projects / mesa.git / blob
? search:


8df807cec883e189b226e110602874c60bcbdc54
[mesa.git] / src / gallium / drivers / llvmpipe / lp_state_fs.c
1 /**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.
4 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
14 *
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
17 * of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 *
27 **************************************************************************/
28
29 /**
30 * @file
31 * Code generate the whole fragment pipeline.
32 *
33 * The fragment pipeline consists of the following stages:
34 * - early depth test
35 * - fragment shader
36 * - alpha test
37 * - depth/stencil test
38 * - blending
39 *
40 * This file has only the glue to assemble the fragment pipeline. The actual
41 * plumbing of converting Gallium state into LLVM IR is done elsewhere, in the
42 * lp_bld_*.[ch] files, and in a complete generic and reusable way. Here we
43 * muster the LLVM JIT execution engine to create a function that follows an
44 * established binary interface and that can be called from C directly.
45 *
46 * A big source of complexity here is that we often want to run different
47 * stages with different precisions and data types and precisions. For example,
48 * the fragment shader needs typically to be done in floats, but the
49 * depth/stencil test and blending is better done in the type that most closely
50 * matches the depth/stencil and color buffer respectively.
51 *
52 * Since the width of a SIMD vector register stays the same regardless of the
53 * element type, different types imply different number of elements, so we must
54 * code generate more instances of the stages with larger types to be able to
55 * feed/consume the stages with smaller types.
56 *
57 * @author Jose Fonseca <jfonseca@vmware.com>
58 */
59
60 #include <limits.h>
61 #include "pipe/p_defines.h"
62 #include "util/u_inlines.h"
63 #include "util/u_memory.h"
64 #include "util/u_pointer.h"
65 #include "util/u_format.h"
66 #include "util/u_dump.h"
67 #include "util/u_string.h"
68 #include "util/u_simple_list.h"
69 #include "os/os_time.h"
70 #include "pipe/p_shader_tokens.h"
71 #include "draw/draw_context.h"
72 #include "tgsi/tgsi_dump.h"
73 #include "tgsi/tgsi_scan.h"
74 #include "tgsi/tgsi_parse.h"
75 #include "gallivm/lp_bld_type.h"
76 #include "gallivm/lp_bld_const.h"
77 #include "gallivm/lp_bld_conv.h"
78 #include "gallivm/lp_bld_init.h"
79 #include "gallivm/lp_bld_intr.h"
80 #include "gallivm/lp_bld_logic.h"
81 #include "gallivm/lp_bld_tgsi.h"
82 #include "gallivm/lp_bld_swizzle.h"
83 #include "gallivm/lp_bld_flow.h"
84 #include "gallivm/lp_bld_debug.h"
85
86 #include "lp_bld_alpha.h"
87 #include "lp_bld_blend.h"
88 #include "lp_bld_depth.h"
89 #include "lp_bld_interp.h"
90 #include "lp_context.h"
91 #include "lp_debug.h"
92 #include "lp_perf.h"
93 #include "lp_screen.h"
94 #include "lp_setup.h"
95 #include "lp_state.h"
96 #include "lp_tex_sample.h"
97 #include "lp_flush.h"
98 #include "lp_state_fs.h"
99
100
101 #include <llvm-c/Analysis.h>
102 #include <llvm-c/BitWriter.h>
103
104
105 static unsigned fs_no = 0;
106
107
108
109 /**
110 * Expand the relevent bits of mask_input to a 4-dword mask for the
111 * four pixels in a 2x2 quad. This will set the four elements of the
112 * quad mask vector to 0 or ~0.
113 *
114 * \param quad which quad of the quad group to test, in [0,3]
115 * \param mask_input bitwise mask for the whole 4x4 stamp
116 */
117 static LLVMValueRef
118 generate_quad_mask(LLVMBuilderRef builder,
119 struct lp_type fs_type,
120 unsigned quad,
121 LLVMValueRef mask_input) /* int32 */
122 {
123 struct lp_type mask_type;
124 LLVMTypeRef i32t = LLVMInt32Type();
125 LLVMValueRef bits[4];
126 LLVMValueRef mask;
127 int shift;
128
129 /*
130 * XXX: We'll need a different path for 16 x u8
131 */
132 assert(fs_type.width == 32);
133 assert(fs_type.length == 4);
134 mask_type = lp_int_type(fs_type);
135
136 /*
137 * mask_input >>= (quad * 4)
138 */
139
140 switch (quad) {
141 case 0:
142 shift = 0;
143 break;
144 case 1:
145 shift = 2;
146 break;
147 case 2:
148 shift = 8;
149 break;
150 case 3:
151 shift = 10;
152 break;
153 default:
154 assert(0);
155 shift = 0;
156 }
157
158 mask_input = LLVMBuildLShr(builder,
159 mask_input,
160 LLVMConstInt(i32t, shift, 0),
161 "");
162
163 /*
164 * mask = { mask_input & (1 << i), for i in [0,3] }
165 */
166
167 mask = lp_build_broadcast(builder, lp_build_vec_type(mask_type), mask_input);
168
169 bits[0] = LLVMConstInt(i32t, 1 << 0, 0);
170 bits[1] = LLVMConstInt(i32t, 1 << 1, 0);
171 bits[2] = LLVMConstInt(i32t, 1 << 4, 0);
172 bits[3] = LLVMConstInt(i32t, 1 << 5, 0);
173
174 mask = LLVMBuildAnd(builder, mask, LLVMConstVector(bits, 4), "");
175
176 /*
177 * mask = mask != 0 ? ~0 : 0
178 */
179
180 mask = lp_build_compare(builder,
181 mask_type, PIPE_FUNC_NOTEQUAL,
182 mask,
183 lp_build_const_int_vec(mask_type, 0));
184
185 return mask;
186 }
187
188
189 #define EARLY_DEPTH_TEST 0x1
190 #define LATE_DEPTH_TEST 0x2
191 #define EARLY_DEPTH_WRITE 0x4
192 #define LATE_DEPTH_WRITE 0x8
193
194 static int
195 find_output_by_semantic( const struct tgsi_shader_info *info,
196 unsigned semantic,
197 unsigned index )
198 {
199 int i;
200
201 for (i = 0; i < info->num_outputs; i++)
202 if (info->output_semantic_name[i] == semantic &&
203 info->output_semantic_index[i] == index)
204 return i;
205
206 return -1;
207 }
208
209
210 /**
211 * Generate the fragment shader, depth/stencil test, and alpha tests.
212 * \param i which quad in the tile, in range [0,3]
213 * \param partial_mask if 1, do mask_input testing
214 */
215 static void
216 generate_fs(struct llvmpipe_context *lp,
217 struct lp_fragment_shader *shader,
218 const struct lp_fragment_shader_variant_key *key,
219 LLVMBuilderRef builder,
220 struct lp_type type,
221 LLVMValueRef context_ptr,
222 unsigned i,
223 struct lp_build_interp_soa_context *interp,
224 struct lp_build_sampler_soa *sampler,
225 LLVMValueRef *pmask,
226 LLVMValueRef (*color)[4],
227 LLVMValueRef depth_ptr,
228 LLVMValueRef facing,
229 unsigned partial_mask,
230 LLVMValueRef mask_input,
231 LLVMValueRef counter)
232 {
233 const struct util_format_description *zs_format_desc = NULL;
234 const struct tgsi_token *tokens = shader->base.tokens;
235 LLVMTypeRef vec_type;
236 LLVMValueRef consts_ptr;
237 LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
238 LLVMValueRef z;
239 LLVMValueRef zs_value = NULL;
240 LLVMValueRef stencil_refs[2];
241 struct lp_build_mask_context mask;
242 boolean simple_shader = (shader->info.base.file_count[TGSI_FILE_SAMPLER] == 0 &&
243 shader->info.base.num_inputs < 3 &&
244 shader->info.base.num_instructions < 8);
245 unsigned attrib;
246 unsigned chan;
247 unsigned cbuf;
248 unsigned depth_mode;
249
250 if (key->depth.enabled ||
251 key->stencil[0].enabled ||
252 key->stencil[1].enabled) {
253
254 zs_format_desc = util_format_description(key->zsbuf_format);
255 assert(zs_format_desc);
256
257 if (!shader->info.base.writes_z) {
258 if (key->alpha.enabled || shader->info.base.uses_kill)
259 /* With alpha test and kill, can do the depth test early
260 * and hopefully eliminate some quads. But need to do a
261 * special deferred depth write once the final mask value
262 * is known.
263 */
264 depth_mode = EARLY_DEPTH_TEST | LATE_DEPTH_WRITE;
265 else
266 depth_mode = EARLY_DEPTH_TEST | EARLY_DEPTH_WRITE;
267 }
268 else {
269 depth_mode = LATE_DEPTH_TEST | LATE_DEPTH_WRITE;
270 }
271
272 if (!(key->depth.enabled && key->depth.writemask) &&
273 !(key->stencil[0].enabled && key->stencil[0].writemask))
274 depth_mode &= ~(LATE_DEPTH_WRITE | EARLY_DEPTH_WRITE);
275 }
276 else {
277 depth_mode = 0;
278 }
279
280 assert(i < 4);
281
282 stencil_refs[0] = lp_jit_context_stencil_ref_front_value(builder, context_ptr);
283 stencil_refs[1] = lp_jit_context_stencil_ref_back_value(builder, context_ptr);
284
285 vec_type = lp_build_vec_type(type);
286
287 consts_ptr = lp_jit_context_constants(builder, context_ptr);
288
289 memset(outputs, 0, sizeof outputs);
290
291 /* Declare the color and z variables */
292 for(cbuf = 0; cbuf < key->nr_cbufs; cbuf++) {
293 for(chan = 0; chan < NUM_CHANNELS; ++chan) {
294 color[cbuf][chan] = lp_build_alloca(builder, vec_type, "color");
295 }
296 }
297
298 /* do triangle edge testing */
299 if (partial_mask) {
300 *pmask = generate_quad_mask(builder, type,
301 i, mask_input);
302 }
303 else {
304 *pmask = lp_build_const_int_vec(type, ~0);
305 }
306
307 /* 'mask' will control execution based on quad's pixel alive/killed state */
308 lp_build_mask_begin(&mask, builder, type, *pmask);
309
310 if (!(depth_mode & EARLY_DEPTH_TEST) && !simple_shader)
311 lp_build_mask_check(&mask);
312
313 lp_build_interp_soa_update_pos(interp, i);
314 z = interp->pos[2];
315
316 if (depth_mode & EARLY_DEPTH_TEST) {
317 lp_build_depth_stencil_test(builder,
318 &key->depth,
319 key->stencil,
320 type,
321 zs_format_desc,
322 &mask,
323 stencil_refs,
324 z,
325 depth_ptr, facing,
326 &zs_value,
327 !simple_shader);
328
329 if (depth_mode & EARLY_DEPTH_WRITE) {
330 lp_build_depth_write(builder, zs_format_desc, depth_ptr, zs_value);
331 }
332 }
333
334 lp_build_interp_soa_update_inputs(interp, i);
335
336 /* Build the actual shader */
337 lp_build_tgsi_soa(builder, tokens, type, &mask,
338 consts_ptr, interp->pos, interp->inputs,
339 outputs, sampler, &shader->info.base);
340
341
342 /* Alpha test */
343 if (key->alpha.enabled) {
344 int color0 = find_output_by_semantic(&shader->info.base,
345 TGSI_SEMANTIC_COLOR,
346 0);
347
348 if (color0 != -1) {
349 LLVMValueRef alpha = LLVMBuildLoad(builder, outputs[color0][3], "alpha");
350 LLVMValueRef alpha_ref_value;
351
352 alpha_ref_value = lp_jit_context_alpha_ref_value(builder, context_ptr);
353 alpha_ref_value = lp_build_broadcast(builder, vec_type, alpha_ref_value);
354
355 lp_build_alpha_test(builder, key->alpha.func, type,
356 &mask, alpha, alpha_ref_value,
357 (depth_mode & LATE_DEPTH_TEST) != 0);
358 }
359 }
360
361 /* Late Z test */
362 if (depth_mode & LATE_DEPTH_TEST) {
363 int pos0 = find_output_by_semantic(&shader->info.base,
364 TGSI_SEMANTIC_POSITION,
365 0);
366
367 if (pos0 != -1) {
368 z = LLVMBuildLoad(builder, outputs[pos0][2], "z");
369 lp_build_name(z, "output%u.%u.%c", i, pos0, "xyzw"[chan]);
370 }
371
372 lp_build_depth_stencil_test(builder,
373 &key->depth,
374 key->stencil,
375 type,
376 zs_format_desc,
377 &mask,
378 stencil_refs,
379 z,
380 depth_ptr, facing,
381 &zs_value,
382 !simple_shader);
383 /* Late Z write */
384 if (depth_mode & LATE_DEPTH_WRITE) {
385 lp_build_depth_write(builder, zs_format_desc, depth_ptr, zs_value);
386 }
387 }
388 else if ((depth_mode & EARLY_DEPTH_TEST) &&
389 (depth_mode & LATE_DEPTH_WRITE))
390 {
391 /* Need to apply a reduced mask to the depth write. Reload the
392 * depth value, update from zs_value with the new mask value and
393 * write that out.
394 */
395 lp_build_deferred_depth_write(builder,
396 type,
397 zs_format_desc,
398 &mask,
399 depth_ptr,
400 zs_value);
401 }
402
403
404 /* Color write */
405 for (attrib = 0; attrib < shader->info.base.num_outputs; ++attrib)
406 {
407 if (shader->info.base.output_semantic_name[attrib] == TGSI_SEMANTIC_COLOR)
408 {
409 unsigned cbuf = shader->info.base.output_semantic_index[attrib];
410 for(chan = 0; chan < NUM_CHANNELS; ++chan) {
411 if(outputs[attrib][chan]) {
412 /* XXX: just initialize outputs to point at colors[] and
413 * skip this.
414 */
415 LLVMValueRef out = LLVMBuildLoad(builder, outputs[attrib][chan], "");
416 lp_build_name(out, "color%u.%u.%c", i, attrib, "rgba"[chan]);
417 LLVMBuildStore(builder, out, color[cbuf][chan]);
418 }
419 }
420 }
421 }
422
423 if (counter)
424 lp_build_occlusion_count(builder, type,
425 lp_build_mask_value(&mask), counter);
426
427 *pmask = lp_build_mask_end(&mask);
428 }
429
430
431 /**
432 * Generate color blending and color output.
433 * \param rt the render target index (to index blend, colormask state)
434 * \param type the pixel color type
435 * \param context_ptr pointer to the runtime JIT context
436 * \param mask execution mask (active fragment/pixel mask)
437 * \param src colors from the fragment shader
438 * \param dst_ptr the destination color buffer pointer
439 */
440 static void
441 generate_blend(const struct pipe_blend_state *blend,
442 unsigned rt,
443 LLVMBuilderRef builder,
444 struct lp_type type,
445 LLVMValueRef context_ptr,
446 LLVMValueRef mask,
447 LLVMValueRef *src,
448 LLVMValueRef dst_ptr,
449 boolean do_branch)
450 {
451 struct lp_build_context bld;
452 struct lp_build_mask_context mask_ctx;
453 LLVMTypeRef vec_type;
454 LLVMValueRef const_ptr;
455 LLVMValueRef con[4];
456 LLVMValueRef dst[4];
457 LLVMValueRef res[4];
458 unsigned chan;
459
460 lp_build_context_init(&bld, builder, type);
461
462 lp_build_mask_begin(&mask_ctx, builder, type, mask);
463 if (do_branch)
464 lp_build_mask_check(&mask_ctx);
465
466 vec_type = lp_build_vec_type(type);
467
468 const_ptr = lp_jit_context_blend_color(builder, context_ptr);
469 const_ptr = LLVMBuildBitCast(builder, const_ptr,
470 LLVMPointerType(vec_type, 0), "");
471
472 /* load constant blend color and colors from the dest color buffer */
473 for(chan = 0; chan < 4; ++chan) {
474 LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), chan, 0);
475 con[chan] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, const_ptr, &index, 1, ""), "");
476
477 dst[chan] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, dst_ptr, &index, 1, ""), "");
478
479 lp_build_name(con[chan], "con.%c", "rgba"[chan]);
480 lp_build_name(dst[chan], "dst.%c", "rgba"[chan]);
481 }
482
483 /* do blend */
484 lp_build_blend_soa(builder, blend, type, rt, src, dst, con, res);
485
486 /* store results to color buffer */
487 for(chan = 0; chan < 4; ++chan) {
488 if(blend->rt[rt].colormask & (1 << chan)) {
489 LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), chan, 0);
490 lp_build_name(res[chan], "res.%c", "rgba"[chan]);
491 res[chan] = lp_build_select(&bld, mask, res[chan], dst[chan]);
492 LLVMBuildStore(builder, res[chan], LLVMBuildGEP(builder, dst_ptr, &index, 1, ""));
493 }
494 }
495
496 lp_build_mask_end(&mask_ctx);
497 }
498
499
500 /**
501 * Generate the runtime callable function for the whole fragment pipeline.
502 * Note that the function which we generate operates on a block of 16
503 * pixels at at time. The block contains 2x2 quads. Each quad contains
504 * 2x2 pixels.
505 */
506 static void
507 generate_fragment(struct llvmpipe_context *lp,
508 struct lp_fragment_shader *shader,
509 struct lp_fragment_shader_variant *variant,
510 unsigned partial_mask)
511 {
512 struct llvmpipe_screen *screen = llvmpipe_screen(lp->pipe.screen);
513 const struct lp_fragment_shader_variant_key *key = &variant->key;
514 char func_name[256];
515 struct lp_type fs_type;
516 struct lp_type blend_type;
517 LLVMTypeRef fs_elem_type;
518 LLVMTypeRef fs_int_vec_type;
519 LLVMTypeRef blend_vec_type;
520 LLVMTypeRef arg_types[11];
521 LLVMTypeRef func_type;
522 LLVMValueRef context_ptr;
523 LLVMValueRef x;
524 LLVMValueRef y;
525 LLVMValueRef a0_ptr;
526 LLVMValueRef dadx_ptr;
527 LLVMValueRef dady_ptr;
528 LLVMValueRef color_ptr_ptr;
529 LLVMValueRef depth_ptr;
530 LLVMValueRef mask_input;
531 LLVMValueRef counter = NULL;
532 LLVMBasicBlockRef block;
533 LLVMBuilderRef builder;
534 struct lp_build_sampler_soa *sampler;
535 struct lp_build_interp_soa_context interp;
536 LLVMValueRef fs_mask[LP_MAX_VECTOR_LENGTH];
537 LLVMValueRef fs_out_color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS][LP_MAX_VECTOR_LENGTH];
538 LLVMValueRef blend_mask;
539 LLVMValueRef function;
540 LLVMValueRef facing;
541 const struct util_format_description *zs_format_desc;
542 unsigned num_fs;
543 unsigned i;
544 unsigned chan;
545 unsigned cbuf;
546
547
548 /* TODO: actually pick these based on the fs and color buffer
549 * characteristics. */
550
551 memset(&fs_type, 0, sizeof fs_type);
552 fs_type.floating = TRUE; /* floating point values */
553 fs_type.sign = TRUE; /* values are signed */
554 fs_type.norm = FALSE; /* values are not limited to [0,1] or [-1,1] */
555 fs_type.width = 32; /* 32-bit float */
556 fs_type.length = 4; /* 4 elements per vector */
557 num_fs = 4; /* number of quads per block */
558
559 memset(&blend_type, 0, sizeof blend_type);
560 blend_type.floating = FALSE; /* values are integers */
561 blend_type.sign = FALSE; /* values are unsigned */
562 blend_type.norm = TRUE; /* values are in [0,1] or [-1,1] */
563 blend_type.width = 8; /* 8-bit ubyte values */
564 blend_type.length = 16; /* 16 elements per vector */
565
566 /*
567 * Generate the function prototype. Any change here must be reflected in
568 * lp_jit.h's lp_jit_frag_func function pointer type, and vice-versa.
569 */
570
571 fs_elem_type = lp_build_elem_type(fs_type);
572 fs_int_vec_type = lp_build_int_vec_type(fs_type);
573
574 blend_vec_type = lp_build_vec_type(blend_type);
575
576 util_snprintf(func_name, sizeof(func_name), "fs%u_variant%u_%s",
577 shader->no, variant->no, partial_mask ? "partial" : "whole");
578
579 arg_types[0] = screen->context_ptr_type; /* context */
580 arg_types[1] = LLVMInt32Type(); /* x */
581 arg_types[2] = LLVMInt32Type(); /* y */
582 arg_types[3] = LLVMInt32Type(); /* facing */
583 arg_types[4] = LLVMPointerType(fs_elem_type, 0); /* a0 */
584 arg_types[5] = LLVMPointerType(fs_elem_type, 0); /* dadx */
585 arg_types[6] = LLVMPointerType(fs_elem_type, 0); /* dady */
586 arg_types[7] = LLVMPointerType(LLVMPointerType(blend_vec_type, 0), 0); /* color */
587 arg_types[8] = LLVMPointerType(LLVMInt8Type(), 0); /* depth */
588 arg_types[9] = LLVMInt32Type(); /* mask_input */
589 arg_types[10] = LLVMPointerType(LLVMInt32Type(), 0);/* counter */
590
591 func_type = LLVMFunctionType(LLVMVoidType(), arg_types, Elements(arg_types), 0);
592
593 function = LLVMAddFunction(screen->module, func_name, func_type);
594 LLVMSetFunctionCallConv(function, LLVMCCallConv);
595
596 variant->function[partial_mask] = function;
597
598
599 /* XXX: need to propagate noalias down into color param now we are
600 * passing a pointer-to-pointer?
601 */
602 for(i = 0; i < Elements(arg_types); ++i)
603 if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
604 LLVMAddAttribute(LLVMGetParam(function, i), LLVMNoAliasAttribute);
605
606 context_ptr = LLVMGetParam(function, 0);
607 x = LLVMGetParam(function, 1);
608 y = LLVMGetParam(function, 2);
609 facing = LLVMGetParam(function, 3);
610 a0_ptr = LLVMGetParam(function, 4);
611 dadx_ptr = LLVMGetParam(function, 5);
612 dady_ptr = LLVMGetParam(function, 6);
613 color_ptr_ptr = LLVMGetParam(function, 7);
614 depth_ptr = LLVMGetParam(function, 8);
615 mask_input = LLVMGetParam(function, 9);
616
617 lp_build_name(context_ptr, "context");
618 lp_build_name(x, "x");
619 lp_build_name(y, "y");
620 lp_build_name(a0_ptr, "a0");
621 lp_build_name(dadx_ptr, "dadx");
622 lp_build_name(dady_ptr, "dady");
623 lp_build_name(color_ptr_ptr, "color_ptr_ptr");
624 lp_build_name(depth_ptr, "depth");
625 lp_build_name(mask_input, "mask_input");
626
627 if (key->occlusion_count) {
628 counter = LLVMGetParam(function, 10);
629 lp_build_name(counter, "counter");
630 }
631
632 /*
633 * Function body
634 */
635
636 block = LLVMAppendBasicBlock(function, "entry");
637 builder = LLVMCreateBuilder();
638 LLVMPositionBuilderAtEnd(builder, block);
639
640 /*
641 * The shader input interpolation info is not explicitely baked in the
642 * shader key, but everything it derives from (TGSI, and flatshade) is
643 * already included in the shader key.
644 */
645 lp_build_interp_soa_init(&interp,
646 lp->num_inputs,
647 lp->inputs,
648 builder, fs_type,
649 a0_ptr, dadx_ptr, dady_ptr,
650 x, y);
651
652 /* code generated texture sampling */
653 sampler = lp_llvm_sampler_soa_create(key->sampler, context_ptr);
654
655 /* loop over quads in the block */
656 zs_format_desc = util_format_description(key->zsbuf_format);
657
658 for(i = 0; i < num_fs; ++i) {
659 LLVMValueRef depth_offset = LLVMConstInt(LLVMInt32Type(),
660 i*fs_type.length*zs_format_desc->block.bits/8,
661 0);
662 LLVMValueRef out_color[PIPE_MAX_COLOR_BUFS][NUM_CHANNELS];
663 LLVMValueRef depth_ptr_i;
664
665 depth_ptr_i = LLVMBuildGEP(builder, depth_ptr, &depth_offset, 1, "");
666
667 generate_fs(lp, shader, key,
668 builder,
669 fs_type,
670 context_ptr,
671 i,
672 &interp,
673 sampler,
674 &fs_mask[i], /* output */
675 out_color,
676 depth_ptr_i,
677 facing,
678 partial_mask,
679 mask_input,
680 counter);
681
682 for(cbuf = 0; cbuf < key->nr_cbufs; cbuf++)
683 for(chan = 0; chan < NUM_CHANNELS; ++chan)
684 fs_out_color[cbuf][chan][i] = out_color[cbuf][chan];
685 }
686
687 sampler->destroy(sampler);
688
689 /* Loop over color outputs / color buffers to do blending.
690 */
691 for(cbuf = 0; cbuf < key->nr_cbufs; cbuf++) {
692 LLVMValueRef color_ptr;
693 LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), cbuf, 0);
694 LLVMValueRef blend_in_color[NUM_CHANNELS];
695 unsigned rt;
696
697 /*
698 * Convert the fs's output color and mask to fit to the blending type.
699 */
700 for(chan = 0; chan < NUM_CHANNELS; ++chan) {
701 LLVMValueRef fs_color_vals[LP_MAX_VECTOR_LENGTH];
702
703 for (i = 0; i < num_fs; i++) {
704 fs_color_vals[i] =
705 LLVMBuildLoad(builder, fs_out_color[cbuf][chan][i], "fs_color_vals");
706 }
707
708 lp_build_conv(builder, fs_type, blend_type,
709 fs_color_vals,
710 num_fs,
711 &blend_in_color[chan], 1);
712
713 lp_build_name(blend_in_color[chan], "color%d.%c", cbuf, "rgba"[chan]);
714 }
715
716 if (partial_mask || !variant->opaque) {
717 lp_build_conv_mask(builder, fs_type, blend_type,
718 fs_mask, num_fs,
719 &blend_mask, 1);
720 } else {
721 blend_mask = lp_build_const_int_vec(blend_type, ~0);
722 }
723
724 color_ptr = LLVMBuildLoad(builder,
725 LLVMBuildGEP(builder, color_ptr_ptr, &index, 1, ""),
726 "");
727 lp_build_name(color_ptr, "color_ptr%d", cbuf);
728
729 /* which blend/colormask state to use */
730 rt = key->blend.independent_blend_enable ? cbuf : 0;
731
732 /*
733 * Blending.
734 */
735 {
736 /* Could the 4x4 have been killed?
737 */
738 boolean do_branch = ((key->depth.enabled || key->stencil[0].enabled) &&
739 !key->alpha.enabled &&
740 !shader->info.base.uses_kill);
741
742 generate_blend(&key->blend,
743 rt,
744 builder,
745 blend_type,
746 context_ptr,
747 blend_mask,
748 blend_in_color,
749 color_ptr,
750 do_branch);
751 }
752 }
753
754 #ifdef PIPE_ARCH_X86
755 /* Avoid corrupting the FPU stack on 32bit OSes. */
756 lp_build_intrinsic(builder, "llvm.x86.mmx.emms", LLVMVoidType(), NULL, 0);
757 #endif
758
759 LLVMBuildRetVoid(builder);
760
761 LLVMDisposeBuilder(builder);
762
763
764 /* Verify the LLVM IR. If invalid, dump and abort */
765 #ifdef DEBUG
766 if(LLVMVerifyFunction(function, LLVMPrintMessageAction)) {
767 if (1)
768 lp_debug_dump_value(function);
769 abort();
770 }
771 #endif
772
773 /* Apply optimizations to LLVM IR */
774 LLVMRunFunctionPassManager(screen->pass, function);
775
776 if ((gallivm_debug & GALLIVM_DEBUG_IR) || (LP_DEBUG & DEBUG_FS)) {
777 /* Print the LLVM IR to stderr */
778 lp_debug_dump_value(function);
779 debug_printf("\n");
780 }
781
782 /* Dump byte code to a file */
783 if (0) {
784 LLVMWriteBitcodeToFile(lp_build_module, "llvmpipe.bc");
785 }
786
787 /*
788 * Translate the LLVM IR into machine code.
789 */
790 {
791 void *f = LLVMGetPointerToGlobal(screen->engine, function);
792
793 variant->jit_function[partial_mask] = (lp_jit_frag_func)pointer_to_func(f);
794
795 if ((gallivm_debug & GALLIVM_DEBUG_ASM) || (LP_DEBUG & DEBUG_FS)) {
796 lp_disassemble(f);
797 }
798 lp_func_delete_body(function);
799 }
800 }
801
802
803 static void
804 dump_fs_variant_key(const struct lp_fragment_shader_variant_key *key)
805 {
806 unsigned i;
807
808 debug_printf("fs variant %p:\n", (void *) key);
809
810 if (key->flatshade) {
811 debug_printf("flatshade = 1\n");
812 }
813 for (i = 0; i < key->nr_cbufs; ++i) {
814 debug_printf("cbuf_format[%u] = %s\n", i, util_format_name(key->cbuf_format[i]));
815 }
816 if (key->depth.enabled) {
817 debug_printf("depth.format = %s\n", util_format_name(key->zsbuf_format));
818 debug_printf("depth.func = %s\n", util_dump_func(key->depth.func, TRUE));
819 debug_printf("depth.writemask = %u\n", key->depth.writemask);
820 }
821
822 for (i = 0; i < 2; ++i) {
823 if (key->stencil[i].enabled) {
824 debug_printf("stencil[%u].func = %s\n", i, util_dump_func(key->stencil[i].func, TRUE));
825 debug_printf("stencil[%u].fail_op = %s\n", i, util_dump_stencil_op(key->stencil[i].fail_op, TRUE));
826 debug_printf("stencil[%u].zpass_op = %s\n", i, util_dump_stencil_op(key->stencil[i].zpass_op, TRUE));
827 debug_printf("stencil[%u].zfail_op = %s\n", i, util_dump_stencil_op(key->stencil[i].zfail_op, TRUE));
828 debug_printf("stencil[%u].valuemask = 0x%x\n", i, key->stencil[i].valuemask);
829 debug_printf("stencil[%u].writemask = 0x%x\n", i, key->stencil[i].writemask);
830 }
831 }
832
833 if (key->alpha.enabled) {
834 debug_printf("alpha.func = %s\n", util_dump_func(key->alpha.func, TRUE));
835 }
836
837 if (key->occlusion_count) {
838 debug_printf("occlusion_count = 1\n");
839 }
840
841 if (key->blend.logicop_enable) {
842 debug_printf("blend.logicop_func = %s\n", util_dump_logicop(key->blend.logicop_func, TRUE));
843 }
844 else if (key->blend.rt[0].blend_enable) {
845 debug_printf("blend.rgb_func = %s\n", util_dump_blend_func (key->blend.rt[0].rgb_func, TRUE));
846 debug_printf("blend.rgb_src_factor = %s\n", util_dump_blend_factor(key->blend.rt[0].rgb_src_factor, TRUE));
847 debug_printf("blend.rgb_dst_factor = %s\n", util_dump_blend_factor(key->blend.rt[0].rgb_dst_factor, TRUE));
848 debug_printf("blend.alpha_func = %s\n", util_dump_blend_func (key->blend.rt[0].alpha_func, TRUE));
849 debug_printf("blend.alpha_src_factor = %s\n", util_dump_blend_factor(key->blend.rt[0].alpha_src_factor, TRUE));
850 debug_printf("blend.alpha_dst_factor = %s\n", util_dump_blend_factor(key->blend.rt[0].alpha_dst_factor, TRUE));
851 }
852 debug_printf("blend.colormask = 0x%x\n", key->blend.rt[0].colormask);
853 for (i = 0; i < key->nr_samplers; ++i) {
854 debug_printf("sampler[%u] = \n", i);
855 debug_printf(" .format = %s\n",
856 util_format_name(key->sampler[i].format));
857 debug_printf(" .target = %s\n",
858 util_dump_tex_target(key->sampler[i].target, TRUE));
859 debug_printf(" .pot = %u %u %u\n",
860 key->sampler[i].pot_width,
861 key->sampler[i].pot_height,
862 key->sampler[i].pot_depth);
863 debug_printf(" .wrap = %s %s %s\n",
864 util_dump_tex_wrap(key->sampler[i].wrap_s, TRUE),
865 util_dump_tex_wrap(key->sampler[i].wrap_t, TRUE),
866 util_dump_tex_wrap(key->sampler[i].wrap_r, TRUE));
867 debug_printf(" .min_img_filter = %s\n",
868 util_dump_tex_filter(key->sampler[i].min_img_filter, TRUE));
869 debug_printf(" .min_mip_filter = %s\n",
870 util_dump_tex_mipfilter(key->sampler[i].min_mip_filter, TRUE));
871 debug_printf(" .mag_img_filter = %s\n",
872 util_dump_tex_filter(key->sampler[i].mag_img_filter, TRUE));
873 if (key->sampler[i].compare_mode != PIPE_TEX_COMPARE_NONE)
874 debug_printf(" .compare_func = %s\n", util_dump_func(key->sampler[i].compare_func, TRUE));
875 debug_printf(" .normalized_coords = %u\n", key->sampler[i].normalized_coords);
876 debug_printf(" .min_max_lod_equal = %u\n", key->sampler[i].min_max_lod_equal);
877 debug_printf(" .lod_bias_non_zero = %u\n", key->sampler[i].lod_bias_non_zero);
878 debug_printf(" .apply_min_lod = %u\n", key->sampler[i].apply_min_lod);
879 debug_printf(" .apply_max_lod = %u\n", key->sampler[i].apply_max_lod);
880 }
881 }
882
883
884 void
885 lp_debug_fs_variant(const struct lp_fragment_shader_variant *variant)
886 {
887 debug_printf("llvmpipe: Fragment shader #%u variant #%u:\n",
888 variant->shader->no, variant->no);
889 tgsi_dump(variant->shader->base.tokens, 0);
890 dump_fs_variant_key(&variant->key);
891 debug_printf("variant->opaque = %u\n", variant->opaque);
892 debug_printf("\n");
893 }
894
895 static struct lp_fragment_shader_variant *
896 generate_variant(struct llvmpipe_context *lp,
897 struct lp_fragment_shader *shader,
898 const struct lp_fragment_shader_variant_key *key)
899 {
900 struct lp_fragment_shader_variant *variant;
901 boolean fullcolormask;
902
903 variant = CALLOC_STRUCT(lp_fragment_shader_variant);
904 if(!variant)
905 return NULL;
906
907 variant->shader = shader;
908 variant->list_item_global.base = variant;
909 variant->list_item_local.base = variant;
910 variant->no = shader->variants_created++;
911
912 memcpy(&variant->key, key, shader->variant_key_size);
913
914 /*
915 * Determine whether we are touching all channels in the color buffer.
916 */
917 fullcolormask = FALSE;
918 if (key->nr_cbufs == 1) {
919 const struct util_format_description *format_desc;
920 format_desc = util_format_description(key->cbuf_format[0]);
921 if ((~key->blend.rt[0].colormask &
922 util_format_colormask(format_desc)) == 0) {
923 fullcolormask = TRUE;
924 }
925 }
926
927 variant->opaque =
928 !key->blend.logicop_enable &&
929 !key->blend.rt[0].blend_enable &&
930 fullcolormask &&
931 !key->stencil[0].enabled &&
932 !key->alpha.enabled &&
933 !key->depth.enabled &&
934 !shader->info.base.uses_kill
935 ? TRUE : FALSE;
936
937
938 if ((LP_DEBUG & DEBUG_FS) || (gallivm_debug & GALLIVM_DEBUG_IR)) {
939 lp_debug_fs_variant(variant);
940 }
941
942 generate_fragment(lp, shader, variant, RAST_EDGE_TEST);
943
944 if (variant->opaque) {
945 /* Specialized shader, which doesn't need to read the color buffer. */
946 generate_fragment(lp, shader, variant, RAST_WHOLE);
947 } else {
948 variant->jit_function[RAST_WHOLE] = variant->jit_function[RAST_EDGE_TEST];
949 }
950
951 return variant;
952 }
953
954
955 static void *
956 llvmpipe_create_fs_state(struct pipe_context *pipe,
957 const struct pipe_shader_state *templ)
958 {
959 struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
960 struct lp_fragment_shader *shader;
961 int nr_samplers;
962
963 shader = CALLOC_STRUCT(lp_fragment_shader);
964 if (!shader)
965 return NULL;
966
967 shader->no = fs_no++;
968 make_empty_list(&shader->variants);
969
970 /* get/save the summary info for this shader */
971 lp_build_tgsi_info(templ->tokens, &shader->info);
972
973 /* we need to keep a local copy of the tokens */
974 shader->base.tokens = tgsi_dup_tokens(templ->tokens);
975
976 shader->draw_data = draw_create_fragment_shader(llvmpipe->draw, templ);
977 if (shader->draw_data == NULL) {
978 FREE((void *) shader->base.tokens);
979 FREE(shader);
980 return NULL;
981 }
982
983 nr_samplers = shader->info.base.file_max[TGSI_FILE_SAMPLER] + 1;
984
985 shader->variant_key_size = Offset(struct lp_fragment_shader_variant_key,
986 sampler[nr_samplers]);
987
988 if (LP_DEBUG & DEBUG_TGSI) {
989 unsigned attrib;
990 debug_printf("llvmpipe: Create fragment shader #%u %p:\n", shader->no, (void *) shader);
991 tgsi_dump(templ->tokens, 0);
992 debug_printf("usage masks:\n");
993 for (attrib = 0; attrib < shader->info.base.num_inputs; ++attrib) {
994 unsigned usage_mask = shader->info.base.input_usage_mask[attrib];
995 debug_printf(" IN[%u].%s%s%s%s\n",
996 attrib,
997 usage_mask & TGSI_WRITEMASK_X ? "x" : "",
998 usage_mask & TGSI_WRITEMASK_Y ? "y" : "",
999 usage_mask & TGSI_WRITEMASK_Z ? "z" : "",
1000 usage_mask & TGSI_WRITEMASK_W ? "w" : "");
1001 }
1002 debug_printf("\n");
1003 }
1004
1005 return shader;
1006 }
1007
1008
1009 static void
1010 llvmpipe_bind_fs_state(struct pipe_context *pipe, void *fs)
1011 {
1012 struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
1013
1014 if (llvmpipe->fs == fs)
1015 return;
1016
1017 draw_flush(llvmpipe->draw);
1018
1019 draw_bind_fragment_shader(llvmpipe->draw,
1020 (llvmpipe->fs ? llvmpipe->fs->draw_data : NULL));
1021
1022 llvmpipe->fs = fs;
1023
1024 llvmpipe->dirty |= LP_NEW_FS;
1025 }
1026
1027 static void
1028 remove_shader_variant(struct llvmpipe_context *lp,
1029 struct lp_fragment_shader_variant *variant)
1030 {
1031 struct llvmpipe_screen *screen = llvmpipe_screen(lp->pipe.screen);
1032 unsigned i;
1033
1034 if (gallivm_debug & GALLIVM_DEBUG_IR) {
1035 debug_printf("llvmpipe: del fs #%u var #%u v created #%u v cached #%u v total cached #%u\n",
1036 variant->shader->no, variant->no, variant->shader->variants_created,
1037 variant->shader->variants_cached, lp->nr_fs_variants);
1038 }
1039 for (i = 0; i < Elements(variant->function); i++) {
1040 if (variant->function[i]) {
1041 if (variant->jit_function[i])
1042 LLVMFreeMachineCodeForFunction(screen->engine,
1043 variant->function[i]);
1044 LLVMDeleteFunction(variant->function[i]);
1045 }
1046 }
1047 remove_from_list(&variant->list_item_local);
1048 variant->shader->variants_cached--;
1049 remove_from_list(&variant->list_item_global);
1050 lp->nr_fs_variants--;
1051 FREE(variant);
1052 }
1053
1054 static void
1055 llvmpipe_delete_fs_state(struct pipe_context *pipe, void *fs)
1056 {
1057 struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
1058 struct lp_fragment_shader *shader = fs;
1059 struct lp_fs_variant_list_item *li;
1060
1061 assert(fs != llvmpipe->fs);
1062 (void) llvmpipe;
1063
1064 /*
1065 * XXX: we need to flush the context until we have some sort of reference
1066 * counting in fragment shaders as they may still be binned
1067 * Flushing alone might not sufficient we need to wait on it too.
1068 */
1069
1070 llvmpipe_finish(pipe, __FUNCTION__);
1071
1072 li = first_elem(&shader->variants);
1073 while(!at_end(&shader->variants, li)) {
1074 struct lp_fs_variant_list_item *next = next_elem(li);
1075 remove_shader_variant(llvmpipe, li->base);
1076 li = next;
1077 }
1078
1079 draw_delete_fragment_shader(llvmpipe->draw, shader->draw_data);
1080
1081 assert(shader->variants_cached == 0);
1082 FREE((void *) shader->base.tokens);
1083 FREE(shader);
1084 }
1085
1086
1087
1088 static void
1089 llvmpipe_set_constant_buffer(struct pipe_context *pipe,
1090 uint shader, uint index,
1091 struct pipe_resource *constants)
1092 {
1093 struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
1094 unsigned size = constants ? constants->width0 : 0;
1095 const void *data = constants ? llvmpipe_resource_data(constants) : NULL;
1096
1097 assert(shader < PIPE_SHADER_TYPES);
1098 assert(index < PIPE_MAX_CONSTANT_BUFFERS);
1099
1100 if(llvmpipe->constants[shader][index] == constants)
1101 return;
1102
1103 draw_flush(llvmpipe->draw);
1104
1105 /* note: reference counting */
1106 pipe_resource_reference(&llvmpipe->constants[shader][index], constants);
1107
1108 if(shader == PIPE_SHADER_VERTEX ||
1109 shader == PIPE_SHADER_GEOMETRY) {
1110 draw_set_mapped_constant_buffer(llvmpipe->draw, shader,
1111 index, data, size);
1112 }
1113
1114 llvmpipe->dirty |= LP_NEW_CONSTANTS;
1115 }
1116
1117
1118 /**
1119 * Return the blend factor equivalent to a destination alpha of one.
1120 */
1121 static INLINE unsigned
1122 force_dst_alpha_one(unsigned factor)
1123 {
1124 switch(factor) {
1125 case PIPE_BLENDFACTOR_DST_ALPHA:
1126 return PIPE_BLENDFACTOR_ONE;
1127 case PIPE_BLENDFACTOR_INV_DST_ALPHA:
1128 return PIPE_BLENDFACTOR_ZERO;
1129 case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
1130 return PIPE_BLENDFACTOR_ZERO;
1131 }
1132
1133 return factor;
1134 }
1135
1136
1137 /**
1138 * We need to generate several variants of the fragment pipeline to match
1139 * all the combinations of the contributing state atoms.
1140 *
1141 * TODO: there is actually no reason to tie this to context state -- the
1142 * generated code could be cached globally in the screen.
1143 */
1144 static void
1145 make_variant_key(struct llvmpipe_context *lp,
1146 struct lp_fragment_shader *shader,
1147 struct lp_fragment_shader_variant_key *key)
1148 {
1149 unsigned i;
1150
1151 memset(key, 0, shader->variant_key_size);
1152
1153 if (lp->framebuffer.zsbuf) {
1154 if (lp->depth_stencil->depth.enabled) {
1155 key->zsbuf_format = lp->framebuffer.zsbuf->format;
1156 memcpy(&key->depth, &lp->depth_stencil->depth, sizeof key->depth);
1157 }
1158 if (lp->depth_stencil->stencil[0].enabled) {
1159 key->zsbuf_format = lp->framebuffer.zsbuf->format;
1160 memcpy(&key->stencil, &lp->depth_stencil->stencil, sizeof key->stencil);
1161 }
1162 }
1163
1164 key->alpha.enabled = lp->depth_stencil->alpha.enabled;
1165 if(key->alpha.enabled)
1166 key->alpha.func = lp->depth_stencil->alpha.func;
1167 /* alpha.ref_value is passed in jit_context */
1168
1169 key->flatshade = lp->rasterizer->flatshade;
1170 if (lp->active_query_count) {
1171 key->occlusion_count = TRUE;
1172 }
1173
1174 if (lp->framebuffer.nr_cbufs) {
1175 memcpy(&key->blend, lp->blend, sizeof key->blend);
1176 }
1177
1178 key->nr_cbufs = lp->framebuffer.nr_cbufs;
1179 for (i = 0; i < lp->framebuffer.nr_cbufs; i++) {
1180 enum pipe_format format = lp->framebuffer.cbufs[i]->format;
1181 struct pipe_rt_blend_state *blend_rt = &key->blend.rt[i];
1182 const struct util_format_description *format_desc;
1183
1184 key->cbuf_format[i] = format;
1185
1186 format_desc = util_format_description(format);
1187 assert(format_desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
1188 format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB);
1189
1190 blend_rt->colormask = lp->blend->rt[i].colormask;
1191
1192 /*
1193 * Mask out color channels not present in the color buffer.
1194 */
1195 blend_rt->colormask &= util_format_colormask(format_desc);
1196
1197 /*
1198 * Our swizzled render tiles always have an alpha channel, but the linear
1199 * render target format often does not, so force here the dst alpha to be
1200 * one.
1201 *
1202 * This is not a mere optimization. Wrong results will be produced if the
1203 * dst alpha is used, the dst format does not have alpha, and the previous
1204 * rendering was not flushed from the swizzled to linear buffer. For
1205 * example, NonPowTwo DCT.
1206 *
1207 * TODO: This should be generalized to all channels for better
1208 * performance, but only alpha causes correctness issues.
1209 *
1210 * Also, force rgb/alpha func/factors match, to make AoS blending easier.
1211 */
1212 if (format_desc->swizzle[3] > UTIL_FORMAT_SWIZZLE_W) {
1213 blend_rt->rgb_src_factor = force_dst_alpha_one(blend_rt->rgb_src_factor);
1214 blend_rt->rgb_dst_factor = force_dst_alpha_one(blend_rt->rgb_dst_factor);
1215 blend_rt->alpha_func = blend_rt->rgb_func;
1216 blend_rt->alpha_src_factor = blend_rt->rgb_src_factor;
1217 blend_rt->alpha_dst_factor = blend_rt->rgb_dst_factor;
1218 }
1219 }
1220
1221 /* This value will be the same for all the variants of a given shader:
1222 */
1223 key->nr_samplers = shader->info.base.file_max[TGSI_FILE_SAMPLER] + 1;
1224
1225 for(i = 0; i < key->nr_samplers; ++i) {
1226 if(shader->info.base.file_mask[TGSI_FILE_SAMPLER] & (1 << i)) {
1227 lp_sampler_static_state(&key->sampler[i],
1228 lp->fragment_sampler_views[i],
1229 lp->sampler[i]);
1230 }
1231 }
1232 }
1233
1234 /**
1235 * Update fragment state. This is called just prior to drawing
1236 * something when some fragment-related state has changed.
1237 */
1238 void
1239 llvmpipe_update_fs(struct llvmpipe_context *lp)
1240 {
1241 struct lp_fragment_shader *shader = lp->fs;
1242 struct lp_fragment_shader_variant_key key;
1243 struct lp_fragment_shader_variant *variant = NULL;
1244 struct lp_fs_variant_list_item *li;
1245
1246 make_variant_key(lp, shader, &key);
1247
1248 li = first_elem(&shader->variants);
1249 while(!at_end(&shader->variants, li)) {
1250 if(memcmp(&li->base->key, &key, shader->variant_key_size) == 0) {
1251 variant = li->base;
1252 break;
1253 }
1254 li = next_elem(li);
1255 }
1256
1257 if (variant) {
1258 move_to_head(&lp->fs_variants_list, &variant->list_item_global);
1259 }
1260 else {
1261 int64_t t0, t1;
1262 int64_t dt;
1263 unsigned i;
1264 if (lp->nr_fs_variants >= LP_MAX_SHADER_VARIANTS) {
1265 struct pipe_context *pipe = &lp->pipe;
1266
1267 /*
1268 * XXX: we need to flush the context until we have some sort of reference
1269 * counting in fragment shaders as they may still be binned
1270 * Flushing alone might not be sufficient we need to wait on it too.
1271 */
1272 llvmpipe_finish(pipe, __FUNCTION__);
1273
1274 for (i = 0; i < LP_MAX_SHADER_VARIANTS / 4; i++) {
1275 struct lp_fs_variant_list_item *item = last_elem(&lp->fs_variants_list);
1276 remove_shader_variant(lp, item->base);
1277 }
1278 }
1279 t0 = os_time_get();
1280
1281 variant = generate_variant(lp, shader, &key);
1282
1283 t1 = os_time_get();
1284 dt = t1 - t0;
1285 LP_COUNT_ADD(llvm_compile_time, dt);
1286 LP_COUNT_ADD(nr_llvm_compiles, 2); /* emit vs. omit in/out test */
1287
1288 if (variant) {
1289 insert_at_head(&shader->variants, &variant->list_item_local);
1290 insert_at_head(&lp->fs_variants_list, &variant->list_item_global);
1291 lp->nr_fs_variants++;
1292 shader->variants_cached++;
1293 }
1294 }
1295
1296 lp_setup_set_fs_variant(lp->setup, variant);
1297 }
1298
1299
1300
1301 void
1302 llvmpipe_init_fs_funcs(struct llvmpipe_context *llvmpipe)
1303 {
1304 llvmpipe->pipe.create_fs_state = llvmpipe_create_fs_state;
1305 llvmpipe->pipe.bind_fs_state = llvmpipe_bind_fs_state;
1306 llvmpipe->pipe.delete_fs_state = llvmpipe_delete_fs_state;
1307
1308 llvmpipe->pipe.set_constant_buffer = llvmpipe_set_constant_buffer;
1309 }