Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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