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 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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    emit_data->args[0] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
 637                                                emit_data->args[0]);
 638    if (bld_base->rsq_action.emit) {
 639       bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
 640    } else {
 641       emit_data->output[emit_data->chan] = bld_base->base.undef;
 642    }
 643 }
 644
 645 const struct lp_build_tgsi_action rsq_action = {
 646    scalar_unary_fetch_args,      /* fetch_args */
 647    rsq_emit      /* emit */
 648
 649 };
 650
 651 /* TGSI_OPCODE_SQRT */
 652
 653 static void
 654 sqrt_emit(
 655    const struct lp_build_tgsi_action * action,
 656    struct lp_build_tgsi_context * bld_base,
 657    struct lp_build_emit_data * emit_data)
 658 {
 659    if (bld_base->sqrt_action.emit) {
 660       bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data);
 661    } else {
 662       emit_data->output[emit_data->chan] = bld_base->base.undef;
 663    }
 664 }
 665
 666 const struct lp_build_tgsi_action sqrt_action = {
 667    scalar_unary_fetch_args,      /* fetch_args */
 668    sqrt_emit     /* emit */
 669 };
 670
 671 /* TGSI_OPCODE_SCS */
 672 static void
 673 scs_emit(
 674    const struct lp_build_tgsi_action * action,
 675    struct lp_build_tgsi_context * bld_base,
 676    struct lp_build_emit_data * emit_data)
 677 {
 678    /* dst.x */
 679    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 680                                            TGSI_OPCODE_COS, emit_data->args[0]);
 681    /* dst.y */
 682    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
 683                                            TGSI_OPCODE_SIN, emit_data->args[0]);
 684    /* dst.z */
 685    emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
 686
 687    /* dst.w */
 688    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 689 }
 690
 691 const struct lp_build_tgsi_action scs_action = {
 692    scalar_unary_fetch_args,      /* fetch_args */
 693    scs_emit      /* emit */
 694 };
 695
 696 /* TGSI_OPCODE_SFL */
 697
 698 static void
 699 sfl_emit(
 700    const struct lp_build_tgsi_action * action,
 701    struct lp_build_tgsi_context * bld_base,
 702    struct lp_build_emit_data * emit_data)
 703 {
 704    emit_data->output[emit_data->chan] = bld_base->base.zero;
 705 }
 706
 707 /* TGSI_OPCODE_STR */
 708
 709 static void
 710 str_emit(
 711    const struct lp_build_tgsi_action * action,
 712    struct lp_build_tgsi_context * bld_base,
 713    struct lp_build_emit_data * emit_data)
 714 {
 715    emit_data->output[emit_data->chan] = bld_base->base.one;
 716 }
 717
 718 /* TGSI_OPCODE_SUB */
 719 static void
 720 sub_emit(
 721    const struct lp_build_tgsi_action * action,
 722    struct lp_build_tgsi_context * bld_base,
 723    struct lp_build_emit_data * emit_data)
 724 {
 725         emit_data->output[emit_data->chan] = LLVMBuildFSub(
 726                                 bld_base->base.gallivm->builder,
 727                                 emit_data->args[0],
 728                                 emit_data->args[1], "");
 729 }
 730
 731 /* TGSI_OPCODE_U2F */
 732 static void
 733 u2f_emit(
 734    const struct lp_build_tgsi_action * action,
 735    struct lp_build_tgsi_context * bld_base,
 736    struct lp_build_emit_data * emit_data)
 737 {
 738    emit_data->output[emit_data->chan] = LLVMBuildUIToFP(bld_base->base.gallivm->builder,
 739                                                         emit_data->args[0],
 740                                                         bld_base->base.vec_type, "");
 741 }
 742
 743 static void
 744 umad_emit(
 745    const struct lp_build_tgsi_action * action,
 746    struct lp_build_tgsi_context * bld_base,
 747    struct lp_build_emit_data * emit_data)
 748 {
 749    LLVMValueRef tmp;
 750    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
 751                                    emit_data->args[0],
 752                                    emit_data->args[1]);
 753    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 754                                        TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
 755 }
 756
 757 /* TGSI_OPCODE_UMUL */
 758 static void
 759 umul_emit(
 760    const struct lp_build_tgsi_action * action,
 761    struct lp_build_tgsi_context * bld_base,
 762    struct lp_build_emit_data * emit_data)
 763 {
 764    emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
 765                                    emit_data->args[0], emit_data->args[1]);
 766 }
 767
 768 /* TGSI_OPCODE_MAX */
 769 static void fmax_emit(
 770    const struct lp_build_tgsi_action * action,
 771    struct lp_build_tgsi_context * bld_base,
 772    struct lp_build_emit_data * emit_data)
 773 {
 774    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 775    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 776                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 777                                    emit_data->args[0], emit_data->args[1], ""),
 778                                    emit_data->args[0], emit_data->args[1], "");
 779 }
 780
 781 /* TGSI_OPCODE_MIN */
 782 static void fmin_emit(
 783    const struct lp_build_tgsi_action * action,
 784    struct lp_build_tgsi_context * bld_base,
 785    struct lp_build_emit_data * emit_data)
 786 {
 787    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 788    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 789                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 790                                    emit_data->args[0], emit_data->args[1], ""),
 791                                    emit_data->args[1], emit_data->args[0], "");
 792 }
 793
 794 /* TGSI_OPCODE_XPD */
 795
 796 static void
 797 xpd_fetch_args(
 798    struct lp_build_tgsi_context * bld_base,
 799    struct lp_build_emit_data * emit_data)
 800 {
 801    dp_fetch_args(bld_base, emit_data, 3);
 802 }
 803
 804 /**
 805  * (a * b) - (c * d)
 806  */
 807 static LLVMValueRef
 808 xpd_helper(
 809   struct lp_build_tgsi_context * bld_base,
 810   LLVMValueRef a,
 811   LLVMValueRef b,
 812   LLVMValueRef c,
 813   LLVMValueRef d)
 814 {
 815    LLVMValueRef tmp0, tmp1;
 816
 817    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
 818    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
 819
 820    return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
 821 }
 822
 823 static void
 824 xpd_emit(
 825    const struct lp_build_tgsi_action * action,
 826    struct lp_build_tgsi_context * bld_base,
 827    struct lp_build_emit_data * emit_data)
 828 {
 829    emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
 830               emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
 831               emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
 832
 833    emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
 834               emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
 835               emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
 836
 837    emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
 838               emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
 839               emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
 840
 841    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 842 }
 843
 844 const struct lp_build_tgsi_action xpd_action = {
 845    xpd_fetch_args,       /* fetch_args */
 846    xpd_emit      /* emit */
 847 };
 848
 849 void
 850 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
 851 {
 852    bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
 853    bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
 854    bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
 855    bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
 856    bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
 857    bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
 858    bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
 859    bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
 860    bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
 861    bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
 862    bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action;
 863    bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
 864    bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
 865    bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
 866
 867    bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args;
 868    bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args;
 869    bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args;
 870    bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
 871    bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
 872    bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
 873    bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args;
 874    bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args;
 875    bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args;
 876    bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
 877    bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
 878    bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
 879
 880    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
 881    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
 882    bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
 883    bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
 884    bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
 885    bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
 886    bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
 887    bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
 888    bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
 889    bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
 890    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
 891    bld_base->op_actions[TGSI_OPCODE_SFL].emit = sfl_emit;
 892    bld_base->op_actions[TGSI_OPCODE_STR].emit = str_emit;
 893    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
 894
 895    bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
 896    bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
 897    bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
 898    bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
 899
 900    bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit;
 901    bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit;
 902 }
 903
 904 /* CPU Only default actions */
 905
 906 /* These actions are CPU only, because they could potentially output SSE
 907  * intrinsics.
 908  */
 909
 910 /* TGSI_OPCODE_ABS (CPU Only)*/
 911
 912 static void
 913 abs_emit_cpu(
 914    const struct lp_build_tgsi_action * action,
 915    struct lp_build_tgsi_context * bld_base,
 916    struct lp_build_emit_data * emit_data)
 917 {
 918    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base,
 919                                                        emit_data->args[0]);
 920 }
 921
 922 /* TGSI_OPCODE_ADD (CPU Only) */
 923 static void
 924 add_emit_cpu(
 925    const struct lp_build_tgsi_action * action,
 926    struct lp_build_tgsi_context * bld_base,
 927    struct lp_build_emit_data * emit_data)
 928 {
 929    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
 930                                    emit_data->args[0], emit_data->args[1]);
 931 }
 932
 933 /* TGSI_OPCODE_AND (CPU Only) */
 934 static void
 935 and_emit_cpu(
 936    const struct lp_build_tgsi_action * action,
 937    struct lp_build_tgsi_context * bld_base,
 938    struct lp_build_emit_data * emit_data)
 939 {
 940    emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
 941                                    emit_data->args[0], emit_data->args[1]);
 942 }
 943
 944 /* TGSI_OPCODE_ARL (CPU Only) */
 945 static void
 946 arl_emit_cpu(
 947    const struct lp_build_tgsi_action * action,
 948    struct lp_build_tgsi_context * bld_base,
 949    struct lp_build_emit_data * emit_data)
 950 {
 951    LLVMValueRef tmp;
 952    tmp = lp_build_floor(&bld_base->base,
 953                         emit_data->args[0]);
 954    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
 955                                                         bld_base->uint_bld.vec_type, "");
 956 }
 957
 958 /* TGSI_OPCODE_ARR (CPU Only) */
 959 static void
 960 arr_emit_cpu(
 961    const struct lp_build_tgsi_action * action,
 962    struct lp_build_tgsi_context * bld_base,
 963    struct lp_build_emit_data * emit_data)
 964 {
 965    emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
 966 }
 967
 968 /* TGSI_OPCODE_CEIL (CPU Only) */
 969 static void
 970 ceil_emit_cpu(
 971    const struct lp_build_tgsi_action * action,
 972    struct lp_build_tgsi_context * bld_base,
 973    struct lp_build_emit_data * emit_data)
 974 {
 975    emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
 976                                                       emit_data->args[0]);
 977 }
 978
 979 /* TGSI_OPCODE_CMP (CPU Only) */
 980 static void
 981 cmp_emit_cpu(
 982    const struct lp_build_tgsi_action * action,
 983    struct lp_build_tgsi_context * bld_base,
 984    struct lp_build_emit_data * emit_data)
 985 {
 986    LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
 987                                    emit_data->args[0], bld_base->base.zero);
 988    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
 989                                 cond, emit_data->args[1], emit_data->args[2]);
 990 }
 991
 992 /* TGSI_OPCODE_UCMP (CPU Only) */
 993 static void
 994 ucmp_emit_cpu(
 995    const struct lp_build_tgsi_action * action,
 996    struct lp_build_tgsi_context * bld_base,
 997    struct lp_build_emit_data * emit_data)
 998 {
 999    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1000    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1001    LLVMValueRef unsigned_cond =
1002       LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, "");
1003    LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL,
1004                                     unsigned_cond,
1005                                     uint_bld->zero);
1006    emit_data->output[emit_data->chan] =
1007       lp_build_select(&bld_base->base,
1008                       cond, emit_data->args[1], emit_data->args[2]);
1009 }
1010
1011
1012 /* TGSI_OPCODE_CND (CPU Only) */
1013 static void
1014 cnd_emit_cpu(
1015    const struct lp_build_tgsi_action * action,
1016    struct lp_build_tgsi_context * bld_base,
1017    struct lp_build_emit_data * emit_data)
1018 {
1019    LLVMValueRef half, tmp;
1020    half = lp_build_const_vec(bld_base->base.gallivm, bld_base->base.type, 0.5);
1021    tmp = lp_build_cmp(&bld_base->base, PIPE_FUNC_GREATER,
1022                       emit_data->args[2], half);
1023    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1024                                           tmp,
1025                                           emit_data->args[0],
1026                                           emit_data->args[1]);
1027 }
1028
1029 /* TGSI_OPCODE_COS (CPU Only) */
1030 static void
1031 cos_emit_cpu(
1032    const struct lp_build_tgsi_action * action,
1033    struct lp_build_tgsi_context * bld_base,
1034    struct lp_build_emit_data * emit_data)
1035 {
1036    emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
1037                                                        emit_data->args[0]);
1038 }
1039
1040 /* TGSI_OPCODE_DIV (CPU Only) */
1041 static void
1042 div_emit_cpu(
1043    const struct lp_build_tgsi_action * action,
1044    struct lp_build_tgsi_context * bld_base,
1045    struct lp_build_emit_data * emit_data)
1046 {
1047    emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
1048                                    emit_data->args[0], emit_data->args[1]);
1049 }
1050
1051 /* TGSI_OPCODE_EX2 (CPU Only) */
1052 static void
1053 ex2_emit_cpu(
1054    const struct lp_build_tgsi_action * action,
1055    struct lp_build_tgsi_context * bld_base,
1056    struct lp_build_emit_data * emit_data)
1057 {
1058    emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
1059                                                         emit_data->args[0]);
1060 }
1061
1062 /* TGSI_OPCODE_EXP (CPU Only) */
1063 static void
1064 exp_emit_cpu(
1065    const struct lp_build_tgsi_action * action,
1066    struct lp_build_tgsi_context * bld_base,
1067    struct lp_build_emit_data * emit_data)
1068 {
1069    lp_build_exp2_approx(&bld_base->base, emit_data->args[0],
1070                         &emit_data->output[TGSI_CHAN_X],
1071                         &emit_data->output[TGSI_CHAN_Y],
1072                         &emit_data->output[TGSI_CHAN_Z]);
1073    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1074 }
1075
1076 /* TGSI_OPCODE_F2I (CPU Only) */
1077 static void
1078 f2i_emit_cpu(
1079    const struct lp_build_tgsi_action * action,
1080    struct lp_build_tgsi_context * bld_base,
1081    struct lp_build_emit_data * emit_data)
1082 {
1083    emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1084                                                         emit_data->args[0]);
1085 }
1086
1087 /* TGSI_OPCODE_F2U (CPU Only) */
1088 static void
1089 f2u_emit_cpu(
1090    const struct lp_build_tgsi_action * action,
1091    struct lp_build_tgsi_context * bld_base,
1092    struct lp_build_emit_data * emit_data)
1093 {
1094    /* FIXME: implement and use lp_build_utrunc() */
1095    emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1096                                                         emit_data->args[0]);
1097 }
1098
1099 /* TGSI_OPCODE_FLR (CPU Only) */
1100
1101 static void
1102 flr_emit_cpu(
1103    const struct lp_build_tgsi_action * action,
1104    struct lp_build_tgsi_context * bld_base,
1105    struct lp_build_emit_data * emit_data)
1106 {
1107    emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
1108                                                          emit_data->args[0]);
1109 }
1110
1111 /* TGSI_OPCODE_I2F (CPU Only) */
1112 static void
1113 i2f_emit_cpu(
1114    const struct lp_build_tgsi_action * action,
1115    struct lp_build_tgsi_context * bld_base,
1116    struct lp_build_emit_data * emit_data)
1117 {
1118    emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1119                                                               emit_data->args[0]);
1120 }
1121
1122 /* TGSI_OPCODE_IABS (CPU Only) */
1123 static void
1124 iabs_emit_cpu(
1125    const struct lp_build_tgsi_action * action,
1126    struct lp_build_tgsi_context * bld_base,
1127    struct lp_build_emit_data * emit_data)
1128 {
1129    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1130                                                        emit_data->args[0]);
1131 }
1132
1133 /* TGSI_OPCODE_IDIV (CPU Only) */
1134 static void
1135 idiv_emit_cpu(
1136    const struct lp_build_tgsi_action * action,
1137    struct lp_build_tgsi_context * bld_base,
1138    struct lp_build_emit_data * emit_data)
1139 {
1140    emit_data->output[emit_data->chan] = lp_build_div(&bld_base->int_bld,
1141                                    emit_data->args[0], emit_data->args[1]);
1142 }
1143
1144 /* TGSI_OPCODE_INEG (CPU Only) */
1145 static void
1146 ineg_emit_cpu(
1147    const struct lp_build_tgsi_action * action,
1148    struct lp_build_tgsi_context * bld_base,
1149    struct lp_build_emit_data * emit_data)
1150 {
1151    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld,
1152                                                      bld_base->int_bld.zero,
1153                                                      emit_data->args[0]);
1154 }
1155
1156 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1157 static void
1158 iset_emit_cpu(
1159    const struct lp_build_tgsi_action * action,
1160    struct lp_build_tgsi_context * bld_base,
1161    struct lp_build_emit_data * emit_data,
1162    unsigned pipe_func)
1163 {
1164    LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1165                                     emit_data->args[0], emit_data->args[1]);
1166    emit_data->output[emit_data->chan] = cond;
1167 }
1168
1169 /* TGSI_OPCODE_IMAX (CPU Only) */
1170 static void
1171 imax_emit_cpu(
1172    const struct lp_build_tgsi_action * action,
1173    struct lp_build_tgsi_context * bld_base,
1174    struct lp_build_emit_data * emit_data)
1175 {
1176    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1177                                    emit_data->args[0], emit_data->args[1]);
1178 }
1179
1180 /* TGSI_OPCODE_IMIN (CPU Only) */
1181 static void
1182 imin_emit_cpu(
1183    const struct lp_build_tgsi_action * action,
1184    struct lp_build_tgsi_context * bld_base,
1185    struct lp_build_emit_data * emit_data)
1186 {
1187    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1188                                    emit_data->args[0], emit_data->args[1]);
1189 }
1190
1191 /* TGSI_OPCODE_ISGE (CPU Only) */
1192 static void
1193 isge_emit_cpu(
1194    const struct lp_build_tgsi_action * action,
1195    struct lp_build_tgsi_context * bld_base,
1196    struct lp_build_emit_data * emit_data)
1197 {
1198    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1199 }
1200
1201 /* TGSI_OPCODE_ISHR (CPU Only) */
1202 static void
1203 ishr_emit_cpu(
1204    const struct lp_build_tgsi_action * action,
1205    struct lp_build_tgsi_context * bld_base,
1206    struct lp_build_emit_data * emit_data)
1207 {
1208    emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->int_bld,
1209                                    emit_data->args[0], emit_data->args[1]);
1210 }
1211
1212 /* TGSI_OPCODE_ISLT (CPU Only) */
1213 static void
1214 islt_emit_cpu(
1215    const struct lp_build_tgsi_action * action,
1216    struct lp_build_tgsi_context * bld_base,
1217    struct lp_build_emit_data * emit_data)
1218 {
1219    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1220 }
1221
1222
1223 /* TGSI_OPCODE_ISSG (CPU Only) */
1224 static void
1225 issg_emit_cpu(
1226    const struct lp_build_tgsi_action * action,
1227    struct lp_build_tgsi_context * bld_base,
1228    struct lp_build_emit_data * emit_data)
1229 {
1230    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1231                                                        emit_data->args[0]);
1232 }
1233
1234 /* TGSI_OPCODE_LG2 (CPU Only) */
1235 static void
1236 lg2_emit_cpu(
1237    const struct lp_build_tgsi_action * action,
1238    struct lp_build_tgsi_context * bld_base,
1239    struct lp_build_emit_data * emit_data)
1240 {
1241    emit_data->output[emit_data->chan] = lp_build_log2(&bld_base->base,
1242                                                         emit_data->args[0]);
1243 }
1244
1245 /* TGSI_OPCODE_LOG (CPU Only) */
1246 static void
1247 log_emit_cpu(
1248    const struct lp_build_tgsi_action * action,
1249    struct lp_build_tgsi_context * bld_base,
1250    struct lp_build_emit_data * emit_data)
1251 {
1252    LLVMValueRef p_floor_log2;
1253    LLVMValueRef p_exp;
1254    LLVMValueRef p_log2;
1255    LLVMValueRef src0 = emit_data->args[0];
1256
1257    lp_build_log2_approx(&bld_base->base, src0,
1258                         &p_exp, &p_floor_log2, &p_log2);
1259
1260    emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1261
1262    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1263                                              TGSI_OPCODE_DIV,
1264                                              src0, p_exp);
1265    emit_data->output[TGSI_CHAN_Z] = p_log2;
1266
1267    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1268
1269 }
1270
1271 /* TGSI_OPCODE_MAX (CPU Only) */
1272
1273 static void
1274 max_emit_cpu(
1275    const struct lp_build_tgsi_action * action,
1276    struct lp_build_tgsi_context * bld_base,
1277    struct lp_build_emit_data * emit_data)
1278 {
1279    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->base,
1280                                    emit_data->args[0], emit_data->args[1]);
1281 }
1282
1283 /* TGSI_OPCODE_MIN (CPU Only) */
1284 static void
1285 min_emit_cpu(
1286    const struct lp_build_tgsi_action * action,
1287    struct lp_build_tgsi_context * bld_base,
1288    struct lp_build_emit_data * emit_data)
1289 {
1290    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->base,
1291                                    emit_data->args[0], emit_data->args[1]);
1292 }
1293
1294 /* TGSI_OPCODE_MOD (CPU Only) */
1295 static void
1296 mod_emit_cpu(
1297    const struct lp_build_tgsi_action * action,
1298    struct lp_build_tgsi_context * bld_base,
1299    struct lp_build_emit_data * emit_data)
1300 {
1301    emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->int_bld,
1302                                    emit_data->args[0], emit_data->args[1]);
1303 }
1304
1305 /* TGSI_OPCODE_NOT */
1306 static void
1307 not_emit_cpu(
1308    const struct lp_build_tgsi_action * action,
1309    struct lp_build_tgsi_context * bld_base,
1310    struct lp_build_emit_data * emit_data)
1311 {
1312    emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld,
1313                                                      emit_data->args[0]);
1314 }
1315
1316 /* TGSI_OPCODE_OR (CPU Only) */
1317 static void
1318 or_emit_cpu(
1319    const struct lp_build_tgsi_action * action,
1320    struct lp_build_tgsi_context * bld_base,
1321    struct lp_build_emit_data * emit_data)
1322 {
1323    emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld,
1324                                    emit_data->args[0], emit_data->args[1]);
1325 }
1326
1327 /* TGSI_OPCODE_POW (CPU Only) */
1328 static void
1329 pow_emit_cpu(
1330    const struct lp_build_tgsi_action * action,
1331    struct lp_build_tgsi_context * bld_base,
1332    struct lp_build_emit_data * emit_data)
1333 {
1334    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1335                                    emit_data->args[0], emit_data->args[1]);
1336 }
1337
1338
1339 /* TGSI_OPCODE_RCP (CPU Only) */
1340
1341 static void
1342 rcp_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    emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1348                                                        emit_data->args[0]);
1349 }
1350
1351 /* Reciprical squareroot (CPU Only) */
1352
1353 /* This is not the same as TGSI_OPCODE_RSQ, which requres the argument to be
1354  * greater than or equal to 0 */
1355 static void
1356 recip_sqrt_emit_cpu(
1357    const struct lp_build_tgsi_action * action,
1358    struct lp_build_tgsi_context * bld_base,
1359    struct lp_build_emit_data * emit_data)
1360 {
1361    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1362                                                          emit_data->args[0]);
1363 }
1364
1365 static void
1366 sqrt_emit_cpu(
1367    const struct lp_build_tgsi_action * action,
1368    struct lp_build_tgsi_context * bld_base,
1369    struct lp_build_emit_data * emit_data)
1370 {
1371    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base,
1372                                                       emit_data->args[0]);
1373 }
1374
1375
1376 /* TGSI_OPCODE_ROUND (CPU Only) */
1377 static void
1378 round_emit_cpu(
1379    const struct lp_build_tgsi_action * action,
1380    struct lp_build_tgsi_context * bld_base,
1381    struct lp_build_emit_data * emit_data)
1382 {
1383    emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1384                                                          emit_data->args[0]);
1385 }
1386
1387 /* TGSI_OPCODE_SET Helper (CPU Only) */
1388
1389 static void
1390 set_emit_cpu(
1391    const struct lp_build_tgsi_action * action,
1392    struct lp_build_tgsi_context * bld_base,
1393    struct lp_build_emit_data * emit_data,
1394    unsigned pipe_func)
1395 {
1396    LLVMValueRef cond = lp_build_cmp(&bld_base->base, pipe_func,
1397                                     emit_data->args[0], emit_data->args[1]);
1398    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1399                                           cond,
1400                                           bld_base->base.one,
1401                                           bld_base->base.zero);
1402 }
1403
1404 /* TGSI_OPCODE_SEQ (CPU Only) */
1405
1406 static void
1407 seq_emit_cpu(
1408    const struct lp_build_tgsi_action * action,
1409    struct lp_build_tgsi_context * bld_base,
1410    struct lp_build_emit_data * emit_data)
1411 {
1412    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1413 }
1414
1415 /* TGSI_OPCODE_SGE (CPU Only) */
1416 static void
1417 sge_emit_cpu(
1418    const struct lp_build_tgsi_action * action,
1419    struct lp_build_tgsi_context * bld_base,
1420    struct lp_build_emit_data * emit_data)
1421 {
1422    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1423 }
1424
1425 /* TGSI_OPCODE_SGT (CPU Only)*/
1426
1427 static void
1428 sgt_emit_cpu(
1429    const struct lp_build_tgsi_action * action,
1430    struct lp_build_tgsi_context * bld_base,
1431    struct lp_build_emit_data * emit_data)
1432 {
1433    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1434 }
1435
1436 /* TGSI_OPCODE_SHL (CPU Only) */
1437 static void
1438 shl_emit_cpu(
1439    const struct lp_build_tgsi_action * action,
1440    struct lp_build_tgsi_context * bld_base,
1441    struct lp_build_emit_data * emit_data)
1442 {
1443    emit_data->output[emit_data->chan] = lp_build_shl(&bld_base->uint_bld,
1444                                    emit_data->args[0], emit_data->args[1]);
1445 }
1446
1447 /* TGSI_OPCODE_SIN (CPU Only) */
1448 static void
1449 sin_emit_cpu(
1450    const struct lp_build_tgsi_action * action,
1451    struct lp_build_tgsi_context * bld_base,
1452    struct lp_build_emit_data * emit_data)
1453 {
1454    emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base,
1455                                                        emit_data->args[0]);
1456 }
1457
1458 /* TGSI_OPCODE_SLE (CPU Only) */
1459 static void
1460 sle_emit_cpu(
1461    const struct lp_build_tgsi_action * action,
1462    struct lp_build_tgsi_context * bld_base,
1463    struct lp_build_emit_data * emit_data)
1464 {
1465    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
1466 }
1467
1468 /* TGSI_OPCODE_SLT (CPU Only) */
1469 static void
1470 slt_emit_cpu(
1471    const struct lp_build_tgsi_action * action,
1472    struct lp_build_tgsi_context * bld_base,
1473    struct lp_build_emit_data * emit_data)
1474 {
1475    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1476 }
1477
1478 /* TGSI_OPCODE_SNE (CPU Only) */
1479
1480 static void
1481 sne_emit_cpu(
1482    const struct lp_build_tgsi_action * action,
1483    struct lp_build_tgsi_context * bld_base,
1484    struct lp_build_emit_data * emit_data)
1485 {
1486    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1487 }
1488
1489 /* TGSI_OPCODE_SSG (CPU Only) */
1490
1491 static void
1492 ssg_emit_cpu(
1493    const struct lp_build_tgsi_action * action,
1494    struct lp_build_tgsi_context * bld_base,
1495    struct lp_build_emit_data * emit_data)
1496 {
1497    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
1498                                                        emit_data->args[0]);
1499 }
1500
1501 /* TGSI_OPCODE_SUB (CPU Only) */
1502
1503 static void
1504 sub_emit_cpu(
1505    const struct lp_build_tgsi_action * action,
1506    struct lp_build_tgsi_context * bld_base,
1507    struct lp_build_emit_data * emit_data)
1508 {
1509    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
1510                                                         emit_data->args[0],
1511                                                         emit_data->args[1]);
1512 }
1513
1514 /* TGSI_OPCODE_TRUNC (CPU Only) */
1515
1516 static void
1517 trunc_emit_cpu(
1518    const struct lp_build_tgsi_action * action,
1519    struct lp_build_tgsi_context * bld_base,
1520    struct lp_build_emit_data * emit_data)
1521 {
1522    emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
1523                                                          emit_data->args[0]);
1524 }
1525
1526 /* TGSI_OPCODE_UADD (CPU Only) */
1527 static void
1528 uadd_emit_cpu(
1529    const struct lp_build_tgsi_action * action,
1530    struct lp_build_tgsi_context * bld_base,
1531    struct lp_build_emit_data * emit_data)
1532 {
1533    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
1534                                    emit_data->args[0], emit_data->args[1]);
1535 }
1536
1537 /* TGSI_OPCODE_UDIV (CPU Only) */
1538 static void
1539 udiv_emit_cpu(
1540    const struct lp_build_tgsi_action * action,
1541    struct lp_build_tgsi_context * bld_base,
1542    struct lp_build_emit_data * emit_data)
1543 {
1544
1545    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1546    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1547                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1548                                         bld_base->uint_bld.zero);
1549    /* We want to make sure that we never divide/mod by zero to not
1550     * generate sigfpe. We don't want to crash just because the
1551     * shader is doing something weird. */
1552    LLVMValueRef divisor = LLVMBuildOr(builder,
1553                                       div_mask,
1554                                       emit_data->args[1], "");
1555    LLVMValueRef result = lp_build_div(&bld_base->uint_bld,
1556                                       emit_data->args[0], divisor);
1557    /* udiv by zero is guaranteed to return 0xffffffff */
1558    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1559                                                     div_mask,
1560                                                     result, "");
1561 }
1562
1563 /* TGSI_OPCODE_UMAX (CPU Only) */
1564 static void
1565 umax_emit_cpu(
1566    const struct lp_build_tgsi_action * action,
1567    struct lp_build_tgsi_context * bld_base,
1568    struct lp_build_emit_data * emit_data)
1569 {
1570    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
1571                                    emit_data->args[0], emit_data->args[1]);
1572 }
1573
1574 /* TGSI_OPCODE_UMIN (CPU Only) */
1575 static void
1576 umin_emit_cpu(
1577    const struct lp_build_tgsi_action * action,
1578    struct lp_build_tgsi_context * bld_base,
1579    struct lp_build_emit_data * emit_data)
1580 {
1581    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld,
1582                                    emit_data->args[0], emit_data->args[1]);
1583 }
1584
1585 /* TGSI_OPCODE_UMOD (CPU Only) */
1586 static void
1587 umod_emit_cpu(
1588    const struct lp_build_tgsi_action * action,
1589    struct lp_build_tgsi_context * bld_base,
1590    struct lp_build_emit_data * emit_data)
1591 {
1592    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1593    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1594                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1595                                         bld_base->uint_bld.zero);
1596    /* We want to make sure that we never divide/mod by zero to not
1597     * generate sigfpe. We don't want to crash just because the
1598     * shader is doing something weird. */
1599    LLVMValueRef divisor = LLVMBuildOr(builder,
1600                                       div_mask,
1601                                       emit_data->args[1], "");
1602    LLVMValueRef result = lp_build_mod(&bld_base->uint_bld,
1603                                       emit_data->args[0], divisor);
1604    /* umod by zero is guaranteed to return 0xffffffff */
1605    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1606                                                     div_mask,
1607                                                     result, "");
1608 }
1609
1610 /* TGSI_OPCODE_USET Helper (CPU Only) */
1611 static void
1612 uset_emit_cpu(
1613    const struct lp_build_tgsi_action * action,
1614    struct lp_build_tgsi_context * bld_base,
1615    struct lp_build_emit_data * emit_data,
1616    unsigned pipe_func)
1617 {
1618    LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
1619                                     emit_data->args[0], emit_data->args[1]);
1620    emit_data->output[emit_data->chan] = cond;
1621 }
1622
1623
1624 /* TGSI_OPCODE_USEQ (CPU Only) */
1625 static void
1626 useq_emit_cpu(
1627    const struct lp_build_tgsi_action * action,
1628    struct lp_build_tgsi_context * bld_base,
1629    struct lp_build_emit_data * emit_data)
1630 {
1631    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1632 }
1633
1634 /* TGSI_OPCODE_ISGE (CPU Only) */
1635 static void
1636 usge_emit_cpu(
1637    const struct lp_build_tgsi_action * action,
1638    struct lp_build_tgsi_context * bld_base,
1639    struct lp_build_emit_data * emit_data)
1640 {
1641    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1642 }
1643
1644 /* TGSI_OPCODE_USHR (CPU Only) */
1645 static void
1646 ushr_emit_cpu(
1647    const struct lp_build_tgsi_action * action,
1648    struct lp_build_tgsi_context * bld_base,
1649    struct lp_build_emit_data * emit_data)
1650 {
1651    emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->uint_bld,
1652                                    emit_data->args[0], emit_data->args[1]);
1653 }
1654
1655 /* TGSI_OPCODE_ISLT (CPU Only) */
1656 static void
1657 uslt_emit_cpu(
1658    const struct lp_build_tgsi_action * action,
1659    struct lp_build_tgsi_context * bld_base,
1660    struct lp_build_emit_data * emit_data)
1661 {
1662    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1663 }
1664
1665 /* TGSI_OPCODE_USNE (CPU Only) */
1666
1667 static void
1668 usne_emit_cpu(
1669    const struct lp_build_tgsi_action * action,
1670    struct lp_build_tgsi_context * bld_base,
1671    struct lp_build_emit_data * emit_data)
1672 {
1673    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1674 }
1675
1676 /* TGSI_OPCODE_XOR */
1677 static void
1678 xor_emit_cpu(
1679    const struct lp_build_tgsi_action * action,
1680    struct lp_build_tgsi_context * bld_base,
1681    struct lp_build_emit_data * emit_data)
1682 {
1683    emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
1684                                                      emit_data->args[0],
1685                                                      emit_data->args[1]);
1686 }
1687
1688 void
1689 lp_set_default_actions_cpu(
1690    struct lp_build_tgsi_context * bld_base)
1691 {
1692    lp_set_default_actions(bld_base);
1693    bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
1694    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
1695    bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
1696    bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
1697    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
1698    bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
1699    bld_base->op_actions[TGSI_OPCODE_CND].emit = cnd_emit_cpu;
1700    bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
1701    bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
1702    bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
1703    bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
1704    bld_base->op_actions[TGSI_OPCODE_EXP].emit = exp_emit_cpu;
1705    bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
1706    bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit_cpu;
1707    bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
1708
1709    bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
1710    bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
1711    bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
1712    bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
1713    bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
1714    bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
1715    bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
1716    bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
1717    bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
1718    bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
1719
1720    bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
1721    bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
1722    bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
1723    bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
1724    bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
1725    bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
1726    bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
1727    bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
1728    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
1729    bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
1730    bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
1731    bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
1732    bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
1733    bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
1734    bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
1735    bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
1736    bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
1737    bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
1738    bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
1739    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
1740    bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
1741
1742    bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
1743    bld_base->sqrt_action.emit = sqrt_emit_cpu;
1744
1745    bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
1746    bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu;
1747    bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
1748    bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
1749    bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
1750    bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
1751    bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
1752    bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
1753    bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
1754    bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
1755    bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
1756
1757    bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
1758
1759 }