src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2011-2012 Advanced Micro Devices, Inc.
   4  * Copyright 2009 VMware, Inc.
   5  * Copyright 2007-2008 VMware, Inc.
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  23  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  24  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  25  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  26  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30 /**
  31  * @file
  32  * TGSI to LLVM IR translation.
  33  *
  34  * @author Jose Fonseca <jfonseca@vmware.com>
  35  * @author Tom Stellard <thomas.stellard@amd.com>
  36  *
  37  * Based on tgsi_sse2.c code written by Michal Krol, Keith Whitwell,
  38  * Brian Paul, and others.
  39  */
  40
  41
  42 #include "lp_bld_tgsi_action.h"
  43
  44 #include "lp_bld_tgsi.h"
  45 #include "lp_bld_arit.h"
  46 #include "lp_bld_bitarit.h"
  47 #include "lp_bld_const.h"
  48 #include "lp_bld_gather.h"
  49 #include "lp_bld_logic.h"
  50
  51 #include "tgsi/tgsi_exec.h"
  52
  53 /* XXX: The CPU only defaults should be repaced by generic ones.  In most
  54  * cases, the CPU defaults are just wrappers around a function in
  55  * lp_build_arit.c and these functions should be inlined here and the CPU
  56  * generic code should be removed and placed elsewhere.
  57  */
  58
  59 /* Default actions */
  60
  61 /* Generic fetch_arg functions */
  62
  63 static void scalar_unary_fetch_args(
  64    struct lp_build_tgsi_context * bld_base,
  65    struct lp_build_emit_data * emit_data)
  66 {
  67    /* src0.x */
  68    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, 0);
  69    emit_data->arg_count = 1;
  70    emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  71 }
  72
  73 static void scalar_binary_fetch_args(
  74    struct lp_build_tgsi_context * bld_base,
  75    struct lp_build_emit_data * emit_data)
  76 {
  77    /* src0.x */
  78    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
  79                                             0, TGSI_CHAN_X);
  80    /* src1.x */
  81    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
  82                                             1, TGSI_CHAN_X);
  83    emit_data->arg_count = 2;
  84    emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  85 }
  86
  87 /* TGSI_OPCODE_ADD */
  88 static void
  89 add_emit(
  90    const struct lp_build_tgsi_action * action,
  91    struct lp_build_tgsi_context * bld_base,
  92    struct lp_build_emit_data * emit_data)
  93 {
  94    emit_data->output[emit_data->chan] = LLVMBuildFAdd(
  95                                 bld_base->base.gallivm->builder,
  96                                 emit_data->args[0], emit_data->args[1], "");
  97 }
  98
  99 /* TGSI_OPCODE_ARR */
 100 static void
 101 arr_emit(
 102    const struct lp_build_tgsi_action * action,
 103    struct lp_build_tgsi_context * bld_base,
 104    struct lp_build_emit_data * emit_data)
 105 {
 106    LLVMValueRef tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ROUND, emit_data->args[0]);
 107    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
 108                                                         bld_base->uint_bld.vec_type, "");
 109 }
 110
 111 /* TGSI_OPCODE_CLAMP */
 112 static void
 113 clamp_emit(
 114    const struct lp_build_tgsi_action * action,
 115    struct lp_build_tgsi_context * bld_base,
 116    struct lp_build_emit_data * emit_data)
 117 {
 118    LLVMValueRef tmp;
 119    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
 120                                    emit_data->args[0],
 121                                    emit_data->args[1]);
 122    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 123                                        TGSI_OPCODE_MIN, tmp, emit_data->args[2]);
 124 }
 125
 126 /* DP* Helper */
 127
 128 static void
 129 dp_fetch_args(
 130    struct lp_build_tgsi_context * bld_base,
 131    struct lp_build_emit_data * emit_data,
 132    unsigned dp_components)
 133 {
 134    unsigned chan, src;
 135    for (src = 0; src < 2; src++) {
 136       for (chan = 0; chan < dp_components; chan++) {
 137          emit_data->args[(src * dp_components) + chan] =
 138                      lp_build_emit_fetch(bld_base, emit_data->inst, src, chan);
 139       }
 140    }
 141    emit_data->dst_type = bld_base->base.elem_type;
 142 }
 143
 144 /* TGSI_OPCODE_DP2 */
 145 static void
 146 dp2_fetch_args(
 147    struct lp_build_tgsi_context * bld_base,
 148    struct lp_build_emit_data * emit_data)
 149 {
 150    dp_fetch_args(bld_base, emit_data, 2);
 151 }
 152
 153 static void
 154 dp2_emit(
 155    const struct lp_build_tgsi_action * action,
 156    struct lp_build_tgsi_context * bld_base,
 157    struct lp_build_emit_data * emit_data)
 158 {
 159    LLVMValueRef tmp0, tmp1;
 160    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 161                                     emit_data->args[0] /* src0.x */,
 162                                     emit_data->args[2] /* src1.x */);
 163    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 164                                     emit_data->args[1] /* src0.y */,
 165                                     emit_data->args[3] /* src1.y */);
 166    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 167                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 168 }
 169
 170 static struct lp_build_tgsi_action dp2_action = {
 171    dp2_fetch_args,       /* fetch_args */
 172    dp2_emit      /* emit */
 173 };
 174
 175 /* TGSI_OPCODE_DP2A */
 176 static void
 177 dp2a_fetch_args(
 178    struct lp_build_tgsi_context * bld_base,
 179    struct lp_build_emit_data * emit_data)
 180 {
 181    dp_fetch_args(bld_base, emit_data, 2);
 182    emit_data->args[5] = lp_build_emit_fetch(bld_base, emit_data->inst,
 183                                             2, TGSI_CHAN_X);
 184 }
 185
 186 static void
 187 dp2a_emit(
 188    const struct lp_build_tgsi_action * action,
 189    struct lp_build_tgsi_context * bld_base,
 190    struct lp_build_emit_data * emit_data)
 191 {
 192    LLVMValueRef tmp;
 193    tmp = lp_build_emit_llvm(bld_base, TGSI_OPCODE_DP2, emit_data);
 194    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD,
 195                                     emit_data->args[5], tmp);
 196 }
 197
 198 static struct lp_build_tgsi_action dp2a_action = {
 199    dp2a_fetch_args,      /* fetch_args */
 200    dp2a_emit     /* emit */
 201 };
 202
 203 /* TGSI_OPCODE_DP3 */
 204 static void
 205 dp3_fetch_args(
 206    struct lp_build_tgsi_context * bld_base,
 207    struct lp_build_emit_data * emit_data)
 208 {
 209    dp_fetch_args(bld_base, emit_data, 3);
 210 }
 211
 212 static void
 213 dp3_emit(
 214    const struct lp_build_tgsi_action * action,
 215    struct lp_build_tgsi_context * bld_base,
 216    struct lp_build_emit_data * emit_data)
 217 {
 218    LLVMValueRef tmp0, tmp1;
 219    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 220                                     emit_data->args[0] /* src0.x */,
 221                                     emit_data->args[3] /* src1.x */);
 222    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 223                                     emit_data->args[1] /* src0.y */,
 224                                     emit_data->args[4] /* src1.y */);
 225    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp1, tmp0);
 226    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 227                                     emit_data->args[2] /* src0.z */,
 228                                     emit_data->args[5] /* src1.z */);
 229    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 230                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 231 }
 232
 233 static struct lp_build_tgsi_action dp3_action = {
 234    dp3_fetch_args,       /* fetch_args */
 235    dp3_emit      /* emit */
 236 };
 237
 238 /* TGSI_OPCODDE_DP4 */
 239
 240 static void
 241 dp4_fetch_args(
 242    struct lp_build_tgsi_context * bld_base,
 243    struct lp_build_emit_data * emit_data)
 244 {
 245    dp_fetch_args(bld_base, emit_data, 4);
 246 }
 247
 248 static void
 249 dp4_emit(
 250    const struct lp_build_tgsi_action * action,
 251    struct lp_build_tgsi_context * bld_base,
 252    struct lp_build_emit_data * emit_data)
 253 {
 254    LLVMValueRef tmp0, tmp1;
 255    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 256                                     emit_data->args[0] /* src0.x */,
 257                                     emit_data->args[4] /* src1.x */);
 258    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 259                                     emit_data->args[1] /* src0.y */,
 260                                     emit_data->args[5] /* src1.y */);
 261    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
 262    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 263                                     emit_data->args[2] /* src0.z */,
 264                                     emit_data->args[6] /* src1.z */);
 265    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
 266    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 267                                     emit_data->args[3] /* src0.w */,
 268                                     emit_data->args[7] /* src1.w */);
 269    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 270                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 271 }
 272
 273 static struct lp_build_tgsi_action dp4_action = {
 274    dp4_fetch_args,       /* fetch_args */
 275    dp4_emit      /* emit */
 276 };
 277
 278 /* TGSI_OPCODE_DPH */
 279 static void
 280 dph_fetch_args(
 281    struct lp_build_tgsi_context * bld_base,
 282    struct lp_build_emit_data * emit_data)
 283 {
 284    dp_fetch_args(bld_base, emit_data, 4);
 285    /* src0.w */
 286    emit_data->args[3] = bld_base->base.one;
 287 }
 288
 289 const struct lp_build_tgsi_action dph_action = {
 290    dph_fetch_args,       /* fetch_args */
 291    dp4_emit      /* emit */
 292 };
 293
 294 /* TGSI_OPCODE_DST */
 295 static void
 296 dst_fetch_args(
 297    struct lp_build_tgsi_context * bld_base,
 298    struct lp_build_emit_data * emit_data)
 299 {
 300    /* src0.y */
 301    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 302                                             0, TGSI_CHAN_Y);
 303    /* src0.z */
 304    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 305                                             0, TGSI_CHAN_Z);
 306    /* src1.y */
 307    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
 308                                             1, TGSI_CHAN_Y);
 309    /* src1.w */
 310    emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
 311                                             1, TGSI_CHAN_W);
 312 }
 313
 314 static void
 315 dst_emit(
 316    const struct lp_build_tgsi_action * action,
 317    struct lp_build_tgsi_context * bld_base,
 318    struct lp_build_emit_data * emit_data)
 319 {
 320    /* dst.x */
 321    emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
 322
 323    /* dst.y */
 324    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 325                                           TGSI_OPCODE_MUL,
 326                                           emit_data->args[0] /* src0.y */,
 327                                           emit_data->args[2] /* src1.y */);
 328    /* dst.z */
 329    emit_data->output[TGSI_CHAN_Z] = emit_data->args[1]; /* src0.z */
 330
 331    /* dst.w */
 332    emit_data->output[TGSI_CHAN_W] = emit_data->args[3]; /* src1.w */
 333 }
 334
 335 static struct lp_build_tgsi_action dst_action = {
 336    dst_fetch_args,       /* fetch_args */
 337    dst_emit      /* emit */
 338 };
 339
 340 /* TGSI_OPCODE_END */
 341 static void
 342 end_emit(
 343    const struct lp_build_tgsi_action * action,
 344    struct lp_build_tgsi_context * bld_base,
 345    struct lp_build_emit_data * emit_data)
 346 {
 347    bld_base->pc = -1;
 348 }
 349
 350 /* TGSI_OPCODE_EXP */
 351
 352 static void
 353 exp_emit(
 354    const struct lp_build_tgsi_action * action,
 355    struct lp_build_tgsi_context * bld_base,
 356    struct lp_build_emit_data * emit_data)
 357 {
 358    LLVMValueRef floor_x;
 359
 360    /* floor( src0.x ) */
 361    floor_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 362                                       emit_data->args[0]);
 363
 364    /* 2 ^ floor( src0.x ) */
 365    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 366                                        TGSI_OPCODE_EX2, floor_x);
 367
 368    /* src0.x - floor( src0.x ) */
 369    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 370                    TGSI_OPCODE_SUB,  emit_data->args[0] /* src0.x */, floor_x);
 371
 372    /* 2 ^ src0.x */
 373    emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_unary(bld_base,
 374                              TGSI_OPCODE_EX2, emit_data->args[0] /* src0.x */);
 375
 376    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 377 }
 378
 379 const struct lp_build_tgsi_action exp_action = {
 380    scalar_unary_fetch_args,      /* fetch_args */
 381    exp_emit      /* emit */
 382 };
 383
 384 /* TGSI_OPCODE_FRC */
 385
 386 static void
 387 frc_emit(
 388    const struct lp_build_tgsi_action * action,
 389    struct lp_build_tgsi_context * bld_base,
 390    struct lp_build_emit_data * emit_data)
 391 {
 392    LLVMValueRef tmp;
 393    tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 394                                   emit_data->args[0]);
 395    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 396                                        TGSI_OPCODE_SUB, emit_data->args[0], tmp);
 397 }
 398
 399 /* TGSI_OPCODE_KILL_IF */
 400
 401 static void
 402 kil_fetch_args(
 403    struct lp_build_tgsi_context * bld_base,
 404    struct lp_build_emit_data * emit_data)
 405 {
 406    /* src0.x */
 407    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 408                                             0, TGSI_CHAN_X);
 409    /* src0.y */
 410    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 411                                             0, TGSI_CHAN_Y);
 412    /* src0.z */
 413    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
 414                                             0, TGSI_CHAN_Z);
 415    /* src0.w */
 416    emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
 417                                             0, TGSI_CHAN_W);
 418    emit_data->arg_count = 4;
 419    emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
 420 }
 421
 422 /* TGSI_OPCODE_KILL */
 423
 424 static void
 425 kilp_fetch_args(
 426    struct lp_build_tgsi_context * bld_base,
 427    struct lp_build_emit_data * emit_data)
 428 {
 429    emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
 430 }
 431
 432 /* TGSI_OPCODE_LIT */
 433
 434 static void
 435 lit_fetch_args(
 436    struct lp_build_tgsi_context * bld_base,
 437    struct lp_build_emit_data * emit_data)
 438 {
 439    /* src0.x */
 440    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_X);
 441    /* src0.y */
 442    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_Y);
 443    /* src0.w */
 444    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W);
 445    emit_data->arg_count = 3;
 446 }
 447
 448 static void
 449 lit_emit(
 450    const struct lp_build_tgsi_action * action,
 451    struct lp_build_tgsi_context * bld_base,
 452    struct lp_build_emit_data * emit_data)
 453 {
 454    LLVMValueRef tmp0, tmp1, tmp2;
 455
 456    /* dst.x */
 457    emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
 458
 459    /* dst. y */
 460    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 461                                                TGSI_OPCODE_MAX,
 462                                                emit_data->args[0] /* src0.x */,
 463                                                bld_base->base.zero);
 464
 465    /* dst.z */
 466    /* XMM[1] = SrcReg[0].yyyy */
 467    tmp1 = emit_data->args[1];
 468    /* XMM[1] = max(XMM[1], 0) */
 469    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
 470                                     tmp1, bld_base->base.zero);
 471    /* XMM[2] = SrcReg[0].wwww */
 472    tmp2 = emit_data->args[2];
 473    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_POW,
 474                                     tmp1, tmp2);
 475    tmp0 = emit_data->args[0];
 476    emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_ternary(bld_base,
 477                                              TGSI_OPCODE_CMP,
 478                                              tmp0, bld_base->base.zero, tmp1);
 479    /* dst.w */
 480    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 481 }
 482
 483 static struct lp_build_tgsi_action lit_action = {
 484    lit_fetch_args,       /* fetch_args */
 485    lit_emit      /* emit */
 486 };
 487
 488 /* TGSI_OPCODE_LOG */
 489
 490 static void
 491 log_emit(
 492    const struct lp_build_tgsi_action * action,
 493    struct lp_build_tgsi_context * bld_base,
 494    struct lp_build_emit_data * emit_data)
 495 {
 496
 497    LLVMValueRef abs_x, log_abs_x, flr_log_abs_x, ex2_flr_log_abs_x;
 498
 499    /* abs( src0.x) */
 500    abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
 501                                     emit_data->args[0] /* src0.x */);
 502
 503    /* log( abs( src0.x ) ) */
 504    log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_LG2,
 505                                         abs_x);
 506
 507    /* floor( log( abs( src0.x ) ) ) */
 508    flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 509                                             log_abs_x);
 510    /* dst.x */
 511    emit_data->output[TGSI_CHAN_X] = flr_log_abs_x;
 512
 513    /* dst.y */
 514    ex2_flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_EX2,
 515                                                 flr_log_abs_x);
 516
 517    /* abs( src0.x ) / 2^( floor( lg2( abs( src0.x ) ) ) ) */
 518    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 519                                     TGSI_OPCODE_DIV, abs_x, ex2_flr_log_abs_x);
 520
 521    /* dst.x */
 522    emit_data->output[TGSI_CHAN_Z] = log_abs_x;
 523
 524    /* dst.w */
 525    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 526 }
 527
 528 static struct lp_build_tgsi_action log_action = {
 529    scalar_unary_fetch_args,      /* fetch_args */
 530    log_emit      /* emit */
 531 };
 532
 533 /* TGSI_OPCODE_LRP */
 534
 535 static void
 536 lrp_emit(
 537    const struct lp_build_tgsi_action * action,
 538    struct lp_build_tgsi_context * bld_base,
 539    struct lp_build_emit_data * emit_data)
 540 {
 541    LLVMValueRef tmp;
 542    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB,
 543                                    emit_data->args[1],
 544                                    emit_data->args[2]);
 545    emit_data->output[emit_data->chan] = lp_build_emit_llvm_ternary(bld_base,
 546                     TGSI_OPCODE_MAD, emit_data->args[0], tmp, emit_data->args[2]);
 547 }
 548
 549 /* TGSI_OPCODE_MAD */
 550
 551 static void
 552 mad_emit(
 553    const struct lp_build_tgsi_action * action,
 554    struct lp_build_tgsi_context * bld_base,
 555    struct lp_build_emit_data * emit_data)
 556 {
 557    LLVMValueRef tmp;
 558    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 559                                    emit_data->args[0],
 560                                    emit_data->args[1]);
 561    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 562                                        TGSI_OPCODE_ADD, tmp, emit_data->args[2]);
 563 }
 564
 565 /* TGSI_OPCODE_MOV */
 566
 567 static void
 568 mov_emit(
 569    const struct lp_build_tgsi_action * action,
 570    struct lp_build_tgsi_context * bld_base,
 571    struct lp_build_emit_data * emit_data)
 572 {
 573    emit_data->output[emit_data->chan] = emit_data->args[0];
 574 }
 575
 576 /* TGSI_OPCODE_MUL */
 577 static void
 578 mul_emit(
 579    const struct lp_build_tgsi_action * action,
 580    struct lp_build_tgsi_context * bld_base,
 581    struct lp_build_emit_data * emit_data)
 582 {
 583    emit_data->output[emit_data->chan] = LLVMBuildFMul(
 584                                    bld_base->base.gallivm->builder,
 585                                    emit_data->args[0], emit_data->args[1], "");
 586 }
 587
 588 /*.TGSI_OPCODE_DIV.*/
 589 static void fdiv_emit(
 590    const struct lp_build_tgsi_action * action,
 591    struct lp_build_tgsi_context * bld_base,
 592    struct lp_build_emit_data * emit_data)
 593 {
 594    emit_data->output[emit_data->chan] = LLVMBuildFDiv(
 595                                    bld_base->base.gallivm->builder,
 596                                    emit_data->args[0], emit_data->args[1], "");
 597 }
 598
 599 /*.TGSI_OPCODE_RCP.*/
 600 static void rcp_emit(
 601    const struct lp_build_tgsi_action * action,
 602    struct lp_build_tgsi_context * bld_base,
 603    struct lp_build_emit_data * emit_data)
 604 {
 605    LLVMValueRef one;
 606    one = lp_build_const_float(bld_base->base.gallivm, 1.0f);
 607    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 608                                    TGSI_OPCODE_DIV, one, emit_data->args[0]);
 609 }
 610
 611 /* TGSI_OPCODE_POW */
 612
 613 static void
 614 pow_emit(
 615    const struct lp_build_tgsi_action * action,
 616    struct lp_build_tgsi_context * bld_base,
 617    struct lp_build_emit_data * emit_data)
 618 {
 619    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
 620                                    emit_data->args[0], emit_data->args[1]);
 621 }
 622
 623 static struct lp_build_tgsi_action pow_action = {
 624    scalar_binary_fetch_args,     /* fetch_args */
 625    pow_emit      /* emit */
 626 };
 627
 628 /* TGSI_OPCODE_RSQ */
 629
 630 static void
 631 rsq_emit(
 632    const struct lp_build_tgsi_action * action,
 633    struct lp_build_tgsi_context * bld_base,
 634    struct lp_build_emit_data * emit_data)
 635 {
 636    if (bld_base->rsq_action.emit) {
 637       bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
 638    } else {
 639       emit_data->output[emit_data->chan] = bld_base->base.undef;
 640    }
 641 }
 642
 643 const struct lp_build_tgsi_action rsq_action = {
 644    scalar_unary_fetch_args,      /* fetch_args */
 645    rsq_emit      /* emit */
 646
 647 };
 648
 649 /* TGSI_OPCODE_SQRT */
 650
 651 static void
 652 sqrt_emit(
 653    const struct lp_build_tgsi_action * action,
 654    struct lp_build_tgsi_context * bld_base,
 655    struct lp_build_emit_data * emit_data)
 656 {
 657    if (bld_base->sqrt_action.emit) {
 658       bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data);
 659    } else {
 660       emit_data->output[emit_data->chan] = bld_base->base.undef;
 661    }
 662 }
 663
 664 const struct lp_build_tgsi_action sqrt_action = {
 665    scalar_unary_fetch_args,      /* fetch_args */
 666    sqrt_emit     /* emit */
 667 };
 668
 669 /* TGSI_OPCODE_SCS */
 670 static void
 671 scs_emit(
 672    const struct lp_build_tgsi_action * action,
 673    struct lp_build_tgsi_context * bld_base,
 674    struct lp_build_emit_data * emit_data)
 675 {
 676    /* dst.x */
 677    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 678                                            TGSI_OPCODE_COS, emit_data->args[0]);
 679    /* dst.y */
 680    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
 681                                            TGSI_OPCODE_SIN, emit_data->args[0]);
 682    /* dst.z */
 683    emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
 684
 685    /* dst.w */
 686    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 687 }
 688
 689 const struct lp_build_tgsi_action scs_action = {
 690    scalar_unary_fetch_args,      /* fetch_args */
 691    scs_emit      /* emit */
 692 };
 693
 694 /* TGSI_OPCODE_SUB */
 695 static void
 696 sub_emit(
 697    const struct lp_build_tgsi_action * action,
 698    struct lp_build_tgsi_context * bld_base,
 699    struct lp_build_emit_data * emit_data)
 700 {
 701    emit_data->output[emit_data->chan] =
 702       LLVMBuildFSub(bld_base->base.gallivm->builder,
 703                     emit_data->args[0],
 704                     emit_data->args[1], "");
 705 }
 706
 707 /* TGSI_OPCODE_F2U */
 708 static void
 709 f2u_emit(
 710    const struct lp_build_tgsi_action * action,
 711    struct lp_build_tgsi_context * bld_base,
 712    struct lp_build_emit_data * emit_data)
 713 {
 714    emit_data->output[emit_data->chan] =
 715       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
 716                       emit_data->args[0],
 717                       bld_base->base.int_vec_type, "");
 718 }
 719
 720 /* TGSI_OPCODE_U2F */
 721 static void
 722 u2f_emit(
 723    const struct lp_build_tgsi_action * action,
 724    struct lp_build_tgsi_context * bld_base,
 725    struct lp_build_emit_data * emit_data)
 726 {
 727    emit_data->output[emit_data->chan] =
 728       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
 729                       emit_data->args[0],
 730                       bld_base->base.vec_type, "");
 731 }
 732
 733 static void
 734 umad_emit(
 735    const struct lp_build_tgsi_action * action,
 736    struct lp_build_tgsi_context * bld_base,
 737    struct lp_build_emit_data * emit_data)
 738 {
 739    LLVMValueRef tmp;
 740    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
 741                                    emit_data->args[0],
 742                                    emit_data->args[1]);
 743    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 744                                        TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
 745 }
 746
 747 /* TGSI_OPCODE_UMUL */
 748 static void
 749 umul_emit(
 750    const struct lp_build_tgsi_action * action,
 751    struct lp_build_tgsi_context * bld_base,
 752    struct lp_build_emit_data * emit_data)
 753 {
 754    emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
 755                                    emit_data->args[0], emit_data->args[1]);
 756 }
 757
 758 /* TGSI_OPCODE_IMUL_HI */
 759 static void
 760 imul_hi_emit(
 761    const struct lp_build_tgsi_action * action,
 762    struct lp_build_tgsi_context * bld_base,
 763    struct lp_build_emit_data * emit_data)
 764 {
 765    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 766    struct lp_build_context *int_bld = &bld_base->int_bld;
 767    struct lp_type type = int_bld->type;
 768    LLVMValueRef src0, src1;
 769    LLVMValueRef dst64;
 770    LLVMTypeRef typeRef;
 771
 772    assert(type.width == 32);
 773    type.width = 64;
 774    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 775    src0 = LLVMBuildSExt(builder, emit_data->args[0], typeRef, "");
 776    src1 = LLVMBuildSExt(builder, emit_data->args[1], typeRef, "");
 777    dst64 = LLVMBuildMul(builder, src0, src1, "");
 778    dst64 = LLVMBuildAShr(
 779             builder, dst64,
 780             lp_build_const_vec(bld_base->base.gallivm, type, 32), "");
 781    type.width = 32;
 782    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 783    emit_data->output[emit_data->chan] =
 784          LLVMBuildTrunc(builder, dst64, typeRef, "");
 785 }
 786
 787 /* TGSI_OPCODE_UMUL_HI */
 788 static void
 789 umul_hi_emit(
 790    const struct lp_build_tgsi_action * action,
 791    struct lp_build_tgsi_context * bld_base,
 792    struct lp_build_emit_data * emit_data)
 793 {
 794    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 795    struct lp_build_context *uint_bld = &bld_base->uint_bld;
 796    struct lp_type type = uint_bld->type;
 797    LLVMValueRef src0, src1;
 798    LLVMValueRef dst64;
 799    LLVMTypeRef typeRef;
 800
 801    assert(type.width == 32);
 802    type.width = 64;
 803    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 804    src0 = LLVMBuildZExt(builder, emit_data->args[0], typeRef, "");
 805    src1 = LLVMBuildZExt(builder, emit_data->args[1], typeRef, "");
 806    dst64 = LLVMBuildMul(builder, src0, src1, "");
 807    dst64 = LLVMBuildLShr(
 808             builder, dst64,
 809             lp_build_const_vec(bld_base->base.gallivm, type, 32), "");
 810    type.width = 32;
 811    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 812    emit_data->output[emit_data->chan] =
 813          LLVMBuildTrunc(builder, dst64, typeRef, "");
 814 }
 815
 816 /* TGSI_OPCODE_MAX */
 817 static void fmax_emit(
 818    const struct lp_build_tgsi_action * action,
 819    struct lp_build_tgsi_context * bld_base,
 820    struct lp_build_emit_data * emit_data)
 821 {
 822    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 823    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 824                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 825                                    emit_data->args[0], emit_data->args[1], ""),
 826                                    emit_data->args[0], emit_data->args[1], "");
 827 }
 828
 829 /* TGSI_OPCODE_MIN */
 830 static void fmin_emit(
 831    const struct lp_build_tgsi_action * action,
 832    struct lp_build_tgsi_context * bld_base,
 833    struct lp_build_emit_data * emit_data)
 834 {
 835    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 836    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 837                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 838                                    emit_data->args[0], emit_data->args[1], ""),
 839                                    emit_data->args[1], emit_data->args[0], "");
 840 }
 841
 842 /* TGSI_OPCODE_XPD */
 843
 844 static void
 845 xpd_fetch_args(
 846    struct lp_build_tgsi_context * bld_base,
 847    struct lp_build_emit_data * emit_data)
 848 {
 849    dp_fetch_args(bld_base, emit_data, 3);
 850 }
 851
 852 /**
 853  * (a * b) - (c * d)
 854  */
 855 static LLVMValueRef
 856 xpd_helper(
 857   struct lp_build_tgsi_context * bld_base,
 858   LLVMValueRef a,
 859   LLVMValueRef b,
 860   LLVMValueRef c,
 861   LLVMValueRef d)
 862 {
 863    LLVMValueRef tmp0, tmp1;
 864
 865    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
 866    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
 867
 868    return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
 869 }
 870
 871 static void
 872 xpd_emit(
 873    const struct lp_build_tgsi_action * action,
 874    struct lp_build_tgsi_context * bld_base,
 875    struct lp_build_emit_data * emit_data)
 876 {
 877    emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
 878               emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
 879               emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
 880
 881    emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
 882               emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
 883               emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
 884
 885    emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
 886               emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
 887               emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
 888
 889    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 890 }
 891
 892 const struct lp_build_tgsi_action xpd_action = {
 893    xpd_fetch_args,       /* fetch_args */
 894    xpd_emit      /* emit */
 895 };
 896
 897 /* TGSI_OPCODE_D2F */
 898 static void
 899 d2f_emit(
 900    const struct lp_build_tgsi_action * action,
 901    struct lp_build_tgsi_context * bld_base,
 902    struct lp_build_emit_data * emit_data)
 903 {
 904    emit_data->output[emit_data->chan] =
 905       LLVMBuildFPTrunc(bld_base->base.gallivm->builder,
 906                       emit_data->args[0],
 907                        bld_base->base.vec_type, "");
 908 }
 909
 910 /* TGSI_OPCODE_D2I */
 911 static void
 912 d2i_emit(
 913    const struct lp_build_tgsi_action * action,
 914    struct lp_build_tgsi_context * bld_base,
 915    struct lp_build_emit_data * emit_data)
 916 {
 917    emit_data->output[emit_data->chan] =
 918       LLVMBuildFPToSI(bld_base->base.gallivm->builder,
 919                       emit_data->args[0],
 920                       bld_base->base.int_vec_type, "");
 921 }
 922
 923 /* TGSI_OPCODE_D2U */
 924 static void
 925 d2u_emit(
 926    const struct lp_build_tgsi_action * action,
 927    struct lp_build_tgsi_context * bld_base,
 928    struct lp_build_emit_data * emit_data)
 929 {
 930    emit_data->output[emit_data->chan] =
 931       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
 932                       emit_data->args[0],
 933                       bld_base->base.int_vec_type, "");
 934 }
 935
 936 /* TGSI_OPCODE_F2D */
 937 static void
 938 f2d_emit(
 939    const struct lp_build_tgsi_action * action,
 940    struct lp_build_tgsi_context * bld_base,
 941    struct lp_build_emit_data * emit_data)
 942 {
 943    emit_data->output[emit_data->chan] =
 944       LLVMBuildFPExt(bld_base->base.gallivm->builder,
 945                       emit_data->args[0],
 946                       bld_base->dbl_bld.vec_type, "");
 947 }
 948
 949 /* TGSI_OPCODE_U2D */
 950 static void
 951 u2d_emit(
 952    const struct lp_build_tgsi_action * action,
 953    struct lp_build_tgsi_context * bld_base,
 954    struct lp_build_emit_data * emit_data)
 955 {
 956    emit_data->output[emit_data->chan] =
 957       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
 958                       emit_data->args[0],
 959                       bld_base->dbl_bld.vec_type, "");
 960 }
 961
 962 /* TGSI_OPCODE_I2D */
 963 static void
 964 i2d_emit(
 965    const struct lp_build_tgsi_action * action,
 966    struct lp_build_tgsi_context * bld_base,
 967    struct lp_build_emit_data * emit_data)
 968 {
 969    emit_data->output[emit_data->chan] =
 970       LLVMBuildSIToFP(bld_base->base.gallivm->builder,
 971                       emit_data->args[0],
 972                       bld_base->dbl_bld.vec_type, "");
 973 }
 974
 975 /* TGSI_OPCODE_DMAD */
 976 static void
 977 dmad_emit(
 978    const struct lp_build_tgsi_action * action,
 979    struct lp_build_tgsi_context * bld_base,
 980    struct lp_build_emit_data * emit_data)
 981 {
 982    LLVMValueRef tmp;
 983    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_DMUL,
 984                                    emit_data->args[0],
 985                                    emit_data->args[1]);
 986    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 987                                        TGSI_OPCODE_DADD, tmp, emit_data->args[2]);
 988 }
 989
 990 /*.TGSI_OPCODE_DRCP.*/
 991 static void drcp_emit(
 992    const struct lp_build_tgsi_action * action,
 993    struct lp_build_tgsi_context * bld_base,
 994    struct lp_build_emit_data * emit_data)
 995 {
 996    LLVMValueRef one;
 997    one = lp_build_const_vec(bld_base->dbl_bld.gallivm, bld_base->dbl_bld.type, 1.0f);
 998    emit_data->output[emit_data->chan] = LLVMBuildFDiv(
 999       bld_base->base.gallivm->builder,
1000       one, emit_data->args[0], "");
1001 }
1002
1003 /* TGSI_OPCODE_DFRAC */
1004 static void dfrac_emit(
1005    const struct lp_build_tgsi_action * action,
1006    struct lp_build_tgsi_context * bld_base,
1007    struct lp_build_emit_data * emit_data)
1008 {
1009    LLVMValueRef tmp;
1010    tmp = lp_build_floor(&bld_base->dbl_bld,
1011                         emit_data->args[0]);
1012    emit_data->output[emit_data->chan] =  LLVMBuildFSub(bld_base->base.gallivm->builder,
1013                                                        emit_data->args[0], tmp, "");
1014 }
1015
1016 void
1017 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
1018 {
1019    bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
1020    bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
1021    bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
1022    bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
1023    bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
1024    bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
1025    bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
1026    bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
1027    bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
1028    bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
1029    bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action;
1030    bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
1031    bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
1032    bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
1033
1034    bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args;
1035    bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args;
1036    bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args;
1037    bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
1038    bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
1039    bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
1040    bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args;
1041    bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args;
1042    bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args;
1043    bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
1044    bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
1045    bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
1046
1047    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
1048    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
1049    bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
1050    bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
1051    bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
1052    bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
1053    bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
1054    bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
1055    bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
1056    bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
1057    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
1058    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
1059
1060    bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
1061    bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit;
1062    bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
1063    bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
1064    bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
1065    bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit;
1066    bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit;
1067
1068    bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit;
1069    bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit;
1070
1071    bld_base->op_actions[TGSI_OPCODE_DADD].emit = add_emit;
1072    bld_base->op_actions[TGSI_OPCODE_DMAX].emit = fmax_emit;
1073    bld_base->op_actions[TGSI_OPCODE_DMIN].emit = fmin_emit;
1074    bld_base->op_actions[TGSI_OPCODE_DMUL].emit = mul_emit;
1075
1076    bld_base->op_actions[TGSI_OPCODE_D2F].emit = d2f_emit;
1077    bld_base->op_actions[TGSI_OPCODE_D2I].emit = d2i_emit;
1078    bld_base->op_actions[TGSI_OPCODE_D2U].emit = d2u_emit;
1079
1080    bld_base->op_actions[TGSI_OPCODE_F2D].emit = f2d_emit;
1081    bld_base->op_actions[TGSI_OPCODE_I2D].emit = i2d_emit;
1082    bld_base->op_actions[TGSI_OPCODE_U2D].emit = u2d_emit;
1083
1084    bld_base->op_actions[TGSI_OPCODE_DMAD].emit = dmad_emit;
1085
1086    bld_base->op_actions[TGSI_OPCODE_DRCP].emit = drcp_emit;
1087    bld_base->op_actions[TGSI_OPCODE_DFRAC].emit = dfrac_emit;
1088
1089 }
1090
1091 /* CPU Only default actions */
1092
1093 /* These actions are CPU only, because they could potentially output SSE
1094  * intrinsics.
1095  */
1096
1097 /* TGSI_OPCODE_ABS (CPU Only)*/
1098
1099 static void
1100 abs_emit_cpu(
1101    const struct lp_build_tgsi_action * action,
1102    struct lp_build_tgsi_context * bld_base,
1103    struct lp_build_emit_data * emit_data)
1104 {
1105    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base,
1106                                                        emit_data->args[0]);
1107 }
1108
1109 /* TGSI_OPCODE_ADD (CPU Only) */
1110 static void
1111 add_emit_cpu(
1112    const struct lp_build_tgsi_action * action,
1113    struct lp_build_tgsi_context * bld_base,
1114    struct lp_build_emit_data * emit_data)
1115 {
1116    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
1117                                    emit_data->args[0], emit_data->args[1]);
1118 }
1119
1120 /* TGSI_OPCODE_AND (CPU Only) */
1121 static void
1122 and_emit_cpu(
1123    const struct lp_build_tgsi_action * action,
1124    struct lp_build_tgsi_context * bld_base,
1125    struct lp_build_emit_data * emit_data)
1126 {
1127    emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
1128                                    emit_data->args[0], emit_data->args[1]);
1129 }
1130
1131 /* TGSI_OPCODE_ARL (CPU Only) */
1132 static void
1133 arl_emit_cpu(
1134    const struct lp_build_tgsi_action * action,
1135    struct lp_build_tgsi_context * bld_base,
1136    struct lp_build_emit_data * emit_data)
1137 {
1138    LLVMValueRef tmp;
1139    tmp = lp_build_floor(&bld_base->base,
1140                         emit_data->args[0]);
1141    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
1142                                                         bld_base->uint_bld.vec_type, "");
1143 }
1144
1145 /* TGSI_OPCODE_ARR (CPU Only) */
1146 static void
1147 arr_emit_cpu(
1148    const struct lp_build_tgsi_action * action,
1149    struct lp_build_tgsi_context * bld_base,
1150    struct lp_build_emit_data * emit_data)
1151 {
1152    emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
1153 }
1154
1155 /* TGSI_OPCODE_CEIL (CPU Only) */
1156 static void
1157 ceil_emit_cpu(
1158    const struct lp_build_tgsi_action * action,
1159    struct lp_build_tgsi_context * bld_base,
1160    struct lp_build_emit_data * emit_data)
1161 {
1162    emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
1163                                                       emit_data->args[0]);
1164 }
1165
1166 /* TGSI_OPCODE_CMP (CPU Only) */
1167 static void
1168 cmp_emit_cpu(
1169    const struct lp_build_tgsi_action * action,
1170    struct lp_build_tgsi_context * bld_base,
1171    struct lp_build_emit_data * emit_data)
1172 {
1173    LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
1174                                    emit_data->args[0], bld_base->base.zero);
1175    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1176                                 cond, emit_data->args[1], emit_data->args[2]);
1177 }
1178
1179 /* TGSI_OPCODE_UCMP (CPU Only) */
1180 static void
1181 ucmp_emit_cpu(
1182    const struct lp_build_tgsi_action * action,
1183    struct lp_build_tgsi_context * bld_base,
1184    struct lp_build_emit_data * emit_data)
1185 {
1186    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1187    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1188    LLVMValueRef unsigned_cond =
1189       LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, "");
1190    LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL,
1191                                     unsigned_cond,
1192                                     uint_bld->zero);
1193    emit_data->output[emit_data->chan] =
1194       lp_build_select(&bld_base->base,
1195                       cond, emit_data->args[1], emit_data->args[2]);
1196 }
1197
1198 /* TGSI_OPCODE_COS (CPU Only) */
1199 static void
1200 cos_emit_cpu(
1201    const struct lp_build_tgsi_action * action,
1202    struct lp_build_tgsi_context * bld_base,
1203    struct lp_build_emit_data * emit_data)
1204 {
1205    emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
1206                                                        emit_data->args[0]);
1207 }
1208
1209 /* TGSI_OPCODE_DIV (CPU Only) */
1210 static void
1211 div_emit_cpu(
1212    const struct lp_build_tgsi_action * action,
1213    struct lp_build_tgsi_context * bld_base,
1214    struct lp_build_emit_data * emit_data)
1215 {
1216    emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
1217                                    emit_data->args[0], emit_data->args[1]);
1218 }
1219
1220 /* TGSI_OPCODE_EX2 (CPU Only) */
1221 static void
1222 ex2_emit_cpu(
1223    const struct lp_build_tgsi_action * action,
1224    struct lp_build_tgsi_context * bld_base,
1225    struct lp_build_emit_data * emit_data)
1226 {
1227    emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
1228                                                         emit_data->args[0]);
1229 }
1230
1231 /* TGSI_OPCODE_F2I (CPU Only) */
1232 static void
1233 f2i_emit_cpu(
1234    const struct lp_build_tgsi_action * action,
1235    struct lp_build_tgsi_context * bld_base,
1236    struct lp_build_emit_data * emit_data)
1237 {
1238    emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1239                                                         emit_data->args[0]);
1240 }
1241
1242 /* TGSI_OPCODE_FSET Helper (CPU Only) */
1243 static void
1244 fset_emit_cpu(
1245    const struct lp_build_tgsi_action * action,
1246    struct lp_build_tgsi_context * bld_base,
1247    struct lp_build_emit_data * emit_data,
1248    unsigned pipe_func)
1249 {
1250    LLVMValueRef cond;
1251
1252    if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1253       cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1254                                   emit_data->args[0], emit_data->args[1]);
1255    }
1256    else {
1257       cond = lp_build_cmp(&bld_base->base, pipe_func,
1258                           emit_data->args[0], emit_data->args[1]);
1259
1260    }
1261    emit_data->output[emit_data->chan] = cond;
1262 }
1263
1264
1265 /* TGSI_OPCODE_FSEQ (CPU Only) */
1266 static void
1267 fseq_emit_cpu(
1268    const struct lp_build_tgsi_action * action,
1269    struct lp_build_tgsi_context * bld_base,
1270    struct lp_build_emit_data * emit_data)
1271 {
1272    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1273 }
1274
1275 /* TGSI_OPCODE_ISGE (CPU Only) */
1276 static void
1277 fsge_emit_cpu(
1278    const struct lp_build_tgsi_action * action,
1279    struct lp_build_tgsi_context * bld_base,
1280    struct lp_build_emit_data * emit_data)
1281 {
1282    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1283 }
1284
1285 /* TGSI_OPCODE_ISLT (CPU Only) */
1286 static void
1287 fslt_emit_cpu(
1288    const struct lp_build_tgsi_action * action,
1289    struct lp_build_tgsi_context * bld_base,
1290    struct lp_build_emit_data * emit_data)
1291 {
1292    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1293 }
1294
1295 /* TGSI_OPCODE_USNE (CPU Only) */
1296
1297 static void
1298 fsne_emit_cpu(
1299    const struct lp_build_tgsi_action * action,
1300    struct lp_build_tgsi_context * bld_base,
1301    struct lp_build_emit_data * emit_data)
1302 {
1303    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1304 }
1305
1306 /* TGSI_OPCODE_FLR (CPU Only) */
1307
1308 static void
1309 flr_emit_cpu(
1310    const struct lp_build_tgsi_action * action,
1311    struct lp_build_tgsi_context * bld_base,
1312    struct lp_build_emit_data * emit_data)
1313 {
1314    emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
1315                                                          emit_data->args[0]);
1316 }
1317
1318 /* TGSI_OPCODE_I2F (CPU Only) */
1319 static void
1320 i2f_emit_cpu(
1321    const struct lp_build_tgsi_action * action,
1322    struct lp_build_tgsi_context * bld_base,
1323    struct lp_build_emit_data * emit_data)
1324 {
1325    emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1326                                                               emit_data->args[0]);
1327 }
1328
1329 /* TGSI_OPCODE_IABS (CPU Only) */
1330 static void
1331 iabs_emit_cpu(
1332    const struct lp_build_tgsi_action * action,
1333    struct lp_build_tgsi_context * bld_base,
1334    struct lp_build_emit_data * emit_data)
1335 {
1336    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1337                                                        emit_data->args[0]);
1338 }
1339
1340 /* TGSI_OPCODE_IDIV (CPU Only) */
1341 static void
1342 idiv_emit_cpu(
1343    const struct lp_build_tgsi_action * action,
1344    struct lp_build_tgsi_context * bld_base,
1345    struct lp_build_emit_data * emit_data)
1346 {
1347    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1348    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1349                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1350                                         bld_base->uint_bld.zero);
1351    /* We want to make sure that we never divide/mod by zero to not
1352     * generate sigfpe. We don't want to crash just because the
1353     * shader is doing something weird. */
1354    LLVMValueRef divisor = LLVMBuildOr(builder,
1355                                       div_mask,
1356                                       emit_data->args[1], "");
1357    LLVMValueRef result = lp_build_div(&bld_base->int_bld,
1358                                       emit_data->args[0], divisor);
1359    LLVMValueRef not_div_mask = LLVMBuildNot(builder,
1360                                             div_mask,"");
1361    /* idiv by zero doesn't have a guaranteed return value chose 0 for now. */
1362    emit_data->output[emit_data->chan] = LLVMBuildAnd(builder,
1363                                                      not_div_mask,
1364                                                      result, "");
1365 }
1366
1367 /* TGSI_OPCODE_INEG (CPU Only) */
1368 static void
1369 ineg_emit_cpu(
1370    const struct lp_build_tgsi_action * action,
1371    struct lp_build_tgsi_context * bld_base,
1372    struct lp_build_emit_data * emit_data)
1373 {
1374    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld,
1375                                                      bld_base->int_bld.zero,
1376                                                      emit_data->args[0]);
1377 }
1378
1379 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1380 static void
1381 iset_emit_cpu(
1382    const struct lp_build_tgsi_action * action,
1383    struct lp_build_tgsi_context * bld_base,
1384    struct lp_build_emit_data * emit_data,
1385    unsigned pipe_func)
1386 {
1387    LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1388                                     emit_data->args[0], emit_data->args[1]);
1389    emit_data->output[emit_data->chan] = cond;
1390 }
1391
1392 /* TGSI_OPCODE_IMAX (CPU Only) */
1393 static void
1394 imax_emit_cpu(
1395    const struct lp_build_tgsi_action * action,
1396    struct lp_build_tgsi_context * bld_base,
1397    struct lp_build_emit_data * emit_data)
1398 {
1399    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1400                                    emit_data->args[0], emit_data->args[1]);
1401 }
1402
1403 /* TGSI_OPCODE_IMIN (CPU Only) */
1404 static void
1405 imin_emit_cpu(
1406    const struct lp_build_tgsi_action * action,
1407    struct lp_build_tgsi_context * bld_base,
1408    struct lp_build_emit_data * emit_data)
1409 {
1410    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1411                                    emit_data->args[0], emit_data->args[1]);
1412 }
1413
1414 /* TGSI_OPCODE_ISGE (CPU Only) */
1415 static void
1416 isge_emit_cpu(
1417    const struct lp_build_tgsi_action * action,
1418    struct lp_build_tgsi_context * bld_base,
1419    struct lp_build_emit_data * emit_data)
1420 {
1421    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1422 }
1423
1424 /* TGSI_OPCODE_ISHR (CPU Only) */
1425 static void
1426 ishr_emit_cpu(
1427    const struct lp_build_tgsi_action * action,
1428    struct lp_build_tgsi_context * bld_base,
1429    struct lp_build_emit_data * emit_data)
1430 {
1431    struct lp_build_context *int_bld = &bld_base->int_bld;
1432    LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type,
1433                                           int_bld->type.width - 1);
1434    LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask);
1435    emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0],
1436                                                      masked_count);
1437 }
1438
1439 /* TGSI_OPCODE_ISLT (CPU Only) */
1440 static void
1441 islt_emit_cpu(
1442    const struct lp_build_tgsi_action * action,
1443    struct lp_build_tgsi_context * bld_base,
1444    struct lp_build_emit_data * emit_data)
1445 {
1446    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1447 }
1448
1449
1450 /* TGSI_OPCODE_ISSG (CPU Only) */
1451 static void
1452 issg_emit_cpu(
1453    const struct lp_build_tgsi_action * action,
1454    struct lp_build_tgsi_context * bld_base,
1455    struct lp_build_emit_data * emit_data)
1456 {
1457    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1458                                                        emit_data->args[0]);
1459 }
1460
1461 /* TGSI_OPCODE_LG2 (CPU Only) */
1462 static void
1463 lg2_emit_cpu(
1464    const struct lp_build_tgsi_action * action,
1465    struct lp_build_tgsi_context * bld_base,
1466    struct lp_build_emit_data * emit_data)
1467 {
1468    emit_data->output[emit_data->chan] = lp_build_log2_safe(&bld_base->base,
1469                                                            emit_data->args[0]);
1470 }
1471
1472 /* TGSI_OPCODE_LOG (CPU Only) */
1473 static void
1474 log_emit_cpu(
1475    const struct lp_build_tgsi_action * action,
1476    struct lp_build_tgsi_context * bld_base,
1477    struct lp_build_emit_data * emit_data)
1478 {
1479    LLVMValueRef p_floor_log2;
1480    LLVMValueRef p_exp;
1481    LLVMValueRef p_log2;
1482    LLVMValueRef src0 = emit_data->args[0];
1483
1484    lp_build_log2_approx(&bld_base->base, src0,
1485                         &p_exp, &p_floor_log2, &p_log2, FALSE);
1486
1487    emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1488
1489    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1490                                              TGSI_OPCODE_DIV,
1491                                              src0, p_exp);
1492    emit_data->output[TGSI_CHAN_Z] = p_log2;
1493
1494    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1495
1496 }
1497
1498 /* TGSI_OPCODE_MAX (CPU Only) */
1499
1500 static void
1501 max_emit_cpu(
1502    const struct lp_build_tgsi_action * action,
1503    struct lp_build_tgsi_context * bld_base,
1504    struct lp_build_emit_data * emit_data)
1505 {
1506    emit_data->output[emit_data->chan] =
1507       lp_build_max_ext(&bld_base->base,
1508                        emit_data->args[0], emit_data->args[1],
1509                        GALLIVM_NAN_RETURN_OTHER);
1510 }
1511
1512 /* TGSI_OPCODE_MIN (CPU Only) */
1513 static void
1514 min_emit_cpu(
1515    const struct lp_build_tgsi_action * action,
1516    struct lp_build_tgsi_context * bld_base,
1517    struct lp_build_emit_data * emit_data)
1518 {
1519    emit_data->output[emit_data->chan] =
1520       lp_build_min_ext(&bld_base->base,
1521                        emit_data->args[0], emit_data->args[1],
1522                        GALLIVM_NAN_RETURN_OTHER);
1523 }
1524
1525 /* TGSI_OPCODE_MOD (CPU Only) */
1526 static void
1527 mod_emit_cpu(
1528    const struct lp_build_tgsi_action * action,
1529    struct lp_build_tgsi_context * bld_base,
1530    struct lp_build_emit_data * emit_data)
1531 {
1532    emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->int_bld,
1533                                    emit_data->args[0], emit_data->args[1]);
1534 }
1535
1536 /* TGSI_OPCODE_NOT */
1537 static void
1538 not_emit_cpu(
1539    const struct lp_build_tgsi_action * action,
1540    struct lp_build_tgsi_context * bld_base,
1541    struct lp_build_emit_data * emit_data)
1542 {
1543    emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld,
1544                                                      emit_data->args[0]);
1545 }
1546
1547 /* TGSI_OPCODE_OR (CPU Only) */
1548 static void
1549 or_emit_cpu(
1550    const struct lp_build_tgsi_action * action,
1551    struct lp_build_tgsi_context * bld_base,
1552    struct lp_build_emit_data * emit_data)
1553 {
1554    emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld,
1555                                    emit_data->args[0], emit_data->args[1]);
1556 }
1557
1558 /* TGSI_OPCODE_POW (CPU Only) */
1559 static void
1560 pow_emit_cpu(
1561    const struct lp_build_tgsi_action * action,
1562    struct lp_build_tgsi_context * bld_base,
1563    struct lp_build_emit_data * emit_data)
1564 {
1565    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1566                                    emit_data->args[0], emit_data->args[1]);
1567 }
1568
1569
1570 /* TGSI_OPCODE_RCP (CPU Only) */
1571
1572 static void
1573 rcp_emit_cpu(
1574    const struct lp_build_tgsi_action * action,
1575    struct lp_build_tgsi_context * bld_base,
1576    struct lp_build_emit_data * emit_data)
1577 {
1578    emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1579                                                        emit_data->args[0]);
1580 }
1581
1582 /* Reciprical squareroot (CPU Only) */
1583 static void
1584 recip_sqrt_emit_cpu(
1585    const struct lp_build_tgsi_action * action,
1586    struct lp_build_tgsi_context * bld_base,
1587    struct lp_build_emit_data * emit_data)
1588 {
1589    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1590                                                          emit_data->args[0]);
1591 }
1592
1593 static void
1594 sqrt_emit_cpu(
1595    const struct lp_build_tgsi_action * action,
1596    struct lp_build_tgsi_context * bld_base,
1597    struct lp_build_emit_data * emit_data)
1598 {
1599    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base,
1600                                                       emit_data->args[0]);
1601 }
1602
1603
1604 /* TGSI_OPCODE_ROUND (CPU Only) */
1605 static void
1606 round_emit_cpu(
1607    const struct lp_build_tgsi_action * action,
1608    struct lp_build_tgsi_context * bld_base,
1609    struct lp_build_emit_data * emit_data)
1610 {
1611    emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1612                                                          emit_data->args[0]);
1613 }
1614
1615 /* TGSI_OPCODE_SET Helper (CPU Only) */
1616
1617 static void
1618 set_emit_cpu(
1619    const struct lp_build_tgsi_action * action,
1620    struct lp_build_tgsi_context * bld_base,
1621    struct lp_build_emit_data * emit_data,
1622    unsigned pipe_func)
1623 {
1624    LLVMValueRef cond;
1625
1626    if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1627       cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1628                                   emit_data->args[0], emit_data->args[1]);
1629    }
1630    else {
1631       cond = lp_build_cmp(&bld_base->base, pipe_func,
1632                           emit_data->args[0], emit_data->args[1]);
1633
1634    }
1635    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1636                                           cond,
1637                                           bld_base->base.one,
1638                                           bld_base->base.zero);
1639 }
1640
1641 /* TGSI_OPCODE_SEQ (CPU Only) */
1642
1643 static void
1644 seq_emit_cpu(
1645    const struct lp_build_tgsi_action * action,
1646    struct lp_build_tgsi_context * bld_base,
1647    struct lp_build_emit_data * emit_data)
1648 {
1649    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1650 }
1651
1652 /* TGSI_OPCODE_SGE (CPU Only) */
1653 static void
1654 sge_emit_cpu(
1655    const struct lp_build_tgsi_action * action,
1656    struct lp_build_tgsi_context * bld_base,
1657    struct lp_build_emit_data * emit_data)
1658 {
1659    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1660 }
1661
1662 /* TGSI_OPCODE_SGT (CPU Only)*/
1663
1664 static void
1665 sgt_emit_cpu(
1666    const struct lp_build_tgsi_action * action,
1667    struct lp_build_tgsi_context * bld_base,
1668    struct lp_build_emit_data * emit_data)
1669 {
1670    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1671 }
1672
1673 /* TGSI_OPCODE_SHL (CPU Only) */
1674 static void
1675 shl_emit_cpu(
1676    const struct lp_build_tgsi_action * action,
1677    struct lp_build_tgsi_context * bld_base,
1678    struct lp_build_emit_data * emit_data)
1679 {
1680    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1681    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
1682                                           uint_bld->type.width - 1);
1683    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
1684    emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0],
1685                                                      masked_count);
1686 }
1687
1688 /* TGSI_OPCODE_SIN (CPU Only) */
1689 static void
1690 sin_emit_cpu(
1691    const struct lp_build_tgsi_action * action,
1692    struct lp_build_tgsi_context * bld_base,
1693    struct lp_build_emit_data * emit_data)
1694 {
1695    emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base,
1696                                                        emit_data->args[0]);
1697 }
1698
1699 /* TGSI_OPCODE_SLE (CPU Only) */
1700 static void
1701 sle_emit_cpu(
1702    const struct lp_build_tgsi_action * action,
1703    struct lp_build_tgsi_context * bld_base,
1704    struct lp_build_emit_data * emit_data)
1705 {
1706    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
1707 }
1708
1709 /* TGSI_OPCODE_SLT (CPU Only) */
1710 static void
1711 slt_emit_cpu(
1712    const struct lp_build_tgsi_action * action,
1713    struct lp_build_tgsi_context * bld_base,
1714    struct lp_build_emit_data * emit_data)
1715 {
1716    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1717 }
1718
1719 /* TGSI_OPCODE_SNE (CPU Only) */
1720
1721 static void
1722 sne_emit_cpu(
1723    const struct lp_build_tgsi_action * action,
1724    struct lp_build_tgsi_context * bld_base,
1725    struct lp_build_emit_data * emit_data)
1726 {
1727    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1728 }
1729
1730 /* TGSI_OPCODE_SSG (CPU Only) */
1731
1732 static void
1733 ssg_emit_cpu(
1734    const struct lp_build_tgsi_action * action,
1735    struct lp_build_tgsi_context * bld_base,
1736    struct lp_build_emit_data * emit_data)
1737 {
1738    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
1739                                                        emit_data->args[0]);
1740 }
1741
1742 /* TGSI_OPCODE_SUB (CPU Only) */
1743
1744 static void
1745 sub_emit_cpu(
1746    const struct lp_build_tgsi_action * action,
1747    struct lp_build_tgsi_context * bld_base,
1748    struct lp_build_emit_data * emit_data)
1749 {
1750    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
1751                                                         emit_data->args[0],
1752                                                         emit_data->args[1]);
1753 }
1754
1755 /* TGSI_OPCODE_TRUNC (CPU Only) */
1756
1757 static void
1758 trunc_emit_cpu(
1759    const struct lp_build_tgsi_action * action,
1760    struct lp_build_tgsi_context * bld_base,
1761    struct lp_build_emit_data * emit_data)
1762 {
1763    emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
1764                                                          emit_data->args[0]);
1765 }
1766
1767 /* TGSI_OPCODE_UADD (CPU Only) */
1768 static void
1769 uadd_emit_cpu(
1770    const struct lp_build_tgsi_action * action,
1771    struct lp_build_tgsi_context * bld_base,
1772    struct lp_build_emit_data * emit_data)
1773 {
1774    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
1775                                    emit_data->args[0], emit_data->args[1]);
1776 }
1777
1778 /* TGSI_OPCODE_UDIV (CPU Only) */
1779 static void
1780 udiv_emit_cpu(
1781    const struct lp_build_tgsi_action * action,
1782    struct lp_build_tgsi_context * bld_base,
1783    struct lp_build_emit_data * emit_data)
1784 {
1785
1786    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1787    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1788                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1789                                         bld_base->uint_bld.zero);
1790    /* We want to make sure that we never divide/mod by zero to not
1791     * generate sigfpe. We don't want to crash just because the
1792     * shader is doing something weird. */
1793    LLVMValueRef divisor = LLVMBuildOr(builder,
1794                                       div_mask,
1795                                       emit_data->args[1], "");
1796    LLVMValueRef result = lp_build_div(&bld_base->uint_bld,
1797                                       emit_data->args[0], divisor);
1798    /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
1799    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1800                                                     div_mask,
1801                                                     result, "");
1802 }
1803
1804 /* TGSI_OPCODE_UMAX (CPU Only) */
1805 static void
1806 umax_emit_cpu(
1807    const struct lp_build_tgsi_action * action,
1808    struct lp_build_tgsi_context * bld_base,
1809    struct lp_build_emit_data * emit_data)
1810 {
1811    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
1812                                    emit_data->args[0], emit_data->args[1]);
1813 }
1814
1815 /* TGSI_OPCODE_UMIN (CPU Only) */
1816 static void
1817 umin_emit_cpu(
1818    const struct lp_build_tgsi_action * action,
1819    struct lp_build_tgsi_context * bld_base,
1820    struct lp_build_emit_data * emit_data)
1821 {
1822    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld,
1823                                    emit_data->args[0], emit_data->args[1]);
1824 }
1825
1826 /* TGSI_OPCODE_UMOD (CPU Only) */
1827 static void
1828 umod_emit_cpu(
1829    const struct lp_build_tgsi_action * action,
1830    struct lp_build_tgsi_context * bld_base,
1831    struct lp_build_emit_data * emit_data)
1832 {
1833    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1834    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1835                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1836                                         bld_base->uint_bld.zero);
1837    /* We want to make sure that we never divide/mod by zero to not
1838     * generate sigfpe. We don't want to crash just because the
1839     * shader is doing something weird. */
1840    LLVMValueRef divisor = LLVMBuildOr(builder,
1841                                       div_mask,
1842                                       emit_data->args[1], "");
1843    LLVMValueRef result = lp_build_mod(&bld_base->uint_bld,
1844                                       emit_data->args[0], divisor);
1845    /* umod by zero is guaranteed to return 0xffffffff */
1846    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1847                                                     div_mask,
1848                                                     result, "");
1849 }
1850
1851 /* TGSI_OPCODE_USET Helper (CPU Only) */
1852 static void
1853 uset_emit_cpu(
1854    const struct lp_build_tgsi_action * action,
1855    struct lp_build_tgsi_context * bld_base,
1856    struct lp_build_emit_data * emit_data,
1857    unsigned pipe_func)
1858 {
1859    LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
1860                                     emit_data->args[0], emit_data->args[1]);
1861    emit_data->output[emit_data->chan] = cond;
1862 }
1863
1864
1865 /* TGSI_OPCODE_USEQ (CPU Only) */
1866 static void
1867 useq_emit_cpu(
1868    const struct lp_build_tgsi_action * action,
1869    struct lp_build_tgsi_context * bld_base,
1870    struct lp_build_emit_data * emit_data)
1871 {
1872    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1873 }
1874
1875 /* TGSI_OPCODE_ISGE (CPU Only) */
1876 static void
1877 usge_emit_cpu(
1878    const struct lp_build_tgsi_action * action,
1879    struct lp_build_tgsi_context * bld_base,
1880    struct lp_build_emit_data * emit_data)
1881 {
1882    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1883 }
1884
1885 /* TGSI_OPCODE_USHR (CPU Only) */
1886 static void
1887 ushr_emit_cpu(
1888    const struct lp_build_tgsi_action * action,
1889    struct lp_build_tgsi_context * bld_base,
1890    struct lp_build_emit_data * emit_data)
1891 {
1892    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1893    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
1894                                           uint_bld->type.width - 1);
1895    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
1896    emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0],
1897                                                      masked_count);
1898 }
1899
1900 /* TGSI_OPCODE_ISLT (CPU Only) */
1901 static void
1902 uslt_emit_cpu(
1903    const struct lp_build_tgsi_action * action,
1904    struct lp_build_tgsi_context * bld_base,
1905    struct lp_build_emit_data * emit_data)
1906 {
1907    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1908 }
1909
1910 /* TGSI_OPCODE_USNE (CPU Only) */
1911
1912 static void
1913 usne_emit_cpu(
1914    const struct lp_build_tgsi_action * action,
1915    struct lp_build_tgsi_context * bld_base,
1916    struct lp_build_emit_data * emit_data)
1917 {
1918    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1919 }
1920
1921 /* TGSI_OPCODE_XOR */
1922 static void
1923 xor_emit_cpu(
1924    const struct lp_build_tgsi_action * action,
1925    struct lp_build_tgsi_context * bld_base,
1926    struct lp_build_emit_data * emit_data)
1927 {
1928    emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
1929                                                      emit_data->args[0],
1930                                                      emit_data->args[1]);
1931 }
1932
1933 /* TGSI_OPCODE_DABS (CPU Only) */
1934 static void
1935 dabs_emit_cpu(
1936    const struct lp_build_tgsi_action * action,
1937    struct lp_build_tgsi_context * bld_base,
1938    struct lp_build_emit_data * emit_data)
1939 {
1940    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->dbl_bld,
1941                                                        emit_data->args[0]);
1942 }
1943
1944 /* TGSI_OPCODE_DNEG (CPU Only) */
1945 static void
1946 dneg_emit_cpu(
1947    const struct lp_build_tgsi_action * action,
1948    struct lp_build_tgsi_context * bld_base,
1949    struct lp_build_emit_data * emit_data)
1950 {
1951    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->dbl_bld,
1952                                                      bld_base->dbl_bld.zero,
1953                                                      emit_data->args[0]);
1954 }
1955
1956 /* TGSI_OPCODE_DSET Helper (CPU Only) */
1957 static void
1958 dset_emit_cpu(
1959    const struct lp_build_tgsi_action * action,
1960    struct lp_build_tgsi_context * bld_base,
1961    struct lp_build_emit_data * emit_data,
1962    unsigned pipe_func)
1963 {
1964    LLVMValueRef cond = lp_build_cmp(&bld_base->dbl_bld, pipe_func,
1965                                     emit_data->args[0], emit_data->args[1]);
1966    emit_data->output[emit_data->chan] = cond;
1967 }
1968
1969 /* TGSI_OPCODE_DSEQ (CPU Only) */
1970 static void
1971 dseq_emit_cpu(
1972    const struct lp_build_tgsi_action * action,
1973    struct lp_build_tgsi_context * bld_base,
1974    struct lp_build_emit_data * emit_data)
1975 {
1976    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1977 }
1978
1979 /* TGSI_OPCODE_DSGE (CPU Only) */
1980 static void
1981 dsge_emit_cpu(
1982    const struct lp_build_tgsi_action * action,
1983    struct lp_build_tgsi_context * bld_base,
1984    struct lp_build_emit_data * emit_data)
1985 {
1986    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1987 }
1988
1989 /* TGSI_OPCODE_DSLT (CPU Only) */
1990 static void
1991 dslt_emit_cpu(
1992    const struct lp_build_tgsi_action * action,
1993    struct lp_build_tgsi_context * bld_base,
1994    struct lp_build_emit_data * emit_data)
1995 {
1996    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1997 }
1998
1999 /* TGSI_OPCODE_DSNE (CPU Only) */
2000 static void
2001 dsne_emit_cpu(
2002    const struct lp_build_tgsi_action * action,
2003    struct lp_build_tgsi_context * bld_base,
2004    struct lp_build_emit_data * emit_data)
2005 {
2006    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2007 }
2008
2009 /* Double Reciprocal squareroot (CPU Only) */
2010 static void
2011 drecip_sqrt_emit_cpu(
2012    const struct lp_build_tgsi_action * action,
2013    struct lp_build_tgsi_context * bld_base,
2014    struct lp_build_emit_data * emit_data)
2015 {
2016    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->dbl_bld,
2017                                                          emit_data->args[0]);
2018 }
2019
2020 /* Double Squareroot (CPU Only) */
2021 static void
2022 dsqrt_emit_cpu(
2023    const struct lp_build_tgsi_action * action,
2024    struct lp_build_tgsi_context * bld_base,
2025    struct lp_build_emit_data * emit_data)
2026 {
2027    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->dbl_bld,
2028                                                       emit_data->args[0]);
2029 }
2030
2031 void
2032 lp_set_default_actions_cpu(
2033    struct lp_build_tgsi_context * bld_base)
2034 {
2035    lp_set_default_actions(bld_base);
2036    bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
2037    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
2038    bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
2039    bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
2040    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
2041    bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
2042    bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
2043    bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
2044    bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
2045    bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
2046    bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
2047    bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
2048    bld_base->op_actions[TGSI_OPCODE_FSEQ].emit = fseq_emit_cpu;
2049    bld_base->op_actions[TGSI_OPCODE_FSGE].emit = fsge_emit_cpu;
2050    bld_base->op_actions[TGSI_OPCODE_FSLT].emit = fslt_emit_cpu;
2051    bld_base->op_actions[TGSI_OPCODE_FSNE].emit = fsne_emit_cpu;
2052
2053    bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
2054    bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
2055    bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
2056    bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
2057    bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
2058    bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
2059    bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
2060    bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
2061    bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
2062    bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
2063
2064    bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
2065    bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
2066    bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
2067    bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
2068    bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
2069    bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
2070    bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
2071    bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
2072    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
2073    bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
2074    bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
2075    bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
2076    bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
2077    bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
2078    bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
2079    bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
2080    bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
2081    bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
2082    bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
2083    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
2084    bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
2085
2086    bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
2087    bld_base->sqrt_action.emit = sqrt_emit_cpu;
2088
2089    bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
2090    bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu;
2091    bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
2092    bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
2093    bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
2094    bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
2095    bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
2096    bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
2097    bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
2098    bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
2099    bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
2100
2101    bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
2102
2103    bld_base->op_actions[TGSI_OPCODE_DABS].emit = dabs_emit_cpu;
2104    bld_base->op_actions[TGSI_OPCODE_DNEG].emit = dneg_emit_cpu;
2105    bld_base->op_actions[TGSI_OPCODE_DSEQ].emit = dseq_emit_cpu;
2106    bld_base->op_actions[TGSI_OPCODE_DSGE].emit = dsge_emit_cpu;
2107    bld_base->op_actions[TGSI_OPCODE_DSLT].emit = dslt_emit_cpu;
2108    bld_base->op_actions[TGSI_OPCODE_DSNE].emit = dsne_emit_cpu;
2109
2110    bld_base->op_actions[TGSI_OPCODE_DRSQ].emit = drecip_sqrt_emit_cpu;
2111    bld_base->op_actions[TGSI_OPCODE_DSQRT].emit = dsqrt_emit_cpu;
2112
2113 }