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    struct lp_build_context *bld = &bld_base->base;
 542    LLVMValueRef inv, a, b;
 543
 544    /* This uses the correct version: (1 - t)*a + t*b
 545     *
 546     * An alternative version is "a + t*(b-a)". The problem is this version
 547     * doesn't return "b" for t = 1, because "a + (b-a)" isn't equal to "b"
 548     * because of the floating-point rounding.
 549     */
 550    inv = lp_build_sub(bld, bld_base->base.one, emit_data->args[0]);
 551    a = lp_build_mul(bld, emit_data->args[1], emit_data->args[0]);
 552    b = lp_build_mul(bld, emit_data->args[2], inv);
 553    emit_data->output[emit_data->chan] = lp_build_add(bld, a, b);
 554 }
 555
 556 /* TGSI_OPCODE_MAD */
 557
 558 static void
 559 mad_emit(
 560    const struct lp_build_tgsi_action * action,
 561    struct lp_build_tgsi_context * bld_base,
 562    struct lp_build_emit_data * emit_data)
 563 {
 564    LLVMValueRef tmp;
 565    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 566                                    emit_data->args[0],
 567                                    emit_data->args[1]);
 568    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 569                                        TGSI_OPCODE_ADD, tmp, emit_data->args[2]);
 570 }
 571
 572 /* TGSI_OPCODE_MOV */
 573
 574 static void
 575 mov_emit(
 576    const struct lp_build_tgsi_action * action,
 577    struct lp_build_tgsi_context * bld_base,
 578    struct lp_build_emit_data * emit_data)
 579 {
 580    emit_data->output[emit_data->chan] = emit_data->args[0];
 581 }
 582
 583 /* TGSI_OPCODE_MUL */
 584 static void
 585 mul_emit(
 586    const struct lp_build_tgsi_action * action,
 587    struct lp_build_tgsi_context * bld_base,
 588    struct lp_build_emit_data * emit_data)
 589 {
 590    emit_data->output[emit_data->chan] = LLVMBuildFMul(
 591                                    bld_base->base.gallivm->builder,
 592                                    emit_data->args[0], emit_data->args[1], "");
 593 }
 594
 595 /*.TGSI_OPCODE_DIV.*/
 596 static void fdiv_emit(
 597    const struct lp_build_tgsi_action * action,
 598    struct lp_build_tgsi_context * bld_base,
 599    struct lp_build_emit_data * emit_data)
 600 {
 601    emit_data->output[emit_data->chan] = LLVMBuildFDiv(
 602                                    bld_base->base.gallivm->builder,
 603                                    emit_data->args[0], emit_data->args[1], "");
 604 }
 605
 606 /*.TGSI_OPCODE_RCP.*/
 607 static void rcp_emit(
 608    const struct lp_build_tgsi_action * action,
 609    struct lp_build_tgsi_context * bld_base,
 610    struct lp_build_emit_data * emit_data)
 611 {
 612    LLVMValueRef one;
 613    one = lp_build_const_float(bld_base->base.gallivm, 1.0f);
 614    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 615                                    TGSI_OPCODE_DIV, one, emit_data->args[0]);
 616 }
 617
 618 /* TGSI_OPCODE_POW */
 619
 620 static void
 621 pow_emit(
 622    const struct lp_build_tgsi_action * action,
 623    struct lp_build_tgsi_context * bld_base,
 624    struct lp_build_emit_data * emit_data)
 625 {
 626    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
 627                                    emit_data->args[0], emit_data->args[1]);
 628 }
 629
 630 static struct lp_build_tgsi_action pow_action = {
 631    scalar_binary_fetch_args,     /* fetch_args */
 632    pow_emit      /* emit */
 633 };
 634
 635 /* TGSI_OPCODE_RSQ */
 636
 637 static void
 638 rsq_emit(
 639    const struct lp_build_tgsi_action * action,
 640    struct lp_build_tgsi_context * bld_base,
 641    struct lp_build_emit_data * emit_data)
 642 {
 643    if (bld_base->rsq_action.emit) {
 644       bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
 645    } else {
 646       emit_data->output[emit_data->chan] = bld_base->base.undef;
 647    }
 648 }
 649
 650 const struct lp_build_tgsi_action rsq_action = {
 651    scalar_unary_fetch_args,      /* fetch_args */
 652    rsq_emit      /* emit */
 653
 654 };
 655
 656 /* TGSI_OPCODE_SQRT */
 657
 658 static void
 659 sqrt_emit(
 660    const struct lp_build_tgsi_action * action,
 661    struct lp_build_tgsi_context * bld_base,
 662    struct lp_build_emit_data * emit_data)
 663 {
 664    if (bld_base->sqrt_action.emit) {
 665       bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data);
 666    } else {
 667       emit_data->output[emit_data->chan] = bld_base->base.undef;
 668    }
 669 }
 670
 671 const struct lp_build_tgsi_action sqrt_action = {
 672    scalar_unary_fetch_args,      /* fetch_args */
 673    sqrt_emit     /* emit */
 674 };
 675
 676 /* TGSI_OPCODE_SCS */
 677 static void
 678 scs_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    /* dst.x */
 684    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 685                                            TGSI_OPCODE_COS, emit_data->args[0]);
 686    /* dst.y */
 687    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
 688                                            TGSI_OPCODE_SIN, emit_data->args[0]);
 689    /* dst.z */
 690    emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
 691
 692    /* dst.w */
 693    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 694 }
 695
 696 const struct lp_build_tgsi_action scs_action = {
 697    scalar_unary_fetch_args,      /* fetch_args */
 698    scs_emit      /* emit */
 699 };
 700
 701 /* TGSI_OPCODE_SUB */
 702 static void
 703 sub_emit(
 704    const struct lp_build_tgsi_action * action,
 705    struct lp_build_tgsi_context * bld_base,
 706    struct lp_build_emit_data * emit_data)
 707 {
 708    emit_data->output[emit_data->chan] =
 709       LLVMBuildFSub(bld_base->base.gallivm->builder,
 710                     emit_data->args[0],
 711                     emit_data->args[1], "");
 712 }
 713
 714 /* TGSI_OPCODE_F2U */
 715 static void
 716 f2u_emit(
 717    const struct lp_build_tgsi_action * action,
 718    struct lp_build_tgsi_context * bld_base,
 719    struct lp_build_emit_data * emit_data)
 720 {
 721    emit_data->output[emit_data->chan] =
 722       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
 723                       emit_data->args[0],
 724                       bld_base->base.int_vec_type, "");
 725 }
 726
 727 /* TGSI_OPCODE_U2F */
 728 static void
 729 u2f_emit(
 730    const struct lp_build_tgsi_action * action,
 731    struct lp_build_tgsi_context * bld_base,
 732    struct lp_build_emit_data * emit_data)
 733 {
 734    emit_data->output[emit_data->chan] =
 735       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
 736                       emit_data->args[0],
 737                       bld_base->base.vec_type, "");
 738 }
 739
 740 static void
 741 umad_emit(
 742    const struct lp_build_tgsi_action * action,
 743    struct lp_build_tgsi_context * bld_base,
 744    struct lp_build_emit_data * emit_data)
 745 {
 746    LLVMValueRef tmp;
 747    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
 748                                    emit_data->args[0],
 749                                    emit_data->args[1]);
 750    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 751                                        TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
 752 }
 753
 754 /* TGSI_OPCODE_UMUL */
 755 static void
 756 umul_emit(
 757    const struct lp_build_tgsi_action * action,
 758    struct lp_build_tgsi_context * bld_base,
 759    struct lp_build_emit_data * emit_data)
 760 {
 761    emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
 762                                    emit_data->args[0], emit_data->args[1]);
 763 }
 764
 765 /* TGSI_OPCODE_IMUL_HI */
 766 static void
 767 imul_hi_emit(
 768    const struct lp_build_tgsi_action * action,
 769    struct lp_build_tgsi_context * bld_base,
 770    struct lp_build_emit_data * emit_data)
 771 {
 772    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 773    struct lp_build_context *int_bld = &bld_base->int_bld;
 774    struct lp_type type = int_bld->type;
 775    LLVMValueRef src0, src1;
 776    LLVMValueRef dst64;
 777    LLVMTypeRef typeRef;
 778
 779    assert(type.width == 32);
 780    type.width = 64;
 781    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 782    src0 = LLVMBuildSExt(builder, emit_data->args[0], typeRef, "");
 783    src1 = LLVMBuildSExt(builder, emit_data->args[1], typeRef, "");
 784    dst64 = LLVMBuildMul(builder, src0, src1, "");
 785    dst64 = LLVMBuildAShr(
 786             builder, dst64,
 787             lp_build_const_vec(bld_base->base.gallivm, type, 32), "");
 788    type.width = 32;
 789    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 790    emit_data->output[emit_data->chan] =
 791          LLVMBuildTrunc(builder, dst64, typeRef, "");
 792 }
 793
 794 /* TGSI_OPCODE_UMUL_HI */
 795 static void
 796 umul_hi_emit(
 797    const struct lp_build_tgsi_action * action,
 798    struct lp_build_tgsi_context * bld_base,
 799    struct lp_build_emit_data * emit_data)
 800 {
 801    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 802    struct lp_build_context *uint_bld = &bld_base->uint_bld;
 803    struct lp_type type = uint_bld->type;
 804    LLVMValueRef src0, src1;
 805    LLVMValueRef dst64;
 806    LLVMTypeRef typeRef;
 807
 808    assert(type.width == 32);
 809    type.width = 64;
 810    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 811    src0 = LLVMBuildZExt(builder, emit_data->args[0], typeRef, "");
 812    src1 = LLVMBuildZExt(builder, emit_data->args[1], typeRef, "");
 813    dst64 = LLVMBuildMul(builder, src0, src1, "");
 814    dst64 = LLVMBuildLShr(
 815             builder, dst64,
 816             lp_build_const_vec(bld_base->base.gallivm, type, 32), "");
 817    type.width = 32;
 818    typeRef = lp_build_vec_type(bld_base->base.gallivm, type);
 819    emit_data->output[emit_data->chan] =
 820          LLVMBuildTrunc(builder, dst64, typeRef, "");
 821 }
 822
 823 /* TGSI_OPCODE_MAX */
 824 static void fmax_emit(
 825    const struct lp_build_tgsi_action * action,
 826    struct lp_build_tgsi_context * bld_base,
 827    struct lp_build_emit_data * emit_data)
 828 {
 829    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 830    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 831                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 832                                    emit_data->args[0], emit_data->args[1], ""),
 833                                    emit_data->args[0], emit_data->args[1], "");
 834 }
 835
 836 /* TGSI_OPCODE_MIN */
 837 static void fmin_emit(
 838    const struct lp_build_tgsi_action * action,
 839    struct lp_build_tgsi_context * bld_base,
 840    struct lp_build_emit_data * emit_data)
 841 {
 842    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 843    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 844                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 845                                    emit_data->args[0], emit_data->args[1], ""),
 846                                    emit_data->args[1], emit_data->args[0], "");
 847 }
 848
 849 /* TGSI_OPCODE_XPD */
 850
 851 static void
 852 xpd_fetch_args(
 853    struct lp_build_tgsi_context * bld_base,
 854    struct lp_build_emit_data * emit_data)
 855 {
 856    dp_fetch_args(bld_base, emit_data, 3);
 857 }
 858
 859 /**
 860  * (a * b) - (c * d)
 861  */
 862 static LLVMValueRef
 863 xpd_helper(
 864   struct lp_build_tgsi_context * bld_base,
 865   LLVMValueRef a,
 866   LLVMValueRef b,
 867   LLVMValueRef c,
 868   LLVMValueRef d)
 869 {
 870    LLVMValueRef tmp0, tmp1;
 871
 872    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
 873    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
 874
 875    return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
 876 }
 877
 878 static void
 879 xpd_emit(
 880    const struct lp_build_tgsi_action * action,
 881    struct lp_build_tgsi_context * bld_base,
 882    struct lp_build_emit_data * emit_data)
 883 {
 884    emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
 885               emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
 886               emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
 887
 888    emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
 889               emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
 890               emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
 891
 892    emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
 893               emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
 894               emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
 895
 896    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 897 }
 898
 899 const struct lp_build_tgsi_action xpd_action = {
 900    xpd_fetch_args,       /* fetch_args */
 901    xpd_emit      /* emit */
 902 };
 903
 904 /* TGSI_OPCODE_D2F */
 905 static void
 906 d2f_emit(
 907    const struct lp_build_tgsi_action * action,
 908    struct lp_build_tgsi_context * bld_base,
 909    struct lp_build_emit_data * emit_data)
 910 {
 911    emit_data->output[emit_data->chan] =
 912       LLVMBuildFPTrunc(bld_base->base.gallivm->builder,
 913                       emit_data->args[0],
 914                        bld_base->base.vec_type, "");
 915 }
 916
 917 /* TGSI_OPCODE_D2I */
 918 static void
 919 d2i_emit(
 920    const struct lp_build_tgsi_action * action,
 921    struct lp_build_tgsi_context * bld_base,
 922    struct lp_build_emit_data * emit_data)
 923 {
 924    emit_data->output[emit_data->chan] =
 925       LLVMBuildFPToSI(bld_base->base.gallivm->builder,
 926                       emit_data->args[0],
 927                       bld_base->base.int_vec_type, "");
 928 }
 929
 930 /* TGSI_OPCODE_D2U */
 931 static void
 932 d2u_emit(
 933    const struct lp_build_tgsi_action * action,
 934    struct lp_build_tgsi_context * bld_base,
 935    struct lp_build_emit_data * emit_data)
 936 {
 937    emit_data->output[emit_data->chan] =
 938       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
 939                       emit_data->args[0],
 940                       bld_base->base.int_vec_type, "");
 941 }
 942
 943 /* TGSI_OPCODE_F2D */
 944 static void
 945 f2d_emit(
 946    const struct lp_build_tgsi_action * action,
 947    struct lp_build_tgsi_context * bld_base,
 948    struct lp_build_emit_data * emit_data)
 949 {
 950    emit_data->output[emit_data->chan] =
 951       LLVMBuildFPExt(bld_base->base.gallivm->builder,
 952                       emit_data->args[0],
 953                       bld_base->dbl_bld.vec_type, "");
 954 }
 955
 956 /* TGSI_OPCODE_U2D */
 957 static void
 958 u2d_emit(
 959    const struct lp_build_tgsi_action * action,
 960    struct lp_build_tgsi_context * bld_base,
 961    struct lp_build_emit_data * emit_data)
 962 {
 963    emit_data->output[emit_data->chan] =
 964       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
 965                       emit_data->args[0],
 966                       bld_base->dbl_bld.vec_type, "");
 967 }
 968
 969 /* TGSI_OPCODE_I2D */
 970 static void
 971 i2d_emit(
 972    const struct lp_build_tgsi_action * action,
 973    struct lp_build_tgsi_context * bld_base,
 974    struct lp_build_emit_data * emit_data)
 975 {
 976    emit_data->output[emit_data->chan] =
 977       LLVMBuildSIToFP(bld_base->base.gallivm->builder,
 978                       emit_data->args[0],
 979                       bld_base->dbl_bld.vec_type, "");
 980 }
 981
 982 /* TGSI_OPCODE_DMAD */
 983 static void
 984 dmad_emit(
 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    LLVMValueRef tmp;
 990    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_DMUL,
 991                                    emit_data->args[0],
 992                                    emit_data->args[1]);
 993    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 994                                        TGSI_OPCODE_DADD, tmp, emit_data->args[2]);
 995 }
 996
 997 /*.TGSI_OPCODE_DRCP.*/
 998 static void drcp_emit(
 999    const struct lp_build_tgsi_action * action,
1000    struct lp_build_tgsi_context * bld_base,
1001    struct lp_build_emit_data * emit_data)
1002 {
1003    LLVMValueRef one;
1004    one = lp_build_const_vec(bld_base->dbl_bld.gallivm, bld_base->dbl_bld.type, 1.0f);
1005    emit_data->output[emit_data->chan] = LLVMBuildFDiv(
1006       bld_base->base.gallivm->builder,
1007       one, emit_data->args[0], "");
1008 }
1009
1010 /* TGSI_OPCODE_DFRAC */
1011 static void dfrac_emit(
1012    const struct lp_build_tgsi_action * action,
1013    struct lp_build_tgsi_context * bld_base,
1014    struct lp_build_emit_data * emit_data)
1015 {
1016    LLVMValueRef tmp;
1017    tmp = lp_build_floor(&bld_base->dbl_bld,
1018                         emit_data->args[0]);
1019    emit_data->output[emit_data->chan] =  LLVMBuildFSub(bld_base->base.gallivm->builder,
1020                                                        emit_data->args[0], tmp, "");
1021 }
1022
1023 void
1024 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
1025 {
1026    bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
1027    bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
1028    bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
1029    bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
1030    bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
1031    bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
1032    bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
1033    bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
1034    bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
1035    bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
1036    bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action;
1037    bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
1038    bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
1039    bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
1040
1041    bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args;
1042    bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args;
1043    bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args;
1044    bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
1045    bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
1046    bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
1047    bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args;
1048    bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args;
1049    bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args;
1050    bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
1051    bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
1052    bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
1053
1054    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
1055    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
1056    bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
1057    bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
1058    bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
1059    bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
1060    bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
1061    bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
1062    bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
1063    bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
1064    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
1065    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
1066
1067    bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
1068    bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit;
1069    bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
1070    bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
1071    bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
1072    bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit;
1073    bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit;
1074
1075    bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit;
1076    bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit;
1077
1078    bld_base->op_actions[TGSI_OPCODE_DADD].emit = add_emit;
1079    bld_base->op_actions[TGSI_OPCODE_DMAX].emit = fmax_emit;
1080    bld_base->op_actions[TGSI_OPCODE_DMIN].emit = fmin_emit;
1081    bld_base->op_actions[TGSI_OPCODE_DMUL].emit = mul_emit;
1082
1083    bld_base->op_actions[TGSI_OPCODE_D2F].emit = d2f_emit;
1084    bld_base->op_actions[TGSI_OPCODE_D2I].emit = d2i_emit;
1085    bld_base->op_actions[TGSI_OPCODE_D2U].emit = d2u_emit;
1086
1087    bld_base->op_actions[TGSI_OPCODE_F2D].emit = f2d_emit;
1088    bld_base->op_actions[TGSI_OPCODE_I2D].emit = i2d_emit;
1089    bld_base->op_actions[TGSI_OPCODE_U2D].emit = u2d_emit;
1090
1091    bld_base->op_actions[TGSI_OPCODE_DMAD].emit = dmad_emit;
1092
1093    bld_base->op_actions[TGSI_OPCODE_DRCP].emit = drcp_emit;
1094    bld_base->op_actions[TGSI_OPCODE_DFRAC].emit = dfrac_emit;
1095
1096 }
1097
1098 /* CPU Only default actions */
1099
1100 /* These actions are CPU only, because they could potentially output SSE
1101  * intrinsics.
1102  */
1103
1104 /* TGSI_OPCODE_ABS (CPU Only)*/
1105
1106 static void
1107 abs_emit_cpu(
1108    const struct lp_build_tgsi_action * action,
1109    struct lp_build_tgsi_context * bld_base,
1110    struct lp_build_emit_data * emit_data)
1111 {
1112    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base,
1113                                                        emit_data->args[0]);
1114 }
1115
1116 /* TGSI_OPCODE_ADD (CPU Only) */
1117 static void
1118 add_emit_cpu(
1119    const struct lp_build_tgsi_action * action,
1120    struct lp_build_tgsi_context * bld_base,
1121    struct lp_build_emit_data * emit_data)
1122 {
1123    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
1124                                    emit_data->args[0], emit_data->args[1]);
1125 }
1126
1127 /* TGSI_OPCODE_AND (CPU Only) */
1128 static void
1129 and_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    emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
1135                                    emit_data->args[0], emit_data->args[1]);
1136 }
1137
1138 /* TGSI_OPCODE_ARL (CPU Only) */
1139 static void
1140 arl_emit_cpu(
1141    const struct lp_build_tgsi_action * action,
1142    struct lp_build_tgsi_context * bld_base,
1143    struct lp_build_emit_data * emit_data)
1144 {
1145    LLVMValueRef tmp;
1146    tmp = lp_build_floor(&bld_base->base,
1147                         emit_data->args[0]);
1148    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
1149                                                         bld_base->uint_bld.vec_type, "");
1150 }
1151
1152 /* TGSI_OPCODE_ARR (CPU Only) */
1153 static void
1154 arr_emit_cpu(
1155    const struct lp_build_tgsi_action * action,
1156    struct lp_build_tgsi_context * bld_base,
1157    struct lp_build_emit_data * emit_data)
1158 {
1159    emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
1160 }
1161
1162 /* TGSI_OPCODE_CEIL (CPU Only) */
1163 static void
1164 ceil_emit_cpu(
1165    const struct lp_build_tgsi_action * action,
1166    struct lp_build_tgsi_context * bld_base,
1167    struct lp_build_emit_data * emit_data)
1168 {
1169    emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
1170                                                       emit_data->args[0]);
1171 }
1172
1173 /* TGSI_OPCODE_CMP (CPU Only) */
1174 static void
1175 cmp_emit_cpu(
1176    const struct lp_build_tgsi_action * action,
1177    struct lp_build_tgsi_context * bld_base,
1178    struct lp_build_emit_data * emit_data)
1179 {
1180    LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
1181                                    emit_data->args[0], bld_base->base.zero);
1182    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1183                                 cond, emit_data->args[1], emit_data->args[2]);
1184 }
1185
1186 /* TGSI_OPCODE_UCMP (CPU Only) */
1187 static void
1188 ucmp_emit_cpu(
1189    const struct lp_build_tgsi_action * action,
1190    struct lp_build_tgsi_context * bld_base,
1191    struct lp_build_emit_data * emit_data)
1192 {
1193    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1194    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1195    LLVMValueRef unsigned_cond =
1196       LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, "");
1197    LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL,
1198                                     unsigned_cond,
1199                                     uint_bld->zero);
1200    emit_data->output[emit_data->chan] =
1201       lp_build_select(&bld_base->base,
1202                       cond, emit_data->args[1], emit_data->args[2]);
1203 }
1204
1205 /* TGSI_OPCODE_COS (CPU Only) */
1206 static void
1207 cos_emit_cpu(
1208    const struct lp_build_tgsi_action * action,
1209    struct lp_build_tgsi_context * bld_base,
1210    struct lp_build_emit_data * emit_data)
1211 {
1212    emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
1213                                                        emit_data->args[0]);
1214 }
1215
1216 /* TGSI_OPCODE_DIV (CPU Only) */
1217 static void
1218 div_emit_cpu(
1219    const struct lp_build_tgsi_action * action,
1220    struct lp_build_tgsi_context * bld_base,
1221    struct lp_build_emit_data * emit_data)
1222 {
1223    emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
1224                                    emit_data->args[0], emit_data->args[1]);
1225 }
1226
1227 /* TGSI_OPCODE_EX2 (CPU Only) */
1228 static void
1229 ex2_emit_cpu(
1230    const struct lp_build_tgsi_action * action,
1231    struct lp_build_tgsi_context * bld_base,
1232    struct lp_build_emit_data * emit_data)
1233 {
1234    emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
1235                                                         emit_data->args[0]);
1236 }
1237
1238 /* TGSI_OPCODE_F2I (CPU Only) */
1239 static void
1240 f2i_emit_cpu(
1241    const struct lp_build_tgsi_action * action,
1242    struct lp_build_tgsi_context * bld_base,
1243    struct lp_build_emit_data * emit_data)
1244 {
1245    emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1246                                                         emit_data->args[0]);
1247 }
1248
1249 /* TGSI_OPCODE_FSET Helper (CPU Only) */
1250 static void
1251 fset_emit_cpu(
1252    const struct lp_build_tgsi_action * action,
1253    struct lp_build_tgsi_context * bld_base,
1254    struct lp_build_emit_data * emit_data,
1255    unsigned pipe_func)
1256 {
1257    LLVMValueRef cond;
1258
1259    if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1260       cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1261                                   emit_data->args[0], emit_data->args[1]);
1262    }
1263    else {
1264       cond = lp_build_cmp(&bld_base->base, pipe_func,
1265                           emit_data->args[0], emit_data->args[1]);
1266
1267    }
1268    emit_data->output[emit_data->chan] = cond;
1269 }
1270
1271
1272 /* TGSI_OPCODE_FSEQ (CPU Only) */
1273 static void
1274 fseq_emit_cpu(
1275    const struct lp_build_tgsi_action * action,
1276    struct lp_build_tgsi_context * bld_base,
1277    struct lp_build_emit_data * emit_data)
1278 {
1279    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1280 }
1281
1282 /* TGSI_OPCODE_ISGE (CPU Only) */
1283 static void
1284 fsge_emit_cpu(
1285    const struct lp_build_tgsi_action * action,
1286    struct lp_build_tgsi_context * bld_base,
1287    struct lp_build_emit_data * emit_data)
1288 {
1289    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1290 }
1291
1292 /* TGSI_OPCODE_ISLT (CPU Only) */
1293 static void
1294 fslt_emit_cpu(
1295    const struct lp_build_tgsi_action * action,
1296    struct lp_build_tgsi_context * bld_base,
1297    struct lp_build_emit_data * emit_data)
1298 {
1299    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1300 }
1301
1302 /* TGSI_OPCODE_USNE (CPU Only) */
1303
1304 static void
1305 fsne_emit_cpu(
1306    const struct lp_build_tgsi_action * action,
1307    struct lp_build_tgsi_context * bld_base,
1308    struct lp_build_emit_data * emit_data)
1309 {
1310    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1311 }
1312
1313 /* TGSI_OPCODE_FLR (CPU Only) */
1314
1315 static void
1316 flr_emit_cpu(
1317    const struct lp_build_tgsi_action * action,
1318    struct lp_build_tgsi_context * bld_base,
1319    struct lp_build_emit_data * emit_data)
1320 {
1321    emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
1322                                                          emit_data->args[0]);
1323 }
1324
1325 /* TGSI_OPCODE_I2F (CPU Only) */
1326 static void
1327 i2f_emit_cpu(
1328    const struct lp_build_tgsi_action * action,
1329    struct lp_build_tgsi_context * bld_base,
1330    struct lp_build_emit_data * emit_data)
1331 {
1332    emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1333                                                               emit_data->args[0]);
1334 }
1335
1336 /* TGSI_OPCODE_IABS (CPU Only) */
1337 static void
1338 iabs_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 {
1343    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1344                                                        emit_data->args[0]);
1345 }
1346
1347 /* TGSI_OPCODE_IDIV (CPU Only) */
1348 static void
1349 idiv_emit_cpu(
1350    const struct lp_build_tgsi_action * action,
1351    struct lp_build_tgsi_context * bld_base,
1352    struct lp_build_emit_data * emit_data)
1353 {
1354    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1355    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1356                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1357                                         bld_base->uint_bld.zero);
1358    /* We want to make sure that we never divide/mod by zero to not
1359     * generate sigfpe. We don't want to crash just because the
1360     * shader is doing something weird. */
1361    LLVMValueRef divisor = LLVMBuildOr(builder,
1362                                       div_mask,
1363                                       emit_data->args[1], "");
1364    LLVMValueRef result = lp_build_div(&bld_base->int_bld,
1365                                       emit_data->args[0], divisor);
1366    LLVMValueRef not_div_mask = LLVMBuildNot(builder,
1367                                             div_mask,"");
1368    /* idiv by zero doesn't have a guaranteed return value chose 0 for now. */
1369    emit_data->output[emit_data->chan] = LLVMBuildAnd(builder,
1370                                                      not_div_mask,
1371                                                      result, "");
1372 }
1373
1374 /* TGSI_OPCODE_INEG (CPU Only) */
1375 static void
1376 ineg_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] = lp_build_sub(&bld_base->int_bld,
1382                                                      bld_base->int_bld.zero,
1383                                                      emit_data->args[0]);
1384 }
1385
1386 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1387 static void
1388 iset_emit_cpu(
1389    const struct lp_build_tgsi_action * action,
1390    struct lp_build_tgsi_context * bld_base,
1391    struct lp_build_emit_data * emit_data,
1392    unsigned pipe_func)
1393 {
1394    LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1395                                     emit_data->args[0], emit_data->args[1]);
1396    emit_data->output[emit_data->chan] = cond;
1397 }
1398
1399 /* TGSI_OPCODE_IMAX (CPU Only) */
1400 static void
1401 imax_emit_cpu(
1402    const struct lp_build_tgsi_action * action,
1403    struct lp_build_tgsi_context * bld_base,
1404    struct lp_build_emit_data * emit_data)
1405 {
1406    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1407                                    emit_data->args[0], emit_data->args[1]);
1408 }
1409
1410 /* TGSI_OPCODE_IMIN (CPU Only) */
1411 static void
1412 imin_emit_cpu(
1413    const struct lp_build_tgsi_action * action,
1414    struct lp_build_tgsi_context * bld_base,
1415    struct lp_build_emit_data * emit_data)
1416 {
1417    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1418                                    emit_data->args[0], emit_data->args[1]);
1419 }
1420
1421 /* TGSI_OPCODE_ISGE (CPU Only) */
1422 static void
1423 isge_emit_cpu(
1424    const struct lp_build_tgsi_action * action,
1425    struct lp_build_tgsi_context * bld_base,
1426    struct lp_build_emit_data * emit_data)
1427 {
1428    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1429 }
1430
1431 /* TGSI_OPCODE_ISHR (CPU Only) */
1432 static void
1433 ishr_emit_cpu(
1434    const struct lp_build_tgsi_action * action,
1435    struct lp_build_tgsi_context * bld_base,
1436    struct lp_build_emit_data * emit_data)
1437 {
1438    struct lp_build_context *int_bld = &bld_base->int_bld;
1439    LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type,
1440                                           int_bld->type.width - 1);
1441    LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask);
1442    emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0],
1443                                                      masked_count);
1444 }
1445
1446 /* TGSI_OPCODE_ISLT (CPU Only) */
1447 static void
1448 islt_emit_cpu(
1449    const struct lp_build_tgsi_action * action,
1450    struct lp_build_tgsi_context * bld_base,
1451    struct lp_build_emit_data * emit_data)
1452 {
1453    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1454 }
1455
1456
1457 /* TGSI_OPCODE_ISSG (CPU Only) */
1458 static void
1459 issg_emit_cpu(
1460    const struct lp_build_tgsi_action * action,
1461    struct lp_build_tgsi_context * bld_base,
1462    struct lp_build_emit_data * emit_data)
1463 {
1464    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1465                                                        emit_data->args[0]);
1466 }
1467
1468 /* TGSI_OPCODE_LG2 (CPU Only) */
1469 static void
1470 lg2_emit_cpu(
1471    const struct lp_build_tgsi_action * action,
1472    struct lp_build_tgsi_context * bld_base,
1473    struct lp_build_emit_data * emit_data)
1474 {
1475    emit_data->output[emit_data->chan] = lp_build_log2_safe(&bld_base->base,
1476                                                            emit_data->args[0]);
1477 }
1478
1479 /* TGSI_OPCODE_LOG (CPU Only) */
1480 static void
1481 log_emit_cpu(
1482    const struct lp_build_tgsi_action * action,
1483    struct lp_build_tgsi_context * bld_base,
1484    struct lp_build_emit_data * emit_data)
1485 {
1486    LLVMValueRef p_floor_log2;
1487    LLVMValueRef p_exp;
1488    LLVMValueRef p_log2;
1489    LLVMValueRef src0 = emit_data->args[0];
1490
1491    lp_build_log2_approx(&bld_base->base, src0,
1492                         &p_exp, &p_floor_log2, &p_log2, FALSE);
1493
1494    emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1495
1496    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1497                                              TGSI_OPCODE_DIV,
1498                                              src0, p_exp);
1499    emit_data->output[TGSI_CHAN_Z] = p_log2;
1500
1501    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1502
1503 }
1504
1505 /* TGSI_OPCODE_MAX (CPU Only) */
1506
1507 static void
1508 max_emit_cpu(
1509    const struct lp_build_tgsi_action * action,
1510    struct lp_build_tgsi_context * bld_base,
1511    struct lp_build_emit_data * emit_data)
1512 {
1513    emit_data->output[emit_data->chan] =
1514       lp_build_max_ext(&bld_base->base,
1515                        emit_data->args[0], emit_data->args[1],
1516                        GALLIVM_NAN_RETURN_OTHER);
1517 }
1518
1519 /* TGSI_OPCODE_MIN (CPU Only) */
1520 static void
1521 min_emit_cpu(
1522    const struct lp_build_tgsi_action * action,
1523    struct lp_build_tgsi_context * bld_base,
1524    struct lp_build_emit_data * emit_data)
1525 {
1526    emit_data->output[emit_data->chan] =
1527       lp_build_min_ext(&bld_base->base,
1528                        emit_data->args[0], emit_data->args[1],
1529                        GALLIVM_NAN_RETURN_OTHER);
1530 }
1531
1532 /* TGSI_OPCODE_MOD (CPU Only) */
1533 static void
1534 mod_emit_cpu(
1535    const struct lp_build_tgsi_action * action,
1536    struct lp_build_tgsi_context * bld_base,
1537    struct lp_build_emit_data * emit_data)
1538 {
1539    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1540    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1541                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1542                                         bld_base->uint_bld.zero);
1543    /* We want to make sure that we never divide/mod by zero to not
1544     * generate sigfpe. We don't want to crash just because the
1545     * shader is doing something weird. */
1546    LLVMValueRef divisor = LLVMBuildOr(builder,
1547                                       div_mask,
1548                                       emit_data->args[1], "");
1549    LLVMValueRef result = lp_build_mod(&bld_base->int_bld,
1550                                       emit_data->args[0], divisor);
1551    /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1552    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1553                                                     div_mask,
1554                                                     result, "");
1555 }
1556
1557 /* TGSI_OPCODE_NOT */
1558 static void
1559 not_emit_cpu(
1560    const struct lp_build_tgsi_action * action,
1561    struct lp_build_tgsi_context * bld_base,
1562    struct lp_build_emit_data * emit_data)
1563 {
1564    emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld,
1565                                                      emit_data->args[0]);
1566 }
1567
1568 /* TGSI_OPCODE_OR (CPU Only) */
1569 static void
1570 or_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_or(&bld_base->uint_bld,
1576                                    emit_data->args[0], emit_data->args[1]);
1577 }
1578
1579 /* TGSI_OPCODE_POW (CPU Only) */
1580 static void
1581 pow_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    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1587                                    emit_data->args[0], emit_data->args[1]);
1588 }
1589
1590
1591 /* TGSI_OPCODE_RCP (CPU Only) */
1592
1593 static void
1594 rcp_emit_cpu(
1595    const struct lp_build_tgsi_action * action,
1596    struct lp_build_tgsi_context * bld_base,
1597    struct lp_build_emit_data * emit_data)
1598 {
1599    emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1600                                                        emit_data->args[0]);
1601 }
1602
1603 /* Reciprical squareroot (CPU Only) */
1604 static void
1605 recip_sqrt_emit_cpu(
1606    const struct lp_build_tgsi_action * action,
1607    struct lp_build_tgsi_context * bld_base,
1608    struct lp_build_emit_data * emit_data)
1609 {
1610    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1611                                                          emit_data->args[0]);
1612 }
1613
1614 static void
1615 sqrt_emit_cpu(
1616    const struct lp_build_tgsi_action * action,
1617    struct lp_build_tgsi_context * bld_base,
1618    struct lp_build_emit_data * emit_data)
1619 {
1620    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base,
1621                                                       emit_data->args[0]);
1622 }
1623
1624
1625 /* TGSI_OPCODE_ROUND (CPU Only) */
1626 static void
1627 round_emit_cpu(
1628    const struct lp_build_tgsi_action * action,
1629    struct lp_build_tgsi_context * bld_base,
1630    struct lp_build_emit_data * emit_data)
1631 {
1632    emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1633                                                          emit_data->args[0]);
1634 }
1635
1636 /* TGSI_OPCODE_SET Helper (CPU Only) */
1637
1638 static void
1639 set_emit_cpu(
1640    const struct lp_build_tgsi_action * action,
1641    struct lp_build_tgsi_context * bld_base,
1642    struct lp_build_emit_data * emit_data,
1643    unsigned pipe_func)
1644 {
1645    LLVMValueRef cond;
1646
1647    if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1648       cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1649                                   emit_data->args[0], emit_data->args[1]);
1650    }
1651    else {
1652       cond = lp_build_cmp(&bld_base->base, pipe_func,
1653                           emit_data->args[0], emit_data->args[1]);
1654
1655    }
1656    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1657                                           cond,
1658                                           bld_base->base.one,
1659                                           bld_base->base.zero);
1660 }
1661
1662 /* TGSI_OPCODE_SEQ (CPU Only) */
1663
1664 static void
1665 seq_emit_cpu(
1666    const struct lp_build_tgsi_action * action,
1667    struct lp_build_tgsi_context * bld_base,
1668    struct lp_build_emit_data * emit_data)
1669 {
1670    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1671 }
1672
1673 /* TGSI_OPCODE_SGE (CPU Only) */
1674 static void
1675 sge_emit_cpu(
1676    const struct lp_build_tgsi_action * action,
1677    struct lp_build_tgsi_context * bld_base,
1678    struct lp_build_emit_data * emit_data)
1679 {
1680    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1681 }
1682
1683 /* TGSI_OPCODE_SGT (CPU Only)*/
1684
1685 static void
1686 sgt_emit_cpu(
1687    const struct lp_build_tgsi_action * action,
1688    struct lp_build_tgsi_context * bld_base,
1689    struct lp_build_emit_data * emit_data)
1690 {
1691    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1692 }
1693
1694 /* TGSI_OPCODE_SHL (CPU Only) */
1695 static void
1696 shl_emit_cpu(
1697    const struct lp_build_tgsi_action * action,
1698    struct lp_build_tgsi_context * bld_base,
1699    struct lp_build_emit_data * emit_data)
1700 {
1701    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1702    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
1703                                           uint_bld->type.width - 1);
1704    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
1705    emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0],
1706                                                      masked_count);
1707 }
1708
1709 /* TGSI_OPCODE_SIN (CPU Only) */
1710 static void
1711 sin_emit_cpu(
1712    const struct lp_build_tgsi_action * action,
1713    struct lp_build_tgsi_context * bld_base,
1714    struct lp_build_emit_data * emit_data)
1715 {
1716    emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base,
1717                                                        emit_data->args[0]);
1718 }
1719
1720 /* TGSI_OPCODE_SLE (CPU Only) */
1721 static void
1722 sle_emit_cpu(
1723    const struct lp_build_tgsi_action * action,
1724    struct lp_build_tgsi_context * bld_base,
1725    struct lp_build_emit_data * emit_data)
1726 {
1727    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
1728 }
1729
1730 /* TGSI_OPCODE_SLT (CPU Only) */
1731 static void
1732 slt_emit_cpu(
1733    const struct lp_build_tgsi_action * action,
1734    struct lp_build_tgsi_context * bld_base,
1735    struct lp_build_emit_data * emit_data)
1736 {
1737    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1738 }
1739
1740 /* TGSI_OPCODE_SNE (CPU Only) */
1741
1742 static void
1743 sne_emit_cpu(
1744    const struct lp_build_tgsi_action * action,
1745    struct lp_build_tgsi_context * bld_base,
1746    struct lp_build_emit_data * emit_data)
1747 {
1748    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1749 }
1750
1751 /* TGSI_OPCODE_SSG (CPU Only) */
1752
1753 static void
1754 ssg_emit_cpu(
1755    const struct lp_build_tgsi_action * action,
1756    struct lp_build_tgsi_context * bld_base,
1757    struct lp_build_emit_data * emit_data)
1758 {
1759    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
1760                                                        emit_data->args[0]);
1761 }
1762
1763 /* TGSI_OPCODE_SUB (CPU Only) */
1764
1765 static void
1766 sub_emit_cpu(
1767    const struct lp_build_tgsi_action * action,
1768    struct lp_build_tgsi_context * bld_base,
1769    struct lp_build_emit_data * emit_data)
1770 {
1771    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
1772                                                         emit_data->args[0],
1773                                                         emit_data->args[1]);
1774 }
1775
1776 /* TGSI_OPCODE_TRUNC (CPU Only) */
1777
1778 static void
1779 trunc_emit_cpu(
1780    const struct lp_build_tgsi_action * action,
1781    struct lp_build_tgsi_context * bld_base,
1782    struct lp_build_emit_data * emit_data)
1783 {
1784    emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
1785                                                          emit_data->args[0]);
1786 }
1787
1788 /* TGSI_OPCODE_UADD (CPU Only) */
1789 static void
1790 uadd_emit_cpu(
1791    const struct lp_build_tgsi_action * action,
1792    struct lp_build_tgsi_context * bld_base,
1793    struct lp_build_emit_data * emit_data)
1794 {
1795    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
1796                                    emit_data->args[0], emit_data->args[1]);
1797 }
1798
1799 /* TGSI_OPCODE_UDIV (CPU Only) */
1800 static void
1801 udiv_emit_cpu(
1802    const struct lp_build_tgsi_action * action,
1803    struct lp_build_tgsi_context * bld_base,
1804    struct lp_build_emit_data * emit_data)
1805 {
1806
1807    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1808    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1809                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1810                                         bld_base->uint_bld.zero);
1811    /* We want to make sure that we never divide/mod by zero to not
1812     * generate sigfpe. We don't want to crash just because the
1813     * shader is doing something weird. */
1814    LLVMValueRef divisor = LLVMBuildOr(builder,
1815                                       div_mask,
1816                                       emit_data->args[1], "");
1817    LLVMValueRef result = lp_build_div(&bld_base->uint_bld,
1818                                       emit_data->args[0], divisor);
1819    /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
1820    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1821                                                     div_mask,
1822                                                     result, "");
1823 }
1824
1825 /* TGSI_OPCODE_UMAX (CPU Only) */
1826 static void
1827 umax_emit_cpu(
1828    const struct lp_build_tgsi_action * action,
1829    struct lp_build_tgsi_context * bld_base,
1830    struct lp_build_emit_data * emit_data)
1831 {
1832    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
1833                                    emit_data->args[0], emit_data->args[1]);
1834 }
1835
1836 /* TGSI_OPCODE_UMIN (CPU Only) */
1837 static void
1838 umin_emit_cpu(
1839    const struct lp_build_tgsi_action * action,
1840    struct lp_build_tgsi_context * bld_base,
1841    struct lp_build_emit_data * emit_data)
1842 {
1843    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld,
1844                                    emit_data->args[0], emit_data->args[1]);
1845 }
1846
1847 /* TGSI_OPCODE_UMOD (CPU Only) */
1848 static void
1849 umod_emit_cpu(
1850    const struct lp_build_tgsi_action * action,
1851    struct lp_build_tgsi_context * bld_base,
1852    struct lp_build_emit_data * emit_data)
1853 {
1854    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1855    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1856                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1857                                         bld_base->uint_bld.zero);
1858    /* We want to make sure that we never divide/mod by zero to not
1859     * generate sigfpe. We don't want to crash just because the
1860     * shader is doing something weird. */
1861    LLVMValueRef divisor = LLVMBuildOr(builder,
1862                                       div_mask,
1863                                       emit_data->args[1], "");
1864    LLVMValueRef result = lp_build_mod(&bld_base->uint_bld,
1865                                       emit_data->args[0], divisor);
1866    /* umod by zero is guaranteed to return 0xffffffff */
1867    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1868                                                     div_mask,
1869                                                     result, "");
1870 }
1871
1872 /* TGSI_OPCODE_USET Helper (CPU Only) */
1873 static void
1874 uset_emit_cpu(
1875    const struct lp_build_tgsi_action * action,
1876    struct lp_build_tgsi_context * bld_base,
1877    struct lp_build_emit_data * emit_data,
1878    unsigned pipe_func)
1879 {
1880    LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
1881                                     emit_data->args[0], emit_data->args[1]);
1882    emit_data->output[emit_data->chan] = cond;
1883 }
1884
1885
1886 /* TGSI_OPCODE_USEQ (CPU Only) */
1887 static void
1888 useq_emit_cpu(
1889    const struct lp_build_tgsi_action * action,
1890    struct lp_build_tgsi_context * bld_base,
1891    struct lp_build_emit_data * emit_data)
1892 {
1893    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1894 }
1895
1896 /* TGSI_OPCODE_ISGE (CPU Only) */
1897 static void
1898 usge_emit_cpu(
1899    const struct lp_build_tgsi_action * action,
1900    struct lp_build_tgsi_context * bld_base,
1901    struct lp_build_emit_data * emit_data)
1902 {
1903    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1904 }
1905
1906 /* TGSI_OPCODE_USHR (CPU Only) */
1907 static void
1908 ushr_emit_cpu(
1909    const struct lp_build_tgsi_action * action,
1910    struct lp_build_tgsi_context * bld_base,
1911    struct lp_build_emit_data * emit_data)
1912 {
1913    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1914    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
1915                                           uint_bld->type.width - 1);
1916    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
1917    emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0],
1918                                                      masked_count);
1919 }
1920
1921 /* TGSI_OPCODE_ISLT (CPU Only) */
1922 static void
1923 uslt_emit_cpu(
1924    const struct lp_build_tgsi_action * action,
1925    struct lp_build_tgsi_context * bld_base,
1926    struct lp_build_emit_data * emit_data)
1927 {
1928    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1929 }
1930
1931 /* TGSI_OPCODE_USNE (CPU Only) */
1932
1933 static void
1934 usne_emit_cpu(
1935    const struct lp_build_tgsi_action * action,
1936    struct lp_build_tgsi_context * bld_base,
1937    struct lp_build_emit_data * emit_data)
1938 {
1939    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1940 }
1941
1942 /* TGSI_OPCODE_XOR */
1943 static void
1944 xor_emit_cpu(
1945    const struct lp_build_tgsi_action * action,
1946    struct lp_build_tgsi_context * bld_base,
1947    struct lp_build_emit_data * emit_data)
1948 {
1949    emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
1950                                                      emit_data->args[0],
1951                                                      emit_data->args[1]);
1952 }
1953
1954 /* TGSI_OPCODE_DABS (CPU Only) */
1955 static void
1956 dabs_emit_cpu(
1957    const struct lp_build_tgsi_action * action,
1958    struct lp_build_tgsi_context * bld_base,
1959    struct lp_build_emit_data * emit_data)
1960 {
1961    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->dbl_bld,
1962                                                        emit_data->args[0]);
1963 }
1964
1965 /* TGSI_OPCODE_DNEG (CPU Only) */
1966 static void
1967 dneg_emit_cpu(
1968    const struct lp_build_tgsi_action * action,
1969    struct lp_build_tgsi_context * bld_base,
1970    struct lp_build_emit_data * emit_data)
1971 {
1972    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->dbl_bld,
1973                                                      bld_base->dbl_bld.zero,
1974                                                      emit_data->args[0]);
1975 }
1976
1977 /* TGSI_OPCODE_DSET Helper (CPU Only) */
1978 static void
1979 dset_emit_cpu(
1980    const struct lp_build_tgsi_action * action,
1981    struct lp_build_tgsi_context * bld_base,
1982    struct lp_build_emit_data * emit_data,
1983    unsigned pipe_func)
1984 {
1985    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1986    LLVMValueRef cond = lp_build_cmp(&bld_base->dbl_bld, pipe_func,
1987                                     emit_data->args[0], emit_data->args[1]);
1988    /* arguments were 64 bit but store as 32 bit */
1989    cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
1990    emit_data->output[emit_data->chan] = cond;
1991 }
1992
1993 /* TGSI_OPCODE_DSEQ (CPU Only) */
1994 static void
1995 dseq_emit_cpu(
1996    const struct lp_build_tgsi_action * action,
1997    struct lp_build_tgsi_context * bld_base,
1998    struct lp_build_emit_data * emit_data)
1999 {
2000    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2001 }
2002
2003 /* TGSI_OPCODE_DSGE (CPU Only) */
2004 static void
2005 dsge_emit_cpu(
2006    const struct lp_build_tgsi_action * action,
2007    struct lp_build_tgsi_context * bld_base,
2008    struct lp_build_emit_data * emit_data)
2009 {
2010    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2011 }
2012
2013 /* TGSI_OPCODE_DSLT (CPU Only) */
2014 static void
2015 dslt_emit_cpu(
2016    const struct lp_build_tgsi_action * action,
2017    struct lp_build_tgsi_context * bld_base,
2018    struct lp_build_emit_data * emit_data)
2019 {
2020    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2021 }
2022
2023 /* TGSI_OPCODE_DSNE (CPU Only) */
2024 static void
2025 dsne_emit_cpu(
2026    const struct lp_build_tgsi_action * action,
2027    struct lp_build_tgsi_context * bld_base,
2028    struct lp_build_emit_data * emit_data)
2029 {
2030    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2031 }
2032
2033 /* Double Reciprocal squareroot (CPU Only) */
2034 static void
2035 drecip_sqrt_emit_cpu(
2036    const struct lp_build_tgsi_action * action,
2037    struct lp_build_tgsi_context * bld_base,
2038    struct lp_build_emit_data * emit_data)
2039 {
2040    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->dbl_bld,
2041                                                          emit_data->args[0]);
2042 }
2043
2044 /* Double Squareroot (CPU Only) */
2045 static void
2046 dsqrt_emit_cpu(
2047    const struct lp_build_tgsi_action * action,
2048    struct lp_build_tgsi_context * bld_base,
2049    struct lp_build_emit_data * emit_data)
2050 {
2051    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->dbl_bld,
2052                                                       emit_data->args[0]);
2053 }
2054
2055 void
2056 lp_set_default_actions_cpu(
2057    struct lp_build_tgsi_context * bld_base)
2058 {
2059    lp_set_default_actions(bld_base);
2060    bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
2061    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
2062    bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
2063    bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
2064    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
2065    bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
2066    bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
2067    bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
2068    bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
2069    bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
2070    bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
2071    bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
2072    bld_base->op_actions[TGSI_OPCODE_FSEQ].emit = fseq_emit_cpu;
2073    bld_base->op_actions[TGSI_OPCODE_FSGE].emit = fsge_emit_cpu;
2074    bld_base->op_actions[TGSI_OPCODE_FSLT].emit = fslt_emit_cpu;
2075    bld_base->op_actions[TGSI_OPCODE_FSNE].emit = fsne_emit_cpu;
2076
2077    bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
2078    bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
2079    bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
2080    bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
2081    bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
2082    bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
2083    bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
2084    bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
2085    bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
2086    bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
2087
2088    bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
2089    bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
2090    bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
2091    bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
2092    bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
2093    bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
2094    bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
2095    bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
2096    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
2097    bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
2098    bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
2099    bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
2100    bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
2101    bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
2102    bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
2103    bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
2104    bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
2105    bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
2106    bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
2107    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
2108    bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
2109
2110    bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
2111    bld_base->sqrt_action.emit = sqrt_emit_cpu;
2112
2113    bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
2114    bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu;
2115    bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
2116    bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
2117    bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
2118    bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
2119    bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
2120    bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
2121    bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
2122    bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
2123    bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
2124
2125    bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
2126
2127    bld_base->op_actions[TGSI_OPCODE_DABS].emit = dabs_emit_cpu;
2128    bld_base->op_actions[TGSI_OPCODE_DNEG].emit = dneg_emit_cpu;
2129    bld_base->op_actions[TGSI_OPCODE_DSEQ].emit = dseq_emit_cpu;
2130    bld_base->op_actions[TGSI_OPCODE_DSGE].emit = dsge_emit_cpu;
2131    bld_base->op_actions[TGSI_OPCODE_DSLT].emit = dslt_emit_cpu;
2132    bld_base->op_actions[TGSI_OPCODE_DSNE].emit = dsne_emit_cpu;
2133
2134    bld_base->op_actions[TGSI_OPCODE_DRSQ].emit = drecip_sqrt_emit_cpu;
2135    bld_base->op_actions[TGSI_OPCODE_DSQRT].emit = dsqrt_emit_cpu;
2136
2137 }