lp_bld_tgsi_action.c revision 579ccae73d29211c9f5c01ba527e1743ea39c94e
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 63static 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 73static 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 */ 88static void 89add_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 */ 100static void 101arr_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 */ 112static void 113clamp_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 128static void 129dp_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 */ 145static void 146dp2_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 153static void 154dp2_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 170static struct lp_build_tgsi_action dp2_action = { 171 dp2_fetch_args, /* fetch_args */ 172 dp2_emit /* emit */ 173}; 174 175/* TGSI_OPCODE_DP2A */ 176static void 177dp2a_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 186static void 187dp2a_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 198static struct lp_build_tgsi_action dp2a_action = { 199 dp2a_fetch_args, /* fetch_args */ 200 dp2a_emit /* emit */ 201}; 202 203/* TGSI_OPCODE_DP3 */ 204static void 205dp3_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 212static void 213dp3_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 233static struct lp_build_tgsi_action dp3_action = { 234 dp3_fetch_args, /* fetch_args */ 235 dp3_emit /* emit */ 236}; 237 238/* TGSI_OPCODDE_DP4 */ 239 240static void 241dp4_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 248static void 249dp4_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 273static struct lp_build_tgsi_action dp4_action = { 274 dp4_fetch_args, /* fetch_args */ 275 dp4_emit /* emit */ 276}; 277 278/* TGSI_OPCODE_DPH */ 279static void 280dph_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 289const struct lp_build_tgsi_action dph_action = { 290 dph_fetch_args, /* fetch_args */ 291 dp4_emit /* emit */ 292}; 293 294/* TGSI_OPCODE_DST */ 295static void 296dst_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 314static void 315dst_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 335static struct lp_build_tgsi_action dst_action = { 336 dst_fetch_args, /* fetch_args */ 337 dst_emit /* emit */ 338}; 339 340/* TGSI_OPCODE_END */ 341static void 342end_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 352static void 353exp_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 379const 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 386static void 387frc_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 401static void 402kil_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 424static void 425kilp_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 434static void 435lit_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 448static void 449lit_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 483static struct lp_build_tgsi_action lit_action = { 484 lit_fetch_args, /* fetch_args */ 485 lit_emit /* emit */ 486}; 487 488/* TGSI_OPCODE_LOG */ 489 490static void 491log_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 528static 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 535static void 536lrp_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 551static void 552mad_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 567static void 568mov_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 */ 577static void 578mul_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_POW */ 588 589static void 590pow_emit( 591 const struct lp_build_tgsi_action * action, 592 struct lp_build_tgsi_context * bld_base, 593 struct lp_build_emit_data * emit_data) 594{ 595 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base, 596 emit_data->args[0], emit_data->args[1]); 597} 598 599static struct lp_build_tgsi_action pow_action = { 600 scalar_binary_fetch_args, /* fetch_args */ 601 pow_emit /* emit */ 602}; 603 604/* TGSI_OPCODE_RSQ */ 605 606static void 607rsq_emit( 608 const struct lp_build_tgsi_action * action, 609 struct lp_build_tgsi_context * bld_base, 610 struct lp_build_emit_data * emit_data) 611{ 612 emit_data->args[0] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS, 613 emit_data->args[0]); 614 if (bld_base->rsq_action.emit) { 615 bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data); 616 } else { 617 emit_data->output[emit_data->chan] = bld_base->base.undef; 618 } 619} 620 621const struct lp_build_tgsi_action rsq_action = { 622 scalar_unary_fetch_args, /* fetch_args */ 623 rsq_emit /* emit */ 624 625}; 626 627/* TGSI_OPCODE_SCS */ 628static void 629scs_emit( 630 const struct lp_build_tgsi_action * action, 631 struct lp_build_tgsi_context * bld_base, 632 struct lp_build_emit_data * emit_data) 633{ 634 /* dst.x */ 635 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base, 636 TGSI_OPCODE_COS, emit_data->args[0]); 637 /* dst.y */ 638 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base, 639 TGSI_OPCODE_SIN, emit_data->args[0]); 640 /* dst.z */ 641 emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero; 642 643 /* dst.w */ 644 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 645} 646 647const struct lp_build_tgsi_action scs_action = { 648 scalar_unary_fetch_args, /* fetch_args */ 649 scs_emit /* emit */ 650}; 651 652/* TGSI_OPCODE_SFL */ 653 654static void 655sfl_emit( 656 const struct lp_build_tgsi_action * action, 657 struct lp_build_tgsi_context * bld_base, 658 struct lp_build_emit_data * emit_data) 659{ 660 emit_data->output[emit_data->chan] = bld_base->base.zero; 661} 662 663/* TGSI_OPCODE_STR */ 664 665static void 666str_emit( 667 const struct lp_build_tgsi_action * action, 668 struct lp_build_tgsi_context * bld_base, 669 struct lp_build_emit_data * emit_data) 670{ 671 emit_data->output[emit_data->chan] = bld_base->base.one; 672} 673 674/* TGSI_OPCODE_SUB */ 675static void 676sub_emit( 677 const struct lp_build_tgsi_action * action, 678 struct lp_build_tgsi_context * bld_base, 679 struct lp_build_emit_data * emit_data) 680{ 681 emit_data->output[emit_data->chan] = LLVMBuildFSub( 682 bld_base->base.gallivm->builder, 683 emit_data->args[0], 684 emit_data->args[1], ""); 685} 686 687/* TGSI_OPCODE_U2F */ 688static void 689u2f_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] = LLVMBuildUIToFP(bld_base->base.gallivm->builder, 695 emit_data->args[0], 696 bld_base->uint_bld.vec_type, ""); 697} 698 699static void 700umad_emit( 701 const struct lp_build_tgsi_action * action, 702 struct lp_build_tgsi_context * bld_base, 703 struct lp_build_emit_data * emit_data) 704{ 705 LLVMValueRef tmp; 706 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL, 707 emit_data->args[0], 708 emit_data->args[1]); 709 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 710 TGSI_OPCODE_UADD, tmp, emit_data->args[2]); 711} 712 713/* TGSI_OPCODE_UMUL */ 714static void 715umul_emit( 716 const struct lp_build_tgsi_action * action, 717 struct lp_build_tgsi_context * bld_base, 718 struct lp_build_emit_data * emit_data) 719{ 720 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld, 721 emit_data->args[0], emit_data->args[1]); 722} 723 724/* TGSI_OPCODE_XPD */ 725 726static void 727xpd_fetch_args( 728 struct lp_build_tgsi_context * bld_base, 729 struct lp_build_emit_data * emit_data) 730{ 731 dp_fetch_args(bld_base, emit_data, 3); 732} 733 734/** 735 * (a * b) - (c * d) 736 */ 737static LLVMValueRef 738xpd_helper( 739 struct lp_build_tgsi_context * bld_base, 740 LLVMValueRef a, 741 LLVMValueRef b, 742 LLVMValueRef c, 743 LLVMValueRef d) 744{ 745 LLVMValueRef tmp0, tmp1; 746 747 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b); 748 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d); 749 750 return lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_SUB, tmp0, tmp1); 751} 752 753static void 754xpd_emit( 755 const struct lp_build_tgsi_action * action, 756 struct lp_build_tgsi_context * bld_base, 757 struct lp_build_emit_data * emit_data) 758{ 759 emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base, 760 emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */, 761 emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */); 762 763 emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base, 764 emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */, 765 emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */); 766 767 emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base, 768 emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */, 769 emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */); 770 771 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 772} 773 774const struct lp_build_tgsi_action xpd_action = { 775 xpd_fetch_args, /* fetch_args */ 776 xpd_emit /* emit */ 777}; 778 779void 780lp_set_default_actions(struct lp_build_tgsi_context * bld_base) 781{ 782 bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action; 783 bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action; 784 bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action; 785 bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action; 786 bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action; 787 bld_base->op_actions[TGSI_OPCODE_DST] = dst_action; 788 bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action; 789 bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action; 790 bld_base->op_actions[TGSI_OPCODE_LOG] = log_action; 791 bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action; 792 bld_base->op_actions[TGSI_OPCODE_POW] = pow_action; 793 bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action; 794 bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action; 795 796 bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args; 797 bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args; 798 bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args; 799 bld_base->op_actions[TGSI_OPCODE_KIL].fetch_args = kil_fetch_args; 800 bld_base->op_actions[TGSI_OPCODE_KILP].fetch_args = kilp_fetch_args; 801 bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args; 802 bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args; 803 bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args; 804 805 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit; 806 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit; 807 bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit; 808 bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit; 809 bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit; 810 bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit; 811 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit; 812 bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit; 813 bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit; 814 bld_base->op_actions[TGSI_OPCODE_SFL].emit = sfl_emit; 815 bld_base->op_actions[TGSI_OPCODE_STR].emit = str_emit; 816 bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit; 817 818 bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit; 819 bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit; 820 bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit; 821 bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit; 822} 823 824/* CPU Only default actions */ 825 826/* These actions are CPU only, because they could potentially output SSE 827 * intrinsics. 828 */ 829 830/* TGSI_OPCODE_ABS (CPU Only)*/ 831 832static void 833abs_emit_cpu( 834 const struct lp_build_tgsi_action * action, 835 struct lp_build_tgsi_context * bld_base, 836 struct lp_build_emit_data * emit_data) 837{ 838 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->base, 839 emit_data->args[0]); 840} 841 842/* TGSI_OPCODE_ADD (CPU Only) */ 843static void 844add_emit_cpu( 845 const struct lp_build_tgsi_action * action, 846 struct lp_build_tgsi_context * bld_base, 847 struct lp_build_emit_data * emit_data) 848{ 849 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base, 850 emit_data->args[0], emit_data->args[1]); 851} 852 853/* TGSI_OPCODE_AND (CPU Only) */ 854static void 855and_emit_cpu( 856 const struct lp_build_tgsi_action * action, 857 struct lp_build_tgsi_context * bld_base, 858 struct lp_build_emit_data * emit_data) 859{ 860 emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld, 861 emit_data->args[0], emit_data->args[1]); 862} 863 864/* TGSI_OPCODE_ARL (CPU Only) */ 865static void 866arl_emit_cpu( 867 const struct lp_build_tgsi_action * action, 868 struct lp_build_tgsi_context * bld_base, 869 struct lp_build_emit_data * emit_data) 870{ 871 LLVMValueRef tmp; 872 tmp = lp_build_floor(&bld_base->base, 873 emit_data->args[0]); 874 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp, 875 bld_base->uint_bld.vec_type, ""); 876} 877 878/* TGSI_OPCODE_ARR (CPU Only) */ 879static void 880arr_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_iround(&bld_base->base, emit_data->args[0]); 886} 887 888/* TGSI_OPCODE_CEIL (CPU Only) */ 889static void 890ceil_emit_cpu( 891 const struct lp_build_tgsi_action * action, 892 struct lp_build_tgsi_context * bld_base, 893 struct lp_build_emit_data * emit_data) 894{ 895 emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base, 896 emit_data->args[0]); 897} 898 899/* TGSI_OPCODE_CMP (CPU Only) */ 900static void 901cmp_emit_cpu( 902 const struct lp_build_tgsi_action * action, 903 struct lp_build_tgsi_context * bld_base, 904 struct lp_build_emit_data * emit_data) 905{ 906 LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS, 907 emit_data->args[0], bld_base->base.zero); 908 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base, 909 cond, emit_data->args[1], emit_data->args[2]); 910} 911 912/* TGSI_OPCODE_CND (CPU Only) */ 913static void 914cnd_emit_cpu( 915 const struct lp_build_tgsi_action * action, 916 struct lp_build_tgsi_context * bld_base, 917 struct lp_build_emit_data * emit_data) 918{ 919 LLVMValueRef half, tmp; 920 half = lp_build_const_vec(bld_base->base.gallivm, bld_base->base.type, 0.5); 921 tmp = lp_build_cmp(&bld_base->base, PIPE_FUNC_GREATER, 922 emit_data->args[2], half); 923 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base, 924 tmp, 925 emit_data->args[0], 926 emit_data->args[1]); 927} 928 929/* TGSI_OPCODE_COS (CPU Only) */ 930static void 931cos_emit_cpu( 932 const struct lp_build_tgsi_action * action, 933 struct lp_build_tgsi_context * bld_base, 934 struct lp_build_emit_data * emit_data) 935{ 936 emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base, 937 emit_data->args[0]); 938} 939 940/* TGSI_OPCODE_DIV (CPU Only) */ 941static void 942div_emit_cpu( 943 const struct lp_build_tgsi_action * action, 944 struct lp_build_tgsi_context * bld_base, 945 struct lp_build_emit_data * emit_data) 946{ 947 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base, 948 emit_data->args[0], emit_data->args[1]); 949} 950 951/* TGSI_OPCODE_EX2 (CPU Only) */ 952static void 953ex2_emit_cpu( 954 const struct lp_build_tgsi_action * action, 955 struct lp_build_tgsi_context * bld_base, 956 struct lp_build_emit_data * emit_data) 957{ 958 emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base, 959 emit_data->args[0]); 960} 961 962/* TGSI_OPCODE_EXP (CPU Only) */ 963static void 964exp_emit_cpu( 965 const struct lp_build_tgsi_action * action, 966 struct lp_build_tgsi_context * bld_base, 967 struct lp_build_emit_data * emit_data) 968{ 969 lp_build_exp2_approx(&bld_base->base, emit_data->args[0], 970 &emit_data->output[TGSI_CHAN_X], 971 &emit_data->output[TGSI_CHAN_Y], 972 &emit_data->output[TGSI_CHAN_Z]); 973 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 974} 975 976/* TGSI_OPCODE_F2I (CPU Only) */ 977static void 978f2i_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_itrunc(&bld_base->base, 984 emit_data->args[0]); 985} 986 987/* TGSI_OPCODE_FLR (CPU Only) */ 988 989static void 990flr_emit_cpu( 991 const struct lp_build_tgsi_action * action, 992 struct lp_build_tgsi_context * bld_base, 993 struct lp_build_emit_data * emit_data) 994{ 995 emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base, 996 emit_data->args[0]); 997} 998 999/* TGSI_OPCODE_I2F (CPU Only) */ 1000static void 1001i2f_emit_cpu( 1002 const struct lp_build_tgsi_action * action, 1003 struct lp_build_tgsi_context * bld_base, 1004 struct lp_build_emit_data * emit_data) 1005{ 1006 emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base, 1007 emit_data->args[0]); 1008} 1009 1010/* TGSI_OPCODE_IDIV (CPU Only) */ 1011static void 1012idiv_emit_cpu( 1013 const struct lp_build_tgsi_action * action, 1014 struct lp_build_tgsi_context * bld_base, 1015 struct lp_build_emit_data * emit_data) 1016{ 1017 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->int_bld, 1018 emit_data->args[0], emit_data->args[1]); 1019} 1020 1021/* TGSI_OPCODE_INEG (CPU Only) */ 1022static void 1023ineg_emit_cpu( 1024 const struct lp_build_tgsi_action * action, 1025 struct lp_build_tgsi_context * bld_base, 1026 struct lp_build_emit_data * emit_data) 1027{ 1028 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld, 1029 bld_base->int_bld.zero, 1030 emit_data->args[0]); 1031} 1032 1033/* TGSI_OPCODE_ISET Helper (CPU Only) */ 1034static void 1035iset_emit_cpu( 1036 const struct lp_build_tgsi_action * action, 1037 struct lp_build_tgsi_context * bld_base, 1038 struct lp_build_emit_data * emit_data, 1039 unsigned pipe_func) 1040{ 1041 LLVMValueRef nz = lp_build_const_vec(bld_base->base.gallivm, 1042 bld_base->int_bld.type, ~0U); 1043 LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func, 1044 emit_data->args[0], emit_data->args[1]); 1045 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->int_bld, 1046 cond, 1047 nz, 1048 bld_base->int_bld.zero); 1049} 1050 1051/* TGSI_OPCODE_IMAX (CPU Only) */ 1052static void 1053imax_emit_cpu( 1054 const struct lp_build_tgsi_action * action, 1055 struct lp_build_tgsi_context * bld_base, 1056 struct lp_build_emit_data * emit_data) 1057{ 1058 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld, 1059 emit_data->args[0], emit_data->args[1]); 1060} 1061 1062/* TGSI_OPCODE_IMIN (CPU Only) */ 1063static void 1064imin_emit_cpu( 1065 const struct lp_build_tgsi_action * action, 1066 struct lp_build_tgsi_context * bld_base, 1067 struct lp_build_emit_data * emit_data) 1068{ 1069 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld, 1070 emit_data->args[0], emit_data->args[1]); 1071} 1072 1073/* TGSI_OPCODE_ISGE (CPU Only) */ 1074static void 1075isge_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 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 1081} 1082 1083/* TGSI_OPCODE_ISHR (CPU Only) */ 1084static void 1085ishr_emit_cpu( 1086 const struct lp_build_tgsi_action * action, 1087 struct lp_build_tgsi_context * bld_base, 1088 struct lp_build_emit_data * emit_data) 1089{ 1090 emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->int_bld, 1091 emit_data->args[0], emit_data->args[1]); 1092} 1093 1094/* TGSI_OPCODE_ISLT (CPU Only) */ 1095static void 1096islt_emit_cpu( 1097 const struct lp_build_tgsi_action * action, 1098 struct lp_build_tgsi_context * bld_base, 1099 struct lp_build_emit_data * emit_data) 1100{ 1101 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 1102} 1103 1104/* TGSI_OPCODE_LG2 (CPU Only) */ 1105static void 1106lg2_emit_cpu( 1107 const struct lp_build_tgsi_action * action, 1108 struct lp_build_tgsi_context * bld_base, 1109 struct lp_build_emit_data * emit_data) 1110{ 1111 emit_data->output[emit_data->chan] = lp_build_log2(&bld_base->base, 1112 emit_data->args[0]); 1113} 1114 1115/* TGSI_OPCODE_LOG (CPU Only) */ 1116static void 1117log_emit_cpu( 1118 const struct lp_build_tgsi_action * action, 1119 struct lp_build_tgsi_context * bld_base, 1120 struct lp_build_emit_data * emit_data) 1121{ 1122 LLVMValueRef p_floor_log2; 1123 LLVMValueRef p_exp; 1124 LLVMValueRef p_log2; 1125 LLVMValueRef src0 = emit_data->args[0]; 1126 1127 lp_build_log2_approx(&bld_base->base, src0, 1128 &p_exp, &p_floor_log2, &p_log2); 1129 1130 emit_data->output[TGSI_CHAN_X] = p_floor_log2; 1131 1132 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base, 1133 TGSI_OPCODE_DIV, 1134 src0, p_exp); 1135 emit_data->output[TGSI_CHAN_Z] = p_log2; 1136 1137 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 1138 1139} 1140 1141/* TGSI_OPCODE_MAX (CPU Only) */ 1142 1143static void 1144max_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 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->base, 1150 emit_data->args[0], emit_data->args[1]); 1151} 1152 1153/* TGSI_OPCODE_MIN (CPU Only) */ 1154static void 1155min_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_min(&bld_base->base, 1161 emit_data->args[0], emit_data->args[1]); 1162} 1163 1164/* TGSI_OPCODE_MOD (CPU Only) */ 1165static void 1166mod_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_mod(&bld_base->int_bld, 1172 emit_data->args[0], emit_data->args[1]); 1173} 1174 1175/* TGSI_OPCODE_NOT */ 1176static void 1177not_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 emit_data->output[emit_data->chan] = lp_build_not(&bld_base->base, 1183 emit_data->args[0]); 1184} 1185 1186/* TGSI_OPCODE_OR (CPU Only) */ 1187static void 1188or_emit_cpu( 1189 const struct lp_build_tgsi_action * action, 1190 struct lp_build_tgsi_context * bld_base, 1191 struct lp_build_emit_data * emit_data) 1192{ 1193 emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld, 1194 emit_data->args[0], emit_data->args[1]); 1195} 1196 1197/* TGSI_OPCODE_POW (CPU Only) */ 1198static void 1199pow_emit_cpu( 1200 const struct lp_build_tgsi_action * action, 1201 struct lp_build_tgsi_context * bld_base, 1202 struct lp_build_emit_data * emit_data) 1203{ 1204 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base, 1205 emit_data->args[0], emit_data->args[1]); 1206} 1207 1208 1209/* TGSI_OPCODE_RCP (CPU Only) */ 1210 1211static void 1212rcp_emit_cpu( 1213 const struct lp_build_tgsi_action * action, 1214 struct lp_build_tgsi_context * bld_base, 1215 struct lp_build_emit_data * emit_data) 1216{ 1217 emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base, 1218 emit_data->args[0]); 1219} 1220 1221/* Reciprical squareroot (CPU Only) */ 1222 1223/* This is not the same as TGSI_OPCODE_RSQ, which requres the argument to be 1224 * greater than or equal to 0 */ 1225static void 1226recip_sqrt_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_rsqrt(&bld_base->base, 1232 emit_data->args[0]); 1233} 1234 1235/* TGSI_OPCODE_ROUND (CPU Only) */ 1236static void 1237round_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_round(&bld_base->base, 1243 emit_data->args[0]); 1244} 1245 1246/* TGSI_OPCODE_SET Helper (CPU Only) */ 1247 1248static void 1249set_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 unsigned pipe_func) 1254{ 1255 LLVMValueRef cond = lp_build_cmp(&bld_base->base, pipe_func, 1256 emit_data->args[0], emit_data->args[1]); 1257 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base, 1258 cond, 1259 bld_base->base.one, 1260 bld_base->base.zero); 1261} 1262 1263/* TGSI_OPCODE_SEQ (CPU Only) */ 1264 1265static void 1266seq_emit_cpu( 1267 const struct lp_build_tgsi_action * action, 1268 struct lp_build_tgsi_context * bld_base, 1269 struct lp_build_emit_data * emit_data) 1270{ 1271 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 1272} 1273 1274/* TGSI_OPCODE_SGE (CPU Only) */ 1275static void 1276sge_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 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 1282} 1283 1284/* TGSI_OPCODE_SGT (CPU Only)*/ 1285 1286static void 1287sgt_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 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER); 1293} 1294 1295/* TGSI_OPCODE_SHL (CPU Only) */ 1296static void 1297shl_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_shl(&bld_base->uint_bld, 1303 emit_data->args[0], emit_data->args[1]); 1304} 1305 1306/* TGSI_OPCODE_SIN (CPU Only) */ 1307static void 1308sin_emit_cpu( 1309 const struct lp_build_tgsi_action * action, 1310 struct lp_build_tgsi_context * bld_base, 1311 struct lp_build_emit_data * emit_data) 1312{ 1313 emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base, 1314 emit_data->args[0]); 1315} 1316 1317/* TGSI_OPCODE_SLE (CPU Only) */ 1318static void 1319sle_emit_cpu( 1320 const struct lp_build_tgsi_action * action, 1321 struct lp_build_tgsi_context * bld_base, 1322 struct lp_build_emit_data * emit_data) 1323{ 1324 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL); 1325} 1326 1327/* TGSI_OPCODE_SLT (CPU Only) */ 1328static void 1329slt_emit_cpu( 1330 const struct lp_build_tgsi_action * action, 1331 struct lp_build_tgsi_context * bld_base, 1332 struct lp_build_emit_data * emit_data) 1333{ 1334 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 1335} 1336 1337/* TGSI_OPCODE_SNE (CPU Only) */ 1338 1339static void 1340sne_emit_cpu( 1341 const struct lp_build_tgsi_action * action, 1342 struct lp_build_tgsi_context * bld_base, 1343 struct lp_build_emit_data * emit_data) 1344{ 1345 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 1346} 1347 1348/* TGSI_OPCODE_SSG (CPU Only) */ 1349 1350static void 1351ssg_emit_cpu( 1352 const struct lp_build_tgsi_action * action, 1353 struct lp_build_tgsi_context * bld_base, 1354 struct lp_build_emit_data * emit_data) 1355{ 1356 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base, 1357 emit_data->args[0]); 1358} 1359 1360/* TGSI_OPCODE_SUB (CPU Only) */ 1361 1362static void 1363sub_emit_cpu( 1364 const struct lp_build_tgsi_action * action, 1365 struct lp_build_tgsi_context * bld_base, 1366 struct lp_build_emit_data * emit_data) 1367{ 1368 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->base, 1369 emit_data->args[0], 1370 emit_data->args[1]); 1371} 1372 1373/* TGSI_OPCODE_TRUNC (CPU Only) */ 1374 1375static void 1376trunc_emit_cpu( 1377 const struct lp_build_tgsi_action * action, 1378 struct lp_build_tgsi_context * bld_base, 1379 struct lp_build_emit_data * emit_data) 1380{ 1381 emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base, 1382 emit_data->args[0]); 1383} 1384 1385/* TGSI_OPCODE_UADD (CPU Only) */ 1386static void 1387uadd_emit_cpu( 1388 const struct lp_build_tgsi_action * action, 1389 struct lp_build_tgsi_context * bld_base, 1390 struct lp_build_emit_data * emit_data) 1391{ 1392 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld, 1393 emit_data->args[0], emit_data->args[1]); 1394} 1395 1396/* TGSI_OPCODE_UDIV (CPU Only) */ 1397static void 1398udiv_emit_cpu( 1399 const struct lp_build_tgsi_action * action, 1400 struct lp_build_tgsi_context * bld_base, 1401 struct lp_build_emit_data * emit_data) 1402{ 1403 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->uint_bld, 1404 emit_data->args[0], emit_data->args[1]); 1405} 1406 1407/* TGSI_OPCODE_UMAX (CPU Only) */ 1408static void 1409umax_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 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld, 1415 emit_data->args[0], emit_data->args[1]); 1416} 1417 1418/* TGSI_OPCODE_UMIN (CPU Only) */ 1419static void 1420umin_emit_cpu( 1421 const struct lp_build_tgsi_action * action, 1422 struct lp_build_tgsi_context * bld_base, 1423 struct lp_build_emit_data * emit_data) 1424{ 1425 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld, 1426 emit_data->args[0], emit_data->args[1]); 1427} 1428 1429/* TGSI_OPCODE_UMOD (CPU Only) */ 1430static void 1431umod_emit_cpu( 1432 const struct lp_build_tgsi_action * action, 1433 struct lp_build_tgsi_context * bld_base, 1434 struct lp_build_emit_data * emit_data) 1435{ 1436 emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->uint_bld, 1437 emit_data->args[0], emit_data->args[1]); 1438} 1439 1440/* TGSI_OPCODE_USET Helper (CPU Only) */ 1441static void 1442uset_emit_cpu( 1443 const struct lp_build_tgsi_action * action, 1444 struct lp_build_tgsi_context * bld_base, 1445 struct lp_build_emit_data * emit_data, 1446 unsigned pipe_func) 1447{ 1448 LLVMValueRef nz = lp_build_const_vec(bld_base->base.gallivm, 1449 bld_base->uint_bld.type, ~0U); 1450 LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func, 1451 emit_data->args[0], emit_data->args[1]); 1452 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->uint_bld, 1453 cond, 1454 nz, 1455 bld_base->uint_bld.zero); 1456} 1457 1458 1459/* TGSI_OPCODE_USEQ (CPU Only) */ 1460static void 1461useq_emit_cpu( 1462 const struct lp_build_tgsi_action * action, 1463 struct lp_build_tgsi_context * bld_base, 1464 struct lp_build_emit_data * emit_data) 1465{ 1466 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 1467} 1468 1469/* TGSI_OPCODE_ISGE (CPU Only) */ 1470static void 1471usge_emit_cpu( 1472 const struct lp_build_tgsi_action * action, 1473 struct lp_build_tgsi_context * bld_base, 1474 struct lp_build_emit_data * emit_data) 1475{ 1476 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 1477} 1478 1479/* TGSI_OPCODE_USHR (CPU Only) */ 1480static void 1481ushr_emit_cpu( 1482 const struct lp_build_tgsi_action * action, 1483 struct lp_build_tgsi_context * bld_base, 1484 struct lp_build_emit_data * emit_data) 1485{ 1486 emit_data->output[emit_data->chan] = lp_build_shr(&bld_base->uint_bld, 1487 emit_data->args[0], emit_data->args[1]); 1488} 1489 1490/* TGSI_OPCODE_ISLT (CPU Only) */ 1491static void 1492uslt_emit_cpu( 1493 const struct lp_build_tgsi_action * action, 1494 struct lp_build_tgsi_context * bld_base, 1495 struct lp_build_emit_data * emit_data) 1496{ 1497 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 1498} 1499 1500/* TGSI_OPCODE_USNE (CPU Only) */ 1501 1502static void 1503usne_emit_cpu( 1504 const struct lp_build_tgsi_action * action, 1505 struct lp_build_tgsi_context * bld_base, 1506 struct lp_build_emit_data * emit_data) 1507{ 1508 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 1509} 1510 1511/* TGSI_OPCODE_XOR */ 1512static void 1513xor_emit_cpu( 1514 const struct lp_build_tgsi_action * action, 1515 struct lp_build_tgsi_context * bld_base, 1516 struct lp_build_emit_data * emit_data) 1517{ 1518 emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld, 1519 emit_data->args[0], 1520 emit_data->args[1]); 1521} 1522 1523void 1524lp_set_default_actions_cpu( 1525 struct lp_build_tgsi_context * bld_base) 1526{ 1527 lp_set_default_actions(bld_base); 1528 bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu; 1529 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu; 1530 bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu; 1531 bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu; 1532 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu; 1533 bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu; 1534 bld_base->op_actions[TGSI_OPCODE_CND].emit = cnd_emit_cpu; 1535 bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu; 1536 bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu; 1537 bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu; 1538 bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu; 1539 bld_base->op_actions[TGSI_OPCODE_EXP].emit = exp_emit_cpu; 1540 bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu; 1541 bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu; 1542 1543 bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu; 1544 bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu; 1545 bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu; 1546 bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu; 1547 bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu; 1548 bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu; 1549 bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu; 1550 bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu; 1551 1552 bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu; 1553 bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu; 1554 bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu; 1555 bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu; 1556 bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu; 1557 bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu; 1558 bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu; 1559 bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu; 1560 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu; 1561 bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu; 1562 bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu; 1563 bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu; 1564 bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu; 1565 bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu; 1566 bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu; 1567 bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu; 1568 bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu; 1569 bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu; 1570 bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu; 1571 bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit_cpu; 1572 bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu; 1573 1574 bld_base->rsq_action.emit = recip_sqrt_emit_cpu; 1575 1576 bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu; 1577 bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu; 1578 bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu; 1579 bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu; 1580 bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu; 1581 bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu; 1582 bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu; 1583 bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu; 1584 bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu; 1585 bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu; 1586 1587 bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu; 1588 1589} 1590