projects / mesa.git / blob
? search:


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