1 /**************************************************************************
3 * Copyright 2011-2012 Advanced Micro Devices, Inc.
4 * Copyright 2009 VMware, Inc.
5 * Copyright 2007-2008 VMware, Inc.
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:
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
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.
28 **************************************************************************/
32 * TGSI to LLVM IR translation.
34 * @author Jose Fonseca <jfonseca@vmware.com>
35 * @author Tom Stellard <thomas.stellard@amd.com>
37 * Based on tgsi_sse2.c code written by Michal Krol, Keith Whitwell,
38 * Brian Paul, and others.
42 #include "lp_bld_tgsi_action.h"
44 #include "lp_bld_tgsi.h"
45 #include "lp_bld_arit.h"
46 #include "lp_bld_bitarit.h"
47 #include "lp_bld_const.h"
48 #include "lp_bld_conv.h"
49 #include "lp_bld_gather.h"
50 #include "lp_bld_logic.h"
51 #include "lp_bld_pack.h"
53 #include "tgsi/tgsi_exec.h"
55 /* XXX: The CPU only defaults should be repaced by generic ones. In most
56 * cases, the CPU defaults are just wrappers around a function in
57 * lp_build_arit.c and these functions should be inlined here and the CPU
58 * generic code should be removed and placed elsewhere.
63 /* Generic fetch_arg functions */
65 static void scalar_unary_fetch_args(
66 struct lp_build_tgsi_context * bld_base,
67 struct lp_build_emit_data * emit_data)
70 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, 0);
71 emit_data->arg_count = 1;
72 emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
75 static void scalar_binary_fetch_args(
76 struct lp_build_tgsi_context * bld_base,
77 struct lp_build_emit_data * emit_data)
80 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
83 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
85 emit_data->arg_count = 2;
86 emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
92 const struct lp_build_tgsi_action * action,
93 struct lp_build_tgsi_context * bld_base,
94 struct lp_build_emit_data * emit_data)
96 emit_data->output[emit_data->chan] = LLVMBuildFAdd(
97 bld_base->base.gallivm->builder,
98 emit_data->args[0], emit_data->args[1], "");
101 /* TGSI_OPCODE_ARR */
104 const struct lp_build_tgsi_action * action,
105 struct lp_build_tgsi_context * bld_base,
106 struct lp_build_emit_data * emit_data)
108 LLVMValueRef tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ROUND, emit_data->args[0]);
109 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
110 bld_base->uint_bld.vec_type, "");
113 /* TGSI_OPCODE_CLAMP */
116 const struct lp_build_tgsi_action * action,
117 struct lp_build_tgsi_context * bld_base,
118 struct lp_build_emit_data * emit_data)
121 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
124 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
125 TGSI_OPCODE_MIN, tmp, emit_data->args[2]);
132 struct lp_build_tgsi_context * bld_base,
133 struct lp_build_emit_data * emit_data,
134 unsigned dp_components)
137 for (src = 0; src < 2; src++) {
138 for (chan = 0; chan < dp_components; chan++) {
139 emit_data->args[(src * dp_components) + chan] =
140 lp_build_emit_fetch(bld_base, emit_data->inst, src, chan);
143 emit_data->dst_type = bld_base->base.elem_type;
146 /* TGSI_OPCODE_DP2 */
149 struct lp_build_tgsi_context * bld_base,
150 struct lp_build_emit_data * emit_data)
152 dp_fetch_args(bld_base, emit_data, 2);
157 const struct lp_build_tgsi_action * action,
158 struct lp_build_tgsi_context * bld_base,
159 struct lp_build_emit_data * emit_data)
161 LLVMValueRef tmp0, tmp1;
162 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
163 emit_data->args[0] /* src0.x */,
164 emit_data->args[2] /* src1.x */);
165 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
166 emit_data->args[1] /* src0.y */,
167 emit_data->args[3] /* src1.y */);
168 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
169 TGSI_OPCODE_ADD, tmp0, tmp1);
172 static struct lp_build_tgsi_action dp2_action = {
173 dp2_fetch_args, /* fetch_args */
177 /* TGSI_OPCODE_DP2A */
180 struct lp_build_tgsi_context * bld_base,
181 struct lp_build_emit_data * emit_data)
183 dp_fetch_args(bld_base, emit_data, 2);
184 emit_data->args[5] = lp_build_emit_fetch(bld_base, emit_data->inst,
190 const struct lp_build_tgsi_action * action,
191 struct lp_build_tgsi_context * bld_base,
192 struct lp_build_emit_data * emit_data)
195 tmp = lp_build_emit_llvm(bld_base, TGSI_OPCODE_DP2, emit_data);
196 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD,
197 emit_data->args[5], tmp);
200 static struct lp_build_tgsi_action dp2a_action = {
201 dp2a_fetch_args, /* fetch_args */
205 /* TGSI_OPCODE_DP3 */
208 struct lp_build_tgsi_context * bld_base,
209 struct lp_build_emit_data * emit_data)
211 dp_fetch_args(bld_base, emit_data, 3);
216 const struct lp_build_tgsi_action * action,
217 struct lp_build_tgsi_context * bld_base,
218 struct lp_build_emit_data * emit_data)
220 LLVMValueRef tmp0, tmp1;
221 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
222 emit_data->args[0] /* src0.x */,
223 emit_data->args[3] /* src1.x */);
224 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
225 emit_data->args[1] /* src0.y */,
226 emit_data->args[4] /* src1.y */);
227 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp1, tmp0);
228 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
229 emit_data->args[2] /* src0.z */,
230 emit_data->args[5] /* src1.z */);
231 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
232 TGSI_OPCODE_ADD, tmp0, tmp1);
235 static struct lp_build_tgsi_action dp3_action = {
236 dp3_fetch_args, /* fetch_args */
240 /* TGSI_OPCODDE_DP4 */
244 struct lp_build_tgsi_context * bld_base,
245 struct lp_build_emit_data * emit_data)
247 dp_fetch_args(bld_base, emit_data, 4);
252 const struct lp_build_tgsi_action * action,
253 struct lp_build_tgsi_context * bld_base,
254 struct lp_build_emit_data * emit_data)
256 LLVMValueRef tmp0, tmp1;
257 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
258 emit_data->args[0] /* src0.x */,
259 emit_data->args[4] /* src1.x */);
260 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
261 emit_data->args[1] /* src0.y */,
262 emit_data->args[5] /* src1.y */);
263 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
264 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
265 emit_data->args[2] /* src0.z */,
266 emit_data->args[6] /* src1.z */);
267 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1);
268 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
269 emit_data->args[3] /* src0.w */,
270 emit_data->args[7] /* src1.w */);
271 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
272 TGSI_OPCODE_ADD, tmp0, tmp1);
275 static struct lp_build_tgsi_action dp4_action = {
276 dp4_fetch_args, /* fetch_args */
280 /* TGSI_OPCODE_DPH */
283 struct lp_build_tgsi_context * bld_base,
284 struct lp_build_emit_data * emit_data)
286 dp_fetch_args(bld_base, emit_data, 4);
288 emit_data->args[3] = bld_base->base.one;
291 const struct lp_build_tgsi_action dph_action = {
292 dph_fetch_args, /* fetch_args */
296 /* TGSI_OPCODE_DST */
299 struct lp_build_tgsi_context * bld_base,
300 struct lp_build_emit_data * emit_data)
303 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
306 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
309 emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
312 emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
318 const struct lp_build_tgsi_action * action,
319 struct lp_build_tgsi_context * bld_base,
320 struct lp_build_emit_data * emit_data)
323 emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
326 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
328 emit_data->args[0] /* src0.y */,
329 emit_data->args[2] /* src1.y */);
331 emit_data->output[TGSI_CHAN_Z] = emit_data->args[1]; /* src0.z */
334 emit_data->output[TGSI_CHAN_W] = emit_data->args[3]; /* src1.w */
337 static struct lp_build_tgsi_action dst_action = {
338 dst_fetch_args, /* fetch_args */
342 /* TGSI_OPCODE_END */
345 const struct lp_build_tgsi_action * action,
346 struct lp_build_tgsi_context * bld_base,
347 struct lp_build_emit_data * emit_data)
352 /* TGSI_OPCODE_EXP */
356 const struct lp_build_tgsi_action * action,
357 struct lp_build_tgsi_context * bld_base,
358 struct lp_build_emit_data * emit_data)
360 LLVMValueRef floor_x;
362 /* floor( src0.x ) */
363 floor_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
366 /* 2 ^ floor( src0.x ) */
367 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
368 TGSI_OPCODE_EX2, floor_x);
370 /* src0.x - floor( src0.x ) */
371 emit_data->output[TGSI_CHAN_Y] =
372 lp_build_sub(&bld_base->base, emit_data->args[0] /* src0.x */, floor_x);
375 emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_unary(bld_base,
376 TGSI_OPCODE_EX2, emit_data->args[0] /* src0.x */);
378 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
381 const struct lp_build_tgsi_action exp_action = {
382 scalar_unary_fetch_args, /* fetch_args */
386 /* TGSI_OPCODE_FRC */
390 const struct lp_build_tgsi_action * action,
391 struct lp_build_tgsi_context * bld_base,
392 struct lp_build_emit_data * emit_data)
395 tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
397 emit_data->output[emit_data->chan] =
398 lp_build_sub(&bld_base->base, emit_data->args[0], tmp);
401 /* TGSI_OPCODE_KILL_IF */
405 struct lp_build_tgsi_context * bld_base,
406 struct lp_build_emit_data * emit_data)
409 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
412 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
415 emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst,
418 emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst,
420 emit_data->arg_count = 4;
421 emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
424 /* TGSI_OPCODE_KILL */
428 struct lp_build_tgsi_context * bld_base,
429 struct lp_build_emit_data * emit_data)
431 emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
434 /* TGSI_OPCODE_LIT */
438 struct lp_build_tgsi_context * bld_base,
439 struct lp_build_emit_data * emit_data)
442 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_X);
444 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_Y);
446 emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W);
447 emit_data->arg_count = 3;
452 const struct lp_build_tgsi_action * action,
453 struct lp_build_tgsi_context * bld_base,
454 struct lp_build_emit_data * emit_data)
456 LLVMValueRef tmp0, tmp1, tmp2;
459 emit_data->output[TGSI_CHAN_X] = bld_base->base.one;
462 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
464 emit_data->args[0] /* src0.x */,
465 bld_base->base.zero);
468 /* XMM[1] = SrcReg[0].yyyy */
469 tmp1 = emit_data->args[1];
470 /* XMM[1] = max(XMM[1], 0) */
471 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX,
472 tmp1, bld_base->base.zero);
473 /* XMM[2] = SrcReg[0].wwww */
474 tmp2 = emit_data->args[2];
475 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_POW,
477 tmp0 = emit_data->args[0];
478 emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_ternary(bld_base,
480 tmp0, bld_base->base.zero, tmp1);
482 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
485 static struct lp_build_tgsi_action lit_action = {
486 lit_fetch_args, /* fetch_args */
490 /* TGSI_OPCODE_LOG */
494 const struct lp_build_tgsi_action * action,
495 struct lp_build_tgsi_context * bld_base,
496 struct lp_build_emit_data * emit_data)
499 LLVMValueRef abs_x, log_abs_x, flr_log_abs_x, ex2_flr_log_abs_x;
502 abs_x = lp_build_abs(&bld_base->base, emit_data->args[0] /* src0.x */);
504 /* log( abs( src0.x ) ) */
505 log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_LG2,
508 /* floor( log( abs( src0.x ) ) ) */
509 flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR,
512 emit_data->output[TGSI_CHAN_X] = flr_log_abs_x;
515 ex2_flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_EX2,
518 /* abs( src0.x ) / 2^( floor( lg2( abs( src0.x ) ) ) ) */
519 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
520 TGSI_OPCODE_DIV, abs_x, ex2_flr_log_abs_x);
523 emit_data->output[TGSI_CHAN_Z] = log_abs_x;
526 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
529 static struct lp_build_tgsi_action log_action = {
530 scalar_unary_fetch_args, /* fetch_args */
534 /* TGSI_OPCODE_PK2H */
538 struct lp_build_tgsi_context * bld_base,
539 struct lp_build_emit_data * emit_data)
542 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst,
545 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst,
551 const struct lp_build_tgsi_action *action,
552 struct lp_build_tgsi_context *bld_base,
553 struct lp_build_emit_data *emit_data)
555 struct gallivm_state *gallivm = bld_base->base.gallivm;
556 struct lp_type f16i_t;
557 LLVMValueRef lo, hi, res;
559 f16i_t = lp_type_uint_vec(16, bld_base->base.type.length * 32);
560 lo = lp_build_float_to_half(gallivm, emit_data->args[0]);
561 hi = lp_build_float_to_half(gallivm, emit_data->args[1]);
562 /* maybe some interleave doubling vector width would be useful... */
563 lo = lp_build_pad_vector(gallivm, lo, bld_base->base.type.length * 2);
564 hi = lp_build_pad_vector(gallivm, hi, bld_base->base.type.length * 2);
565 res = lp_build_interleave2(gallivm, f16i_t, lo, hi, 0);
567 emit_data->output[emit_data->chan] = res;
570 static struct lp_build_tgsi_action pk2h_action = {
571 pk2h_fetch_args, /* fetch_args */
575 /* TGSI_OPCODE_UP2H */
579 const struct lp_build_tgsi_action *action,
580 struct lp_build_tgsi_context *bld_base,
581 struct lp_build_emit_data *emit_data)
583 struct gallivm_state *gallivm = bld_base->base.gallivm;
584 LLVMBuilderRef builder = gallivm->builder;
585 LLVMContextRef context = gallivm->context;
586 LLVMValueRef lo, hi, res[2], arg;
587 unsigned nr = bld_base->base.type.length;
588 LLVMTypeRef i16t = LLVMVectorType(LLVMInt16TypeInContext(context), nr * 2);
590 arg = LLVMBuildBitCast(builder, emit_data->args[0], i16t, "");
591 lo = lp_build_uninterleave1(gallivm, nr * 2, arg, 0);
592 hi = lp_build_uninterleave1(gallivm, nr * 2, arg, 1);
593 res[0] = lp_build_half_to_float(gallivm, lo);
594 res[1] = lp_build_half_to_float(gallivm, hi);
596 emit_data->output[0] = emit_data->output[2] = res[0];
597 emit_data->output[1] = emit_data->output[3] = res[1];
600 static struct lp_build_tgsi_action up2h_action = {
601 scalar_unary_fetch_args, /* fetch_args */
605 /* TGSI_OPCODE_LRP */
609 const struct lp_build_tgsi_action * action,
610 struct lp_build_tgsi_context * bld_base,
611 struct lp_build_emit_data * emit_data)
613 struct lp_build_context *bld = &bld_base->base;
614 LLVMValueRef inv, a, b;
616 /* This uses the correct version: (1 - t)*a + t*b
618 * An alternative version is "a + t*(b-a)". The problem is this version
619 * doesn't return "b" for t = 1, because "a + (b-a)" isn't equal to "b"
620 * because of the floating-point rounding.
622 inv = lp_build_sub(bld, bld_base->base.one, emit_data->args[0]);
623 a = lp_build_mul(bld, emit_data->args[1], emit_data->args[0]);
624 b = lp_build_mul(bld, emit_data->args[2], inv);
625 emit_data->output[emit_data->chan] = lp_build_add(bld, a, b);
628 /* TGSI_OPCODE_MAD */
632 const struct lp_build_tgsi_action * action,
633 struct lp_build_tgsi_context * bld_base,
634 struct lp_build_emit_data * emit_data)
637 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL,
640 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
641 TGSI_OPCODE_ADD, tmp, emit_data->args[2]);
644 /* TGSI_OPCODE_MOV */
648 const struct lp_build_tgsi_action * action,
649 struct lp_build_tgsi_context * bld_base,
650 struct lp_build_emit_data * emit_data)
652 emit_data->output[emit_data->chan] = emit_data->args[0];
655 /* TGSI_OPCODE_MUL */
658 const struct lp_build_tgsi_action * action,
659 struct lp_build_tgsi_context * bld_base,
660 struct lp_build_emit_data * emit_data)
662 emit_data->output[emit_data->chan] = LLVMBuildFMul(
663 bld_base->base.gallivm->builder,
664 emit_data->args[0], emit_data->args[1], "");
667 /*.TGSI_OPCODE_DIV.*/
668 static void fdiv_emit(
669 const struct lp_build_tgsi_action * action,
670 struct lp_build_tgsi_context * bld_base,
671 struct lp_build_emit_data * emit_data)
673 emit_data->output[emit_data->chan] = LLVMBuildFDiv(
674 bld_base->base.gallivm->builder,
675 emit_data->args[0], emit_data->args[1], "");
678 /*.TGSI_OPCODE_RCP.*/
679 static void rcp_emit(
680 const struct lp_build_tgsi_action * action,
681 struct lp_build_tgsi_context * bld_base,
682 struct lp_build_emit_data * emit_data)
685 one = lp_build_const_float(bld_base->base.gallivm, 1.0f);
686 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
687 TGSI_OPCODE_DIV, one, emit_data->args[0]);
690 /* TGSI_OPCODE_POW */
694 const struct lp_build_tgsi_action * action,
695 struct lp_build_tgsi_context * bld_base,
696 struct lp_build_emit_data * emit_data)
698 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
699 emit_data->args[0], emit_data->args[1]);
702 static struct lp_build_tgsi_action pow_action = {
703 scalar_binary_fetch_args, /* fetch_args */
707 /* TGSI_OPCODE_RSQ */
711 const struct lp_build_tgsi_action * action,
712 struct lp_build_tgsi_context * bld_base,
713 struct lp_build_emit_data * emit_data)
715 if (bld_base->rsq_action.emit) {
716 bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
718 emit_data->output[emit_data->chan] = bld_base->base.undef;
722 const struct lp_build_tgsi_action rsq_action = {
723 scalar_unary_fetch_args, /* fetch_args */
728 /* TGSI_OPCODE_SQRT */
732 const struct lp_build_tgsi_action * action,
733 struct lp_build_tgsi_context * bld_base,
734 struct lp_build_emit_data * emit_data)
736 if (bld_base->sqrt_action.emit) {
737 bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data);
739 emit_data->output[emit_data->chan] = bld_base->base.undef;
743 const struct lp_build_tgsi_action sqrt_action = {
744 scalar_unary_fetch_args, /* fetch_args */
748 /* TGSI_OPCODE_SCS */
751 const struct lp_build_tgsi_action * action,
752 struct lp_build_tgsi_context * bld_base,
753 struct lp_build_emit_data * emit_data)
756 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
757 TGSI_OPCODE_COS, emit_data->args[0]);
759 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
760 TGSI_OPCODE_SIN, emit_data->args[0]);
762 emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
765 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
768 const struct lp_build_tgsi_action scs_action = {
769 scalar_unary_fetch_args, /* fetch_args */
773 /* TGSI_OPCODE_F2U */
776 const struct lp_build_tgsi_action * action,
777 struct lp_build_tgsi_context * bld_base,
778 struct lp_build_emit_data * emit_data)
780 emit_data->output[emit_data->chan] =
781 LLVMBuildFPToUI(bld_base->base.gallivm->builder,
783 bld_base->base.int_vec_type, "");
786 /* TGSI_OPCODE_U2F */
789 const struct lp_build_tgsi_action * action,
790 struct lp_build_tgsi_context * bld_base,
791 struct lp_build_emit_data * emit_data)
793 emit_data->output[emit_data->chan] =
794 LLVMBuildUIToFP(bld_base->base.gallivm->builder,
796 bld_base->base.vec_type, "");
801 const struct lp_build_tgsi_action * action,
802 struct lp_build_tgsi_context * bld_base,
803 struct lp_build_emit_data * emit_data)
806 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
809 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
810 TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
813 /* TGSI_OPCODE_UMUL */
816 const struct lp_build_tgsi_action * action,
817 struct lp_build_tgsi_context * bld_base,
818 struct lp_build_emit_data * emit_data)
820 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
821 emit_data->args[0], emit_data->args[1]);
824 /* TGSI_OPCODE_IMUL_HI */
827 const struct lp_build_tgsi_action * action,
828 struct lp_build_tgsi_context * bld_base,
829 struct lp_build_emit_data * emit_data)
831 struct lp_build_context *int_bld = &bld_base->int_bld;
832 LLVMValueRef hi_bits;
834 assert(int_bld->type.width == 32);
836 /* low result bits are tossed away */
837 lp_build_mul_32_lohi(int_bld, emit_data->args[0],
838 emit_data->args[1], &hi_bits);
839 emit_data->output[emit_data->chan] = hi_bits;
844 const struct lp_build_tgsi_action * action,
845 struct lp_build_tgsi_context * bld_base,
846 struct lp_build_emit_data * emit_data)
848 struct lp_build_context *int_bld = &bld_base->int_bld;
849 LLVMValueRef hi_bits;
851 assert(int_bld->type.width == 32);
853 /* low result bits are tossed away */
854 lp_build_mul_32_lohi_cpu(int_bld, emit_data->args[0],
855 emit_data->args[1], &hi_bits);
856 emit_data->output[emit_data->chan] = hi_bits;
859 /* TGSI_OPCODE_UMUL_HI */
862 const struct lp_build_tgsi_action * action,
863 struct lp_build_tgsi_context * bld_base,
864 struct lp_build_emit_data * emit_data)
866 struct lp_build_context *uint_bld = &bld_base->uint_bld;
867 LLVMValueRef hi_bits;
869 assert(uint_bld->type.width == 32);
871 /* low result bits are tossed away */
872 lp_build_mul_32_lohi(uint_bld, emit_data->args[0],
873 emit_data->args[1], &hi_bits);
874 emit_data->output[emit_data->chan] = hi_bits;
879 const struct lp_build_tgsi_action * action,
880 struct lp_build_tgsi_context * bld_base,
881 struct lp_build_emit_data * emit_data)
883 struct lp_build_context *uint_bld = &bld_base->uint_bld;
884 LLVMValueRef hi_bits;
886 assert(uint_bld->type.width == 32);
888 /* low result bits are tossed away */
889 lp_build_mul_32_lohi_cpu(uint_bld, emit_data->args[0],
890 emit_data->args[1], &hi_bits);
891 emit_data->output[emit_data->chan] = hi_bits;
894 /* TGSI_OPCODE_MAX */
895 static void fmax_emit(
896 const struct lp_build_tgsi_action * action,
897 struct lp_build_tgsi_context * bld_base,
898 struct lp_build_emit_data * emit_data)
900 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
901 emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
902 LLVMBuildFCmp(builder, LLVMRealUGE,
903 emit_data->args[0], emit_data->args[1], ""),
904 emit_data->args[0], emit_data->args[1], "");
907 /* TGSI_OPCODE_MIN */
908 static void fmin_emit(
909 const struct lp_build_tgsi_action * action,
910 struct lp_build_tgsi_context * bld_base,
911 struct lp_build_emit_data * emit_data)
913 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
914 emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
915 LLVMBuildFCmp(builder, LLVMRealUGE,
916 emit_data->args[0], emit_data->args[1], ""),
917 emit_data->args[1], emit_data->args[0], "");
920 /* TGSI_OPCODE_XPD */
924 struct lp_build_tgsi_context * bld_base,
925 struct lp_build_emit_data * emit_data)
927 dp_fetch_args(bld_base, emit_data, 3);
935 struct lp_build_tgsi_context * bld_base,
941 LLVMValueRef tmp0, tmp1;
943 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
944 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
946 return lp_build_sub(&bld_base->base, tmp0, tmp1);
951 const struct lp_build_tgsi_action * action,
952 struct lp_build_tgsi_context * bld_base,
953 struct lp_build_emit_data * emit_data)
955 emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
956 emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
957 emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
959 emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
960 emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
961 emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
963 emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
964 emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
965 emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
967 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
970 const struct lp_build_tgsi_action xpd_action = {
971 xpd_fetch_args, /* fetch_args */
975 /* TGSI_OPCODE_D2F */
978 const struct lp_build_tgsi_action * action,
979 struct lp_build_tgsi_context * bld_base,
980 struct lp_build_emit_data * emit_data)
982 emit_data->output[emit_data->chan] =
983 LLVMBuildFPTrunc(bld_base->base.gallivm->builder,
985 bld_base->base.vec_type, "");
988 /* TGSI_OPCODE_D2I */
991 const struct lp_build_tgsi_action * action,
992 struct lp_build_tgsi_context * bld_base,
993 struct lp_build_emit_data * emit_data)
995 emit_data->output[emit_data->chan] =
996 LLVMBuildFPToSI(bld_base->base.gallivm->builder,
998 bld_base->base.int_vec_type, "");
1001 /* TGSI_OPCODE_D2U */
1004 const struct lp_build_tgsi_action * action,
1005 struct lp_build_tgsi_context * bld_base,
1006 struct lp_build_emit_data * emit_data)
1008 emit_data->output[emit_data->chan] =
1009 LLVMBuildFPToUI(bld_base->base.gallivm->builder,
1011 bld_base->base.int_vec_type, "");
1014 /* TGSI_OPCODE_F2D */
1017 const struct lp_build_tgsi_action * action,
1018 struct lp_build_tgsi_context * bld_base,
1019 struct lp_build_emit_data * emit_data)
1021 emit_data->output[emit_data->chan] =
1022 LLVMBuildFPExt(bld_base->base.gallivm->builder,
1024 bld_base->dbl_bld.vec_type, "");
1027 /* TGSI_OPCODE_U2D */
1030 const struct lp_build_tgsi_action * action,
1031 struct lp_build_tgsi_context * bld_base,
1032 struct lp_build_emit_data * emit_data)
1034 emit_data->output[emit_data->chan] =
1035 LLVMBuildUIToFP(bld_base->base.gallivm->builder,
1037 bld_base->dbl_bld.vec_type, "");
1040 /* TGSI_OPCODE_I2D */
1043 const struct lp_build_tgsi_action * action,
1044 struct lp_build_tgsi_context * bld_base,
1045 struct lp_build_emit_data * emit_data)
1047 emit_data->output[emit_data->chan] =
1048 LLVMBuildSIToFP(bld_base->base.gallivm->builder,
1050 bld_base->dbl_bld.vec_type, "");
1053 /* TGSI_OPCODE_DMAD */
1056 const struct lp_build_tgsi_action * action,
1057 struct lp_build_tgsi_context * bld_base,
1058 struct lp_build_emit_data * emit_data)
1061 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_DMUL,
1063 emit_data->args[1]);
1064 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
1065 TGSI_OPCODE_DADD, tmp, emit_data->args[2]);
1068 /*.TGSI_OPCODE_DRCP.*/
1069 static void drcp_emit(
1070 const struct lp_build_tgsi_action * action,
1071 struct lp_build_tgsi_context * bld_base,
1072 struct lp_build_emit_data * emit_data)
1075 one = lp_build_const_vec(bld_base->dbl_bld.gallivm, bld_base->dbl_bld.type, 1.0f);
1076 emit_data->output[emit_data->chan] = LLVMBuildFDiv(
1077 bld_base->base.gallivm->builder,
1078 one, emit_data->args[0], "");
1081 /* TGSI_OPCODE_DFRAC */
1082 static void dfrac_emit(
1083 const struct lp_build_tgsi_action * action,
1084 struct lp_build_tgsi_context * bld_base,
1085 struct lp_build_emit_data * emit_data)
1088 tmp = lp_build_floor(&bld_base->dbl_bld,
1089 emit_data->args[0]);
1090 emit_data->output[emit_data->chan] = LLVMBuildFSub(bld_base->base.gallivm->builder,
1091 emit_data->args[0], tmp, "");
1096 const struct lp_build_tgsi_action * action,
1097 struct lp_build_tgsi_context * bld_base,
1098 struct lp_build_emit_data * emit_data)
1100 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint64_bld,
1101 emit_data->args[0], emit_data->args[1]);
1106 const struct lp_build_tgsi_action * action,
1107 struct lp_build_tgsi_context * bld_base,
1108 struct lp_build_emit_data * emit_data)
1110 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1111 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld,
1112 PIPE_FUNC_EQUAL, emit_data->args[1],
1113 bld_base->uint64_bld.zero);
1114 /* We want to make sure that we never divide/mod by zero to not
1115 * generate sigfpe. We don't want to crash just because the
1116 * shader is doing something weird. */
1117 LLVMValueRef divisor = LLVMBuildOr(builder,
1119 emit_data->args[1], "");
1120 LLVMValueRef result = lp_build_mod(&bld_base->uint64_bld,
1121 emit_data->args[0], divisor);
1122 /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1123 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1130 const struct lp_build_tgsi_action * action,
1131 struct lp_build_tgsi_context * bld_base,
1132 struct lp_build_emit_data * emit_data)
1134 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1135 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld,
1136 PIPE_FUNC_EQUAL, emit_data->args[1],
1137 bld_base->uint64_bld.zero);
1138 /* We want to make sure that we never divide/mod by zero to not
1139 * generate sigfpe. We don't want to crash just because the
1140 * shader is doing something weird. */
1141 LLVMValueRef divisor = LLVMBuildOr(builder,
1143 emit_data->args[1], "");
1144 LLVMValueRef result = lp_build_mod(&bld_base->int64_bld,
1145 emit_data->args[0], divisor);
1146 /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1147 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1154 const struct lp_build_tgsi_action * action,
1155 struct lp_build_tgsi_context * bld_base,
1156 struct lp_build_emit_data * emit_data)
1159 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1160 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld,
1161 PIPE_FUNC_EQUAL, emit_data->args[1],
1162 bld_base->uint64_bld.zero);
1163 /* We want to make sure that we never divide/mod by zero to not
1164 * generate sigfpe. We don't want to crash just because the
1165 * shader is doing something weird. */
1166 LLVMValueRef divisor = LLVMBuildOr(builder,
1168 emit_data->args[1], "");
1169 LLVMValueRef result = LLVMBuildUDiv(builder,
1170 emit_data->args[0], divisor, "");
1171 /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
1172 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1179 const struct lp_build_tgsi_action * action,
1180 struct lp_build_tgsi_context * bld_base,
1181 struct lp_build_emit_data * emit_data)
1184 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1185 LLVMValueRef div_mask = lp_build_cmp(&bld_base->int64_bld,
1186 PIPE_FUNC_EQUAL, emit_data->args[1],
1187 bld_base->int64_bld.zero);
1188 /* We want to make sure that we never divide/mod by zero to not
1189 * generate sigfpe. We don't want to crash just because the
1190 * shader is doing something weird. */
1191 LLVMValueRef divisor = LLVMBuildOr(builder,
1193 emit_data->args[1], "");
1194 LLVMValueRef result = LLVMBuildSDiv(builder,
1195 emit_data->args[0], divisor, "");
1196 /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
1197 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1204 const struct lp_build_tgsi_action * action,
1205 struct lp_build_tgsi_context * bld_base,
1206 struct lp_build_emit_data * emit_data)
1208 emit_data->output[emit_data->chan] =
1209 LLVMBuildFPToUI(bld_base->base.gallivm->builder,
1211 bld_base->uint64_bld.vec_type, "");
1216 const struct lp_build_tgsi_action * action,
1217 struct lp_build_tgsi_context * bld_base,
1218 struct lp_build_emit_data * emit_data)
1220 emit_data->output[emit_data->chan] =
1221 LLVMBuildFPToSI(bld_base->base.gallivm->builder,
1223 bld_base->int64_bld.vec_type, "");
1228 const struct lp_build_tgsi_action * action,
1229 struct lp_build_tgsi_context * bld_base,
1230 struct lp_build_emit_data * emit_data)
1232 emit_data->output[emit_data->chan] =
1233 LLVMBuildZExt(bld_base->base.gallivm->builder,
1235 bld_base->uint64_bld.vec_type, "");
1240 const struct lp_build_tgsi_action * action,
1241 struct lp_build_tgsi_context * bld_base,
1242 struct lp_build_emit_data * emit_data)
1244 emit_data->output[emit_data->chan] =
1245 LLVMBuildSExt(bld_base->base.gallivm->builder,
1247 bld_base->int64_bld.vec_type, "");
1252 const struct lp_build_tgsi_action * action,
1253 struct lp_build_tgsi_context * bld_base,
1254 struct lp_build_emit_data * emit_data)
1256 emit_data->output[emit_data->chan] =
1257 LLVMBuildSIToFP(bld_base->base.gallivm->builder,
1259 bld_base->base.vec_type, "");
1264 const struct lp_build_tgsi_action * action,
1265 struct lp_build_tgsi_context * bld_base,
1266 struct lp_build_emit_data * emit_data)
1268 emit_data->output[emit_data->chan] =
1269 LLVMBuildUIToFP(bld_base->base.gallivm->builder,
1271 bld_base->base.vec_type, "");
1276 const struct lp_build_tgsi_action * action,
1277 struct lp_build_tgsi_context * bld_base,
1278 struct lp_build_emit_data * emit_data)
1280 emit_data->output[emit_data->chan] =
1281 LLVMBuildSIToFP(bld_base->base.gallivm->builder,
1283 bld_base->dbl_bld.vec_type, "");
1288 const struct lp_build_tgsi_action * action,
1289 struct lp_build_tgsi_context * bld_base,
1290 struct lp_build_emit_data * emit_data)
1292 emit_data->output[emit_data->chan] =
1293 LLVMBuildUIToFP(bld_base->base.gallivm->builder,
1295 bld_base->dbl_bld.vec_type, "");
1299 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
1301 bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
1302 bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
1303 bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
1304 bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
1305 bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
1306 bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
1307 bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
1308 bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
1309 bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
1310 bld_base->op_actions[TGSI_OPCODE_PK2H] = pk2h_action;
1311 bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
1312 bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action;
1313 bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
1314 bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
1315 bld_base->op_actions[TGSI_OPCODE_UP2H] = up2h_action;
1316 bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
1318 bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args;
1319 bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args;
1320 bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args;
1321 bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
1322 bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
1323 bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
1324 bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args;
1325 bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args;
1326 bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args;
1327 bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
1328 bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
1329 bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
1331 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
1332 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
1333 bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
1334 bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
1335 bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
1336 bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
1337 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
1338 bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
1339 bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
1340 bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
1341 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
1343 bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
1344 bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit;
1345 bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
1346 bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
1347 bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
1348 bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit;
1349 bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit;
1351 bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit;
1352 bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit;
1354 bld_base->op_actions[TGSI_OPCODE_DADD].emit = add_emit;
1355 bld_base->op_actions[TGSI_OPCODE_DMAX].emit = fmax_emit;
1356 bld_base->op_actions[TGSI_OPCODE_DMIN].emit = fmin_emit;
1357 bld_base->op_actions[TGSI_OPCODE_DMUL].emit = mul_emit;
1358 bld_base->op_actions[TGSI_OPCODE_DDIV].emit = fdiv_emit;
1360 bld_base->op_actions[TGSI_OPCODE_D2F].emit = d2f_emit;
1361 bld_base->op_actions[TGSI_OPCODE_D2I].emit = d2i_emit;
1362 bld_base->op_actions[TGSI_OPCODE_D2U].emit = d2u_emit;
1364 bld_base->op_actions[TGSI_OPCODE_F2D].emit = f2d_emit;
1365 bld_base->op_actions[TGSI_OPCODE_I2D].emit = i2d_emit;
1366 bld_base->op_actions[TGSI_OPCODE_U2D].emit = u2d_emit;
1368 bld_base->op_actions[TGSI_OPCODE_DMAD].emit = dmad_emit;
1370 bld_base->op_actions[TGSI_OPCODE_DRCP].emit = drcp_emit;
1371 bld_base->op_actions[TGSI_OPCODE_DFRAC].emit = dfrac_emit;
1373 bld_base->op_actions[TGSI_OPCODE_U64MUL].emit = u64mul_emit;
1375 bld_base->op_actions[TGSI_OPCODE_F2I64].emit = f2i64_emit;
1376 bld_base->op_actions[TGSI_OPCODE_F2U64].emit = f2u64_emit;
1378 bld_base->op_actions[TGSI_OPCODE_D2I64].emit = f2i64_emit;
1379 bld_base->op_actions[TGSI_OPCODE_D2U64].emit = f2u64_emit;
1381 bld_base->op_actions[TGSI_OPCODE_I2I64].emit = i2i64_emit;
1382 bld_base->op_actions[TGSI_OPCODE_U2I64].emit = u2i64_emit;
1384 bld_base->op_actions[TGSI_OPCODE_I642F].emit = i642f_emit;
1385 bld_base->op_actions[TGSI_OPCODE_U642F].emit = u642f_emit;
1387 bld_base->op_actions[TGSI_OPCODE_I642F].emit = i642f_emit;
1388 bld_base->op_actions[TGSI_OPCODE_U642F].emit = u642f_emit;
1390 bld_base->op_actions[TGSI_OPCODE_I642D].emit = i642d_emit;
1391 bld_base->op_actions[TGSI_OPCODE_U642D].emit = u642d_emit;
1395 /* CPU Only default actions */
1397 /* These actions are CPU only, because they could potentially output SSE
1401 /* TGSI_OPCODE_ADD (CPU Only) */
1404 const struct lp_build_tgsi_action * action,
1405 struct lp_build_tgsi_context * bld_base,
1406 struct lp_build_emit_data * emit_data)
1408 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
1409 emit_data->args[0], emit_data->args[1]);
1412 /* TGSI_OPCODE_AND (CPU Only) */
1415 const struct lp_build_tgsi_action * action,
1416 struct lp_build_tgsi_context * bld_base,
1417 struct lp_build_emit_data * emit_data)
1419 emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
1420 emit_data->args[0], emit_data->args[1]);
1423 /* TGSI_OPCODE_ARL (CPU Only) */
1426 const struct lp_build_tgsi_action * action,
1427 struct lp_build_tgsi_context * bld_base,
1428 struct lp_build_emit_data * emit_data)
1431 tmp = lp_build_floor(&bld_base->base,
1432 emit_data->args[0]);
1433 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
1434 bld_base->uint_bld.vec_type, "");
1437 /* TGSI_OPCODE_ARR (CPU Only) */
1440 const struct lp_build_tgsi_action * action,
1441 struct lp_build_tgsi_context * bld_base,
1442 struct lp_build_emit_data * emit_data)
1444 emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
1447 /* TGSI_OPCODE_CEIL (CPU Only) */
1450 const struct lp_build_tgsi_action * action,
1451 struct lp_build_tgsi_context * bld_base,
1452 struct lp_build_emit_data * emit_data)
1454 emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
1455 emit_data->args[0]);
1458 /* TGSI_OPCODE_CMP (CPU Only) */
1461 const struct lp_build_tgsi_action * action,
1462 struct lp_build_tgsi_context * bld_base,
1463 struct lp_build_emit_data * emit_data)
1465 LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
1466 emit_data->args[0], bld_base->base.zero);
1467 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1468 cond, emit_data->args[1], emit_data->args[2]);
1471 /* TGSI_OPCODE_UCMP (CPU Only) */
1474 const struct lp_build_tgsi_action * action,
1475 struct lp_build_tgsi_context * bld_base,
1476 struct lp_build_emit_data * emit_data)
1478 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1479 struct lp_build_context *uint_bld = &bld_base->uint_bld;
1480 LLVMValueRef unsigned_cond =
1481 LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, "");
1482 LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL,
1485 emit_data->output[emit_data->chan] =
1486 lp_build_select(&bld_base->base,
1487 cond, emit_data->args[1], emit_data->args[2]);
1490 /* TGSI_OPCODE_COS (CPU Only) */
1493 const struct lp_build_tgsi_action * action,
1494 struct lp_build_tgsi_context * bld_base,
1495 struct lp_build_emit_data * emit_data)
1497 emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
1498 emit_data->args[0]);
1501 /* TGSI_OPCODE_DIV (CPU Only) */
1504 const struct lp_build_tgsi_action * action,
1505 struct lp_build_tgsi_context * bld_base,
1506 struct lp_build_emit_data * emit_data)
1508 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
1509 emit_data->args[0], emit_data->args[1]);
1512 /* TGSI_OPCODE_EX2 (CPU Only) */
1515 const struct lp_build_tgsi_action * action,
1516 struct lp_build_tgsi_context * bld_base,
1517 struct lp_build_emit_data * emit_data)
1519 emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
1520 emit_data->args[0]);
1523 /* TGSI_OPCODE_F2I (CPU Only) */
1526 const struct lp_build_tgsi_action * action,
1527 struct lp_build_tgsi_context * bld_base,
1528 struct lp_build_emit_data * emit_data)
1530 emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1531 emit_data->args[0]);
1534 /* TGSI_OPCODE_FSET Helper (CPU Only) */
1537 const struct lp_build_tgsi_action * action,
1538 struct lp_build_tgsi_context * bld_base,
1539 struct lp_build_emit_data * emit_data,
1544 if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1545 cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1546 emit_data->args[0], emit_data->args[1]);
1549 cond = lp_build_cmp(&bld_base->base, pipe_func,
1550 emit_data->args[0], emit_data->args[1]);
1553 emit_data->output[emit_data->chan] = cond;
1557 /* TGSI_OPCODE_FSEQ (CPU Only) */
1560 const struct lp_build_tgsi_action * action,
1561 struct lp_build_tgsi_context * bld_base,
1562 struct lp_build_emit_data * emit_data)
1564 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1567 /* TGSI_OPCODE_ISGE (CPU Only) */
1570 const struct lp_build_tgsi_action * action,
1571 struct lp_build_tgsi_context * bld_base,
1572 struct lp_build_emit_data * emit_data)
1574 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1577 /* TGSI_OPCODE_ISLT (CPU Only) */
1580 const struct lp_build_tgsi_action * action,
1581 struct lp_build_tgsi_context * bld_base,
1582 struct lp_build_emit_data * emit_data)
1584 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1587 /* TGSI_OPCODE_USNE (CPU Only) */
1591 const struct lp_build_tgsi_action * action,
1592 struct lp_build_tgsi_context * bld_base,
1593 struct lp_build_emit_data * emit_data)
1595 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1598 /* TGSI_OPCODE_FLR (CPU Only) */
1602 const struct lp_build_tgsi_action * action,
1603 struct lp_build_tgsi_context * bld_base,
1604 struct lp_build_emit_data * emit_data)
1606 emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
1607 emit_data->args[0]);
1610 /* TGSI_OPCODE_I2F (CPU Only) */
1613 const struct lp_build_tgsi_action * action,
1614 struct lp_build_tgsi_context * bld_base,
1615 struct lp_build_emit_data * emit_data)
1617 emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1618 emit_data->args[0]);
1621 /* TGSI_OPCODE_IABS (CPU Only) */
1624 const struct lp_build_tgsi_action * action,
1625 struct lp_build_tgsi_context * bld_base,
1626 struct lp_build_emit_data * emit_data)
1628 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1629 emit_data->args[0]);
1632 /* TGSI_OPCODE_IDIV (CPU Only) */
1635 const struct lp_build_tgsi_action * action,
1636 struct lp_build_tgsi_context * bld_base,
1637 struct lp_build_emit_data * emit_data)
1639 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1640 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1641 PIPE_FUNC_EQUAL, emit_data->args[1],
1642 bld_base->uint_bld.zero);
1643 /* We want to make sure that we never divide/mod by zero to not
1644 * generate sigfpe. We don't want to crash just because the
1645 * shader is doing something weird. */
1646 LLVMValueRef divisor = LLVMBuildOr(builder,
1648 emit_data->args[1], "");
1649 LLVMValueRef result = lp_build_div(&bld_base->int_bld,
1650 emit_data->args[0], divisor);
1651 LLVMValueRef not_div_mask = LLVMBuildNot(builder,
1653 /* idiv by zero doesn't have a guaranteed return value chose 0 for now. */
1654 emit_data->output[emit_data->chan] = LLVMBuildAnd(builder,
1659 /* TGSI_OPCODE_INEG (CPU Only) */
1662 const struct lp_build_tgsi_action * action,
1663 struct lp_build_tgsi_context * bld_base,
1664 struct lp_build_emit_data * emit_data)
1666 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld,
1667 bld_base->int_bld.zero,
1668 emit_data->args[0]);
1671 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1674 const struct lp_build_tgsi_action * action,
1675 struct lp_build_tgsi_context * bld_base,
1676 struct lp_build_emit_data * emit_data,
1679 LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1680 emit_data->args[0], emit_data->args[1]);
1681 emit_data->output[emit_data->chan] = cond;
1684 /* TGSI_OPCODE_IMAX (CPU Only) */
1687 const struct lp_build_tgsi_action * action,
1688 struct lp_build_tgsi_context * bld_base,
1689 struct lp_build_emit_data * emit_data)
1691 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1692 emit_data->args[0], emit_data->args[1]);
1695 /* TGSI_OPCODE_IMIN (CPU Only) */
1698 const struct lp_build_tgsi_action * action,
1699 struct lp_build_tgsi_context * bld_base,
1700 struct lp_build_emit_data * emit_data)
1702 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1703 emit_data->args[0], emit_data->args[1]);
1706 /* TGSI_OPCODE_ISGE (CPU Only) */
1709 const struct lp_build_tgsi_action * action,
1710 struct lp_build_tgsi_context * bld_base,
1711 struct lp_build_emit_data * emit_data)
1713 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1716 /* TGSI_OPCODE_ISHR (CPU Only) */
1719 const struct lp_build_tgsi_action * action,
1720 struct lp_build_tgsi_context * bld_base,
1721 struct lp_build_emit_data * emit_data)
1723 struct lp_build_context *int_bld = &bld_base->int_bld;
1724 LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type,
1725 int_bld->type.width - 1);
1726 LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask);
1727 emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0],
1731 /* TGSI_OPCODE_ISLT (CPU Only) */
1734 const struct lp_build_tgsi_action * action,
1735 struct lp_build_tgsi_context * bld_base,
1736 struct lp_build_emit_data * emit_data)
1738 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1742 /* TGSI_OPCODE_ISSG (CPU Only) */
1745 const struct lp_build_tgsi_action * action,
1746 struct lp_build_tgsi_context * bld_base,
1747 struct lp_build_emit_data * emit_data)
1749 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1750 emit_data->args[0]);
1753 /* TGSI_OPCODE_LG2 (CPU Only) */
1756 const struct lp_build_tgsi_action * action,
1757 struct lp_build_tgsi_context * bld_base,
1758 struct lp_build_emit_data * emit_data)
1760 emit_data->output[emit_data->chan] = lp_build_log2_safe(&bld_base->base,
1761 emit_data->args[0]);
1764 /* TGSI_OPCODE_LOG (CPU Only) */
1767 const struct lp_build_tgsi_action * action,
1768 struct lp_build_tgsi_context * bld_base,
1769 struct lp_build_emit_data * emit_data)
1771 LLVMValueRef p_floor_log2;
1773 LLVMValueRef p_log2;
1774 LLVMValueRef src0 = emit_data->args[0];
1776 lp_build_log2_approx(&bld_base->base, src0,
1777 &p_exp, &p_floor_log2, &p_log2, FALSE);
1779 emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1781 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1784 emit_data->output[TGSI_CHAN_Z] = p_log2;
1786 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1790 /* TGSI_OPCODE_MAD (CPU Only) */
1794 const struct lp_build_tgsi_action * action,
1795 struct lp_build_tgsi_context * bld_base,
1796 struct lp_build_emit_data * emit_data)
1798 emit_data->output[emit_data->chan] =
1799 lp_build_mad(&bld_base->base,
1800 emit_data->args[0], emit_data->args[1], emit_data->args[2]);
1803 /* TGSI_OPCODE_MAX (CPU Only) */
1807 const struct lp_build_tgsi_action * action,
1808 struct lp_build_tgsi_context * bld_base,
1809 struct lp_build_emit_data * emit_data)
1811 emit_data->output[emit_data->chan] =
1812 lp_build_max_ext(&bld_base->base,
1813 emit_data->args[0], emit_data->args[1],
1814 GALLIVM_NAN_RETURN_OTHER);
1817 /* TGSI_OPCODE_MIN (CPU Only) */
1820 const struct lp_build_tgsi_action * action,
1821 struct lp_build_tgsi_context * bld_base,
1822 struct lp_build_emit_data * emit_data)
1824 emit_data->output[emit_data->chan] =
1825 lp_build_min_ext(&bld_base->base,
1826 emit_data->args[0], emit_data->args[1],
1827 GALLIVM_NAN_RETURN_OTHER);
1830 /* TGSI_OPCODE_MOD (CPU Only) */
1833 const struct lp_build_tgsi_action * action,
1834 struct lp_build_tgsi_context * bld_base,
1835 struct lp_build_emit_data * emit_data)
1837 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1838 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1839 PIPE_FUNC_EQUAL, emit_data->args[1],
1840 bld_base->uint_bld.zero);
1841 /* We want to make sure that we never divide/mod by zero to not
1842 * generate sigfpe. We don't want to crash just because the
1843 * shader is doing something weird. */
1844 LLVMValueRef divisor = LLVMBuildOr(builder,
1846 emit_data->args[1], "");
1847 LLVMValueRef result = lp_build_mod(&bld_base->int_bld,
1848 emit_data->args[0], divisor);
1849 /* umod by zero doesn't have a guaranteed return value chose -1 for now. */
1850 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1855 /* TGSI_OPCODE_NOT */
1858 const struct lp_build_tgsi_action * action,
1859 struct lp_build_tgsi_context * bld_base,
1860 struct lp_build_emit_data * emit_data)
1862 emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld,
1863 emit_data->args[0]);
1866 /* TGSI_OPCODE_OR (CPU Only) */
1869 const struct lp_build_tgsi_action * action,
1870 struct lp_build_tgsi_context * bld_base,
1871 struct lp_build_emit_data * emit_data)
1873 emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld,
1874 emit_data->args[0], emit_data->args[1]);
1877 /* TGSI_OPCODE_POW (CPU Only) */
1880 const struct lp_build_tgsi_action * action,
1881 struct lp_build_tgsi_context * bld_base,
1882 struct lp_build_emit_data * emit_data)
1884 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1885 emit_data->args[0], emit_data->args[1]);
1889 /* TGSI_OPCODE_RCP (CPU Only) */
1893 const struct lp_build_tgsi_action * action,
1894 struct lp_build_tgsi_context * bld_base,
1895 struct lp_build_emit_data * emit_data)
1897 emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1898 emit_data->args[0]);
1901 /* Reciprical squareroot (CPU Only) */
1903 recip_sqrt_emit_cpu(
1904 const struct lp_build_tgsi_action * action,
1905 struct lp_build_tgsi_context * bld_base,
1906 struct lp_build_emit_data * emit_data)
1908 emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1909 emit_data->args[0]);
1914 const struct lp_build_tgsi_action * action,
1915 struct lp_build_tgsi_context * bld_base,
1916 struct lp_build_emit_data * emit_data)
1918 emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base,
1919 emit_data->args[0]);
1923 /* TGSI_OPCODE_ROUND (CPU Only) */
1926 const struct lp_build_tgsi_action * action,
1927 struct lp_build_tgsi_context * bld_base,
1928 struct lp_build_emit_data * emit_data)
1930 emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1931 emit_data->args[0]);
1934 /* TGSI_OPCODE_SET Helper (CPU Only) */
1938 const struct lp_build_tgsi_action * action,
1939 struct lp_build_tgsi_context * bld_base,
1940 struct lp_build_emit_data * emit_data,
1945 if (pipe_func != PIPE_FUNC_NOTEQUAL) {
1946 cond = lp_build_cmp_ordered(&bld_base->base, pipe_func,
1947 emit_data->args[0], emit_data->args[1]);
1950 cond = lp_build_cmp(&bld_base->base, pipe_func,
1951 emit_data->args[0], emit_data->args[1]);
1954 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1957 bld_base->base.zero);
1960 /* TGSI_OPCODE_SEQ (CPU Only) */
1964 const struct lp_build_tgsi_action * action,
1965 struct lp_build_tgsi_context * bld_base,
1966 struct lp_build_emit_data * emit_data)
1968 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1971 /* TGSI_OPCODE_SGE (CPU Only) */
1974 const struct lp_build_tgsi_action * action,
1975 struct lp_build_tgsi_context * bld_base,
1976 struct lp_build_emit_data * emit_data)
1978 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1981 /* TGSI_OPCODE_SGT (CPU Only)*/
1985 const struct lp_build_tgsi_action * action,
1986 struct lp_build_tgsi_context * bld_base,
1987 struct lp_build_emit_data * emit_data)
1989 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1992 /* TGSI_OPCODE_SHL (CPU Only) */
1995 const struct lp_build_tgsi_action * action,
1996 struct lp_build_tgsi_context * bld_base,
1997 struct lp_build_emit_data * emit_data)
1999 struct lp_build_context *uint_bld = &bld_base->uint_bld;
2000 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2001 uint_bld->type.width - 1);
2002 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2003 emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0],
2007 /* TGSI_OPCODE_SIN (CPU Only) */
2010 const struct lp_build_tgsi_action * action,
2011 struct lp_build_tgsi_context * bld_base,
2012 struct lp_build_emit_data * emit_data)
2014 emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base,
2015 emit_data->args[0]);
2018 /* TGSI_OPCODE_SLE (CPU Only) */
2021 const struct lp_build_tgsi_action * action,
2022 struct lp_build_tgsi_context * bld_base,
2023 struct lp_build_emit_data * emit_data)
2025 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
2028 /* TGSI_OPCODE_SLT (CPU Only) */
2031 const struct lp_build_tgsi_action * action,
2032 struct lp_build_tgsi_context * bld_base,
2033 struct lp_build_emit_data * emit_data)
2035 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2038 /* TGSI_OPCODE_SNE (CPU Only) */
2042 const struct lp_build_tgsi_action * action,
2043 struct lp_build_tgsi_context * bld_base,
2044 struct lp_build_emit_data * emit_data)
2046 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2049 /* TGSI_OPCODE_SSG (CPU Only) */
2053 const struct lp_build_tgsi_action * action,
2054 struct lp_build_tgsi_context * bld_base,
2055 struct lp_build_emit_data * emit_data)
2057 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
2058 emit_data->args[0]);
2061 /* TGSI_OPCODE_TRUNC (CPU Only) */
2065 const struct lp_build_tgsi_action * action,
2066 struct lp_build_tgsi_context * bld_base,
2067 struct lp_build_emit_data * emit_data)
2069 emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
2070 emit_data->args[0]);
2073 /* TGSI_OPCODE_UADD (CPU Only) */
2076 const struct lp_build_tgsi_action * action,
2077 struct lp_build_tgsi_context * bld_base,
2078 struct lp_build_emit_data * emit_data)
2080 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
2081 emit_data->args[0], emit_data->args[1]);
2084 /* TGSI_OPCODE_UDIV (CPU Only) */
2087 const struct lp_build_tgsi_action * action,
2088 struct lp_build_tgsi_context * bld_base,
2089 struct lp_build_emit_data * emit_data)
2092 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2093 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
2094 PIPE_FUNC_EQUAL, emit_data->args[1],
2095 bld_base->uint_bld.zero);
2096 /* We want to make sure that we never divide/mod by zero to not
2097 * generate sigfpe. We don't want to crash just because the
2098 * shader is doing something weird. */
2099 LLVMValueRef divisor = LLVMBuildOr(builder,
2101 emit_data->args[1], "");
2102 LLVMValueRef result = lp_build_div(&bld_base->uint_bld,
2103 emit_data->args[0], divisor);
2104 /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */
2105 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
2110 /* TGSI_OPCODE_UMAX (CPU Only) */
2113 const struct lp_build_tgsi_action * action,
2114 struct lp_build_tgsi_context * bld_base,
2115 struct lp_build_emit_data * emit_data)
2117 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
2118 emit_data->args[0], emit_data->args[1]);
2121 /* TGSI_OPCODE_UMIN (CPU Only) */
2124 const struct lp_build_tgsi_action * action,
2125 struct lp_build_tgsi_context * bld_base,
2126 struct lp_build_emit_data * emit_data)
2128 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld,
2129 emit_data->args[0], emit_data->args[1]);
2132 /* TGSI_OPCODE_UMOD (CPU Only) */
2135 const struct lp_build_tgsi_action * action,
2136 struct lp_build_tgsi_context * bld_base,
2137 struct lp_build_emit_data * emit_data)
2139 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2140 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
2141 PIPE_FUNC_EQUAL, emit_data->args[1],
2142 bld_base->uint_bld.zero);
2143 /* We want to make sure that we never divide/mod by zero to not
2144 * generate sigfpe. We don't want to crash just because the
2145 * shader is doing something weird. */
2146 LLVMValueRef divisor = LLVMBuildOr(builder,
2148 emit_data->args[1], "");
2149 LLVMValueRef result = lp_build_mod(&bld_base->uint_bld,
2150 emit_data->args[0], divisor);
2151 /* umod by zero is guaranteed to return 0xffffffff */
2152 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
2157 /* TGSI_OPCODE_USET Helper (CPU Only) */
2160 const struct lp_build_tgsi_action * action,
2161 struct lp_build_tgsi_context * bld_base,
2162 struct lp_build_emit_data * emit_data,
2165 LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
2166 emit_data->args[0], emit_data->args[1]);
2167 emit_data->output[emit_data->chan] = cond;
2171 /* TGSI_OPCODE_USEQ (CPU Only) */
2174 const struct lp_build_tgsi_action * action,
2175 struct lp_build_tgsi_context * bld_base,
2176 struct lp_build_emit_data * emit_data)
2178 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2181 /* TGSI_OPCODE_ISGE (CPU Only) */
2184 const struct lp_build_tgsi_action * action,
2185 struct lp_build_tgsi_context * bld_base,
2186 struct lp_build_emit_data * emit_data)
2188 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2191 /* TGSI_OPCODE_USHR (CPU Only) */
2194 const struct lp_build_tgsi_action * action,
2195 struct lp_build_tgsi_context * bld_base,
2196 struct lp_build_emit_data * emit_data)
2198 struct lp_build_context *uint_bld = &bld_base->uint_bld;
2199 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2200 uint_bld->type.width - 1);
2201 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2202 emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0],
2206 /* TGSI_OPCODE_ISLT (CPU Only) */
2209 const struct lp_build_tgsi_action * action,
2210 struct lp_build_tgsi_context * bld_base,
2211 struct lp_build_emit_data * emit_data)
2213 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2216 /* TGSI_OPCODE_USNE (CPU Only) */
2220 const struct lp_build_tgsi_action * action,
2221 struct lp_build_tgsi_context * bld_base,
2222 struct lp_build_emit_data * emit_data)
2224 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2227 /* TGSI_OPCODE_XOR */
2230 const struct lp_build_tgsi_action * action,
2231 struct lp_build_tgsi_context * bld_base,
2232 struct lp_build_emit_data * emit_data)
2234 emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
2236 emit_data->args[1]);
2239 /* TGSI_OPCODE_DABS (CPU Only) */
2242 const struct lp_build_tgsi_action * action,
2243 struct lp_build_tgsi_context * bld_base,
2244 struct lp_build_emit_data * emit_data)
2246 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->dbl_bld,
2247 emit_data->args[0]);
2250 /* TGSI_OPCODE_DNEG (CPU Only) */
2253 const struct lp_build_tgsi_action * action,
2254 struct lp_build_tgsi_context * bld_base,
2255 struct lp_build_emit_data * emit_data)
2257 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->dbl_bld,
2258 bld_base->dbl_bld.zero,
2259 emit_data->args[0]);
2262 /* TGSI_OPCODE_DSET Helper (CPU Only) */
2265 const struct lp_build_tgsi_action * action,
2266 struct lp_build_tgsi_context * bld_base,
2267 struct lp_build_emit_data * emit_data,
2270 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2271 LLVMValueRef cond = lp_build_cmp(&bld_base->dbl_bld, pipe_func,
2272 emit_data->args[0], emit_data->args[1]);
2273 /* arguments were 64 bit but store as 32 bit */
2274 cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
2275 emit_data->output[emit_data->chan] = cond;
2278 /* TGSI_OPCODE_DSEQ (CPU Only) */
2281 const struct lp_build_tgsi_action * action,
2282 struct lp_build_tgsi_context * bld_base,
2283 struct lp_build_emit_data * emit_data)
2285 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2288 /* TGSI_OPCODE_DSGE (CPU Only) */
2291 const struct lp_build_tgsi_action * action,
2292 struct lp_build_tgsi_context * bld_base,
2293 struct lp_build_emit_data * emit_data)
2295 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2298 /* TGSI_OPCODE_DSLT (CPU Only) */
2301 const struct lp_build_tgsi_action * action,
2302 struct lp_build_tgsi_context * bld_base,
2303 struct lp_build_emit_data * emit_data)
2305 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2308 /* TGSI_OPCODE_DSNE (CPU Only) */
2311 const struct lp_build_tgsi_action * action,
2312 struct lp_build_tgsi_context * bld_base,
2313 struct lp_build_emit_data * emit_data)
2315 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2318 /* Double Reciprocal squareroot (CPU Only) */
2320 drecip_sqrt_emit_cpu(
2321 const struct lp_build_tgsi_action * action,
2322 struct lp_build_tgsi_context * bld_base,
2323 struct lp_build_emit_data * emit_data)
2325 emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->dbl_bld,
2326 emit_data->args[0]);
2329 /* Double Squareroot (CPU Only) */
2332 const struct lp_build_tgsi_action * action,
2333 struct lp_build_tgsi_context * bld_base,
2334 struct lp_build_emit_data * emit_data)
2336 emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->dbl_bld,
2337 emit_data->args[0]);
2342 const struct lp_build_tgsi_action * action,
2343 struct lp_build_tgsi_context * bld_base,
2344 struct lp_build_emit_data * emit_data)
2346 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int64_bld,
2347 emit_data->args[0]);
2352 const struct lp_build_tgsi_action * action,
2353 struct lp_build_tgsi_context * bld_base,
2354 struct lp_build_emit_data * emit_data)
2356 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int64_bld,
2357 emit_data->args[0]);
2362 const struct lp_build_tgsi_action * action,
2363 struct lp_build_tgsi_context * bld_base,
2364 struct lp_build_emit_data * emit_data)
2366 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int64_bld,
2367 bld_base->int64_bld.zero,
2368 emit_data->args[0]);
2373 const struct lp_build_tgsi_action * action,
2374 struct lp_build_tgsi_context * bld_base,
2375 struct lp_build_emit_data * emit_data,
2378 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2379 LLVMValueRef cond = lp_build_cmp(&bld_base->uint64_bld, pipe_func,
2380 emit_data->args[0], emit_data->args[1]);
2381 /* arguments were 64 bit but store as 32 bit */
2382 cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
2383 emit_data->output[emit_data->chan] = cond;
2388 const struct lp_build_tgsi_action * action,
2389 struct lp_build_tgsi_context * bld_base,
2390 struct lp_build_emit_data * emit_data)
2392 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
2397 const struct lp_build_tgsi_action * action,
2398 struct lp_build_tgsi_context * bld_base,
2399 struct lp_build_emit_data * emit_data)
2401 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
2406 const struct lp_build_tgsi_action * action,
2407 struct lp_build_tgsi_context * bld_base,
2408 struct lp_build_emit_data * emit_data)
2410 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2415 const struct lp_build_tgsi_action * action,
2416 struct lp_build_tgsi_context * bld_base,
2417 struct lp_build_emit_data * emit_data)
2419 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2424 const struct lp_build_tgsi_action * action,
2425 struct lp_build_tgsi_context * bld_base,
2426 struct lp_build_emit_data * emit_data,
2429 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
2430 LLVMValueRef cond = lp_build_cmp(&bld_base->int64_bld, pipe_func,
2431 emit_data->args[0], emit_data->args[1]);
2432 /* arguments were 64 bit but store as 32 bit */
2433 cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, "");
2434 emit_data->output[emit_data->chan] = cond;
2439 const struct lp_build_tgsi_action * action,
2440 struct lp_build_tgsi_context * bld_base,
2441 struct lp_build_emit_data * emit_data)
2443 i64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
2448 const struct lp_build_tgsi_action * action,
2449 struct lp_build_tgsi_context * bld_base,
2450 struct lp_build_emit_data * emit_data)
2452 i64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
2457 const struct lp_build_tgsi_action * action,
2458 struct lp_build_tgsi_context * bld_base,
2459 struct lp_build_emit_data * emit_data)
2461 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint64_bld,
2462 emit_data->args[0], emit_data->args[1]);
2467 const struct lp_build_tgsi_action * action,
2468 struct lp_build_tgsi_context * bld_base,
2469 struct lp_build_emit_data * emit_data)
2471 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint64_bld,
2472 emit_data->args[0], emit_data->args[1]);
2477 const struct lp_build_tgsi_action * action,
2478 struct lp_build_tgsi_context * bld_base,
2479 struct lp_build_emit_data * emit_data)
2481 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int64_bld,
2482 emit_data->args[0], emit_data->args[1]);
2487 const struct lp_build_tgsi_action * action,
2488 struct lp_build_tgsi_context * bld_base,
2489 struct lp_build_emit_data * emit_data)
2491 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int64_bld,
2492 emit_data->args[0], emit_data->args[1]);
2497 const struct lp_build_tgsi_action * action,
2498 struct lp_build_tgsi_context * bld_base,
2499 struct lp_build_emit_data * emit_data)
2501 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint64_bld,
2502 emit_data->args[0], emit_data->args[1]);
2507 const struct lp_build_tgsi_action * action,
2508 struct lp_build_tgsi_context * bld_base,
2509 struct lp_build_emit_data * emit_data)
2511 struct lp_build_context *uint_bld = &bld_base->uint64_bld;
2512 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2513 uint_bld->type.width - 1);
2514 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2515 emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0],
2521 const struct lp_build_tgsi_action * action,
2522 struct lp_build_tgsi_context * bld_base,
2523 struct lp_build_emit_data * emit_data)
2525 struct lp_build_context *int_bld = &bld_base->int64_bld;
2526 LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type,
2527 int_bld->type.width - 1);
2528 LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask);
2529 emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0],
2535 const struct lp_build_tgsi_action * action,
2536 struct lp_build_tgsi_context * bld_base,
2537 struct lp_build_emit_data * emit_data)
2539 struct lp_build_context *uint_bld = &bld_base->uint64_bld;
2540 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type,
2541 uint_bld->type.width - 1);
2542 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask);
2543 emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0],
2548 lp_set_default_actions_cpu(
2549 struct lp_build_tgsi_context * bld_base)
2551 lp_set_default_actions(bld_base);
2552 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
2553 bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
2554 bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
2555 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
2556 bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
2557 bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
2558 bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
2559 bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
2560 bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
2561 bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
2562 bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
2563 bld_base->op_actions[TGSI_OPCODE_FSEQ].emit = fseq_emit_cpu;
2564 bld_base->op_actions[TGSI_OPCODE_FSGE].emit = fsge_emit_cpu;
2565 bld_base->op_actions[TGSI_OPCODE_FSLT].emit = fslt_emit_cpu;
2566 bld_base->op_actions[TGSI_OPCODE_FSNE].emit = fsne_emit_cpu;
2568 bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
2569 bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
2570 bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
2571 bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
2572 bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
2573 bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
2574 bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
2575 bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
2576 bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
2577 bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
2578 bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit_cpu;
2579 bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit_cpu;
2581 bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
2582 bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
2583 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit_cpu;
2584 bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
2585 bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
2586 bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
2587 bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
2588 bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
2589 bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
2590 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
2591 bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
2592 bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
2593 bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
2594 bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
2595 bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
2596 bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
2597 bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
2598 bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
2599 bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
2600 bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
2601 bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
2603 bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
2604 bld_base->sqrt_action.emit = sqrt_emit_cpu;
2606 bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
2607 bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu;
2608 bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
2609 bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
2610 bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
2611 bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
2612 bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
2613 bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
2614 bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
2615 bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
2616 bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
2618 bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
2620 bld_base->op_actions[TGSI_OPCODE_DABS].emit = dabs_emit_cpu;
2621 bld_base->op_actions[TGSI_OPCODE_DNEG].emit = dneg_emit_cpu;
2622 bld_base->op_actions[TGSI_OPCODE_DSEQ].emit = dseq_emit_cpu;
2623 bld_base->op_actions[TGSI_OPCODE_DSGE].emit = dsge_emit_cpu;
2624 bld_base->op_actions[TGSI_OPCODE_DSLT].emit = dslt_emit_cpu;
2625 bld_base->op_actions[TGSI_OPCODE_DSNE].emit = dsne_emit_cpu;
2627 bld_base->op_actions[TGSI_OPCODE_DRSQ].emit = drecip_sqrt_emit_cpu;
2628 bld_base->op_actions[TGSI_OPCODE_DSQRT].emit = dsqrt_emit_cpu;
2630 bld_base->op_actions[TGSI_OPCODE_I64ABS].emit = i64abs_emit_cpu;
2631 bld_base->op_actions[TGSI_OPCODE_I64SSG].emit = i64ssg_emit_cpu;
2632 bld_base->op_actions[TGSI_OPCODE_I64NEG].emit = i64neg_emit_cpu;
2634 bld_base->op_actions[TGSI_OPCODE_U64SEQ].emit = u64seq_emit_cpu;
2635 bld_base->op_actions[TGSI_OPCODE_U64SNE].emit = u64sne_emit_cpu;
2636 bld_base->op_actions[TGSI_OPCODE_U64SLT].emit = u64slt_emit_cpu;
2637 bld_base->op_actions[TGSI_OPCODE_U64SGE].emit = u64sge_emit_cpu;
2638 bld_base->op_actions[TGSI_OPCODE_I64SLT].emit = i64slt_emit_cpu;
2639 bld_base->op_actions[TGSI_OPCODE_I64SGE].emit = i64sge_emit_cpu;
2641 bld_base->op_actions[TGSI_OPCODE_U64MIN].emit = u64min_emit_cpu;
2642 bld_base->op_actions[TGSI_OPCODE_U64MAX].emit = u64max_emit_cpu;
2643 bld_base->op_actions[TGSI_OPCODE_I64MIN].emit = i64min_emit_cpu;
2644 bld_base->op_actions[TGSI_OPCODE_I64MAX].emit = i64max_emit_cpu;
2646 bld_base->op_actions[TGSI_OPCODE_U64ADD].emit = u64add_emit_cpu;
2647 bld_base->op_actions[TGSI_OPCODE_U64MOD].emit = u64mod_emit_cpu;
2648 bld_base->op_actions[TGSI_OPCODE_I64MOD].emit = i64mod_emit_cpu;
2649 bld_base->op_actions[TGSI_OPCODE_U64DIV].emit = u64div_emit_cpu;
2650 bld_base->op_actions[TGSI_OPCODE_I64DIV].emit = i64div_emit_cpu;
2652 bld_base->op_actions[TGSI_OPCODE_U64SHL].emit = u64shl_emit_cpu;
2653 bld_base->op_actions[TGSI_OPCODE_I64SHR].emit = i64shr_emit_cpu;
2654 bld_base->op_actions[TGSI_OPCODE_U64SHR].emit = u64shr_emit_cpu;