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 "os/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_RED, PIPE_SWIZZLE_ZERO,
 139                                        PIPE_SWIZZLE_ZERO, PIPE_SWIZZLE_ZERO };
 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_ZERO:
 606          /*
 607           * The information we get from the output is bogus, replace it
 608           * with zero.
 609           */
 610          emit_constant_coef4(gallivm, args, slot+1, args->bld.zero);
 611          break;
 612       case LP_INTERP_FACING:
 613          emit_facing_coef(gallivm, args, slot+1);
 614          break;
 615
 616       default:
 617          assert(0);
 618       }
 619    }
 620 }
 621
 622
 623 /* XXX: generic code:
 624  */
 625 static void
 626 set_noalias(LLVMBuilderRef builder,
 627             LLVMValueRef function,
 628             const LLVMTypeRef *arg_types,
 629             int nr_args)
 630 {
 631    int i;
 632    for(i = 0; i < nr_args; ++i)
 633       if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
 634          LLVMAddAttribute(LLVMGetParam(function, i),
 635             LLVMNoAliasAttribute);
 636 }
 637
 638 static void
 639 init_args(struct gallivm_state *gallivm,
 640           const struct lp_setup_variant_key *key,
 641           struct lp_setup_args *args)
 642 {
 643    LLVMBuilderRef b = gallivm->builder;
 644    LLVMTypeRef shuf_type = LLVMInt32TypeInContext(gallivm->context);
 645    LLVMValueRef onef = lp_build_const_float(gallivm, 1.0);
 646    LLVMValueRef onei = lp_build_const_int32(gallivm, 1);
 647    LLVMValueRef zeroi = lp_build_const_int32(gallivm, 0);
 648    LLVMValueRef pixel_center, xy0_center, dxy01, dxy20, dyx20;
 649    LLVMValueRef e, f, ef, ooa;
 650    LLVMValueRef shuffles[4], shuf10;
 651    LLVMValueRef attr_pos[3];
 652    struct lp_type typef4 = lp_type_float_vec(32, 128);
 653    struct lp_build_context bld;
 654
 655    lp_build_context_init(&bld, gallivm, typef4);
 656    args->bld = bld;
 657
 658    /* The internal position input is in slot zero:
 659     */
 660    load_attribute(gallivm, args, key, 0, attr_pos);
 661
 662    pixel_center = lp_build_const_vec(gallivm, typef4,
 663                                      key->pixel_center_half ? 0.5 : 0.0);
 664
 665    /*
 666     * xy are first two elems in v0a/v1a/v2a but just use vec4 arit
 667     * also offset_tri uses actually xyz in them
 668     */
 669    xy0_center = LLVMBuildFSub(b, attr_pos[0], pixel_center, "xy0_center" );
 670
 671    dxy01 = LLVMBuildFSub(b, attr_pos[0], attr_pos[1], "dxy01");
 672    dxy20 = LLVMBuildFSub(b, attr_pos[2], attr_pos[0], "dxy20");
 673
 674    shuffles[0] = onei;
 675    shuffles[1] = zeroi;
 676    shuffles[2] = LLVMGetUndef(shuf_type);
 677    shuffles[3] = LLVMGetUndef(shuf_type);
 678    shuf10 = LLVMConstVector(shuffles, 4);
 679
 680    dyx20 = LLVMBuildShuffleVector(b, dxy20, dxy20, shuf10, "");
 681
 682    ef = LLVMBuildFMul(b, dxy01, dyx20, "ef");
 683    e = LLVMBuildExtractElement(b, ef, zeroi, "");
 684    f = LLVMBuildExtractElement(b, ef, onei, "");
 685
 686    ooa  = LLVMBuildFDiv(b, onef, LLVMBuildFSub(b, e, f, ""), "ooa");
 687
 688    ooa = lp_build_broadcast_scalar(&bld, ooa);
 689
 690    /* tri offset calc shares a lot of arithmetic, do it here */
 691    if (key->pgon_offset_scale != 0.0f || key->pgon_offset_units != 0.0f) {
 692       lp_do_offset_tri(gallivm, args, key, ooa, dxy01, dxy20, attr_pos);
 693    }
 694
 695    dxy20 = LLVMBuildFMul(b, dxy20, ooa, "");
 696    dxy01 = LLVMBuildFMul(b, dxy01, ooa, "");
 697
 698    args->dy20_ooa  = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy20, onei);
 699    args->dy01_ooa  = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy01, onei);
 700
 701    args->dx20_ooa  = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy20, zeroi);
 702    args->dx01_ooa  = lp_build_extract_broadcast(gallivm, typef4, typef4, dxy01, zeroi);
 703
 704    args->x0_center = lp_build_extract_broadcast(gallivm, typef4, typef4, xy0_center, zeroi);
 705    args->y0_center = lp_build_extract_broadcast(gallivm, typef4, typef4, xy0_center, onei);
 706
 707    emit_linear_coef(gallivm, args, 0, attr_pos);
 708 }
 709
 710 /**
 711  * Generate the runtime callable function for the coefficient calculation.
 712  *
 713  */
 714 static struct lp_setup_variant *
 715 generate_setup_variant(struct lp_setup_variant_key *key,
 716                        struct llvmpipe_context *lp)
 717 {
 718    struct lp_setup_variant *variant = NULL;
 719    struct gallivm_state *gallivm;
 720    struct lp_setup_args args;
 721    char func_name[64];
 722    LLVMTypeRef vec4f_type;
 723    LLVMTypeRef func_type;
 724    LLVMTypeRef arg_types[7];
 725    LLVMBasicBlockRef block;
 726    LLVMBuilderRef builder;
 727    int64_t t0 = 0, t1;
 728
 729    if (0)
 730       goto fail;
 731
 732    variant = CALLOC_STRUCT(lp_setup_variant);
 733    if (!variant)
 734       goto fail;
 735
 736    variant->no = setup_no++;
 737
 738    util_snprintf(func_name, sizeof(func_name), "setup_variant_%u",
 739                  variant->no);
 740
 741    variant->gallivm = gallivm = gallivm_create(func_name, lp->context);
 742    if (!variant->gallivm) {
 743       goto fail;
 744    }
 745
 746    builder = gallivm->builder;
 747
 748    if (LP_DEBUG & DEBUG_COUNTERS) {
 749       t0 = os_time_get();
 750    }
 751
 752    memcpy(&variant->key, key, key->size);
 753    variant->list_item_global.base = variant;
 754
 755    /* Currently always deal with full 4-wide vertex attributes from
 756     * the vertices.
 757     */
 758
 759    vec4f_type = LLVMVectorType(LLVMFloatTypeInContext(gallivm->context), 4);
 760
 761    arg_types[0] = LLVMPointerType(vec4f_type, 0);        /* v0 */
 762    arg_types[1] = LLVMPointerType(vec4f_type, 0);        /* v1 */
 763    arg_types[2] = LLVMPointerType(vec4f_type, 0);        /* v2 */
 764    arg_types[3] = LLVMInt32TypeInContext(gallivm->context); /* facing */
 765    arg_types[4] = LLVMPointerType(vec4f_type, 0);       /* a0, aligned */
 766    arg_types[5] = LLVMPointerType(vec4f_type, 0);       /* dadx, aligned */
 767    arg_types[6] = LLVMPointerType(vec4f_type, 0);       /* dady, aligned */
 768
 769    func_type = LLVMFunctionType(LLVMVoidTypeInContext(gallivm->context),
 770                                 arg_types, Elements(arg_types), 0);
 771
 772    variant->function = LLVMAddFunction(gallivm->module, func_name, func_type);
 773    if (!variant->function)
 774       goto fail;
 775
 776    LLVMSetFunctionCallConv(variant->function, LLVMCCallConv);
 777
 778    args.v0       = LLVMGetParam(variant->function, 0);
 779    args.v1       = LLVMGetParam(variant->function, 1);
 780    args.v2       = LLVMGetParam(variant->function, 2);
 781    args.facing   = LLVMGetParam(variant->function, 3);
 782    args.a0       = LLVMGetParam(variant->function, 4);
 783    args.dadx     = LLVMGetParam(variant->function, 5);
 784    args.dady     = LLVMGetParam(variant->function, 6);
 785
 786    lp_build_name(args.v0, "in_v0");
 787    lp_build_name(args.v1, "in_v1");
 788    lp_build_name(args.v2, "in_v2");
 789    lp_build_name(args.facing, "in_facing");
 790    lp_build_name(args.a0, "out_a0");
 791    lp_build_name(args.dadx, "out_dadx");
 792    lp_build_name(args.dady, "out_dady");
 793
 794    /*
 795     * Function body
 796     */
 797    block = LLVMAppendBasicBlockInContext(gallivm->context,
 798                                          variant->function, "entry");
 799    LLVMPositionBuilderAtEnd(builder, block);
 800
 801    set_noalias(builder, variant->function, arg_types, Elements(arg_types));
 802    init_args(gallivm, &variant->key, &args);
 803    emit_tri_coef(gallivm, &variant->key, &args);
 804
 805    LLVMBuildRetVoid(builder);
 806
 807    gallivm_verify_function(gallivm, variant->function);
 808
 809    gallivm_compile_module(gallivm);
 810
 811    variant->jit_function = (lp_jit_setup_triangle)
 812       gallivm_jit_function(gallivm, variant->function);
 813    if (!variant->jit_function)
 814       goto fail;
 815
 816    gallivm_free_ir(variant->gallivm);
 817
 818    /*
 819     * Update timing information:
 820     */
 821    if (LP_DEBUG & DEBUG_COUNTERS) {
 822       t1 = os_time_get();
 823       LP_COUNT_ADD(llvm_compile_time, t1 - t0);
 824       LP_COUNT_ADD(nr_llvm_compiles, 1);
 825    }
 826
 827    return variant;
 828
 829 fail:
 830    if (variant) {
 831       if (variant->gallivm) {
 832          gallivm_destroy(variant->gallivm);
 833       }
 834       FREE(variant);
 835    }
 836
 837    return NULL;
 838 }
 839
 840
 841
 842 static void
 843 lp_make_setup_variant_key(struct llvmpipe_context *lp,
 844                           struct lp_setup_variant_key *key)
 845 {
 846    struct lp_fragment_shader *fs = lp->fs;
 847    unsigned i;
 848
 849    assert(sizeof key->inputs[0] == sizeof(uint));
 850
 851    key->num_inputs = fs->info.base.num_inputs;
 852    key->flatshade_first = lp->rasterizer->flatshade_first;
 853    key->pixel_center_half = lp->rasterizer->half_pixel_center;
 854    key->twoside = lp->rasterizer->light_twoside;
 855    key->size = Offset(struct lp_setup_variant_key,
 856                       inputs[key->num_inputs]);
 857
 858    key->color_slot = lp->color_slot[0];
 859    key->bcolor_slot = lp->bcolor_slot[0];
 860    key->spec_slot = lp->color_slot[1];
 861    key->bspec_slot = lp->bcolor_slot[1];
 862
 863    /*
 864     * If depth is floating point, depth bias is calculated with respect
 865     * to the primitive's maximum Z value. Retain the original depth bias
 866     * value until that stage.
 867     */
 868    key->floating_point_depth = lp->floating_point_depth;
 869
 870    if (key->floating_point_depth) {
 871       key->pgon_offset_units = (float) lp->rasterizer->offset_units;
 872    } else {
 873       key->pgon_offset_units =
 874          (float) (lp->rasterizer->offset_units * lp->mrd);
 875    }
 876
 877    key->pgon_offset_scale = lp->rasterizer->offset_scale;
 878    key->pgon_offset_clamp = lp->rasterizer->offset_clamp;
 879    key->pad = 0;
 880    memcpy(key->inputs, fs->inputs, key->num_inputs * sizeof key->inputs[0]);
 881    for (i = 0; i < key->num_inputs; i++) {
 882       if (key->inputs[i].interp == LP_INTERP_CONSTANT) {
 883          if (key->inputs[i].src_index == lp->fake_vpindex_slot ||
 884              key->inputs[i].src_index == lp->fake_layer_slot) {
 885             key->inputs[i].interp = LP_INTERP_ZERO;
 886          }
 887       }
 888       else if (key->inputs[i].interp == LP_INTERP_COLOR) {
 889          if (lp->rasterizer->flatshade)
 890             key->inputs[i].interp = LP_INTERP_CONSTANT;
 891          else
 892             key->inputs[i].interp = LP_INTERP_PERSPECTIVE;
 893       }
 894    }
 895
 896 }
 897
 898
 899 static void
 900 remove_setup_variant(struct llvmpipe_context *lp,
 901                      struct lp_setup_variant *variant)
 902 {
 903    if (gallivm_debug & GALLIVM_DEBUG_IR) {
 904       debug_printf("llvmpipe: del setup_variant #%u total %u\n",
 905                    variant->no, lp->nr_setup_variants);
 906    }
 907
 908    if (variant->gallivm) {
 909       gallivm_destroy(variant->gallivm);
 910    }
 911
 912    remove_from_list(&variant->list_item_global);
 913    lp->nr_setup_variants--;
 914    FREE(variant);
 915 }
 916
 917
 918
 919 /* When the number of setup variants exceeds a threshold, cull a
 920  * fraction (currently a quarter) of them.
 921  */
 922 static void
 923 cull_setup_variants(struct llvmpipe_context *lp)
 924 {
 925    struct pipe_context *pipe = &lp->pipe;
 926    int i;
 927
 928    /*
 929     * XXX: we need to flush the context until we have some sort of reference
 930     * counting in fragment shaders as they may still be binned
 931     * Flushing alone might not be sufficient we need to wait on it too.
 932     */
 933    llvmpipe_finish(pipe, __FUNCTION__);
 934
 935    for (i = 0; i < LP_MAX_SETUP_VARIANTS / 4; i++) {
 936       struct lp_setup_variant_list_item *item;
 937       if (is_empty_list(&lp->setup_variants_list)) {
 938          break;
 939       }
 940       item = last_elem(&lp->setup_variants_list);
 941       assert(item);
 942       assert(item->base);
 943       remove_setup_variant(lp, item->base);
 944    }
 945 }
 946
 947
 948 /**
 949  * Update fragment/vertex shader linkage state.  This is called just
 950  * prior to drawing something when some fragment-related state has
 951  * changed.
 952  */
 953 void
 954 llvmpipe_update_setup(struct llvmpipe_context *lp)
 955 {
 956    struct lp_setup_variant_key *key = &lp->setup_variant.key;
 957    struct lp_setup_variant *variant = NULL;
 958    struct lp_setup_variant_list_item *li;
 959
 960    lp_make_setup_variant_key(lp, key);
 961
 962    foreach(li, &lp->setup_variants_list) {
 963       if(li->base->key.size == key->size &&
 964          memcmp(&li->base->key, key, key->size) == 0) {
 965          variant = li->base;
 966          break;
 967       }
 968    }
 969
 970    if (variant) {
 971       move_to_head(&lp->setup_variants_list, &variant->list_item_global);
 972    }
 973    else {
 974       if (lp->nr_setup_variants >= LP_MAX_SETUP_VARIANTS) {
 975          cull_setup_variants(lp);
 976       }
 977
 978       variant = generate_setup_variant(key, lp);
 979       if (variant) {
 980          insert_at_head(&lp->setup_variants_list, &variant->list_item_global);
 981          lp->nr_setup_variants++;
 982       }
 983    }
 984
 985    lp_setup_set_setup_variant(lp->setup, variant);
 986 }
 987
 988 void
 989 lp_delete_setup_variants(struct llvmpipe_context *lp)
 990 {
 991    struct lp_setup_variant_list_item *li;
 992    li = first_elem(&lp->setup_variants_list);
 993    while(!at_end(&lp->setup_variants_list, li)) {
 994       struct lp_setup_variant_list_item *next = next_elem(li);
 995       remove_setup_variant(lp, li->base);
 996       li = next;
 997    }
 998 }
 999
