projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
util: use standard name for snprintf()
[mesa.git] / src / gallium / drivers / llvmpipe / lp_state_setup.c
1 /**************************************************************************
2 *
3 * Copyright 2010 VMware.
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 "util/u_math.h"
30 #include "util/u_memory.h"
31 #include "util/simple_list.h"
32 #include "util/os_time.h"
33 #include "gallivm/lp_bld_arit.h"
34 #include "gallivm/lp_bld_bitarit.h"
35 #include "gallivm/lp_bld_const.h"
36 #include "gallivm/lp_bld_debug.h"
37 #include "gallivm/lp_bld_init.h"
38 #include "gallivm/lp_bld_logic.h"
39 #include "gallivm/lp_bld_intr.h"
40 #include "gallivm/lp_bld_flow.h"
41 #include "gallivm/lp_bld_type.h"
42
43 #include "lp_perf.h"
44 #include "lp_debug.h"
45 #include "lp_flush.h"
46 #include "lp_screen.h"
47 #include "lp_context.h"
48 #include "lp_state.h"
49 #include "lp_state_fs.h"
50 #include "lp_state_setup.h"
51
52
53 /** Setup shader number (for debugging) */
54 static unsigned setup_no = 0;
55
56
57 /* currently organized to interpolate full float[4] attributes even
58 * when some elements are unused. Later, can pack vertex data more
59 * closely.
60 */
61
62
63 struct lp_setup_args
64 {
65 /* Function arguments:
66 */
67 LLVMValueRef v0;
68 LLVMValueRef v1;
69 LLVMValueRef v2;
70 LLVMValueRef facing; /* boolean */
71 LLVMValueRef a0;
72 LLVMValueRef dadx;
73 LLVMValueRef dady;
74
75 /* Derived:
76 */
77 LLVMValueRef x0_center;
78 LLVMValueRef y0_center;
79 LLVMValueRef dy20_ooa;
80 LLVMValueRef dy01_ooa;
81 LLVMValueRef dx20_ooa;
82 LLVMValueRef dx01_ooa;
83 struct lp_build_context bld;
84 };
85
86
87 static void
88 store_coef(struct gallivm_state *gallivm,
89 struct lp_setup_args *args,
90 unsigned slot,
91 LLVMValueRef a0,
92 LLVMValueRef dadx,
93 LLVMValueRef dady)
94 {
95 LLVMBuilderRef builder = gallivm->builder;
96 LLVMValueRef idx = lp_build_const_int32(gallivm, slot);
97
98 LLVMBuildStore(builder,
99 a0,
100 LLVMBuildGEP(builder, args->a0, &idx, 1, ""));
101
102 LLVMBuildStore(builder,
103 dadx,
104 LLVMBuildGEP(builder, args->dadx, &idx, 1, ""));
105
106 LLVMBuildStore(builder,
107 dady,
108 LLVMBuildGEP(builder, args->dady, &idx, 1, ""));
109 }
110
111
112
113 static void
114 emit_constant_coef4(struct gallivm_state *gallivm,
115 struct lp_setup_args *args,
116 unsigned slot,
117 LLVMValueRef vert)
118 {
119 store_coef(gallivm, args, slot, vert, args->bld.zero, args->bld.zero);
120 }
121
122
123
124 /**
125 * Setup the fragment input attribute with the front-facing value.
126 * \param frontface is the triangle front facing?
127 */
128 static void
129 emit_facing_coef(struct gallivm_state *gallivm,
130 struct lp_setup_args *args,
131 unsigned slot )
132 {
133 LLVMBuilderRef builder = gallivm->builder;
134 LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context);
135 LLVMValueRef a0_0 = args->facing;
136 LLVMValueRef a0_0f = LLVMBuildSIToFP(builder, a0_0, float_type, "");
137 LLVMValueRef a0, face_val;
138 const unsigned char swizzles[4] = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_0,
139 PIPE_SWIZZLE_0, PIPE_SWIZZLE_0 };
140 /* Our face val is either 1 or 0 so we do
141 * face = (val * 2) - 1
142 * to make it 1 or -1
143 */
144 face_val =
145 LLVMBuildFAdd(builder,
146 LLVMBuildFMul(builder, a0_0f,
147 lp_build_const_float(gallivm, 2.0),
148 ""),
149 lp_build_const_float(gallivm, -1.0),
150 "facing");
151 face_val = lp_build_broadcast_scalar(&args->bld, face_val);
152 a0 = lp_build_swizzle_aos(&args->bld, face_val, swizzles);
153
154 store_coef(gallivm, args, slot, a0, args->bld.zero, args->bld.zero);
155 }
156
157
158 static LLVMValueRef
159 vert_attrib(struct gallivm_state *gallivm,
160 LLVMValueRef vert,
161 int attr,
162 int elem,
163 const char *name)
164 {
165 LLVMBuilderRef b = gallivm->builder;
166 LLVMValueRef idx[2];
167 idx[0] = lp_build_const_int32(gallivm, attr);
168 idx[1] = lp_build_const_int32(gallivm, elem);
169 return LLVMBuildLoad(b, LLVMBuildGEP(b, vert, idx, 2, ""), name);
170 }
171
172
173 static void
174 lp_twoside(struct gallivm_state *gallivm,
175 struct lp_setup_args *args,
176 const struct lp_setup_variant_key *key,
177 int bcolor_slot,
178 LLVMValueRef attribv[3])
179 {
180 LLVMBuilderRef b = gallivm->builder;
181 LLVMValueRef a0_back, a1_back, a2_back;
182 LLVMValueRef idx2 = lp_build_const_int32(gallivm, bcolor_slot);
183
184 LLVMValueRef facing = args->facing;
185 LLVMValueRef front_facing = LLVMBuildICmp(b, LLVMIntEQ, facing,
186 lp_build_const_int32(gallivm, 0), ""); /** need i1 for if condition */
187
188 a0_back = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v0, &idx2, 1, ""), "v0a_back");
189 a1_back = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v1, &idx2, 1, ""), "v1a_back");
190 a2_back = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v2, &idx2, 1, ""), "v2a_back");
191
192 /* Possibly swap the front and back attrib values,
193 *
194 * Prefer select to if so we don't have to worry about phis or
195 * allocas.
196 */
197 attribv[0] = LLVMBuildSelect(b, front_facing, a0_back, attribv[0], "");
198 attribv[1] = LLVMBuildSelect(b, front_facing, a1_back, attribv[1], "");
199 attribv[2] = LLVMBuildSelect(b, front_facing, a2_back, attribv[2], "");
200
201 }
202
203 static void
204 lp_do_offset_tri(struct gallivm_state *gallivm,
205 struct lp_setup_args *args,
206 const struct lp_setup_variant_key *key,
207 LLVMValueRef inv_det,
208 LLVMValueRef dxyz01,
209 LLVMValueRef dxyz20,
210 LLVMValueRef attribv[3])
211 {
212 LLVMBuilderRef b = gallivm->builder;
213 struct lp_build_context flt_scalar_bld;
214 struct lp_build_context int_scalar_bld;
215 struct lp_build_context *bld = &args->bld;
216 LLVMValueRef zoffset, mult;
217 LLVMValueRef z0_new, z1_new, z2_new;
218 LLVMValueRef dzdxdzdy, dzdx, dzdy, dzxyz20, dyzzx01, dyzzx01_dzxyz20, dzx01_dyz20;
219 LLVMValueRef z0z1, z0z1z2;
220 LLVMValueRef max, max_value, res12;
221 LLVMValueRef shuffles[4];
222 LLVMTypeRef shuf_type = LLVMInt32TypeInContext(gallivm->context);
223 LLVMValueRef onei = lp_build_const_int32(gallivm, 1);
224 LLVMValueRef zeroi = lp_build_const_int32(gallivm, 0);
225 LLVMValueRef twoi = lp_build_const_int32(gallivm, 2);
226 LLVMValueRef threei = lp_build_const_int32(gallivm, 3);
227
228 /* (res12) = cross(e,f).xy */
229 shuffles[0] = twoi;
230 shuffles[1] = zeroi;
231 shuffles[2] = onei;
232 shuffles[3] = twoi;
233 dzxyz20 = LLVMBuildShuffleVector(b, dxyz20, dxyz20, LLVMConstVector(shuffles, 4), "");
234
235 shuffles[0] = onei;
236 shuffles[1] = twoi;
237 shuffles[2] = twoi;
238 shuffles[3] = zeroi;
239 dyzzx01 = LLVMBuildShuffleVector(b, dxyz01, dxyz01, LLVMConstVector(shuffles, 4), "");
240
241 dyzzx01_dzxyz20 = LLVMBuildFMul(b, dzxyz20, dyzzx01, "dyzzx01_dzxyz20");
242
243 shuffles[0] = twoi;
244 shuffles[1] = threei;
245 shuffles[2] = LLVMGetUndef(shuf_type);
246 shuffles[3] = LLVMGetUndef(shuf_type);
247 dzx01_dyz20 = LLVMBuildShuffleVector(b, dyzzx01_dzxyz20, dyzzx01_dzxyz20,
248 LLVMConstVector(shuffles, 4), "");
249
250 res12 = LLVMBuildFSub(b, dyzzx01_dzxyz20, dzx01_dyz20, "res12");
251
252 /* dzdx = fabsf(res1 * inv_det), dydx = fabsf(res2 * inv_det)*/
253 dzdxdzdy = LLVMBuildFMul(b, res12, inv_det, "dzdxdzdy");
254 dzdxdzdy = lp_build_abs(bld, dzdxdzdy);
255
256 dzdx = LLVMBuildExtractElement(b, dzdxdzdy, zeroi, "");
257 dzdy = LLVMBuildExtractElement(b, dzdxdzdy, onei, "");
258
259 /* mult = MAX2(dzdx, dzdy) * pgon_offset_scale */
260 max = LLVMBuildFCmp(b, LLVMRealUGT, dzdx, dzdy, "");
261 max_value = LLVMBuildSelect(b, max, dzdx, dzdy, "max");
262
263 mult = LLVMBuildFMul(b, max_value,
264 lp_build_const_float(gallivm, key->pgon_offset_scale), "");
265
266 lp_build_context_init(&flt_scalar_bld, gallivm, lp_type_float_vec(32, 32));
267
268 if (key->floating_point_depth) {
269 /*
270 * bias = pgon_offset_units * 2^(exponent(max(z0, z1, z2)) - mantissa_bits) +
271 * MAX2(dzdx, dzdy) * pgon_offset_scale
272 *
273 * NOTE: Assumes IEEE float32.
274 */
275 LLVMValueRef c23_shifted, exp_mask, bias, exp;
276 LLVMValueRef maxz_value, maxz0z1_value;
277
278 lp_build_context_init(&int_scalar_bld, gallivm, lp_type_int_vec(32, 32));
279
280 c23_shifted = lp_build_const_int32(gallivm, 23 << 23);
281 exp_mask = lp_build_const_int32(gallivm, 0xff << 23);
282
283 maxz0z1_value = lp_build_max(&flt_scalar_bld,
284 LLVMBuildExtractElement(b, attribv[0], twoi, ""),
285 LLVMBuildExtractElement(b, attribv[1], twoi, ""));
286
287 maxz_value = lp_build_max(&flt_scalar_bld,
288 LLVMBuildExtractElement(b, attribv[2], twoi, ""),
289 maxz0z1_value);
290
291 exp = LLVMBuildBitCast(b, maxz_value, int_scalar_bld.vec_type, "");
292 exp = lp_build_and(&int_scalar_bld, exp, exp_mask);
293 exp = lp_build_sub(&int_scalar_bld, exp, c23_shifted);
294 /* Clamping to zero means mrd will be zero for very small numbers,
295 * but specs do not indicate this should be prevented by clamping
296 * mrd to smallest normal number instead. */
297 exp = lp_build_max(&int_scalar_bld, exp, int_scalar_bld.zero);
298 exp = LLVMBuildBitCast(b, exp, flt_scalar_bld.vec_type, "");
299
300 bias = LLVMBuildFMul(b, exp,
301 lp_build_const_float(gallivm, key->pgon_offset_units),
302 "bias");
303
304 zoffset = LLVMBuildFAdd(b, bias, mult, "zoffset");
305 } else {
306 /*
307 * bias = pgon_offset_units + MAX2(dzdx, dzdy) * pgon_offset_scale
308 */
309 zoffset = LLVMBuildFAdd(b,
310 lp_build_const_float(gallivm, key->pgon_offset_units),
311 mult, "zoffset");
312 }
313
314 if (key->pgon_offset_clamp > 0) {
315 zoffset = lp_build_min(&flt_scalar_bld,
316 lp_build_const_float(gallivm, key->pgon_offset_clamp),
317 zoffset);
318 }
319 else if (key->pgon_offset_clamp < 0) {
320 zoffset = lp_build_max(&flt_scalar_bld,
321 lp_build_const_float(gallivm, key->pgon_offset_clamp),
322 zoffset);
323 }
324
325 /* yuck */
326 shuffles[0] = twoi;
327 shuffles[1] = lp_build_const_int32(gallivm, 6);
328 shuffles[2] = LLVMGetUndef(shuf_type);
329 shuffles[3] = LLVMGetUndef(shuf_type);
330 z0z1 = LLVMBuildShuffleVector(b, attribv[0], attribv[1], LLVMConstVector(shuffles, 4), "");
331 shuffles[0] = zeroi;
332 shuffles[1] = onei;
333 shuffles[2] = lp_build_const_int32(gallivm, 6);
334 shuffles[3] = LLVMGetUndef(shuf_type);
335 z0z1z2 = LLVMBuildShuffleVector(b, z0z1, attribv[2], LLVMConstVector(shuffles, 4), "");
336 zoffset = lp_build_broadcast_scalar(bld, zoffset);
337
338 /* clamp and do offset */
339 /*
340 * FIXME I suspect the clamp (is that even right to always clamp to fixed
341 * 0.0/1.0?) should really be per fragment?
342 */
343 z0z1z2 = lp_build_clamp(bld, LLVMBuildFAdd(b, z0z1z2, zoffset, ""), bld->zero, bld->one);
344
345 /* insert into args->a0.z, a1.z, a2.z:
346 */
347 z0_new = LLVMBuildExtractElement(b, z0z1z2, zeroi, "");
348 z1_new = LLVMBuildExtractElement(b, z0z1z2, onei, "");
349 z2_new = LLVMBuildExtractElement(b, z0z1z2, twoi, "");
350 attribv[0] = LLVMBuildInsertElement(b, attribv[0], z0_new, twoi, "");
351 attribv[1] = LLVMBuildInsertElement(b, attribv[1], z1_new, twoi, "");
352 attribv[2] = LLVMBuildInsertElement(b, attribv[2], z2_new, twoi, "");
353 }
354
355 static void
356 load_attribute(struct gallivm_state *gallivm,
357 struct lp_setup_args *args,
358 const struct lp_setup_variant_key *key,
359 unsigned vert_attr,
360 LLVMValueRef attribv[3])
361 {
362 LLVMBuilderRef b = gallivm->builder;
363 LLVMValueRef idx = lp_build_const_int32(gallivm, vert_attr);
364
365 /* Load the vertex data
366 */
367 attribv[0] = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v0, &idx, 1, ""), "v0a");
368 attribv[1] = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v1, &idx, 1, ""), "v1a");
369 attribv[2] = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v2, &idx, 1, ""), "v2a");
370
371
372 /* Potentially modify it according to twoside, etc:
373 */
374 if (key->twoside) {
375 if (vert_attr == key->color_slot && key->bcolor_slot >= 0)
376 lp_twoside(gallivm, args, key, key->bcolor_slot, attribv);
377 else if (vert_attr == key->spec_slot && key->bspec_slot >= 0)
378 lp_twoside(gallivm, args, key, key->bspec_slot, attribv);
379 }
380 }
381
382 /*
383 * FIXME: interpolation is always done wrt fb origin (0/0).
384 * However, if some (small) tri is far away from the origin and gradients
385 * are large, this can lead to HUGE errors, since the a0 value calculated
386 * here can get very large (with the actual values inside the triangle way
387 * smaller), leading to complete loss of accuracy. This could be prevented
388 * by using some point inside (or at corner) of the tri as interpolation
389 * origin, or just use barycentric interpolation (which GL suggests and is
390 * what real hw does - you can get the barycentric coordinates from the
391 * edge functions in rasterization in principle (though we skip these
392 * sometimes completely in case of tris covering a block fully,
393 * which obviously wouldn't work)).
394 */
395 static void
396 emit_coef4( struct gallivm_state *gallivm,
397 struct lp_setup_args *args,
398 unsigned slot,
399 LLVMValueRef a0,
400 LLVMValueRef a1,
401 LLVMValueRef a2)
402 {
403 LLVMBuilderRef b = gallivm->builder;
404 LLVMValueRef attr_0;
405 LLVMValueRef dy20_ooa = args->dy20_ooa;
406 LLVMValueRef dy01_ooa = args->dy01_ooa;
407 LLVMValueRef dx20_ooa = args->dx20_ooa;
408 LLVMValueRef dx01_ooa = args->dx01_ooa;
409 LLVMValueRef x0_center = args->x0_center;
410 LLVMValueRef y0_center = args->y0_center;
411 LLVMValueRef da01 = LLVMBuildFSub(b, a0, a1, "da01");
412 LLVMValueRef da20 = LLVMBuildFSub(b, a2, a0, "da20");
413
414 /* Calculate dadx (vec4f)
415 */
416 LLVMValueRef da01_dy20_ooa = LLVMBuildFMul(b, da01, dy20_ooa, "da01_dy20_ooa");
417 LLVMValueRef da20_dy01_ooa = LLVMBuildFMul(b, da20, dy01_ooa, "da20_dy01_ooa");
418 LLVMValueRef dadx = LLVMBuildFSub(b, da01_dy20_ooa, da20_dy01_ooa, "dadx");
419
420 /* Calculate dady (vec4f)
421 */
422 LLVMValueRef da01_dx20_ooa = LLVMBuildFMul(b, da01, dx20_ooa, "da01_dx20_ooa");
423 LLVMValueRef da20_dx01_ooa = LLVMBuildFMul(b, da20, dx01_ooa, "da20_dx01_ooa");
424 LLVMValueRef dady = LLVMBuildFSub(b, da20_dx01_ooa, da01_dx20_ooa, "dady");
425
426 /* Calculate a0 - the attribute value at the origin
427 */
428 LLVMValueRef dadx_x0 = LLVMBuildFMul(b, dadx, x0_center, "dadx_x0");
429 LLVMValueRef dady_y0 = LLVMBuildFMul(b, dady, y0_center, "dady_y0");
430 LLVMValueRef attr_v0 = LLVMBuildFAdd(b, dadx_x0, dady_y0, "attr_v0");
431 attr_0 = LLVMBuildFSub(b, a0, attr_v0, "attr_0");
432
433 store_coef(gallivm, args, slot, attr_0, dadx, dady);
434 }
435
436
437 static void
438 emit_linear_coef( struct gallivm_state *gallivm,
439 struct lp_setup_args *args,
440 unsigned slot,
441 LLVMValueRef attribv[3])
442 {
443 /* nothing to do anymore */
444 emit_coef4(gallivm,
445 args, slot,
446 attribv[0],
447 attribv[1],
448 attribv[2]);
449 }
450
451
452 /**
453 * Compute a0, dadx and dady for a perspective-corrected interpolant,
454 * for a triangle.
455 * We basically multiply the vertex value by 1/w before computing
456 * the plane coefficients (a0, dadx, dady).
457 * Later, when we compute the value at a particular fragment position we'll
458 * divide the interpolated value by the interpolated W at that fragment.
459 */
460 static void
461 apply_perspective_corr( struct gallivm_state *gallivm,
462 struct lp_setup_args *args,
463 unsigned slot,
464 LLVMValueRef attribv[3])
465 {
466 LLVMBuilderRef b = gallivm->builder;
467
468 /* premultiply by 1/w (v[0][3] is always 1/w):
469 */
470 LLVMValueRef v0_oow = lp_build_broadcast_scalar(&args->bld,
471 vert_attrib(gallivm, args->v0, 0, 3, "v0_oow"));
472 LLVMValueRef v1_oow = lp_build_broadcast_scalar(&args->bld,
473 vert_attrib(gallivm, args->v1, 0, 3, "v1_oow"));
474 LLVMValueRef v2_oow = lp_build_broadcast_scalar(&args->bld,
475 vert_attrib(gallivm, args->v2, 0, 3, "v2_oow"));
476
477 attribv[0] = LLVMBuildFMul(b, attribv[0], v0_oow, "v0_oow_v0a");
478 attribv[1] = LLVMBuildFMul(b, attribv[1], v1_oow, "v1_oow_v1a");
479 attribv[2] = LLVMBuildFMul(b, attribv[2], v2_oow, "v2_oow_v2a");
480 }
481
482
483 /**
484 * Applys cylindrical wrapping to vertex attributes if enabled.
485 * Input coordinates must be in [0, 1] range, otherwise results are undefined.
486 *
487 * @param cyl_wrap TGSI_CYLINDRICAL_WRAP_x flags
488 */
489 static void
490 emit_apply_cyl_wrap(struct gallivm_state *gallivm,
491 struct lp_setup_args *args,
492 uint cyl_wrap,
493 LLVMValueRef attribv[3])
494
495 {
496 LLVMBuilderRef builder = gallivm->builder;
497 struct lp_type type = args->bld.type;
498 LLVMTypeRef float_vec_type = args->bld.vec_type;
499 LLVMValueRef pos_half;
500 LLVMValueRef neg_half;
501 LLVMValueRef cyl_mask;
502 LLVMValueRef offset;
503 LLVMValueRef delta;
504 LLVMValueRef one;
505
506 if (!cyl_wrap)
507 return;
508
509 /* Constants */
510 pos_half = lp_build_const_vec(gallivm, type, +0.5f);
511 neg_half = lp_build_const_vec(gallivm, type, -0.5f);
512 cyl_mask = lp_build_const_mask_aos(gallivm, type, cyl_wrap, 4);
513
514 one = lp_build_const_vec(gallivm, type, 1.0f);
515 one = LLVMBuildBitCast(builder, one, lp_build_int_vec_type(gallivm, type), "");
516 one = LLVMBuildAnd(builder, one, cyl_mask, "");
517
518 /* Edge v0 -> v1 */
519 delta = LLVMBuildFSub(builder, attribv[1], attribv[0], "");
520
521 offset = lp_build_compare(gallivm, type, PIPE_FUNC_GREATER, delta, pos_half);
522 offset = LLVMBuildAnd(builder, offset, one, "");
523 offset = LLVMBuildBitCast(builder, offset, float_vec_type, "");
524 attribv[0] = LLVMBuildFAdd(builder, attribv[0], offset, "");
525
526 offset = lp_build_compare(gallivm, type, PIPE_FUNC_LESS, delta, neg_half);
527 offset = LLVMBuildAnd(builder, offset, one, "");
528 offset = LLVMBuildBitCast(builder, offset, float_vec_type, "");
529 attribv[1] = LLVMBuildFAdd(builder, attribv[1], offset, "");
530
531 /* Edge v1 -> v2 */
532 delta = LLVMBuildFSub(builder, attribv[2], attribv[1], "");
533
534 offset = lp_build_compare(gallivm, type, PIPE_FUNC_GREATER, delta, pos_half);
535 offset = LLVMBuildAnd(builder, offset, one, "");
536 offset = LLVMBuildBitCast(builder, offset, float_vec_type, "");
537 attribv[1] = LLVMBuildFAdd(builder, attribv[1], offset, "");
538
539 offset = lp_build_compare(gallivm, type, PIPE_FUNC_LESS, delta, neg_half);
540 offset = LLVMBuildAnd(builder, offset, one, "");
541 offset = LLVMBuildBitCast(builder, offset, float_vec_type, "");
542 attribv[2] = LLVMBuildFAdd(builder, attribv[2], offset, "");
543
544 /* Edge v2 -> v0 */
545 delta = LLVMBuildFSub(builder, attribv[0], attribv[2], "");
546
547 offset = lp_build_compare(gallivm, type, PIPE_FUNC_GREATER, delta, pos_half);
548 offset = LLVMBuildAnd(builder, offset, one, "");
549 offset = LLVMBuildBitCast(builder, offset, float_vec_type, "");
550 attribv[2] = LLVMBuildFAdd(builder, attribv[2], offset, "");
551
552 offset = lp_build_compare(gallivm, type, PIPE_FUNC_LESS, delta, neg_half);
553 offset = LLVMBuildAnd(builder, offset, one, "");
554 offset = LLVMBuildBitCast(builder, offset, float_vec_type, "");
555 attribv[0] = LLVMBuildFAdd(builder, attribv[0], offset, "");
556 }
557
558
559 /**
560 * Compute the inputs-> dadx, dady, a0 values.
561 */
562 static void
563 emit_tri_coef( struct gallivm_state *gallivm,
564 const struct lp_setup_variant_key *key,
565 struct lp_setup_args *args)
566 {
567 unsigned slot;
568
569 LLVMValueRef attribs[3];
570
571 /* setup interpolation for all the remaining attributes:
572 */
573 for (slot = 0; slot < key->num_inputs; slot++) {
574 switch (key->inputs[slot].interp) {
575 case LP_INTERP_CONSTANT:
576 load_attribute(gallivm, args, key, key->inputs[slot].src_index, attribs);
577 if (key->flatshade_first) {
578 emit_constant_coef4(gallivm, args, slot+1, attribs[0]);
579 }
580 else {
581 emit_constant_coef4(gallivm, args, slot+1, attribs[2]);
582 }
583 break;
584
585 case LP_INTERP_LINEAR:
586 load_attribute(gallivm, args, key, key->inputs[slot].src_index, attribs);
587 emit_apply_cyl_wrap(gallivm, args, key->inputs[slot].cyl_wrap, attribs);
588 emit_linear_coef(gallivm, args, slot+1, attribs);
589 break;
590
591 case LP_INTERP_PERSPECTIVE:
592 load_attribute(gallivm, args, key, key->inputs[slot].src_index, attribs);
593 emit_apply_cyl_wrap(gallivm, args, key->inputs[slot].cyl_wrap, attribs);
594 apply_perspective_corr(gallivm, args, slot+1, attribs);
595 emit_linear_coef(gallivm, args, slot+1, attribs);
596 break;
597
598 case LP_INTERP_POSITION:
599 /*
600 * The generated pixel interpolators will pick up the coeffs from
601 * slot 0.
602 */
603 break;
604
605 case LP_INTERP_FACING:
606 emit_facing_coef(gallivm, args, slot+1);
607 break;
608
609 default:
610 assert(0);
611 }
612 }
613 }
614
615
616 /* XXX: generic code:
617 */
618 static void
619 set_noalias(LLVMBuilderRef builder,
620 LLVMValueRef function,
621 const LLVMTypeRef *arg_types,
622 int nr_args)
623 {
624 int i;
625 for(i = 0; i < nr_args; ++i)
626 if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
627 lp_add_function_attr(function, i + 1, LP_FUNC_ATTR_NOALIAS);
628 }
629
630 static void
631 init_args(struct gallivm_state *gallivm,
632 const struct lp_setup_variant_key *key,
633 struct lp_setup_args *args)
634 {
635 LLVMBuilderRef b = gallivm->builder;
636 LLVMTypeRef shuf_type = LLVMInt32TypeInContext(gallivm->context);
637 LLVMValueRef onef = lp_build_const_float(gallivm, 1.0);
638 LLVMValueRef onei = lp_build_const_int32(gallivm, 1);
639 LLVMValueRef zeroi = lp_build_const_int32(gallivm, 0);
640 LLVMValueRef pixel_center, xy0_center, dxy01, dxy20, dyx20;
641 LLVMValueRef e, f, ef, ooa;
642 LLVMValueRef shuffles[4], shuf10;
643 LLVMValueRef attr_pos[3];
644 struct lp_type typef4 = lp_type_float_vec(32, 128);
645 struct lp_build_context bld;
646
647 lp_build_context_init(&bld, gallivm, typef4);
648 args->bld = bld;
649
650 /* The internal position input is in slot zero:
651 */
652 load_attribute(gallivm, args, key, 0, attr_pos);
653
654 pixel_center = lp_build_const_vec(gallivm, typef4,
655 key->pixel_center_half ? 0.5 : 0.0);
656
657 /*
658 * xy are first two elems in v0a/v1a/v2a but just use vec4 arit
659 * also offset_tri uses actually xyz in them
660 */
661 xy0_center = LLVMBuildFSub(b, attr_pos[0], pixel_center, "xy0_center" );
662
663 dxy01 = LLVMBuildFSub(b, attr_pos[0], attr_pos[1], "dxy01");
664 dxy20 = LLVMBuildFSub(b, attr_pos[2], attr_pos[0], "dxy20");
665
666 shuffles[0] = onei;
667 shuffles[1] = zeroi;
668 shuffles[2] = LLVMGetUndef(shuf_type);
669 shuffles[3] = LLVMGetUndef(shuf_type);
670 shuf10 = LLVMConstVector(shuffles, 4);
671
672 dyx20 = LLVMBuildShuffleVector(b, dxy20, dxy20, shuf10, "");
673
674 ef = LLVMBuildFMul(b, dxy01, dyx20, "ef");
675 e = LLVMBuildExtractElement(b, ef, zeroi, "");
676 f = LLVMBuildExtractElement(b, ef, onei, "");
677
678 ooa = LLVMBuildFDiv(b, onef, LLVMBuildFSub(b, e, f, ""), "ooa");
679
680 ooa = lp_build_broadcast_scalar(&bld, ooa);
681
682 /* tri offset calc shares a lot of arithmetic, do it here */
683 if (key->pgon_offset_scale != 0.0f || key->pgon_offset_units != 0.0f) {
684 lp_do_offset_tri(gallivm, args, key, ooa, dxy01, dxy20, attr_pos);
685 }
686
687 dxy20 = LLVMBuildFMul(b, dxy20, ooa, "");
688 dxy01 = LLVMBuildFMul(b, dxy01, ooa, "");
689
690 args->dy20_ooa = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy20, onei);
691 args->dy01_ooa = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy01, onei);
692
693 args->dx20_ooa = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy20, zeroi);
694 args->dx01_ooa = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy01, zeroi);
695
696 args->x0_center = lp_build_extract_broadcast(gallivm, typef4, typef4, xy0_center, zeroi);
697 args->y0_center = lp_build_extract_broadcast(gallivm, typef4, typef4, xy0_center, onei);
698
699 emit_linear_coef(gallivm, args, 0, attr_pos);
700 }
701
702 /**
703 * Generate the runtime callable function for the coefficient calculation.
704 *
705 */
706 static struct lp_setup_variant *
707 generate_setup_variant(struct lp_setup_variant_key *key,
708 struct llvmpipe_context *lp)
709 {
710 struct lp_setup_variant *variant = NULL;
711 struct gallivm_state *gallivm;
712 struct lp_setup_args args;
713 char func_name[64];
714 LLVMTypeRef vec4f_type;
715 LLVMTypeRef func_type;
716 LLVMTypeRef arg_types[7];
717 LLVMBasicBlockRef block;
718 LLVMBuilderRef builder;
719 int64_t t0 = 0, t1;
720
721 if (0)
722 goto fail;
723
724 variant = CALLOC_STRUCT(lp_setup_variant);
725 if (!variant)
726 goto fail;
727
728 variant->no = setup_no++;
729
730 snprintf(func_name, sizeof(func_name), "setup_variant_%u",
731 variant->no);
732
733 variant->gallivm = gallivm = gallivm_create(func_name, lp->context);
734 if (!variant->gallivm) {
735 goto fail;
736 }
737
738 builder = gallivm->builder;
739
740 if (LP_DEBUG & DEBUG_COUNTERS) {
741 t0 = os_time_get();
742 }
743
744 memcpy(&variant->key, key, key->size);
745 variant->list_item_global.base = variant;
746
747 /* Currently always deal with full 4-wide vertex attributes from
748 * the vertices.
749 */
750
751 vec4f_type = LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4);
752
753 arg_types[0] = LLVMPointerType(vec4f_type, 0); /* v0 */
754 arg_types[1] = LLVMPointerType(vec4f_type, 0); /* v1 */
755 arg_types[2] = LLVMPointerType(vec4f_type, 0); /* v2 */
756 arg_types[3] = LLVMInt32TypeInContext(gallivm->context); /* facing */
757 arg_types[4] = LLVMPointerType(vec4f_type, 0); /* a0, aligned */
758 arg_types[5] = LLVMPointerType(vec4f_type, 0); /* dadx, aligned */
759 arg_types[6] = LLVMPointerType(vec4f_type, 0); /* dady, aligned */
760
761 func_type = LLVMFunctionType(LLVMVoidTypeInContext(gallivm->context),
762 arg_types, ARRAY_SIZE(arg_types), 0);
763
764 variant->function = LLVMAddFunction(gallivm->module, func_name, func_type);
765 if (!variant->function)
766 goto fail;
767
768 LLVMSetFunctionCallConv(variant->function, LLVMCCallConv);
769
770 args.v0 = LLVMGetParam(variant->function, 0);
771 args.v1 = LLVMGetParam(variant->function, 1);
772 args.v2 = LLVMGetParam(variant->function, 2);
773 args.facing = LLVMGetParam(variant->function, 3);
774 args.a0 = LLVMGetParam(variant->function, 4);
775 args.dadx = LLVMGetParam(variant->function, 5);
776 args.dady = LLVMGetParam(variant->function, 6);
777
778 lp_build_name(args.v0, "in_v0");
779 lp_build_name(args.v1, "in_v1");
780 lp_build_name(args.v2, "in_v2");
781 lp_build_name(args.facing, "in_facing");
782 lp_build_name(args.a0, "out_a0");
783 lp_build_name(args.dadx, "out_dadx");
784 lp_build_name(args.dady, "out_dady");
785
786 /*
787 * Function body
788 */
789 block = LLVMAppendBasicBlockInContext(gallivm->context,
790 variant->function, "entry");
791 LLVMPositionBuilderAtEnd(builder, block);
792
793 set_noalias(builder, variant->function, arg_types, ARRAY_SIZE(arg_types));
794 init_args(gallivm, &variant->key, &args);
795 emit_tri_coef(gallivm, &variant->key, &args);
796
797 LLVMBuildRetVoid(builder);
798
799 gallivm_verify_function(gallivm, variant->function);
800
801 gallivm_compile_module(gallivm);
802
803 variant->jit_function = (lp_jit_setup_triangle)
804 gallivm_jit_function(gallivm, variant->function);
805 if (!variant->jit_function)
806 goto fail;
807
808 gallivm_free_ir(variant->gallivm);
809
810 /*
811 * Update timing information:
812 */
813 if (LP_DEBUG & DEBUG_COUNTERS) {
814 t1 = os_time_get();
815 LP_COUNT_ADD(llvm_compile_time, t1 - t0);
816 LP_COUNT_ADD(nr_llvm_compiles, 1);
817 }
818
819 return variant;
820
821 fail:
822 if (variant) {
823 if (variant->gallivm) {
824 gallivm_destroy(variant->gallivm);
825 }
826 FREE(variant);
827 }
828
829 return NULL;
830 }
831
832
833
834 static void
835 lp_make_setup_variant_key(struct llvmpipe_context *lp,
836 struct lp_setup_variant_key *key)
837 {
838 struct lp_fragment_shader *fs = lp->fs;
839 unsigned i;
840
841 assert(sizeof key->inputs[0] == sizeof(uint));
842
843 key->num_inputs = fs->info.base.num_inputs;
844 key->flatshade_first = lp->rasterizer->flatshade_first;
845 key->pixel_center_half = lp->rasterizer->half_pixel_center;
846 key->twoside = lp->rasterizer->light_twoside;
847 key->size = Offset(struct lp_setup_variant_key,
848 inputs[key->num_inputs]);
849
850 key->color_slot = lp->color_slot[0];
851 key->bcolor_slot = lp->bcolor_slot[0];
852 key->spec_slot = lp->color_slot[1];
853 key->bspec_slot = lp->bcolor_slot[1];
854
855 /*
856 * If depth is floating point, depth bias is calculated with respect
857 * to the primitive's maximum Z value. Retain the original depth bias
858 * value until that stage.
859 */
860 key->floating_point_depth = lp->floating_point_depth;
861
862 if (key->floating_point_depth) {
863 key->pgon_offset_units = (float) lp->rasterizer->offset_units;
864 } else {
865 key->pgon_offset_units =
866 (float) (lp->rasterizer->offset_units * lp->mrd);
867 }
868
869 key->pgon_offset_scale = lp->rasterizer->offset_scale;
870 key->pgon_offset_clamp = lp->rasterizer->offset_clamp;
871 key->pad = 0;
872 memcpy(key->inputs, fs->inputs, key->num_inputs * sizeof key->inputs[0]);
873 for (i = 0; i < key->num_inputs; i++) {
874 if (key->inputs[i].interp == LP_INTERP_COLOR) {
875 if (lp->rasterizer->flatshade)
876 key->inputs[i].interp = LP_INTERP_CONSTANT;
877 else
878 key->inputs[i].interp = LP_INTERP_PERSPECTIVE;
879 }
880 }
881
882 }
883
884
885 static void
886 remove_setup_variant(struct llvmpipe_context *lp,
887 struct lp_setup_variant *variant)
888 {
889 if (gallivm_debug & GALLIVM_DEBUG_IR) {
890 debug_printf("llvmpipe: del setup_variant #%u total %u\n",
891 variant->no, lp->nr_setup_variants);
892 }
893
894 if (variant->gallivm) {
895 gallivm_destroy(variant->gallivm);
896 }
897
898 remove_from_list(&variant->list_item_global);
899 lp->nr_setup_variants--;
900 FREE(variant);
901 }
902
903
904
905 /* When the number of setup variants exceeds a threshold, cull a
906 * fraction (currently a quarter) of them.
907 */
908 static void
909 cull_setup_variants(struct llvmpipe_context *lp)
910 {
911 struct pipe_context *pipe = &lp->pipe;
912 int i;
913
914 /*
915 * XXX: we need to flush the context until we have some sort of reference
916 * counting in fragment shaders as they may still be binned
917 * Flushing alone might not be sufficient we need to wait on it too.
918 */
919 llvmpipe_finish(pipe, __FUNCTION__);
920
921 for (i = 0; i < LP_MAX_SETUP_VARIANTS / 4; i++) {
922 struct lp_setup_variant_list_item *item;
923 if (is_empty_list(&lp->setup_variants_list)) {
924 break;
925 }
926 item = last_elem(&lp->setup_variants_list);
927 assert(item);
928 assert(item->base);
929 remove_setup_variant(lp, item->base);
930 }
931 }
932
933
934 /**
935 * Update fragment/vertex shader linkage state. This is called just
936 * prior to drawing something when some fragment-related state has
937 * changed.
938 */
939 void
940 llvmpipe_update_setup(struct llvmpipe_context *lp)
941 {
942 struct lp_setup_variant_key *key = &lp->setup_variant.key;
943 struct lp_setup_variant *variant = NULL;
944 struct lp_setup_variant_list_item *li;
945
946 lp_make_setup_variant_key(lp, key);
947
948 foreach(li, &lp->setup_variants_list) {
949 if(li->base->key.size == key->size &&
950 memcmp(&li->base->key, key, key->size) == 0) {
951 variant = li->base;
952 break;
953 }
954 }
955
956 if (variant) {
957 move_to_head(&lp->setup_variants_list, &variant->list_item_global);
958 }
959 else {
960 if (lp->nr_setup_variants >= LP_MAX_SETUP_VARIANTS) {
961 cull_setup_variants(lp);
962 }
963
964 variant = generate_setup_variant(key, lp);
965 if (variant) {
966 insert_at_head(&lp->setup_variants_list, &variant->list_item_global);
967 lp->nr_setup_variants++;
968 }
969 }
970
971 lp_setup_set_setup_variant(lp->setup, variant);
972 }
973
974 void
975 lp_delete_setup_variants(struct llvmpipe_context *lp)
976 {
977 struct lp_setup_variant_list_item *li;
978 li = first_elem(&lp->setup_variants_list);
979 while(!at_end(&lp->setup_variants_list, li)) {
980 struct lp_setup_variant_list_item *next = next_elem(li);
981 remove_setup_variant(lp, li->base);
982 li = next;
983 }
984 }
985
986 void
987 lp_dump_setup_coef(const struct lp_setup_variant_key *key,
988 const float (*sa0)[4],
989 const float (*sdadx)[4],
990 const float (*sdady)[4])
991 {
992 int i, slot;
993
994 for (i = 0; i < TGSI_NUM_CHANNELS; i++) {
995 float a0 = sa0 [0][i];
996 float dadx = sdadx[0][i];
997 float dady = sdady[0][i];
998
999 debug_printf("POS.%c: a0 = %f, dadx = %f, dady = %f\n",
1000 "xyzw"[i], a0, dadx, dady);
1001 }
1002
1003 for (slot = 0; slot < key->num_inputs; slot++) {
1004 unsigned usage_mask = key->inputs[slot].usage_mask;
1005 for (i = 0; i < TGSI_NUM_CHANNELS; i++) {
1006 if (usage_mask & (1 << i)) {
1007 float a0 = sa0 [1 + slot][i];
1008 float dadx = sdadx[1 + slot][i];
1009 float dady = sdady[1 + slot][i];
1010
1011 debug_printf("IN[%u].%c: a0 = %f, dadx = %f, dady = %f\n",
1012 slot, "xyzw"[i], a0, dadx, dady);
1013 }
1014 }
1015 }
1016 }