X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_state_setup.c;h=915e21db52cfc9a0993d74fdd8e32782f1ab0981;hb=3263c9824ebf35a24380e401bb1b1852d538a46d;hp=bb5cfc4be469ec020e00ec48d728b688b6a91e47;hpb=670f829102f45263f32826ec2dbbbf5c367b5f54;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_state_setup.c b/src/gallium/drivers/llvmpipe/lp_state_setup.c index bb5cfc4be46..915e21db52c 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_setup.c +++ b/src/gallium/drivers/llvmpipe/lp_state_setup.c @@ -28,9 +28,10 @@ #include "util/u_math.h" #include "util/u_memory.h" -#include "util/u_simple_list.h" -#include "os/os_time.h" +#include "util/simple_list.h" +#include "util/os_time.h" #include "gallivm/lp_bld_arit.h" +#include "gallivm/lp_bld_bitarit.h" #include "gallivm/lp_bld_const.h" #include "gallivm/lp_bld_debug.h" #include "gallivm/lp_bld_init.h" @@ -49,6 +50,9 @@ #include "lp_state_setup.h" +/** Setup shader number (for debugging) */ +static unsigned setup_no = 0; + /* currently organized to interpolate full float[4] attributes even * when some elements are unused. Later, can pack vertex data more @@ -76,94 +80,43 @@ struct lp_setup_args LLVMValueRef dy01_ooa; LLVMValueRef dx20_ooa; LLVMValueRef dx01_ooa; + struct lp_build_context bld; }; - -static LLVMTypeRef -type4f(struct gallivm_state *gallivm) -{ - return LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4); -} - - -/* Equivalent of _mm_setr_ps(a,b,c,d) - */ -static LLVMValueRef -vec4f(struct gallivm_state *gallivm, - LLVMValueRef a, LLVMValueRef b, LLVMValueRef c, LLVMValueRef d, - const char *name) -{ - LLVMBuilderRef bld = gallivm->builder; - LLVMValueRef i0 = lp_build_const_int32(gallivm, 0); - LLVMValueRef i1 = lp_build_const_int32(gallivm, 1); - LLVMValueRef i2 = lp_build_const_int32(gallivm, 2); - LLVMValueRef i3 = lp_build_const_int32(gallivm, 3); - - LLVMValueRef res = LLVMGetUndef(type4f(gallivm)); - - res = LLVMBuildInsertElement(bld, res, a, i0, ""); - res = LLVMBuildInsertElement(bld, res, b, i1, ""); - res = LLVMBuildInsertElement(bld, res, c, i2, ""); - res = LLVMBuildInsertElement(bld, res, d, i3, name); - - return res; -} - -/* Equivalent of _mm_set1_ps(a) - */ -static LLVMValueRef -vec4f_from_scalar(struct gallivm_state *gallivm, - LLVMValueRef a, - const char *name) -{ - LLVMBuilderRef bld = gallivm->builder; - LLVMValueRef res = LLVMGetUndef(type4f(gallivm)); - int i; - - for(i = 0; i < 4; ++i) { - LLVMValueRef index = lp_build_const_int32(gallivm, i); - res = LLVMBuildInsertElement(bld, res, a, index, i == 3 ? name : ""); - } - - return res; -} - static void store_coef(struct gallivm_state *gallivm, - struct lp_setup_args *args, - unsigned slot, - LLVMValueRef a0, - LLVMValueRef dadx, - LLVMValueRef dady) + struct lp_setup_args *args, + unsigned slot, + LLVMValueRef a0, + LLVMValueRef dadx, + LLVMValueRef dady) { LLVMBuilderRef builder = gallivm->builder; LLVMValueRef idx = lp_build_const_int32(gallivm, slot); LLVMBuildStore(builder, - a0, - LLVMBuildGEP(builder, args->a0, &idx, 1, "")); + a0, + LLVMBuildGEP(builder, args->a0, &idx, 1, "")); LLVMBuildStore(builder, - dadx, - LLVMBuildGEP(builder, args->dadx, &idx, 1, "")); + dadx, + LLVMBuildGEP(builder, args->dadx, &idx, 1, "")); LLVMBuildStore(builder, - dady, - LLVMBuildGEP(builder, args->dady, &idx, 1, "")); + dady, + LLVMBuildGEP(builder, args->dady, &idx, 1, "")); } static void emit_constant_coef4(struct gallivm_state *gallivm, - struct lp_setup_args *args, - unsigned slot, - LLVMValueRef vert) + struct lp_setup_args *args, + unsigned slot, + LLVMValueRef vert) { - LLVMValueRef zero = lp_build_const_float(gallivm, 0.0); - LLVMValueRef zerovec = vec4f_from_scalar(gallivm, zero, "zero"); - store_coef(gallivm, args, slot, vert, zerovec, zerovec); + store_coef(gallivm, args, slot, vert, args->bld.zero, args->bld.zero); } @@ -174,27 +127,40 @@ emit_constant_coef4(struct gallivm_state *gallivm, */ static void emit_facing_coef(struct gallivm_state *gallivm, - struct lp_setup_args *args, - unsigned slot ) + struct lp_setup_args *args, + unsigned slot ) { LLVMBuilderRef builder = gallivm->builder; LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); LLVMValueRef a0_0 = args->facing; LLVMValueRef a0_0f = LLVMBuildSIToFP(builder, a0_0, float_type, ""); - LLVMValueRef zero = lp_build_const_float(gallivm, 0.0); - LLVMValueRef a0 = vec4f(gallivm, a0_0f, zero, zero, zero, "facing"); - LLVMValueRef zerovec = vec4f_from_scalar(gallivm, zero, "zero"); - - store_coef(gallivm, args, slot, a0, zerovec, zerovec); + LLVMValueRef a0, face_val; + const unsigned char swizzles[4] = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_0, + PIPE_SWIZZLE_0, PIPE_SWIZZLE_0 }; + /* Our face val is either 1 or 0 so we do + * face = (val * 2) - 1 + * to make it 1 or -1 + */ + face_val = + LLVMBuildFAdd(builder, + LLVMBuildFMul(builder, a0_0f, + lp_build_const_float(gallivm, 2.0), + ""), + lp_build_const_float(gallivm, -1.0), + "facing"); + face_val = lp_build_broadcast_scalar(&args->bld, face_val); + a0 = lp_build_swizzle_aos(&args->bld, face_val, swizzles); + + store_coef(gallivm, args, slot, a0, args->bld.zero, args->bld.zero); } static LLVMValueRef vert_attrib(struct gallivm_state *gallivm, - LLVMValueRef vert, - int attr, - int elem, - const char *name) + LLVMValueRef vert, + int attr, + int elem, + const char *name) { LLVMBuilderRef b = gallivm->builder; LLVMValueRef idx[2]; @@ -216,8 +182,9 @@ lp_twoside(struct gallivm_state *gallivm, LLVMValueRef idx2 = lp_build_const_int32(gallivm, bcolor_slot); LLVMValueRef facing = args->facing; - LLVMValueRef front_facing = LLVMBuildICmp(b, LLVMIntEQ, facing, lp_build_const_int32(gallivm, 0), ""); /** need i1 for if condition */ - + LLVMValueRef front_facing = LLVMBuildICmp(b, LLVMIntEQ, facing, + lp_build_const_int32(gallivm, 0), ""); /** need i1 for if condition */ + a0_back = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v0, &idx2, 1, ""), "v0a_back"); a1_back = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v1, &idx2, 1, ""), "v1a_back"); a2_back = LLVMBuildLoad(b, LLVMBuildGEP(b, args->v2, &idx2, 1, ""), "v2a_back"); @@ -243,8 +210,9 @@ lp_do_offset_tri(struct gallivm_state *gallivm, LLVMValueRef attribv[3]) { LLVMBuilderRef b = gallivm->builder; - struct lp_build_context bld; struct lp_build_context flt_scalar_bld; + struct lp_build_context int_scalar_bld; + struct lp_build_context *bld = &args->bld; LLVMValueRef zoffset, mult; LLVMValueRef z0_new, z1_new, z2_new; LLVMValueRef dzdxdzdy, dzdx, dzdy, dzxyz20, dyzzx01, dyzzx01_dzxyz20, dzx01_dyz20; @@ -282,24 +250,67 @@ lp_do_offset_tri(struct gallivm_state *gallivm, res12 = LLVMBuildFSub(b, dyzzx01_dzxyz20, dzx01_dyz20, "res12"); /* dzdx = fabsf(res1 * inv_det), dydx = fabsf(res2 * inv_det)*/ - lp_build_context_init(&bld, gallivm, lp_type_float_vec(32, 128)); dzdxdzdy = LLVMBuildFMul(b, res12, inv_det, "dzdxdzdy"); - dzdxdzdy = lp_build_abs(&bld, dzdxdzdy); + dzdxdzdy = lp_build_abs(bld, dzdxdzdy); dzdx = LLVMBuildExtractElement(b, dzdxdzdy, zeroi, ""); dzdy = LLVMBuildExtractElement(b, dzdxdzdy, onei, ""); - /* zoffset = pgon_offset_units + MAX2(dzdx, dzdy) * pgon_offset_scale */ + /* mult = MAX2(dzdx, dzdy) * pgon_offset_scale */ max = LLVMBuildFCmp(b, LLVMRealUGT, dzdx, dzdy, ""); max_value = LLVMBuildSelect(b, max, dzdx, dzdy, "max"); mult = LLVMBuildFMul(b, max_value, lp_build_const_float(gallivm, key->pgon_offset_scale), ""); - zoffset = LLVMBuildFAdd(b, - lp_build_const_float(gallivm, key->pgon_offset_units), - mult, "zoffset"); lp_build_context_init(&flt_scalar_bld, gallivm, lp_type_float_vec(32, 32)); + + if (key->floating_point_depth) { + /* + * bias = pgon_offset_units * 2^(exponent(max(z0, z1, z2)) - mantissa_bits) + + * MAX2(dzdx, dzdy) * pgon_offset_scale + * + * NOTE: Assumes IEEE float32. + */ + LLVMValueRef c23_shifted, exp_mask, bias, exp; + LLVMValueRef maxz_value, maxz0z1_value; + + lp_build_context_init(&int_scalar_bld, gallivm, lp_type_int_vec(32, 32)); + + c23_shifted = lp_build_const_int32(gallivm, 23 << 23); + exp_mask = lp_build_const_int32(gallivm, 0xff << 23); + + maxz0z1_value = lp_build_max(&flt_scalar_bld, + LLVMBuildExtractElement(b, attribv[0], twoi, ""), + LLVMBuildExtractElement(b, attribv[1], twoi, "")); + + maxz_value = lp_build_max(&flt_scalar_bld, + LLVMBuildExtractElement(b, attribv[2], twoi, ""), + maxz0z1_value); + + exp = LLVMBuildBitCast(b, maxz_value, int_scalar_bld.vec_type, ""); + exp = lp_build_and(&int_scalar_bld, exp, exp_mask); + exp = lp_build_sub(&int_scalar_bld, exp, c23_shifted); + /* Clamping to zero means mrd will be zero for very small numbers, + * but specs do not indicate this should be prevented by clamping + * mrd to smallest normal number instead. */ + exp = lp_build_max(&int_scalar_bld, exp, int_scalar_bld.zero); + exp = LLVMBuildBitCast(b, exp, flt_scalar_bld.vec_type, ""); + + bias = LLVMBuildFMul(b, exp, + lp_build_const_float(gallivm, key->pgon_offset_units), + "bias"); + + zoffset = LLVMBuildFAdd(b, bias, mult, "zoffset"); + } else { + /* + * bias = pgon_offset_units + MAX2(dzdx, dzdy) * pgon_offset_scale + */ + zoffset = LLVMBuildFAdd(b, + lp_build_const_float(gallivm, key->pgon_offset_units), + mult, "zoffset"); + } + if (key->pgon_offset_clamp > 0) { zoffset = lp_build_min(&flt_scalar_bld, lp_build_const_float(gallivm, key->pgon_offset_clamp), @@ -322,14 +333,14 @@ lp_do_offset_tri(struct gallivm_state *gallivm, shuffles[2] = lp_build_const_int32(gallivm, 6); shuffles[3] = LLVMGetUndef(shuf_type); z0z1z2 = LLVMBuildShuffleVector(b, z0z1, attribv[2], LLVMConstVector(shuffles, 4), ""); - zoffset = vec4f_from_scalar(gallivm, zoffset, ""); + zoffset = lp_build_broadcast_scalar(bld, zoffset); /* clamp and do offset */ /* * FIXME I suspect the clamp (is that even right to always clamp to fixed * 0.0/1.0?) should really be per fragment? */ - z0z1z2 = lp_build_clamp(&bld, LLVMBuildFAdd(b, z0z1z2, zoffset, ""), bld.zero, bld.one); + z0z1z2 = lp_build_clamp(bld, LLVMBuildFAdd(b, z0z1z2, zoffset, ""), bld->zero, bld->one); /* insert into args->a0.z, a1.z, a2.z: */ @@ -368,22 +379,35 @@ load_attribute(struct gallivm_state *gallivm, } } +/* + * FIXME: interpolation is always done wrt fb origin (0/0). + * However, if some (small) tri is far away from the origin and gradients + * are large, this can lead to HUGE errors, since the a0 value calculated + * here can get very large (with the actual values inside the triangle way + * smaller), leading to complete loss of accuracy. This could be prevented + * by using some point inside (or at corner) of the tri as interpolation + * origin, or just use barycentric interpolation (which GL suggests and is + * what real hw does - you can get the barycentric coordinates from the + * edge functions in rasterization in principle (though we skip these + * sometimes completely in case of tris covering a block fully, + * which obviously wouldn't work)). + */ static void emit_coef4( struct gallivm_state *gallivm, - struct lp_setup_args *args, - unsigned slot, - LLVMValueRef a0, - LLVMValueRef a1, - LLVMValueRef a2) + struct lp_setup_args *args, + unsigned slot, + LLVMValueRef a0, + LLVMValueRef a1, + LLVMValueRef a2) { LLVMBuilderRef b = gallivm->builder; + LLVMValueRef attr_0; LLVMValueRef dy20_ooa = args->dy20_ooa; LLVMValueRef dy01_ooa = args->dy01_ooa; LLVMValueRef dx20_ooa = args->dx20_ooa; LLVMValueRef dx01_ooa = args->dx01_ooa; LLVMValueRef x0_center = args->x0_center; LLVMValueRef y0_center = args->y0_center; - LLVMValueRef da01 = LLVMBuildFSub(b, a0, a1, "da01"); LLVMValueRef da20 = LLVMBuildFSub(b, a2, a0, "da20"); @@ -401,10 +425,10 @@ emit_coef4( struct gallivm_state *gallivm, /* Calculate a0 - the attribute value at the origin */ - LLVMValueRef dadx_x0 = LLVMBuildFMul(b, dadx, x0_center, "dadx_x0"); - LLVMValueRef dady_y0 = LLVMBuildFMul(b, dady, y0_center, "dady_y0"); - LLVMValueRef attr_v0 = LLVMBuildFAdd(b, dadx_x0, dady_y0, "attr_v0"); - LLVMValueRef attr_0 = LLVMBuildFSub(b, a0, attr_v0, "attr_0"); + LLVMValueRef dadx_x0 = LLVMBuildFMul(b, dadx, x0_center, "dadx_x0"); + LLVMValueRef dady_y0 = LLVMBuildFMul(b, dady, y0_center, "dady_y0"); + LLVMValueRef attr_v0 = LLVMBuildFAdd(b, dadx_x0, dady_y0, "attr_v0"); + attr_0 = LLVMBuildFSub(b, a0, attr_v0, "attr_0"); store_coef(gallivm, args, slot, attr_0, dadx, dady); } @@ -412,9 +436,9 @@ emit_coef4( struct gallivm_state *gallivm, static void emit_linear_coef( struct gallivm_state *gallivm, - struct lp_setup_args *args, - unsigned slot, - LLVMValueRef attribv[3]) + struct lp_setup_args *args, + unsigned slot, + LLVMValueRef attribv[3]) { /* nothing to do anymore */ emit_coef4(gallivm, @@ -443,9 +467,12 @@ apply_perspective_corr( struct gallivm_state *gallivm, /* premultiply by 1/w (v[0][3] is always 1/w): */ - LLVMValueRef v0_oow = vec4f_from_scalar(gallivm, vert_attrib(gallivm, args->v0, 0, 3, ""), "v0_oow"); - LLVMValueRef v1_oow = vec4f_from_scalar(gallivm, vert_attrib(gallivm, args->v1, 0, 3, ""), "v1_oow"); - LLVMValueRef v2_oow = vec4f_from_scalar(gallivm, vert_attrib(gallivm, args->v2, 0, 3, ""), "v2_oow"); + LLVMValueRef v0_oow = lp_build_broadcast_scalar(&args->bld, + vert_attrib(gallivm, args->v0, 0, 3, "v0_oow")); + LLVMValueRef v1_oow = lp_build_broadcast_scalar(&args->bld, + vert_attrib(gallivm, args->v1, 0, 3, "v1_oow")); + LLVMValueRef v2_oow = lp_build_broadcast_scalar(&args->bld, + vert_attrib(gallivm, args->v2, 0, 3, "v2_oow")); attribv[0] = LLVMBuildFMul(b, attribv[0], v0_oow, "v0_oow_v0a"); attribv[1] = LLVMBuildFMul(b, attribv[1], v1_oow, "v1_oow_v1a"); @@ -453,16 +480,6 @@ apply_perspective_corr( struct gallivm_state *gallivm, } -static void -emit_position_coef( struct gallivm_state *gallivm, - struct lp_setup_args *args, - int slot, - LLVMValueRef attribv[3]) -{ - emit_linear_coef(gallivm, args, slot, attribv); -} - - /** * Applys cylindrical wrapping to vertex attributes if enabled. * Input coordinates must be in [0, 1] range, otherwise results are undefined. @@ -473,12 +490,12 @@ static void emit_apply_cyl_wrap(struct gallivm_state *gallivm, struct lp_setup_args *args, uint cyl_wrap, - LLVMValueRef attribv[3]) + LLVMValueRef attribv[3]) { LLVMBuilderRef builder = gallivm->builder; - struct lp_type type = lp_float32_vec4_type(); - LLVMTypeRef float_vec_type = lp_build_vec_type(gallivm, type); + struct lp_type type = args->bld.type; + LLVMTypeRef float_vec_type = args->bld.vec_type; LLVMValueRef pos_half; LLVMValueRef neg_half; LLVMValueRef cyl_mask; @@ -567,13 +584,13 @@ emit_tri_coef( struct gallivm_state *gallivm, case LP_INTERP_LINEAR: load_attribute(gallivm, args, key, key->inputs[slot].src_index, attribs); - emit_apply_cyl_wrap(gallivm, args, key->inputs[slot].cyl_wrap, attribs); + emit_apply_cyl_wrap(gallivm, args, key->inputs[slot].cyl_wrap, attribs); emit_linear_coef(gallivm, args, slot+1, attribs); break; case LP_INTERP_PERSPECTIVE: load_attribute(gallivm, args, key, key->inputs[slot].src_index, attribs); - emit_apply_cyl_wrap(gallivm, args, key->inputs[slot].cyl_wrap, attribs); + emit_apply_cyl_wrap(gallivm, args, key->inputs[slot].cyl_wrap, attribs); apply_perspective_corr(gallivm, args, slot+1, attribs); emit_linear_coef(gallivm, args, slot+1, attribs); break; @@ -600,21 +617,20 @@ emit_tri_coef( struct gallivm_state *gallivm, */ static void set_noalias(LLVMBuilderRef builder, - LLVMValueRef function, - const LLVMTypeRef *arg_types, - int nr_args) + LLVMValueRef function, + const LLVMTypeRef *arg_types, + int nr_args) { int i; for(i = 0; i < nr_args; ++i) if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) - LLVMAddAttribute(LLVMGetParam(function, i), - LLVMNoAliasAttribute); + lp_add_function_attr(function, i + 1, LP_FUNC_ATTR_NOALIAS); } static void init_args(struct gallivm_state *gallivm, const struct lp_setup_variant_key *key, - struct lp_setup_args *args) + struct lp_setup_args *args) { LLVMBuilderRef b = gallivm->builder; LLVMTypeRef shuf_type = LLVMInt32TypeInContext(gallivm->context); @@ -623,16 +639,20 @@ init_args(struct gallivm_state *gallivm, LLVMValueRef zeroi = lp_build_const_int32(gallivm, 0); LLVMValueRef pixel_center, xy0_center, dxy01, dxy20, dyx20; LLVMValueRef e, f, ef, ooa; - LLVMValueRef shuffles[4]; + LLVMValueRef shuffles[4], shuf10; LLVMValueRef attr_pos[3]; struct lp_type typef4 = lp_type_float_vec(32, 128); + struct lp_build_context bld; + + lp_build_context_init(&bld, gallivm, typef4); + args->bld = bld; /* The internal position input is in slot zero: */ load_attribute(gallivm, args, key, 0, attr_pos); pixel_center = lp_build_const_vec(gallivm, typef4, - key->pixel_center_half ? 0.5 : 0.0); + key->pixel_center_half ? 0.5 : 0.0); /* * xy are first two elems in v0a/v1a/v2a but just use vec4 arit @@ -647,8 +667,9 @@ init_args(struct gallivm_state *gallivm, shuffles[1] = zeroi; shuffles[2] = LLVMGetUndef(shuf_type); shuffles[3] = LLVMGetUndef(shuf_type); + shuf10 = LLVMConstVector(shuffles, 4); - dyx20 = LLVMBuildShuffleVector(b, dxy20, dxy20, LLVMConstVector(shuffles, 4), ""); + dyx20 = LLVMBuildShuffleVector(b, dxy20, dxy20, shuf10, ""); ef = LLVMBuildFMul(b, dxy01, dyx20, "ef"); e = LLVMBuildExtractElement(b, ef, zeroi, ""); @@ -656,7 +677,7 @@ init_args(struct gallivm_state *gallivm, ooa = LLVMBuildFDiv(b, onef, LLVMBuildFSub(b, e, f, ""), "ooa"); - ooa = vec4f_from_scalar(gallivm, ooa, ""); + ooa = lp_build_broadcast_scalar(&bld, ooa); /* tri offset calc shares a lot of arithmetic, do it here */ if (key->pgon_offset_scale != 0.0f || key->pgon_offset_units != 0.0f) { @@ -675,8 +696,7 @@ init_args(struct gallivm_state *gallivm, args->x0_center = lp_build_extract_broadcast(gallivm, typef4, typef4, xy0_center, zeroi); args->y0_center = lp_build_extract_broadcast(gallivm, typef4, typef4, xy0_center, onei); - /* might want to merge that with other coef emit in the future */ - emit_position_coef(gallivm, args, 0, attr_pos); + emit_linear_coef(gallivm, args, 0, attr_pos); } /** @@ -690,7 +710,7 @@ generate_setup_variant(struct lp_setup_variant_key *key, struct lp_setup_variant *variant = NULL; struct gallivm_state *gallivm; struct lp_setup_args args; - char func_name[256]; + char func_name[64]; LLVMTypeRef vec4f_type; LLVMTypeRef func_type; LLVMTypeRef arg_types[7]; @@ -702,10 +722,15 @@ generate_setup_variant(struct lp_setup_variant_key *key, goto fail; variant = CALLOC_STRUCT(lp_setup_variant); - if (variant == NULL) + if (!variant) goto fail; - variant->gallivm = gallivm = gallivm_create(); + variant->no = setup_no++; + + snprintf(func_name, sizeof(func_name), "setup_variant_%u", + variant->no); + + variant->gallivm = gallivm = gallivm_create(func_name, lp->context); if (!variant->gallivm) { goto fail; } @@ -719,10 +744,6 @@ generate_setup_variant(struct lp_setup_variant_key *key, memcpy(&variant->key, key, key->size); variant->list_item_global.base = variant; - util_snprintf(func_name, sizeof(func_name), "fs%u_setup%u", - 0, - variant->no); - /* Currently always deal with full 4-wide vertex attributes from * the vertices. */ @@ -738,7 +759,7 @@ generate_setup_variant(struct lp_setup_variant_key *key, arg_types[6] = LLVMPointerType(vec4f_type, 0); /* dady, aligned */ func_type = LLVMFunctionType(LLVMVoidTypeInContext(gallivm->context), - arg_types, Elements(arg_types), 0); + arg_types, ARRAY_SIZE(arg_types), 0); variant->function = LLVMAddFunction(gallivm->module, func_name, func_type); if (!variant->function) @@ -769,7 +790,7 @@ generate_setup_variant(struct lp_setup_variant_key *key, variant->function, "entry"); LLVMPositionBuilderAtEnd(builder, block); - set_noalias(builder, variant->function, arg_types, Elements(arg_types)); + set_noalias(builder, variant->function, arg_types, ARRAY_SIZE(arg_types)); init_args(gallivm, &variant->key, &args); emit_tri_coef(gallivm, &variant->key, &args); @@ -784,6 +805,8 @@ generate_setup_variant(struct lp_setup_variant_key *key, if (!variant->jit_function) goto fail; + gallivm_free_ir(variant->gallivm); + /* * Update timing information: */ @@ -792,22 +815,17 @@ generate_setup_variant(struct lp_setup_variant_key *key, LP_COUNT_ADD(llvm_compile_time, t1 - t0); LP_COUNT_ADD(nr_llvm_compiles, 1); } - + return variant; fail: if (variant) { - if (variant->function) { - gallivm_free_function(gallivm, - variant->function, - variant->jit_function); - } if (variant->gallivm) { gallivm_destroy(variant->gallivm); } FREE(variant); } - + return NULL; } @@ -815,13 +833,13 @@ fail: static void lp_make_setup_variant_key(struct llvmpipe_context *lp, - struct lp_setup_variant_key *key) + struct lp_setup_variant_key *key) { struct lp_fragment_shader *fs = lp->fs; unsigned i; assert(sizeof key->inputs[0] == sizeof(uint)); - + key->num_inputs = fs->info.base.num_inputs; key->flatshade_first = lp->rasterizer->flatshade_first; key->pixel_center_half = lp->rasterizer->half_pixel_center; @@ -829,16 +847,25 @@ lp_make_setup_variant_key(struct llvmpipe_context *lp, key->size = Offset(struct lp_setup_variant_key, inputs[key->num_inputs]); - key->color_slot = lp->color_slot [0]; + key->color_slot = lp->color_slot[0]; key->bcolor_slot = lp->bcolor_slot[0]; - key->spec_slot = lp->color_slot [1]; - key->bspec_slot = lp->bcolor_slot[1]; - assert(key->color_slot == lp->color_slot [0]); - assert(key->bcolor_slot == lp->bcolor_slot[0]); - assert(key->spec_slot == lp->color_slot [1]); - assert(key->bspec_slot == lp->bcolor_slot[1]); - - key->pgon_offset_units = (float) (lp->rasterizer->offset_units * lp->mrd); + key->spec_slot = lp->color_slot[1]; + key->bspec_slot = lp->bcolor_slot[1]; + + /* + * If depth is floating point, depth bias is calculated with respect + * to the primitive's maximum Z value. Retain the original depth bias + * value until that stage. + */ + key->floating_point_depth = lp->floating_point_depth; + + if (key->floating_point_depth) { + key->pgon_offset_units = (float) lp->rasterizer->offset_units; + } else { + key->pgon_offset_units = + (float) (lp->rasterizer->offset_units * lp->mrd); + } + key->pgon_offset_scale = lp->rasterizer->offset_scale; key->pgon_offset_clamp = lp->rasterizer->offset_clamp; key->pad = 0; @@ -846,9 +873,9 @@ lp_make_setup_variant_key(struct llvmpipe_context *lp, for (i = 0; i < key->num_inputs; i++) { if (key->inputs[i].interp == LP_INTERP_COLOR) { if (lp->rasterizer->flatshade) - key->inputs[i].interp = LP_INTERP_CONSTANT; - else - key->inputs[i].interp = LP_INTERP_PERSPECTIVE; + key->inputs[i].interp = LP_INTERP_CONSTANT; + else + key->inputs[i].interp = LP_INTERP_PERSPECTIVE; } } @@ -857,17 +884,11 @@ lp_make_setup_variant_key(struct llvmpipe_context *lp, static void remove_setup_variant(struct llvmpipe_context *lp, - struct lp_setup_variant *variant) + struct lp_setup_variant *variant) { if (gallivm_debug & GALLIVM_DEBUG_IR) { debug_printf("llvmpipe: del setup_variant #%u total %u\n", - variant->no, lp->nr_setup_variants); - } - - if (variant->function) { - gallivm_free_function(variant->gallivm, - variant->function, - variant->jit_function); + variant->no, lp->nr_setup_variants); } if (variant->gallivm) { @@ -926,7 +947,7 @@ llvmpipe_update_setup(struct llvmpipe_context *lp) foreach(li, &lp->setup_variants_list) { if(li->base->key.size == key->size && - memcmp(&li->base->key, key, key->size) == 0) { + memcmp(&li->base->key, key, key->size) == 0) { variant = li->base; break; } @@ -937,19 +958,17 @@ llvmpipe_update_setup(struct llvmpipe_context *lp) } else { if (lp->nr_setup_variants >= LP_MAX_SETUP_VARIANTS) { - cull_setup_variants(lp); + cull_setup_variants(lp); } variant = generate_setup_variant(key, lp); if (variant) { insert_at_head(&lp->setup_variants_list, &variant->list_item_global); lp->nr_setup_variants++; - llvmpipe_variant_count++; } } - lp_setup_set_setup_variant(lp->setup, - variant); + lp_setup_set_setup_variant(lp->setup, variant); } void @@ -965,10 +984,10 @@ lp_delete_setup_variants(struct llvmpipe_context *lp) } void -lp_dump_setup_coef( const struct lp_setup_variant_key *key, - const float (*sa0)[4], - const float (*sdadx)[4], - const float (*sdady)[4]) +lp_dump_setup_coef(const struct lp_setup_variant_key *key, + const float (*sa0)[4], + const float (*sdadx)[4], + const float (*sdady)[4]) { int i, slot; @@ -978,23 +997,20 @@ lp_dump_setup_coef( const struct lp_setup_variant_key *key, float dady = sdady[0][i]; debug_printf("POS.%c: a0 = %f, dadx = %f, dady = %f\n", - "xyzw"[i], - a0, dadx, dady); + "xyzw"[i], a0, dadx, dady); } for (slot = 0; slot < key->num_inputs; slot++) { unsigned usage_mask = key->inputs[slot].usage_mask; for (i = 0; i < TGSI_NUM_CHANNELS; i++) { - if (usage_mask & (1 << i)) { - float a0 = sa0 [1 + slot][i]; - float dadx = sdadx[1 + slot][i]; - float dady = sdady[1 + slot][i]; - - debug_printf("IN[%u].%c: a0 = %f, dadx = %f, dady = %f\n", - slot, - "xyzw"[i], - a0, dadx, dady); - } + if (usage_mask & (1 << i)) { + float a0 = sa0 [1 + slot][i]; + float dadx = sdadx[1 + slot][i]; + float dady = sdady[1 + slot][i]; + + debug_printf("IN[%u].%c: a0 = %f, dadx = %f, dady = %f\n", + slot, "xyzw"[i], a0, dadx, dady); + } } } }