1/************************************************************************** 2 * 3 * Copyright 2011-2012 Advanced Micro Devices, Inc. 4 * Copyright 2009 VMware, Inc. 5 * Copyright 2007-2008 VMware, Inc. 6 * All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the 10 * "Software"), to deal in the Software without restriction, including 11 * without limitation the rights to use, copy, modify, merge, publish, 12 * distribute, sub license, and/or sell copies of the Software, and to 13 * permit persons to whom the Software is furnished to do so, subject to 14 * the following conditions: 15 * 16 * The above copyright notice and this permission notice (including the 17 * next paragraph) shall be included in all copies or substantial portions 18 * of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 23 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 27 * 28 **************************************************************************/ 29 30/** 31 * @file 32 * TGSI to LLVM IR translation. 33 * 34 * @author Jose Fonseca <jfonseca@vmware.com> 35 * @author Tom Stellard <thomas.stellard@amd.com> 36 * 37 * Based on tgsi_sse2.c code written by Michal Krol, Keith Whitwell, 38 * Brian Paul, and others. 39 */ 40 41 42#include "lp_bld_tgsi_action.h" 43 44#include "lp_bld_tgsi.h" 45#include "lp_bld_arit.h" 46#include "lp_bld_bitarit.h" 47#include "lp_bld_const.h" 48#include "lp_bld_conv.h" 49#include "lp_bld_gather.h" 50#include "lp_bld_logic.h" 51#include "lp_bld_pack.h" 52 53#include "tgsi/tgsi_exec.h" 54 55/* XXX: The CPU only defaults should be repaced by generic ones. In most 56 * cases, the CPU defaults are just wrappers around a function in 57 * lp_build_arit.c and these functions should be inlined here and the CPU 58 * generic code should be removed and placed elsewhere. 59 */ 60 61/* Default actions */ 62 63/* Generic fetch_arg functions */ 64 65static void scalar_unary_fetch_args( 66 struct lp_build_tgsi_context * bld_base, 67 struct lp_build_emit_data * emit_data) 68{ 69 /* src0.x */ 70 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, 0); 71 emit_data->arg_count = 1; 72 emit_data->dst_type = LLVMTypeOf(emit_data->args[0]); 73} 74 75static void scalar_binary_fetch_args( 76 struct lp_build_tgsi_context * bld_base, 77 struct lp_build_emit_data * emit_data) 78{ 79 /* src0.x */ 80 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 81 0, TGSI_CHAN_X); 82 /* src1.x */ 83 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 84 1, TGSI_CHAN_X); 85 emit_data->arg_count = 2; 86 emit_data->dst_type = LLVMTypeOf(emit_data->args[0]); 87} 88 89/* TGSI_OPCODE_ADD */ 90static void 91add_emit( 92 const struct lp_build_tgsi_action * action, 93 struct lp_build_tgsi_context * bld_base, 94 struct lp_build_emit_data * emit_data) 95{ 96 emit_data->output[emit_data->chan] = LLVMBuildFAdd( 97 bld_base->base.gallivm->builder, 98 emit_data->args[0], emit_data->args[1], ""); 99} 100 101/* TGSI_OPCODE_ARR */ 102static void 103arr_emit( 104 const struct lp_build_tgsi_action * action, 105 struct lp_build_tgsi_context * bld_base, 106 struct lp_build_emit_data * emit_data) 107{ 108 LLVMValueRef tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ROUND, emit_data->args[0]); 109 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp, 110 bld_base->uint_bld.vec_type, ""); 111} 112 113/* TGSI_OPCODE_CLAMP */ 114static void 115clamp_emit( 116 const struct lp_build_tgsi_action * action, 117 struct lp_build_tgsi_context * bld_base, 118 struct lp_build_emit_data * emit_data) 119{ 120 LLVMValueRef tmp; 121 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX, 122 emit_data->args[0], 123 emit_data->args[1]); 124 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 125 TGSI_OPCODE_MIN, tmp, emit_data->args[2]); 126} 127 128/* DP* Helper */ 129 130static void 131dp_fetch_args( 132 struct lp_build_tgsi_context * bld_base, 133 struct lp_build_emit_data * emit_data, 134 unsigned dp_components) 135{ 136 unsigned chan, src; 137 for (src = 0; src < 2; src++) { 138 for (chan = 0; chan < dp_components; chan++) { 139 emit_data->args[(src * dp_components) + chan] = 140 lp_build_emit_fetch(bld_base, emit_data->inst, src, chan); 141 } 142 } 143 emit_data->dst_type = bld_base->base.elem_type; 144} 145 146/* TGSI_OPCODE_DP2 */ 147static void 148dp2_fetch_args( 149 struct lp_build_tgsi_context * bld_base, 150 struct lp_build_emit_data * emit_data) 151{ 152 dp_fetch_args(bld_base, emit_data, 2); 153} 154 155static void 156dp2_emit( 157 const struct lp_build_tgsi_action * action, 158 struct lp_build_tgsi_context * bld_base, 159 struct lp_build_emit_data * emit_data) 160{ 161 LLVMValueRef tmp0, tmp1; 162 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 163 emit_data->args[0] /* src0.x */, 164 emit_data->args[2] /* src1.x */); 165 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 166 emit_data->args[1] /* src0.y */, 167 emit_data->args[3] /* src1.y */); 168 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 169 TGSI_OPCODE_ADD, tmp0, tmp1); 170} 171 172static struct lp_build_tgsi_action dp2_action = { 173 dp2_fetch_args, /* fetch_args */ 174 dp2_emit /* emit */ 175}; 176 177/* TGSI_OPCODE_DP2A */ 178static void 179dp2a_fetch_args( 180 struct lp_build_tgsi_context * bld_base, 181 struct lp_build_emit_data * emit_data) 182{ 183 dp_fetch_args(bld_base, emit_data, 2); 184 emit_data->args[5] = lp_build_emit_fetch(bld_base, emit_data->inst, 185 2, TGSI_CHAN_X); 186} 187 188static void 189dp2a_emit( 190 const struct lp_build_tgsi_action * action, 191 struct lp_build_tgsi_context * bld_base, 192 struct lp_build_emit_data * emit_data) 193{ 194 LLVMValueRef tmp; 195 tmp = lp_build_emit_llvm(bld_base, TGSI_OPCODE_DP2, emit_data); 196 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, 197 emit_data->args[5], tmp); 198} 199 200static struct lp_build_tgsi_action dp2a_action = { 201 dp2a_fetch_args, /* fetch_args */ 202 dp2a_emit /* emit */ 203}; 204 205/* TGSI_OPCODE_DP3 */ 206static void 207dp3_fetch_args( 208 struct lp_build_tgsi_context * bld_base, 209 struct lp_build_emit_data * emit_data) 210{ 211 dp_fetch_args(bld_base, emit_data, 3); 212} 213 214static void 215dp3_emit( 216 const struct lp_build_tgsi_action * action, 217 struct lp_build_tgsi_context * bld_base, 218 struct lp_build_emit_data * emit_data) 219{ 220 LLVMValueRef tmp0, tmp1; 221 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 222 emit_data->args[0] /* src0.x */, 223 emit_data->args[3] /* src1.x */); 224 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 225 emit_data->args[1] /* src0.y */, 226 emit_data->args[4] /* src1.y */); 227 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp1, tmp0); 228 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 229 emit_data->args[2] /* src0.z */, 230 emit_data->args[5] /* src1.z */); 231 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 232 TGSI_OPCODE_ADD, tmp0, tmp1); 233} 234 235static struct lp_build_tgsi_action dp3_action = { 236 dp3_fetch_args, /* fetch_args */ 237 dp3_emit /* emit */ 238}; 239 240/* TGSI_OPCODDE_DP4 */ 241 242static void 243dp4_fetch_args( 244 struct lp_build_tgsi_context * bld_base, 245 struct lp_build_emit_data * emit_data) 246{ 247 dp_fetch_args(bld_base, emit_data, 4); 248} 249 250static void 251dp4_emit( 252 const struct lp_build_tgsi_action * action, 253 struct lp_build_tgsi_context * bld_base, 254 struct lp_build_emit_data * emit_data) 255{ 256 LLVMValueRef tmp0, tmp1; 257 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 258 emit_data->args[0] /* src0.x */, 259 emit_data->args[4] /* src1.x */); 260 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 261 emit_data->args[1] /* src0.y */, 262 emit_data->args[5] /* src1.y */); 263 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1); 264 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 265 emit_data->args[2] /* src0.z */, 266 emit_data->args[6] /* src1.z */); 267 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_ADD, tmp0, tmp1); 268 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 269 emit_data->args[3] /* src0.w */, 270 emit_data->args[7] /* src1.w */); 271 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 272 TGSI_OPCODE_ADD, tmp0, tmp1); 273} 274 275static struct lp_build_tgsi_action dp4_action = { 276 dp4_fetch_args, /* fetch_args */ 277 dp4_emit /* emit */ 278}; 279 280/* TGSI_OPCODE_DPH */ 281static void 282dph_fetch_args( 283 struct lp_build_tgsi_context * bld_base, 284 struct lp_build_emit_data * emit_data) 285{ 286 dp_fetch_args(bld_base, emit_data, 4); 287 /* src0.w */ 288 emit_data->args[3] = bld_base->base.one; 289} 290 291const struct lp_build_tgsi_action dph_action = { 292 dph_fetch_args, /* fetch_args */ 293 dp4_emit /* emit */ 294}; 295 296/* TGSI_OPCODE_DST */ 297static void 298dst_fetch_args( 299 struct lp_build_tgsi_context * bld_base, 300 struct lp_build_emit_data * emit_data) 301{ 302 /* src0.y */ 303 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 304 0, TGSI_CHAN_Y); 305 /* src0.z */ 306 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 307 0, TGSI_CHAN_Z); 308 /* src1.y */ 309 emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 310 1, TGSI_CHAN_Y); 311 /* src1.w */ 312 emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst, 313 1, TGSI_CHAN_W); 314} 315 316static void 317dst_emit( 318 const struct lp_build_tgsi_action * action, 319 struct lp_build_tgsi_context * bld_base, 320 struct lp_build_emit_data * emit_data) 321{ 322 /* dst.x */ 323 emit_data->output[TGSI_CHAN_X] = bld_base->base.one; 324 325 /* dst.y */ 326 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base, 327 TGSI_OPCODE_MUL, 328 emit_data->args[0] /* src0.y */, 329 emit_data->args[2] /* src1.y */); 330 /* dst.z */ 331 emit_data->output[TGSI_CHAN_Z] = emit_data->args[1]; /* src0.z */ 332 333 /* dst.w */ 334 emit_data->output[TGSI_CHAN_W] = emit_data->args[3]; /* src1.w */ 335} 336 337static struct lp_build_tgsi_action dst_action = { 338 dst_fetch_args, /* fetch_args */ 339 dst_emit /* emit */ 340}; 341 342/* TGSI_OPCODE_END */ 343static void 344end_emit( 345 const struct lp_build_tgsi_action * action, 346 struct lp_build_tgsi_context * bld_base, 347 struct lp_build_emit_data * emit_data) 348{ 349 bld_base->pc = -1; 350} 351 352/* TGSI_OPCODE_EXP */ 353 354static void 355exp_emit( 356 const struct lp_build_tgsi_action * action, 357 struct lp_build_tgsi_context * bld_base, 358 struct lp_build_emit_data * emit_data) 359{ 360 LLVMValueRef floor_x; 361 362 /* floor( src0.x ) */ 363 floor_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR, 364 emit_data->args[0]); 365 366 /* 2 ^ floor( src0.x ) */ 367 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base, 368 TGSI_OPCODE_EX2, floor_x); 369 370 /* src0.x - floor( src0.x ) */ 371 emit_data->output[TGSI_CHAN_Y] = 372 lp_build_sub(&bld_base->base, emit_data->args[0] /* src0.x */, floor_x); 373 374 /* 2 ^ src0.x */ 375 emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_unary(bld_base, 376 TGSI_OPCODE_EX2, emit_data->args[0] /* src0.x */); 377 378 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 379} 380 381const struct lp_build_tgsi_action exp_action = { 382 scalar_unary_fetch_args, /* fetch_args */ 383 exp_emit /* emit */ 384}; 385 386/* TGSI_OPCODE_FRC */ 387 388static void 389frc_emit( 390 const struct lp_build_tgsi_action * action, 391 struct lp_build_tgsi_context * bld_base, 392 struct lp_build_emit_data * emit_data) 393{ 394 LLVMValueRef tmp; 395 tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR, 396 emit_data->args[0]); 397 emit_data->output[emit_data->chan] = 398 lp_build_sub(&bld_base->base, emit_data->args[0], tmp); 399} 400 401/* TGSI_OPCODE_KILL_IF */ 402 403static void 404kil_fetch_args( 405 struct lp_build_tgsi_context * bld_base, 406 struct lp_build_emit_data * emit_data) 407{ 408 /* src0.x */ 409 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 410 0, TGSI_CHAN_X); 411 /* src0.y */ 412 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 413 0, TGSI_CHAN_Y); 414 /* src0.z */ 415 emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 416 0, TGSI_CHAN_Z); 417 /* src0.w */ 418 emit_data->args[3] = lp_build_emit_fetch(bld_base, emit_data->inst, 419 0, TGSI_CHAN_W); 420 emit_data->arg_count = 4; 421 emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context); 422} 423 424/* TGSI_OPCODE_KILL */ 425 426static void 427kilp_fetch_args( 428 struct lp_build_tgsi_context * bld_base, 429 struct lp_build_emit_data * emit_data) 430{ 431 emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context); 432} 433 434/* TGSI_OPCODE_LIT */ 435 436static void 437lit_fetch_args( 438 struct lp_build_tgsi_context * bld_base, 439 struct lp_build_emit_data * emit_data) 440{ 441 /* src0.x */ 442 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_X); 443 /* src0.y */ 444 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_Y); 445 /* src0.w */ 446 emit_data->args[2] = lp_build_emit_fetch(bld_base, emit_data->inst, 0, TGSI_CHAN_W); 447 emit_data->arg_count = 3; 448} 449 450static void 451lit_emit( 452 const struct lp_build_tgsi_action * action, 453 struct lp_build_tgsi_context * bld_base, 454 struct lp_build_emit_data * emit_data) 455{ 456 LLVMValueRef tmp0, tmp1, tmp2; 457 458 /* dst.x */ 459 emit_data->output[TGSI_CHAN_X] = bld_base->base.one; 460 461 /* dst. y */ 462 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base, 463 TGSI_OPCODE_MAX, 464 emit_data->args[0] /* src0.x */, 465 bld_base->base.zero); 466 467 /* dst.z */ 468 /* XMM[1] = SrcReg[0].yyyy */ 469 tmp1 = emit_data->args[1]; 470 /* XMM[1] = max(XMM[1], 0) */ 471 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MAX, 472 tmp1, bld_base->base.zero); 473 /* XMM[2] = SrcReg[0].wwww */ 474 tmp2 = emit_data->args[2]; 475 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_POW, 476 tmp1, tmp2); 477 tmp0 = emit_data->args[0]; 478 emit_data->output[TGSI_CHAN_Z] = lp_build_emit_llvm_ternary(bld_base, 479 TGSI_OPCODE_CMP, 480 tmp0, bld_base->base.zero, tmp1); 481 /* dst.w */ 482 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 483} 484 485static struct lp_build_tgsi_action lit_action = { 486 lit_fetch_args, /* fetch_args */ 487 lit_emit /* emit */ 488}; 489 490/* TGSI_OPCODE_LOG */ 491 492static void 493log_emit( 494 const struct lp_build_tgsi_action * action, 495 struct lp_build_tgsi_context * bld_base, 496 struct lp_build_emit_data * emit_data) 497{ 498 499 LLVMValueRef abs_x, log_abs_x, flr_log_abs_x, ex2_flr_log_abs_x; 500 501 /* abs( src0.x) */ 502 abs_x = lp_build_abs(&bld_base->base, emit_data->args[0] /* src0.x */); 503 504 /* log( abs( src0.x ) ) */ 505 log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_LG2, 506 abs_x); 507 508 /* floor( log( abs( src0.x ) ) ) */ 509 flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_FLR, 510 log_abs_x); 511 /* dst.x */ 512 emit_data->output[TGSI_CHAN_X] = flr_log_abs_x; 513 514 /* dst.y */ 515 ex2_flr_log_abs_x = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_EX2, 516 flr_log_abs_x); 517 518 /* abs( src0.x ) / 2^( floor( lg2( abs( src0.x ) ) ) ) */ 519 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base, 520 TGSI_OPCODE_DIV, abs_x, ex2_flr_log_abs_x); 521 522 /* dst.x */ 523 emit_data->output[TGSI_CHAN_Z] = log_abs_x; 524 525 /* dst.w */ 526 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 527} 528 529static struct lp_build_tgsi_action log_action = { 530 scalar_unary_fetch_args, /* fetch_args */ 531 log_emit /* emit */ 532}; 533 534/* TGSI_OPCODE_PK2H */ 535 536static void 537pk2h_fetch_args( 538 struct lp_build_tgsi_context * bld_base, 539 struct lp_build_emit_data * emit_data) 540{ 541 /* src0.x */ 542 emit_data->args[0] = lp_build_emit_fetch(bld_base, emit_data->inst, 543 0, TGSI_CHAN_X); 544 /* src0.y */ 545 emit_data->args[1] = lp_build_emit_fetch(bld_base, emit_data->inst, 546 0, TGSI_CHAN_Y); 547} 548 549static void 550pk2h_emit( 551 const struct lp_build_tgsi_action *action, 552 struct lp_build_tgsi_context *bld_base, 553 struct lp_build_emit_data *emit_data) 554{ 555 struct gallivm_state *gallivm = bld_base->base.gallivm; 556 struct lp_type f16i_t; 557 LLVMValueRef lo, hi, res; 558 559 f16i_t = lp_type_uint_vec(16, bld_base->base.type.length * 32); 560 lo = lp_build_float_to_half(gallivm, emit_data->args[0]); 561 hi = lp_build_float_to_half(gallivm, emit_data->args[1]); 562 /* maybe some interleave doubling vector width would be useful... */ 563 lo = lp_build_pad_vector(gallivm, lo, bld_base->base.type.length * 2); 564 hi = lp_build_pad_vector(gallivm, hi, bld_base->base.type.length * 2); 565 res = lp_build_interleave2(gallivm, f16i_t, lo, hi, 0); 566 567 emit_data->output[emit_data->chan] = res; 568} 569 570static struct lp_build_tgsi_action pk2h_action = { 571 pk2h_fetch_args, /* fetch_args */ 572 pk2h_emit /* emit */ 573}; 574 575/* TGSI_OPCODE_UP2H */ 576 577static void 578up2h_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 struct gallivm_state *gallivm = bld_base->base.gallivm; 584 LLVMBuilderRef builder = gallivm->builder; 585 LLVMContextRef context = gallivm->context; 586 LLVMValueRef lo, hi, res[2], arg; 587 unsigned nr = bld_base->base.type.length; 588 LLVMTypeRef i16t = LLVMVectorType(LLVMInt16TypeInContext(context), nr * 2); 589 590 arg = LLVMBuildBitCast(builder, emit_data->args[0], i16t, ""); 591 lo = lp_build_uninterleave1(gallivm, nr * 2, arg, 0); 592 hi = lp_build_uninterleave1(gallivm, nr * 2, arg, 1); 593 res[0] = lp_build_half_to_float(gallivm, lo); 594 res[1] = lp_build_half_to_float(gallivm, hi); 595 596 emit_data->output[0] = emit_data->output[2] = res[0]; 597 emit_data->output[1] = emit_data->output[3] = res[1]; 598} 599 600static struct lp_build_tgsi_action up2h_action = { 601 scalar_unary_fetch_args, /* fetch_args */ 602 up2h_emit /* emit */ 603}; 604 605/* TGSI_OPCODE_LRP */ 606 607static void 608lrp_emit( 609 const struct lp_build_tgsi_action * action, 610 struct lp_build_tgsi_context * bld_base, 611 struct lp_build_emit_data * emit_data) 612{ 613 struct lp_build_context *bld = &bld_base->base; 614 LLVMValueRef inv, a, b; 615 616 /* This uses the correct version: (1 - t)*a + t*b 617 * 618 * An alternative version is "a + t*(b-a)". The problem is this version 619 * doesn't return "b" for t = 1, because "a + (b-a)" isn't equal to "b" 620 * because of the floating-point rounding. 621 */ 622 inv = lp_build_sub(bld, bld_base->base.one, emit_data->args[0]); 623 a = lp_build_mul(bld, emit_data->args[1], emit_data->args[0]); 624 b = lp_build_mul(bld, emit_data->args[2], inv); 625 emit_data->output[emit_data->chan] = lp_build_add(bld, a, b); 626} 627 628/* TGSI_OPCODE_MAD */ 629 630static void 631mad_emit( 632 const struct lp_build_tgsi_action * action, 633 struct lp_build_tgsi_context * bld_base, 634 struct lp_build_emit_data * emit_data) 635{ 636 LLVMValueRef tmp; 637 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, 638 emit_data->args[0], 639 emit_data->args[1]); 640 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 641 TGSI_OPCODE_ADD, tmp, emit_data->args[2]); 642} 643 644/* TGSI_OPCODE_MOV */ 645 646static void 647mov_emit( 648 const struct lp_build_tgsi_action * action, 649 struct lp_build_tgsi_context * bld_base, 650 struct lp_build_emit_data * emit_data) 651{ 652 emit_data->output[emit_data->chan] = emit_data->args[0]; 653} 654 655/* TGSI_OPCODE_MUL */ 656static void 657mul_emit( 658 const struct lp_build_tgsi_action * action, 659 struct lp_build_tgsi_context * bld_base, 660 struct lp_build_emit_data * emit_data) 661{ 662 emit_data->output[emit_data->chan] = LLVMBuildFMul( 663 bld_base->base.gallivm->builder, 664 emit_data->args[0], emit_data->args[1], ""); 665} 666 667/*.TGSI_OPCODE_DIV.*/ 668static void fdiv_emit( 669 const struct lp_build_tgsi_action * action, 670 struct lp_build_tgsi_context * bld_base, 671 struct lp_build_emit_data * emit_data) 672{ 673 emit_data->output[emit_data->chan] = LLVMBuildFDiv( 674 bld_base->base.gallivm->builder, 675 emit_data->args[0], emit_data->args[1], ""); 676} 677 678/*.TGSI_OPCODE_RCP.*/ 679static void rcp_emit( 680 const struct lp_build_tgsi_action * action, 681 struct lp_build_tgsi_context * bld_base, 682 struct lp_build_emit_data * emit_data) 683{ 684 LLVMValueRef one; 685 one = lp_build_const_float(bld_base->base.gallivm, 1.0f); 686 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 687 TGSI_OPCODE_DIV, one, emit_data->args[0]); 688} 689 690/* TGSI_OPCODE_POW */ 691 692static void 693pow_emit( 694 const struct lp_build_tgsi_action * action, 695 struct lp_build_tgsi_context * bld_base, 696 struct lp_build_emit_data * emit_data) 697{ 698 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base, 699 emit_data->args[0], emit_data->args[1]); 700} 701 702static struct lp_build_tgsi_action pow_action = { 703 scalar_binary_fetch_args, /* fetch_args */ 704 pow_emit /* emit */ 705}; 706 707/* TGSI_OPCODE_RSQ */ 708 709static void 710rsq_emit( 711 const struct lp_build_tgsi_action * action, 712 struct lp_build_tgsi_context * bld_base, 713 struct lp_build_emit_data * emit_data) 714{ 715 if (bld_base->rsq_action.emit) { 716 bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data); 717 } else { 718 emit_data->output[emit_data->chan] = bld_base->base.undef; 719 } 720} 721 722const struct lp_build_tgsi_action rsq_action = { 723 scalar_unary_fetch_args, /* fetch_args */ 724 rsq_emit /* emit */ 725 726}; 727 728/* TGSI_OPCODE_SQRT */ 729 730static void 731sqrt_emit( 732 const struct lp_build_tgsi_action * action, 733 struct lp_build_tgsi_context * bld_base, 734 struct lp_build_emit_data * emit_data) 735{ 736 if (bld_base->sqrt_action.emit) { 737 bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data); 738 } else { 739 emit_data->output[emit_data->chan] = bld_base->base.undef; 740 } 741} 742 743const struct lp_build_tgsi_action sqrt_action = { 744 scalar_unary_fetch_args, /* fetch_args */ 745 sqrt_emit /* emit */ 746}; 747 748/* TGSI_OPCODE_SCS */ 749static void 750scs_emit( 751 const struct lp_build_tgsi_action * action, 752 struct lp_build_tgsi_context * bld_base, 753 struct lp_build_emit_data * emit_data) 754{ 755 /* dst.x */ 756 emit_data->output[TGSI_CHAN_X] = lp_build_emit_llvm_unary(bld_base, 757 TGSI_OPCODE_COS, emit_data->args[0]); 758 /* dst.y */ 759 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_unary(bld_base, 760 TGSI_OPCODE_SIN, emit_data->args[0]); 761 /* dst.z */ 762 emit_data->output[TGSI_CHAN_Z] = bld_base->base.zero; 763 764 /* dst.w */ 765 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 766} 767 768const struct lp_build_tgsi_action scs_action = { 769 scalar_unary_fetch_args, /* fetch_args */ 770 scs_emit /* emit */ 771}; 772 773/* TGSI_OPCODE_F2U */ 774static void 775f2u_emit( 776 const struct lp_build_tgsi_action * action, 777 struct lp_build_tgsi_context * bld_base, 778 struct lp_build_emit_data * emit_data) 779{ 780 emit_data->output[emit_data->chan] = 781 LLVMBuildFPToUI(bld_base->base.gallivm->builder, 782 emit_data->args[0], 783 bld_base->base.int_vec_type, ""); 784} 785 786/* TGSI_OPCODE_U2F */ 787static void 788u2f_emit( 789 const struct lp_build_tgsi_action * action, 790 struct lp_build_tgsi_context * bld_base, 791 struct lp_build_emit_data * emit_data) 792{ 793 emit_data->output[emit_data->chan] = 794 LLVMBuildUIToFP(bld_base->base.gallivm->builder, 795 emit_data->args[0], 796 bld_base->base.vec_type, ""); 797} 798 799static void 800umad_emit( 801 const struct lp_build_tgsi_action * action, 802 struct lp_build_tgsi_context * bld_base, 803 struct lp_build_emit_data * emit_data) 804{ 805 LLVMValueRef tmp; 806 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL, 807 emit_data->args[0], 808 emit_data->args[1]); 809 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 810 TGSI_OPCODE_UADD, tmp, emit_data->args[2]); 811} 812 813/* TGSI_OPCODE_UMUL */ 814static void 815umul_emit( 816 const struct lp_build_tgsi_action * action, 817 struct lp_build_tgsi_context * bld_base, 818 struct lp_build_emit_data * emit_data) 819{ 820 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld, 821 emit_data->args[0], emit_data->args[1]); 822} 823 824/* TGSI_OPCODE_IMUL_HI */ 825static void 826imul_hi_emit( 827 const struct lp_build_tgsi_action * action, 828 struct lp_build_tgsi_context * bld_base, 829 struct lp_build_emit_data * emit_data) 830{ 831 struct lp_build_context *int_bld = &bld_base->int_bld; 832 LLVMValueRef hi_bits; 833 834 assert(int_bld->type.width == 32); 835 836 /* low result bits are tossed away */ 837 lp_build_mul_32_lohi(int_bld, emit_data->args[0], 838 emit_data->args[1], &hi_bits); 839 emit_data->output[emit_data->chan] = hi_bits; 840} 841 842static void 843imul_hi_emit_cpu( 844 const struct lp_build_tgsi_action * action, 845 struct lp_build_tgsi_context * bld_base, 846 struct lp_build_emit_data * emit_data) 847{ 848 struct lp_build_context *int_bld = &bld_base->int_bld; 849 LLVMValueRef hi_bits; 850 851 assert(int_bld->type.width == 32); 852 853 /* low result bits are tossed away */ 854 lp_build_mul_32_lohi_cpu(int_bld, emit_data->args[0], 855 emit_data->args[1], &hi_bits); 856 emit_data->output[emit_data->chan] = hi_bits; 857} 858 859/* TGSI_OPCODE_UMUL_HI */ 860static void 861umul_hi_emit( 862 const struct lp_build_tgsi_action * action, 863 struct lp_build_tgsi_context * bld_base, 864 struct lp_build_emit_data * emit_data) 865{ 866 struct lp_build_context *uint_bld = &bld_base->uint_bld; 867 LLVMValueRef hi_bits; 868 869 assert(uint_bld->type.width == 32); 870 871 /* low result bits are tossed away */ 872 lp_build_mul_32_lohi(uint_bld, emit_data->args[0], 873 emit_data->args[1], &hi_bits); 874 emit_data->output[emit_data->chan] = hi_bits; 875} 876 877static void 878umul_hi_emit_cpu( 879 const struct lp_build_tgsi_action * action, 880 struct lp_build_tgsi_context * bld_base, 881 struct lp_build_emit_data * emit_data) 882{ 883 struct lp_build_context *uint_bld = &bld_base->uint_bld; 884 LLVMValueRef hi_bits; 885 886 assert(uint_bld->type.width == 32); 887 888 /* low result bits are tossed away */ 889 lp_build_mul_32_lohi_cpu(uint_bld, emit_data->args[0], 890 emit_data->args[1], &hi_bits); 891 emit_data->output[emit_data->chan] = hi_bits; 892} 893 894/* TGSI_OPCODE_MAX */ 895static void fmax_emit( 896 const struct lp_build_tgsi_action * action, 897 struct lp_build_tgsi_context * bld_base, 898 struct lp_build_emit_data * emit_data) 899{ 900 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 901 emit_data->output[emit_data->chan] = LLVMBuildSelect(builder, 902 LLVMBuildFCmp(builder, LLVMRealUGE, 903 emit_data->args[0], emit_data->args[1], ""), 904 emit_data->args[0], emit_data->args[1], ""); 905} 906 907/* TGSI_OPCODE_MIN */ 908static void fmin_emit( 909 const struct lp_build_tgsi_action * action, 910 struct lp_build_tgsi_context * bld_base, 911 struct lp_build_emit_data * emit_data) 912{ 913 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 914 emit_data->output[emit_data->chan] = LLVMBuildSelect(builder, 915 LLVMBuildFCmp(builder, LLVMRealUGE, 916 emit_data->args[0], emit_data->args[1], ""), 917 emit_data->args[1], emit_data->args[0], ""); 918} 919 920/* TGSI_OPCODE_XPD */ 921 922static void 923xpd_fetch_args( 924 struct lp_build_tgsi_context * bld_base, 925 struct lp_build_emit_data * emit_data) 926{ 927 dp_fetch_args(bld_base, emit_data, 3); 928} 929 930/** 931 * (a * b) - (c * d) 932 */ 933static LLVMValueRef 934xpd_helper( 935 struct lp_build_tgsi_context * bld_base, 936 LLVMValueRef a, 937 LLVMValueRef b, 938 LLVMValueRef c, 939 LLVMValueRef d) 940{ 941 LLVMValueRef tmp0, tmp1; 942 943 tmp0 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, a, b); 944 tmp1 = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_MUL, c, d); 945 946 return lp_build_sub(&bld_base->base, tmp0, tmp1); 947} 948 949static void 950xpd_emit( 951 const struct lp_build_tgsi_action * action, 952 struct lp_build_tgsi_context * bld_base, 953 struct lp_build_emit_data * emit_data) 954{ 955 emit_data->output[TGSI_CHAN_X] = xpd_helper(bld_base, 956 emit_data->args[1] /* src0.y */, emit_data->args[5] /* src1.z */, 957 emit_data->args[4] /* src1.y */, emit_data->args[2] /* src0.z */); 958 959 emit_data->output[TGSI_CHAN_Y] = xpd_helper(bld_base, 960 emit_data->args[2] /* src0.z */, emit_data->args[3] /* src1.x */, 961 emit_data->args[5] /* src1.z */, emit_data->args[0] /* src0.x */); 962 963 emit_data->output[TGSI_CHAN_Z] = xpd_helper(bld_base, 964 emit_data->args[0] /* src0.x */, emit_data->args[4] /* src1.y */, 965 emit_data->args[3] /* src1.x */, emit_data->args[1] /* src0.y */); 966 967 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 968} 969 970const struct lp_build_tgsi_action xpd_action = { 971 xpd_fetch_args, /* fetch_args */ 972 xpd_emit /* emit */ 973}; 974 975/* TGSI_OPCODE_D2F */ 976static void 977d2f_emit( 978 const struct lp_build_tgsi_action * action, 979 struct lp_build_tgsi_context * bld_base, 980 struct lp_build_emit_data * emit_data) 981{ 982 emit_data->output[emit_data->chan] = 983 LLVMBuildFPTrunc(bld_base->base.gallivm->builder, 984 emit_data->args[0], 985 bld_base->base.vec_type, ""); 986} 987 988/* TGSI_OPCODE_D2I */ 989static void 990d2i_emit( 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] = 996 LLVMBuildFPToSI(bld_base->base.gallivm->builder, 997 emit_data->args[0], 998 bld_base->base.int_vec_type, ""); 999} 1000 1001/* TGSI_OPCODE_D2U */ 1002static void 1003d2u_emit( 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] = 1009 LLVMBuildFPToUI(bld_base->base.gallivm->builder, 1010 emit_data->args[0], 1011 bld_base->base.int_vec_type, ""); 1012} 1013 1014/* TGSI_OPCODE_F2D */ 1015static void 1016f2d_emit( 1017 const struct lp_build_tgsi_action * action, 1018 struct lp_build_tgsi_context * bld_base, 1019 struct lp_build_emit_data * emit_data) 1020{ 1021 emit_data->output[emit_data->chan] = 1022 LLVMBuildFPExt(bld_base->base.gallivm->builder, 1023 emit_data->args[0], 1024 bld_base->dbl_bld.vec_type, ""); 1025} 1026 1027/* TGSI_OPCODE_U2D */ 1028static void 1029u2d_emit( 1030 const struct lp_build_tgsi_action * action, 1031 struct lp_build_tgsi_context * bld_base, 1032 struct lp_build_emit_data * emit_data) 1033{ 1034 emit_data->output[emit_data->chan] = 1035 LLVMBuildUIToFP(bld_base->base.gallivm->builder, 1036 emit_data->args[0], 1037 bld_base->dbl_bld.vec_type, ""); 1038} 1039 1040/* TGSI_OPCODE_I2D */ 1041static void 1042i2d_emit( 1043 const struct lp_build_tgsi_action * action, 1044 struct lp_build_tgsi_context * bld_base, 1045 struct lp_build_emit_data * emit_data) 1046{ 1047 emit_data->output[emit_data->chan] = 1048 LLVMBuildSIToFP(bld_base->base.gallivm->builder, 1049 emit_data->args[0], 1050 bld_base->dbl_bld.vec_type, ""); 1051} 1052 1053/* TGSI_OPCODE_DMAD */ 1054static void 1055dmad_emit( 1056 const struct lp_build_tgsi_action * action, 1057 struct lp_build_tgsi_context * bld_base, 1058 struct lp_build_emit_data * emit_data) 1059{ 1060 LLVMValueRef tmp; 1061 tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_DMUL, 1062 emit_data->args[0], 1063 emit_data->args[1]); 1064 emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, 1065 TGSI_OPCODE_DADD, tmp, emit_data->args[2]); 1066} 1067 1068/*.TGSI_OPCODE_DRCP.*/ 1069static void drcp_emit( 1070 const struct lp_build_tgsi_action * action, 1071 struct lp_build_tgsi_context * bld_base, 1072 struct lp_build_emit_data * emit_data) 1073{ 1074 LLVMValueRef one; 1075 one = lp_build_const_vec(bld_base->dbl_bld.gallivm, bld_base->dbl_bld.type, 1.0f); 1076 emit_data->output[emit_data->chan] = LLVMBuildFDiv( 1077 bld_base->base.gallivm->builder, 1078 one, emit_data->args[0], ""); 1079} 1080 1081/* TGSI_OPCODE_DFRAC */ 1082static void dfrac_emit( 1083 const struct lp_build_tgsi_action * action, 1084 struct lp_build_tgsi_context * bld_base, 1085 struct lp_build_emit_data * emit_data) 1086{ 1087 LLVMValueRef tmp; 1088 tmp = lp_build_floor(&bld_base->dbl_bld, 1089 emit_data->args[0]); 1090 emit_data->output[emit_data->chan] = LLVMBuildFSub(bld_base->base.gallivm->builder, 1091 emit_data->args[0], tmp, ""); 1092} 1093 1094static void 1095u64mul_emit( 1096 const struct lp_build_tgsi_action * action, 1097 struct lp_build_tgsi_context * bld_base, 1098 struct lp_build_emit_data * emit_data) 1099{ 1100 emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint64_bld, 1101 emit_data->args[0], emit_data->args[1]); 1102} 1103 1104static void 1105u64mod_emit_cpu( 1106 const struct lp_build_tgsi_action * action, 1107 struct lp_build_tgsi_context * bld_base, 1108 struct lp_build_emit_data * emit_data) 1109{ 1110 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1111 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld, 1112 PIPE_FUNC_EQUAL, emit_data->args[1], 1113 bld_base->uint64_bld.zero); 1114 /* We want to make sure that we never divide/mod by zero to not 1115 * generate sigfpe. We don't want to crash just because the 1116 * shader is doing something weird. */ 1117 LLVMValueRef divisor = LLVMBuildOr(builder, 1118 div_mask, 1119 emit_data->args[1], ""); 1120 LLVMValueRef result = lp_build_mod(&bld_base->uint64_bld, 1121 emit_data->args[0], divisor); 1122 /* umod by zero doesn't have a guaranteed return value chose -1 for now. */ 1123 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 1124 div_mask, 1125 result, ""); 1126} 1127 1128static void 1129i64mod_emit_cpu( 1130 const struct lp_build_tgsi_action * action, 1131 struct lp_build_tgsi_context * bld_base, 1132 struct lp_build_emit_data * emit_data) 1133{ 1134 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1135 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld, 1136 PIPE_FUNC_EQUAL, emit_data->args[1], 1137 bld_base->uint64_bld.zero); 1138 /* We want to make sure that we never divide/mod by zero to not 1139 * generate sigfpe. We don't want to crash just because the 1140 * shader is doing something weird. */ 1141 LLVMValueRef divisor = LLVMBuildOr(builder, 1142 div_mask, 1143 emit_data->args[1], ""); 1144 LLVMValueRef result = lp_build_mod(&bld_base->int64_bld, 1145 emit_data->args[0], divisor); 1146 /* umod by zero doesn't have a guaranteed return value chose -1 for now. */ 1147 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 1148 div_mask, 1149 result, ""); 1150} 1151 1152static void 1153u64div_emit_cpu( 1154 const struct lp_build_tgsi_action * action, 1155 struct lp_build_tgsi_context * bld_base, 1156 struct lp_build_emit_data * emit_data) 1157{ 1158 1159 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1160 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint64_bld, 1161 PIPE_FUNC_EQUAL, emit_data->args[1], 1162 bld_base->uint64_bld.zero); 1163 /* We want to make sure that we never divide/mod by zero to not 1164 * generate sigfpe. We don't want to crash just because the 1165 * shader is doing something weird. */ 1166 LLVMValueRef divisor = LLVMBuildOr(builder, 1167 div_mask, 1168 emit_data->args[1], ""); 1169 LLVMValueRef result = LLVMBuildUDiv(builder, 1170 emit_data->args[0], divisor, ""); 1171 /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */ 1172 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 1173 div_mask, 1174 result, ""); 1175} 1176 1177static void 1178i64div_emit_cpu( 1179 const struct lp_build_tgsi_action * action, 1180 struct lp_build_tgsi_context * bld_base, 1181 struct lp_build_emit_data * emit_data) 1182{ 1183 1184 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1185 LLVMValueRef div_mask = lp_build_cmp(&bld_base->int64_bld, 1186 PIPE_FUNC_EQUAL, emit_data->args[1], 1187 bld_base->int64_bld.zero); 1188 /* We want to make sure that we never divide/mod by zero to not 1189 * generate sigfpe. We don't want to crash just because the 1190 * shader is doing something weird. */ 1191 LLVMValueRef divisor = LLVMBuildOr(builder, 1192 div_mask, 1193 emit_data->args[1], ""); 1194 LLVMValueRef result = LLVMBuildSDiv(builder, 1195 emit_data->args[0], divisor, ""); 1196 /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */ 1197 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 1198 div_mask, 1199 result, ""); 1200} 1201 1202static void 1203f2u64_emit( 1204 const struct lp_build_tgsi_action * action, 1205 struct lp_build_tgsi_context * bld_base, 1206 struct lp_build_emit_data * emit_data) 1207{ 1208 emit_data->output[emit_data->chan] = 1209 LLVMBuildFPToUI(bld_base->base.gallivm->builder, 1210 emit_data->args[0], 1211 bld_base->uint64_bld.vec_type, ""); 1212} 1213 1214static void 1215f2i64_emit( 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] = 1221 LLVMBuildFPToSI(bld_base->base.gallivm->builder, 1222 emit_data->args[0], 1223 bld_base->int64_bld.vec_type, ""); 1224} 1225 1226static void 1227u2i64_emit( 1228 const struct lp_build_tgsi_action * action, 1229 struct lp_build_tgsi_context * bld_base, 1230 struct lp_build_emit_data * emit_data) 1231{ 1232 emit_data->output[emit_data->chan] = 1233 LLVMBuildZExt(bld_base->base.gallivm->builder, 1234 emit_data->args[0], 1235 bld_base->uint64_bld.vec_type, ""); 1236} 1237 1238static void 1239i2i64_emit( 1240 const struct lp_build_tgsi_action * action, 1241 struct lp_build_tgsi_context * bld_base, 1242 struct lp_build_emit_data * emit_data) 1243{ 1244 emit_data->output[emit_data->chan] = 1245 LLVMBuildSExt(bld_base->base.gallivm->builder, 1246 emit_data->args[0], 1247 bld_base->int64_bld.vec_type, ""); 1248} 1249 1250static void 1251i642f_emit( 1252 const struct lp_build_tgsi_action * action, 1253 struct lp_build_tgsi_context * bld_base, 1254 struct lp_build_emit_data * emit_data) 1255{ 1256 emit_data->output[emit_data->chan] = 1257 LLVMBuildSIToFP(bld_base->base.gallivm->builder, 1258 emit_data->args[0], 1259 bld_base->base.vec_type, ""); 1260} 1261 1262static void 1263u642f_emit( 1264 const struct lp_build_tgsi_action * action, 1265 struct lp_build_tgsi_context * bld_base, 1266 struct lp_build_emit_data * emit_data) 1267{ 1268 emit_data->output[emit_data->chan] = 1269 LLVMBuildUIToFP(bld_base->base.gallivm->builder, 1270 emit_data->args[0], 1271 bld_base->base.vec_type, ""); 1272} 1273 1274static void 1275i642d_emit( 1276 const struct lp_build_tgsi_action * action, 1277 struct lp_build_tgsi_context * bld_base, 1278 struct lp_build_emit_data * emit_data) 1279{ 1280 emit_data->output[emit_data->chan] = 1281 LLVMBuildSIToFP(bld_base->base.gallivm->builder, 1282 emit_data->args[0], 1283 bld_base->dbl_bld.vec_type, ""); 1284} 1285 1286static void 1287u642d_emit( 1288 const struct lp_build_tgsi_action * action, 1289 struct lp_build_tgsi_context * bld_base, 1290 struct lp_build_emit_data * emit_data) 1291{ 1292 emit_data->output[emit_data->chan] = 1293 LLVMBuildUIToFP(bld_base->base.gallivm->builder, 1294 emit_data->args[0], 1295 bld_base->dbl_bld.vec_type, ""); 1296} 1297 1298void 1299lp_set_default_actions(struct lp_build_tgsi_context * bld_base) 1300{ 1301 bld_base->op_actions[TGSI_OPCODE_DP2] = dp2_action; 1302 bld_base->op_actions[TGSI_OPCODE_DP3] = dp3_action; 1303 bld_base->op_actions[TGSI_OPCODE_DP4] = dp4_action; 1304 bld_base->op_actions[TGSI_OPCODE_DP2A] = dp2a_action; 1305 bld_base->op_actions[TGSI_OPCODE_DPH] = dph_action; 1306 bld_base->op_actions[TGSI_OPCODE_DST] = dst_action; 1307 bld_base->op_actions[TGSI_OPCODE_EXP] = exp_action; 1308 bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action; 1309 bld_base->op_actions[TGSI_OPCODE_LOG] = log_action; 1310 bld_base->op_actions[TGSI_OPCODE_PK2H] = pk2h_action; 1311 bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action; 1312 bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action; 1313 bld_base->op_actions[TGSI_OPCODE_POW] = pow_action; 1314 bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action; 1315 bld_base->op_actions[TGSI_OPCODE_UP2H] = up2h_action; 1316 bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action; 1317 1318 bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args; 1319 bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args; 1320 bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args; 1321 bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args; 1322 bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args; 1323 bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args; 1324 bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args; 1325 bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args; 1326 bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args; 1327 bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args; 1328 bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args; 1329 bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args; 1330 1331 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit; 1332 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit; 1333 bld_base->op_actions[TGSI_OPCODE_CLAMP].emit = clamp_emit; 1334 bld_base->op_actions[TGSI_OPCODE_END].emit = end_emit; 1335 bld_base->op_actions[TGSI_OPCODE_FRC].emit = frc_emit; 1336 bld_base->op_actions[TGSI_OPCODE_LRP].emit = lrp_emit; 1337 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit; 1338 bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit; 1339 bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit; 1340 bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit; 1341 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit; 1342 1343 bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit; 1344 bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit; 1345 bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit; 1346 bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit; 1347 bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit; 1348 bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit; 1349 bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit; 1350 1351 bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit; 1352 bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit; 1353 1354 bld_base->op_actions[TGSI_OPCODE_DADD].emit = add_emit; 1355 bld_base->op_actions[TGSI_OPCODE_DMAX].emit = fmax_emit; 1356 bld_base->op_actions[TGSI_OPCODE_DMIN].emit = fmin_emit; 1357 bld_base->op_actions[TGSI_OPCODE_DMUL].emit = mul_emit; 1358 bld_base->op_actions[TGSI_OPCODE_DDIV].emit = fdiv_emit; 1359 1360 bld_base->op_actions[TGSI_OPCODE_D2F].emit = d2f_emit; 1361 bld_base->op_actions[TGSI_OPCODE_D2I].emit = d2i_emit; 1362 bld_base->op_actions[TGSI_OPCODE_D2U].emit = d2u_emit; 1363 1364 bld_base->op_actions[TGSI_OPCODE_F2D].emit = f2d_emit; 1365 bld_base->op_actions[TGSI_OPCODE_I2D].emit = i2d_emit; 1366 bld_base->op_actions[TGSI_OPCODE_U2D].emit = u2d_emit; 1367 1368 bld_base->op_actions[TGSI_OPCODE_DMAD].emit = dmad_emit; 1369 1370 bld_base->op_actions[TGSI_OPCODE_DRCP].emit = drcp_emit; 1371 bld_base->op_actions[TGSI_OPCODE_DFRAC].emit = dfrac_emit; 1372 1373 bld_base->op_actions[TGSI_OPCODE_U64MUL].emit = u64mul_emit; 1374 1375 bld_base->op_actions[TGSI_OPCODE_F2I64].emit = f2i64_emit; 1376 bld_base->op_actions[TGSI_OPCODE_F2U64].emit = f2u64_emit; 1377 1378 bld_base->op_actions[TGSI_OPCODE_D2I64].emit = f2i64_emit; 1379 bld_base->op_actions[TGSI_OPCODE_D2U64].emit = f2u64_emit; 1380 1381 bld_base->op_actions[TGSI_OPCODE_I2I64].emit = i2i64_emit; 1382 bld_base->op_actions[TGSI_OPCODE_U2I64].emit = u2i64_emit; 1383 1384 bld_base->op_actions[TGSI_OPCODE_I642F].emit = i642f_emit; 1385 bld_base->op_actions[TGSI_OPCODE_U642F].emit = u642f_emit; 1386 1387 bld_base->op_actions[TGSI_OPCODE_I642F].emit = i642f_emit; 1388 bld_base->op_actions[TGSI_OPCODE_U642F].emit = u642f_emit; 1389 1390 bld_base->op_actions[TGSI_OPCODE_I642D].emit = i642d_emit; 1391 bld_base->op_actions[TGSI_OPCODE_U642D].emit = u642d_emit; 1392 1393} 1394 1395/* CPU Only default actions */ 1396 1397/* These actions are CPU only, because they could potentially output SSE 1398 * intrinsics. 1399 */ 1400 1401/* TGSI_OPCODE_ADD (CPU Only) */ 1402static void 1403add_emit_cpu( 1404 const struct lp_build_tgsi_action * action, 1405 struct lp_build_tgsi_context * bld_base, 1406 struct lp_build_emit_data * emit_data) 1407{ 1408 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->base, 1409 emit_data->args[0], emit_data->args[1]); 1410} 1411 1412/* TGSI_OPCODE_AND (CPU Only) */ 1413static void 1414and_emit_cpu( 1415 const struct lp_build_tgsi_action * action, 1416 struct lp_build_tgsi_context * bld_base, 1417 struct lp_build_emit_data * emit_data) 1418{ 1419 emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld, 1420 emit_data->args[0], emit_data->args[1]); 1421} 1422 1423/* TGSI_OPCODE_ARL (CPU Only) */ 1424static void 1425arl_emit_cpu( 1426 const struct lp_build_tgsi_action * action, 1427 struct lp_build_tgsi_context * bld_base, 1428 struct lp_build_emit_data * emit_data) 1429{ 1430 LLVMValueRef tmp; 1431 tmp = lp_build_floor(&bld_base->base, 1432 emit_data->args[0]); 1433 emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp, 1434 bld_base->uint_bld.vec_type, ""); 1435} 1436 1437/* TGSI_OPCODE_ARR (CPU Only) */ 1438static void 1439arr_emit_cpu( 1440 const struct lp_build_tgsi_action * action, 1441 struct lp_build_tgsi_context * bld_base, 1442 struct lp_build_emit_data * emit_data) 1443{ 1444 emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]); 1445} 1446 1447/* TGSI_OPCODE_CEIL (CPU Only) */ 1448static void 1449ceil_emit_cpu( 1450 const struct lp_build_tgsi_action * action, 1451 struct lp_build_tgsi_context * bld_base, 1452 struct lp_build_emit_data * emit_data) 1453{ 1454 emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base, 1455 emit_data->args[0]); 1456} 1457 1458/* TGSI_OPCODE_CMP (CPU Only) */ 1459static void 1460cmp_emit_cpu( 1461 const struct lp_build_tgsi_action * action, 1462 struct lp_build_tgsi_context * bld_base, 1463 struct lp_build_emit_data * emit_data) 1464{ 1465 LLVMValueRef cond = lp_build_cmp(&bld_base->base, PIPE_FUNC_LESS, 1466 emit_data->args[0], bld_base->base.zero); 1467 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base, 1468 cond, emit_data->args[1], emit_data->args[2]); 1469} 1470 1471/* TGSI_OPCODE_UCMP (CPU Only) */ 1472static void 1473ucmp_emit_cpu( 1474 const struct lp_build_tgsi_action * action, 1475 struct lp_build_tgsi_context * bld_base, 1476 struct lp_build_emit_data * emit_data) 1477{ 1478 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1479 struct lp_build_context *uint_bld = &bld_base->uint_bld; 1480 LLVMValueRef unsigned_cond = 1481 LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, ""); 1482 LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL, 1483 unsigned_cond, 1484 uint_bld->zero); 1485 emit_data->output[emit_data->chan] = 1486 lp_build_select(&bld_base->base, 1487 cond, emit_data->args[1], emit_data->args[2]); 1488} 1489 1490/* TGSI_OPCODE_COS (CPU Only) */ 1491static void 1492cos_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 emit_data->output[emit_data->chan] = lp_build_cos(&bld_base->base, 1498 emit_data->args[0]); 1499} 1500 1501/* TGSI_OPCODE_DIV (CPU Only) */ 1502static void 1503div_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 emit_data->output[emit_data->chan] = lp_build_div(&bld_base->base, 1509 emit_data->args[0], emit_data->args[1]); 1510} 1511 1512/* TGSI_OPCODE_EX2 (CPU Only) */ 1513static void 1514ex2_emit_cpu( 1515 const struct lp_build_tgsi_action * action, 1516 struct lp_build_tgsi_context * bld_base, 1517 struct lp_build_emit_data * emit_data) 1518{ 1519 emit_data->output[emit_data->chan] = lp_build_exp2(&bld_base->base, 1520 emit_data->args[0]); 1521} 1522 1523/* TGSI_OPCODE_F2I (CPU Only) */ 1524static void 1525f2i_emit_cpu( 1526 const struct lp_build_tgsi_action * action, 1527 struct lp_build_tgsi_context * bld_base, 1528 struct lp_build_emit_data * emit_data) 1529{ 1530 emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base, 1531 emit_data->args[0]); 1532} 1533 1534/* TGSI_OPCODE_FSET Helper (CPU Only) */ 1535static void 1536fset_emit_cpu( 1537 const struct lp_build_tgsi_action * action, 1538 struct lp_build_tgsi_context * bld_base, 1539 struct lp_build_emit_data * emit_data, 1540 unsigned pipe_func) 1541{ 1542 LLVMValueRef cond; 1543 1544 if (pipe_func != PIPE_FUNC_NOTEQUAL) { 1545 cond = lp_build_cmp_ordered(&bld_base->base, pipe_func, 1546 emit_data->args[0], emit_data->args[1]); 1547 } 1548 else { 1549 cond = lp_build_cmp(&bld_base->base, pipe_func, 1550 emit_data->args[0], emit_data->args[1]); 1551 1552 } 1553 emit_data->output[emit_data->chan] = cond; 1554} 1555 1556 1557/* TGSI_OPCODE_FSEQ (CPU Only) */ 1558static void 1559fseq_emit_cpu( 1560 const struct lp_build_tgsi_action * action, 1561 struct lp_build_tgsi_context * bld_base, 1562 struct lp_build_emit_data * emit_data) 1563{ 1564 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 1565} 1566 1567/* TGSI_OPCODE_ISGE (CPU Only) */ 1568static void 1569fsge_emit_cpu( 1570 const struct lp_build_tgsi_action * action, 1571 struct lp_build_tgsi_context * bld_base, 1572 struct lp_build_emit_data * emit_data) 1573{ 1574 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 1575} 1576 1577/* TGSI_OPCODE_ISLT (CPU Only) */ 1578static void 1579fslt_emit_cpu( 1580 const struct lp_build_tgsi_action * action, 1581 struct lp_build_tgsi_context * bld_base, 1582 struct lp_build_emit_data * emit_data) 1583{ 1584 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 1585} 1586 1587/* TGSI_OPCODE_USNE (CPU Only) */ 1588 1589static void 1590fsne_emit_cpu( 1591 const struct lp_build_tgsi_action * action, 1592 struct lp_build_tgsi_context * bld_base, 1593 struct lp_build_emit_data * emit_data) 1594{ 1595 fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 1596} 1597 1598/* TGSI_OPCODE_FLR (CPU Only) */ 1599 1600static void 1601flr_emit_cpu( 1602 const struct lp_build_tgsi_action * action, 1603 struct lp_build_tgsi_context * bld_base, 1604 struct lp_build_emit_data * emit_data) 1605{ 1606 emit_data->output[emit_data->chan] = lp_build_floor(&bld_base->base, 1607 emit_data->args[0]); 1608} 1609 1610/* TGSI_OPCODE_I2F (CPU Only) */ 1611static void 1612i2f_emit_cpu( 1613 const struct lp_build_tgsi_action * action, 1614 struct lp_build_tgsi_context * bld_base, 1615 struct lp_build_emit_data * emit_data) 1616{ 1617 emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base, 1618 emit_data->args[0]); 1619} 1620 1621/* TGSI_OPCODE_IABS (CPU Only) */ 1622static void 1623iabs_emit_cpu( 1624 const struct lp_build_tgsi_action * action, 1625 struct lp_build_tgsi_context * bld_base, 1626 struct lp_build_emit_data * emit_data) 1627{ 1628 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld, 1629 emit_data->args[0]); 1630} 1631 1632/* TGSI_OPCODE_IDIV (CPU Only) */ 1633static void 1634idiv_emit_cpu( 1635 const struct lp_build_tgsi_action * action, 1636 struct lp_build_tgsi_context * bld_base, 1637 struct lp_build_emit_data * emit_data) 1638{ 1639 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1640 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld, 1641 PIPE_FUNC_EQUAL, emit_data->args[1], 1642 bld_base->uint_bld.zero); 1643 /* We want to make sure that we never divide/mod by zero to not 1644 * generate sigfpe. We don't want to crash just because the 1645 * shader is doing something weird. */ 1646 LLVMValueRef divisor = LLVMBuildOr(builder, 1647 div_mask, 1648 emit_data->args[1], ""); 1649 LLVMValueRef result = lp_build_div(&bld_base->int_bld, 1650 emit_data->args[0], divisor); 1651 LLVMValueRef not_div_mask = LLVMBuildNot(builder, 1652 div_mask,""); 1653 /* idiv by zero doesn't have a guaranteed return value chose 0 for now. */ 1654 emit_data->output[emit_data->chan] = LLVMBuildAnd(builder, 1655 not_div_mask, 1656 result, ""); 1657} 1658 1659/* TGSI_OPCODE_INEG (CPU Only) */ 1660static void 1661ineg_emit_cpu( 1662 const struct lp_build_tgsi_action * action, 1663 struct lp_build_tgsi_context * bld_base, 1664 struct lp_build_emit_data * emit_data) 1665{ 1666 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld, 1667 bld_base->int_bld.zero, 1668 emit_data->args[0]); 1669} 1670 1671/* TGSI_OPCODE_ISET Helper (CPU Only) */ 1672static void 1673iset_emit_cpu( 1674 const struct lp_build_tgsi_action * action, 1675 struct lp_build_tgsi_context * bld_base, 1676 struct lp_build_emit_data * emit_data, 1677 unsigned pipe_func) 1678{ 1679 LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func, 1680 emit_data->args[0], emit_data->args[1]); 1681 emit_data->output[emit_data->chan] = cond; 1682} 1683 1684/* TGSI_OPCODE_IMAX (CPU Only) */ 1685static void 1686imax_emit_cpu( 1687 const struct lp_build_tgsi_action * action, 1688 struct lp_build_tgsi_context * bld_base, 1689 struct lp_build_emit_data * emit_data) 1690{ 1691 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld, 1692 emit_data->args[0], emit_data->args[1]); 1693} 1694 1695/* TGSI_OPCODE_IMIN (CPU Only) */ 1696static void 1697imin_emit_cpu( 1698 const struct lp_build_tgsi_action * action, 1699 struct lp_build_tgsi_context * bld_base, 1700 struct lp_build_emit_data * emit_data) 1701{ 1702 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld, 1703 emit_data->args[0], emit_data->args[1]); 1704} 1705 1706/* TGSI_OPCODE_ISGE (CPU Only) */ 1707static void 1708isge_emit_cpu( 1709 const struct lp_build_tgsi_action * action, 1710 struct lp_build_tgsi_context * bld_base, 1711 struct lp_build_emit_data * emit_data) 1712{ 1713 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 1714} 1715 1716/* TGSI_OPCODE_ISHR (CPU Only) */ 1717static void 1718ishr_emit_cpu( 1719 const struct lp_build_tgsi_action * action, 1720 struct lp_build_tgsi_context * bld_base, 1721 struct lp_build_emit_data * emit_data) 1722{ 1723 struct lp_build_context *int_bld = &bld_base->int_bld; 1724 LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type, 1725 int_bld->type.width - 1); 1726 LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask); 1727 emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0], 1728 masked_count); 1729} 1730 1731/* TGSI_OPCODE_ISLT (CPU Only) */ 1732static void 1733islt_emit_cpu( 1734 const struct lp_build_tgsi_action * action, 1735 struct lp_build_tgsi_context * bld_base, 1736 struct lp_build_emit_data * emit_data) 1737{ 1738 iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 1739} 1740 1741 1742/* TGSI_OPCODE_ISSG (CPU Only) */ 1743static void 1744issg_emit_cpu( 1745 const struct lp_build_tgsi_action * action, 1746 struct lp_build_tgsi_context * bld_base, 1747 struct lp_build_emit_data * emit_data) 1748{ 1749 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld, 1750 emit_data->args[0]); 1751} 1752 1753/* TGSI_OPCODE_LG2 (CPU Only) */ 1754static void 1755lg2_emit_cpu( 1756 const struct lp_build_tgsi_action * action, 1757 struct lp_build_tgsi_context * bld_base, 1758 struct lp_build_emit_data * emit_data) 1759{ 1760 emit_data->output[emit_data->chan] = lp_build_log2_safe(&bld_base->base, 1761 emit_data->args[0]); 1762} 1763 1764/* TGSI_OPCODE_LOG (CPU Only) */ 1765static void 1766log_emit_cpu( 1767 const struct lp_build_tgsi_action * action, 1768 struct lp_build_tgsi_context * bld_base, 1769 struct lp_build_emit_data * emit_data) 1770{ 1771 LLVMValueRef p_floor_log2; 1772 LLVMValueRef p_exp; 1773 LLVMValueRef p_log2; 1774 LLVMValueRef src0 = emit_data->args[0]; 1775 1776 lp_build_log2_approx(&bld_base->base, src0, 1777 &p_exp, &p_floor_log2, &p_log2, FALSE); 1778 1779 emit_data->output[TGSI_CHAN_X] = p_floor_log2; 1780 1781 emit_data->output[TGSI_CHAN_Y] = lp_build_emit_llvm_binary(bld_base, 1782 TGSI_OPCODE_DIV, 1783 src0, p_exp); 1784 emit_data->output[TGSI_CHAN_Z] = p_log2; 1785 1786 emit_data->output[TGSI_CHAN_W] = bld_base->base.one; 1787 1788} 1789 1790/* TGSI_OPCODE_MAD (CPU Only) */ 1791 1792static void 1793mad_emit_cpu( 1794 const struct lp_build_tgsi_action * action, 1795 struct lp_build_tgsi_context * bld_base, 1796 struct lp_build_emit_data * emit_data) 1797{ 1798 emit_data->output[emit_data->chan] = 1799 lp_build_mad(&bld_base->base, 1800 emit_data->args[0], emit_data->args[1], emit_data->args[2]); 1801} 1802 1803/* TGSI_OPCODE_MAX (CPU Only) */ 1804 1805static void 1806max_emit_cpu( 1807 const struct lp_build_tgsi_action * action, 1808 struct lp_build_tgsi_context * bld_base, 1809 struct lp_build_emit_data * emit_data) 1810{ 1811 emit_data->output[emit_data->chan] = 1812 lp_build_max_ext(&bld_base->base, 1813 emit_data->args[0], emit_data->args[1], 1814 GALLIVM_NAN_RETURN_OTHER); 1815} 1816 1817/* TGSI_OPCODE_MIN (CPU Only) */ 1818static void 1819min_emit_cpu( 1820 const struct lp_build_tgsi_action * action, 1821 struct lp_build_tgsi_context * bld_base, 1822 struct lp_build_emit_data * emit_data) 1823{ 1824 emit_data->output[emit_data->chan] = 1825 lp_build_min_ext(&bld_base->base, 1826 emit_data->args[0], emit_data->args[1], 1827 GALLIVM_NAN_RETURN_OTHER); 1828} 1829 1830/* TGSI_OPCODE_MOD (CPU Only) */ 1831static void 1832mod_emit_cpu( 1833 const struct lp_build_tgsi_action * action, 1834 struct lp_build_tgsi_context * bld_base, 1835 struct lp_build_emit_data * emit_data) 1836{ 1837 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 1838 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld, 1839 PIPE_FUNC_EQUAL, emit_data->args[1], 1840 bld_base->uint_bld.zero); 1841 /* We want to make sure that we never divide/mod by zero to not 1842 * generate sigfpe. We don't want to crash just because the 1843 * shader is doing something weird. */ 1844 LLVMValueRef divisor = LLVMBuildOr(builder, 1845 div_mask, 1846 emit_data->args[1], ""); 1847 LLVMValueRef result = lp_build_mod(&bld_base->int_bld, 1848 emit_data->args[0], divisor); 1849 /* umod by zero doesn't have a guaranteed return value chose -1 for now. */ 1850 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 1851 div_mask, 1852 result, ""); 1853} 1854 1855/* TGSI_OPCODE_NOT */ 1856static void 1857not_emit_cpu( 1858 const struct lp_build_tgsi_action * action, 1859 struct lp_build_tgsi_context * bld_base, 1860 struct lp_build_emit_data * emit_data) 1861{ 1862 emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld, 1863 emit_data->args[0]); 1864} 1865 1866/* TGSI_OPCODE_OR (CPU Only) */ 1867static void 1868or_emit_cpu( 1869 const struct lp_build_tgsi_action * action, 1870 struct lp_build_tgsi_context * bld_base, 1871 struct lp_build_emit_data * emit_data) 1872{ 1873 emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld, 1874 emit_data->args[0], emit_data->args[1]); 1875} 1876 1877/* TGSI_OPCODE_POW (CPU Only) */ 1878static void 1879pow_emit_cpu( 1880 const struct lp_build_tgsi_action * action, 1881 struct lp_build_tgsi_context * bld_base, 1882 struct lp_build_emit_data * emit_data) 1883{ 1884 emit_data->output[emit_data->chan] = lp_build_pow(&bld_base->base, 1885 emit_data->args[0], emit_data->args[1]); 1886} 1887 1888 1889/* TGSI_OPCODE_RCP (CPU Only) */ 1890 1891static void 1892rcp_emit_cpu( 1893 const struct lp_build_tgsi_action * action, 1894 struct lp_build_tgsi_context * bld_base, 1895 struct lp_build_emit_data * emit_data) 1896{ 1897 emit_data->output[emit_data->chan] = lp_build_rcp(&bld_base->base, 1898 emit_data->args[0]); 1899} 1900 1901/* Reciprical squareroot (CPU Only) */ 1902static void 1903recip_sqrt_emit_cpu( 1904 const struct lp_build_tgsi_action * action, 1905 struct lp_build_tgsi_context * bld_base, 1906 struct lp_build_emit_data * emit_data) 1907{ 1908 emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->base, 1909 emit_data->args[0]); 1910} 1911 1912static void 1913sqrt_emit_cpu( 1914 const struct lp_build_tgsi_action * action, 1915 struct lp_build_tgsi_context * bld_base, 1916 struct lp_build_emit_data * emit_data) 1917{ 1918 emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base, 1919 emit_data->args[0]); 1920} 1921 1922 1923/* TGSI_OPCODE_ROUND (CPU Only) */ 1924static void 1925round_emit_cpu( 1926 const struct lp_build_tgsi_action * action, 1927 struct lp_build_tgsi_context * bld_base, 1928 struct lp_build_emit_data * emit_data) 1929{ 1930 emit_data->output[emit_data->chan] = lp_build_round(&bld_base->base, 1931 emit_data->args[0]); 1932} 1933 1934/* TGSI_OPCODE_SET Helper (CPU Only) */ 1935 1936static void 1937set_emit_cpu( 1938 const struct lp_build_tgsi_action * action, 1939 struct lp_build_tgsi_context * bld_base, 1940 struct lp_build_emit_data * emit_data, 1941 unsigned pipe_func) 1942{ 1943 LLVMValueRef cond; 1944 1945 if (pipe_func != PIPE_FUNC_NOTEQUAL) { 1946 cond = lp_build_cmp_ordered(&bld_base->base, pipe_func, 1947 emit_data->args[0], emit_data->args[1]); 1948 } 1949 else { 1950 cond = lp_build_cmp(&bld_base->base, pipe_func, 1951 emit_data->args[0], emit_data->args[1]); 1952 1953 } 1954 emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base, 1955 cond, 1956 bld_base->base.one, 1957 bld_base->base.zero); 1958} 1959 1960/* TGSI_OPCODE_SEQ (CPU Only) */ 1961 1962static void 1963seq_emit_cpu( 1964 const struct lp_build_tgsi_action * action, 1965 struct lp_build_tgsi_context * bld_base, 1966 struct lp_build_emit_data * emit_data) 1967{ 1968 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 1969} 1970 1971/* TGSI_OPCODE_SGE (CPU Only) */ 1972static void 1973sge_emit_cpu( 1974 const struct lp_build_tgsi_action * action, 1975 struct lp_build_tgsi_context * bld_base, 1976 struct lp_build_emit_data * emit_data) 1977{ 1978 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 1979} 1980 1981/* TGSI_OPCODE_SGT (CPU Only)*/ 1982 1983static void 1984sgt_emit_cpu( 1985 const struct lp_build_tgsi_action * action, 1986 struct lp_build_tgsi_context * bld_base, 1987 struct lp_build_emit_data * emit_data) 1988{ 1989 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER); 1990} 1991 1992/* TGSI_OPCODE_SHL (CPU Only) */ 1993static void 1994shl_emit_cpu( 1995 const struct lp_build_tgsi_action * action, 1996 struct lp_build_tgsi_context * bld_base, 1997 struct lp_build_emit_data * emit_data) 1998{ 1999 struct lp_build_context *uint_bld = &bld_base->uint_bld; 2000 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type, 2001 uint_bld->type.width - 1); 2002 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask); 2003 emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0], 2004 masked_count); 2005} 2006 2007/* TGSI_OPCODE_SIN (CPU Only) */ 2008static void 2009sin_emit_cpu( 2010 const struct lp_build_tgsi_action * action, 2011 struct lp_build_tgsi_context * bld_base, 2012 struct lp_build_emit_data * emit_data) 2013{ 2014 emit_data->output[emit_data->chan] = lp_build_sin(&bld_base->base, 2015 emit_data->args[0]); 2016} 2017 2018/* TGSI_OPCODE_SLE (CPU Only) */ 2019static void 2020sle_emit_cpu( 2021 const struct lp_build_tgsi_action * action, 2022 struct lp_build_tgsi_context * bld_base, 2023 struct lp_build_emit_data * emit_data) 2024{ 2025 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LEQUAL); 2026} 2027 2028/* TGSI_OPCODE_SLT (CPU Only) */ 2029static void 2030slt_emit_cpu( 2031 const struct lp_build_tgsi_action * action, 2032 struct lp_build_tgsi_context * bld_base, 2033 struct lp_build_emit_data * emit_data) 2034{ 2035 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 2036} 2037 2038/* TGSI_OPCODE_SNE (CPU Only) */ 2039 2040static void 2041sne_emit_cpu( 2042 const struct lp_build_tgsi_action * action, 2043 struct lp_build_tgsi_context * bld_base, 2044 struct lp_build_emit_data * emit_data) 2045{ 2046 set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 2047} 2048 2049/* TGSI_OPCODE_SSG (CPU Only) */ 2050 2051static void 2052ssg_emit_cpu( 2053 const struct lp_build_tgsi_action * action, 2054 struct lp_build_tgsi_context * bld_base, 2055 struct lp_build_emit_data * emit_data) 2056{ 2057 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->base, 2058 emit_data->args[0]); 2059} 2060 2061/* TGSI_OPCODE_TRUNC (CPU Only) */ 2062 2063static void 2064trunc_emit_cpu( 2065 const struct lp_build_tgsi_action * action, 2066 struct lp_build_tgsi_context * bld_base, 2067 struct lp_build_emit_data * emit_data) 2068{ 2069 emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base, 2070 emit_data->args[0]); 2071} 2072 2073/* TGSI_OPCODE_UADD (CPU Only) */ 2074static void 2075uadd_emit_cpu( 2076 const struct lp_build_tgsi_action * action, 2077 struct lp_build_tgsi_context * bld_base, 2078 struct lp_build_emit_data * emit_data) 2079{ 2080 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld, 2081 emit_data->args[0], emit_data->args[1]); 2082} 2083 2084/* TGSI_OPCODE_UDIV (CPU Only) */ 2085static void 2086udiv_emit_cpu( 2087 const struct lp_build_tgsi_action * action, 2088 struct lp_build_tgsi_context * bld_base, 2089 struct lp_build_emit_data * emit_data) 2090{ 2091 2092 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 2093 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld, 2094 PIPE_FUNC_EQUAL, emit_data->args[1], 2095 bld_base->uint_bld.zero); 2096 /* We want to make sure that we never divide/mod by zero to not 2097 * generate sigfpe. We don't want to crash just because the 2098 * shader is doing something weird. */ 2099 LLVMValueRef divisor = LLVMBuildOr(builder, 2100 div_mask, 2101 emit_data->args[1], ""); 2102 LLVMValueRef result = lp_build_div(&bld_base->uint_bld, 2103 emit_data->args[0], divisor); 2104 /* udiv by zero is guaranteed to return 0xffffffff at least with d3d10 */ 2105 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 2106 div_mask, 2107 result, ""); 2108} 2109 2110/* TGSI_OPCODE_UMAX (CPU Only) */ 2111static void 2112umax_emit_cpu( 2113 const struct lp_build_tgsi_action * action, 2114 struct lp_build_tgsi_context * bld_base, 2115 struct lp_build_emit_data * emit_data) 2116{ 2117 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld, 2118 emit_data->args[0], emit_data->args[1]); 2119} 2120 2121/* TGSI_OPCODE_UMIN (CPU Only) */ 2122static void 2123umin_emit_cpu( 2124 const struct lp_build_tgsi_action * action, 2125 struct lp_build_tgsi_context * bld_base, 2126 struct lp_build_emit_data * emit_data) 2127{ 2128 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld, 2129 emit_data->args[0], emit_data->args[1]); 2130} 2131 2132/* TGSI_OPCODE_UMOD (CPU Only) */ 2133static void 2134umod_emit_cpu( 2135 const struct lp_build_tgsi_action * action, 2136 struct lp_build_tgsi_context * bld_base, 2137 struct lp_build_emit_data * emit_data) 2138{ 2139 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 2140 LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld, 2141 PIPE_FUNC_EQUAL, emit_data->args[1], 2142 bld_base->uint_bld.zero); 2143 /* We want to make sure that we never divide/mod by zero to not 2144 * generate sigfpe. We don't want to crash just because the 2145 * shader is doing something weird. */ 2146 LLVMValueRef divisor = LLVMBuildOr(builder, 2147 div_mask, 2148 emit_data->args[1], ""); 2149 LLVMValueRef result = lp_build_mod(&bld_base->uint_bld, 2150 emit_data->args[0], divisor); 2151 /* umod by zero is guaranteed to return 0xffffffff */ 2152 emit_data->output[emit_data->chan] = LLVMBuildOr(builder, 2153 div_mask, 2154 result, ""); 2155} 2156 2157/* TGSI_OPCODE_USET Helper (CPU Only) */ 2158static void 2159uset_emit_cpu( 2160 const struct lp_build_tgsi_action * action, 2161 struct lp_build_tgsi_context * bld_base, 2162 struct lp_build_emit_data * emit_data, 2163 unsigned pipe_func) 2164{ 2165 LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func, 2166 emit_data->args[0], emit_data->args[1]); 2167 emit_data->output[emit_data->chan] = cond; 2168} 2169 2170 2171/* TGSI_OPCODE_USEQ (CPU Only) */ 2172static void 2173useq_emit_cpu( 2174 const struct lp_build_tgsi_action * action, 2175 struct lp_build_tgsi_context * bld_base, 2176 struct lp_build_emit_data * emit_data) 2177{ 2178 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 2179} 2180 2181/* TGSI_OPCODE_ISGE (CPU Only) */ 2182static void 2183usge_emit_cpu( 2184 const struct lp_build_tgsi_action * action, 2185 struct lp_build_tgsi_context * bld_base, 2186 struct lp_build_emit_data * emit_data) 2187{ 2188 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 2189} 2190 2191/* TGSI_OPCODE_USHR (CPU Only) */ 2192static void 2193ushr_emit_cpu( 2194 const struct lp_build_tgsi_action * action, 2195 struct lp_build_tgsi_context * bld_base, 2196 struct lp_build_emit_data * emit_data) 2197{ 2198 struct lp_build_context *uint_bld = &bld_base->uint_bld; 2199 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type, 2200 uint_bld->type.width - 1); 2201 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask); 2202 emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0], 2203 masked_count); 2204} 2205 2206/* TGSI_OPCODE_ISLT (CPU Only) */ 2207static void 2208uslt_emit_cpu( 2209 const struct lp_build_tgsi_action * action, 2210 struct lp_build_tgsi_context * bld_base, 2211 struct lp_build_emit_data * emit_data) 2212{ 2213 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 2214} 2215 2216/* TGSI_OPCODE_USNE (CPU Only) */ 2217 2218static void 2219usne_emit_cpu( 2220 const struct lp_build_tgsi_action * action, 2221 struct lp_build_tgsi_context * bld_base, 2222 struct lp_build_emit_data * emit_data) 2223{ 2224 uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 2225} 2226 2227/* TGSI_OPCODE_XOR */ 2228static void 2229xor_emit_cpu( 2230 const struct lp_build_tgsi_action * action, 2231 struct lp_build_tgsi_context * bld_base, 2232 struct lp_build_emit_data * emit_data) 2233{ 2234 emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld, 2235 emit_data->args[0], 2236 emit_data->args[1]); 2237} 2238 2239/* TGSI_OPCODE_DABS (CPU Only) */ 2240static void 2241dabs_emit_cpu( 2242 const struct lp_build_tgsi_action * action, 2243 struct lp_build_tgsi_context * bld_base, 2244 struct lp_build_emit_data * emit_data) 2245{ 2246 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->dbl_bld, 2247 emit_data->args[0]); 2248} 2249 2250/* TGSI_OPCODE_DNEG (CPU Only) */ 2251static void 2252dneg_emit_cpu( 2253 const struct lp_build_tgsi_action * action, 2254 struct lp_build_tgsi_context * bld_base, 2255 struct lp_build_emit_data * emit_data) 2256{ 2257 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->dbl_bld, 2258 bld_base->dbl_bld.zero, 2259 emit_data->args[0]); 2260} 2261 2262/* TGSI_OPCODE_DSET Helper (CPU Only) */ 2263static void 2264dset_emit_cpu( 2265 const struct lp_build_tgsi_action * action, 2266 struct lp_build_tgsi_context * bld_base, 2267 struct lp_build_emit_data * emit_data, 2268 unsigned pipe_func) 2269{ 2270 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 2271 LLVMValueRef cond = lp_build_cmp(&bld_base->dbl_bld, pipe_func, 2272 emit_data->args[0], emit_data->args[1]); 2273 /* arguments were 64 bit but store as 32 bit */ 2274 cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, ""); 2275 emit_data->output[emit_data->chan] = cond; 2276} 2277 2278/* TGSI_OPCODE_DSEQ (CPU Only) */ 2279static void 2280dseq_emit_cpu( 2281 const struct lp_build_tgsi_action * action, 2282 struct lp_build_tgsi_context * bld_base, 2283 struct lp_build_emit_data * emit_data) 2284{ 2285 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 2286} 2287 2288/* TGSI_OPCODE_DSGE (CPU Only) */ 2289static void 2290dsge_emit_cpu( 2291 const struct lp_build_tgsi_action * action, 2292 struct lp_build_tgsi_context * bld_base, 2293 struct lp_build_emit_data * emit_data) 2294{ 2295 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 2296} 2297 2298/* TGSI_OPCODE_DSLT (CPU Only) */ 2299static void 2300dslt_emit_cpu( 2301 const struct lp_build_tgsi_action * action, 2302 struct lp_build_tgsi_context * bld_base, 2303 struct lp_build_emit_data * emit_data) 2304{ 2305 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 2306} 2307 2308/* TGSI_OPCODE_DSNE (CPU Only) */ 2309static void 2310dsne_emit_cpu( 2311 const struct lp_build_tgsi_action * action, 2312 struct lp_build_tgsi_context * bld_base, 2313 struct lp_build_emit_data * emit_data) 2314{ 2315 dset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 2316} 2317 2318/* Double Reciprocal squareroot (CPU Only) */ 2319static void 2320drecip_sqrt_emit_cpu( 2321 const struct lp_build_tgsi_action * action, 2322 struct lp_build_tgsi_context * bld_base, 2323 struct lp_build_emit_data * emit_data) 2324{ 2325 emit_data->output[emit_data->chan] = lp_build_rsqrt(&bld_base->dbl_bld, 2326 emit_data->args[0]); 2327} 2328 2329/* Double Squareroot (CPU Only) */ 2330static void 2331dsqrt_emit_cpu( 2332 const struct lp_build_tgsi_action * action, 2333 struct lp_build_tgsi_context * bld_base, 2334 struct lp_build_emit_data * emit_data) 2335{ 2336 emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->dbl_bld, 2337 emit_data->args[0]); 2338} 2339 2340static void 2341i64abs_emit_cpu( 2342 const struct lp_build_tgsi_action * action, 2343 struct lp_build_tgsi_context * bld_base, 2344 struct lp_build_emit_data * emit_data) 2345{ 2346 emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int64_bld, 2347 emit_data->args[0]); 2348} 2349 2350static void 2351i64ssg_emit_cpu( 2352 const struct lp_build_tgsi_action * action, 2353 struct lp_build_tgsi_context * bld_base, 2354 struct lp_build_emit_data * emit_data) 2355{ 2356 emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int64_bld, 2357 emit_data->args[0]); 2358} 2359 2360static void 2361i64neg_emit_cpu( 2362 const struct lp_build_tgsi_action * action, 2363 struct lp_build_tgsi_context * bld_base, 2364 struct lp_build_emit_data * emit_data) 2365{ 2366 emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int64_bld, 2367 bld_base->int64_bld.zero, 2368 emit_data->args[0]); 2369} 2370 2371static void 2372u64set_emit_cpu( 2373 const struct lp_build_tgsi_action * action, 2374 struct lp_build_tgsi_context * bld_base, 2375 struct lp_build_emit_data * emit_data, 2376 unsigned pipe_func) 2377{ 2378 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 2379 LLVMValueRef cond = lp_build_cmp(&bld_base->uint64_bld, pipe_func, 2380 emit_data->args[0], emit_data->args[1]); 2381 /* arguments were 64 bit but store as 32 bit */ 2382 cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, ""); 2383 emit_data->output[emit_data->chan] = cond; 2384} 2385 2386static void 2387u64seq_emit_cpu( 2388 const struct lp_build_tgsi_action * action, 2389 struct lp_build_tgsi_context * bld_base, 2390 struct lp_build_emit_data * emit_data) 2391{ 2392 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); 2393} 2394 2395static void 2396u64sne_emit_cpu( 2397 const struct lp_build_tgsi_action * action, 2398 struct lp_build_tgsi_context * bld_base, 2399 struct lp_build_emit_data * emit_data) 2400{ 2401 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); 2402} 2403 2404static void 2405u64slt_emit_cpu( 2406 const struct lp_build_tgsi_action * action, 2407 struct lp_build_tgsi_context * bld_base, 2408 struct lp_build_emit_data * emit_data) 2409{ 2410 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 2411} 2412 2413static void 2414u64sge_emit_cpu( 2415 const struct lp_build_tgsi_action * action, 2416 struct lp_build_tgsi_context * bld_base, 2417 struct lp_build_emit_data * emit_data) 2418{ 2419 u64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 2420} 2421 2422static void 2423i64set_emit_cpu( 2424 const struct lp_build_tgsi_action * action, 2425 struct lp_build_tgsi_context * bld_base, 2426 struct lp_build_emit_data * emit_data, 2427 unsigned pipe_func) 2428{ 2429 LLVMBuilderRef builder = bld_base->base.gallivm->builder; 2430 LLVMValueRef cond = lp_build_cmp(&bld_base->int64_bld, pipe_func, 2431 emit_data->args[0], emit_data->args[1]); 2432 /* arguments were 64 bit but store as 32 bit */ 2433 cond = LLVMBuildTrunc(builder, cond, bld_base->int_bld.int_vec_type, ""); 2434 emit_data->output[emit_data->chan] = cond; 2435} 2436 2437static void 2438i64slt_emit_cpu( 2439 const struct lp_build_tgsi_action * action, 2440 struct lp_build_tgsi_context * bld_base, 2441 struct lp_build_emit_data * emit_data) 2442{ 2443 i64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); 2444} 2445 2446static void 2447i64sge_emit_cpu( 2448 const struct lp_build_tgsi_action * action, 2449 struct lp_build_tgsi_context * bld_base, 2450 struct lp_build_emit_data * emit_data) 2451{ 2452 i64set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); 2453} 2454 2455static void 2456u64max_emit_cpu( 2457 const struct lp_build_tgsi_action * action, 2458 struct lp_build_tgsi_context * bld_base, 2459 struct lp_build_emit_data * emit_data) 2460{ 2461 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint64_bld, 2462 emit_data->args[0], emit_data->args[1]); 2463} 2464 2465static void 2466u64min_emit_cpu( 2467 const struct lp_build_tgsi_action * action, 2468 struct lp_build_tgsi_context * bld_base, 2469 struct lp_build_emit_data * emit_data) 2470{ 2471 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint64_bld, 2472 emit_data->args[0], emit_data->args[1]); 2473} 2474 2475static void 2476i64max_emit_cpu( 2477 const struct lp_build_tgsi_action * action, 2478 struct lp_build_tgsi_context * bld_base, 2479 struct lp_build_emit_data * emit_data) 2480{ 2481 emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int64_bld, 2482 emit_data->args[0], emit_data->args[1]); 2483} 2484 2485static void 2486i64min_emit_cpu( 2487 const struct lp_build_tgsi_action * action, 2488 struct lp_build_tgsi_context * bld_base, 2489 struct lp_build_emit_data * emit_data) 2490{ 2491 emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int64_bld, 2492 emit_data->args[0], emit_data->args[1]); 2493} 2494 2495static void 2496u64add_emit_cpu( 2497 const struct lp_build_tgsi_action * action, 2498 struct lp_build_tgsi_context * bld_base, 2499 struct lp_build_emit_data * emit_data) 2500{ 2501 emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint64_bld, 2502 emit_data->args[0], emit_data->args[1]); 2503} 2504 2505static void 2506u64shl_emit_cpu( 2507 const struct lp_build_tgsi_action * action, 2508 struct lp_build_tgsi_context * bld_base, 2509 struct lp_build_emit_data * emit_data) 2510{ 2511 struct lp_build_context *uint_bld = &bld_base->uint64_bld; 2512 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type, 2513 uint_bld->type.width - 1); 2514 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask); 2515 emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0], 2516 masked_count); 2517} 2518 2519static void 2520i64shr_emit_cpu( 2521 const struct lp_build_tgsi_action * action, 2522 struct lp_build_tgsi_context * bld_base, 2523 struct lp_build_emit_data * emit_data) 2524{ 2525 struct lp_build_context *int_bld = &bld_base->int64_bld; 2526 LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type, 2527 int_bld->type.width - 1); 2528 LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask); 2529 emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0], 2530 masked_count); 2531} 2532 2533static void 2534u64shr_emit_cpu( 2535 const struct lp_build_tgsi_action * action, 2536 struct lp_build_tgsi_context * bld_base, 2537 struct lp_build_emit_data * emit_data) 2538{ 2539 struct lp_build_context *uint_bld = &bld_base->uint64_bld; 2540 LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type, 2541 uint_bld->type.width - 1); 2542 LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask); 2543 emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0], 2544 masked_count); 2545} 2546 2547void 2548lp_set_default_actions_cpu( 2549 struct lp_build_tgsi_context * bld_base) 2550{ 2551 lp_set_default_actions(bld_base); 2552 bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu; 2553 bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu; 2554 bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu; 2555 bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu; 2556 bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu; 2557 bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu; 2558 bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu; 2559 bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu; 2560 bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu; 2561 bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu; 2562 bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu; 2563 bld_base->op_actions[TGSI_OPCODE_FSEQ].emit = fseq_emit_cpu; 2564 bld_base->op_actions[TGSI_OPCODE_FSGE].emit = fsge_emit_cpu; 2565 bld_base->op_actions[TGSI_OPCODE_FSLT].emit = fslt_emit_cpu; 2566 bld_base->op_actions[TGSI_OPCODE_FSNE].emit = fsne_emit_cpu; 2567 2568 bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu; 2569 bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu; 2570 bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu; 2571 bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu; 2572 bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu; 2573 bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu; 2574 bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu; 2575 bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu; 2576 bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu; 2577 bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu; 2578 bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit_cpu; 2579 bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit_cpu; 2580 2581 bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu; 2582 bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu; 2583 bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit_cpu; 2584 bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu; 2585 bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu; 2586 bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu; 2587 bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu; 2588 bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu; 2589 bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu; 2590 bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu; 2591 bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu; 2592 bld_base->op_actions[TGSI_OPCODE_SEQ].emit = seq_emit_cpu; 2593 bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu; 2594 bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu; 2595 bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu; 2596 bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu; 2597 bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu; 2598 bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu; 2599 bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu; 2600 bld_base->op_actions[TGSI_OPCODE_SSG].emit = ssg_emit_cpu; 2601 bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu; 2602 2603 bld_base->rsq_action.emit = recip_sqrt_emit_cpu; 2604 bld_base->sqrt_action.emit = sqrt_emit_cpu; 2605 2606 bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu; 2607 bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu; 2608 bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu; 2609 bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu; 2610 bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu; 2611 bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu; 2612 bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu; 2613 bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu; 2614 bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu; 2615 bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu; 2616 bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu; 2617 2618 bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu; 2619 2620 bld_base->op_actions[TGSI_OPCODE_DABS].emit = dabs_emit_cpu; 2621 bld_base->op_actions[TGSI_OPCODE_DNEG].emit = dneg_emit_cpu; 2622 bld_base->op_actions[TGSI_OPCODE_DSEQ].emit = dseq_emit_cpu; 2623 bld_base->op_actions[TGSI_OPCODE_DSGE].emit = dsge_emit_cpu; 2624 bld_base->op_actions[TGSI_OPCODE_DSLT].emit = dslt_emit_cpu; 2625 bld_base->op_actions[TGSI_OPCODE_DSNE].emit = dsne_emit_cpu; 2626 2627 bld_base->op_actions[TGSI_OPCODE_DRSQ].emit = drecip_sqrt_emit_cpu; 2628 bld_base->op_actions[TGSI_OPCODE_DSQRT].emit = dsqrt_emit_cpu; 2629 2630 bld_base->op_actions[TGSI_OPCODE_I64ABS].emit = i64abs_emit_cpu; 2631 bld_base->op_actions[TGSI_OPCODE_I64SSG].emit = i64ssg_emit_cpu; 2632 bld_base->op_actions[TGSI_OPCODE_I64NEG].emit = i64neg_emit_cpu; 2633 2634 bld_base->op_actions[TGSI_OPCODE_U64SEQ].emit = u64seq_emit_cpu; 2635 bld_base->op_actions[TGSI_OPCODE_U64SNE].emit = u64sne_emit_cpu; 2636 bld_base->op_actions[TGSI_OPCODE_U64SLT].emit = u64slt_emit_cpu; 2637 bld_base->op_actions[TGSI_OPCODE_U64SGE].emit = u64sge_emit_cpu; 2638 bld_base->op_actions[TGSI_OPCODE_I64SLT].emit = i64slt_emit_cpu; 2639 bld_base->op_actions[TGSI_OPCODE_I64SGE].emit = i64sge_emit_cpu; 2640 2641 bld_base->op_actions[TGSI_OPCODE_U64MIN].emit = u64min_emit_cpu; 2642 bld_base->op_actions[TGSI_OPCODE_U64MAX].emit = u64max_emit_cpu; 2643 bld_base->op_actions[TGSI_OPCODE_I64MIN].emit = i64min_emit_cpu; 2644 bld_base->op_actions[TGSI_OPCODE_I64MAX].emit = i64max_emit_cpu; 2645 2646 bld_base->op_actions[TGSI_OPCODE_U64ADD].emit = u64add_emit_cpu; 2647 bld_base->op_actions[TGSI_OPCODE_U64MOD].emit = u64mod_emit_cpu; 2648 bld_base->op_actions[TGSI_OPCODE_I64MOD].emit = i64mod_emit_cpu; 2649 bld_base->op_actions[TGSI_OPCODE_U64DIV].emit = u64div_emit_cpu; 2650 bld_base->op_actions[TGSI_OPCODE_I64DIV].emit = i64div_emit_cpu; 2651 2652 bld_base->op_actions[TGSI_OPCODE_U64SHL].emit = u64shl_emit_cpu; 2653 bld_base->op_actions[TGSI_OPCODE_I64SHR].emit = i64shr_emit_cpu; 2654 bld_base->op_actions[TGSI_OPCODE_U64SHR].emit = u64shr_emit_cpu; 2655} 2656