projects / mesa.git / blob
? search:


cd57faef0c07f83fa073f008c26ed49ed06ac263
[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] = lp_build_mul(&bld_base->base,
584 emit_data->args[0], emit_data->args[1]);
585 }
586
587 /*.TGSI_OPCODE_DIV.*/
588 static void fdiv_emit(
589 const struct lp_build_tgsi_action * action,
590 struct lp_build_tgsi_context * bld_base,
591 struct lp_build_emit_data * emit_data)
592 {
593 emit_data->output[emit_data->chan] = LLVMBuildFDiv(
594 bld_base->base.gallivm->builder,
595 emit_data->args[0], emit_data->args[1], "");
596 }
597
598 /*.TGSI_OPCODE_RCP.*/
599 static void rcp_emit(
600 const struct lp_build_tgsi_action * action,
601 struct lp_build_tgsi_context * bld_base,
602 struct lp_build_emit_data * emit_data)
603 {
604 LLVMValueRef one;
605 one = lp_build_const_float(bld_base->base.gallivm, 1.0f);
606 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
607 TGSI_OPCODE_DIV, one, emit_data->args[0]);
608 }
609
610 /* TGSI_OPCODE_POW */
611
612 static void
613 pow_emit(
614 const struct lp_build_tgsi_action * action,
615 struct lp_build_tgsi_context * bld_base,
616 struct lp_build_emit_data * emit_data)
617 {
618 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
619 emit_data->args[0], emit_data->args[1]);
620 }
621
622 static struct lp_build_tgsi_action pow_action = {
623 scalar_binary_fetch_args, /* fetch_args */
624 pow_emit /* emit */
625 };
626
627 /* TGSI_OPCODE_RSQ */
628
629 static void
630 rsq_emit(
631 const struct lp_build_tgsi_action * action,
632 struct lp_build_tgsi_context * bld_base,
633 struct lp_build_emit_data * emit_data)
634 {
635 emit_data->args[0] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS,
636 emit_data->args[0]);
637 if (bld_base->rsq_action.emit) {
638 bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data);
639 } else {
640 emit_data->output[emit_data->chan] = bld_base->base.undef;
641 }
642 }
643
644 const struct lp_build_tgsi_action rsq_action = {
645 scalar_unary_fetch_args, /* fetch_args */
646 rsq_emit /* emit */
647
648 };
649
650 /* TGSI_OPCODE_SCS */
651 static void
652 scs_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 /* dst.x */
658 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base,
659 TGSI_OPCODE_COS, emit_data->args[0]);
660 /* dst.y */
661 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base,
662 TGSI_OPCODE_SIN, emit_data->args[0]);
663 /* dst.z */
664 emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero;
665
666 /* dst.w */
667 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
668 }
669
670 const struct lp_build_tgsi_action scs_action = {
671 scalar_unary_fetch_args, /* fetch_args */
672 scs_emit /* emit */
673 };
674
675 /* TGSI_OPCODE_SFL */
676
677 static void
678 sfl_emit(
679 const struct lp_build_tgsi_action * action,
680 struct lp_build_tgsi_context * bld_base,
681 struct lp_build_emit_data * emit_data)
682 {
683 emit_data->output[emit_data->chan] = bld_base->base.zero;
684 }
685
686 /* TGSI_OPCODE_STR */
687
688 static void
689 str_emit(
690 const struct lp_build_tgsi_action * action,
691 struct lp_build_tgsi_context * bld_base,
692 struct lp_build_emit_data * emit_data)
693 {
694 emit_data->output[emit_data->chan] = bld_base->base.one;
695 }
696
697 /* TGSI_OPCODE_SUB */
698 static void
699 sub_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] = LLVMBuildFSub(
705 bld_base->base.gallivm->builder,
706 emit_data->args[0],
707 emit_data->args[1], "");
708 }
709
710 /* TGSI_OPCODE_U2F */
711 static void
712 u2f_emit(
713 const struct lp_build_tgsi_action * action,
714 struct lp_build_tgsi_context * bld_base,
715 struct lp_build_emit_data * emit_data)
716 {
717 emit_data->output[emit_data->chan] = LLVMBuildUIToFP(bld_base->base.gallivm->builder,
718 emit_data->args[0],
719 bld_base->base.vec_type, "");
720 }
721
722 static void
723 umad_emit(
724 const struct lp_build_tgsi_action * action,
725 struct lp_build_tgsi_context * bld_base,
726 struct lp_build_emit_data * emit_data)
727 {
728 LLVMValueRef tmp;
729 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL,
730 emit_data->args[0],
731 emit_data->args[1]);
732 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base,
733 TGSI_OPCODE_UADD, tmp, emit_data->args[2]);
734 }
735
736 /* TGSI_OPCODE_UMUL */
737 static void
738 umul_emit(
739 const struct lp_build_tgsi_action * action,
740 struct lp_build_tgsi_context * bld_base,
741 struct lp_build_emit_data * emit_data)
742 {
743 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld,
744 emit_data->args[0], emit_data->args[1]);
745 }
746
747 /* TGSI_OPCODE_XPD */
748
749 static void
750 xpd_fetch_args(
751 struct lp_build_tgsi_context * bld_base,
752 struct lp_build_emit_data * emit_data)
753 {
754 dp_fetch_args(bld_base, emit_data, 3);
755 }
756
757 /**
758 * (a * b) - (c * d)
759 */
760 static LLVMValueRef
761 xpd_helper(
762 struct lp_build_tgsi_context * bld_base,
763 LLVMValueRef a,
764 LLVMValueRef b,
765 LLVMValueRef c,
766 LLVMValueRef d)
767 {
768 LLVMValueRef tmp0, tmp1;
769
770 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b);
771 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d);
772
773 return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1);
774 }
775
776 static void
777 xpd_emit(
778 const struct lp_build_tgsi_action * action,
779 struct lp_build_tgsi_context * bld_base,
780 struct lp_build_emit_data * emit_data)
781 {
782 emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base,
783 emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */,
784 emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */);
785
786 emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base,
787 emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */,
788 emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */);
789
790 emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base,
791 emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */,
792 emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */);
793
794 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
795 }
796
797 const struct lp_build_tgsi_action xpd_action = {
798 xpd_fetch_args, /* fetch_args */
799 xpd_emit /* emit */
800 };
801
802 void
803 lp_set_default_actions(struct lp_build_tgsi_context * bld_base)
804 {
805 bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action;
806 bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action;
807 bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action;
808 bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action;
809 bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action;
810 bld_base->op_actions[TGSI_OPCODE_DST] = dst_action;
811 bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action;
812 bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action;
813 bld_base->op_actions[TGSI_OPCODE_LOG] = log_action;
814 bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action;
815 bld_base->op_actions[TGSI_OPCODE_POW] = pow_action;
816 bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action;
817 bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action;
818
819 bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args;
820 bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args;
821 bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args;
822 bld_base->op_actions[TGSI_OPCODE_KIL].fetch_args = kil_fetch_args;
823 bld_base->op_actions[TGSI_OPCODE_KILP].fetch_args = kilp_fetch_args;
824 bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args;
825 bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args;
826 bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args;
827
828 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit;
829 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit;
830 bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit;
831 bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit;
832 bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit;
833 bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit;
834 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit;
835 bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit;
836 bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit;
837 bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit;
838 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit;
839 bld_base->op_actions[TGSI_OPCODE_SFL].emit = sfl_emit;
840 bld_base->op_actions[TGSI_OPCODE_STR].emit = str_emit;
841 bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit;
842
843 bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit;
844 bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit;
845 bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit;
846 bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit;
847 }
848
849 /* CPU Only default actions */
850
851 /* These actions are CPU only, because they could potentially output SSE
852 * intrinsics.
853 */
854
855 /* TGSI_OPCODE_ABS (CPU Only)*/
856
857 static void
858 abs_emit_cpu(
859 const struct lp_build_tgsi_action * action,
860 struct lp_build_tgsi_context * bld_base,
861 struct lp_build_emit_data * emit_data)
862 {
863 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base,
864 emit_data->args[0]);
865 }
866
867 /* TGSI_OPCODE_ADD (CPU Only) */
868 static void
869 add_emit_cpu(
870 const struct lp_build_tgsi_action * action,
871 struct lp_build_tgsi_context * bld_base,
872 struct lp_build_emit_data * emit_data)
873 {
874 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base,
875 emit_data->args[0], emit_data->args[1]);
876 }
877
878 /* TGSI_OPCODE_AND (CPU Only) */
879 static void
880 and_emit_cpu(
881 const struct lp_build_tgsi_action * action,
882 struct lp_build_tgsi_context * bld_base,
883 struct lp_build_emit_data * emit_data)
884 {
885 emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld,
886 emit_data->args[0], emit_data->args[1]);
887 }
888
889 /* TGSI_OPCODE_ARL (CPU Only) */
890 static void
891 arl_emit_cpu(
892 const struct lp_build_tgsi_action * action,
893 struct lp_build_tgsi_context * bld_base,
894 struct lp_build_emit_data * emit_data)
895 {
896 LLVMValueRef tmp;
897 tmp = lp_build_floor(&bld_base->base,
898 emit_data->args[0]);
899 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp,
900 bld_base->uint_bld.vec_type, "");
901 }
902
903 /* TGSI_OPCODE_ARR (CPU Only) */
904 static void
905 arr_emit_cpu(
906 const struct lp_build_tgsi_action * action,
907 struct lp_build_tgsi_context * bld_base,
908 struct lp_build_emit_data * emit_data)
909 {
910 emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]);
911 }
912
913 /* TGSI_OPCODE_CEIL (CPU Only) */
914 static void
915 ceil_emit_cpu(
916 const struct lp_build_tgsi_action * action,
917 struct lp_build_tgsi_context * bld_base,
918 struct lp_build_emit_data * emit_data)
919 {
920 emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base,
921 emit_data->args[0]);
922 }
923
924 /* TGSI_OPCODE_CMP (CPU Only) */
925 static void
926 cmp_emit_cpu(
927 const struct lp_build_tgsi_action * action,
928 struct lp_build_tgsi_context * bld_base,
929 struct lp_build_emit_data * emit_data)
930 {
931 LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS,
932 emit_data->args[0], bld_base->base.zero);
933 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
934 cond, emit_data->args[1], emit_data->args[2]);
935 }
936
937 /* TGSI_OPCODE_CND (CPU Only) */
938 static void
939 cnd_emit_cpu(
940 const struct lp_build_tgsi_action * action,
941 struct lp_build_tgsi_context * bld_base,
942 struct lp_build_emit_data * emit_data)
943 {
944 LLVMValueRef half, tmp;
945 half = lp_build_const_vec(bld_base->base.gallivm, bld_base->base.type, 0.5);
946 tmp = lp_build_cmp(&bld_base->base, PIPE_FUNC_GREATER,
947 emit_data->args[2], half);
948 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
949 tmp,
950 emit_data->args[0],
951 emit_data->args[1]);
952 }
953
954 /* TGSI_OPCODE_COS (CPU Only) */
955 static void
956 cos_emit_cpu(
957 const struct lp_build_tgsi_action * action,
958 struct lp_build_tgsi_context * bld_base,
959 struct lp_build_emit_data * emit_data)
960 {
961 emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base,
962 emit_data->args[0]);
963 }
964
965 /* TGSI_OPCODE_DIV (CPU Only) */
966 static void
967 div_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_div(&bld_base->base,
973 emit_data->args[0], emit_data->args[1]);
974 }
975
976 /* TGSI_OPCODE_EX2 (CPU Only) */
977 static void
978 ex2_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 emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base,
984 emit_data->args[0]);
985 }
986
987 /* TGSI_OPCODE_EXP (CPU Only) */
988 static void
989 exp_emit_cpu(
990 const struct lp_build_tgsi_action * action,
991 struct lp_build_tgsi_context * bld_base,
992 struct lp_build_emit_data * emit_data)
993 {
994 lp_build_exp2_approx(&bld_base->base, emit_data->args[0],
995 &emit_data->output[TGSI_CHAN_X],
996 &emit_data->output[TGSI_CHAN_Y],
997 &emit_data->output[TGSI_CHAN_Z]);
998 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
999 }
1000
1001 /* TGSI_OPCODE_F2I (CPU Only) */
1002 static void
1003 f2i_emit_cpu(
1004 const struct lp_build_tgsi_action * action,
1005 struct lp_build_tgsi_context * bld_base,
1006 struct lp_build_emit_data * emit_data)
1007 {
1008 emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1009 emit_data->args[0]);
1010 }
1011
1012 /* TGSI_OPCODE_F2U (CPU Only) */
1013 static void
1014 f2u_emit_cpu(
1015 const struct lp_build_tgsi_action * action,
1016 struct lp_build_tgsi_context * bld_base,
1017 struct lp_build_emit_data * emit_data)
1018 {
1019 /* FIXME: implement and use lp_build_utrunc() */
1020 emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base,
1021 emit_data->args[0]);
1022 }
1023
1024 /* TGSI_OPCODE_FLR (CPU Only) */
1025
1026 static void
1027 flr_emit_cpu(
1028 const struct lp_build_tgsi_action * action,
1029 struct lp_build_tgsi_context * bld_base,
1030 struct lp_build_emit_data * emit_data)
1031 {
1032 emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base,
1033 emit_data->args[0]);
1034 }
1035
1036 /* TGSI_OPCODE_I2F (CPU Only) */
1037 static void
1038 i2f_emit_cpu(
1039 const struct lp_build_tgsi_action * action,
1040 struct lp_build_tgsi_context * bld_base,
1041 struct lp_build_emit_data * emit_data)
1042 {
1043 emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base,
1044 emit_data->args[0]);
1045 }
1046
1047 /* TGSI_OPCODE_IABS (CPU Only) */
1048 static void
1049 iabs_emit_cpu(
1050 const struct lp_build_tgsi_action * action,
1051 struct lp_build_tgsi_context * bld_base,
1052 struct lp_build_emit_data * emit_data)
1053 {
1054 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld,
1055 emit_data->args[0]);
1056 }
1057
1058 /* TGSI_OPCODE_IDIV (CPU Only) */
1059 static void
1060 idiv_emit_cpu(
1061 const struct lp_build_tgsi_action * action,
1062 struct lp_build_tgsi_context * bld_base,
1063 struct lp_build_emit_data * emit_data)
1064 {
1065 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->int_bld,
1066 emit_data->args[0], emit_data->args[1]);
1067 }
1068
1069 /* TGSI_OPCODE_INEG (CPU Only) */
1070 static void
1071 ineg_emit_cpu(
1072 const struct lp_build_tgsi_action * action,
1073 struct lp_build_tgsi_context * bld_base,
1074 struct lp_build_emit_data * emit_data)
1075 {
1076 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld,
1077 bld_base->int_bld.zero,
1078 emit_data->args[0]);
1079 }
1080
1081 /* TGSI_OPCODE_ISET Helper (CPU Only) */
1082 static void
1083 iset_emit_cpu(
1084 const struct lp_build_tgsi_action * action,
1085 struct lp_build_tgsi_context * bld_base,
1086 struct lp_build_emit_data * emit_data,
1087 unsigned pipe_func)
1088 {
1089 LLVMValueRef nz = lp_build_const_vec(bld_base->base.gallivm,
1090 bld_base->int_bld.type, ~0U);
1091 LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func,
1092 emit_data->args[0], emit_data->args[1]);
1093 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->int_bld,
1094 cond,
1095 nz,
1096 bld_base->int_bld.zero);
1097 }
1098
1099 /* TGSI_OPCODE_IMAX (CPU Only) */
1100 static void
1101 imax_emit_cpu(
1102 const struct lp_build_tgsi_action * action,
1103 struct lp_build_tgsi_context * bld_base,
1104 struct lp_build_emit_data * emit_data)
1105 {
1106 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld,
1107 emit_data->args[0], emit_data->args[1]);
1108 }
1109
1110 /* TGSI_OPCODE_IMIN (CPU Only) */
1111 static void
1112 imin_emit_cpu(
1113 const struct lp_build_tgsi_action * action,
1114 struct lp_build_tgsi_context * bld_base,
1115 struct lp_build_emit_data * emit_data)
1116 {
1117 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld,
1118 emit_data->args[0], emit_data->args[1]);
1119 }
1120
1121 /* TGSI_OPCODE_ISGE (CPU Only) */
1122 static void
1123 isge_emit_cpu(
1124 const struct lp_build_tgsi_action * action,
1125 struct lp_build_tgsi_context * bld_base,
1126 struct lp_build_emit_data * emit_data)
1127 {
1128 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1129 }
1130
1131 /* TGSI_OPCODE_ISHR (CPU Only) */
1132 static void
1133 ishr_emit_cpu(
1134 const struct lp_build_tgsi_action * action,
1135 struct lp_build_tgsi_context * bld_base,
1136 struct lp_build_emit_data * emit_data)
1137 {
1138 emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->int_bld,
1139 emit_data->args[0], emit_data->args[1]);
1140 }
1141
1142 /* TGSI_OPCODE_ISLT (CPU Only) */
1143 static void
1144 islt_emit_cpu(
1145 const struct lp_build_tgsi_action * action,
1146 struct lp_build_tgsi_context * bld_base,
1147 struct lp_build_emit_data * emit_data)
1148 {
1149 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1150 }
1151
1152
1153 /* TGSI_OPCODE_ISSG (CPU Only) */
1154 static void
1155 issg_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 {
1160 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld,
1161 emit_data->args[0]);
1162 }
1163
1164 /* TGSI_OPCODE_LG2 (CPU Only) */
1165 static void
1166 lg2_emit_cpu(
1167 const struct lp_build_tgsi_action * action,
1168 struct lp_build_tgsi_context * bld_base,
1169 struct lp_build_emit_data * emit_data)
1170 {
1171 emit_data->output[emit_data->chan] = lp_build_log2(&bld_base->base,
1172 emit_data->args[0]);
1173 }
1174
1175 /* TGSI_OPCODE_LOG (CPU Only) */
1176 static void
1177 log_emit_cpu(
1178 const struct lp_build_tgsi_action * action,
1179 struct lp_build_tgsi_context * bld_base,
1180 struct lp_build_emit_data * emit_data)
1181 {
1182 LLVMValueRef p_floor_log2;
1183 LLVMValueRef p_exp;
1184 LLVMValueRef p_log2;
1185 LLVMValueRef src0 = emit_data->args[0];
1186
1187 lp_build_log2_approx(&bld_base->base, src0,
1188 &p_exp, &p_floor_log2, &p_log2);
1189
1190 emit_data->output[TGSI_CHAN_X] = p_floor_log2;
1191
1192 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base,
1193 TGSI_OPCODE_DIV,
1194 src0, p_exp);
1195 emit_data->output[TGSI_CHAN_Z] = p_log2;
1196
1197 emit_data->output[TGSI_CHAN_W] = bld_base->base.one;
1198
1199 }
1200
1201 /* TGSI_OPCODE_MAX (CPU Only) */
1202
1203 static void
1204 max_emit_cpu(
1205 const struct lp_build_tgsi_action * action,
1206 struct lp_build_tgsi_context * bld_base,
1207 struct lp_build_emit_data * emit_data)
1208 {
1209 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->base,
1210 emit_data->args[0], emit_data->args[1]);
1211 }
1212
1213 /* TGSI_OPCODE_MIN (CPU Only) */
1214 static void
1215 min_emit_cpu(
1216 const struct lp_build_tgsi_action * action,
1217 struct lp_build_tgsi_context * bld_base,
1218 struct lp_build_emit_data * emit_data)
1219 {
1220 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->base,
1221 emit_data->args[0], emit_data->args[1]);
1222 }
1223
1224 /* TGSI_OPCODE_MOD (CPU Only) */
1225 static void
1226 mod_emit_cpu(
1227 const struct lp_build_tgsi_action * action,
1228 struct lp_build_tgsi_context * bld_base,
1229 struct lp_build_emit_data * emit_data)
1230 {
1231 emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->int_bld,
1232 emit_data->args[0], emit_data->args[1]);
1233 }
1234
1235 /* TGSI_OPCODE_NOT */
1236 static void
1237 not_emit_cpu(
1238 const struct lp_build_tgsi_action * action,
1239 struct lp_build_tgsi_context * bld_base,
1240 struct lp_build_emit_data * emit_data)
1241 {
1242 emit_data->output[emit_data->chan] = lp_build_not(&bld_base->base,
1243 emit_data->args[0]);
1244 }
1245
1246 /* TGSI_OPCODE_OR (CPU Only) */
1247 static void
1248 or_emit_cpu(
1249 const struct lp_build_tgsi_action * action,
1250 struct lp_build_tgsi_context * bld_base,
1251 struct lp_build_emit_data * emit_data)
1252 {
1253 emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld,
1254 emit_data->args[0], emit_data->args[1]);
1255 }
1256
1257 /* TGSI_OPCODE_POW (CPU Only) */
1258 static void
1259 pow_emit_cpu(
1260 const struct lp_build_tgsi_action * action,
1261 struct lp_build_tgsi_context * bld_base,
1262 struct lp_build_emit_data * emit_data)
1263 {
1264 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base,
1265 emit_data->args[0], emit_data->args[1]);
1266 }
1267
1268
1269 /* TGSI_OPCODE_RCP (CPU Only) */
1270
1271 static void
1272 rcp_emit_cpu(
1273 const struct lp_build_tgsi_action * action,
1274 struct lp_build_tgsi_context * bld_base,
1275 struct lp_build_emit_data * emit_data)
1276 {
1277 emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base,
1278 emit_data->args[0]);
1279 }
1280
1281 /* Reciprical squareroot (CPU Only) */
1282
1283 /* This is not the same as TGSI_OPCODE_RSQ, which requres the argument to be
1284 * greater than or equal to 0 */
1285 static void
1286 recip_sqrt_emit_cpu(
1287 const struct lp_build_tgsi_action * action,
1288 struct lp_build_tgsi_context * bld_base,
1289 struct lp_build_emit_data * emit_data)
1290 {
1291 emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base,
1292 emit_data->args[0]);
1293 }
1294
1295 /* TGSI_OPCODE_ROUND (CPU Only) */
1296 static void
1297 round_emit_cpu(
1298 const struct lp_build_tgsi_action * action,
1299 struct lp_build_tgsi_context * bld_base,
1300 struct lp_build_emit_data * emit_data)
1301 {
1302 emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base,
1303 emit_data->args[0]);
1304 }
1305
1306 /* TGSI_OPCODE_SET Helper (CPU Only) */
1307
1308 static void
1309 set_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 unsigned pipe_func)
1314 {
1315 LLVMValueRef cond = lp_build_cmp(&bld_base->base, pipe_func,
1316 emit_data->args[0], emit_data->args[1]);
1317 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base,
1318 cond,
1319 bld_base->base.one,
1320 bld_base->base.zero);
1321 }
1322
1323 /* TGSI_OPCODE_SEQ (CPU Only) */
1324
1325 static void
1326 seq_emit_cpu(
1327 const struct lp_build_tgsi_action * action,
1328 struct lp_build_tgsi_context * bld_base,
1329 struct lp_build_emit_data * emit_data)
1330 {
1331 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1332 }
1333
1334 /* TGSI_OPCODE_SGE (CPU Only) */
1335 static void
1336 sge_emit_cpu(
1337 const struct lp_build_tgsi_action * action,
1338 struct lp_build_tgsi_context * bld_base,
1339 struct lp_build_emit_data * emit_data)
1340 {
1341 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1342 }
1343
1344 /* TGSI_OPCODE_SGT (CPU Only)*/
1345
1346 static void
1347 sgt_emit_cpu(
1348 const struct lp_build_tgsi_action * action,
1349 struct lp_build_tgsi_context * bld_base,
1350 struct lp_build_emit_data * emit_data)
1351 {
1352 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER);
1353 }
1354
1355 /* TGSI_OPCODE_SHL (CPU Only) */
1356 static void
1357 shl_emit_cpu(
1358 const struct lp_build_tgsi_action * action,
1359 struct lp_build_tgsi_context * bld_base,
1360 struct lp_build_emit_data * emit_data)
1361 {
1362 emit_data->output[emit_data->chan] = lp_build_shl(&bld_base->uint_bld,
1363 emit_data->args[0], emit_data->args[1]);
1364 }
1365
1366 /* TGSI_OPCODE_SIN (CPU Only) */
1367 static void
1368 sin_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_sin(&bld_base->base,
1374 emit_data->args[0]);
1375 }
1376
1377 /* TGSI_OPCODE_SLE (CPU Only) */
1378 static void
1379 sle_emit_cpu(
1380 const struct lp_build_tgsi_action * action,
1381 struct lp_build_tgsi_context * bld_base,
1382 struct lp_build_emit_data * emit_data)
1383 {
1384 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL);
1385 }
1386
1387 /* TGSI_OPCODE_SLT (CPU Only) */
1388 static void
1389 slt_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 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1395 }
1396
1397 /* TGSI_OPCODE_SNE (CPU Only) */
1398
1399 static void
1400 sne_emit_cpu(
1401 const struct lp_build_tgsi_action * action,
1402 struct lp_build_tgsi_context * bld_base,
1403 struct lp_build_emit_data * emit_data)
1404 {
1405 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1406 }
1407
1408 /* TGSI_OPCODE_SSG (CPU Only) */
1409
1410 static void
1411 ssg_emit_cpu(
1412 const struct lp_build_tgsi_action * action,
1413 struct lp_build_tgsi_context * bld_base,
1414 struct lp_build_emit_data * emit_data)
1415 {
1416 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base,
1417 emit_data->args[0]);
1418 }
1419
1420 /* TGSI_OPCODE_SUB (CPU Only) */
1421
1422 static void
1423 sub_emit_cpu(
1424 const struct lp_build_tgsi_action * action,
1425 struct lp_build_tgsi_context * bld_base,
1426 struct lp_build_emit_data * emit_data)
1427 {
1428 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base,
1429 emit_data->args[0],
1430 emit_data->args[1]);
1431 }
1432
1433 /* TGSI_OPCODE_TRUNC (CPU Only) */
1434
1435 static void
1436 trunc_emit_cpu(
1437 const struct lp_build_tgsi_action * action,
1438 struct lp_build_tgsi_context * bld_base,
1439 struct lp_build_emit_data * emit_data)
1440 {
1441 emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base,
1442 emit_data->args[0]);
1443 }
1444
1445 /* TGSI_OPCODE_UADD (CPU Only) */
1446 static void
1447 uadd_emit_cpu(
1448 const struct lp_build_tgsi_action * action,
1449 struct lp_build_tgsi_context * bld_base,
1450 struct lp_build_emit_data * emit_data)
1451 {
1452 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld,
1453 emit_data->args[0], emit_data->args[1]);
1454 }
1455
1456 /* TGSI_OPCODE_UDIV (CPU Only) */
1457 static void
1458 udiv_emit_cpu(
1459 const struct lp_build_tgsi_action * action,
1460 struct lp_build_tgsi_context * bld_base,
1461 struct lp_build_emit_data * emit_data)
1462 {
1463 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->uint_bld,
1464 emit_data->args[0], emit_data->args[1]);
1465 }
1466
1467 /* TGSI_OPCODE_UMAX (CPU Only) */
1468 static void
1469 umax_emit_cpu(
1470 const struct lp_build_tgsi_action * action,
1471 struct lp_build_tgsi_context * bld_base,
1472 struct lp_build_emit_data * emit_data)
1473 {
1474 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld,
1475 emit_data->args[0], emit_data->args[1]);
1476 }
1477
1478 /* TGSI_OPCODE_UMIN (CPU Only) */
1479 static void
1480 umin_emit_cpu(
1481 const struct lp_build_tgsi_action * action,
1482 struct lp_build_tgsi_context * bld_base,
1483 struct lp_build_emit_data * emit_data)
1484 {
1485 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld,
1486 emit_data->args[0], emit_data->args[1]);
1487 }
1488
1489 /* TGSI_OPCODE_UMOD (CPU Only) */
1490 static void
1491 umod_emit_cpu(
1492 const struct lp_build_tgsi_action * action,
1493 struct lp_build_tgsi_context * bld_base,
1494 struct lp_build_emit_data * emit_data)
1495 {
1496 emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->uint_bld,
1497 emit_data->args[0], emit_data->args[1]);
1498 }
1499
1500 /* TGSI_OPCODE_USET Helper (CPU Only) */
1501 static void
1502 uset_emit_cpu(
1503 const struct lp_build_tgsi_action * action,
1504 struct lp_build_tgsi_context * bld_base,
1505 struct lp_build_emit_data * emit_data,
1506 unsigned pipe_func)
1507 {
1508 LLVMValueRef nz = lp_build_const_vec(bld_base->base.gallivm,
1509 bld_base->uint_bld.type, ~0U);
1510 LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func,
1511 emit_data->args[0], emit_data->args[1]);
1512 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->uint_bld,
1513 cond,
1514 nz,
1515 bld_base->uint_bld.zero);
1516 }
1517
1518
1519 /* TGSI_OPCODE_USEQ (CPU Only) */
1520 static void
1521 useq_emit_cpu(
1522 const struct lp_build_tgsi_action * action,
1523 struct lp_build_tgsi_context * bld_base,
1524 struct lp_build_emit_data * emit_data)
1525 {
1526 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL);
1527 }
1528
1529 /* TGSI_OPCODE_ISGE (CPU Only) */
1530 static void
1531 usge_emit_cpu(
1532 const struct lp_build_tgsi_action * action,
1533 struct lp_build_tgsi_context * bld_base,
1534 struct lp_build_emit_data * emit_data)
1535 {
1536 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL);
1537 }
1538
1539 /* TGSI_OPCODE_USHR (CPU Only) */
1540 static void
1541 ushr_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 emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->uint_bld,
1547 emit_data->args[0], emit_data->args[1]);
1548 }
1549
1550 /* TGSI_OPCODE_ISLT (CPU Only) */
1551 static void
1552 uslt_emit_cpu(
1553 const struct lp_build_tgsi_action * action,
1554 struct lp_build_tgsi_context * bld_base,
1555 struct lp_build_emit_data * emit_data)
1556 {
1557 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS);
1558 }
1559
1560 /* TGSI_OPCODE_USNE (CPU Only) */
1561
1562 static void
1563 usne_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 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL);
1569 }
1570
1571 /* TGSI_OPCODE_XOR */
1572 static void
1573 xor_emit_cpu(
1574 const struct lp_build_tgsi_action * action,
1575 struct lp_build_tgsi_context * bld_base,
1576 struct lp_build_emit_data * emit_data)
1577 {
1578 emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld,
1579 emit_data->args[0],
1580 emit_data->args[1]);
1581 }
1582
1583 void
1584 lp_set_default_actions_cpu(
1585 struct lp_build_tgsi_context * bld_base)
1586 {
1587 lp_set_default_actions(bld_base);
1588 bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu;
1589 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu;
1590 bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu;
1591 bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu;
1592 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu;
1593 bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu;
1594 bld_base->op_actions[TGSI_OPCODE_CND].emit = cnd_emit_cpu;
1595 bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu;
1596 bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu;
1597 bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu;
1598 bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu;
1599 bld_base->op_actions[TGSI_OPCODE_EXP].emit = exp_emit_cpu;
1600 bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu;
1601 bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit_cpu;
1602 bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu;
1603
1604 bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu;
1605 bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu;
1606 bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu;
1607 bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu;
1608 bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu;
1609 bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu;
1610 bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu;
1611 bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu;
1612 bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu;
1613 bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu;
1614
1615 bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu;
1616 bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu;
1617 bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu;
1618 bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu;
1619 bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu;
1620 bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu;
1621 bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu;
1622 bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu;
1623 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu;
1624 bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu;
1625 bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu;
1626 bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu;
1627 bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu;
1628 bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu;
1629 bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu;
1630 bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu;
1631 bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu;
1632 bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu;
1633 bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu;
1634 bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu;
1635 bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu;
1636
1637 bld_base->rsq_action.emit = recip_sqrt_emit_cpu;
1638
1639 bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu;
1640 bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu;
1641 bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu;
1642 bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu;
1643 bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu;
1644 bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu;
1645 bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu;
1646 bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu;
1647 bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu;
1648 bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu;
1649
1650 bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu;
1651
1652 }