1000 void
1001 lp_dump_setup_coef(const struct lp_setup_variant_key *key,
1002                    const float (*sa0)[4],
1003                    const float (*sdadx)[4],
1004                    const float (*sdady)[4])
1005 {
1006    int i, slot;
1007
1008    for (i = 0; i < TGSI_NUM_CHANNELS; i++) {
1009       float a0   = sa0  [0][i];
1010       float dadx = sdadx[0][i];
1011       float dady = sdady[0][i];
1012
1013       debug_printf("POS.%c: a0 = %f, dadx = %f, dady = %f\n",
1014                    "xyzw"[i], a0, dadx, dady);
1015    }
1016
1017    for (slot = 0; slot < key->num_inputs; slot++) {
1018       unsigned usage_mask = key->inputs[slot].usage_mask;
1019       for (i = 0; i < TGSI_NUM_CHANNELS; i++) {
1020          if (usage_mask & (1 << i)) {
1021             float a0   = sa0  [1 + slot][i];
1022             float dadx = sdadx[1 + slot][i];
1023             float dady = sdady[1 + slot][i];
1024
1025             debug_printf("IN[%u].%c: a0 = %f, dadx = %f, dady = %f\n",
1026                          slot, "xyzw"[i], a0, dadx, dady);
1027          }
1028       }
1029    }
1030 }