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