projects / mesa.git / blob
? search:


c71c1f111bd073c6aa40863657cc429bbae14413
[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 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
18 * of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
23 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 *
28 **************************************************************************/
29
30 /**
31 * @file
32 * TGSI to LLVM IR translation.
33 *
34 * @author Jose Fonseca <jfonseca@vmware.com>
35 * @author Tom Stellard <thomas.stellard@amd.com>
36 *
37 * Based on tgsi_sse2.c code written by Michal Krol, Keith Whitwell,
38 * Brian Paul, and others.
39 */
40
41
42 #include "lp_bld_tgsi_action.h"
43
44 #include "lp_bld_tgsi.h"
45 #include "lp_bld_arit.h"
46 #include "lp_bld_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_KIL */
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_KILP */
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 emit_data->args[0] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
637 emit_data->args[0]);
638 if (bld_base->rsq_action.emit) {
639 bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
640 } else {
641 emit_data->output[emit_data->chan] = bld_base->base.undef;
642 }
643 }
644
645 const struct lp_build_tgsi_action rsq_action = {
646 scalar_unary_fetch_args, /* fetch_args */
647 rsq_emit /* emit */
648
649 };
650
651 /* TGSI_OPCODE_SQRT */
652
653 static void
654 sqrt_emit(
655 const struct lp_build_tgsi_action * action,
656 struct lp_build_tgsi_context * bld_base,
657 struct lp_build_emit_data * emit_data)
658 {
659 if (bld_base->sqrt_action.emit) {
660 bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data);
661 } else {
662 emit_data->output[emit_data->chan] = bld_base->base.undef;
663 }
664 }
665
666 const struct lp_build_tgsi_action sqrt_action = {
667 scalar_unary_fetch_args, /* fetch_args */
668 sqrt_emit /* emit */
669 };
670
671 /* TGSI_OPCODE_SCS */
672 static void
673 scs_emit(
674 const struct lp_build_tgsi_action * action,
675 struct lp_build_tgsi_context * bld_base,
676 struct lp_build_emit_data * emit_data)
677 {
678 /* dst.x */
679 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
680 TGSI_OPCODE_COS, emit_data->args[0]);
681 /* dst.y */
682 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
683 TGSI_OPCODE_SIN, emit_data->args[0]);
684 /* dst.z */
685 emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
686
687 /* dst.w */
688 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
689 }
690
691 const struct lp_build_tgsi_action scs_action = {
692 scalar_unary_fetch_args, /* fetch_args */
693 scs_emit /* emit */
694 };
695
696 /* TGSI_OPCODE_SFL */
697
698 static void
699 sfl_emit(
700 const struct lp_build_tgsi_action * action,
701 struct lp_build_tgsi_context * bld_base,
702 struct lp_build_emit_data * emit_data)
703 {
704 emit_data->output[emit_data->chan] = bld_base->base.zero;
705 }
706
707 /* TGSI_OPCODE_STR */
708
709 static void
710 str_emit(
711 const struct lp_build_tgsi_action * action,
712 struct lp_build_tgsi_context * bld_base,
713 struct lp_build_emit_data * emit_data)
714 {
715 emit_data->output[emit_data->chan] = bld_base->base.one;
716 }
717
718 /* TGSI_OPCODE_SUB */
719 static void
720 sub_emit(
721 const struct lp_build_tgsi_action * action,
722 struct lp_build_tgsi_context * bld_base,
723 struct lp_build_emit_data * emit_data)
724 {
725 emit_data->output[emit_data->chan] = LLVMBuildFSub(
726 bld_base->base.gallivm->builder,
727 emit_data->args[0],
728 emit_data->args[1], "");
729 }
730
731 /* TGSI_OPCODE_U2F */
732 static void
733 u2f_emit(
734 const struct lp_build_tgsi_action * action,
735 struct lp_build_tgsi_context * bld_base,
736 struct lp_build_emit_data * emit_data)
737 {
738 emit_data->output[emit_data->chan] = LLVMBuildUIToFP(bld_base->base.gallivm->builder,
739 emit_data->args[0],
740 bld_base->base.vec_type, "");
741 }
742
743 static void
744 umad_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 LLVMValueRef tmp;
750 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
751 emit_data->args[0],
752 emit_data->args[1]);
753 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
754 TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
755 }
756
757 /* TGSI_OPCODE_UMUL */
758 static void
759 umul_emit(
760 const struct lp_build_tgsi_action * action,
761 struct lp_build_tgsi_context * bld_base,
762 struct lp_build_emit_data * emit_data)
763 {
764 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
765 emit_data->args[0], emit_data->args[1]);
766 }
767
768 /* TGSI_OPCODE_MAX */
769 static void fmax_emit(
770 const struct lp_build_tgsi_action * action,
771 struct lp_build_tgsi_context * bld_base,
772 struct lp_build_emit_data * emit_data)
773 {
774 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
775 emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
776 LLVMBuildFCmp(builder, LLVMRealUGE,
777 emit_data->args[0], emit_data->args[1], ""),
778 emit_data->args[0], emit_data->args[1], "");
779 }
780
781 /* TGSI_OPCODE_MIN */
782 static void fmin_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 emit_data->output[emit_data->chan] = LLVMBuildSelect(builder,
789 LLVMBuildFCmp(builder, LLVMRealUGE,
790 emit_data->args[0], emit_data->args[1], ""),
791 emit_data->args[1], emit_data->args[0], "");
792 }
793
794 /* TGSI_OPCODE_XPD */
795
796 static void
797 xpd_fetch_args(
798 struct lp_build_tgsi_context * bld_base,
799 struct lp_build_emit_data * emit_data)
800 {
801 dp_fetch_args(bld_base, emit_data, 3);
802 }
803
804 /**
805 * (a * b) - (c * d)
806 */
807 static LLVMValueRef
808 xpd_helper(
809 struct lp_build_tgsi_context * bld_base,
810 LLVMValueRef a,
811 LLVMValueRef b,
812 LLVMValueRef c,
813 LLVMValueRef d)
814 {
815 LLVMValueRef tmp0, tmp1;
816
817 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
818 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
819
820 return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
821 }
822
823 static void
824 xpd_emit(
825 const struct lp_build_tgsi_action * action,
826 struct lp_build_tgsi_context * bld_base,
827 struct lp_build_emit_data * emit_data)
828 {
829 emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
830 emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
831 emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
832
833 emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
834 emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
835 emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
836
837 emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
838 emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
839 emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
840
841 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
842 }
843
844 const struct lp_build_tgsi_action xpd_action = {
845 xpd_fetch_args, /* fetch_args */
846 xpd_emit /* emit */
847 };
848
849 void
850 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
851 {
852 bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
853 bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
854 bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
855 bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
856 bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
857 bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
858 bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
859 bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
860 bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
861 bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
862 bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action;
863 bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
864 bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
865 bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
866
867 bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args;
868 bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
869 bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
870 bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
871 bld_base->op_actions[TGSI_OPCODE_KIL].fetch_args = kil_fetch_args;
872 bld_base->op_actions[TGSI_OPCODE_KILP].fetch_args = kilp_fetch_args;
873 bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
874 bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
875 bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
876
877 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
878 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
879 bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
880 bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
881 bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
882 bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
883 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
884 bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
885 bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
886 bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
887 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
888 bld_base->op_actions[TGSI_OPCODE_SFL].emit = sfl_emit;
889 bld_base->op_actions[TGSI_OPCODE_STR].emit = str_emit;
890 bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
891
892 bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
893 bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
894 bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
895 bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
896
897 bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit;
898 bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit;
899 }
900
901 /* CPU Only default actions */
902
903 /* These actions are CPU only, because they could potentially output SSE
904 * intrinsics.
905 */
906
907 /* TGSI_OPCODE_ABS (CPU Only)*/
908
909 static void
910 abs_emit_cpu(
911 const struct lp_build_tgsi_action * action,
912 struct lp_build_tgsi_context * bld_base,
913 struct lp_build_emit_data * emit_data)
914 {
915 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base,
916 emit_data->args[0]);
917 }
918
919 /* TGSI_OPCODE_ADD (CPU Only) */
920 static void
921 add_emit_cpu(
922 const struct lp_build_tgsi_action * action,
923 struct lp_build_tgsi_context * bld_base,
924 struct lp_build_emit_data * emit_data)
925 {
926 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
927 emit_data->args[0], emit_data->args[1]);
928 }
929
930 /* TGSI_OPCODE_AND (CPU Only) */
931 static void
932 and_emit_cpu(
933 const struct lp_build_tgsi_action * action,
934 struct lp_build_tgsi_context * bld_base,
935 struct lp_build_emit_data * emit_data)
936 {
937 emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
938 emit_data->args[0], emit_data->args[1]);
939 }
940
941 /* TGSI_OPCODE_ARL (CPU Only) */
942 static void
943 arl_emit_cpu(
944 const struct lp_build_tgsi_action * action,
945 struct lp_build_tgsi_context * bld_base,
946 struct lp_build_emit_data * emit_data)
947 {
948 LLVMValueRef tmp;
949 tmp = lp_build_floor(&bld_base->base,
950 emit_data->args[0]);
951 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
952 bld_base->uint_bld.vec_type, "");
953 }
954
955 /* TGSI_OPCODE_ARR (CPU Only) */
956 static void
957 arr_emit_cpu(
958 const struct lp_build_tgsi_action * action,
959 struct lp_build_tgsi_context * bld_base,
960 struct lp_build_emit_data * emit_data)
961 {
962 emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
963 }
964
965 /* TGSI_OPCODE_CEIL (CPU Only) */
966 static void
967 ceil_emit_cpu(
968 const struct lp_build_tgsi_action * action,
969 struct lp_build_tgsi_context * bld_base,
970 struct lp_build_emit_data * emit_data)
971 {
972 emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
973 emit_data->args[0]);
974 }
975
976 /* TGSI_OPCODE_CMP (CPU Only) */
977 static void
978 cmp_emit_cpu(
979 const struct lp_build_tgsi_action * action,
980 struct lp_build_tgsi_context * bld_base,
981 struct lp_build_emit_data * emit_data)
982 {
983 LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
984 emit_data->args[0], bld_base->base.zero);
985 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
986 cond, emit_data->args[1], emit_data->args[2]);
987 }
988
989 /* TGSI_OPCODE_UCMP (CPU Only) */
990 static void
991 ucmp_emit_cpu(
992 const struct lp_build_tgsi_action * action,
993 struct lp_build_tgsi_context * bld_base,
994 struct lp_build_emit_data * emit_data)
995 {
996 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
997 struct lp_build_context *uint_bld = &bld_base->uint_bld;
998 LLVMValueRef unsigned_cond =
999 LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, "");
1000 LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL,
1001 unsigned_cond,
1002 uint_bld->zero);
1003 emit_data->output[emit_data->chan] =
1004 lp_build_select(&bld_base->base,
1005 cond, emit_data->args[1], emit_data->args[2]);
1006 }
1007
1008
1009 /* TGSI_OPCODE_CND (CPU Only) */
1010 static void
1011 cnd_emit_cpu(
1012 const struct lp_build_tgsi_action * action,
1013 struct lp_build_tgsi_context * bld_base,
1014 struct lp_build_emit_data * emit_data)
1015 {
1016 LLVMValueRef half, tmp;
1017 half = lp_build_const_vec(bld_base->base.gallivm, bld_base->base.type, 0.5);
1018 tmp = lp_build_cmp(&bld_base->base, PIPE_FUNC_GREATER,
1019 emit_data->args[2], half);
1020 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1021 tmp,
1022 emit_data->args[0],
1023 emit_data->args[1]);
1024 }
1025
1026 /* TGSI_OPCODE_COS (CPU Only) */
1027 static void
1028 cos_emit_cpu(
1029 const struct lp_build_tgsi_action * action,
1030 struct lp_build_tgsi_context * bld_base,
1031 struct lp_build_emit_data * emit_data)
1032 {
1033 emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
1034 emit_data->args[0]);
1035 }
1036
1037 /* TGSI_OPCODE_DIV (CPU Only) */
1038 static void
1039 div_emit_cpu(
1040 const struct lp_build_tgsi_action * action,
1041 struct lp_build_tgsi_context * bld_base,
1042 struct lp_build_emit_data * emit_data)
1043 {
1044 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base,
1045 emit_data->args[0], emit_data->args[1]);
1046 }
1047
1048 /* TGSI_OPCODE_EX2 (CPU Only) */
1049 static void
1050 ex2_emit_cpu(
1051 const struct lp_build_tgsi_action * action,
1052 struct lp_build_tgsi_context * bld_base,
1053 struct lp_build_emit_data * emit_data)
1054 {
1055 emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
1056 emit_data->args[0]);
1057 }
1058
1059 /* TGSI_OPCODE_EXP (CPU Only) */
1060 static void
1061 exp_emit_cpu(
1062 const struct lp_build_tgsi_action * action,
1063 struct lp_build_tgsi_context * bld_base,
1064 struct lp_build_emit_data * emit_data)
1065 {
1066 lp_build_exp2_approx(&bld_base->base, emit_data->args[0],
1067 &emit_data->output[TGSI_CHAN_X],
1068 &emit_data->output[TGSI_CHAN_Y],
1069 &emit_data->output[TGSI_CHAN_Z]);
1070 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1071 }
1072
1073 /* TGSI_OPCODE_F2I (CPU Only) */
1074 static void
1075 f2i_emit_cpu(
1076 const struct lp_build_tgsi_action * action,
1077 struct lp_build_tgsi_context * bld_base,
1078 struct lp_build_emit_data * emit_data)
1079 {
1080 emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1081 emit_data->args[0]);
1082 }
1083
1084 /* TGSI_OPCODE_F2U (CPU Only) */
1085 static void
1086 f2u_emit_cpu(
1087 const struct lp_build_tgsi_action * action,
1088 struct lp_build_tgsi_context * bld_base,
1089 struct lp_build_emit_data * emit_data)
1090 {
1091 /* FIXME: implement and use lp_build_utrunc() */
1092 emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1093 emit_data->args[0]);
1094 }
1095
1096 /* TGSI_OPCODE_FLR (CPU Only) */
1097
1098 static void
1099 flr_emit_cpu(
1100 const struct lp_build_tgsi_action * action,
1101 struct lp_build_tgsi_context * bld_base,
1102 struct lp_build_emit_data * emit_data)
1103 {
1104 emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
1105 emit_data->args[0]);
1106 }
1107
1108 /* TGSI_OPCODE_I2F (CPU Only) */
1109 static void
1110 i2f_emit_cpu(
1111 const struct lp_build_tgsi_action * action,
1112 struct lp_build_tgsi_context * bld_base,
1113 struct lp_build_emit_data * emit_data)
1114 {
1115 emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1116 emit_data->args[0]);
1117 }
1118
1119 /* TGSI_OPCODE_IABS (CPU Only) */
1120 static void
1121 iabs_emit_cpu(
1122 const struct lp_build_tgsi_action * action,
1123 struct lp_build_tgsi_context * bld_base,
1124 struct lp_build_emit_data * emit_data)
1125 {
1126 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1127 emit_data->args[0]);
1128 }
1129
1130 /* TGSI_OPCODE_IDIV (CPU Only) */
1131 static void
1132 idiv_emit_cpu(
1133 const struct lp_build_tgsi_action * action,
1134 struct lp_build_tgsi_context * bld_base,
1135 struct lp_build_emit_data * emit_data)
1136 {
1137 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->int_bld,
1138 emit_data->args[0], emit_data->args[1]);
1139 }
1140
1141 /* TGSI_OPCODE_INEG (CPU Only) */
1142 static void
1143 ineg_emit_cpu(
1144 const struct lp_build_tgsi_action * action,
1145 struct lp_build_tgsi_context * bld_base,
1146 struct lp_build_emit_data * emit_data)
1147 {
1148 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld,
1149 bld_base->int_bld.zero,
1150 emit_data->args[0]);
1151 }
1152
1153 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1154 static void
1155 iset_emit_cpu(
1156 const struct lp_build_tgsi_action * action,
1157 struct lp_build_tgsi_context * bld_base,
1158 struct lp_build_emit_data * emit_data,
1159 unsigned pipe_func)
1160 {
1161 LLVMValueRef nz = lp_build_const_vec(bld_base->base.gallivm,
1162 bld_base->int_bld.type, ~0U);
1163 LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1164 emit_data->args[0], emit_data->args[1]);
1165 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->int_bld,
1166 cond,
1167 nz,
1168 bld_base->int_bld.zero);
1169 }
1170
1171 /* TGSI_OPCODE_IMAX (CPU Only) */
1172 static void
1173 imax_emit_cpu(
1174 const struct lp_build_tgsi_action * action,
1175 struct lp_build_tgsi_context * bld_base,
1176 struct lp_build_emit_data * emit_data)
1177 {
1178 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1179 emit_data->args[0], emit_data->args[1]);
1180 }
1181
1182 /* TGSI_OPCODE_IMIN (CPU Only) */
1183 static void
1184 imin_emit_cpu(
1185 const struct lp_build_tgsi_action * action,
1186 struct lp_build_tgsi_context * bld_base,
1187 struct lp_build_emit_data * emit_data)
1188 {
1189 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1190 emit_data->args[0], emit_data->args[1]);
1191 }
1192
1193 /* TGSI_OPCODE_ISGE (CPU Only) */
1194 static void
1195 isge_emit_cpu(
1196 const struct lp_build_tgsi_action * action,
1197 struct lp_build_tgsi_context * bld_base,
1198 struct lp_build_emit_data * emit_data)
1199 {
1200 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1201 }
1202
1203 /* TGSI_OPCODE_ISHR (CPU Only) */
1204 static void
1205 ishr_emit_cpu(
1206 const struct lp_build_tgsi_action * action,
1207 struct lp_build_tgsi_context * bld_base,
1208 struct lp_build_emit_data * emit_data)
1209 {
1210 emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->int_bld,
1211 emit_data->args[0], emit_data->args[1]);
1212 }
1213
1214 /* TGSI_OPCODE_ISLT (CPU Only) */
1215 static void
1216 islt_emit_cpu(
1217 const struct lp_build_tgsi_action * action,
1218 struct lp_build_tgsi_context * bld_base,
1219 struct lp_build_emit_data * emit_data)
1220 {
1221 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1222 }
1223
1224
1225 /* TGSI_OPCODE_ISSG (CPU Only) */
1226 static void
1227 issg_emit_cpu(
1228 const struct lp_build_tgsi_action * action,
1229 struct lp_build_tgsi_context * bld_base,
1230 struct lp_build_emit_data * emit_data)
1231 {
1232 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1233 emit_data->args[0]);
1234 }
1235
1236 /* TGSI_OPCODE_LG2 (CPU Only) */
1237 static void
1238 lg2_emit_cpu(
1239 const struct lp_build_tgsi_action * action,
1240 struct lp_build_tgsi_context * bld_base,
1241 struct lp_build_emit_data * emit_data)
1242 {
1243 emit_data->output[emit_data->chan] = lp_build_log2(&bld_base->base,
1244 emit_data->args[0]);
1245 }
1246
1247 /* TGSI_OPCODE_LOG (CPU Only) */
1248 static void
1249 log_emit_cpu(
1250 const struct lp_build_tgsi_action * action,
1251 struct lp_build_tgsi_context * bld_base,
1252 struct lp_build_emit_data * emit_data)
1253 {
1254 LLVMValueRef p_floor_log2;
1255 LLVMValueRef p_exp;
1256 LLVMValueRef p_log2;
1257 LLVMValueRef src0 = emit_data->args[0];
1258
1259 lp_build_log2_approx(&bld_base->base, src0,
1260 &p_exp, &p_floor_log2, &p_log2);
1261
1262 emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1263
1264 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1265 TGSI_OPCODE_DIV,
1266 src0, p_exp);
1267 emit_data->output[TGSI_CHAN_Z] = p_log2;
1268
1269 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1270
1271 }
1272
1273 /* TGSI_OPCODE_MAX (CPU Only) */
1274
1275 static void
1276 max_emit_cpu(
1277 const struct lp_build_tgsi_action * action,
1278 struct lp_build_tgsi_context * bld_base,
1279 struct lp_build_emit_data * emit_data)
1280 {
1281 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->base,
1282 emit_data->args[0], emit_data->args[1]);
1283 }
1284
1285 /* TGSI_OPCODE_MIN (CPU Only) */
1286 static void
1287 min_emit_cpu(
1288 const struct lp_build_tgsi_action * action,
1289 struct lp_build_tgsi_context * bld_base,
1290 struct lp_build_emit_data * emit_data)
1291 {
1292 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->base,
1293 emit_data->args[0], emit_data->args[1]);
1294 }
1295
1296 /* TGSI_OPCODE_MOD (CPU Only) */
1297 static void
1298 mod_emit_cpu(
1299 const struct lp_build_tgsi_action * action,
1300 struct lp_build_tgsi_context * bld_base,
1301 struct lp_build_emit_data * emit_data)
1302 {
1303 emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->int_bld,
1304 emit_data->args[0], emit_data->args[1]);
1305 }
1306
1307 /* TGSI_OPCODE_NOT */
1308 static void
1309 not_emit_cpu(
1310 const struct lp_build_tgsi_action * action,
1311 struct lp_build_tgsi_context * bld_base,
1312 struct lp_build_emit_data * emit_data)
1313 {
1314 emit_data->output[emit_data->chan] = lp_build_not(&bld_base->base,
1315 emit_data->args[0]);
1316 }
1317
1318 /* TGSI_OPCODE_OR (CPU Only) */
1319 static void
1320 or_emit_cpu(
1321 const struct lp_build_tgsi_action * action,
1322 struct lp_build_tgsi_context * bld_base,
1323 struct lp_build_emit_data * emit_data)
1324 {
1325 emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld,
1326 emit_data->args[0], emit_data->args[1]);
1327 }
1328
1329 /* TGSI_OPCODE_POW (CPU Only) */
1330 static void
1331 pow_emit_cpu(
1332 const struct lp_build_tgsi_action * action,
1333 struct lp_build_tgsi_context * bld_base,
1334 struct lp_build_emit_data * emit_data)
1335 {
1336 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1337 emit_data->args[0], emit_data->args[1]);
1338 }
1339
1340
1341 /* TGSI_OPCODE_RCP (CPU Only) */
1342
1343 static void
1344 rcp_emit_cpu(
1345 const struct lp_build_tgsi_action * action,
1346 struct lp_build_tgsi_context * bld_base,
1347 struct lp_build_emit_data * emit_data)
1348 {
1349 emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1350 emit_data->args[0]);
1351 }
1352
1353 /* Reciprical squareroot (CPU Only) */
1354
1355 /* This is not the same as TGSI_OPCODE_RSQ, which requres the argument to be
1356 * greater than or equal to 0 */
1357 static void
1358 recip_sqrt_emit_cpu(
1359 const struct lp_build_tgsi_action * action,
1360 struct lp_build_tgsi_context * bld_base,
1361 struct lp_build_emit_data * emit_data)
1362 {
1363 emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1364 emit_data->args[0]);
1365 }
1366
1367 static void
1368 sqrt_emit_cpu(
1369 const struct lp_build_tgsi_action * action,
1370 struct lp_build_tgsi_context * bld_base,
1371 struct lp_build_emit_data * emit_data)
1372 {
1373 emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base,
1374 emit_data->args[0]);
1375 }
1376
1377
1378 /* TGSI_OPCODE_ROUND (CPU Only) */
1379 static void
1380 round_emit_cpu(
1381 const struct lp_build_tgsi_action * action,
1382 struct lp_build_tgsi_context * bld_base,
1383 struct lp_build_emit_data * emit_data)
1384 {
1385 emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1386 emit_data->args[0]);
1387 }
1388
1389 /* TGSI_OPCODE_SET Helper (CPU Only) */
1390
1391 static void
1392 set_emit_cpu(
1393 const struct lp_build_tgsi_action * action,
1394 struct lp_build_tgsi_context * bld_base,
1395 struct lp_build_emit_data * emit_data,
1396 unsigned pipe_func)
1397 {
1398 LLVMValueRef cond = lp_build_cmp(&bld_base->base, pipe_func,
1399 emit_data->args[0], emit_data->args[1]);
1400 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1401 cond,
1402 bld_base->base.one,
1403 bld_base->base.zero);
1404 }
1405
1406 /* TGSI_OPCODE_SEQ (CPU Only) */
1407
1408 static void
1409 seq_emit_cpu(
1410 const struct lp_build_tgsi_action * action,
1411 struct lp_build_tgsi_context * bld_base,
1412 struct lp_build_emit_data * emit_data)
1413 {
1414 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1415 }
1416
1417 /* TGSI_OPCODE_SGE (CPU Only) */
1418 static void
1419 sge_emit_cpu(
1420 const struct lp_build_tgsi_action * action,
1421 struct lp_build_tgsi_context * bld_base,
1422 struct lp_build_emit_data * emit_data)
1423 {
1424 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1425 }
1426
1427 /* TGSI_OPCODE_SGT (CPU Only)*/
1428
1429 static void
1430 sgt_emit_cpu(
1431 const struct lp_build_tgsi_action * action,
1432 struct lp_build_tgsi_context * bld_base,
1433 struct lp_build_emit_data * emit_data)
1434 {
1435 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1436 }
1437
1438 /* TGSI_OPCODE_SHL (CPU Only) */
1439 static void
1440 shl_emit_cpu(
1441 const struct lp_build_tgsi_action * action,
1442 struct lp_build_tgsi_context * bld_base,
1443 struct lp_build_emit_data * emit_data)
1444 {
1445 emit_data->output[emit_data->chan] = lp_build_shl(&bld_base->uint_bld,
1446 emit_data->args[0], emit_data->args[1]);
1447 }
1448
1449 /* TGSI_OPCODE_SIN (CPU Only) */
1450 static void
1451 sin_emit_cpu(
1452 const struct lp_build_tgsi_action * action,
1453 struct lp_build_tgsi_context * bld_base,
1454 struct lp_build_emit_data * emit_data)
1455 {
1456 emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base,
1457 emit_data->args[0]);
1458 }
1459
1460 /* TGSI_OPCODE_SLE (CPU Only) */
1461 static void
1462 sle_emit_cpu(
1463 const struct lp_build_tgsi_action * action,
1464 struct lp_build_tgsi_context * bld_base,
1465 struct lp_build_emit_data * emit_data)
1466 {
1467 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
1468 }
1469
1470 /* TGSI_OPCODE_SLT (CPU Only) */
1471 static void
1472 slt_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 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1478 }
1479
1480 /* TGSI_OPCODE_SNE (CPU Only) */
1481
1482 static void
1483 sne_emit_cpu(
1484 const struct lp_build_tgsi_action * action,
1485 struct lp_build_tgsi_context * bld_base,
1486 struct lp_build_emit_data * emit_data)
1487 {
1488 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1489 }
1490
1491 /* TGSI_OPCODE_SSG (CPU Only) */
1492
1493 static void
1494 ssg_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_sgn(&bld_base->base,
1500 emit_data->args[0]);
1501 }
1502
1503 /* TGSI_OPCODE_SUB (CPU Only) */
1504
1505 static void
1506 sub_emit_cpu(
1507 const struct lp_build_tgsi_action * action,
1508 struct lp_build_tgsi_context * bld_base,
1509 struct lp_build_emit_data * emit_data)
1510 {
1511 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
1512 emit_data->args[0],
1513 emit_data->args[1]);
1514 }
1515
1516 /* TGSI_OPCODE_TRUNC (CPU Only) */
1517
1518 static void
1519 trunc_emit_cpu(
1520 const struct lp_build_tgsi_action * action,
1521 struct lp_build_tgsi_context * bld_base,
1522 struct lp_build_emit_data * emit_data)
1523 {
1524 emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
1525 emit_data->args[0]);
1526 }
1527
1528 /* TGSI_OPCODE_UADD (CPU Only) */
1529 static void
1530 uadd_emit_cpu(
1531 const struct lp_build_tgsi_action * action,
1532 struct lp_build_tgsi_context * bld_base,
1533 struct lp_build_emit_data * emit_data)
1534 {
1535 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
1536 emit_data->args[0], emit_data->args[1]);
1537 }
1538
1539 /* TGSI_OPCODE_UDIV (CPU Only) */
1540 static void
1541 udiv_emit_cpu(
1542 const struct lp_build_tgsi_action * action,
1543 struct lp_build_tgsi_context * bld_base,
1544 struct lp_build_emit_data * emit_data)
1545 {
1546
1547 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1548 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1549 PIPE_FUNC_EQUAL, emit_data->args[1],
1550 bld_base->uint_bld.zero);
1551 /* We want to make sure that we never divide/mod by zero to not
1552 * generate sigfpe. We don't want to crash just because the
1553 * shader is doing something weird. */
1554 LLVMValueRef divisor = LLVMBuildOr(builder,
1555 div_mask,
1556 emit_data->args[1], "");
1557 LLVMValueRef result = lp_build_div(&bld_base->uint_bld,
1558 emit_data->args[0], divisor);
1559 /* udiv by zero is guaranteed to return 0xffffffff */
1560 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1561 div_mask,
1562 result, "");
1563 }
1564
1565 /* TGSI_OPCODE_UMAX (CPU Only) */
1566 static void
1567 umax_emit_cpu(
1568 const struct lp_build_tgsi_action * action,
1569 struct lp_build_tgsi_context * bld_base,
1570 struct lp_build_emit_data * emit_data)
1571 {
1572 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
1573 emit_data->args[0], emit_data->args[1]);
1574 }
1575
1576 /* TGSI_OPCODE_UMIN (CPU Only) */
1577 static void
1578 umin_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_min(&bld_base->uint_bld,
1584 emit_data->args[0], emit_data->args[1]);
1585 }
1586
1587 /* TGSI_OPCODE_UMOD (CPU Only) */
1588 static void
1589 umod_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 LLVMBuilderRef builder = bld_base->base.gallivm->builder;
1595 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld,
1596 PIPE_FUNC_EQUAL, emit_data->args[1],
1597 bld_base->uint_bld.zero);
1598 /* We want to make sure that we never divide/mod by zero to not
1599 * generate sigfpe. We don't want to crash just because the
1600 * shader is doing something weird. */
1601 LLVMValueRef divisor = LLVMBuildOr(builder,
1602 div_mask,
1603 emit_data->args[1], "");
1604 LLVMValueRef result = lp_build_mod(&bld_base->uint_bld,
1605 emit_data->args[0], divisor);
1606 /* umod by zero is guaranteed to return 0xffffffff */
1607 emit_data->output[emit_data->chan] = LLVMBuildOr(builder,
1608 div_mask,
1609 result, "");
1610 }
1611
1612 /* TGSI_OPCODE_USET Helper (CPU Only) */
1613 static void
1614 uset_emit_cpu(
1615 const struct lp_build_tgsi_action * action,
1616 struct lp_build_tgsi_context * bld_base,
1617 struct lp_build_emit_data * emit_data,
1618 unsigned pipe_func)
1619 {
1620 LLVMValueRef nz = lp_build_const_vec(bld_base->base.gallivm,
1621 bld_base->uint_bld.type, ~0U);
1622 LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
1623 emit_data->args[0], emit_data->args[1]);
1624 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->uint_bld,
1625 cond,
1626 nz,
1627 bld_base->uint_bld.zero);
1628 }
1629
1630
1631 /* TGSI_OPCODE_USEQ (CPU Only) */
1632 static void
1633 useq_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 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1639 }
1640
1641 /* TGSI_OPCODE_ISGE (CPU Only) */
1642 static void
1643 usge_emit_cpu(
1644 const struct lp_build_tgsi_action * action,
1645 struct lp_build_tgsi_context * bld_base,
1646 struct lp_build_emit_data * emit_data)
1647 {
1648 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1649 }
1650
1651 /* TGSI_OPCODE_USHR (CPU Only) */
1652 static void
1653 ushr_emit_cpu(
1654 const struct lp_build_tgsi_action * action,
1655 struct lp_build_tgsi_context * bld_base,
1656 struct lp_build_emit_data * emit_data)
1657 {
1658 emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->uint_bld,
1659 emit_data->args[0], emit_data->args[1]);
1660 }
1661
1662 /* TGSI_OPCODE_ISLT (CPU Only) */
1663 static void
1664 uslt_emit_cpu(
1665 const struct lp_build_tgsi_action * action,
1666 struct lp_build_tgsi_context * bld_base,
1667 struct lp_build_emit_data * emit_data)
1668 {
1669 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1670 }
1671
1672 /* TGSI_OPCODE_USNE (CPU Only) */
1673
1674 static void
1675 usne_emit_cpu(
1676 const struct lp_build_tgsi_action * action,
1677 struct lp_build_tgsi_context * bld_base,
1678 struct lp_build_emit_data * emit_data)
1679 {
1680 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1681 }
1682
1683 /* TGSI_OPCODE_XOR */
1684 static void
1685 xor_emit_cpu(
1686 const struct lp_build_tgsi_action * action,
1687 struct lp_build_tgsi_context * bld_base,
1688 struct lp_build_emit_data * emit_data)
1689 {
1690 emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
1691 emit_data->args[0],
1692 emit_data->args[1]);
1693 }
1694
1695 void
1696 lp_set_default_actions_cpu(
1697 struct lp_build_tgsi_context * bld_base)
1698 {
1699 lp_set_default_actions(bld_base);
1700 bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
1701 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
1702 bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
1703 bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
1704 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
1705 bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
1706 bld_base->op_actions[TGSI_OPCODE_CND].emit = cnd_emit_cpu;
1707 bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
1708 bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
1709 bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
1710 bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
1711 bld_base->op_actions[TGSI_OPCODE_EXP].emit = exp_emit_cpu;
1712 bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
1713 bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit_cpu;
1714 bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
1715
1716 bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
1717 bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
1718 bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
1719 bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
1720 bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
1721 bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
1722 bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
1723 bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
1724 bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
1725 bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
1726
1727 bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
1728 bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
1729 bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
1730 bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
1731 bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
1732 bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
1733 bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
1734 bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
1735 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
1736 bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
1737 bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
1738 bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
1739 bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
1740 bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
1741 bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
1742 bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
1743 bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
1744 bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
1745 bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
1746 bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
1747 bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
1748
1749 bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
1750 bld_base->sqrt_action.emit = sqrt_emit_cpu;
1751
1752 bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
1753 bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu;
1754 bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
1755 bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
1756 bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
1757 bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
1758 bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
1759 bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
1760 bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
1761 bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
1762 bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
1763
1764 bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
1765
1766 }