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_conv.h"
  49 #include "lp_bld_gather.h"
  50 #include "lp_bld_logic.h"
  51 #include "lp_bld_pack.h"
  52
  53 #include "tgsi/tgsi_exec.h"
  54
  55 /* XXX: The CPU only defaults should be repaced by generic ones.  In most
  56  * cases, the CPU defaults are just wrappers around a function in
  57  * lp_build_arit.c and these functions should be inlined here and the CPU
  58  * generic code should be removed and placed elsewhere.
  59  */
  60
  61 /* Default actions */
  62
  63 /* Generic fetch_arg functions */
  64
  65 static void scalar_unary_fetch_args(
  66    struct lp_build_tgsi_context * bld_base,
  67    struct lp_build_emit_data * emit_data)
  68 {
  69    /* src0.x */
  70    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, 0);
  71    emit_data->arg_count = 1;
  72    emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  73 }
  74
  75 static void scalar_binary_fetch_args(
  76    struct lp_build_tgsi_context * bld_base,
  77    struct lp_build_emit_data * emit_data)
  78 {
  79    /* src0.x */
  80    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
  81                                             0, TGSI_CHAN_X);
  82    /* src1.x */
  83    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
  84                                             1, TGSI_CHAN_X);
  85    emit_data->arg_count = 2;
  86    emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  87 }
  88
  89 /* TGSI_OPCODE_ADD */
  90 static void
  91 add_emit(
  92    const struct lp_build_tgsi_action * action,
  93    struct lp_build_tgsi_context * bld_base,
  94    struct lp_build_emit_data * emit_data)
  95 {
  96    emit_data->output[emit_data->chan] = LLVMBuildFAdd(
  97                                 bld_base->base.gallivm->builder,
  98                                 emit_data->args[0], emit_data->args[1], "");
  99 }
 100
 101 /* TGSI_OPCODE_ARR */
 102 static void
 103 arr_emit(
 104    const struct lp_build_tgsi_action * action,
 105    struct lp_build_tgsi_context * bld_base,
 106    struct lp_build_emit_data * emit_data)
 107 {
 108    LLVMValueRef tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ROUND, emit_data->args[0]);
 109    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
 110                                                         bld_base->uint_bld.vec_type, "");
 111 }
 112
 113 /* TGSI_OPCODE_CLAMP */
 114 static void
 115 clamp_emit(
 116    const struct lp_build_tgsi_action * action,
 117    struct lp_build_tgsi_context * bld_base,
 118    struct lp_build_emit_data * emit_data)
 119 {
 120    LLVMValueRef tmp;
 121    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
 122                                    emit_data->args[0],
 123                                    emit_data->args[1]);
 124    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 125                                        TGSI_OPCODE_MIN, tmp, emit_data->args[2]);
 126 }
 127
 128 /* DP* Helper */
 129
 130 static void
 131 dp_fetch_args(
 132    struct lp_build_tgsi_context * bld_base,
 133    struct lp_build_emit_data * emit_data,
 134    unsigned dp_components)
 135 {
 136    unsigned chan, src;
 137    for (src = 0; src < 2; src++) {
 138       for (chan = 0; chan < dp_components; chan++) {
 139          emit_data->args[(src * dp_components) + chan] =
 140                      lp_build_emit_fetch(bld_base, emit_data->inst, src, chan);
 141       }
 142    }
 143    emit_data->dst_type = bld_base->base.elem_type;
 144 }
 145
 146 /* TGSI_OPCODE_DP2 */
 147 static void
 148 dp2_fetch_args(
 149    struct lp_build_tgsi_context * bld_base,
 150    struct lp_build_emit_data * emit_data)
 151 {
 152    dp_fetch_args(bld_base, emit_data, 2);
 153 }
 154
 155 static void
 156 dp2_emit(
 157    const struct lp_build_tgsi_action * action,
 158    struct lp_build_tgsi_context * bld_base,
 159    struct lp_build_emit_data * emit_data)
 160 {
 161    LLVMValueRef tmp0, tmp1;
 162    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 163                                     emit_data->args[0] /* src0.x */,
 164                                     emit_data->args[2] /* src1.x */);
 165    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 166                                     emit_data->args[1] /* src0.y */,
 167                                     emit_data->args[3] /* src1.y */);
 168    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 169                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 170 }
 171
 172 static struct lp_build_tgsi_action dp2_action = {
 173    dp2_fetch_args,       /* fetch_args */
 174    dp2_emit      /* emit */
 175 };
 176
 177 /* TGSI_OPCODE_DP2A */
 178 static void
 179 dp2a_fetch_args(
 180    struct lp_build_tgsi_context * bld_base,
 181    struct lp_build_emit_data * emit_data)
 182 {
 183    dp_fetch_args(bld_base, emit_data, 2);
 184    emit_data->args[5] = lp_build_emit_fetch(bld_base, emit_data->inst,
 185                                             2, TGSI_CHAN_X);
 186 }
 187
 188 static void
 189 dp2a_emit(
 190    const struct lp_build_tgsi_action * action,
 191    struct lp_build_tgsi_context * bld_base,
 192    struct lp_build_emit_data * emit_data)
 193 {
 194    LLVMValueRef tmp;
 195    tmp = lp_build_emit_llvm(bld_base, TGSI_OPCODE_DP2, emit_data);
 196    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD,
 197                                     emit_data->args[5], tmp);
 198 }
 199
 200 static struct lp_build_tgsi_action dp2a_action = {
 201    dp2a_fetch_args,      /* fetch_args */
 202    dp2a_emit     /* emit */
 203 };
 204
 205 /* TGSI_OPCODE_DP3 */
 206 static void
 207 dp3_fetch_args(
 208    struct lp_build_tgsi_context * bld_base,
 209    struct lp_build_emit_data * emit_data)
 210 {
 211    dp_fetch_args(bld_base, emit_data, 3);
 212 }
 213
 214 static void
 215 dp3_emit(
 216    const struct lp_build_tgsi_action * action,
 217    struct lp_build_tgsi_context * bld_base,
 218    struct lp_build_emit_data * emit_data)
 219 {
 220    LLVMValueRef tmp0, tmp1;
 221    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 222                                     emit_data->args[0] /* src0.x */,
 223                                     emit_data->args[3] /* src1.x */);
 224    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 225                                     emit_data->args[1] /* src0.y */,
 226                                     emit_data->args[4] /* src1.y */);
 227    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp1, tmp0);
 228    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 229                                     emit_data->args[2] /* src0.z */,
 230                                     emit_data->args[5] /* src1.z */);
 231    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 232                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 233 }
 234
 235 static struct lp_build_tgsi_action dp3_action = {
 236    dp3_fetch_args,       /* fetch_args */
 237    dp3_emit      /* emit */
 238 };
 239
 240 /* TGSI_OPCODDE_DP4 */
 241
 242 static void
 243 dp4_fetch_args(
 244    struct lp_build_tgsi_context * bld_base,
 245    struct lp_build_emit_data * emit_data)
 246 {
 247    dp_fetch_args(bld_base, emit_data, 4);
 248 }
 249
 250 static void
 251 dp4_emit(
 252    const struct lp_build_tgsi_action * action,
 253    struct lp_build_tgsi_context * bld_base,
 254    struct lp_build_emit_data * emit_data)
 255 {
 256    LLVMValueRef tmp0, tmp1;
 257    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 258                                     emit_data->args[0] /* src0.x */,
 259                                     emit_data->args[4] /* src1.x */);
 260    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 261                                     emit_data->args[1] /* src0.y */,
 262                                     emit_data->args[5] /* src1.y */);
 263    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
 264    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 265                                     emit_data->args[2] /* src0.z */,
 266                                     emit_data->args[6] /* src1.z */);
 267    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
 268    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 269                                     emit_data->args[3] /* src0.w */,
 270                                     emit_data->args[7] /* src1.w */);
 271    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 272                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 273 }
 274
 275 static struct lp_build_tgsi_action dp4_action = {
 276    dp4_fetch_args,       /* fetch_args */
 277    dp4_emit      /* emit */
 278 };
 279
 280 /* TGSI_OPCODE_DPH */
 281 static void
 282 dph_fetch_args(
 283    struct lp_build_tgsi_context * bld_base,
 284    struct lp_build_emit_data * emit_data)
 285 {
 286    dp_fetch_args(bld_base, emit_data, 4);
 287    /* src0.w */
 288    emit_data->args[3] = bld_base->base.one;
 289 }
 290
 291 const struct lp_build_tgsi_action dph_action = {
 292    dph_fetch_args,       /* fetch_args */
 293    dp4_emit      /* emit */
 294 };
 295
 296 /* TGSI_OPCODE_DST */
 297 static void
 298 dst_fetch_args(
 299    struct lp_build_tgsi_context * bld_base,
 300    struct lp_build_emit_data * emit_data)
 301 {
 302    /* src0.y */
 303    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 304                                             0, TGSI_CHAN_Y);
 305    /* src0.z */
 306    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 307                                             0, TGSI_CHAN_Z);
 308    /* src1.y */
 309    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
 310                                             1, TGSI_CHAN_Y);
 311    /* src1.w */
 312    emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
 313                                             1, TGSI_CHAN_W);
 314 }
 315
 316 static void
 317 dst_emit(
 318    const struct lp_build_tgsi_action * action,
 319    struct lp_build_tgsi_context * bld_base,
 320    struct lp_build_emit_data * emit_data)
 321 {
 322    /* dst.x */
 323    emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
 324
 325    /* dst.y */
 326    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 327                                           TGSI_OPCODE_MUL,
 328                                           emit_data->args[0] /* src0.y */,
 329                                           emit_data->args[2] /* src1.y */);
 330    /* dst.z */
 331    emit_data->output[TGSI_CHAN_Z] = emit_data->args[1]; /* src0.z */
 332
 333    /* dst.w */
 334    emit_data->output[TGSI_CHAN_W] = emit_data->args[3]; /* src1.w */
 335 }
 336
 337 static struct lp_build_tgsi_action dst_action = {
 338    dst_fetch_args,       /* fetch_args */
 339    dst_emit      /* emit */
 340 };
 341
 342 /* TGSI_OPCODE_END */
 343 static void
 344 end_emit(
 345    const struct lp_build_tgsi_action * action,
 346    struct lp_build_tgsi_context * bld_base,
 347    struct lp_build_emit_data * emit_data)
 348 {
 349    bld_base->pc = -1;
 350 }
 351
 352 /* TGSI_OPCODE_EXP */
 353
 354 static void
 355 exp_emit(
 356    const struct lp_build_tgsi_action * action,
 357    struct lp_build_tgsi_context * bld_base,
 358    struct lp_build_emit_data * emit_data)
 359 {
 360    LLVMValueRef floor_x;
 361
 362    /* floor( src0.x ) */
 363    floor_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 364                                       emit_data->args[0]);
 365
 366    /* 2 ^ floor( src0.x ) */
 367    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 368                                        TGSI_OPCODE_EX2, floor_x);
 369
 370    /* src0.x - floor( src0.x ) */
 371    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 372                    TGSI_OPCODE_SUB,  emit_data->args[0] /* src0.x */, floor_x);
 373
 374    /* 2 ^ src0.x */
 375    emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_unary(bld_base,
 376                              TGSI_OPCODE_EX2, emit_data->args[0] /* src0.x */);
 377
 378    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 379 }
 380
 381 const struct lp_build_tgsi_action exp_action = {
 382    scalar_unary_fetch_args,      /* fetch_args */
 383    exp_emit      /* emit */
 384 };
 385
 386 /* TGSI_OPCODE_FRC */
 387
 388 static void
 389 frc_emit(
 390    const struct lp_build_tgsi_action * action,
 391    struct lp_build_tgsi_context * bld_base,
 392    struct lp_build_emit_data * emit_data)
 393 {
 394    LLVMValueRef tmp;
 395    tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 396                                   emit_data->args[0]);
 397    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 398                                        TGSI_OPCODE_SUB, emit_data->args[0], tmp);
 399 }
 400
 401 /* TGSI_OPCODE_KILL_IF */
 402
 403 static void
 404 kil_fetch_args(
 405    struct lp_build_tgsi_context * bld_base,
 406    struct lp_build_emit_data * emit_data)
 407 {
 408    /* src0.x */
 409    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 410                                             0, TGSI_CHAN_X);
 411    /* src0.y */
 412    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 413                                             0, TGSI_CHAN_Y);
 414    /* src0.z */
 415    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
 416                                             0, TGSI_CHAN_Z);
 417    /* src0.w */
 418    emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
 419                                             0, TGSI_CHAN_W);
 420    emit_data->arg_count = 4;
 421    emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
 422 }
 423
 424 /* TGSI_OPCODE_KILL */
 425
 426 static void
 427 kilp_fetch_args(
 428    struct lp_build_tgsi_context * bld_base,
 429    struct lp_build_emit_data * emit_data)
 430 {
 431    emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
 432 }
 433
 434 /* TGSI_OPCODE_LIT */
 435
 436 static void
 437 lit_fetch_args(
 438    struct lp_build_tgsi_context * bld_base,
 439    struct lp_build_emit_data * emit_data)
 440 {
 441    /* src0.x */
 442    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_X);
 443    /* src0.y */
 444    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_Y);
 445    /* src0.w */
 446    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W);
 447    emit_data->arg_count = 3;
 448 }
 449
 450 static void
 451 lit_emit(
 452    const struct lp_build_tgsi_action * action,
 453    struct lp_build_tgsi_context * bld_base,
 454    struct lp_build_emit_data * emit_data)
 455 {
 456    LLVMValueRef tmp0, tmp1, tmp2;
 457
 458    /* dst.x */
 459    emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
 460
 461    /* dst. y */
 462    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 463                                                TGSI_OPCODE_MAX,
 464                                                emit_data->args[0] /* src0.x */,
 465                                                bld_base->base.zero);
 466
 467    /* dst.z */
 468    /* XMM[1] = SrcReg[0].yyyy */
 469    tmp1 = emit_data->args[1];
 470    /* XMM[1] = max(XMM[1], 0) */
 471    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
 472                                     tmp1, bld_base->base.zero);
 473    /* XMM[2] = SrcReg[0].wwww */
 474    tmp2 = emit_data->args[2];
 475    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_POW,
 476                                     tmp1, tmp2);
 477    tmp0 = emit_data->args[0];
 478    emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_ternary(bld_base,
 479                                              TGSI_OPCODE_CMP,
 480                                              tmp0, bld_base->base.zero, tmp1);
 481    /* dst.w */
 482    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 483 }
 484
 485 static struct lp_build_tgsi_action lit_action = {
 486    lit_fetch_args,       /* fetch_args */
 487    lit_emit      /* emit */
 488 };
 489
 490 /* TGSI_OPCODE_LOG */
 491
 492 static void
 493 log_emit(
 494    const struct lp_build_tgsi_action * action,
 495    struct lp_build_tgsi_context * bld_base,
 496    struct lp_build_emit_data * emit_data)
 497 {
 498
 499    LLVMValueRef abs_x, log_abs_x, flr_log_abs_x, ex2_flr_log_abs_x;
 500
 501    /* abs( src0.x) */
 502    abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
 503                                     emit_data->args[0] /* src0.x */);
 504
 505    /* log( abs( src0.x ) ) */
 506    log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_LG2,
 507                                         abs_x);
 508
 509    /* floor( log( abs( src0.x ) ) ) */
 510    flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 511                                             log_abs_x);
 512    /* dst.x */
 513    emit_data->output[TGSI_CHAN_X] = flr_log_abs_x;
 514
 515    /* dst.y */
 516    ex2_flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_EX2,
 517                                                 flr_log_abs_x);
 518
 519    /* abs( src0.x ) / 2^( floor( lg2( abs( src0.x ) ) ) ) */
 520    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 521                                     TGSI_OPCODE_DIV, abs_x, ex2_flr_log_abs_x);
 522
 523    /* dst.x */
 524    emit_data->output[TGSI_CHAN_Z] = log_abs_x;
 525
 526    /* dst.w */
 527    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 528 }
 529
 530 static struct lp_build_tgsi_action log_action = {
 531    scalar_unary_fetch_args,      /* fetch_args */
 532    log_emit      /* emit */
 533 };
 534
 535 /* TGSI_OPCODE_PK2H */
 536
 537 static void
 538 pk2h_fetch_args(
 539    struct lp_build_tgsi_context * bld_base,
 540    struct lp_build_emit_data * emit_data)
 541 {
 542    /* src0.x */
 543    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 544                                             0, TGSI_CHAN_X);
 545    /* src0.y */
 546    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 547                                             0, TGSI_CHAN_Y);
 548 }
 549
 550 static void
 551 pk2h_emit(
 552    const struct lp_build_tgsi_action *action,
 553    struct lp_build_tgsi_context *bld_base,
 554    struct lp_build_emit_data *emit_data)
 555 {
 556    struct gallivm_state *gallivm = bld_base->base.gallivm;
 557    struct lp_type f16i_t;
 558    LLVMValueRef lo, hi, res;
 559
 560    f16i_t = lp_type_uint_vec(16, bld_base->base.type.length * 32);
 561    lo = lp_build_float_to_half(gallivm, emit_data->args[0]);
 562    hi = lp_build_float_to_half(gallivm, emit_data->args[1]);
 563    /* maybe some interleave doubling vector width would be useful... */
 564    lo = lp_build_pad_vector(gallivm, lo, bld_base->base.type.length * 2);
 565    hi = lp_build_pad_vector(gallivm, hi, bld_base->base.type.length * 2);
 566    res = lp_build_interleave2(gallivm, f16i_t, lo, hi, 0);
 567
 568    emit_data->output[emit_data->chan] = res;
 569 }
 570
 571 static struct lp_build_tgsi_action pk2h_action = {
 572    pk2h_fetch_args, /* fetch_args */
 573    pk2h_emit        /* emit */
 574 };
 575
 576 /* TGSI_OPCODE_UP2H */
 577
 578 static void
 579 up2h_emit(
 580    const struct lp_build_tgsi_action *action,
 581    struct lp_build_tgsi_context *bld_base,
 582    struct lp_build_emit_data *emit_data)
 583 {
 584    struct gallivm_state *gallivm = bld_base->base.gallivm;
 585    LLVMBuilderRef builder = gallivm->builder;
 586    LLVMContextRef context = gallivm->context;
 587    LLVMValueRef lo, hi, res[2], arg;
 588    unsigned nr = bld_base->base.type.length;
 589    LLVMTypeRef i16t = LLVMVectorType(LLVMInt16TypeInContext(context), nr * 2);
 590
 591    arg = LLVMBuildBitCast(builder, emit_data->args[0], i16t, "");
 592    lo = lp_build_uninterleave1(gallivm, nr * 2, arg, 0);
 593    hi = lp_build_uninterleave1(gallivm, nr * 2, arg, 1);
 594    res[0] = lp_build_half_to_float(gallivm, lo);
 595    res[1] = lp_build_half_to_float(gallivm, hi);
 596
 597    emit_data->output[0] = emit_data->output[2] = res[0];
 598    emit_data->output[1] = emit_data->output[3] = res[1];
 599 }
 600
 601 static struct lp_build_tgsi_action up2h_action = {
 602    scalar_unary_fetch_args, /* fetch_args */
 603    up2h_emit                /* emit */
 604 };
 605
 606 /* TGSI_OPCODE_LRP */
 607
 608 static void
 609 lrp_emit(
 610    const struct lp_build_tgsi_action * action,
 611    struct lp_build_tgsi_context * bld_base,
 612    struct lp_build_emit_data * emit_data)
 613 {
 614    struct lp_build_context *bld = &bld_base->base;
 615    LLVMValueRef inv, a, b;
 616
 617    /* This uses the correct version: (1 - t)*a + t*b
 618     *
 619     * An alternative version is "a + t*(b-a)". The problem is this version
 620     * doesn't return "b" for t = 1, because "a + (b-a)" isn't equal to "b"
 621     * because of the floating-point rounding.
 622     */
 623    inv = lp_build_sub(bld, bld_base->base.one, emit_data->args[0]);
 624    a = lp_build_mul(bld, emit_data->args[1], emit_data->args[0]);
 625    b = lp_build_mul(bld, emit_data->args[2], inv);
 626    emit_data->output[emit_data->chan] = lp_build_add(bld, a, b);
 627 }
 628
 629 /* TGSI_OPCODE_MAD */
 630
 631 static void
 632 mad_emit(
 633    const struct lp_build_tgsi_action * action,
 634    struct lp_build_tgsi_context * bld_base,
 635    struct lp_build_emit_data * emit_data)
 636 {
 637    LLVMValueRef tmp;
 638    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 639                                    emit_data->args[0],
 640                                    emit_data->args[1]);
 641    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 642                                        TGSI_OPCODE_ADD, tmp, emit_data->args[2]);
 643 }
 644
 645 /* TGSI_OPCODE_MOV */
 646
 647 static void
 648 mov_emit(
 649    const struct lp_build_tgsi_action * action,
 650    struct lp_build_tgsi_context * bld_base,
 651    struct lp_build_emit_data * emit_data)
 652 {
 653    emit_data->output[emit_data->chan] = emit_data->args[0];
 654 }
 655
 656 /* TGSI_OPCODE_MUL */
 657 static void
 658 mul_emit(
 659    const struct lp_build_tgsi_action * action,
 660    struct lp_build_tgsi_context * bld_base,
 661    struct lp_build_emit_data * emit_data)
 662 {
 663    emit_data->output[emit_data->chan] = LLVMBuildFMul(
 664                                    bld_base->base.gallivm->builder,
 665                                    emit_data->args[0], emit_data->args[1], "");
 666 }
 667
 668 /*.TGSI_OPCODE_DIV.*/
 669 static void fdiv_emit(
 670    const struct lp_build_tgsi_action * action,
 671    struct lp_build_tgsi_context * bld_base,
 672    struct lp_build_emit_data * emit_data)
 673 {
 674    emit_data->output[emit_data->chan] = LLVMBuildFDiv(
 675                                    bld_base->base.gallivm->builder,
 676                                    emit_data->args[0], emit_data->args[1], "");
 677 }
 678
 679 /*.TGSI_OPCODE_RCP.*/
 680 static void rcp_emit(
 681    const struct lp_build_tgsi_action * action,
 682    struct lp_build_tgsi_context * bld_base,
 683    struct lp_build_emit_data * emit_data)
 684 {
 685    LLVMValueRef one;
 686    one = lp_build_const_float(bld_base->base.gallivm, 1.0f);
 687    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 688                                    TGSI_OPCODE_DIV, one, emit_data->args[0]);
 689 }
 690
 691 /* TGSI_OPCODE_POW */
 692
 693 static void
 694 pow_emit(
 695    const struct lp_build_tgsi_action * action,
 696    struct lp_build_tgsi_context * bld_base,
 697    struct lp_build_emit_data * emit_data)
 698 {
 699    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
 700                                    emit_data->args[0], emit_data->args[1]);
 701 }
 702
 703 static struct lp_build_tgsi_action pow_action = {
 704    scalar_binary_fetch_args,     /* fetch_args */
 705    pow_emit      /* emit */
 706 };
 707
 708 /* TGSI_OPCODE_RSQ */
 709
 710 static void
 711 rsq_emit(
 712    const struct lp_build_tgsi_action * action,
 713    struct lp_build_tgsi_context * bld_base,
 714    struct lp_build_emit_data * emit_data)
 715 {
 716    if (bld_base->rsq_action.emit) {
 717       bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
 718    } else {
 719       emit_data->output[emit_data->chan] = bld_base->base.undef;
 720    }
 721 }
 722
 723 const struct lp_build_tgsi_action rsq_action = {
 724    scalar_unary_fetch_args,      /* fetch_args */
 725    rsq_emit      /* emit */
 726
 727 };
 728
 729 /* TGSI_OPCODE_SQRT */
 730
 731 static void
 732 sqrt_emit(
 733    const struct lp_build_tgsi_action * action,
 734    struct lp_build_tgsi_context * bld_base,
 735    struct lp_build_emit_data * emit_data)
 736 {
 737    if (bld_base->sqrt_action.emit) {
 738       bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data);
 739    } else {
 740       emit_data->output[emit_data->chan] = bld_base->base.undef;
 741    }
 742 }
 743
 744 const struct lp_build_tgsi_action sqrt_action = {
 745    scalar_unary_fetch_args,      /* fetch_args */
 746    sqrt_emit     /* emit */
 747 };
 748
 749 /* TGSI_OPCODE_SCS */
 750 static void
 751 scs_emit(
 752    const struct lp_build_tgsi_action * action,
 753    struct lp_build_tgsi_context * bld_base,
 754    struct lp_build_emit_data * emit_data)
 755 {
 756    /* dst.x */
 757    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 758                                            TGSI_OPCODE_COS, emit_data->args[0]);
 759    /* dst.y */
 760    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
 761                                            TGSI_OPCODE_SIN, emit_data->args[0]);
 762    /* dst.z */
 763    emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
 764
 765    /* dst.w */
 766    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 767 }
 768
 769 const struct lp_build_tgsi_action scs_action = {
 770    scalar_unary_fetch_args,      /* fetch_args */
 771    scs_emit      /* emit */
 772 };
 773
 774 /* TGSI_OPCODE_SUB */
 775 static void
 776 sub_emit(
 777    const struct lp_build_tgsi_action * action,
 778    struct lp_build_tgsi_context * bld_base,
 779    struct lp_build_emit_data * emit_data)
 780 {
 781    emit_data->output[emit_data->chan] =
 782       LLVMBuildFSub(bld_base->base.gallivm->builder,
 783                     emit_data->args[0],
 784                     emit_data->args[1], "");
 785 }
 786
 787 /* TGSI_OPCODE_F2U */
 788 static void
 789 f2u_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    emit_data->output[emit_data->chan] =
 795       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
 796                       emit_data->args[0],
 797                       bld_base->base.int_vec_type, "");
 798 }
 799
 800 /* TGSI_OPCODE_U2F */
 801 static void
 802 u2f_emit(
 803    const struct lp_build_tgsi_action * action,
 804    struct lp_build_tgsi_context * bld_base,
 805    struct lp_build_emit_data * emit_data)
 806 {
 807    emit_data->output[emit_data->chan] =
 808       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
 809                       emit_data->args[0],
 810                       bld_base->base.vec_type, "");
 811 }
 812
 813 static void
 814 umad_emit(
 815    const struct lp_build_tgsi_action * action,
 816    struct lp_build_tgsi_context * bld_base,
 817    struct lp_build_emit_data * emit_data)
 818 {
 819    LLVMValueRef tmp;
 820    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
 821                                    emit_data->args[0],
 822                                    emit_data->args[1]);
 823    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 824                                        TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
 825 }
 826
 827 /* TGSI_OPCODE_UMUL */
 828 static void
 829 umul_emit(
 830    const struct lp_build_tgsi_action * action,
 831    struct lp_build_tgsi_context * bld_base,
 832    struct lp_build_emit_data * emit_data)
 833 {
 834    emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
 835                                    emit_data->args[0], emit_data->args[1]);
 836 }
 837
 838 /* TGSI_OPCODE_IMUL_HI */
 839 static void
 840 imul_hi_emit(
 841    const struct lp_build_tgsi_action * action,
 842    struct lp_build_tgsi_context * bld_base,
 843    struct lp_build_emit_data * emit_data)
 844 {
 845    struct lp_build_context *int_bld = &bld_base->int_bld;
 846    LLVMValueRef hi_bits;
 847
 848    assert(int_bld->type.width == 32);
 849
 850    /* low result bits are tossed away */
 851    lp_build_mul_32_lohi(int_bld, emit_data->args[0],
 852                         emit_data->args[1], &hi_bits);
 853    emit_data->output[emit_data->chan] = hi_bits;
 854 }
 855
 856 static void
 857 imul_hi_emit_cpu(
 858    const struct lp_build_tgsi_action * action,
 859    struct lp_build_tgsi_context * bld_base,
 860    struct lp_build_emit_data * emit_data)
 861 {
 862    struct lp_build_context *int_bld = &bld_base->int_bld;
 863    LLVMValueRef hi_bits;
 864
 865    assert(int_bld->type.width == 32);
 866
 867    /* low result bits are tossed away */
 868    lp_build_mul_32_lohi_cpu(int_bld, emit_data->args[0],
 869                             emit_data->args[1], &hi_bits);
 870    emit_data->output[emit_data->chan] = hi_bits;
 871 }
 872
 873 /* TGSI_OPCODE_UMUL_HI */
 874 static void
 875 umul_hi_emit(
 876    const struct lp_build_tgsi_action * action,
 877    struct lp_build_tgsi_context * bld_base,
 878    struct lp_build_emit_data * emit_data)
 879 {
 880    struct lp_build_context *uint_bld = &bld_base->uint_bld;
 881    LLVMValueRef hi_bits;
 882
 883    assert(uint_bld->type.width == 32);
 884
 885    /* low result bits are tossed away */
 886    lp_build_mul_32_lohi(uint_bld, emit_data->args[0],
 887                         emit_data->args[1], &hi_bits);
 888    emit_data->output[emit_data->chan] = hi_bits;
 889 }
 890
 891 static void
 892 umul_hi_emit_cpu(
 893    const struct lp_build_tgsi_action * action,
 894    struct lp_build_tgsi_context * bld_base,
 895    struct lp_build_emit_data * emit_data)
 896 {
 897    struct lp_build_context *uint_bld = &bld_base->uint_bld;
 898    LLVMValueRef hi_bits;
 899
 900    assert(uint_bld->type.width == 32);
 901
 902    /* low result bits are tossed away */
 903    lp_build_mul_32_lohi_cpu(uint_bld, emit_data->args[0],
 904                             emit_data->args[1], &hi_bits);
 905    emit_data->output[emit_data->chan] = hi_bits;
 906 }
 907
 908 /* TGSI_OPCODE_MAX */
 909 static void fmax_emit(
 910    const struct lp_build_tgsi_action * action,
 911    struct lp_build_tgsi_context * bld_base,
 912    struct lp_build_emit_data * emit_data)
 913 {
 914    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 915    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 916                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 917                                    emit_data->args[0], emit_data->args[1], ""),
 918                                    emit_data->args[0], emit_data->args[1], "");
 919 }
 920
 921 /* TGSI_OPCODE_MIN */
 922 static void fmin_emit(
 923    const struct lp_build_tgsi_action * action,
 924    struct lp_build_tgsi_context * bld_base,
 925    struct lp_build_emit_data * emit_data)
 926 {
 927    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
 928    emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
 929                                    LLVMBuildFCmp(builder, LLVMRealUGE,
 930                                    emit_data->args[0], emit_data->args[1], ""),
 931                                    emit_data->args[1], emit_data->args[0], "");
 932 }
 933
 934 /* TGSI_OPCODE_XPD */
 935
 936 static void
 937 xpd_fetch_args(
 938    struct lp_build_tgsi_context * bld_base,
 939    struct lp_build_emit_data * emit_data)
 940 {
 941    dp_fetch_args(bld_base, emit_data, 3);
 942 }
 943
 944 /**
 945  * (a * b) - (c * d)
 946  */
 947 static LLVMValueRef
 948 xpd_helper(
 949   struct lp_build_tgsi_context * bld_base,
 950   LLVMValueRef a,
 951   LLVMValueRef b,
 952   LLVMValueRef c,
 953   LLVMValueRef d)
 954 {
 955    LLVMValueRef tmp0, tmp1;
 956
 957    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
 958    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
 959
 960    return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
 961 }
 962
 963 static void
 964 xpd_emit(
 965    const struct lp_build_tgsi_action * action,
 966    struct lp_build_tgsi_context * bld_base,
 967    struct lp_build_emit_data * emit_data)
 968 {
 969    emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
 970               emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
 971               emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
 972
 973    emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
 974               emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
 975               emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
 976
 977    emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
 978               emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
 979               emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
 980
 981    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 982 }
 983
 984 const struct lp_build_tgsi_action xpd_action = {
 985    xpd_fetch_args,       /* fetch_args */
 986    xpd_emit      /* emit */
 987 };
 988
 989 /* TGSI_OPCODE_D2F */
 990 static void
 991 d2f_emit(
 992    const struct lp_build_tgsi_action * action,
 993    struct lp_build_tgsi_context * bld_base,
 994    struct lp_build_emit_data * emit_data)
 995 {
 996    emit_data->output[emit_data->chan] =
 997       LLVMBuildFPTrunc(bld_base->base.gallivm->builder,
 998                       emit_data->args[0],
 999                        bld_base->base.vec_type, "");
1000 }
1001
1002 /* TGSI_OPCODE_D2I */
1003 static void
1004 d2i_emit(
1005    const struct lp_build_tgsi_action * action,
1006    struct lp_build_tgsi_context * bld_base,
1007    struct lp_build_emit_data * emit_data)
1008 {
1009    emit_data->output[emit_data->chan] =
1010       LLVMBuildFPToSI(bld_base->base.gallivm->builder,
1011                       emit_data->args[0],
1012                       bld_base->base.int_vec_type, "");
1013 }
1014
1015 /* TGSI_OPCODE_D2U */
1016 static void
1017 d2u_emit(
1018    const struct lp_build_tgsi_action * action,
1019    struct lp_build_tgsi_context * bld_base,
1020    struct lp_build_emit_data * emit_data)
1021 {
1022    emit_data->output[emit_data->chan] =
1023       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
1024                       emit_data->args[0],
1025                       bld_base->base.int_vec_type, "");
1026 }
1027
1028 /* TGSI_OPCODE_F2D */
1029 static void
1030 f2d_emit(
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    emit_data->output[emit_data->chan] =
1036       LLVMBuildFPExt(bld_base->base.gallivm->builder,
1037                       emit_data->args[0],
1038                       bld_base->dbl_bld.vec_type, "");
1039 }
1040
1041 /* TGSI_OPCODE_U2D */
1042 static void
1043 u2d_emit(
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    emit_data->output[emit_data->chan] =
1049       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
1050                       emit_data->args[0],
1051                       bld_base->dbl_bld.vec_type, "");
1052 }
1053
1054 /* TGSI_OPCODE_I2D */
1055 static void
1056 i2d_emit(
1057    const struct lp_build_tgsi_action * action,
1058    struct lp_build_tgsi_context * bld_base,
1059    struct lp_build_emit_data * emit_data)
1060 {
1061    emit_data->output[emit_data->chan] =
1062       LLVMBuildSIToFP(bld_base->base.gallivm->builder,
1063                       emit_data->args[0],
1064                       bld_base->dbl_bld.vec_type, "");
1065 }
1066
1067 /* TGSI_OPCODE_DMAD */
1068 static void
1069 dmad_emit(
1070    const struct lp_build_tgsi_action * action,
1071    struct lp_build_tgsi_context * bld_base,
1072    struct lp_build_emit_data * emit_data)
1073 {
1074    LLVMValueRef tmp;
1075    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_DMUL,
1076                                    emit_data->args[0],
1077                                    emit_data->args[1]);
1078    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
1079                                        TGSI_OPCODE_DADD, tmp, emit_data->args[2]);
1080 }
1081
1082 /*.TGSI_OPCODE_DRCP.*/
1083 static void drcp_emit(
1084    const struct lp_build_tgsi_action * action,
1085    struct lp_build_tgsi_context * bld_base,
1086    struct lp_build_emit_data * emit_data)
1087 {
1088    LLVMValueRef one;
1089    one = lp_build_const_vec(bld_base->dbl_bld.gallivm, bld_base->dbl_bld.type, 1.0f);
1090    emit_data->output[emit_data->chan] = LLVMBuildFDiv(
1091       bld_base->base.gallivm->builder,
1092       one, emit_data->args[0], "");
1093 }
1094
1095 /* TGSI_OPCODE_DFRAC */
1096 static void dfrac_emit(
1097    const struct lp_build_tgsi_action * action,
1098    struct lp_build_tgsi_context * bld_base,
1099    struct lp_build_emit_data * emit_data)
1100 {
1101    LLVMValueRef tmp;
1102    tmp = lp_build_floor(&bld_base->dbl_bld,
1103                         emit_data->args[0]);
1104    emit_data->output[emit_data->chan] =  LLVMBuildFSub(bld_base->base.gallivm->builder,
1105                                                        emit_data->args[0], tmp, "");
1106 }
1107
1108 static void
1109 u64mul_emit(
1110    const struct lp_build_tgsi_action * action,
1111    struct lp_build_tgsi_context * bld_base,
1112    struct lp_build_emit_data * emit_data)
1113 {
1114    emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint64_bld,
1115                                    emit_data->args[0], emit_data->args[1]);
1116 }
1117
1118 static void
1119 u64mod_emit_cpu(
1120    const struct lp_build_tgsi_action * action,
1121    struct lp_build_tgsi_context * bld_base,
1122    struct lp_build_emit_data * emit_data)
1123 {
1124    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1125    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld,
1126                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1127                                         bld_base->uint64_bld.zero);
1128    /* We want to make sure that we never divide/mod by zero to not
1129     * generate sigfpe. We don't want to crash just because the
1130     * shader is doing something weird. */
1131    LLVMValueRef divisor = LLVMBuildOr(builder,
1132                                       div_mask,
1133                                       emit_data->args[1], "");
1134    LLVMValueRef result = lp_build_mod(&bld_base->uint64_bld,
1135                                       emit_data->args[0], divisor);
1136    /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1137    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1138                                                     div_mask,
1139                                                     result, "");
1140 }
1141
1142 static void
1143 i64mod_emit_cpu(
1144    const struct lp_build_tgsi_action * action,
1145    struct lp_build_tgsi_context * bld_base,
1146    struct lp_build_emit_data * emit_data)
1147 {
1148    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1149    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld,
1150                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1151                                         bld_base->uint64_bld.zero);
1152    /* We want to make sure that we never divide/mod by zero to not
1153     * generate sigfpe. We don't want to crash just because the
1154     * shader is doing something weird. */
1155    LLVMValueRef divisor = LLVMBuildOr(builder,
1156                                       div_mask,
1157                                       emit_data->args[1], "");
1158    LLVMValueRef result = lp_build_mod(&bld_base->int64_bld,
1159                                       emit_data->args[0], divisor);
1160    /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1161    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1162                                                     div_mask,
1163                                                     result, "");
1164 }
1165
1166 static void
1167 u64div_emit_cpu(
1168    const struct lp_build_tgsi_action * action,
1169    struct lp_build_tgsi_context * bld_base,
1170    struct lp_build_emit_data * emit_data)
1171 {
1172
1173    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1174    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld,
1175                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1176                                         bld_base->uint64_bld.zero);
1177    /* We want to make sure that we never divide/mod by zero to not
1178     * generate sigfpe. We don't want to crash just because the
1179     * shader is doing something weird. */
1180    LLVMValueRef divisor = LLVMBuildOr(builder,
1181                                       div_mask,
1182                                       emit_data->args[1], "");
1183    LLVMValueRef result = LLVMBuildUDiv(builder,
1184                                        emit_data->args[0], divisor, "");
1185    /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
1186    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1187                                                     div_mask,
1188                                                     result, "");
1189 }
1190
1191 static void
1192 i64div_emit_cpu(
1193    const struct lp_build_tgsi_action * action,
1194    struct lp_build_tgsi_context * bld_base,
1195    struct lp_build_emit_data * emit_data)
1196 {
1197
1198    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1199    LLVMValueRef div_mask = lp_build_cmp(&bld_base->int64_bld,
1200                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1201                                         bld_base->int64_bld.zero);
1202    /* We want to make sure that we never divide/mod by zero to not
1203     * generate sigfpe. We don't want to crash just because the
1204     * shader is doing something weird. */
1205    LLVMValueRef divisor = LLVMBuildOr(builder,
1206                                       div_mask,
1207                                       emit_data->args[1], "");
1208    LLVMValueRef result = LLVMBuildSDiv(builder,
1209                                        emit_data->args[0], divisor, "");
1210    /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
1211    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1212                                                     div_mask,
1213                                                     result, "");
1214 }
1215
1216 static void
1217 f2u64_emit(
1218    const struct lp_build_tgsi_action * action,
1219    struct lp_build_tgsi_context * bld_base,
1220    struct lp_build_emit_data * emit_data)
1221 {
1222    emit_data->output[emit_data->chan] =
1223       LLVMBuildFPToUI(bld_base->base.gallivm->builder,
1224                       emit_data->args[0],
1225                       bld_base->uint64_bld.vec_type, "");
1226 }
1227
1228 static void
1229 f2i64_emit(
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] =
1235       LLVMBuildFPToSI(bld_base->base.gallivm->builder,
1236                       emit_data->args[0],
1237                       bld_base->int64_bld.vec_type, "");
1238 }
1239
1240 static void
1241 u2i64_emit(
1242    const struct lp_build_tgsi_action * action,
1243    struct lp_build_tgsi_context * bld_base,
1244    struct lp_build_emit_data * emit_data)
1245 {
1246    emit_data->output[emit_data->chan] =
1247       LLVMBuildZExt(bld_base->base.gallivm->builder,
1248                       emit_data->args[0],
1249                       bld_base->uint64_bld.vec_type, "");
1250 }
1251
1252 static void
1253 i2i64_emit(
1254    const struct lp_build_tgsi_action * action,
1255    struct lp_build_tgsi_context * bld_base,
1256    struct lp_build_emit_data * emit_data)
1257 {
1258    emit_data->output[emit_data->chan] =
1259       LLVMBuildSExt(bld_base->base.gallivm->builder,
1260                       emit_data->args[0],
1261                       bld_base->int64_bld.vec_type, "");
1262 }
1263
1264 static void
1265 i642f_emit(
1266    const struct lp_build_tgsi_action * action,
1267    struct lp_build_tgsi_context * bld_base,
1268    struct lp_build_emit_data * emit_data)
1269 {
1270    emit_data->output[emit_data->chan] =
1271       LLVMBuildSIToFP(bld_base->base.gallivm->builder,
1272                       emit_data->args[0],
1273                       bld_base->base.vec_type, "");
1274 }
1275
1276 static void
1277 u642f_emit(
1278    const struct lp_build_tgsi_action * action,
1279    struct lp_build_tgsi_context * bld_base,
1280    struct lp_build_emit_data * emit_data)
1281 {
1282    emit_data->output[emit_data->chan] =
1283       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
1284                       emit_data->args[0],
1285                       bld_base->base.vec_type, "");
1286 }
1287
1288 static void
1289 i642d_emit(
1290    const struct lp_build_tgsi_action * action,
1291    struct lp_build_tgsi_context * bld_base,
1292    struct lp_build_emit_data * emit_data)
1293 {
1294    emit_data->output[emit_data->chan] =
1295       LLVMBuildSIToFP(bld_base->base.gallivm->builder,
1296                       emit_data->args[0],
1297                       bld_base->dbl_bld.vec_type, "");
1298 }
1299
1300 static void
1301 u642d_emit(
1302    const struct lp_build_tgsi_action * action,
1303    struct lp_build_tgsi_context * bld_base,
1304    struct lp_build_emit_data * emit_data)
1305 {
1306    emit_data->output[emit_data->chan] =
1307       LLVMBuildUIToFP(bld_base->base.gallivm->builder,
1308                       emit_data->args[0],
1309                       bld_base->dbl_bld.vec_type, "");
1310 }
1311
1312 void
1313 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
1314 {
1315    bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
1316    bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
1317    bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
1318    bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
1319    bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
1320    bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
1321    bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
1322    bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
1323    bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
1324    bld_base->op_actions[TGSI_OPCODE_PK2H] = pk2h_action;
1325    bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
1326    bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action;
1327    bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
1328    bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
1329    bld_base->op_actions[TGSI_OPCODE_UP2H] = up2h_action;
1330    bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
1331
1332    bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args;
1333    bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args;
1334    bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args;
1335    bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
1336    bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
1337    bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
1338    bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args;
1339    bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args;
1340    bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args;
1341    bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
1342    bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
1343    bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
1344
1345    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
1346    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
1347    bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
1348    bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
1349    bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
1350    bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
1351    bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
1352    bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
1353    bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
1354    bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
1355    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
1356    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
1357
1358    bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
1359    bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit;
1360    bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
1361    bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
1362    bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
1363    bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit;
1364    bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit;
1365
1366    bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit;
1367    bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit;
1368
1369    bld_base->op_actions[TGSI_OPCODE_DADD].emit = add_emit;
1370    bld_base->op_actions[TGSI_OPCODE_DMAX].emit = fmax_emit;
1371    bld_base->op_actions[TGSI_OPCODE_DMIN].emit = fmin_emit;
1372    bld_base->op_actions[TGSI_OPCODE_DMUL].emit = mul_emit;
1373
1374    bld_base->op_actions[TGSI_OPCODE_D2F].emit = d2f_emit;
1375    bld_base->op_actions[TGSI_OPCODE_D2I].emit = d2i_emit;
1376    bld_base->op_actions[TGSI_OPCODE_D2U].emit = d2u_emit;
1377
1378    bld_base->op_actions[TGSI_OPCODE_F2D].emit = f2d_emit;
1379    bld_base->op_actions[TGSI_OPCODE_I2D].emit = i2d_emit;
1380    bld_base->op_actions[TGSI_OPCODE_U2D].emit = u2d_emit;
1381
1382    bld_base->op_actions[TGSI_OPCODE_DMAD].emit = dmad_emit;
1383
1384    bld_base->op_actions[TGSI_OPCODE_DRCP].emit = drcp_emit;
1385    bld_base->op_actions[TGSI_OPCODE_DFRAC].emit = dfrac_emit;
1386
1387    bld_base->op_actions[TGSI_OPCODE_U64MUL].emit = u64mul_emit;
1388
1389    bld_base->op_actions[TGSI_OPCODE_F2I64].emit = f2i64_emit;
1390    bld_base->op_actions[TGSI_OPCODE_F2U64].emit = f2u64_emit;
1391
1392    bld_base->op_actions[TGSI_OPCODE_D2I64].emit = f2i64_emit;
1393    bld_base->op_actions[TGSI_OPCODE_D2U64].emit = f2u64_emit;
1394
1395    bld_base->op_actions[TGSI_OPCODE_I2I64].emit = i2i64_emit;
1396    bld_base->op_actions[TGSI_OPCODE_U2I64].emit = u2i64_emit;
1397
1398    bld_base->op_actions[TGSI_OPCODE_I642F].emit = i642f_emit;
1399    bld_base->op_actions[TGSI_OPCODE_U642F].emit = u642f_emit;
1400
1401    bld_base->op_actions[TGSI_OPCODE_I642F].emit = i642f_emit;
1402    bld_base->op_actions[TGSI_OPCODE_U642F].emit = u642f_emit;
1403
1404    bld_base->op_actions[TGSI_OPCODE_I642D].emit = i642d_emit;
1405    bld_base->op_actions[TGSI_OPCODE_U642D].emit = u642d_emit;
1406
1407 }
1408
1409 /* CPU Only default actions */
1410
1411 /* These actions are CPU only, because they could potentially output SSE
1412  * intrinsics.
1413  */
1414
1415 /* TGSI_OPCODE_ABS (CPU Only)*/
1416
1417 static void
1418 abs_emit_cpu(
1419    const struct lp_build_tgsi_action * action,
1420    struct lp_build_tgsi_context * bld_base,
1421    struct lp_build_emit_data * emit_data)
1422 {
1423    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base,
1424                                                        emit_data->args[0]);
1425 }
1426
1427 /* TGSI_OPCODE_ADD (CPU Only) */
1428 static void
1429 add_emit_cpu(
1430    const struct lp_build_tgsi_action * action,
1431    struct lp_build_tgsi_context * bld_base,
1432    struct lp_build_emit_data * emit_data)
1433 {
1434    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
1435                                    emit_data->args[0], emit_data->args[1]);
1436 }
1437
1438 /* TGSI_OPCODE_AND (CPU Only) */
1439 static void
1440 and_emit_cpu(
1441    const struct lp_build_tgsi_action * action,
1442    struct lp_build_tgsi_context * bld_base,
1443    struct lp_build_emit_data * emit_data)
1444 {
1445    emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
1446                                    emit_data->args[0], emit_data->args[1]);
1447 }
1448
1449 /* TGSI_OPCODE_ARL (CPU Only) */
1450 static void
1451 arl_emit_cpu(
1452    const struct lp_build_tgsi_action * action,
1453    struct lp_build_tgsi_context * bld_base,
1454    struct lp_build_emit_data * emit_data)
1455 {
1456    LLVMValueRef tmp;
1457    tmp = lp_build_floor(&bld_base->base,
1458                         emit_data->args[0]);
1459    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
1460                                                         bld_base->uint_bld.vec_type, "");
1461 }
1462
1463 /* TGSI_OPCODE_ARR (CPU Only) */
1464 static void
1465 arr_emit_cpu(
1466    const struct lp_build_tgsi_action * action,
1467    struct lp_build_tgsi_context * bld_base,
1468    struct lp_build_emit_data * emit_data)
1469 {
1470    emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
1471 }
1472
1473 /* TGSI_OPCODE_CEIL (CPU Only) */
1474 static void
1475 ceil_emit_cpu(
1476    const struct lp_build_tgsi_action * action,
1477    struct lp_build_tgsi_context * bld_base,
1478    struct lp_build_emit_data * emit_data)
1479 {
1480    emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
1481                                                       emit_data->args[0]);
1482 }
1483
1484 /* TGSI_OPCODE_CMP (CPU Only) */
1485 static void
1486 cmp_emit_cpu(
1487    const struct lp_build_tgsi_action * action,
1488    struct lp_build_tgsi_context * bld_base,
1489    struct lp_build_emit_data * emit_data)
1490 {
1491    LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
1492                                    emit_data->args[0], bld_base->base.zero);
1493    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1494                                 cond, emit_data->args[1], emit_data->args[2]);
1495 }
1496
1497 /* TGSI_OPCODE_UCMP (CPU Only) */
1498 static void
1499 ucmp_emit_cpu(
1500    const struct lp_build_tgsi_action * action,
1501    struct lp_build_tgsi_context * bld_base,
1502    struct lp_build_emit_data * emit_data)
1503 {
1504    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1505    struct lp_build_context *uint_bld = &bld_base->uint_bld;
1506    LLVMValueRef unsigned_cond =
1507       LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, "");
1508    LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL,
1509                                     unsigned_cond,
1510                                     uint_bld->zero);
1511    emit_data->output[emit_data->chan] =
1512       lp_build_select(&bld_base->base,
1513                       cond, emit_data->args[1], emit_data->args[2]);
1514 }
1515
1516 /* TGSI_OPCODE_COS (CPU Only) */
1517 static void
1518 cos_emit_cpu(
1519    const struct lp_build_tgsi_action * action,
1520    struct lp_build_tgsi_context * bld_base,
1521    struct lp_build_emit_data * emit_data)
1522 {
1523    emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
1524                                                        emit_data->args[0]);
1525 }
1526
1527 /* TGSI_OPCODE_DIV (CPU Only) */
1528 static void
1529 div_emit_cpu(
1530    const struct lp_build_tgsi_action * action,
1531    struct lp_build_tgsi_context * bld_base,
1532    struct lp_build_emit_data * emit_data)
1533 {
1534    emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
1535                                    emit_data->args[0], emit_data->args[1]);
1536 }
1537
1538 /* TGSI_OPCODE_EX2 (CPU Only) */
1539 static void
1540 ex2_emit_cpu(
1541    const struct lp_build_tgsi_action * action,
1542    struct lp_build_tgsi_context * bld_base,
1543    struct lp_build_emit_data * emit_data)
1544 {
1545    emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
1546                                                         emit_data->args[0]);
1547 }
1548
1549 /* TGSI_OPCODE_F2I (CPU Only) */
1550 static void
1551 f2i_emit_cpu(
1552    const struct lp_build_tgsi_action * action,
1553    struct lp_build_tgsi_context * bld_base,
1554    struct lp_build_emit_data * emit_data)
1555 {
1556    emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1557                                                         emit_data->args[0]);
1558 }
1559
1560 /* TGSI_OPCODE_FSET Helper (CPU Only) */
1561 static void
1562 fset_emit_cpu(
1563    const struct lp_build_tgsi_action * action,
1564    struct lp_build_tgsi_context * bld_base,
1565    struct lp_build_emit_data * emit_data,
1566    unsigned pipe_func)
1567 {
1568    LLVMValueRef cond;
1569
1570    if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1571       cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1572                                   emit_data->args[0], emit_data->args[1]);
1573    }
1574    else {
1575       cond = lp_build_cmp(&bld_base->base, pipe_func,
1576                           emit_data->args[0], emit_data->args[1]);
1577
1578    }
1579    emit_data->output[emit_data->chan] = cond;
1580 }
1581
1582
1583 /* TGSI_OPCODE_FSEQ (CPU Only) */
1584 static void
1585 fseq_emit_cpu(
1586    const struct lp_build_tgsi_action * action,
1587    struct lp_build_tgsi_context * bld_base,
1588    struct lp_build_emit_data * emit_data)
1589 {
1590    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1591 }
1592
1593 /* TGSI_OPCODE_ISGE (CPU Only) */
1594 static void
1595 fsge_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    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1601 }
1602
1603 /* TGSI_OPCODE_ISLT (CPU Only) */
1604 static void
1605 fslt_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    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1611 }
1612
1613 /* TGSI_OPCODE_USNE (CPU Only) */
1614
1615 static void
1616 fsne_emit_cpu(
1617    const struct lp_build_tgsi_action * action,
1618    struct lp_build_tgsi_context * bld_base,
1619    struct lp_build_emit_data * emit_data)
1620 {
1621    fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1622 }
1623
1624 /* TGSI_OPCODE_FLR (CPU Only) */
1625
1626 static void
1627 flr_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_floor(&bld_base->base,
1633                                                          emit_data->args[0]);
1634 }
1635
1636 /* TGSI_OPCODE_I2F (CPU Only) */
1637 static void
1638 i2f_emit_cpu(
1639    const struct lp_build_tgsi_action * action,
1640    struct lp_build_tgsi_context * bld_base,
1641    struct lp_build_emit_data * emit_data)
1642 {
1643    emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1644                                                               emit_data->args[0]);
1645 }
1646
1647 /* TGSI_OPCODE_IABS (CPU Only) */
1648 static void
1649 iabs_emit_cpu(
1650    const struct lp_build_tgsi_action * action,
1651    struct lp_build_tgsi_context * bld_base,
1652    struct lp_build_emit_data * emit_data)
1653 {
1654    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1655                                                        emit_data->args[0]);
1656 }
1657
1658 /* TGSI_OPCODE_IDIV (CPU Only) */
1659 static void
1660 idiv_emit_cpu(
1661    const struct lp_build_tgsi_action * action,
1662    struct lp_build_tgsi_context * bld_base,
1663    struct lp_build_emit_data * emit_data)
1664 {
1665    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1666    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1667                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1668                                         bld_base->uint_bld.zero);
1669    /* We want to make sure that we never divide/mod by zero to not
1670     * generate sigfpe. We don't want to crash just because the
1671     * shader is doing something weird. */
1672    LLVMValueRef divisor = LLVMBuildOr(builder,
1673                                       div_mask,
1674                                       emit_data->args[1], "");
1675    LLVMValueRef result = lp_build_div(&bld_base->int_bld,
1676                                       emit_data->args[0], divisor);
1677    LLVMValueRef not_div_mask = LLVMBuildNot(builder,
1678                                             div_mask,"");
1679    /* idiv by zero doesn't have a guaranteed return value chose 0 for now. */
1680    emit_data->output[emit_data->chan] = LLVMBuildAnd(builder,
1681                                                      not_div_mask,
1682                                                      result, "");
1683 }
1684
1685 /* TGSI_OPCODE_INEG (CPU Only) */
1686 static void
1687 ineg_emit_cpu(
1688    const struct lp_build_tgsi_action * action,
1689    struct lp_build_tgsi_context * bld_base,
1690    struct lp_build_emit_data * emit_data)
1691 {
1692    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld,
1693                                                      bld_base->int_bld.zero,
1694                                                      emit_data->args[0]);
1695 }
1696
1697 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1698 static void
1699 iset_emit_cpu(
1700    const struct lp_build_tgsi_action * action,
1701    struct lp_build_tgsi_context * bld_base,
1702    struct lp_build_emit_data * emit_data,
1703    unsigned pipe_func)
1704 {
1705    LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1706                                     emit_data->args[0], emit_data->args[1]);
1707    emit_data->output[emit_data->chan] = cond;
1708 }
1709
1710 /* TGSI_OPCODE_IMAX (CPU Only) */
1711 static void
1712 imax_emit_cpu(
1713    const struct lp_build_tgsi_action * action,
1714    struct lp_build_tgsi_context * bld_base,
1715    struct lp_build_emit_data * emit_data)
1716 {
1717    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1718                                    emit_data->args[0], emit_data->args[1]);
1719 }
1720
1721 /* TGSI_OPCODE_IMIN (CPU Only) */
1722 static void
1723 imin_emit_cpu(
1724    const struct lp_build_tgsi_action * action,
1725    struct lp_build_tgsi_context * bld_base,
1726    struct lp_build_emit_data * emit_data)
1727 {
1728    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1729                                    emit_data->args[0], emit_data->args[1]);
1730 }
1731
1732 /* TGSI_OPCODE_ISGE (CPU Only) */
1733 static void
1734 isge_emit_cpu(
1735    const struct lp_build_tgsi_action * action,
1736    struct lp_build_tgsi_context * bld_base,
1737    struct lp_build_emit_data * emit_data)
1738 {
1739    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1740 }
1741
1742 /* TGSI_OPCODE_ISHR (CPU Only) */
1743 static void
1744 ishr_emit_cpu(
1745    const struct lp_build_tgsi_action * action,
1746    struct lp_build_tgsi_context * bld_base,
1747    struct lp_build_emit_data * emit_data)
1748 {
1749    struct lp_build_context *int_bld = &bld_base->int_bld;
1750    LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type,
1751                                           int_bld->type.width - 1);
1752    LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask);
1753    emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0],
1754                                                      masked_count);
1755 }
1756
1757 /* TGSI_OPCODE_ISLT (CPU Only) */
1758 static void
1759 islt_emit_cpu(
1760    const struct lp_build_tgsi_action * action,
1761    struct lp_build_tgsi_context * bld_base,
1762    struct lp_build_emit_data * emit_data)
1763 {
1764    iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1765 }
1766
1767
1768 /* TGSI_OPCODE_ISSG (CPU Only) */
1769 static void
1770 issg_emit_cpu(
1771    const struct lp_build_tgsi_action * action,
1772    struct lp_build_tgsi_context * bld_base,
1773    struct lp_build_emit_data * emit_data)
1774 {
1775    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1776                                                        emit_data->args[0]);
1777 }
1778
1779 /* TGSI_OPCODE_LG2 (CPU Only) */
1780 static void
1781 lg2_emit_cpu(
1782    const struct lp_build_tgsi_action * action,
1783    struct lp_build_tgsi_context * bld_base,
1784    struct lp_build_emit_data * emit_data)
1785 {
1786    emit_data->output[emit_data->chan] = lp_build_log2_safe(&bld_base->base,
1787                                                            emit_data->args[0]);
1788 }
1789
1790 /* TGSI_OPCODE_LOG (CPU Only) */
1791 static void
1792 log_emit_cpu(
1793    const struct lp_build_tgsi_action * action,
1794    struct lp_build_tgsi_context * bld_base,
1795    struct lp_build_emit_data * emit_data)
1796 {
1797    LLVMValueRef p_floor_log2;
1798    LLVMValueRef p_exp;
1799    LLVMValueRef p_log2;
1800    LLVMValueRef src0 = emit_data->args[0];
1801
1802    lp_build_log2_approx(&bld_base->base, src0,
1803                         &p_exp, &p_floor_log2, &p_log2, FALSE);
1804
1805    emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1806
1807    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1808                                              TGSI_OPCODE_DIV,
1809                                              src0, p_exp);
1810    emit_data->output[TGSI_CHAN_Z] = p_log2;
1811
1812    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1813
1814 }
1815
1816 /* TGSI_OPCODE_MAD (CPU Only) */
1817
1818 static void
1819 mad_emit_cpu(
1820    const struct lp_build_tgsi_action * action,
1821    struct lp_build_tgsi_context * bld_base,
1822    struct lp_build_emit_data * emit_data)
1823 {
1824    emit_data->output[emit_data->chan] =
1825       lp_build_mad(&bld_base->base,
1826                    emit_data->args[0], emit_data->args[1], emit_data->args[2]);
1827 }
1828
1829 /* TGSI_OPCODE_MAX (CPU Only) */
1830
1831 static void
1832 max_emit_cpu(
1833    const struct lp_build_tgsi_action * action,
1834    struct lp_build_tgsi_context * bld_base,
1835    struct lp_build_emit_data * emit_data)
1836 {
1837    emit_data->output[emit_data->chan] =
1838       lp_build_max_ext(&bld_base->base,
1839                        emit_data->args[0], emit_data->args[1],
1840                        GALLIVM_NAN_RETURN_OTHER);
1841 }
1842
1843 /* TGSI_OPCODE_MIN (CPU Only) */
1844 static void
1845 min_emit_cpu(
1846    const struct lp_build_tgsi_action * action,
1847    struct lp_build_tgsi_context * bld_base,
1848    struct lp_build_emit_data * emit_data)
1849 {
1850    emit_data->output[emit_data->chan] =
1851       lp_build_min_ext(&bld_base->base,
1852                        emit_data->args[0], emit_data->args[1],
1853                        GALLIVM_NAN_RETURN_OTHER);
1854 }
1855
1856 /* TGSI_OPCODE_MOD (CPU Only) */
1857 static void
1858 mod_emit_cpu(
1859    const struct lp_build_tgsi_action * action,
1860    struct lp_build_tgsi_context * bld_base,
1861    struct lp_build_emit_data * emit_data)
1862 {
1863    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1864    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1865                                         PIPE_FUNC_EQUAL, emit_data->args[1],
1866                                         bld_base->uint_bld.zero);
1867    /* We want to make sure that we never divide/mod by zero to not
1868     * generate sigfpe. We don't want to crash just because the
1869     * shader is doing something weird. */
1870    LLVMValueRef divisor = LLVMBuildOr(builder,
1871                                       div_mask,
1872                                       emit_data->args[1], "");
1873    LLVMValueRef result = lp_build_mod(&bld_base->int_bld,
1874                                       emit_data->args[0], divisor);
1875    /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1876    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1877                                                     div_mask,
1878                                                     result, "");
1879 }
1880
1881 /* TGSI_OPCODE_NOT */
1882 static void
1883 not_emit_cpu(
1884    const struct lp_build_tgsi_action * action,
1885    struct lp_build_tgsi_context * bld_base,
1886    struct lp_build_emit_data * emit_data)
1887 {
1888    emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld,
1889                                                      emit_data->args[0]);
1890 }
1891
1892 /* TGSI_OPCODE_OR (CPU Only) */
1893 static void
1894 or_emit_cpu(
1895    const struct lp_build_tgsi_action * action,
1896    struct lp_build_tgsi_context * bld_base,
1897    struct lp_build_emit_data * emit_data)
1898 {
1899    emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld,
1900                                    emit_data->args[0], emit_data->args[1]);
1901 }
1902
1903 /* TGSI_OPCODE_POW (CPU Only) */
1904 static void
1905 pow_emit_cpu(
1906    const struct lp_build_tgsi_action * action,
1907    struct lp_build_tgsi_context * bld_base,
1908    struct lp_build_emit_data * emit_data)
1909 {
1910    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1911                                    emit_data->args[0], emit_data->args[1]);
1912 }
1913
1914
1915 /* TGSI_OPCODE_RCP (CPU Only) */
1916
1917 static void
1918 rcp_emit_cpu(
1919    const struct lp_build_tgsi_action * action,
1920    struct lp_build_tgsi_context * bld_base,
1921    struct lp_build_emit_data * emit_data)
1922 {
1923    emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1924                                                        emit_data->args[0]);
1925 }
1926
1927 /* Reciprical squareroot (CPU Only) */
1928 static void
1929 recip_sqrt_emit_cpu(
1930    const struct lp_build_tgsi_action * action,
1931    struct lp_build_tgsi_context * bld_base,
1932    struct lp_build_emit_data * emit_data)
1933 {
1934    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1935                                                          emit_data->args[0]);
1936 }
1937
1938 static void
1939 sqrt_emit_cpu(
1940    const struct lp_build_tgsi_action * action,
1941    struct lp_build_tgsi_context * bld_base,
1942    struct lp_build_emit_data * emit_data)
1943 {
1944    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base,
1945                                                       emit_data->args[0]);
1946 }
1947
1948
1949 /* TGSI_OPCODE_ROUND (CPU Only) */
1950 static void
1951 round_emit_cpu(
1952    const struct lp_build_tgsi_action * action,
1953    struct lp_build_tgsi_context * bld_base,
1954    struct lp_build_emit_data * emit_data)
1955 {
1956    emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1957                                                          emit_data->args[0]);
1958 }
1959
1960 /* TGSI_OPCODE_SET Helper (CPU Only) */
1961
1962 static void
1963 set_emit_cpu(
1964    const struct lp_build_tgsi_action * action,
1965    struct lp_build_tgsi_context * bld_base,
1966    struct lp_build_emit_data * emit_data,
1967    unsigned pipe_func)
1968 {
1969    LLVMValueRef cond;
1970
1971    if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1972       cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1973                                   emit_data->args[0], emit_data->args[1]);
1974    }
1975    else {
1976       cond = lp_build_cmp(&bld_base->base, pipe_func,
1977                           emit_data->args[0], emit_data->args[1]);
1978
1979    }
1980    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1981                                           cond,
1982                                           bld_base->base.one,
1983                                           bld_base->base.zero);
1984 }
1985
1986 /* TGSI_OPCODE_SEQ (CPU Only) */
1987
1988 static void
1989 seq_emit_cpu(
1990    const struct lp_build_tgsi_action * action,
1991    struct lp_build_tgsi_context * bld_base,
1992    struct lp_build_emit_data * emit_data)
1993 {
1994    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1995 }
1996
1997 /* TGSI_OPCODE_SGE (CPU Only) */
1998 static void
1999 sge_emit_cpu(
2000    const struct lp_build_tgsi_action * action,
2001    struct lp_build_tgsi_context * bld_base,
2002    struct lp_build_emit_data * emit_data)
2003 {
2004    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2005 }
2006
2007 /* TGSI_OPCODE_SGT (CPU Only)*/
2008
2009 static void
2010 sgt_emit_cpu(
2011    const struct lp_build_tgsi_action * action,
2012    struct lp_build_tgsi_context * bld_base,
2013    struct lp_build_emit_data * emit_data)
2014 {
2015    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
2016 }
2017
2018 /* TGSI_OPCODE_SHL (CPU Only) */
2019 static void
2020 shl_emit_cpu(
2021    const struct lp_build_tgsi_action * action,
2022    struct lp_build_tgsi_context * bld_base,
2023    struct lp_build_emit_data * emit_data)
2024 {
2025    struct lp_build_context *uint_bld = &bld_base->uint_bld;
2026    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2027                                           uint_bld->type.width - 1);
2028    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2029    emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0],
2030                                                      masked_count);
2031 }
2032
2033 /* TGSI_OPCODE_SIN (CPU Only) */
2034 static void
2035 sin_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_sin(&bld_base->base,
2041                                                        emit_data->args[0]);
2042 }
2043
2044 /* TGSI_OPCODE_SLE (CPU Only) */
2045 static void
2046 sle_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    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
2052 }
2053
2054 /* TGSI_OPCODE_SLT (CPU Only) */
2055 static void
2056 slt_emit_cpu(
2057    const struct lp_build_tgsi_action * action,
2058    struct lp_build_tgsi_context * bld_base,
2059    struct lp_build_emit_data * emit_data)
2060 {
2061    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2062 }
2063
2064 /* TGSI_OPCODE_SNE (CPU Only) */
2065
2066 static void
2067 sne_emit_cpu(
2068    const struct lp_build_tgsi_action * action,
2069    struct lp_build_tgsi_context * bld_base,
2070    struct lp_build_emit_data * emit_data)
2071 {
2072    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2073 }
2074
2075 /* TGSI_OPCODE_SSG (CPU Only) */
2076
2077 static void
2078 ssg_emit_cpu(
2079    const struct lp_build_tgsi_action * action,
2080    struct lp_build_tgsi_context * bld_base,
2081    struct lp_build_emit_data * emit_data)
2082 {
2083    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
2084                                                        emit_data->args[0]);
2085 }
2086
2087 /* TGSI_OPCODE_SUB (CPU Only) */
2088
2089 static void
2090 sub_emit_cpu(
2091    const struct lp_build_tgsi_action * action,
2092    struct lp_build_tgsi_context * bld_base,
2093    struct lp_build_emit_data * emit_data)
2094 {
2095    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
2096                                                         emit_data->args[0],
2097                                                         emit_data->args[1]);
2098 }
2099
2100 /* TGSI_OPCODE_TRUNC (CPU Only) */
2101
2102 static void
2103 trunc_emit_cpu(
2104    const struct lp_build_tgsi_action * action,
2105    struct lp_build_tgsi_context * bld_base,
2106    struct lp_build_emit_data * emit_data)
2107 {
2108    emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
2109                                                          emit_data->args[0]);
2110 }
2111
2112 /* TGSI_OPCODE_UADD (CPU Only) */
2113 static void
2114 uadd_emit_cpu(
2115    const struct lp_build_tgsi_action * action,
2116    struct lp_build_tgsi_context * bld_base,
2117    struct lp_build_emit_data * emit_data)
2118 {
2119    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
2120                                    emit_data->args[0], emit_data->args[1]);
2121 }
2122
2123 /* TGSI_OPCODE_UDIV (CPU Only) */
2124 static void
2125 udiv_emit_cpu(
2126    const struct lp_build_tgsi_action * action,
2127    struct lp_build_tgsi_context * bld_base,
2128    struct lp_build_emit_data * emit_data)
2129 {
2130
2131    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2132    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
2133                                         PIPE_FUNC_EQUAL, emit_data->args[1],
2134                                         bld_base->uint_bld.zero);
2135    /* We want to make sure that we never divide/mod by zero to not
2136     * generate sigfpe. We don't want to crash just because the
2137     * shader is doing something weird. */
2138    LLVMValueRef divisor = LLVMBuildOr(builder,
2139                                       div_mask,
2140                                       emit_data->args[1], "");
2141    LLVMValueRef result = lp_build_div(&bld_base->uint_bld,
2142                                       emit_data->args[0], divisor);
2143    /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
2144    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
2145                                                     div_mask,
2146                                                     result, "");
2147 }
2148
2149 /* TGSI_OPCODE_UMAX (CPU Only) */
2150 static void
2151 umax_emit_cpu(
2152    const struct lp_build_tgsi_action * action,
2153    struct lp_build_tgsi_context * bld_base,
2154    struct lp_build_emit_data * emit_data)
2155 {
2156    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
2157                                    emit_data->args[0], emit_data->args[1]);
2158 }
2159
2160 /* TGSI_OPCODE_UMIN (CPU Only) */
2161 static void
2162 umin_emit_cpu(
2163    const struct lp_build_tgsi_action * action,
2164    struct lp_build_tgsi_context * bld_base,
2165    struct lp_build_emit_data * emit_data)
2166 {
2167    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld,
2168                                    emit_data->args[0], emit_data->args[1]);
2169 }
2170
2171 /* TGSI_OPCODE_UMOD (CPU Only) */
2172 static void
2173 umod_emit_cpu(
2174    const struct lp_build_tgsi_action * action,
2175    struct lp_build_tgsi_context * bld_base,
2176    struct lp_build_emit_data * emit_data)
2177 {
2178    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2179    LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
2180                                         PIPE_FUNC_EQUAL, emit_data->args[1],
2181                                         bld_base->uint_bld.zero);
2182    /* We want to make sure that we never divide/mod by zero to not
2183     * generate sigfpe. We don't want to crash just because the
2184     * shader is doing something weird. */
2185    LLVMValueRef divisor = LLVMBuildOr(builder,
2186                                       div_mask,
2187                                       emit_data->args[1], "");
2188    LLVMValueRef result = lp_build_mod(&bld_base->uint_bld,
2189                                       emit_data->args[0], divisor);
2190    /* umod by zero is guaranteed to return 0xffffffff */
2191    emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
2192                                                     div_mask,
2193                                                     result, "");
2194 }
2195
2196 /* TGSI_OPCODE_USET Helper (CPU Only) */
2197 static void
2198 uset_emit_cpu(
2199    const struct lp_build_tgsi_action * action,
2200    struct lp_build_tgsi_context * bld_base,
2201    struct lp_build_emit_data * emit_data,
2202    unsigned pipe_func)
2203 {
2204    LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
2205                                     emit_data->args[0], emit_data->args[1]);
2206    emit_data->output[emit_data->chan] = cond;
2207 }
2208
2209
2210 /* TGSI_OPCODE_USEQ (CPU Only) */
2211 static void
2212 useq_emit_cpu(
2213    const struct lp_build_tgsi_action * action,
2214    struct lp_build_tgsi_context * bld_base,
2215    struct lp_build_emit_data * emit_data)
2216 {
2217    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2218 }
2219
2220 /* TGSI_OPCODE_ISGE (CPU Only) */
2221 static void
2222 usge_emit_cpu(
2223    const struct lp_build_tgsi_action * action,
2224    struct lp_build_tgsi_context * bld_base,
2225    struct lp_build_emit_data * emit_data)
2226 {
2227    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2228 }
2229
2230 /* TGSI_OPCODE_USHR (CPU Only) */
2231 static void
2232 ushr_emit_cpu(
2233    const struct lp_build_tgsi_action * action,
2234    struct lp_build_tgsi_context * bld_base,
2235    struct lp_build_emit_data * emit_data)
2236 {
2237    struct lp_build_context *uint_bld = &bld_base->uint_bld;
2238    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2239                                           uint_bld->type.width - 1);
2240    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2241    emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0],
2242                                                      masked_count);
2243 }
2244
2245 /* TGSI_OPCODE_ISLT (CPU Only) */
2246 static void
2247 uslt_emit_cpu(
2248    const struct lp_build_tgsi_action * action,
2249    struct lp_build_tgsi_context * bld_base,
2250    struct lp_build_emit_data * emit_data)
2251 {
2252    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2253 }
2254
2255 /* TGSI_OPCODE_USNE (CPU Only) */
2256
2257 static void
2258 usne_emit_cpu(
2259    const struct lp_build_tgsi_action * action,
2260    struct lp_build_tgsi_context * bld_base,
2261    struct lp_build_emit_data * emit_data)
2262 {
2263    uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2264 }
2265
2266 /* TGSI_OPCODE_XOR */
2267 static void
2268 xor_emit_cpu(
2269    const struct lp_build_tgsi_action * action,
2270    struct lp_build_tgsi_context * bld_base,
2271    struct lp_build_emit_data * emit_data)
2272 {
2273    emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
2274                                                      emit_data->args[0],
2275                                                      emit_data->args[1]);
2276 }
2277
2278 /* TGSI_OPCODE_DABS (CPU Only) */
2279 static void
2280 dabs_emit_cpu(
2281    const struct lp_build_tgsi_action * action,
2282    struct lp_build_tgsi_context * bld_base,
2283    struct lp_build_emit_data * emit_data)
2284 {
2285    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->dbl_bld,
2286                                                        emit_data->args[0]);
2287 }
2288
2289 /* TGSI_OPCODE_DNEG (CPU Only) */
2290 static void
2291 dneg_emit_cpu(
2292    const struct lp_build_tgsi_action * action,
2293    struct lp_build_tgsi_context * bld_base,
2294    struct lp_build_emit_data * emit_data)
2295 {
2296    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->dbl_bld,
2297                                                      bld_base->dbl_bld.zero,
2298                                                      emit_data->args[0]);
2299 }
2300
2301 /* TGSI_OPCODE_DSET Helper (CPU Only) */
2302 static void
2303 dset_emit_cpu(
2304    const struct lp_build_tgsi_action * action,
2305    struct lp_build_tgsi_context * bld_base,
2306    struct lp_build_emit_data * emit_data,
2307    unsigned pipe_func)
2308 {
2309    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2310    LLVMValueRef cond = lp_build_cmp(&bld_base->dbl_bld, pipe_func,
2311                                     emit_data->args[0], emit_data->args[1]);
2312    /* arguments were 64 bit but store as 32 bit */
2313    cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
2314    emit_data->output[emit_data->chan] = cond;
2315 }
2316
2317 /* TGSI_OPCODE_DSEQ (CPU Only) */
2318 static void
2319 dseq_emit_cpu(
2320    const struct lp_build_tgsi_action * action,
2321    struct lp_build_tgsi_context * bld_base,
2322    struct lp_build_emit_data * emit_data)
2323 {
2324    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2325 }
2326
2327 /* TGSI_OPCODE_DSGE (CPU Only) */
2328 static void
2329 dsge_emit_cpu(
2330    const struct lp_build_tgsi_action * action,
2331    struct lp_build_tgsi_context * bld_base,
2332    struct lp_build_emit_data * emit_data)
2333 {
2334    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2335 }
2336
2337 /* TGSI_OPCODE_DSLT (CPU Only) */
2338 static void
2339 dslt_emit_cpu(
2340    const struct lp_build_tgsi_action * action,
2341    struct lp_build_tgsi_context * bld_base,
2342    struct lp_build_emit_data * emit_data)
2343 {
2344    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2345 }
2346
2347 /* TGSI_OPCODE_DSNE (CPU Only) */
2348 static void
2349 dsne_emit_cpu(
2350    const struct lp_build_tgsi_action * action,
2351    struct lp_build_tgsi_context * bld_base,
2352    struct lp_build_emit_data * emit_data)
2353 {
2354    dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2355 }
2356
2357 /* Double Reciprocal squareroot (CPU Only) */
2358 static void
2359 drecip_sqrt_emit_cpu(
2360    const struct lp_build_tgsi_action * action,
2361    struct lp_build_tgsi_context * bld_base,
2362    struct lp_build_emit_data * emit_data)
2363 {
2364    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->dbl_bld,
2365                                                          emit_data->args[0]);
2366 }
2367
2368 /* Double Squareroot (CPU Only) */
2369 static void
2370 dsqrt_emit_cpu(
2371    const struct lp_build_tgsi_action * action,
2372    struct lp_build_tgsi_context * bld_base,
2373    struct lp_build_emit_data * emit_data)
2374 {
2375    emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->dbl_bld,
2376                                                       emit_data->args[0]);
2377 }
2378
2379 static void
2380 i64abs_emit_cpu(
2381    const struct lp_build_tgsi_action * action,
2382    struct lp_build_tgsi_context * bld_base,
2383    struct lp_build_emit_data * emit_data)
2384 {
2385    emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int64_bld,
2386                                                        emit_data->args[0]);
2387 }
2388
2389 static void
2390 i64ssg_emit_cpu(
2391    const struct lp_build_tgsi_action * action,
2392    struct lp_build_tgsi_context * bld_base,
2393    struct lp_build_emit_data * emit_data)
2394 {
2395    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int64_bld,
2396                                                        emit_data->args[0]);
2397 }
2398
2399 static void
2400 i64neg_emit_cpu(
2401    const struct lp_build_tgsi_action * action,
2402    struct lp_build_tgsi_context * bld_base,
2403    struct lp_build_emit_data * emit_data)
2404 {
2405    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int64_bld,
2406                                                      bld_base->int64_bld.zero,
2407                                                      emit_data->args[0]);
2408 }
2409
2410 static void
2411 u64set_emit_cpu(
2412    const struct lp_build_tgsi_action * action,
2413    struct lp_build_tgsi_context * bld_base,
2414    struct lp_build_emit_data * emit_data,
2415    unsigned pipe_func)
2416 {
2417    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2418    LLVMValueRef cond = lp_build_cmp(&bld_base->uint64_bld, pipe_func,
2419                                     emit_data->args[0], emit_data->args[1]);
2420    /* arguments were 64 bit but store as 32 bit */
2421    cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
2422    emit_data->output[emit_data->chan] = cond;
2423 }
2424
2425 static void
2426 u64seq_emit_cpu(
2427    const struct lp_build_tgsi_action * action,
2428    struct lp_build_tgsi_context * bld_base,
2429    struct lp_build_emit_data * emit_data)
2430 {
2431    u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2432 }
2433
2434 static void
2435 u64sne_emit_cpu(
2436    const struct lp_build_tgsi_action * action,
2437    struct lp_build_tgsi_context * bld_base,
2438    struct lp_build_emit_data * emit_data)
2439 {
2440    u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2441 }
2442
2443 static void
2444 u64slt_emit_cpu(
2445    const struct lp_build_tgsi_action * action,
2446    struct lp_build_tgsi_context * bld_base,
2447    struct lp_build_emit_data * emit_data)
2448 {
2449    u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2450 }
2451
2452 static void
2453 u64sge_emit_cpu(
2454    const struct lp_build_tgsi_action * action,
2455    struct lp_build_tgsi_context * bld_base,
2456    struct lp_build_emit_data * emit_data)
2457 {
2458    u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2459 }
2460
2461 static void
2462 i64set_emit_cpu(
2463    const struct lp_build_tgsi_action * action,
2464    struct lp_build_tgsi_context * bld_base,
2465    struct lp_build_emit_data * emit_data,
2466    unsigned pipe_func)
2467 {
2468    LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2469    LLVMValueRef cond = lp_build_cmp(&bld_base->int64_bld, pipe_func,
2470                                     emit_data->args[0], emit_data->args[1]);
2471    /* arguments were 64 bit but store as 32 bit */
2472    cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
2473    emit_data->output[emit_data->chan] = cond;
2474 }
2475
2476 static void
2477 i64slt_emit_cpu(
2478    const struct lp_build_tgsi_action * action,
2479    struct lp_build_tgsi_context * bld_base,
2480    struct lp_build_emit_data * emit_data)
2481 {
2482    i64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2483 }
2484
2485 static void
2486 i64sge_emit_cpu(
2487    const struct lp_build_tgsi_action * action,
2488    struct lp_build_tgsi_context * bld_base,
2489    struct lp_build_emit_data * emit_data)
2490 {
2491    i64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2492 }
2493
2494 static void
2495 u64max_emit_cpu(
2496    const struct lp_build_tgsi_action * action,
2497    struct lp_build_tgsi_context * bld_base,
2498    struct lp_build_emit_data * emit_data)
2499 {
2500    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint64_bld,
2501                                    emit_data->args[0], emit_data->args[1]);
2502 }
2503
2504 static void
2505 u64min_emit_cpu(
2506    const struct lp_build_tgsi_action * action,
2507    struct lp_build_tgsi_context * bld_base,
2508    struct lp_build_emit_data * emit_data)
2509 {
2510    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint64_bld,
2511                                    emit_data->args[0], emit_data->args[1]);
2512 }
2513
2514 static void
2515 i64max_emit_cpu(
2516    const struct lp_build_tgsi_action * action,
2517    struct lp_build_tgsi_context * bld_base,
2518    struct lp_build_emit_data * emit_data)
2519 {
2520    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int64_bld,
2521                                    emit_data->args[0], emit_data->args[1]);
2522 }
2523
2524 static void
2525 i64min_emit_cpu(
2526    const struct lp_build_tgsi_action * action,
2527    struct lp_build_tgsi_context * bld_base,
2528    struct lp_build_emit_data * emit_data)
2529 {
2530    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int64_bld,
2531                                    emit_data->args[0], emit_data->args[1]);
2532 }
2533
2534 static void
2535 u64add_emit_cpu(
2536    const struct lp_build_tgsi_action * action,
2537    struct lp_build_tgsi_context * bld_base,
2538    struct lp_build_emit_data * emit_data)
2539 {
2540    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint64_bld,
2541                                    emit_data->args[0], emit_data->args[1]);
2542 }
2543
2544 static void
2545 u64shl_emit_cpu(
2546    const struct lp_build_tgsi_action * action,
2547    struct lp_build_tgsi_context * bld_base,
2548    struct lp_build_emit_data * emit_data)
2549 {
2550    struct lp_build_context *uint_bld = &bld_base->uint64_bld;
2551    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2552                                           uint_bld->type.width - 1);
2553    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2554    emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0],
2555                                                      masked_count);
2556 }
2557
2558 static void
2559 i64shr_emit_cpu(
2560    const struct lp_build_tgsi_action * action,
2561    struct lp_build_tgsi_context * bld_base,
2562    struct lp_build_emit_data * emit_data)
2563 {
2564    struct lp_build_context *int_bld = &bld_base->int64_bld;
2565    LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type,
2566                                           int_bld->type.width - 1);
2567    LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask);
2568    emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0],
2569                                                      masked_count);
2570 }
2571
2572 static void
2573 u64shr_emit_cpu(
2574    const struct lp_build_tgsi_action * action,
2575    struct lp_build_tgsi_context * bld_base,
2576    struct lp_build_emit_data * emit_data)
2577 {
2578    struct lp_build_context *uint_bld = &bld_base->uint64_bld;
2579    LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2580                                           uint_bld->type.width - 1);
2581    LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2582    emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0],
2583                                                      masked_count);
2584 }
2585
2586 void
2587 lp_set_default_actions_cpu(
2588    struct lp_build_tgsi_context * bld_base)
2589 {
2590    lp_set_default_actions(bld_base);
2591    bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
2592    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
2593    bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
2594    bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
2595    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
2596    bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
2597    bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
2598    bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
2599    bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
2600    bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
2601    bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
2602    bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
2603    bld_base->op_actions[TGSI_OPCODE_FSEQ].emit = fseq_emit_cpu;
2604    bld_base->op_actions[TGSI_OPCODE_FSGE].emit = fsge_emit_cpu;
2605    bld_base->op_actions[TGSI_OPCODE_FSLT].emit = fslt_emit_cpu;
2606    bld_base->op_actions[TGSI_OPCODE_FSNE].emit = fsne_emit_cpu;
2607
2608    bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
2609    bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
2610    bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
2611    bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
2612    bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
2613    bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
2614    bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
2615    bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
2616    bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
2617    bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
2618    bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit_cpu;
2619    bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit_cpu;
2620
2621    bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
2622    bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
2623    bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit_cpu;
2624    bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
2625    bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
2626    bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
2627    bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
2628    bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
2629    bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
2630    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
2631    bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
2632    bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
2633    bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
2634    bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
2635    bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
2636    bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
2637    bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
2638    bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
2639    bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
2640    bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
2641    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
2642    bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
2643
2644    bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
2645    bld_base->sqrt_action.emit = sqrt_emit_cpu;
2646
2647    bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
2648    bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu;
2649    bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
2650    bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
2651    bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
2652    bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
2653    bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
2654    bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
2655    bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
2656    bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
2657    bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
2658
2659    bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
2660
2661    bld_base->op_actions[TGSI_OPCODE_DABS].emit = dabs_emit_cpu;
2662    bld_base->op_actions[TGSI_OPCODE_DNEG].emit = dneg_emit_cpu;
2663    bld_base->op_actions[TGSI_OPCODE_DSEQ].emit = dseq_emit_cpu;
2664    bld_base->op_actions[TGSI_OPCODE_DSGE].emit = dsge_emit_cpu;
2665    bld_base->op_actions[TGSI_OPCODE_DSLT].emit = dslt_emit_cpu;
2666    bld_base->op_actions[TGSI_OPCODE_DSNE].emit = dsne_emit_cpu;
2667
2668    bld_base->op_actions[TGSI_OPCODE_DRSQ].emit = drecip_sqrt_emit_cpu;
2669    bld_base->op_actions[TGSI_OPCODE_DSQRT].emit = dsqrt_emit_cpu;
2670
2671    bld_base->op_actions[TGSI_OPCODE_I64ABS].emit = i64abs_emit_cpu;
2672    bld_base->op_actions[TGSI_OPCODE_I64SSG].emit = i64ssg_emit_cpu;
2673    bld_base->op_actions[TGSI_OPCODE_I64NEG].emit = i64neg_emit_cpu;
2674
2675    bld_base->op_actions[TGSI_OPCODE_U64SEQ].emit = u64seq_emit_cpu;
2676    bld_base->op_actions[TGSI_OPCODE_U64SNE].emit = u64sne_emit_cpu;
2677    bld_base->op_actions[TGSI_OPCODE_U64SLT].emit = u64slt_emit_cpu;
2678    bld_base->op_actions[TGSI_OPCODE_U64SGE].emit = u64sge_emit_cpu;
2679    bld_base->op_actions[TGSI_OPCODE_I64SLT].emit = i64slt_emit_cpu;
2680    bld_base->op_actions[TGSI_OPCODE_I64SGE].emit = i64sge_emit_cpu;
2681
2682    bld_base->op_actions[TGSI_OPCODE_U64MIN].emit = u64min_emit_cpu;
2683    bld_base->op_actions[TGSI_OPCODE_U64MAX].emit = u64max_emit_cpu;
2684    bld_base->op_actions[TGSI_OPCODE_I64MIN].emit = i64min_emit_cpu;
2685    bld_base->op_actions[TGSI_OPCODE_I64MAX].emit = i64max_emit_cpu;
2686
2687    bld_base->op_actions[TGSI_OPCODE_U64ADD].emit = u64add_emit_cpu;
2688    bld_base->op_actions[TGSI_OPCODE_U64MOD].emit = u64mod_emit_cpu;
2689    bld_base->op_actions[TGSI_OPCODE_I64MOD].emit = i64mod_emit_cpu;
2690    bld_base->op_actions[TGSI_OPCODE_U64DIV].emit = u64div_emit_cpu;
2691    bld_base->op_actions[TGSI_OPCODE_I64DIV].emit = i64div_emit_cpu;
2692
2693    bld_base->op_actions[TGSI_OPCODE_U64SHL].emit = u64shl_emit_cpu;
2694    bld_base->op_actions[TGSI_OPCODE_I64SHR].emit = i64shr_emit_cpu;
2695    bld_base->op_actions[TGSI_OPCODE_U64SHR].emit = u64shr_emit_cpu;
2696 }