src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2011-2012 Advanced Micro Devices, Inc.
   4  * Copyright 2009 VMware, Inc.
   5  * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  23  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  24  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  25  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  26  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30 /**
  31  * @file
  32  * TGSI to LLVM IR translation.
  33  *
  34  * @author Jose Fonseca <jfonseca@vmware.com>
  35  * @author Tom Stellard <thomas.stellard@amd.com>
  36  *
  37  * Based on tgsi_sse2.c code written by Michal Krol, Keith Whitwell,
  38  * Brian Paul, and others.
  39  */
  40
  41
  42 #include "lp_bld_tgsi_action.h"
  43
  44 #include "lp_bld_tgsi.h"
  45 #include "lp_bld_arit.h"
  46 #include "lp_bld_const.h"
  47 #include "lp_bld_gather.h"
  48 #include "lp_bld_logic.h"
  49
  50 #include "tgsi/tgsi_exec.h"
  51
  52 /* XXX: The CPU only defaults should be repaced by generic ones.  In most
  53  * cases, the CPU defaults are just wrappers around a function in
  54  * lp_build_arit.c and these functions should be inlined here and the CPU
  55  * generic code should be removed and placed elsewhere.
  56  */
  57
  58 /* Default actions */
  59
  60 /* Generic fetch_arg functions */
  61
  62 static void scalar_unary_fetch_args(
  63    struct lp_build_tgsi_context * bld_base,
  64    struct lp_build_emit_data * emit_data)
  65 {
  66    /* src0.x */
  67    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, 0);
  68    emit_data->arg_count = 1;
  69    emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  70 }
  71
  72 static void scalar_binary_fetch_args(
  73    struct lp_build_tgsi_context * bld_base,
  74    struct lp_build_emit_data * emit_data)
  75 {
  76    /* src0.x */
  77    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
  78                                             0, TGSI_CHAN_X);
  79    /* src1.x */
  80    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
  81                                             1, TGSI_CHAN_X);
  82    emit_data->arg_count = 2;
  83    emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  84 }
  85
  86 /* TGSI_OPCODE_ADD */
  87 static void
  88 add_emit(
  89    const struct lp_build_tgsi_action * action,
  90    struct lp_build_tgsi_context * bld_base,
  91    struct lp_build_emit_data * emit_data)
  92 {
  93    emit_data->output[emit_data->chan] = LLVMBuildFAdd(
  94                                 bld_base->base.gallivm->builder,
  95                                 emit_data->args[0], emit_data->args[1], "");
  96 }
  97
  98 /* TGSI_OPCODE_ARR */
  99 static void
 100 arr_emit(
 101    const struct lp_build_tgsi_action * action,
 102    struct lp_build_tgsi_context * bld_base,
 103    struct lp_build_emit_data * emit_data)
 104 {
 105    emit_data->output[emit_data->chan] = lp_build_emit_llvm_unary(bld_base,
 106                                          TGSI_OPCODE_ROUND, emit_data->args[0]);
 107 }
 108
 109 /* TGSI_OPCODE_CLAMP */
 110 static void
 111 clamp_emit(
 112    const struct lp_build_tgsi_action * action,
 113    struct lp_build_tgsi_context * bld_base,
 114    struct lp_build_emit_data * emit_data)
 115 {
 116    LLVMValueRef tmp;
 117    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
 118                                    emit_data->args[0],
 119                                    emit_data->args[1]);
 120    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 121                                        TGSI_OPCODE_MIN, tmp, emit_data->args[2]);
 122 }
 123
 124 /* DP* Helper */
 125
 126 static void
 127 dp_fetch_args(
 128    struct lp_build_tgsi_context * bld_base,
 129    struct lp_build_emit_data * emit_data,
 130    unsigned dp_components)
 131 {
 132    unsigned chan, src;
 133    for (src = 0; src < 2; src++) {
 134       for (chan = 0; chan < dp_components; chan++) {
 135          emit_data->args[(src * dp_components) + chan] =
 136                      lp_build_emit_fetch(bld_base, emit_data->inst, src, chan);
 137       }
 138    }
 139    emit_data->dst_type = bld_base->base.elem_type;
 140 }
 141
 142 /* TGSI_OPCODE_DP2 */
 143 static void
 144 dp2_fetch_args(
 145    struct lp_build_tgsi_context * bld_base,
 146    struct lp_build_emit_data * emit_data)
 147 {
 148    dp_fetch_args(bld_base, emit_data, 2);
 149 }
 150
 151 static void
 152 dp2_emit(
 153    const struct lp_build_tgsi_action * action,
 154    struct lp_build_tgsi_context * bld_base,
 155    struct lp_build_emit_data * emit_data)
 156 {
 157    LLVMValueRef tmp0, tmp1;
 158    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 159                                     emit_data->args[0] /* src0.x */,
 160                                     emit_data->args[2] /* src1.x */);
 161    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 162                                     emit_data->args[1] /* src0.y */,
 163                                     emit_data->args[3] /* src1.y */);
 164    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 165                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 166 }
 167
 168 static struct lp_build_tgsi_action dp2_action = {
 169    dp2_fetch_args,       /* fetch_args */
 170    dp2_emit      /* emit */
 171 };
 172
 173 /* TGSI_OPCODE_DP2A */
 174 static void
 175 dp2a_fetch_args(
 176    struct lp_build_tgsi_context * bld_base,
 177    struct lp_build_emit_data * emit_data)
 178 {
 179    dp_fetch_args(bld_base, emit_data, 2);
 180    emit_data->args[5] = lp_build_emit_fetch(bld_base, emit_data->inst,
 181                                             2, TGSI_CHAN_X);
 182 }
 183
 184 static void
 185 dp2a_emit(
 186    const struct lp_build_tgsi_action * action,
 187    struct lp_build_tgsi_context * bld_base,
 188    struct lp_build_emit_data * emit_data)
 189 {
 190    LLVMValueRef tmp;
 191    tmp = lp_build_emit_llvm(bld_base, TGSI_OPCODE_DP2, emit_data);
 192    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD,
 193                                     emit_data->args[5], tmp);
 194 }
 195
 196 static struct lp_build_tgsi_action dp2a_action = {
 197    dp2a_fetch_args,      /* fetch_args */
 198    dp2a_emit     /* emit */
 199 };
 200
 201 /* TGSI_OPCODE_DP3 */
 202 static void
 203 dp3_fetch_args(
 204    struct lp_build_tgsi_context * bld_base,
 205    struct lp_build_emit_data * emit_data)
 206 {
 207    dp_fetch_args(bld_base, emit_data, 3);
 208 }
 209
 210 static void
 211 dp3_emit(
 212    const struct lp_build_tgsi_action * action,
 213    struct lp_build_tgsi_context * bld_base,
 214    struct lp_build_emit_data * emit_data)
 215 {
 216    LLVMValueRef tmp0, tmp1;
 217    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 218                                     emit_data->args[0] /* src0.x */,
 219                                     emit_data->args[3] /* src1.x */);
 220    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 221                                     emit_data->args[1] /* src0.y */,
 222                                     emit_data->args[4] /* src1.y */);
 223    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp1, tmp0);
 224    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 225                                     emit_data->args[2] /* src0.z */,
 226                                     emit_data->args[5] /* src1.z */);
 227    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 228                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 229 }
 230
 231 static struct lp_build_tgsi_action dp3_action = {
 232    dp3_fetch_args,       /* fetch_args */
 233    dp3_emit      /* emit */
 234 };
 235
 236 /* TGSI_OPCODDE_DP4 */
 237
 238 static void
 239 dp4_fetch_args(
 240    struct lp_build_tgsi_context * bld_base,
 241    struct lp_build_emit_data * emit_data)
 242 {
 243    dp_fetch_args(bld_base, emit_data, 4);
 244 }
 245
 246 static void
 247 dp4_emit(
 248    const struct lp_build_tgsi_action * action,
 249    struct lp_build_tgsi_context * bld_base,
 250    struct lp_build_emit_data * emit_data)
 251 {
 252    LLVMValueRef tmp0, tmp1;
 253    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 254                                     emit_data->args[0] /* src0.x */,
 255                                     emit_data->args[4] /* src1.x */);
 256    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 257                                     emit_data->args[1] /* src0.y */,
 258                                     emit_data->args[5] /* src1.y */);
 259    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
 260    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 261                                     emit_data->args[2] /* src0.z */,
 262                                     emit_data->args[6] /* src1.z */);
 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[3] /* src0.w */,
 266                                     emit_data->args[7] /* src1.w */);
 267    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 268                                                     TGSI_OPCODE_ADD, tmp0, tmp1);
 269 }
 270
 271 static struct lp_build_tgsi_action dp4_action = {
 272    dp4_fetch_args,       /* fetch_args */
 273    dp4_emit      /* emit */
 274 };
 275
 276 /* TGSI_OPCODE_DPH */
 277 static void
 278 dph_fetch_args(
 279    struct lp_build_tgsi_context * bld_base,
 280    struct lp_build_emit_data * emit_data)
 281 {
 282    dp_fetch_args(bld_base, emit_data, 4);
 283    /* src0.w */
 284    emit_data->args[3] = bld_base->base.one;
 285 }
 286
 287 const struct lp_build_tgsi_action dph_action = {
 288    dph_fetch_args,       /* fetch_args */
 289    dp4_emit      /* emit */
 290 };
 291
 292 /* TGSI_OPCODE_DST */
 293 static void
 294 dst_fetch_args(
 295    struct lp_build_tgsi_context * bld_base,
 296    struct lp_build_emit_data * emit_data)
 297 {
 298    /* src0.y */
 299    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 300                                             0, TGSI_CHAN_Y);
 301    /* src0.z */
 302    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 303                                             0, TGSI_CHAN_Z);
 304    /* src1.y */
 305    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
 306                                             1, TGSI_CHAN_Y);
 307    /* src1.w */
 308    emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
 309                                             1, TGSI_CHAN_W);
 310 }
 311
 312 static void
 313 dst_emit(
 314    const struct lp_build_tgsi_action * action,
 315    struct lp_build_tgsi_context * bld_base,
 316    struct lp_build_emit_data * emit_data)
 317 {
 318    /* dst.x */
 319    emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
 320
 321    /* dst.y */
 322    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 323                                           TGSI_OPCODE_MUL,
 324                                           emit_data->args[0] /* src0.y */,
 325                                           emit_data->args[2] /* src1.y */);
 326    /* dst.z */
 327    emit_data->output[TGSI_CHAN_Z] = emit_data->args[1]; /* src0.z */
 328
 329    /* dst.w */
 330    emit_data->output[TGSI_CHAN_W] = emit_data->args[3]; /* src1.w */
 331 }
 332
 333 static struct lp_build_tgsi_action dst_action = {
 334    dst_fetch_args,       /* fetch_args */
 335    dst_emit      /* emit */
 336 };
 337
 338 /* TGSI_OPCODE_END */
 339 static void
 340 end_emit(
 341    const struct lp_build_tgsi_action * action,
 342    struct lp_build_tgsi_context * bld_base,
 343    struct lp_build_emit_data * emit_data)
 344 {
 345    bld_base->pc = -1;
 346 }
 347
 348 /* TGSI_OPCODE_EXP */
 349
 350 static void
 351 exp_emit(
 352    const struct lp_build_tgsi_action * action,
 353    struct lp_build_tgsi_context * bld_base,
 354    struct lp_build_emit_data * emit_data)
 355 {
 356    LLVMValueRef floor_x;
 357
 358    /* floor( src0.x ) */
 359    floor_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 360                                       emit_data->args[0]);
 361
 362    /* 2 ^ floor( src0.x ) */
 363    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 364                                        TGSI_OPCODE_EX2, floor_x);
 365
 366    /* src0.x - floor( src0.x ) */
 367    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 368                    TGSI_OPCODE_SUB,  emit_data->args[0] /* src0.x */, floor_x);
 369
 370    /* 2 ^ src0.x */
 371    emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_unary(bld_base,
 372                              TGSI_OPCODE_EX2, emit_data->args[0] /* src0.x */);
 373
 374    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 375 }
 376
 377 const struct lp_build_tgsi_action exp_action = {
 378    scalar_unary_fetch_args,      /* fetch_args */
 379    exp_emit      /* emit */
 380 };
 381
 382 /* TGSI_OPCODE_FRC */
 383
 384 static void
 385 frc_emit(
 386    const struct lp_build_tgsi_action * action,
 387    struct lp_build_tgsi_context * bld_base,
 388    struct lp_build_emit_data * emit_data)
 389 {
 390    LLVMValueRef tmp;
 391    tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 392                                   emit_data->args[0]);
 393    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 394                                        TGSI_OPCODE_SUB, emit_data->args[0], tmp);
 395 }
 396
 397 /* TGSI_OPCODE_KIL */
 398
 399 static void
 400 kil_fetch_args(
 401    struct lp_build_tgsi_context * bld_base,
 402    struct lp_build_emit_data * emit_data)
 403 {
 404    /* src0.x */
 405    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
 406                                             0, TGSI_CHAN_X);
 407    /* src0.y */
 408    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
 409                                             0, TGSI_CHAN_Y);
 410    /* src0.z */
 411    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
 412                                             0, TGSI_CHAN_Z);
 413    /* src0.w */
 414    emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
 415                                             0, TGSI_CHAN_W);
 416    emit_data->arg_count = 4;
 417    emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
 418 }
 419
 420 /* TGSI_OPCODE_KILP */
 421
 422 static void
 423 kilp_fetch_args(
 424    struct lp_build_tgsi_context * bld_base,
 425    struct lp_build_emit_data * emit_data)
 426 {
 427    emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
 428 }
 429
 430 /* TGSI_OPCODE_LIT */
 431
 432 static void
 433 lit_fetch_args(
 434    struct lp_build_tgsi_context * bld_base,
 435    struct lp_build_emit_data * emit_data)
 436 {
 437    /* src0.x */
 438    emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_X);
 439    /* src0.y */
 440    emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_Y);
 441    /* src0.w */
 442    emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W);
 443    emit_data->arg_count = 3;
 444 }
 445
 446 static void
 447 lit_emit(
 448    const struct lp_build_tgsi_action * action,
 449    struct lp_build_tgsi_context * bld_base,
 450    struct lp_build_emit_data * emit_data)
 451 {
 452    LLVMValueRef tmp0, tmp1, tmp2;
 453
 454    /* dst.x */
 455    emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
 456
 457    /* dst. y */
 458    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 459                                                TGSI_OPCODE_MAX,
 460                                                emit_data->args[0] /* src0.x */,
 461                                                bld_base->base.zero);
 462
 463    /* dst.z */
 464    /* XMM[1] = SrcReg[0].yyyy */
 465    tmp1 = emit_data->args[1];
 466    /* XMM[1] = max(XMM[1], 0) */
 467    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
 468                                     tmp1, bld_base->base.zero);
 469    /* XMM[2] = SrcReg[0].wwww */
 470    tmp2 = emit_data->args[2];
 471    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_POW,
 472                                     tmp1, tmp2);
 473    tmp0 = emit_data->args[0];
 474    emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_ternary(bld_base,
 475                                              TGSI_OPCODE_CMP,
 476                                              tmp0, bld_base->base.zero, tmp1);
 477    /* dst.w */
 478    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 479 }
 480
 481 static struct lp_build_tgsi_action lit_action = {
 482    lit_fetch_args,       /* fetch_args */
 483    lit_emit      /* emit */
 484 };
 485
 486 /* TGSI_OPCODE_LOG */
 487
 488 static void
 489 log_emit(
 490    const struct lp_build_tgsi_action * action,
 491    struct lp_build_tgsi_context * bld_base,
 492    struct lp_build_emit_data * emit_data)
 493 {
 494
 495    LLVMValueRef abs_x, log_abs_x, flr_log_abs_x, ex2_flr_log_abs_x;
 496
 497    /* abs( src0.x) */
 498    abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
 499                                     emit_data->args[0] /* src0.x */);
 500
 501    /* log( abs( src0.x ) ) */
 502    log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_LG2,
 503                                         abs_x);
 504
 505    /* floor( log( abs( src0.x ) ) ) */
 506    flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
 507                                             log_abs_x);
 508    /* dst.x */
 509    emit_data->output[TGSI_CHAN_X] = flr_log_abs_x;
 510
 511    /* dst.y */
 512    ex2_flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_EX2,
 513                                                 flr_log_abs_x);
 514
 515    /* abs( src0.x ) / 2^( floor( lg2( abs( src0.x ) ) ) ) */
 516    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 517                                     TGSI_OPCODE_DIV, abs_x, ex2_flr_log_abs_x);
 518
 519    /* dst.x */
 520    emit_data->output[TGSI_CHAN_Z] = log_abs_x;
 521
 522    /* dst.w */
 523    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 524 }
 525
 526 static struct lp_build_tgsi_action log_action = {
 527    scalar_unary_fetch_args,      /* fetch_args */
 528    log_emit      /* emit */
 529 };
 530
 531 /* TGSI_OPCODE_LRP */
 532
 533 static void
 534 lrp_emit(
 535    const struct lp_build_tgsi_action * action,
 536    struct lp_build_tgsi_context * bld_base,
 537    struct lp_build_emit_data * emit_data)
 538 {
 539    LLVMValueRef tmp;
 540    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB,
 541                                    emit_data->args[1],
 542                                    emit_data->args[2]);
 543    emit_data->output[emit_data->chan] = lp_build_emit_llvm_ternary(bld_base,
 544                     TGSI_OPCODE_MAD, emit_data->args[0], tmp, emit_data->args[2]);
 545 }
 546
 547 /* TGSI_OPCODE_MAD */
 548
 549 static void
 550 mad_emit(
 551    const struct lp_build_tgsi_action * action,
 552    struct lp_build_tgsi_context * bld_base,
 553    struct lp_build_emit_data * emit_data)
 554 {
 555    LLVMValueRef tmp;
 556    tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
 557                                    emit_data->args[0],
 558                                    emit_data->args[1]);
 559    emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
 560                                        TGSI_OPCODE_ADD, tmp, emit_data->args[2]);
 561 }
 562
 563 /* TGSI_OPCODE_MOV */
 564
 565 static void
 566 mov_emit(
 567    const struct lp_build_tgsi_action * action,
 568    struct lp_build_tgsi_context * bld_base,
 569    struct lp_build_emit_data * emit_data)
 570 {
 571    emit_data->output[emit_data->chan] = emit_data->args[0];
 572 }
 573
 574 /* TGSI_OPCODE_MUL */
 575 static void
 576 mul_emit(
 577    const struct lp_build_tgsi_action * action,
 578    struct lp_build_tgsi_context * bld_base,
 579    struct lp_build_emit_data * emit_data)
 580 {
 581    emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->base,
 582                                    emit_data->args[0], emit_data->args[1]);
 583 }
 584
 585 /* TGSI_OPCODE_POW */
 586
 587 static void
 588 pow_emit(
 589    const struct lp_build_tgsi_action * action,
 590    struct lp_build_tgsi_context * bld_base,
 591    struct lp_build_emit_data * emit_data)
 592 {
 593    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
 594                                    emit_data->args[0], emit_data->args[1]);
 595 }
 596
 597 static struct lp_build_tgsi_action pow_action = {
 598    scalar_binary_fetch_args,     /* fetch_args */
 599    pow_emit      /* emit */
 600 };
 601
 602 /* TGSI_OPCODE_RSQ */
 603
 604 static void
 605 rsq_emit(
 606    const struct lp_build_tgsi_action * action,
 607    struct lp_build_tgsi_context * bld_base,
 608    struct lp_build_emit_data * emit_data)
 609 {
 610    emit_data->args[0] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
 611                                                emit_data->args[0]);
 612    if (bld_base->rsq_action.emit) {
 613       bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
 614    } else {
 615       emit_data->output[emit_data->chan] = bld_base->base.undef;
 616    }
 617 }
 618
 619 const struct lp_build_tgsi_action rsq_action = {
 620    scalar_unary_fetch_args,      /* fetch_args */
 621    rsq_emit      /* emit */
 622
 623 };
 624
 625 /* TGSI_OPCODE_SCS */
 626 static void
 627 scs_emit(
 628    const struct lp_build_tgsi_action * action,
 629    struct lp_build_tgsi_context * bld_base,
 630    struct lp_build_emit_data * emit_data)
 631 {
 632    /* dst.x */
 633    emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
 634                                            TGSI_OPCODE_COS, emit_data->args[0]);
 635    /* dst.y */
 636    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
 637                                            TGSI_OPCODE_SIN, emit_data->args[0]);
 638    /* dst.z */
 639    emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
 640
 641    /* dst.w */
 642    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 643 }
 644
 645 const struct lp_build_tgsi_action scs_action = {
 646    scalar_unary_fetch_args,      /* fetch_args */
 647    scs_emit      /* emit */
 648 };
 649
 650 /* TGSI_OPCODE_SFL */
 651
 652 static void
 653 sfl_emit(
 654    const struct lp_build_tgsi_action * action,
 655    struct lp_build_tgsi_context * bld_base,
 656    struct lp_build_emit_data * emit_data)
 657 {
 658    emit_data->output[emit_data->chan] = bld_base->base.zero;
 659 }
 660
 661 /* TGSI_OPCODE_STR */
 662
 663 static void
 664 str_emit(
 665    const struct lp_build_tgsi_action * action,
 666    struct lp_build_tgsi_context * bld_base,
 667    struct lp_build_emit_data * emit_data)
 668 {
 669    emit_data->output[emit_data->chan] = bld_base->base.one;
 670 }
 671
 672 /* TGSI_OPCODE_SUB */
 673 static void
 674 sub_emit(
 675    const struct lp_build_tgsi_action * action,
 676    struct lp_build_tgsi_context * bld_base,
 677    struct lp_build_emit_data * emit_data)
 678 {
 679         emit_data->output[emit_data->chan] = LLVMBuildFSub(
 680                                 bld_base->base.gallivm->builder,
 681                                 emit_data->args[0],
 682                                 emit_data->args[1], "");
 683 }
 684
 685 /* TGSI_OPCODE_XPD */
 686
 687 static void
 688 xpd_fetch_args(
 689    struct lp_build_tgsi_context * bld_base,
 690    struct lp_build_emit_data * emit_data)
 691 {
 692    dp_fetch_args(bld_base, emit_data, 3);
 693 }
 694
 695 /**
 696  * (a * b) - (c * d)
 697  */
 698 static LLVMValueRef
 699 xpd_helper(
 700   struct lp_build_tgsi_context * bld_base,
 701   LLVMValueRef a,
 702   LLVMValueRef b,
 703   LLVMValueRef c,
 704   LLVMValueRef d)
 705 {
 706    LLVMValueRef tmp0, tmp1;
 707
 708    tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
 709    tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
 710
 711    return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
 712 }
 713
 714 static void
 715 xpd_emit(
 716    const struct lp_build_tgsi_action * action,
 717    struct lp_build_tgsi_context * bld_base,
 718    struct lp_build_emit_data * emit_data)
 719 {
 720    emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
 721               emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
 722               emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
 723
 724    emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
 725               emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
 726               emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
 727
 728    emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
 729               emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
 730               emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
 731
 732    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 733 }
 734
 735 const struct lp_build_tgsi_action xpd_action = {
 736    xpd_fetch_args,       /* fetch_args */
 737    xpd_emit      /* emit */
 738 };
 739
 740 void
 741 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
 742 {
 743    bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
 744    bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
 745    bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
 746    bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
 747    bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
 748    bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
 749    bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
 750    bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
 751    bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
 752    bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
 753    bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
 754    bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
 755    bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
 756
 757    bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
 758    bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
 759    bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
 760    bld_base->op_actions[TGSI_OPCODE_KIL].fetch_args = kil_fetch_args;
 761    bld_base->op_actions[TGSI_OPCODE_KILP].fetch_args = kilp_fetch_args;
 762    bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
 763    bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
 764    bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
 765
 766    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
 767    bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
 768    bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
 769    bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
 770    bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
 771    bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
 772    bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
 773    bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
 774    bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
 775    bld_base->op_actions[TGSI_OPCODE_SFL].emit = sfl_emit;
 776    bld_base->op_actions[TGSI_OPCODE_STR].emit = str_emit;
 777    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
 778 }
 779
 780 /* CPU Only default actions */
 781
 782 /* These actions are CPU only, because they could potentially output SSE
 783  * intrinsics.
 784  */
 785
 786 /* TGSI_OPCODE_ABS (CPU Only)*/
 787
 788 static void
 789 abs_emit_cpu(
 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] = lp_build_abs(&bld_base->base,
 795                                                        emit_data->args[0]);
 796 }
 797
 798 /* TGSI_OPCODE_ADD (CPU Only) */
 799 static void
 800 add_emit_cpu(
 801    const struct lp_build_tgsi_action * action,
 802    struct lp_build_tgsi_context * bld_base,
 803    struct lp_build_emit_data * emit_data)
 804 {
 805    emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
 806                                    emit_data->args[0], emit_data->args[1]);
 807 }
 808
 809 /* TGSI_OPCODE_ARL (CPU Only) */
 810 static void
 811 arl_emit_cpu(
 812    const struct lp_build_tgsi_action * action,
 813    struct lp_build_tgsi_context * bld_base,
 814    struct lp_build_emit_data * emit_data)
 815 {
 816    LLVMValueRef tmp;
 817    tmp = lp_build_floor(&bld_base->base,
 818                         emit_data->args[0]);
 819    emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
 820                                                         bld_base->uint_bld.vec_type, "");
 821 }
 822
 823 /* TGSI_OPCODE_CEIL (CPU Only) */
 824 static void
 825 ceil_emit_cpu(
 826    const struct lp_build_tgsi_action * action,
 827    struct lp_build_tgsi_context * bld_base,
 828    struct lp_build_emit_data * emit_data)
 829 {
 830    emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
 831                                                          emit_data->args[0]);
 832 }
 833
 834 /* TGSI_OPCODE_CMP (CPU Only) */
 835 static void
 836 cmp_emit_cpu(
 837    const struct lp_build_tgsi_action * action,
 838    struct lp_build_tgsi_context * bld_base,
 839    struct lp_build_emit_data * emit_data)
 840 {
 841    LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
 842                                    emit_data->args[0], bld_base->base.zero);
 843    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
 844                                 cond, emit_data->args[1], emit_data->args[2]);
 845 }
 846
 847 /* TGSI_OPCODE_CND (CPU Only) */
 848 static void
 849 cnd_emit_cpu(
 850    const struct lp_build_tgsi_action * action,
 851    struct lp_build_tgsi_context * bld_base,
 852    struct lp_build_emit_data * emit_data)
 853 {
 854    LLVMValueRef half, tmp;
 855    half = lp_build_const_vec(bld_base->base.gallivm, bld_base->base.type, 0.5);
 856    tmp = lp_build_cmp(&bld_base->base, PIPE_FUNC_GREATER,
 857                       emit_data->args[2], half);
 858    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
 859                                           tmp,
 860                                           emit_data->args[0],
 861                                           emit_data->args[1]);
 862 }
 863
 864 /* TGSI_OPCODE_COS (CPU Only) */
 865 static void
 866 cos_emit_cpu(
 867    const struct lp_build_tgsi_action * action,
 868    struct lp_build_tgsi_context * bld_base,
 869    struct lp_build_emit_data * emit_data)
 870 {
 871    emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
 872                                                        emit_data->args[0]);
 873 }
 874
 875 /* TGSI_OPCODE_DIV (CPU Only) */
 876 static void
 877 div_emit_cpu(
 878    const struct lp_build_tgsi_action * action,
 879    struct lp_build_tgsi_context * bld_base,
 880    struct lp_build_emit_data * emit_data)
 881 {
 882    emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
 883                                    emit_data->args[0], emit_data->args[1]);
 884 }
 885
 886 /* TGSI_OPCODE_EX2 (CPU Only) */
 887 static void
 888 ex2_emit_cpu(
 889    const struct lp_build_tgsi_action * action,
 890    struct lp_build_tgsi_context * bld_base,
 891    struct lp_build_emit_data * emit_data)
 892 {
 893    emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
 894                                                         emit_data->args[0]);
 895 }
 896
 897 /* TGSI_OPCODE_EXP (CPU Only) */
 898 static void
 899 exp_emit_cpu(
 900    const struct lp_build_tgsi_action * action,
 901    struct lp_build_tgsi_context * bld_base,
 902    struct lp_build_emit_data * emit_data)
 903 {
 904    lp_build_exp2_approx(&bld_base->base, emit_data->args[0],
 905                         &emit_data->output[TGSI_CHAN_X],
 906                         &emit_data->output[TGSI_CHAN_Y],
 907                         &emit_data->output[TGSI_CHAN_Z]);
 908    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 909 }
 910
 911 /* TGSI_OPCODE_FLR (CPU Only) */
 912
 913 static void
 914 flr_emit_cpu(
 915    const struct lp_build_tgsi_action * action,
 916    struct lp_build_tgsi_context * bld_base,
 917    struct lp_build_emit_data * emit_data)
 918 {
 919    emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
 920                                                          emit_data->args[0]);
 921 }
 922
 923 /* TGSI_OPCODE_LG2 (CPU Only) */
 924 static void
 925 lg2_emit_cpu(
 926    const struct lp_build_tgsi_action * action,
 927    struct lp_build_tgsi_context * bld_base,
 928    struct lp_build_emit_data * emit_data)
 929 {
 930    emit_data->output[emit_data->chan] = lp_build_log2(&bld_base->base,
 931                                                         emit_data->args[0]);
 932 }
 933
 934 /* TGSI_OPCODE_LOG (CPU Only) */
 935 static void
 936 log_emit_cpu(
 937    const struct lp_build_tgsi_action * action,
 938    struct lp_build_tgsi_context * bld_base,
 939    struct lp_build_emit_data * emit_data)
 940 {
 941    LLVMValueRef p_floor_log2;
 942    LLVMValueRef p_exp;
 943    LLVMValueRef p_log2;
 944    LLVMValueRef src0 = emit_data->args[0];
 945
 946    lp_build_log2_approx(&bld_base->base, src0,
 947                         &p_exp, &p_floor_log2, &p_log2);
 948
 949    emit_data->output[TGSI_CHAN_X] = p_floor_log2;
 950
 951    emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
 952                                              TGSI_OPCODE_DIV,
 953                                              src0, p_exp);
 954    emit_data->output[TGSI_CHAN_Z] = p_log2;
 955
 956    emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
 957
 958 }
 959
 960 /* TGSI_OPCODE_MAX (CPU Only) */
 961
 962 static void
 963 max_emit_cpu(
 964    const struct lp_build_tgsi_action * action,
 965    struct lp_build_tgsi_context * bld_base,
 966    struct lp_build_emit_data * emit_data)
 967 {
 968    emit_data->output[emit_data->chan] = lp_build_max(&bld_base->base,
 969                                    emit_data->args[0], emit_data->args[1]);
 970 }
 971
 972 /* TGSI_OPCODE_MIN (CPU Only) */
 973 static void
 974 min_emit_cpu(
 975    const struct lp_build_tgsi_action * action,
 976    struct lp_build_tgsi_context * bld_base,
 977    struct lp_build_emit_data * emit_data)
 978 {
 979    emit_data->output[emit_data->chan] = lp_build_min(&bld_base->base,
 980                                    emit_data->args[0], emit_data->args[1]);
 981 }
 982
 983 /* TGSI_OPCODE_POW (CPU Only) */
 984 static void
 985 pow_emit_cpu(
 986    const struct lp_build_tgsi_action * action,
 987    struct lp_build_tgsi_context * bld_base,
 988    struct lp_build_emit_data * emit_data)
 989 {
 990    emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
 991                                    emit_data->args[0], emit_data->args[1]);
 992 }
 993
 994
 995 /* TGSI_OPCODE_RCP (CPU Only) */
 996
 997 static void
 998 rcp_emit_cpu(
 999    const struct lp_build_tgsi_action * action,
1000    struct lp_build_tgsi_context * bld_base,
1001    struct lp_build_emit_data * emit_data)
1002 {
1003    emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1004                                                        emit_data->args[0]);
1005 }
1006
1007 /* Reciprical squareroot (CPU Only) */
1008
1009 /* This is not the same as TGSI_OPCODE_RSQ, which requres the argument to be
1010  * greater than or equal to 0 */
1011 static void
1012 recip_sqrt_emit_cpu(
1013    const struct lp_build_tgsi_action * action,
1014    struct lp_build_tgsi_context * bld_base,
1015    struct lp_build_emit_data * emit_data)
1016 {
1017    emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1018                                                          emit_data->args[0]);
1019 }
1020
1021 /* TGSI_OPCODE_ROUND (CPU Only) */
1022 static void
1023 round_emit_cpu(
1024    const struct lp_build_tgsi_action * action,
1025    struct lp_build_tgsi_context * bld_base,
1026    struct lp_build_emit_data * emit_data)
1027 {
1028    emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1029                                                          emit_data->args[0]);
1030 }
1031
1032 /* TGSI_OPCODE_SET Helper (CPU Only) */
1033
1034 static void
1035 set_emit_cpu(
1036    const struct lp_build_tgsi_action * action,
1037    struct lp_build_tgsi_context * bld_base,
1038    struct lp_build_emit_data * emit_data,
1039    unsigned pipe_func)
1040 {
1041    LLVMValueRef cond = lp_build_cmp(&bld_base->base, pipe_func,
1042                                     emit_data->args[0], emit_data->args[1]);
1043    emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1044                                           cond,
1045                                           bld_base->base.one,
1046                                           bld_base->base.zero);
1047 }
1048
1049 /* TGSI_OPCODE_SEQ (CPU Only) */
1050
1051 static void
1052 seq_emit_cpu(
1053    const struct lp_build_tgsi_action * action,
1054    struct lp_build_tgsi_context * bld_base,
1055    struct lp_build_emit_data * emit_data)
1056 {
1057    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1058 }
1059
1060 /* TGSI_OPCODE_SGE (CPU Only) */
1061 static void
1062 sge_emit_cpu(
1063    const struct lp_build_tgsi_action * action,
1064    struct lp_build_tgsi_context * bld_base,
1065    struct lp_build_emit_data * emit_data)
1066 {
1067    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1068 }
1069
1070 /* TGSI_OPCODE_SGT (CPU Only)*/
1071
1072 static void
1073 sgt_emit_cpu(
1074    const struct lp_build_tgsi_action * action,
1075    struct lp_build_tgsi_context * bld_base,
1076    struct lp_build_emit_data * emit_data)
1077 {
1078    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1079 }
1080
1081 /* TGSI_OPCODE_SIN (CPU Only) */
1082 static void
1083 sin_emit_cpu(
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    emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base,
1089                                                        emit_data->args[0]);
1090 }
1091
1092 /* TGSI_OPCODE_SLE (CPU Only) */
1093 static void
1094 sle_emit_cpu(
1095    const struct lp_build_tgsi_action * action,
1096    struct lp_build_tgsi_context * bld_base,
1097    struct lp_build_emit_data * emit_data)
1098 {
1099    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
1100 }
1101
1102 /* TGSI_OPCODE_SLT (CPU Only) */
1103
1104 static void
1105 slt_emit_cpu(
1106    const struct lp_build_tgsi_action * action,
1107    struct lp_build_tgsi_context * bld_base,
1108    struct lp_build_emit_data * emit_data)
1109 {
1110    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1111 }
1112
1113 /* TGSI_OPCODE_SNE (CPU Only) */
1114
1115 static void
1116 sne_emit_cpu(
1117    const struct lp_build_tgsi_action * action,
1118    struct lp_build_tgsi_context * bld_base,
1119    struct lp_build_emit_data * emit_data)
1120 {
1121    set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1122 }
1123
1124 /* TGSI_OPCODE_SSG (CPU Only) */
1125
1126 static void
1127 ssg_emit_cpu(
1128    const struct lp_build_tgsi_action * action,
1129    struct lp_build_tgsi_context * bld_base,
1130    struct lp_build_emit_data * emit_data)
1131 {
1132    emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
1133                                                        emit_data->args[0]);
1134 }
1135
1136 /* TGSI_OPCODE_SUB (CPU Only) */
1137
1138 static void
1139 sub_emit_cpu(
1140    const struct lp_build_tgsi_action * action,
1141    struct lp_build_tgsi_context * bld_base,
1142    struct lp_build_emit_data * emit_data)
1143 {
1144    emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
1145                                                         emit_data->args[0],
1146                                                         emit_data->args[1]);
1147 }
1148
1149 /* TGSI_OPCODE_TRUNC (CPU Only) */
1150
1151 static void
1152 trunc_emit_cpu(
1153    const struct lp_build_tgsi_action * action,
1154    struct lp_build_tgsi_context * bld_base,
1155    struct lp_build_emit_data * emit_data)
1156 {
1157    emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
1158                                                          emit_data->args[0]);
1159 }
1160
1161 void
1162 lp_set_default_actions_cpu(
1163    struct lp_build_tgsi_context * bld_base)
1164 {
1165    lp_set_default_actions(bld_base);
1166    bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
1167    bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
1168    bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
1169    bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
1170    bld_base->op_actions[TGSI_OPCODE_CND].emit = cnd_emit_cpu;
1171    bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
1172    bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
1173    bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
1174    bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
1175    bld_base->op_actions[TGSI_OPCODE_EXP].emit = exp_emit_cpu;
1176    bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
1177    bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
1178    bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
1179    bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
1180    bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
1181    bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
1182    bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
1183    bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
1184    bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
1185    bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
1186    bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
1187    bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
1188    bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
1189    bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
1190    bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
1191    bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
1192    bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
1193    bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
1194
1195    bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
1196 }