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