src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c

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