src/gallium/auxiliary/gallivm/lp_bld_tgsi_soa.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 /**
  30  * @file
  31  * TGSI to LLVM IR translation -- SoA.
  32  *
  33  * @author Jose Fonseca <jfonseca@vmware.com>
  34  *
  35  * Based on tgsi_sse2.c code written by Michal Krol, Keith Whitwell,
  36  * Brian Paul, and others.
  37  */
  38
  39 #include "pipe/p_config.h"
  40 #include "pipe/p_shader_tokens.h"
  41 #include "util/u_debug.h"
  42 #include "util/u_math.h"
  43 #include "util/u_memory.h"
  44 #include "tgsi/tgsi_dump.h"
  45 #include "tgsi/tgsi_info.h"
  46 #include "tgsi/tgsi_parse.h"
  47 #include "tgsi/tgsi_util.h"
  48 #include "tgsi/tgsi_exec.h"
  49 #include "lp_bld_type.h"
  50 #include "lp_bld_const.h"
  51 #include "lp_bld_arit.h"
  52 #include "lp_bld_logic.h"
  53 #include "lp_bld_swizzle.h"
  54 #include "lp_bld_flow.h"
  55 #include "lp_bld_tgsi.h"
  56 #include "lp_bld_debug.h"
  57
  58
  59 #define LP_MAX_TEMPS 256
  60 #define LP_MAX_IMMEDIATES 256
  61
  62
  63 #define FOR_EACH_CHANNEL( CHAN )\
  64    for (CHAN = 0; CHAN < NUM_CHANNELS; CHAN++)
  65
  66 #define IS_DST0_CHANNEL_ENABLED( INST, CHAN )\
  67    ((INST)->Dst[0].Register.WriteMask & (1 << (CHAN)))
  68
  69 #define IF_IS_DST0_CHANNEL_ENABLED( INST, CHAN )\
  70    if (IS_DST0_CHANNEL_ENABLED( INST, CHAN ))
  71
  72 #define FOR_EACH_DST0_ENABLED_CHANNEL( INST, CHAN )\
  73    FOR_EACH_CHANNEL( CHAN )\
  74       IF_IS_DST0_CHANNEL_ENABLED( INST, CHAN )
  75
  76 #define CHAN_X 0
  77 #define CHAN_Y 1
  78 #define CHAN_Z 2
  79 #define CHAN_W 3
  80
  81 #define QUAD_TOP_LEFT     0
  82 #define QUAD_TOP_RIGHT    1
  83 #define QUAD_BOTTOM_LEFT  2
  84 #define QUAD_BOTTOM_RIGHT 3
  85
  86 #define LP_TGSI_MAX_NESTING 16
  87
  88 struct lp_exec_mask {
  89    struct lp_build_context *bld;
  90
  91    boolean has_mask;
  92
  93    LLVMTypeRef int_vec_type;
  94
  95    LLVMValueRef cond_stack[LP_TGSI_MAX_NESTING];
  96    int cond_stack_size;
  97    LLVMValueRef cond_mask;
  98
  99    LLVMValueRef break_stack[LP_TGSI_MAX_NESTING];
 100    int break_stack_size;
 101    LLVMValueRef break_mask;
 102
 103    LLVMValueRef cont_stack[LP_TGSI_MAX_NESTING];
 104    int cont_stack_size;
 105    LLVMValueRef cont_mask;
 106
 107    LLVMBasicBlockRef loop_stack[LP_TGSI_MAX_NESTING];
 108    int loop_stack_size;
 109    LLVMBasicBlockRef loop_block;
 110
 111
 112    LLVMValueRef exec_mask;
 113 };
 114
 115 struct lp_build_tgsi_soa_context
 116 {
 117    struct lp_build_context base;
 118
 119    LLVMValueRef consts_ptr;
 120    const LLVMValueRef *pos;
 121    const LLVMValueRef (*inputs)[NUM_CHANNELS];
 122    LLVMValueRef (*outputs)[NUM_CHANNELS];
 123
 124    struct lp_build_sampler_soa *sampler;
 125
 126    LLVMValueRef immediates[LP_MAX_IMMEDIATES][NUM_CHANNELS];
 127    LLVMValueRef temps[LP_MAX_TEMPS][NUM_CHANNELS];
 128
 129    struct lp_build_mask_context *mask;
 130    struct lp_exec_mask exec_mask;
 131 };
 132
 133 static const unsigned char
 134 swizzle_left[4] = {
 135    QUAD_TOP_LEFT,     QUAD_TOP_LEFT,
 136    QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_LEFT
 137 };
 138
 139 static const unsigned char
 140 swizzle_right[4] = {
 141    QUAD_TOP_RIGHT,    QUAD_TOP_RIGHT,
 142    QUAD_BOTTOM_RIGHT, QUAD_BOTTOM_RIGHT
 143 };
 144
 145 static const unsigned char
 146 swizzle_top[4] = {
 147    QUAD_TOP_LEFT,     QUAD_TOP_RIGHT,
 148    QUAD_TOP_LEFT,     QUAD_TOP_RIGHT
 149 };
 150
 151 static const unsigned char
 152 swizzle_bottom[4] = {
 153    QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_RIGHT,
 154    QUAD_BOTTOM_LEFT,  QUAD_BOTTOM_RIGHT
 155 };
 156
 157 static void lp_exec_mask_init(struct lp_exec_mask *mask, struct lp_build_context *bld)
 158 {
 159    mask->bld = bld;
 160    mask->has_mask = FALSE;
 161    mask->cond_stack_size = 0;
 162    mask->loop_stack_size = 0;
 163    mask->break_stack_size = 0;
 164    mask->cont_stack_size = 0;
 165
 166    mask->int_vec_type = lp_build_int_vec_type(mask->bld->type);
 167 }
 168
 169 static void lp_exec_mask_update(struct lp_exec_mask *mask)
 170 {
 171    if (mask->loop_stack_size) {
 172       /*for loops we need to update the entire mask at
 173        * runtime */
 174       LLVMValueRef tmp;
 175       tmp = LLVMBuildAnd(mask->bld->builder,
 176                          mask->cont_mask,
 177                          mask->break_mask,
 178                          "maskcb");
 179       mask->exec_mask = LLVMBuildAnd(mask->bld->builder,
 180                                      mask->cond_mask,
 181                                      tmp,
 182                                      "maskfull");
 183    } else
 184       mask->exec_mask = mask->cond_mask;
 185
 186
 187    mask->has_mask = (mask->cond_stack_size > 0 ||
 188                      mask->loop_stack_size > 0);
 189 }
 190
 191 static void lp_exec_mask_cond_push(struct lp_exec_mask *mask,
 192                                    LLVMValueRef val)
 193 {
 194    mask->cond_stack[mask->cond_stack_size++] = mask->cond_mask;
 195    mask->cond_mask = LLVMBuildBitCast(mask->bld->builder, val,
 196                                       mask->int_vec_type, "");
 197
 198    lp_exec_mask_update(mask);
 199 }
 200
 201 static void lp_exec_mask_cond_invert(struct lp_exec_mask *mask)
 202 {
 203    LLVMValueRef prev_mask = mask->cond_stack[mask->cond_stack_size - 1];
 204    LLVMValueRef inv_mask = LLVMBuildNot(mask->bld->builder,
 205                                         mask->cond_mask, "");
 206
 207    /* means that we didn't have any mask before and that
 208     * we were fully enabled */
 209    if (mask->cond_stack_size <= 1) {
 210       prev_mask = LLVMConstAllOnes(mask->int_vec_type);
 211    }
 212
 213    mask->cond_mask = LLVMBuildAnd(mask->bld->builder,
 214                                   inv_mask,
 215                                   prev_mask, "");
 216    lp_exec_mask_update(mask);
 217 }
 218
 219 static void lp_exec_mask_cond_pop(struct lp_exec_mask *mask)
 220 {
 221    mask->cond_mask = mask->cond_stack[--mask->cond_stack_size];
 222    lp_exec_mask_update(mask);
 223 }
 224
 225 static void lp_exec_bgnloop(struct lp_exec_mask *mask)
 226 {
 227
 228    if (mask->cont_stack_size == 0)
 229       mask->cont_mask = LLVMConstAllOnes(mask->int_vec_type);
 230    if (mask->cont_stack_size == 0)
 231       mask->break_mask = LLVMConstAllOnes(mask->int_vec_type);
 232    if (mask->cond_stack_size == 0)
 233       mask->cond_mask = LLVMConstAllOnes(mask->int_vec_type);
 234    mask->loop_stack[mask->loop_stack_size++] = mask->loop_block;
 235    mask->loop_block = lp_build_insert_new_block(mask->bld->builder, "bgnloop");
 236    LLVMBuildBr(mask->bld->builder, mask->loop_block);
 237    LLVMPositionBuilderAtEnd(mask->bld->builder, mask->loop_block);
 238
 239    lp_exec_mask_update(mask);
 240 }
 241
 242 static void lp_exec_break(struct lp_exec_mask *mask)
 243 {
 244    LLVMValueRef exec_mask = LLVMBuildNot(mask->bld->builder,
 245                                          mask->exec_mask,
 246                                          "break");
 247
 248    mask->break_stack[mask->break_stack_size++] = mask->break_mask;
 249    if (mask->break_stack_size > 1) {
 250       mask->break_mask = LLVMBuildAnd(mask->bld->builder,
 251                                       mask->break_mask,
 252                                       exec_mask, "break_full");
 253    } else
 254       mask->break_mask = exec_mask;
 255
 256    lp_exec_mask_update(mask);
 257 }
 258
 259 static void lp_exec_continue(struct lp_exec_mask *mask)
 260 {
 261    LLVMValueRef exec_mask = LLVMBuildNot(mask->bld->builder,
 262                                          mask->exec_mask,
 263                                          "");
 264
 265    mask->cont_stack[mask->cont_stack_size++] = mask->cont_mask;
 266    if (mask->cont_stack_size > 1) {
 267       mask->cont_mask = LLVMBuildAnd(mask->bld->builder,
 268                                      mask->cont_mask,
 269                                      exec_mask, "");
 270    } else
 271       mask->cont_mask = exec_mask;
 272
 273    lp_exec_mask_update(mask);
 274 }
 275
 276
 277 static void lp_exec_endloop(struct lp_exec_mask *mask)
 278 {
 279    LLVMBasicBlockRef endloop;
 280    LLVMTypeRef reg_type = LLVMIntType(mask->bld->type.width*
 281                                       mask->bld->type.length);
 282    /* i1cond = (mask == 0) */
 283    LLVMValueRef i1cond = LLVMBuildICmp(
 284       mask->bld->builder,
 285       LLVMIntNE,
 286       LLVMBuildBitCast(mask->bld->builder, mask->break_mask, reg_type, ""),
 287       LLVMConstNull(reg_type), "");
 288
 289    endloop = lp_build_insert_new_block(mask->bld->builder, "endloop");
 290
 291    LLVMBuildCondBr(mask->bld->builder,
 292                    i1cond, mask->loop_block, endloop);
 293
 294    LLVMPositionBuilderAtEnd(mask->bld->builder, endloop);
 295
 296    mask->loop_block = mask->loop_stack[--mask->loop_stack_size];
 297    /* pop the break mask */
 298    if (mask->cont_stack_size) {
 299       mask->cont_mask = mask->cont_stack[--mask->cont_stack_size];
 300    }
 301    if (mask->break_stack_size) {
 302       mask->break_mask = mask->cont_stack[--mask->break_stack_size];
 303    }
 304
 305    lp_exec_mask_update(mask);
 306 }
 307
 308 static void lp_exec_mask_store(struct lp_exec_mask *mask,
 309                                LLVMValueRef val,
 310                                LLVMValueRef dst)
 311 {
 312    if (mask->has_mask) {
 313       LLVMValueRef real_val, dst_val;
 314
 315       dst_val = LLVMBuildLoad(mask->bld->builder, dst, "");
 316       real_val = lp_build_select(mask->bld,
 317                                  mask->exec_mask,
 318                                  val, dst_val);
 319
 320       LLVMBuildStore(mask->bld->builder, real_val, dst);
 321    } else
 322       LLVMBuildStore(mask->bld->builder, val, dst);
 323 }
 324
 325
 326 static LLVMValueRef
 327 emit_ddx(struct lp_build_tgsi_soa_context *bld,
 328          LLVMValueRef src)
 329 {
 330    LLVMValueRef src_left  = lp_build_swizzle1_aos(&bld->base, src, swizzle_left);
 331    LLVMValueRef src_right = lp_build_swizzle1_aos(&bld->base, src, swizzle_right);
 332    return lp_build_sub(&bld->base, src_right, src_left);
 333 }
 334
 335
 336 static LLVMValueRef
 337 emit_ddy(struct lp_build_tgsi_soa_context *bld,
 338          LLVMValueRef src)
 339 {
 340    LLVMValueRef src_top    = lp_build_swizzle1_aos(&bld->base, src, swizzle_top);
 341    LLVMValueRef src_bottom = lp_build_swizzle1_aos(&bld->base, src, swizzle_bottom);
 342    return lp_build_sub(&bld->base, src_top, src_bottom);
 343 }
 344
 345
 346 /**
 347  * Register fetch.
 348  */
 349 static LLVMValueRef
 350 emit_fetch(
 351    struct lp_build_tgsi_soa_context *bld,
 352    const struct tgsi_full_instruction *inst,
 353    unsigned index,
 354    const unsigned chan_index )
 355 {
 356    const struct tgsi_full_src_register *reg = &inst->Src[index];
 357    unsigned swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
 358    LLVMValueRef res;
 359
 360    switch (swizzle) {
 361    case TGSI_SWIZZLE_X:
 362    case TGSI_SWIZZLE_Y:
 363    case TGSI_SWIZZLE_Z:
 364    case TGSI_SWIZZLE_W:
 365
 366       switch (reg->Register.File) {
 367       case TGSI_FILE_CONSTANT: {
 368          LLVMValueRef index = LLVMConstInt(LLVMInt32Type(), reg->Register.Index*4 + swizzle, 0);
 369          LLVMValueRef scalar_ptr = LLVMBuildGEP(bld->base.builder, bld->consts_ptr, &index, 1, "");
 370          LLVMValueRef scalar = LLVMBuildLoad(bld->base.builder, scalar_ptr, "");
 371          res = lp_build_broadcast_scalar(&bld->base, scalar);
 372          break;
 373       }
 374
 375       case TGSI_FILE_IMMEDIATE:
 376          res = bld->immediates[reg->Register.Index][swizzle];
 377          assert(res);
 378          break;
 379
 380       case TGSI_FILE_INPUT:
 381          res = bld->inputs[reg->Register.Index][swizzle];
 382          assert(res);
 383          break;
 384
 385       case TGSI_FILE_TEMPORARY:
 386          res = LLVMBuildLoad(bld->base.builder, bld->temps[reg->Register.Index][swizzle], "");
 387          if(!res)
 388             return bld->base.undef;
 389          break;
 390
 391       default:
 392          assert( 0 );
 393          return bld->base.undef;
 394       }
 395       break;
 396
 397    default:
 398       assert( 0 );
 399       return bld->base.undef;
 400    }
 401
 402    switch( tgsi_util_get_full_src_register_sign_mode( reg, chan_index ) ) {
 403    case TGSI_UTIL_SIGN_CLEAR:
 404       res = lp_build_abs( &bld->base, res );
 405       break;
 406
 407    case TGSI_UTIL_SIGN_SET:
 408       /* TODO: Use bitwese OR for floating point */
 409       res = lp_build_abs( &bld->base, res );
 410       res = LLVMBuildNeg( bld->base.builder, res, "" );
 411       break;
 412
 413    case TGSI_UTIL_SIGN_TOGGLE:
 414       res = LLVMBuildNeg( bld->base.builder, res, "" );
 415       break;
 416
 417    case TGSI_UTIL_SIGN_KEEP:
 418       break;
 419    }
 420
 421    return res;
 422 }
 423
 424
 425 /**
 426  * Register fetch with derivatives.
 427  */
 428 static void
 429 emit_fetch_deriv(
 430    struct lp_build_tgsi_soa_context *bld,
 431    const struct tgsi_full_instruction *inst,
 432    unsigned index,
 433    const unsigned chan_index,
 434    LLVMValueRef *res,
 435    LLVMValueRef *ddx,
 436    LLVMValueRef *ddy)
 437 {
 438    LLVMValueRef src;
 439
 440    src = emit_fetch(bld, inst, index, chan_index);
 441
 442    if(res)
 443       *res = src;
 444
 445    /* TODO: use interpolation coeffs for inputs */
 446
 447    if(ddx)
 448       *ddx = emit_ddx(bld, src);
 449
 450    if(ddy)
 451       *ddy = emit_ddy(bld, src);
 452 }
 453
 454
 455 /**
 456  * Register store.
 457  */
 458 static void
 459 emit_store(
 460    struct lp_build_tgsi_soa_context *bld,
 461    const struct tgsi_full_instruction *inst,
 462    unsigned index,
 463    unsigned chan_index,
 464    LLVMValueRef value)
 465 {
 466    const struct tgsi_full_dst_register *reg = &inst->Dst[index];
 467
 468    switch( inst->Instruction.Saturate ) {
 469    case TGSI_SAT_NONE:
 470       break;
 471
 472    case TGSI_SAT_ZERO_ONE:
 473       value = lp_build_max(&bld->base, value, bld->base.zero);
 474       value = lp_build_min(&bld->base, value, bld->base.one);
 475       break;
 476
 477    case TGSI_SAT_MINUS_PLUS_ONE:
 478       value = lp_build_max(&bld->base, value, lp_build_const_vec(bld->base.type, -1.0));
 479       value = lp_build_min(&bld->base, value, bld->base.one);
 480       break;
 481
 482    default:
 483       assert(0);
 484    }
 485
 486    switch( reg->Register.File ) {
 487    case TGSI_FILE_OUTPUT:
 488       lp_exec_mask_store(&bld->exec_mask, value,
 489                          bld->outputs[reg->Register.Index][chan_index]);
 490       break;
 491
 492    case TGSI_FILE_TEMPORARY:
 493       lp_exec_mask_store(&bld->exec_mask, value,
 494                          bld->temps[reg->Register.Index][chan_index]);
 495       break;
 496
 497    case TGSI_FILE_ADDRESS:
 498       /* FIXME */
 499       assert(0);
 500       break;
 501
 502    case TGSI_FILE_PREDICATE:
 503       /* FIXME */
 504       assert(0);
 505       break;
 506
 507    default:
 508       assert( 0 );
 509    }
 510 }
 511
 512
 513 /**
 514  * High-level instruction translators.
 515  */
 516
 517
 518 static void
 519 emit_tex( struct lp_build_tgsi_soa_context *bld,
 520           const struct tgsi_full_instruction *inst,
 521           boolean apply_lodbias,
 522           boolean projected,
 523           LLVMValueRef *texel)
 524 {
 525    const uint unit = inst->Src[1].Register.Index;
 526    LLVMValueRef lodbias;
 527    LLVMValueRef oow = NULL;
 528    LLVMValueRef coords[3];
 529    unsigned num_coords;
 530    unsigned i;
 531
 532    switch (inst->Texture.Texture) {
 533    case TGSI_TEXTURE_1D:
 534       num_coords = 1;
 535       break;
 536    case TGSI_TEXTURE_2D:
 537    case TGSI_TEXTURE_RECT:
 538       num_coords = 2;
 539       break;
 540    case TGSI_TEXTURE_SHADOW1D:
 541    case TGSI_TEXTURE_SHADOW2D:
 542    case TGSI_TEXTURE_SHADOWRECT:
 543    case TGSI_TEXTURE_3D:
 544    case TGSI_TEXTURE_CUBE:
 545       num_coords = 3;
 546       break;
 547    default:
 548       assert(0);
 549       return;
 550    }
 551
 552    if(apply_lodbias)
 553       lodbias = emit_fetch( bld, inst, 0, 3 );
 554    else
 555       lodbias = bld->base.zero;
 556
 557    if (projected) {
 558       oow = emit_fetch( bld, inst, 0, 3 );
 559       oow = lp_build_rcp(&bld->base, oow);
 560    }
 561
 562    for (i = 0; i < num_coords; i++) {
 563       coords[i] = emit_fetch( bld, inst, 0, i );
 564       if (projected)
 565          coords[i] = lp_build_mul(&bld->base, coords[i], oow);
 566    }
 567    for (i = num_coords; i < 3; i++) {
 568       coords[i] = bld->base.undef;
 569    }
 570
 571    bld->sampler->emit_fetch_texel(bld->sampler,
 572                                   bld->base.builder,
 573                                   bld->base.type,
 574                                   unit, num_coords, coords, lodbias,
 575                                   texel);
 576 }
 577
 578
 579 /**
 580  * Kill fragment if any of the src register values are negative.
 581  */
 582 static void
 583 emit_kil(
 584    struct lp_build_tgsi_soa_context *bld,
 585    const struct tgsi_full_instruction *inst )
 586 {
 587    const struct tgsi_full_src_register *reg = &inst->Src[0];
 588    LLVMValueRef terms[NUM_CHANNELS];
 589    LLVMValueRef mask;
 590    unsigned chan_index;
 591
 592    memset(&terms, 0, sizeof terms);
 593
 594    FOR_EACH_CHANNEL( chan_index ) {
 595       unsigned swizzle;
 596
 597       /* Unswizzle channel */
 598       swizzle = tgsi_util_get_full_src_register_swizzle( reg, chan_index );
 599
 600       /* Check if the component has not been already tested. */
 601       assert(swizzle < NUM_CHANNELS);
 602       if( !terms[swizzle] )
 603          /* TODO: change the comparison operator instead of setting the sign */
 604          terms[swizzle] =  emit_fetch(bld, inst, 0, chan_index );
 605    }
 606
 607    mask = NULL;
 608    FOR_EACH_CHANNEL( chan_index ) {
 609       if(terms[chan_index]) {
 610          LLVMValueRef chan_mask;
 611
 612          /*
 613           * If term < 0 then mask = 0 else mask = ~0.
 614           */
 615          chan_mask = lp_build_cmp(&bld->base, PIPE_FUNC_GEQUAL, terms[chan_index], bld->base.zero);
 616
 617          if(mask)
 618             mask = LLVMBuildAnd(bld->base.builder, mask, chan_mask, "");
 619          else
 620             mask = chan_mask;
 621       }
 622    }
 623
 624    if(mask)
 625       lp_build_mask_update(bld->mask, mask);
 626 }
 627
 628
 629 /**
 630  * Predicated fragment kill.
 631  * XXX Actually, we do an unconditional kill (as in tgsi_exec.c).
 632  * The only predication is the execution mask which will apply if
 633  * we're inside a loop or conditional.
 634  */
 635 static void
 636 emit_kilp(struct lp_build_tgsi_soa_context *bld,
 637           const struct tgsi_full_instruction *inst)
 638 {
 639    LLVMValueRef mask;
 640
 641    /* For those channels which are "alive", disable fragment shader
 642     * execution.
 643     */
 644    if (bld->exec_mask.has_mask) {
 645       mask = LLVMBuildNot(bld->base.builder, bld->exec_mask.exec_mask, "kilp");
 646    }
 647    else {
 648       mask = bld->base.zero;
 649    }
 650
 651    lp_build_mask_update(bld->mask, mask);
 652 }
 653
 654
 655 /**
 656  * Check if inst src/dest regs use indirect addressing into temporary
 657  * register file.
 658  */
 659 static boolean
 660 indirect_temp_reference(const struct tgsi_full_instruction *inst)
 661 {
 662    uint i;
 663    for (i = 0; i < inst->Instruction.NumSrcRegs; i++) {
 664       const struct tgsi_full_src_register *reg = &inst->Src[i];
 665       if (reg->Register.File == TGSI_FILE_TEMPORARY &&
 666           reg->Register.Indirect)
 667          return TRUE;
 668    }
 669    for (i = 0; i < inst->Instruction.NumDstRegs; i++) {
 670       const struct tgsi_full_dst_register *reg = &inst->Dst[i];
 671       if (reg->Register.File == TGSI_FILE_TEMPORARY &&
 672           reg->Register.Indirect)
 673          return TRUE;
 674    }
 675    return FALSE;
 676 }
 677
 678 static int
 679 emit_declaration(
 680    struct lp_build_tgsi_soa_context *bld,
 681    const struct tgsi_full_declaration *decl)
 682 {
 683    unsigned first = decl->Range.First;
 684    unsigned last = decl->Range.Last;
 685    unsigned idx, i;
 686    LLVMBasicBlockRef current_block =
 687       LLVMGetInsertBlock(bld->base.builder);
 688    LLVMBasicBlockRef first_block =
 689       LLVMGetEntryBasicBlock(
 690          LLVMGetBasicBlockParent(current_block));
 691    LLVMValueRef first_inst =
 692       LLVMGetFirstInstruction(first_block);
 693
 694    /* we want alloca's to be the first instruction
 695     * in the function so we need to rewind the builder
 696     * to the very beginning */
 697    LLVMPositionBuilderBefore(bld->base.builder,
 698                              first_inst);
 699
 700    for (idx = first; idx <= last; ++idx) {
 701       switch (decl->Declaration.File) {
 702       case TGSI_FILE_TEMPORARY:
 703          for (i = 0; i < NUM_CHANNELS; i++)
 704             bld->temps[idx][i] = lp_build_alloca(&bld->base);
 705          break;
 706
 707       case TGSI_FILE_OUTPUT:
 708          for (i = 0; i < NUM_CHANNELS; i++)
 709             bld->outputs[idx][i] = lp_build_alloca(&bld->base);
 710          break;
 711
 712       default:
 713          /* don't need to declare other vars */
 714          break;
 715       }
 716    }
 717
 718    LLVMPositionBuilderAtEnd(bld->base.builder,
 719                             current_block);
 720    return TRUE;
 721 }
 722
 723
 724 /**
 725  * Emit LLVM for one TGSI instruction.
 726  * \param return TRUE for success, FALSE otherwise
 727  */
 728 static boolean
 729 emit_instruction(
 730    struct lp_build_tgsi_soa_context *bld,
 731    const struct tgsi_full_instruction *inst,
 732    const struct tgsi_opcode_info *info)
 733 {
 734    unsigned chan_index;
 735    LLVMValueRef src0, src1, src2;
 736    LLVMValueRef tmp0, tmp1, tmp2;
 737    LLVMValueRef tmp3 = NULL;
 738    LLVMValueRef tmp4 = NULL;
 739    LLVMValueRef tmp5 = NULL;
 740    LLVMValueRef tmp6 = NULL;
 741    LLVMValueRef tmp7 = NULL;
 742    LLVMValueRef res;
 743    LLVMValueRef dst0[NUM_CHANNELS];
 744
 745    /* we can't handle indirect addressing into temp register file yet */
 746    if (indirect_temp_reference(inst))
 747       return FALSE;
 748
 749    /*
 750     * Stores and write masks are handled in a general fashion after the long
 751     * instruction opcode switch statement.
 752     *
 753     * Although not stricitly necessary, we avoid generating instructions for
 754     * channels which won't be stored, in cases where's that easy. For some
 755     * complex instructions, like texture sampling, it is more convenient to
 756     * assume a full writemask and then let LLVM optimization passes eliminate
 757     * redundant code.
 758     */
 759
 760    assert(info->num_dst <= 1);
 761    if(info->num_dst) {
 762       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 763          dst0[chan_index] = bld->base.undef;
 764       }
 765    }
 766
 767    switch (inst->Instruction.Opcode) {
 768 #if 0
 769    case TGSI_OPCODE_ARL:
 770       /* FIXME */
 771       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 772          tmp0 = emit_fetch( bld, inst, 0, chan_index );
 773          emit_flr(bld, 0, 0);
 774          emit_f2it( bld, 0 );
 775          dst0[chan_index] = tmp0;
 776       }
 777       break;
 778 #endif
 779
 780    case TGSI_OPCODE_MOV:
 781       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 782          dst0[chan_index] = emit_fetch( bld, inst, 0, chan_index );
 783       }
 784       break;
 785
 786    case TGSI_OPCODE_LIT:
 787       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ) {
 788          dst0[CHAN_X] = bld->base.one;
 789       }
 790       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ) {
 791          src0 = emit_fetch( bld, inst, 0, CHAN_X );
 792          dst0[CHAN_Y] = lp_build_max( &bld->base, src0, bld->base.zero);
 793       }
 794       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
 795          /* XMM[1] = SrcReg[0].yyyy */
 796          tmp1 = emit_fetch( bld, inst, 0, CHAN_Y );
 797          /* XMM[1] = max(XMM[1], 0) */
 798          tmp1 = lp_build_max( &bld->base, tmp1, bld->base.zero);
 799          /* XMM[2] = SrcReg[0].wwww */
 800          tmp2 = emit_fetch( bld, inst, 0, CHAN_W );
 801          tmp1 = lp_build_pow( &bld->base, tmp1, tmp2);
 802          tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
 803          tmp2 = lp_build_cmp(&bld->base, PIPE_FUNC_GREATER, tmp0, bld->base.zero);
 804          dst0[CHAN_Z] = lp_build_select(&bld->base, tmp2, tmp1, bld->base.zero);
 805       }
 806       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) ) {
 807          dst0[CHAN_W] = bld->base.one;
 808       }
 809       break;
 810
 811    case TGSI_OPCODE_RCP:
 812    /* TGSI_OPCODE_RECIP */
 813       src0 = emit_fetch( bld, inst, 0, CHAN_X );
 814       res = lp_build_rcp(&bld->base, src0);
 815       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 816          dst0[chan_index] = res;
 817       }
 818       break;
 819
 820    case TGSI_OPCODE_RSQ:
 821    /* TGSI_OPCODE_RECIPSQRT */
 822       src0 = emit_fetch( bld, inst, 0, CHAN_X );
 823       src0 = lp_build_abs(&bld->base, src0);
 824       res = lp_build_rsqrt(&bld->base, src0);
 825       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 826          dst0[chan_index] = res;
 827       }
 828       break;
 829
 830    case TGSI_OPCODE_EXP:
 831       if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ||
 832           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ||
 833           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z )) {
 834          LLVMValueRef *p_exp2_int_part = NULL;
 835          LLVMValueRef *p_frac_part = NULL;
 836          LLVMValueRef *p_exp2 = NULL;
 837
 838          src0 = emit_fetch( bld, inst, 0, CHAN_X );
 839
 840          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
 841             p_exp2_int_part = &tmp0;
 842          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ))
 843             p_frac_part = &tmp1;
 844          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
 845             p_exp2 = &tmp2;
 846
 847          lp_build_exp2_approx(&bld->base, src0, p_exp2_int_part, p_frac_part, p_exp2);
 848
 849          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
 850             dst0[CHAN_X] = tmp0;
 851          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ))
 852             dst0[CHAN_Y] = tmp1;
 853          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
 854             dst0[CHAN_Z] = tmp2;
 855       }
 856       /* dst.w = 1.0 */
 857       if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_W )) {
 858          dst0[CHAN_W] = bld->base.one;
 859       }
 860       break;
 861
 862    case TGSI_OPCODE_LOG:
 863       if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ||
 864           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ||
 865           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z )) {
 866          LLVMValueRef *p_floor_log2 = NULL;
 867          LLVMValueRef *p_exp = NULL;
 868          LLVMValueRef *p_log2 = NULL;
 869
 870          src0 = emit_fetch( bld, inst, 0, CHAN_X );
 871          src0 = lp_build_abs( &bld->base, src0 );
 872
 873          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
 874             p_floor_log2 = &tmp0;
 875          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ))
 876             p_exp = &tmp1;
 877          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
 878             p_log2 = &tmp2;
 879
 880          lp_build_log2_approx(&bld->base, src0, p_exp, p_floor_log2, p_log2);
 881
 882          /* dst.x = floor(lg2(abs(src.x))) */
 883          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ))
 884             dst0[CHAN_X] = tmp0;
 885          /* dst.y = abs(src)/ex2(floor(lg2(abs(src.x)))) */
 886          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y )) {
 887             dst0[CHAN_Y] = lp_build_div( &bld->base, src0, tmp1);
 888          }
 889          /* dst.z = lg2(abs(src.x)) */
 890          if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ))
 891             dst0[CHAN_Z] = tmp2;
 892       }
 893       /* dst.w = 1.0 */
 894       if (IS_DST0_CHANNEL_ENABLED( inst, CHAN_W )) {
 895          dst0[CHAN_W] = bld->base.one;
 896       }
 897       break;
 898
 899    case TGSI_OPCODE_MUL:
 900       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 901          src0 = emit_fetch( bld, inst, 0, chan_index );
 902          src1 = emit_fetch( bld, inst, 1, chan_index );
 903          dst0[chan_index] = lp_build_mul(&bld->base, src0, src1);
 904       }
 905       break;
 906
 907    case TGSI_OPCODE_ADD:
 908       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 909          src0 = emit_fetch( bld, inst, 0, chan_index );
 910          src1 = emit_fetch( bld, inst, 1, chan_index );
 911          dst0[chan_index] = lp_build_add(&bld->base, src0, src1);
 912       }
 913       break;
 914
 915    case TGSI_OPCODE_DP3:
 916    /* TGSI_OPCODE_DOT3 */
 917       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
 918       tmp1 = emit_fetch( bld, inst, 1, CHAN_X );
 919       tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
 920       tmp1 = emit_fetch( bld, inst, 0, CHAN_Y );
 921       tmp2 = emit_fetch( bld, inst, 1, CHAN_Y );
 922       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
 923       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
 924       tmp1 = emit_fetch( bld, inst, 0, CHAN_Z );
 925       tmp2 = emit_fetch( bld, inst, 1, CHAN_Z );
 926       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
 927       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
 928       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 929          dst0[chan_index] = tmp0;
 930       }
 931       break;
 932
 933    case TGSI_OPCODE_DP4:
 934    /* TGSI_OPCODE_DOT4 */
 935       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
 936       tmp1 = emit_fetch( bld, inst, 1, CHAN_X );
 937       tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
 938       tmp1 = emit_fetch( bld, inst, 0, CHAN_Y );
 939       tmp2 = emit_fetch( bld, inst, 1, CHAN_Y );
 940       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
 941       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
 942       tmp1 = emit_fetch( bld, inst, 0, CHAN_Z );
 943       tmp2 = emit_fetch( bld, inst, 1, CHAN_Z );
 944       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
 945       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
 946       tmp1 = emit_fetch( bld, inst, 0, CHAN_W );
 947       tmp2 = emit_fetch( bld, inst, 1, CHAN_W );
 948       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
 949       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
 950       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 951          dst0[chan_index] = tmp0;
 952       }
 953       break;
 954
 955    case TGSI_OPCODE_DST:
 956       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
 957          dst0[CHAN_X] = bld->base.one;
 958       }
 959       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
 960          tmp0 = emit_fetch( bld, inst, 0, CHAN_Y );
 961          tmp1 = emit_fetch( bld, inst, 1, CHAN_Y );
 962          dst0[CHAN_Y] = lp_build_mul( &bld->base, tmp0, tmp1);
 963       }
 964       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
 965          dst0[CHAN_Z] = emit_fetch( bld, inst, 0, CHAN_Z );
 966       }
 967       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
 968          dst0[CHAN_W] = emit_fetch( bld, inst, 1, CHAN_W );
 969       }
 970       break;
 971
 972    case TGSI_OPCODE_MIN:
 973       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 974          src0 = emit_fetch( bld, inst, 0, chan_index );
 975          src1 = emit_fetch( bld, inst, 1, chan_index );
 976          dst0[chan_index] = lp_build_min( &bld->base, src0, src1 );
 977       }
 978       break;
 979
 980    case TGSI_OPCODE_MAX:
 981       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 982          src0 = emit_fetch( bld, inst, 0, chan_index );
 983          src1 = emit_fetch( bld, inst, 1, chan_index );
 984          dst0[chan_index] = lp_build_max( &bld->base, src0, src1 );
 985       }
 986       break;
 987
 988    case TGSI_OPCODE_SLT:
 989    /* TGSI_OPCODE_SETLT */
 990       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 991          src0 = emit_fetch( bld, inst, 0, chan_index );
 992          src1 = emit_fetch( bld, inst, 1, chan_index );
 993          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LESS, src0, src1 );
 994          dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
 995       }
 996       break;
 997
 998    case TGSI_OPCODE_SGE:
 999    /* TGSI_OPCODE_SETGE */
