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