1000       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1001          src0 = emit_fetch( bld, inst, 0, chan_index );
1002          src1 = emit_fetch( bld, inst, 1, chan_index );
1003          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GEQUAL, src0, src1 );
1004          dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
1005       }
1006       break;
1007
1008    case TGSI_OPCODE_MAD:
1009    /* TGSI_OPCODE_MADD */
1010       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1011          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1012          tmp1 = emit_fetch( bld, inst, 1, chan_index );
1013          tmp2 = emit_fetch( bld, inst, 2, chan_index );
1014          tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
1015          tmp0 = lp_build_add( &bld->base, tmp0, tmp2);
1016          dst0[chan_index] = tmp0;
1017       }
1018       break;
1019
1020    case TGSI_OPCODE_SUB:
1021       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1022          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1023          tmp1 = emit_fetch( bld, inst, 1, chan_index );
1024          dst0[chan_index] = lp_build_sub( &bld->base, tmp0, tmp1);
1025       }
1026       break;
1027
1028    case TGSI_OPCODE_LRP:
1029       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1030          src0 = emit_fetch( bld, inst, 0, chan_index );
1031          src1 = emit_fetch( bld, inst, 1, chan_index );
1032          src2 = emit_fetch( bld, inst, 2, chan_index );
1033          tmp0 = lp_build_sub( &bld->base, src1, src2 );
1034          tmp0 = lp_build_mul( &bld->base, src0, tmp0 );
1035          dst0[chan_index] = lp_build_add( &bld->base, tmp0, src2 );
1036       }
1037       break;
1038
1039    case TGSI_OPCODE_CND:
1040       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1041          src0 = emit_fetch( bld, inst, 0, chan_index );
1042          src1 = emit_fetch( bld, inst, 1, chan_index );
1043          src2 = emit_fetch( bld, inst, 2, chan_index );
1044          tmp1 = lp_build_const_vec(bld->base.type, 0.5);
1045          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src2, tmp1);
1046          dst0[chan_index] = lp_build_select( &bld->base, tmp0, src0, src1 );
1047       }
1048       break;
1049
1050    case TGSI_OPCODE_DP2A:
1051       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );  /* xmm0 = src[0].x */
1052       tmp1 = emit_fetch( bld, inst, 1, CHAN_X );  /* xmm1 = src[1].x */
1053       tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 * xmm1 */
1054       tmp1 = emit_fetch( bld, inst, 0, CHAN_Y );  /* xmm1 = src[0].y */
1055       tmp2 = emit_fetch( bld, inst, 1, CHAN_Y );  /* xmm2 = src[1].y */
1056       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);              /* xmm1 = xmm1 * xmm2 */
1057       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 + xmm1 */
1058       tmp1 = emit_fetch( bld, inst, 2, CHAN_X );  /* xmm1 = src[2].x */
1059       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 + xmm1 */
1060       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1061          dst0[chan_index] = tmp0;  /* dest[ch] = xmm0 */
1062       }
1063       break;
1064
1065    case TGSI_OPCODE_FRC:
1066       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1067          src0 = emit_fetch( bld, inst, 0, chan_index );
1068          tmp0 = lp_build_floor(&bld->base, src0);
1069          tmp0 = lp_build_sub(&bld->base, src0, tmp0);
1070          dst0[chan_index] = tmp0;
1071       }
1072       break;
1073
1074    case TGSI_OPCODE_CLAMP:
1075       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1076          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1077          src1 = emit_fetch( bld, inst, 1, chan_index );
1078          src2 = emit_fetch( bld, inst, 2, chan_index );
1079          tmp0 = lp_build_max(&bld->base, tmp0, src1);
1080          tmp0 = lp_build_min(&bld->base, tmp0, src2);
1081          dst0[chan_index] = tmp0;
1082       }
1083       break;
1084
1085    case TGSI_OPCODE_FLR:
1086       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1087          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1088          dst0[chan_index] = lp_build_floor(&bld->base, tmp0);
1089       }
1090       break;
1091
1092    case TGSI_OPCODE_ROUND:
1093       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1094          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1095          dst0[chan_index] = lp_build_round(&bld->base, tmp0);
1096       }
1097       break;
1098
1099    case TGSI_OPCODE_EX2: {
1100       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1101       tmp0 = lp_build_exp2( &bld->base, tmp0);
1102       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1103          dst0[chan_index] = tmp0;
1104       }
1105       break;
1106    }
1107
1108    case TGSI_OPCODE_LG2:
1109       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1110       tmp0 = lp_build_log2( &bld->base, tmp0);
1111       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1112          dst0[chan_index] = tmp0;
1113       }
1114       break;
1115
1116    case TGSI_OPCODE_POW:
1117       src0 = emit_fetch( bld, inst, 0, CHAN_X );
1118       src1 = emit_fetch( bld, inst, 1, CHAN_X );
1119       res = lp_build_pow( &bld->base, src0, src1 );
1120       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1121          dst0[chan_index] = res;
1122       }
1123       break;
1124
1125    case TGSI_OPCODE_XPD:
1126       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ||
1127           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ) {
1128          tmp1 = emit_fetch( bld, inst, 1, CHAN_Z );
1129          tmp3 = emit_fetch( bld, inst, 0, CHAN_Z );
1130       }
1131       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) ||
1132           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
1133          tmp0 = emit_fetch( bld, inst, 0, CHAN_Y );
1134          tmp4 = emit_fetch( bld, inst, 1, CHAN_Y );
1135       }
1136       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
1137          tmp2 = tmp0;
1138          tmp2 = lp_build_mul( &bld->base, tmp2, tmp1);
1139          tmp5 = tmp3;
1140          tmp5 = lp_build_mul( &bld->base, tmp5, tmp4);
1141          tmp2 = lp_build_sub( &bld->base, tmp2, tmp5);
1142          dst0[CHAN_X] = tmp2;
1143       }
1144       if( IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) ||
1145           IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) ) {
1146          tmp2 = emit_fetch( bld, inst, 1, CHAN_X );
1147          tmp5 = emit_fetch( bld, inst, 0, CHAN_X );
1148       }
1149       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
1150          tmp3 = lp_build_mul( &bld->base, tmp3, tmp2);
1151          tmp1 = lp_build_mul( &bld->base, tmp1, tmp5);
1152          tmp3 = lp_build_sub( &bld->base, tmp3, tmp1);
1153          dst0[CHAN_Y] = tmp3;
1154       }
1155       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
1156          tmp5 = lp_build_mul( &bld->base, tmp5, tmp4);
1157          tmp0 = lp_build_mul( &bld->base, tmp0, tmp2);
1158          tmp5 = lp_build_sub( &bld->base, tmp5, tmp0);
1159          dst0[CHAN_Z] = tmp5;
1160       }
1161       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
1162          dst0[CHAN_W] = bld->base.one;
1163       }
1164       break;
1165
1166    case TGSI_OPCODE_ABS:
1167       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1168          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1169          dst0[chan_index] = lp_build_abs( &bld->base, tmp0 );
1170       }
1171       break;
1172
1173    case TGSI_OPCODE_RCC:
1174       /* deprecated? */
1175       assert(0);
1176       return FALSE;
1177
1178    case TGSI_OPCODE_DPH:
1179       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1180       tmp1 = emit_fetch( bld, inst, 1, CHAN_X );
1181       tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);
1182       tmp1 = emit_fetch( bld, inst, 0, CHAN_Y );
1183       tmp2 = emit_fetch( bld, inst, 1, CHAN_Y );
1184       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
1185       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
1186       tmp1 = emit_fetch( bld, inst, 0, CHAN_Z );
1187       tmp2 = emit_fetch( bld, inst, 1, CHAN_Z );
1188       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);
1189       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
1190       tmp1 = emit_fetch( bld, inst, 1, CHAN_W );
1191       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
1192       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1193          dst0[chan_index] = tmp0;
1194       }
1195       break;
1196
1197    case TGSI_OPCODE_COS:
1198       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1199       tmp0 = lp_build_cos( &bld->base, tmp0 );
1200       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1201          dst0[chan_index] = tmp0;
1202       }
1203       break;
1204
1205    case TGSI_OPCODE_DDX:
1206       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1207          emit_fetch_deriv( bld, inst, 0, chan_index, NULL, &dst0[chan_index], NULL);
1208       }
1209       break;
1210
1211    case TGSI_OPCODE_DDY:
1212       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1213          emit_fetch_deriv( bld, inst, 0, chan_index, NULL, NULL, &dst0[chan_index]);
1214       }
1215       break;
1216
1217    case TGSI_OPCODE_KILP:
1218       /* predicated kill */
1219       emit_kilp( bld, inst );
1220       break;
1221
1222    case TGSI_OPCODE_KIL:
1223       /* conditional kill */
1224       emit_kil( bld, inst );
1225       break;
1226
1227    case TGSI_OPCODE_PK2H:
1228       return FALSE;
1229       break;
1230
1231    case TGSI_OPCODE_PK2US:
1232       return FALSE;
1233       break;
1234
1235    case TGSI_OPCODE_PK4B:
1236       return FALSE;
1237       break;
1238
1239    case TGSI_OPCODE_PK4UB:
1240       return FALSE;
1241       break;
1242
1243    case TGSI_OPCODE_RFL:
1244       return FALSE;
1245       break;
1246
1247    case TGSI_OPCODE_SEQ:
1248       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1249          src0 = emit_fetch( bld, inst, 0, chan_index );
1250          src1 = emit_fetch( bld, inst, 1, chan_index );
1251          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_EQUAL, src0, src1 );
1252          dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
1253       }
1254       break;
1255
1256    case TGSI_OPCODE_SFL:
1257       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1258          dst0[chan_index] = bld->base.zero;
1259       }
1260       break;
1261
1262    case TGSI_OPCODE_SGT:
1263       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1264          src0 = emit_fetch( bld, inst, 0, chan_index );
1265          src1 = emit_fetch( bld, inst, 1, chan_index );
1266          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_GREATER, src0, src1 );
1267          dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
1268       }
1269       break;
1270
1271    case TGSI_OPCODE_SIN:
1272       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1273       tmp0 = lp_build_sin( &bld->base, tmp0 );
1274       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1275          dst0[chan_index] = tmp0;
1276       }
1277       break;
1278
1279    case TGSI_OPCODE_SLE:
1280       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1281          src0 = emit_fetch( bld, inst, 0, chan_index );
1282          src1 = emit_fetch( bld, inst, 1, chan_index );
1283          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LEQUAL, src0, src1 );
1284          dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
1285       }
1286       break;
1287
1288    case TGSI_OPCODE_SNE:
1289       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1290          src0 = emit_fetch( bld, inst, 0, chan_index );
1291          src1 = emit_fetch( bld, inst, 1, chan_index );
1292          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_NOTEQUAL, src0, src1 );
1293          dst0[chan_index] = lp_build_select( &bld->base, tmp0, bld->base.one, bld->base.zero );
1294       }
1295       break;
1296
1297    case TGSI_OPCODE_STR:
1298       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1299          dst0[chan_index] = bld->base.one;
1300       }
1301       break;
1302
1303    case TGSI_OPCODE_TEX:
1304       emit_tex( bld, inst, FALSE, FALSE, dst0 );
1305       break;
1306
1307    case TGSI_OPCODE_TXD:
1308       /* FIXME */
1309       return FALSE;
1310       break;
1311
1312    case TGSI_OPCODE_UP2H:
1313       /* deprecated */
1314       assert (0);
1315       return FALSE;
1316       break;
1317
1318    case TGSI_OPCODE_UP2US:
1319       /* deprecated */
1320       assert(0);
1321       return FALSE;
1322       break;
1323
1324    case TGSI_OPCODE_UP4B:
1325       /* deprecated */
1326       assert(0);
1327       return FALSE;
1328       break;
1329
1330    case TGSI_OPCODE_UP4UB:
1331       /* deprecated */
1332       assert(0);
1333       return FALSE;
1334       break;
1335
1336    case TGSI_OPCODE_X2D:
1337       /* deprecated? */
1338       assert(0);
1339       return FALSE;
1340       break;
1341
1342    case TGSI_OPCODE_ARA:
1343       /* deprecated */
1344       assert(0);
1345       return FALSE;
1346       break;
1347
1348 #if 0
1349    case TGSI_OPCODE_ARR:
1350       /* FIXME */
1351       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1352          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1353          emit_rnd( bld, 0, 0 );
1354          emit_f2it( bld, 0 );
1355          dst0[chan_index] = tmp0;
1356       }
1357       break;
1358 #endif
1359
1360    case TGSI_OPCODE_BRA:
1361       /* deprecated */
1362       assert(0);
1363       return FALSE;
1364       break;
1365
1366    case TGSI_OPCODE_CAL:
1367       /* FIXME */
1368       return FALSE;
1369       break;
1370
1371    case TGSI_OPCODE_RET:
1372       /* FIXME */
1373       return FALSE;
1374       break;
1375
1376    case TGSI_OPCODE_END:
1377       break;
1378
1379    case TGSI_OPCODE_SSG:
1380    /* TGSI_OPCODE_SGN */
1381       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1382          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1383          dst0[chan_index] = lp_build_sgn( &bld->base, tmp0 );
1384       }
1385       break;
1386
1387    case TGSI_OPCODE_CMP:
1388       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1389          src0 = emit_fetch( bld, inst, 0, chan_index );
1390          src1 = emit_fetch( bld, inst, 1, chan_index );
1391          src2 = emit_fetch( bld, inst, 2, chan_index );
1392          tmp0 = lp_build_cmp( &bld->base, PIPE_FUNC_LESS, src0, bld->base.zero );
1393          dst0[chan_index] = lp_build_select( &bld->base, tmp0, src1, src2);
1394       }
1395       break;
1396
1397    case TGSI_OPCODE_SCS:
1398       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_X ) {
1399          tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1400          dst0[CHAN_X] = lp_build_cos( &bld->base, tmp0 );
1401       }
1402       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Y ) {
1403          tmp0 = emit_fetch( bld, inst, 0, CHAN_X );
1404          dst0[CHAN_Y] = lp_build_sin( &bld->base, tmp0 );
1405       }
1406       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_Z ) {
1407          dst0[CHAN_Z] = bld->base.zero;
1408       }
1409       IF_IS_DST0_CHANNEL_ENABLED( inst, CHAN_W ) {
1410          dst0[CHAN_W] = bld->base.one;
1411       }
1412       break;
1413
1414    case TGSI_OPCODE_TXB:
1415       emit_tex( bld, inst, TRUE, FALSE, dst0 );
1416       break;
1417
1418    case TGSI_OPCODE_NRM:
1419       /* fall-through */
1420    case TGSI_OPCODE_NRM4:
1421       /* 3 or 4-component normalization */
1422       {
1423          uint dims = (inst->Instruction.Opcode == TGSI_OPCODE_NRM) ? 3 : 4;
1424
1425          if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X) ||
1426              IS_DST0_CHANNEL_ENABLED(inst, CHAN_Y) ||
1427              IS_DST0_CHANNEL_ENABLED(inst, CHAN_Z) ||
1428              (IS_DST0_CHANNEL_ENABLED(inst, CHAN_W) && dims == 4)) {
1429
1430             /* NOTE: Cannot use xmm regs 2/3 here (see emit_rsqrt() above). */
1431
1432             /* xmm4 = src.x */
1433             /* xmm0 = src.x * src.x */
1434             tmp0 = emit_fetch(bld, inst, 0, CHAN_X);
1435             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X)) {
1436                tmp4 = tmp0;
1437             }
1438             tmp0 = lp_build_mul( &bld->base, tmp0, tmp0);
1439
1440             /* xmm5 = src.y */
1441             /* xmm0 = xmm0 + src.y * src.y */
1442             tmp1 = emit_fetch(bld, inst, 0, CHAN_Y);
1443             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Y)) {
1444                tmp5 = tmp1;
1445             }
1446             tmp1 = lp_build_mul( &bld->base, tmp1, tmp1);
1447             tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
1448
1449             /* xmm6 = src.z */
1450             /* xmm0 = xmm0 + src.z * src.z */
1451             tmp1 = emit_fetch(bld, inst, 0, CHAN_Z);
1452             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Z)) {
1453                tmp6 = tmp1;
1454             }
1455             tmp1 = lp_build_mul( &bld->base, tmp1, tmp1);
1456             tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
1457
1458             if (dims == 4) {
1459                /* xmm7 = src.w */
1460                /* xmm0 = xmm0 + src.w * src.w */
1461                tmp1 = emit_fetch(bld, inst, 0, CHAN_W);
1462                if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_W)) {
1463                   tmp7 = tmp1;
1464                }
1465                tmp1 = lp_build_mul( &bld->base, tmp1, tmp1);
1466                tmp0 = lp_build_add( &bld->base, tmp0, tmp1);
1467             }
1468
1469             /* xmm1 = 1 / sqrt(xmm0) */
1470             tmp1 = lp_build_rsqrt( &bld->base, tmp0);
1471
1472             /* dst.x = xmm1 * src.x */
1473             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X)) {
1474                dst0[CHAN_X] = lp_build_mul( &bld->base, tmp4, tmp1);
1475             }
1476
1477             /* dst.y = xmm1 * src.y */
1478             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Y)) {
1479                dst0[CHAN_Y] = lp_build_mul( &bld->base, tmp5, tmp1);
1480             }
1481
1482             /* dst.z = xmm1 * src.z */
1483             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_Z)) {
1484                dst0[CHAN_Z] = lp_build_mul( &bld->base, tmp6, tmp1);
1485             }
1486
1487             /* dst.w = xmm1 * src.w */
1488             if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_X) && dims == 4) {
1489                dst0[CHAN_W] = lp_build_mul( &bld->base, tmp7, tmp1);
1490             }
1491          }
1492
1493          /* dst.w = 1.0 */
1494          if (IS_DST0_CHANNEL_ENABLED(inst, CHAN_W) && dims == 3) {
1495             dst0[CHAN_W] = bld->base.one;
1496          }
1497       }
1498       break;
1499
1500    case TGSI_OPCODE_DIV:
1501       /* deprecated */
1502       assert( 0 );
1503       return FALSE;
1504       break;
1505
1506    case TGSI_OPCODE_DP2:
1507       tmp0 = emit_fetch( bld, inst, 0, CHAN_X );  /* xmm0 = src[0].x */
1508       tmp1 = emit_fetch( bld, inst, 1, CHAN_X );  /* xmm1 = src[1].x */
1509       tmp0 = lp_build_mul( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 * xmm1 */
1510       tmp1 = emit_fetch( bld, inst, 0, CHAN_Y );  /* xmm1 = src[0].y */
1511       tmp2 = emit_fetch( bld, inst, 1, CHAN_Y );  /* xmm2 = src[1].y */
1512       tmp1 = lp_build_mul( &bld->base, tmp1, tmp2);              /* xmm1 = xmm1 * xmm2 */
1513       tmp0 = lp_build_add( &bld->base, tmp0, tmp1);              /* xmm0 = xmm0 + xmm1 */
1514       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1515          dst0[chan_index] = tmp0;  /* dest[ch] = xmm0 */
1516       }
1517       break;
1518
1519    case TGSI_OPCODE_TXL:
1520       emit_tex( bld, inst, TRUE, FALSE, dst0 );
1521       break;
1522
1523    case TGSI_OPCODE_TXP:
1524       emit_tex( bld, inst, FALSE, TRUE, dst0 );
1525       break;
1526
1527    case TGSI_OPCODE_BRK:
1528       lp_exec_break(&bld->exec_mask);
1529       break;
1530
1531    case TGSI_OPCODE_IF:
1532       tmp0 = emit_fetch(bld, inst, 0, CHAN_X);
1533       tmp0 = lp_build_cmp(&bld->base, PIPE_FUNC_NOTEQUAL,
1534                           tmp0, bld->base.zero);
1535       lp_exec_mask_cond_push(&bld->exec_mask, tmp0);
1536       break;
1537
1538    case TGSI_OPCODE_BGNFOR:
1539       /* deprecated */
1540       assert(0);
1541       return FALSE;
1542       break;
1543
1544    case TGSI_OPCODE_BGNLOOP:
1545       lp_exec_bgnloop(&bld->exec_mask);
1546       break;
1547
1548    case TGSI_OPCODE_REP:
1549       /* deprecated */
1550       assert(0);
1551       return FALSE;
1552       break;
1553
1554    case TGSI_OPCODE_ELSE:
1555       lp_exec_mask_cond_invert(&bld->exec_mask);
1556       break;
1557
1558    case TGSI_OPCODE_ENDIF:
1559       lp_exec_mask_cond_pop(&bld->exec_mask);
1560       break;
1561
1562    case TGSI_OPCODE_ENDFOR:
1563       /* deprecated */
1564       assert(0);
1565       return FALSE;
1566       break;
1567
1568    case TGSI_OPCODE_ENDLOOP:
1569       lp_exec_endloop(&bld->exec_mask);
1570       break;
1571
1572    case TGSI_OPCODE_ENDREP:
1573       /* deprecated */
1574       assert(0);
1575       return FALSE;
1576       break;
1577
1578    case TGSI_OPCODE_PUSHA:
1579       /* deprecated? */
1580       assert(0);
1581       return FALSE;
1582       break;
1583
1584    case TGSI_OPCODE_POPA:
1585       /* deprecated? */
1586       assert(0);
1587       return FALSE;
1588       break;
1589
1590    case TGSI_OPCODE_CEIL:
1591       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1592          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1593          dst0[chan_index] = lp_build_ceil(&bld->base, tmp0);
1594       }
1595       break;
1596
1597    case TGSI_OPCODE_I2F:
1598       /* deprecated? */
1599       assert(0);
1600       return FALSE;
1601       break;
1602
1603    case TGSI_OPCODE_NOT:
1604       /* deprecated? */
1605       assert(0);
1606       return FALSE;
1607       break;
1608
1609    case TGSI_OPCODE_TRUNC:
1610       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1611          tmp0 = emit_fetch( bld, inst, 0, chan_index );
1612          dst0[chan_index] = lp_build_trunc(&bld->base, tmp0);
1613       }
1614       break;
1615
1616    case TGSI_OPCODE_SHL:
1617       /* deprecated? */
1618       assert(0);
1619       return FALSE;
1620       break;
1621
1622    case TGSI_OPCODE_ISHR:
1623       /* deprecated? */
1624       assert(0);
1625       return FALSE;
1626       break;
1627
1628    case TGSI_OPCODE_AND:
1629       /* deprecated? */
1630       assert(0);
1631       return FALSE;
1632       break;
1633
1634    case TGSI_OPCODE_OR:
1635       /* deprecated? */
1636       assert(0);
1637       return FALSE;
1638       break;
1639
1640    case TGSI_OPCODE_MOD:
1641       /* deprecated? */
1642       assert(0);
1643       return FALSE;
1644       break;
1645
1646    case TGSI_OPCODE_XOR:
1647       /* deprecated? */
1648       assert(0);
1649       return FALSE;
1650       break;
1651
1652    case TGSI_OPCODE_SAD:
1653       /* deprecated? */
1654       assert(0);
1655       return FALSE;
1656       break;
1657
1658    case TGSI_OPCODE_TXF:
1659       /* deprecated? */
1660       assert(0);
1661       return FALSE;
1662       break;
1663
1664    case TGSI_OPCODE_TXQ:
1665       /* deprecated? */
1666       assert(0);
1667       return FALSE;
1668       break;
1669
1670    case TGSI_OPCODE_CONT:
1671       lp_exec_continue(&bld->exec_mask);
1672       break;
1673
1674    case TGSI_OPCODE_EMIT:
1675       return FALSE;
1676       break;
1677
1678    case TGSI_OPCODE_ENDPRIM:
1679       return FALSE;
1680       break;
1681
1682    case TGSI_OPCODE_NOP:
1683       break;
1684
1685    default:
1686       return FALSE;
1687    }
1688
1689    if(info->num_dst) {
1690       FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
1691          emit_store( bld, inst, 0, chan_index, dst0[chan_index]);
1692       }
1693    }
1694
1695    return TRUE;
1696 }
1697
1698
1699 void
1700 lp_build_tgsi_soa(LLVMBuilderRef builder,
1701                   const struct tgsi_token *tokens,
1702                   struct lp_type type,
1703                   struct lp_build_mask_context *mask,
1704                   LLVMValueRef consts_ptr,
1705                   const LLVMValueRef *pos,
1706                   const LLVMValueRef (*inputs)[NUM_CHANNELS],
1707                   LLVMValueRef (*outputs)[NUM_CHANNELS],
1708                   struct lp_build_sampler_soa *sampler)
1709 {
1710    struct lp_build_tgsi_soa_context bld;
1711    struct tgsi_parse_context parse;
1712    uint num_immediates = 0;
1713    unsigned i;
1714
1715    /* Setup build context */
1716    memset(&bld, 0, sizeof bld);
1717    lp_build_context_init(&bld.base, builder, type);
1718    bld.mask = mask;
1719    bld.pos = pos;
1720    bld.inputs = inputs;
1721    bld.outputs = outputs;
1722    bld.consts_ptr = consts_ptr;
1723    bld.sampler = sampler;
1724
1725    lp_exec_mask_init(&bld.exec_mask, &bld.base);
1726
1727    tgsi_parse_init( &parse, tokens );
1728
1729    while( !tgsi_parse_end_of_tokens( &parse ) ) {
1730       tgsi_parse_token( &parse );
1731
1732       switch( parse.FullToken.Token.Type ) {
1733       case TGSI_TOKEN_TYPE_DECLARATION:
1734          /* Inputs already interpolated */
1735          {
1736             if (!emit_declaration( &bld, &parse.FullToken.FullDeclaration ))
1737                _debug_printf("warning: failed to define LLVM variable\n");
1738          }
1739          break;
1740
1741       case TGSI_TOKEN_TYPE_INSTRUCTION:
1742          {
1743             unsigned opcode = parse.FullToken.FullInstruction.Instruction.Opcode;
1744             const struct tgsi_opcode_info *info = tgsi_get_opcode_info(opcode);
1745             if (!emit_instruction( &bld, &parse.FullToken.FullInstruction, info ))
1746                _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
1747                              info ? info->mnemonic : "<invalid>");
1748          }
1749
1750          break;
1751
1752       case TGSI_TOKEN_TYPE_IMMEDIATE:
1753          /* simply copy the immediate values into the next immediates[] slot */
1754          {
1755             const uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;
1756             assert(size <= 4);
1757             assert(num_immediates < LP_MAX_IMMEDIATES);
1758             for( i = 0; i < size; ++i )
1759                bld.immediates[num_immediates][i] =
1760                   lp_build_const_vec(type, parse.FullToken.FullImmediate.u[i].Float);
1761             for( i = size; i < 4; ++i )
1762                bld.immediates[num_immediates][i] = bld.base.undef;
1763             num_immediates++;
1764          }
1765          break;
1766
1767       case TGSI_TOKEN_TYPE_PROPERTY:
1768          break;
1769
1770       default:
1771          assert( 0 );
1772       }
1773    }
1774    if (0) {
1775       LLVMBasicBlockRef block = LLVMGetInsertBlock(builder);
1776       LLVMValueRef function = LLVMGetBasicBlockParent(block);
1777       debug_printf("11111111111111111111111111111 \n");
1778       tgsi_dump(tokens, 0);
1779       LLVMDumpValue(function);
1780       debug_printf("2222222222222222222222222222 \n");
1781    }
1782    tgsi_parse_free( &parse );
1783 }
1784