1 switch (this->operation) { 2 case ir_unop_bit_not: 3 for (unsigned c = 0; c < op[0]->type->components(); c++) { 4 switch (op[0]->type->base_type) { 5 case GLSL_TYPE_UINT: 6 data.u[c] = ~ op[0]->value.u[c]; 7 break; 8 case GLSL_TYPE_INT: 9 data.i[c] = ~ op[0]->value.i[c]; 10 break; 11 case GLSL_TYPE_UINT64: 12 data.u64[c] = ~ op[0]->value.u64[c]; 13 break; 14 case GLSL_TYPE_INT64: 15 data.i64[c] = ~ op[0]->value.i64[c]; 16 break; 17 default: 18 unreachable("invalid type"); 19 } 20 } 21 break; 22 23 case ir_unop_logic_not: 24 for (unsigned c = 0; c < op[0]->type->components(); c++) { 25 switch (op[0]->type->base_type) { 26 case GLSL_TYPE_BOOL: 27 data.b[c] = !op[0]->value.b[c]; 28 break; 29 default: 30 unreachable("invalid type"); 31 } 32 } 33 break; 34 35 case ir_unop_neg: 36 for (unsigned c = 0; c < op[0]->type->components(); c++) { 37 switch (op[0]->type->base_type) { 38 case GLSL_TYPE_UINT: 39 data.u[c] = -((int) op[0]->value.u[c]); 40 break; 41 case GLSL_TYPE_INT: 42 data.i[c] = -op[0]->value.i[c]; 43 break; 44 case GLSL_TYPE_FLOAT: 45 data.f[c] = -op[0]->value.f[c]; 46 break; 47 case GLSL_TYPE_DOUBLE: 48 data.d[c] = -op[0]->value.d[c]; 49 break; 50 case GLSL_TYPE_UINT64: 51 data.u64[c] = -((int64_t) op[0]->value.u64[c]); 52 break; 53 case GLSL_TYPE_INT64: 54 data.i64[c] = -op[0]->value.i64[c]; 55 break; 56 default: 57 unreachable("invalid type"); 58 } 59 } 60 break; 61 62 case ir_unop_abs: 63 for (unsigned c = 0; c < op[0]->type->components(); c++) { 64 switch (op[0]->type->base_type) { 65 case GLSL_TYPE_INT: 66 data.i[c] = op[0]->value.i[c] < 0 ? -op[0]->value.i[c] : op[0]->value.i[c]; 67 break; 68 case GLSL_TYPE_FLOAT: 69 data.f[c] = fabsf(op[0]->value.f[c]); 70 break; 71 case GLSL_TYPE_DOUBLE: 72 data.d[c] = fabs(op[0]->value.d[c]); 73 break; 74 case GLSL_TYPE_INT64: 75 data.i64[c] = op[0]->value.i64[c] < 0 ? -op[0]->value.i64[c] : op[0]->value.i64[c]; 76 break; 77 default: 78 unreachable("invalid type"); 79 } 80 } 81 break; 82 83 case ir_unop_sign: 84 for (unsigned c = 0; c < op[0]->type->components(); c++) { 85 switch (op[0]->type->base_type) { 86 case GLSL_TYPE_INT: 87 data.i[c] = (op[0]->value.i[c] > 0) - (op[0]->value.i[c] < 0); 88 break; 89 case GLSL_TYPE_FLOAT: 90 data.f[c] = float((op[0]->value.f[c] > 0.0F) - (op[0]->value.f[c] < 0.0F)); 91 break; 92 case GLSL_TYPE_DOUBLE: 93 data.d[c] = double((op[0]->value.d[c] > 0.0) - (op[0]->value.d[c] < 0.0)); 94 break; 95 case GLSL_TYPE_INT64: 96 data.i64[c] = (op[0]->value.i64[c] > 0) - (op[0]->value.i64[c] < 0); 97 break; 98 default: 99 unreachable("invalid type"); 100 } 101 } 102 break; 103 104 case ir_unop_rcp: 105 for (unsigned c = 0; c < op[0]->type->components(); c++) { 106 switch (op[0]->type->base_type) { 107 case GLSL_TYPE_FLOAT: 108 data.f[c] = 1.0F / op[0]->value.f[c]; 109 break; 110 case GLSL_TYPE_DOUBLE: 111 data.d[c] = 1.0 / op[0]->value.d[c]; 112 break; 113 default: 114 unreachable("invalid type"); 115 } 116 } 117 break; 118 119 case ir_unop_rsq: 120 for (unsigned c = 0; c < op[0]->type->components(); c++) { 121 switch (op[0]->type->base_type) { 122 case GLSL_TYPE_FLOAT: 123 data.f[c] = 1.0F / sqrtf(op[0]->value.f[c]); 124 break; 125 case GLSL_TYPE_DOUBLE: 126 data.d[c] = 1.0 / sqrt(op[0]->value.d[c]); 127 break; 128 default: 129 unreachable("invalid type"); 130 } 131 } 132 break; 133 134 case ir_unop_sqrt: 135 for (unsigned c = 0; c < op[0]->type->components(); c++) { 136 switch (op[0]->type->base_type) { 137 case GLSL_TYPE_FLOAT: 138 data.f[c] = sqrtf(op[0]->value.f[c]); 139 break; 140 case GLSL_TYPE_DOUBLE: 141 data.d[c] = sqrt(op[0]->value.d[c]); 142 break; 143 default: 144 unreachable("invalid type"); 145 } 146 } 147 break; 148 149 case ir_unop_exp: 150 for (unsigned c = 0; c < op[0]->type->components(); c++) { 151 switch (op[0]->type->base_type) { 152 case GLSL_TYPE_FLOAT: 153 data.f[c] = expf(op[0]->value.f[c]); 154 break; 155 default: 156 unreachable("invalid type"); 157 } 158 } 159 break; 160 161 case ir_unop_log: 162 for (unsigned c = 0; c < op[0]->type->components(); c++) { 163 switch (op[0]->type->base_type) { 164 case GLSL_TYPE_FLOAT: 165 data.f[c] = logf(op[0]->value.f[c]); 166 break; 167 default: 168 unreachable("invalid type"); 169 } 170 } 171 break; 172 173 case ir_unop_exp2: 174 for (unsigned c = 0; c < op[0]->type->components(); c++) { 175 switch (op[0]->type->base_type) { 176 case GLSL_TYPE_FLOAT: 177 data.f[c] = exp2f(op[0]->value.f[c]); 178 break; 179 default: 180 unreachable("invalid type"); 181 } 182 } 183 break; 184 185 case ir_unop_log2: 186 for (unsigned c = 0; c < op[0]->type->components(); c++) { 187 switch (op[0]->type->base_type) { 188 case GLSL_TYPE_FLOAT: 189 data.f[c] = log2f(op[0]->value.f[c]); 190 break; 191 default: 192 unreachable("invalid type"); 193 } 194 } 195 break; 196 197 case ir_unop_f2i: 198 for (unsigned c = 0; c < op[0]->type->components(); c++) { 199 switch (op[0]->type->base_type) { 200 case GLSL_TYPE_FLOAT: 201 data.i[c] = (int) op[0]->value.f[c]; 202 break; 203 default: 204 unreachable("invalid type"); 205 } 206 } 207 break; 208 209 case ir_unop_f2u: 210 for (unsigned c = 0; c < op[0]->type->components(); c++) { 211 switch (op[0]->type->base_type) { 212 case GLSL_TYPE_FLOAT: 213 data.u[c] = (unsigned) op[0]->value.f[c]; 214 break; 215 default: 216 unreachable("invalid type"); 217 } 218 } 219 break; 220 221 case ir_unop_i2f: 222 for (unsigned c = 0; c < op[0]->type->components(); c++) { 223 switch (op[0]->type->base_type) { 224 case GLSL_TYPE_INT: 225 data.f[c] = (float) op[0]->value.i[c]; 226 break; 227 default: 228 unreachable("invalid type"); 229 } 230 } 231 break; 232 233 case ir_unop_f2b: 234 for (unsigned c = 0; c < op[0]->type->components(); c++) { 235 switch (op[0]->type->base_type) { 236 case GLSL_TYPE_FLOAT: 237 data.b[c] = op[0]->value.f[c] != 0.0F ? true : false; 238 break; 239 default: 240 unreachable("invalid type"); 241 } 242 } 243 break; 244 245 case ir_unop_b2f: 246 for (unsigned c = 0; c < op[0]->type->components(); c++) { 247 switch (op[0]->type->base_type) { 248 case GLSL_TYPE_BOOL: 249 data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F; 250 break; 251 default: 252 unreachable("invalid type"); 253 } 254 } 255 break; 256 257 case ir_unop_b2f16: 258 for (unsigned c = 0; c < op[0]->type->components(); c++) { 259 switch (op[0]->type->base_type) { 260 case GLSL_TYPE_BOOL: 261 data.f[c] = op[0]->value.b[c] ? 1.0F : 0.0F; 262 break; 263 default: 264 unreachable("invalid type"); 265 } 266 } 267 break; 268 269 case ir_unop_i2b: 270 for (unsigned c = 0; c < op[0]->type->components(); c++) { 271 switch (op[0]->type->base_type) { 272 case GLSL_TYPE_UINT: 273 data.b[c] = op[0]->value.u[c] ? true : false; 274 break; 275 case GLSL_TYPE_INT: 276 data.b[c] = op[0]->value.i[c] ? true : false; 277 break; 278 default: 279 unreachable("invalid type"); 280 } 281 } 282 break; 283 284 case ir_unop_b2i: 285 for (unsigned c = 0; c < op[0]->type->components(); c++) { 286 switch (op[0]->type->base_type) { 287 case GLSL_TYPE_BOOL: 288 data.i[c] = op[0]->value.b[c] ? 1 : 0; 289 break; 290 default: 291 unreachable("invalid type"); 292 } 293 } 294 break; 295 296 case ir_unop_u2f: 297 for (unsigned c = 0; c < op[0]->type->components(); c++) { 298 switch (op[0]->type->base_type) { 299 case GLSL_TYPE_UINT: 300 data.f[c] = (float) op[0]->value.u[c]; 301 break; 302 default: 303 unreachable("invalid type"); 304 } 305 } 306 break; 307 308 case ir_unop_i2u: 309 for (unsigned c = 0; c < op[0]->type->components(); c++) { 310 switch (op[0]->type->base_type) { 311 case GLSL_TYPE_INT: 312 data.u[c] = op[0]->value.i[c]; 313 break; 314 default: 315 unreachable("invalid type"); 316 } 317 } 318 break; 319 320 case ir_unop_u2i: 321 for (unsigned c = 0; c < op[0]->type->components(); c++) { 322 switch (op[0]->type->base_type) { 323 case GLSL_TYPE_UINT: 324 data.i[c] = op[0]->value.u[c]; 325 break; 326 default: 327 unreachable("invalid type"); 328 } 329 } 330 break; 331 332 case ir_unop_d2f: 333 for (unsigned c = 0; c < op[0]->type->components(); c++) { 334 switch (op[0]->type->base_type) { 335 case GLSL_TYPE_DOUBLE: 336 data.f[c] = op[0]->value.d[c]; 337 break; 338 default: 339 unreachable("invalid type"); 340 } 341 } 342 break; 343 344 case ir_unop_f2d: 345 for (unsigned c = 0; c < op[0]->type->components(); c++) { 346 switch (op[0]->type->base_type) { 347 case GLSL_TYPE_FLOAT: 348 data.d[c] = op[0]->value.f[c]; 349 break; 350 default: 351 unreachable("invalid type"); 352 } 353 } 354 break; 355 356 case ir_unop_f2f16: 357 for (unsigned c = 0; c < op[0]->type->components(); c++) { 358 switch (op[0]->type->base_type) { 359 case GLSL_TYPE_FLOAT: 360 data.f[c] = op[0]->value.f[c]; 361 break; 362 default: 363 unreachable("invalid type"); 364 } 365 } 366 break; 367 368 case ir_unop_f2fmp: 369 for (unsigned c = 0; c < op[0]->type->components(); c++) { 370 switch (op[0]->type->base_type) { 371 case GLSL_TYPE_FLOAT: 372 data.f[c] = op[0]->value.f[c]; 373 break; 374 default: 375 unreachable("invalid type"); 376 } 377 } 378 break; 379 380 case ir_unop_f162f: 381 for (unsigned c = 0; c < op[0]->type->components(); c++) { 382 switch (op[0]->type->base_type) { 383 case GLSL_TYPE_FLOAT: 384 data.f[c] = op[0]->value.f[c]; 385 break; 386 default: 387 unreachable("invalid type"); 388 } 389 } 390 break; 391 392 case ir_unop_i2i: 393 for (unsigned c = 0; c < op[0]->type->components(); c++) { 394 switch (op[0]->type->base_type) { 395 case GLSL_TYPE_INT: 396 data.i[c] = op[0]->value.i[c]; 397 break; 398 default: 399 unreachable("invalid type"); 400 } 401 } 402 break; 403 404 case ir_unop_i2imp: 405 for (unsigned c = 0; c < op[0]->type->components(); c++) { 406 switch (op[0]->type->base_type) { 407 case GLSL_TYPE_INT: 408 data.i[c] = op[0]->value.i[c]; 409 break; 410 default: 411 unreachable("invalid type"); 412 } 413 } 414 break; 415 416 case ir_unop_u2u: 417 for (unsigned c = 0; c < op[0]->type->components(); c++) { 418 switch (op[0]->type->base_type) { 419 case GLSL_TYPE_UINT: 420 data.u[c] = op[0]->value.u[c]; 421 break; 422 default: 423 unreachable("invalid type"); 424 } 425 } 426 break; 427 428 case ir_unop_u2ump: 429 for (unsigned c = 0; c < op[0]->type->components(); c++) { 430 switch (op[0]->type->base_type) { 431 case GLSL_TYPE_UINT: 432 data.u[c] = op[0]->value.u[c]; 433 break; 434 default: 435 unreachable("invalid type"); 436 } 437 } 438 break; 439 440 case ir_unop_d2i: 441 for (unsigned c = 0; c < op[0]->type->components(); c++) { 442 switch (op[0]->type->base_type) { 443 case GLSL_TYPE_DOUBLE: 444 data.i[c] = op[0]->value.d[c]; 445 break; 446 default: 447 unreachable("invalid type"); 448 } 449 } 450 break; 451 452 case ir_unop_i2d: 453 for (unsigned c = 0; c < op[0]->type->components(); c++) { 454 switch (op[0]->type->base_type) { 455 case GLSL_TYPE_INT: 456 data.d[c] = op[0]->value.i[c]; 457 break; 458 default: 459 unreachable("invalid type"); 460 } 461 } 462 break; 463 464 case ir_unop_d2u: 465 for (unsigned c = 0; c < op[0]->type->components(); c++) { 466 switch (op[0]->type->base_type) { 467 case GLSL_TYPE_DOUBLE: 468 data.u[c] = op[0]->value.d[c]; 469 break; 470 default: 471 unreachable("invalid type"); 472 } 473 } 474 break; 475 476 case ir_unop_u2d: 477 for (unsigned c = 0; c < op[0]->type->components(); c++) { 478 switch (op[0]->type->base_type) { 479 case GLSL_TYPE_UINT: 480 data.d[c] = op[0]->value.u[c]; 481 break; 482 default: 483 unreachable("invalid type"); 484 } 485 } 486 break; 487 488 case ir_unop_d2b: 489 for (unsigned c = 0; c < op[0]->type->components(); c++) { 490 switch (op[0]->type->base_type) { 491 case GLSL_TYPE_DOUBLE: 492 data.b[c] = op[0]->value.d[c] != 0.0; 493 break; 494 default: 495 unreachable("invalid type"); 496 } 497 } 498 break; 499 500 case ir_unop_f162b: 501 for (unsigned c = 0; c < op[0]->type->components(); c++) { 502 switch (op[0]->type->base_type) { 503 case GLSL_TYPE_FLOAT: 504 data.b[c] = op[0]->value.f[c] != 0.0; 505 break; 506 default: 507 unreachable("invalid type"); 508 } 509 } 510 break; 511 512 case ir_unop_bitcast_i2f: 513 for (unsigned c = 0; c < op[0]->type->components(); c++) { 514 switch (op[0]->type->base_type) { 515 case GLSL_TYPE_INT: 516 data.f[c] = bitcast_u2f(op[0]->value.i[c]); 517 break; 518 default: 519 unreachable("invalid type"); 520 } 521 } 522 break; 523 524 case ir_unop_bitcast_f2i: 525 for (unsigned c = 0; c < op[0]->type->components(); c++) { 526 switch (op[0]->type->base_type) { 527 case GLSL_TYPE_FLOAT: 528 data.i[c] = bitcast_f2u(op[0]->value.f[c]); 529 break; 530 default: 531 unreachable("invalid type"); 532 } 533 } 534 break; 535 536 case ir_unop_bitcast_u2f: 537 for (unsigned c = 0; c < op[0]->type->components(); c++) { 538 switch (op[0]->type->base_type) { 539 case GLSL_TYPE_UINT: 540 data.f[c] = bitcast_u2f(op[0]->value.u[c]); 541 break; 542 default: 543 unreachable("invalid type"); 544 } 545 } 546 break; 547 548 case ir_unop_bitcast_f2u: 549 for (unsigned c = 0; c < op[0]->type->components(); c++) { 550 switch (op[0]->type->base_type) { 551 case GLSL_TYPE_FLOAT: 552 data.u[c] = bitcast_f2u(op[0]->value.f[c]); 553 break; 554 default: 555 unreachable("invalid type"); 556 } 557 } 558 break; 559 560 case ir_unop_bitcast_u642d: 561 for (unsigned c = 0; c < op[0]->type->components(); c++) { 562 switch (op[0]->type->base_type) { 563 case GLSL_TYPE_UINT64: 564 data.d[c] = bitcast_u642d(op[0]->value.u64[c]); 565 break; 566 default: 567 unreachable("invalid type"); 568 } 569 } 570 break; 571 572 case ir_unop_bitcast_i642d: 573 for (unsigned c = 0; c < op[0]->type->components(); c++) { 574 switch (op[0]->type->base_type) { 575 case GLSL_TYPE_INT64: 576 data.d[c] = bitcast_i642d(op[0]->value.i64[c]); 577 break; 578 default: 579 unreachable("invalid type"); 580 } 581 } 582 break; 583 584 case ir_unop_bitcast_d2u64: 585 for (unsigned c = 0; c < op[0]->type->components(); c++) { 586 switch (op[0]->type->base_type) { 587 case GLSL_TYPE_DOUBLE: 588 data.u64[c] = bitcast_d2u64(op[0]->value.d[c]); 589 break; 590 default: 591 unreachable("invalid type"); 592 } 593 } 594 break; 595 596 case ir_unop_bitcast_d2i64: 597 for (unsigned c = 0; c < op[0]->type->components(); c++) { 598 switch (op[0]->type->base_type) { 599 case GLSL_TYPE_DOUBLE: 600 data.i64[c] = bitcast_d2i64(op[0]->value.d[c]); 601 break; 602 default: 603 unreachable("invalid type"); 604 } 605 } 606 break; 607 608 case ir_unop_i642i: 609 for (unsigned c = 0; c < op[0]->type->components(); c++) { 610 switch (op[0]->type->base_type) { 611 case GLSL_TYPE_INT64: 612 data.i[c] = op[0]->value.i64[c]; 613 break; 614 default: 615 unreachable("invalid type"); 616 } 617 } 618 break; 619 620 case ir_unop_u642i: 621 for (unsigned c = 0; c < op[0]->type->components(); c++) { 622 switch (op[0]->type->base_type) { 623 case GLSL_TYPE_UINT64: 624 data.i[c] = op[0]->value.u64[c]; 625 break; 626 default: 627 unreachable("invalid type"); 628 } 629 } 630 break; 631 632 case ir_unop_i642u: 633 for (unsigned c = 0; c < op[0]->type->components(); c++) { 634 switch (op[0]->type->base_type) { 635 case GLSL_TYPE_INT64: 636 data.u[c] = op[0]->value.i64[c]; 637 break; 638 default: 639 unreachable("invalid type"); 640 } 641 } 642 break; 643 644 case ir_unop_u642u: 645 for (unsigned c = 0; c < op[0]->type->components(); c++) { 646 switch (op[0]->type->base_type) { 647 case GLSL_TYPE_UINT64: 648 data.u[c] = op[0]->value.u64[c]; 649 break; 650 default: 651 unreachable("invalid type"); 652 } 653 } 654 break; 655 656 case ir_unop_i642b: 657 for (unsigned c = 0; c < op[0]->type->components(); c++) { 658 switch (op[0]->type->base_type) { 659 case GLSL_TYPE_INT64: 660 data.b[c] = op[0]->value.i64[c] != 0; 661 break; 662 default: 663 unreachable("invalid type"); 664 } 665 } 666 break; 667 668 case ir_unop_i642f: 669 for (unsigned c = 0; c < op[0]->type->components(); c++) { 670 switch (op[0]->type->base_type) { 671 case GLSL_TYPE_INT64: 672 data.f[c] = op[0]->value.i64[c]; 673 break; 674 default: 675 unreachable("invalid type"); 676 } 677 } 678 break; 679 680 case ir_unop_u642f: 681 for (unsigned c = 0; c < op[0]->type->components(); c++) { 682 switch (op[0]->type->base_type) { 683 case GLSL_TYPE_UINT64: 684 data.f[c] = op[0]->value.u64[c]; 685 break; 686 default: 687 unreachable("invalid type"); 688 } 689 } 690 break; 691 692 case ir_unop_i642d: 693 for (unsigned c = 0; c < op[0]->type->components(); c++) { 694 switch (op[0]->type->base_type) { 695 case GLSL_TYPE_INT64: 696 data.d[c] = op[0]->value.i64[c]; 697 break; 698 default: 699 unreachable("invalid type"); 700 } 701 } 702 break; 703 704 case ir_unop_u642d: 705 for (unsigned c = 0; c < op[0]->type->components(); c++) { 706 switch (op[0]->type->base_type) { 707 case GLSL_TYPE_UINT64: 708 data.d[c] = op[0]->value.u64[c]; 709 break; 710 default: 711 unreachable("invalid type"); 712 } 713 } 714 break; 715 716 case ir_unop_i2i64: 717 for (unsigned c = 0; c < op[0]->type->components(); c++) { 718 switch (op[0]->type->base_type) { 719 case GLSL_TYPE_INT: 720 data.i64[c] = op[0]->value.i[c]; 721 break; 722 default: 723 unreachable("invalid type"); 724 } 725 } 726 break; 727 728 case ir_unop_u2i64: 729 for (unsigned c = 0; c < op[0]->type->components(); c++) { 730 switch (op[0]->type->base_type) { 731 case GLSL_TYPE_UINT: 732 data.i64[c] = op[0]->value.u[c]; 733 break; 734 default: 735 unreachable("invalid type"); 736 } 737 } 738 break; 739 740 case ir_unop_b2i64: 741 for (unsigned c = 0; c < op[0]->type->components(); c++) { 742 switch (op[0]->type->base_type) { 743 case GLSL_TYPE_BOOL: 744 data.i64[c] = op[0]->value.b[c]; 745 break; 746 default: 747 unreachable("invalid type"); 748 } 749 } 750 break; 751 752 case ir_unop_f2i64: 753 for (unsigned c = 0; c < op[0]->type->components(); c++) { 754 switch (op[0]->type->base_type) { 755 case GLSL_TYPE_FLOAT: 756 data.i64[c] = op[0]->value.f[c]; 757 break; 758 default: 759 unreachable("invalid type"); 760 } 761 } 762 break; 763 764 case ir_unop_d2i64: 765 for (unsigned c = 0; c < op[0]->type->components(); c++) { 766 switch (op[0]->type->base_type) { 767 case GLSL_TYPE_DOUBLE: 768 data.i64[c] = op[0]->value.d[c]; 769 break; 770 default: 771 unreachable("invalid type"); 772 } 773 } 774 break; 775 776 case ir_unop_i2u64: 777 for (unsigned c = 0; c < op[0]->type->components(); c++) { 778 switch (op[0]->type->base_type) { 779 case GLSL_TYPE_INT: 780 data.u64[c] = op[0]->value.i[c]; 781 break; 782 default: 783 unreachable("invalid type"); 784 } 785 } 786 break; 787 788 case ir_unop_u2u64: 789 for (unsigned c = 0; c < op[0]->type->components(); c++) { 790 switch (op[0]->type->base_type) { 791 case GLSL_TYPE_UINT: 792 data.u64[c] = op[0]->value.u[c]; 793 break; 794 default: 795 unreachable("invalid type"); 796 } 797 } 798 break; 799 800 case ir_unop_f2u64: 801 for (unsigned c = 0; c < op[0]->type->components(); c++) { 802 switch (op[0]->type->base_type) { 803 case GLSL_TYPE_FLOAT: 804 data.u64[c] = op[0]->value.f[c]; 805 break; 806 default: 807 unreachable("invalid type"); 808 } 809 } 810 break; 811 812 case ir_unop_d2u64: 813 for (unsigned c = 0; c < op[0]->type->components(); c++) { 814 switch (op[0]->type->base_type) { 815 case GLSL_TYPE_DOUBLE: 816 data.u64[c] = op[0]->value.d[c]; 817 break; 818 default: 819 unreachable("invalid type"); 820 } 821 } 822 break; 823 824 case ir_unop_u642i64: 825 for (unsigned c = 0; c < op[0]->type->components(); c++) { 826 switch (op[0]->type->base_type) { 827 case GLSL_TYPE_UINT64: 828 data.i64[c] = op[0]->value.u64[c]; 829 break; 830 default: 831 unreachable("invalid type"); 832 } 833 } 834 break; 835 836 case ir_unop_i642u64: 837 for (unsigned c = 0; c < op[0]->type->components(); c++) { 838 switch (op[0]->type->base_type) { 839 case GLSL_TYPE_INT64: 840 data.u64[c] = op[0]->value.i64[c]; 841 break; 842 default: 843 unreachable("invalid type"); 844 } 845 } 846 break; 847 848 case ir_unop_trunc: 849 for (unsigned c = 0; c < op[0]->type->components(); c++) { 850 switch (op[0]->type->base_type) { 851 case GLSL_TYPE_FLOAT: 852 data.f[c] = truncf(op[0]->value.f[c]); 853 break; 854 case GLSL_TYPE_DOUBLE: 855 data.d[c] = trunc(op[0]->value.d[c]); 856 break; 857 default: 858 unreachable("invalid type"); 859 } 860 } 861 break; 862 863 case ir_unop_ceil: 864 for (unsigned c = 0; c < op[0]->type->components(); c++) { 865 switch (op[0]->type->base_type) { 866 case GLSL_TYPE_FLOAT: 867 data.f[c] = ceilf(op[0]->value.f[c]); 868 break; 869 case GLSL_TYPE_DOUBLE: 870 data.d[c] = ceil(op[0]->value.d[c]); 871 break; 872 default: 873 unreachable("invalid type"); 874 } 875 } 876 break; 877 878 case ir_unop_floor: 879 for (unsigned c = 0; c < op[0]->type->components(); c++) { 880 switch (op[0]->type->base_type) { 881 case GLSL_TYPE_FLOAT: 882 data.f[c] = floorf(op[0]->value.f[c]); 883 break; 884 case GLSL_TYPE_DOUBLE: 885 data.d[c] = floor(op[0]->value.d[c]); 886 break; 887 default: 888 unreachable("invalid type"); 889 } 890 } 891 break; 892 893 case ir_unop_fract: 894 for (unsigned c = 0; c < op[0]->type->components(); c++) { 895 switch (op[0]->type->base_type) { 896 case GLSL_TYPE_FLOAT: 897 data.f[c] = op[0]->value.f[c] - floorf(op[0]->value.f[c]); 898 break; 899 case GLSL_TYPE_DOUBLE: 900 data.d[c] = op[0]->value.d[c] - floor(op[0]->value.d[c]); 901 break; 902 default: 903 unreachable("invalid type"); 904 } 905 } 906 break; 907 908 case ir_unop_round_even: 909 for (unsigned c = 0; c < op[0]->type->components(); c++) { 910 switch (op[0]->type->base_type) { 911 case GLSL_TYPE_FLOAT: 912 data.f[c] = _mesa_roundevenf(op[0]->value.f[c]); 913 break; 914 case GLSL_TYPE_DOUBLE: 915 data.d[c] = _mesa_roundeven(op[0]->value.d[c]); 916 break; 917 default: 918 unreachable("invalid type"); 919 } 920 } 921 break; 922 923 case ir_unop_sin: 924 for (unsigned c = 0; c < op[0]->type->components(); c++) { 925 switch (op[0]->type->base_type) { 926 case GLSL_TYPE_FLOAT: 927 data.f[c] = sinf(op[0]->value.f[c]); 928 break; 929 default: 930 unreachable("invalid type"); 931 } 932 } 933 break; 934 935 case ir_unop_cos: 936 for (unsigned c = 0; c < op[0]->type->components(); c++) { 937 switch (op[0]->type->base_type) { 938 case GLSL_TYPE_FLOAT: 939 data.f[c] = cosf(op[0]->value.f[c]); 940 break; 941 default: 942 unreachable("invalid type"); 943 } 944 } 945 break; 946 947 case ir_unop_atan: 948 for (unsigned c = 0; c < op[0]->type->components(); c++) { 949 switch (op[0]->type->base_type) { 950 case GLSL_TYPE_FLOAT: 951 data.f[c] = atan(op[0]->value.f[c]); 952 break; 953 default: 954 unreachable("invalid type"); 955 } 956 } 957 break; 958 959 case ir_unop_dFdx: 960 for (unsigned c = 0; c < op[0]->type->components(); c++) { 961 switch (op[0]->type->base_type) { 962 case GLSL_TYPE_FLOAT: 963 data.f[c] = 0.0f; 964 break; 965 default: 966 unreachable("invalid type"); 967 } 968 } 969 break; 970 971 case ir_unop_dFdx_coarse: 972 for (unsigned c = 0; c < op[0]->type->components(); c++) { 973 switch (op[0]->type->base_type) { 974 case GLSL_TYPE_FLOAT: 975 data.f[c] = 0.0f; 976 break; 977 default: 978 unreachable("invalid type"); 979 } 980 } 981 break; 982 983 case ir_unop_dFdx_fine: 984 for (unsigned c = 0; c < op[0]->type->components(); c++) { 985 switch (op[0]->type->base_type) { 986 case GLSL_TYPE_FLOAT: 987 data.f[c] = 0.0f; 988 break; 989 default: 990 unreachable("invalid type"); 991 } 992 } 993 break; 994 995 case ir_unop_dFdy: 996 for (unsigned c = 0; c < op[0]->type->components(); c++) { 997 switch (op[0]->type->base_type) { 998 case GLSL_TYPE_FLOAT: 999 data.f[c] = 0.0f; 1000 break; 1001 default: 1002 unreachable("invalid type"); 1003 } 1004 } 1005 break; 1006 1007 case ir_unop_dFdy_coarse: 1008 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1009 switch (op[0]->type->base_type) { 1010 case GLSL_TYPE_FLOAT: 1011 data.f[c] = 0.0f; 1012 break; 1013 default: 1014 unreachable("invalid type"); 1015 } 1016 } 1017 break; 1018 1019 case ir_unop_dFdy_fine: 1020 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1021 switch (op[0]->type->base_type) { 1022 case GLSL_TYPE_FLOAT: 1023 data.f[c] = 0.0f; 1024 break; 1025 default: 1026 unreachable("invalid type"); 1027 } 1028 } 1029 break; 1030 1031 case ir_unop_pack_snorm_2x16: 1032 switch (op[0]->type->base_type) { 1033 case GLSL_TYPE_FLOAT: 1034 data.u[0] = pack_2x16(pack_snorm_1x16, op[0]->value.f[0], op[0]->value.f[1]); 1035 break; 1036 default: 1037 unreachable("invalid type"); 1038 } 1039 break; 1040 1041 case ir_unop_pack_snorm_4x8: 1042 switch (op[0]->type->base_type) { 1043 case GLSL_TYPE_FLOAT: 1044 data.u[0] = pack_4x8(pack_snorm_1x8, op[0]->value.f[0], op[0]->value.f[1], op[0]->value.f[2], op[0]->value.f[3]); 1045 break; 1046 default: 1047 unreachable("invalid type"); 1048 } 1049 break; 1050 1051 case ir_unop_pack_unorm_2x16: 1052 switch (op[0]->type->base_type) { 1053 case GLSL_TYPE_FLOAT: 1054 data.u[0] = pack_2x16(pack_unorm_1x16, op[0]->value.f[0], op[0]->value.f[1]); 1055 break; 1056 default: 1057 unreachable("invalid type"); 1058 } 1059 break; 1060 1061 case ir_unop_pack_unorm_4x8: 1062 switch (op[0]->type->base_type) { 1063 case GLSL_TYPE_FLOAT: 1064 data.u[0] = pack_4x8(pack_unorm_1x8, op[0]->value.f[0], op[0]->value.f[1], op[0]->value.f[2], op[0]->value.f[3]); 1065 break; 1066 default: 1067 unreachable("invalid type"); 1068 } 1069 break; 1070 1071 case ir_unop_pack_half_2x16: 1072 switch (op[0]->type->base_type) { 1073 case GLSL_TYPE_FLOAT: 1074 data.u[0] = pack_2x16(pack_half_1x16, op[0]->value.f[0], op[0]->value.f[1]); 1075 break; 1076 default: 1077 unreachable("invalid type"); 1078 } 1079 break; 1080 1081 case ir_unop_unpack_snorm_2x16: 1082 unpack_2x16(unpack_snorm_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]); 1083 break; 1084 1085 case ir_unop_unpack_snorm_4x8: 1086 unpack_4x8(unpack_snorm_1x8, op[0]->value.u[0], &data.f[0], &data.f[1], &data.f[2], &data.f[3]); 1087 break; 1088 1089 case ir_unop_unpack_unorm_2x16: 1090 unpack_2x16(unpack_unorm_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]); 1091 break; 1092 1093 case ir_unop_unpack_unorm_4x8: 1094 unpack_4x8(unpack_unorm_1x8, op[0]->value.u[0], &data.f[0], &data.f[1], &data.f[2], &data.f[3]); 1095 break; 1096 1097 case ir_unop_unpack_half_2x16: 1098 unpack_2x16(unpack_half_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]); 1099 break; 1100 1101 case ir_unop_bitfield_reverse: 1102 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1103 switch (op[0]->type->base_type) { 1104 case GLSL_TYPE_UINT: 1105 data.u[c] = bitfield_reverse(op[0]->value.u[c]); 1106 break; 1107 case GLSL_TYPE_INT: 1108 data.i[c] = bitfield_reverse(op[0]->value.i[c]); 1109 break; 1110 default: 1111 unreachable("invalid type"); 1112 } 1113 } 1114 break; 1115 1116 case ir_unop_bit_count: 1117 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1118 switch (op[0]->type->base_type) { 1119 case GLSL_TYPE_UINT: 1120 data.i[c] = util_bitcount(op[0]->value.u[c]); 1121 break; 1122 case GLSL_TYPE_INT: 1123 data.i[c] = util_bitcount(op[0]->value.i[c]); 1124 break; 1125 default: 1126 unreachable("invalid type"); 1127 } 1128 } 1129 break; 1130 1131 case ir_unop_find_msb: 1132 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1133 switch (op[0]->type->base_type) { 1134 case GLSL_TYPE_UINT: 1135 data.i[c] = find_msb_uint(op[0]->value.u[c]); 1136 break; 1137 case GLSL_TYPE_INT: 1138 data.i[c] = find_msb_int(op[0]->value.i[c]); 1139 break; 1140 default: 1141 unreachable("invalid type"); 1142 } 1143 } 1144 break; 1145 1146 case ir_unop_find_lsb: 1147 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1148 switch (op[0]->type->base_type) { 1149 case GLSL_TYPE_UINT: 1150 data.i[c] = find_msb_uint(op[0]->value.u[c] & -op[0]->value.u[c]); 1151 break; 1152 case GLSL_TYPE_INT: 1153 data.i[c] = find_msb_uint(op[0]->value.i[c] & -op[0]->value.i[c]); 1154 break; 1155 default: 1156 unreachable("invalid type"); 1157 } 1158 } 1159 break; 1160 1161 case ir_unop_clz: 1162 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1163 switch (op[0]->type->base_type) { 1164 case GLSL_TYPE_UINT: 1165 data.u[c] = (unsigned)(31 - find_msb_uint(op[0]->value.u[c])); 1166 break; 1167 default: 1168 unreachable("invalid type"); 1169 } 1170 } 1171 break; 1172 1173 case ir_unop_saturate: 1174 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1175 switch (op[0]->type->base_type) { 1176 case GLSL_TYPE_FLOAT: 1177 data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f); 1178 break; 1179 default: 1180 unreachable("invalid type"); 1181 } 1182 } 1183 break; 1184 1185 case ir_unop_pack_double_2x32: 1186 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1187 break; 1188 1189 case ir_unop_unpack_double_2x32: 1190 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1191 break; 1192 1193 case ir_unop_pack_sampler_2x32: 1194 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1195 break; 1196 1197 case ir_unop_pack_image_2x32: 1198 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1199 break; 1200 1201 case ir_unop_unpack_sampler_2x32: 1202 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1203 break; 1204 1205 case ir_unop_unpack_image_2x32: 1206 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1207 break; 1208 1209 case ir_unop_pack_int_2x32: 1210 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1211 break; 1212 1213 case ir_unop_pack_uint_2x32: 1214 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1215 break; 1216 1217 case ir_unop_unpack_int_2x32: 1218 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1219 break; 1220 1221 case ir_unop_unpack_uint_2x32: 1222 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1223 break; 1224 1225 case ir_binop_add: 1226 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1227 for (unsigned c = 0, c0 = 0, c1 = 0; 1228 c < components; 1229 c0 += c0_inc, c1 += c1_inc, c++) { 1230 1231 switch (op[0]->type->base_type) { 1232 case GLSL_TYPE_UINT: 1233 data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1]; 1234 break; 1235 case GLSL_TYPE_INT: 1236 data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1]; 1237 break; 1238 case GLSL_TYPE_FLOAT: 1239 data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1]; 1240 break; 1241 case GLSL_TYPE_DOUBLE: 1242 data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1]; 1243 break; 1244 case GLSL_TYPE_UINT64: 1245 data.u64[c] = op[0]->value.u64[c0] + op[1]->value.u64[c1]; 1246 break; 1247 case GLSL_TYPE_INT64: 1248 data.i64[c] = op[0]->value.i64[c0] + op[1]->value.i64[c1]; 1249 break; 1250 default: 1251 unreachable("invalid type"); 1252 } 1253 } 1254 break; 1255 1256 case ir_binop_sub: 1257 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1258 for (unsigned c = 0, c0 = 0, c1 = 0; 1259 c < components; 1260 c0 += c0_inc, c1 += c1_inc, c++) { 1261 1262 switch (op[0]->type->base_type) { 1263 case GLSL_TYPE_UINT: 1264 data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1]; 1265 break; 1266 case GLSL_TYPE_INT: 1267 data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1]; 1268 break; 1269 case GLSL_TYPE_FLOAT: 1270 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]; 1271 break; 1272 case GLSL_TYPE_DOUBLE: 1273 data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1]; 1274 break; 1275 case GLSL_TYPE_UINT64: 1276 data.u64[c] = op[0]->value.u64[c0] - op[1]->value.u64[c1]; 1277 break; 1278 case GLSL_TYPE_INT64: 1279 data.i64[c] = op[0]->value.i64[c0] - op[1]->value.i64[c1]; 1280 break; 1281 default: 1282 unreachable("invalid type"); 1283 } 1284 } 1285 break; 1286 1287 case ir_binop_add_sat: 1288 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1289 switch (op[0]->type->base_type) { 1290 case GLSL_TYPE_UINT: 1291 data.u[c] = (op[0]->value.u[c] + op[1]->value.u[c]) < op[0]->value.u[c] ? UINT32_MAX : (op[0]->value.u[c] + op[1]->value.u[c]); 1292 break; 1293 case GLSL_TYPE_INT: 1294 data.i[c] = iadd_saturate(op[0]->value.i[c], op[1]->value.i[c]); 1295 break; 1296 case GLSL_TYPE_UINT64: 1297 data.u64[c] = (op[0]->value.u64[c] + op[1]->value.u64[c]) < op[0]->value.u64[c] ? UINT64_MAX : (op[0]->value.u64[c] + op[1]->value.u64[c]); 1298 break; 1299 case GLSL_TYPE_INT64: 1300 data.i64[c] = iadd64_saturate(op[0]->value.i64[c], op[1]->value.i64[c]); 1301 break; 1302 default: 1303 unreachable("invalid type"); 1304 } 1305 } 1306 break; 1307 1308 case ir_binop_sub_sat: 1309 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1310 switch (op[0]->type->base_type) { 1311 case GLSL_TYPE_UINT: 1312 data.u[c] = (op[1]->value.u[c] > op[0]->value.u[c]) ? 0 : op[0]->value.u[c] - op[1]->value.u[c]; 1313 break; 1314 case GLSL_TYPE_INT: 1315 data.i[c] = isub_saturate(op[0]->value.i[c], op[1]->value.i[c]); 1316 break; 1317 case GLSL_TYPE_UINT64: 1318 data.u64[c] = (op[1]->value.u64[c] > op[0]->value.u64[c]) ? 0 : op[0]->value.u64[c] - op[1]->value.u64[c]; 1319 break; 1320 case GLSL_TYPE_INT64: 1321 data.i64[c] = isub64_saturate(op[0]->value.i64[c], op[1]->value.i64[c]); 1322 break; 1323 default: 1324 unreachable("invalid type"); 1325 } 1326 } 1327 break; 1328 1329 case ir_binop_abs_sub: 1330 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1331 switch (op[0]->type->base_type) { 1332 case GLSL_TYPE_UINT: 1333 data.u[c] = (op[1]->value.u[c] > op[0]->value.u[c]) ? op[1]->value.u[c] - op[0]->value.u[c] : op[0]->value.u[c] - op[1]->value.u[c]; 1334 break; 1335 case GLSL_TYPE_INT: 1336 data.i[c] = (op[1]->value.i[c] > op[0]->value.i[c]) ? (unsigned)op[1]->value.i[c] - (unsigned)op[0]->value.i[c] : (unsigned)op[0]->value.i[c] - (unsigned)op[1]->value.i[c]; 1337 break; 1338 case GLSL_TYPE_UINT64: 1339 data.u64[c] = (op[1]->value.u64[c] > op[0]->value.u64[c]) ? op[1]->value.u64[c] - op[0]->value.u64[c] : op[0]->value.u64[c] - op[1]->value.u64[c]; 1340 break; 1341 case GLSL_TYPE_INT64: 1342 data.i64[c] = (op[1]->value.i64[c] > op[0]->value.i64[c]) ? (uint64_t)op[1]->value.i64[c] - (uint64_t)op[0]->value.i64[c] : (uint64_t)op[0]->value.i64[c] - (uint64_t)op[1]->value.i64[c]; 1343 break; 1344 default: 1345 unreachable("invalid type"); 1346 } 1347 } 1348 break; 1349 1350 case ir_binop_avg: 1351 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1352 switch (op[0]->type->base_type) { 1353 case GLSL_TYPE_UINT: 1354 data.u[c] = (op[0]->value.u[c] >> 1) + (op[1]->value.u[c] >> 1) + ((op[0]->value.u[c] & op[1]->value.u[c]) & 1); 1355 break; 1356 case GLSL_TYPE_INT: 1357 data.i[c] = (op[0]->value.i[c] >> 1) + (op[1]->value.i[c] >> 1) + ((op[0]->value.i[c] & op[1]->value.i[c]) & 1); 1358 break; 1359 case GLSL_TYPE_UINT64: 1360 data.u64[c] = (op[0]->value.u64[c] >> 1) + (op[1]->value.u64[c] >> 1) + ((op[0]->value.u64[c] & op[1]->value.u64[c]) & 1); 1361 break; 1362 case GLSL_TYPE_INT64: 1363 data.i64[c] = (op[0]->value.i64[c] >> 1) + (op[1]->value.i64[c] >> 1) + ((op[0]->value.i64[c] & op[1]->value.i64[c]) & 1); 1364 break; 1365 default: 1366 unreachable("invalid type"); 1367 } 1368 } 1369 break; 1370 1371 case ir_binop_avg_round: 1372 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1373 switch (op[0]->type->base_type) { 1374 case GLSL_TYPE_UINT: 1375 data.u[c] = (op[0]->value.u[c] >> 1) + (op[1]->value.u[c] >> 1) + ((op[0]->value.u[c] | op[1]->value.u[c]) & 1); 1376 break; 1377 case GLSL_TYPE_INT: 1378 data.i[c] = (op[0]->value.i[c] >> 1) + (op[1]->value.i[c] >> 1) + ((op[0]->value.i[c] | op[1]->value.i[c]) & 1); 1379 break; 1380 case GLSL_TYPE_UINT64: 1381 data.u64[c] = (op[0]->value.u64[c] >> 1) + (op[1]->value.u64[c] >> 1) + ((op[0]->value.u64[c] | op[1]->value.u64[c]) & 1); 1382 break; 1383 case GLSL_TYPE_INT64: 1384 data.i64[c] = (op[0]->value.i64[c] >> 1) + (op[1]->value.i64[c] >> 1) + ((op[0]->value.i64[c] | op[1]->value.i64[c]) & 1); 1385 break; 1386 default: 1387 unreachable("invalid type"); 1388 } 1389 } 1390 break; 1391 1392 case ir_binop_mul: 1393 /* Check for equal types, or unequal types involving scalars */ 1394 if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix()) 1395 || op0_scalar || op1_scalar) { 1396 for (unsigned c = 0, c0 = 0, c1 = 0; 1397 c < components; 1398 c0 += c0_inc, c1 += c1_inc, c++) { 1399 1400 switch (op[0]->type->base_type) { 1401 case GLSL_TYPE_UINT: 1402 data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1]; 1403 break; 1404 case GLSL_TYPE_INT: 1405 data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1]; 1406 break; 1407 case GLSL_TYPE_FLOAT: 1408 data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1]; 1409 break; 1410 case GLSL_TYPE_DOUBLE: 1411 data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1]; 1412 break; 1413 case GLSL_TYPE_UINT64: 1414 data.u64[c] = op[0]->value.u64[c0] * op[1]->value.u64[c1]; 1415 break; 1416 case GLSL_TYPE_INT64: 1417 data.i64[c] = op[0]->value.i64[c0] * op[1]->value.i64[c1]; 1418 break; 1419 default: 1420 unreachable("invalid type"); 1421 } 1422 } 1423 } else { 1424 assert(op[0]->type->is_matrix() || op[1]->type->is_matrix()); 1425 1426 /* Multiply an N-by-M matrix with an M-by-P matrix. Since either 1427 * matrix can be a GLSL vector, either N or P can be 1. 1428 * 1429 * For vec*mat, the vector is treated as a row vector. This 1430 * means the vector is a 1-row x M-column matrix. 1431 * 1432 * For mat*vec, the vector is treated as a column vector. Since 1433 * matrix_columns is 1 for vectors, this just works. 1434 */ 1435 const unsigned n = op[0]->type->is_vector() 1436 ? 1 : op[0]->type->vector_elements; 1437 const unsigned m = op[1]->type->vector_elements; 1438 const unsigned p = op[1]->type->matrix_columns; 1439 for (unsigned j = 0; j < p; j++) { 1440 for (unsigned i = 0; i < n; i++) { 1441 for (unsigned k = 0; k < m; k++) { 1442 if (op[0]->type->is_double()) 1443 data.d[i+n*j] += op[0]->value.d[i+n*k]*op[1]->value.d[k+m*j]; 1444 else 1445 data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j]; 1446 } 1447 } 1448 } 1449 } 1450 break; 1451 1452 case ir_binop_mul_32x16: 1453 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1454 switch (op[0]->type->base_type) { 1455 case GLSL_TYPE_UINT: 1456 data.u[c] = op[0]->value.u[c] * (uint16_t)op[1]->value.u[c]; 1457 break; 1458 case GLSL_TYPE_INT: 1459 data.i[c] = op[0]->value.i[c] * (int16_t)op[0]->value.i[c]; 1460 break; 1461 default: 1462 unreachable("invalid type"); 1463 } 1464 } 1465 break; 1466 1467 case ir_binop_div: 1468 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1469 for (unsigned c = 0, c0 = 0, c1 = 0; 1470 c < components; 1471 c0 += c0_inc, c1 += c1_inc, c++) { 1472 1473 switch (op[0]->type->base_type) { 1474 case GLSL_TYPE_UINT: 1475 data.u[c] = op[1]->value.u[c1] == 0 ? 0 : op[0]->value.u[c0] / op[1]->value.u[c1]; 1476 break; 1477 case GLSL_TYPE_INT: 1478 data.i[c] = op[1]->value.i[c1] == 0 ? 0 : op[0]->value.i[c0] / op[1]->value.i[c1]; 1479 break; 1480 case GLSL_TYPE_FLOAT: 1481 data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1]; 1482 break; 1483 case GLSL_TYPE_DOUBLE: 1484 data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1]; 1485 break; 1486 case GLSL_TYPE_UINT64: 1487 data.u64[c] = op[1]->value.u64[c1] == 0 ? 0 : op[0]->value.u64[c0] / op[1]->value.u64[c1]; 1488 break; 1489 case GLSL_TYPE_INT64: 1490 data.i64[c] = op[1]->value.i64[c1] == 0 ? 0 : op[0]->value.i64[c0] / op[1]->value.i64[c1]; 1491 break; 1492 default: 1493 unreachable("invalid type"); 1494 } 1495 } 1496 break; 1497 1498 case ir_binop_mod: 1499 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1500 for (unsigned c = 0, c0 = 0, c1 = 0; 1501 c < components; 1502 c0 += c0_inc, c1 += c1_inc, c++) { 1503 1504 switch (op[0]->type->base_type) { 1505 case GLSL_TYPE_UINT: 1506 data.u[c] = op[1]->value.u[c1] == 0 ? 0 : op[0]->value.u[c0] % op[1]->value.u[c1]; 1507 break; 1508 case GLSL_TYPE_INT: 1509 data.i[c] = op[1]->value.i[c1] == 0 ? 0 : op[0]->value.i[c0] % op[1]->value.i[c1]; 1510 break; 1511 case GLSL_TYPE_FLOAT: 1512 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1] * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]); 1513 break; 1514 case GLSL_TYPE_DOUBLE: 1515 data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1] * floor(op[0]->value.d[c0] / op[1]->value.d[c1]); 1516 break; 1517 case GLSL_TYPE_UINT64: 1518 data.u64[c] = op[1]->value.u64[c1] == 0 ? 0 : op[0]->value.u64[c0] % op[1]->value.u64[c1]; 1519 break; 1520 case GLSL_TYPE_INT64: 1521 data.i64[c] = op[1]->value.i64[c1] == 0 ? 0 : op[0]->value.i64[c0] % op[1]->value.i64[c1]; 1522 break; 1523 default: 1524 unreachable("invalid type"); 1525 } 1526 } 1527 break; 1528 1529 case ir_binop_less: 1530 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1531 switch (op[0]->type->base_type) { 1532 case GLSL_TYPE_UINT: 1533 data.b[c] = op[0]->value.u[c] < op[1]->value.u[c]; 1534 break; 1535 case GLSL_TYPE_INT: 1536 data.b[c] = op[0]->value.i[c] < op[1]->value.i[c]; 1537 break; 1538 case GLSL_TYPE_FLOAT: 1539 data.b[c] = op[0]->value.f[c] < op[1]->value.f[c]; 1540 break; 1541 case GLSL_TYPE_DOUBLE: 1542 data.b[c] = op[0]->value.d[c] < op[1]->value.d[c]; 1543 break; 1544 case GLSL_TYPE_UINT64: 1545 data.b[c] = op[0]->value.u64[c] < op[1]->value.u64[c]; 1546 break; 1547 case GLSL_TYPE_INT64: 1548 data.b[c] = op[0]->value.i64[c] < op[1]->value.i64[c]; 1549 break; 1550 default: 1551 unreachable("invalid type"); 1552 } 1553 } 1554 break; 1555 1556 case ir_binop_gequal: 1557 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1558 switch (op[0]->type->base_type) { 1559 case GLSL_TYPE_UINT: 1560 data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c]; 1561 break; 1562 case GLSL_TYPE_INT: 1563 data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c]; 1564 break; 1565 case GLSL_TYPE_FLOAT: 1566 data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c]; 1567 break; 1568 case GLSL_TYPE_DOUBLE: 1569 data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c]; 1570 break; 1571 case GLSL_TYPE_UINT64: 1572 data.b[c] = op[0]->value.u64[c] >= op[1]->value.u64[c]; 1573 break; 1574 case GLSL_TYPE_INT64: 1575 data.b[c] = op[0]->value.i64[c] >= op[1]->value.i64[c]; 1576 break; 1577 default: 1578 unreachable("invalid type"); 1579 } 1580 } 1581 break; 1582 1583 case ir_binop_equal: 1584 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1585 switch (op[0]->type->base_type) { 1586 case GLSL_TYPE_UINT: 1587 data.b[c] = op[0]->value.u[c] == op[1]->value.u[c]; 1588 break; 1589 case GLSL_TYPE_INT: 1590 data.b[c] = op[0]->value.i[c] == op[1]->value.i[c]; 1591 break; 1592 case GLSL_TYPE_FLOAT: 1593 data.b[c] = op[0]->value.f[c] == op[1]->value.f[c]; 1594 break; 1595 case GLSL_TYPE_DOUBLE: 1596 data.b[c] = op[0]->value.d[c] == op[1]->value.d[c]; 1597 break; 1598 case GLSL_TYPE_UINT64: 1599 data.b[c] = op[0]->value.u64[c] == op[1]->value.u64[c]; 1600 break; 1601 case GLSL_TYPE_INT64: 1602 data.b[c] = op[0]->value.i64[c] == op[1]->value.i64[c]; 1603 break; 1604 case GLSL_TYPE_BOOL: 1605 data.b[c] = op[0]->value.b[c] == op[1]->value.b[c]; 1606 break; 1607 default: 1608 unreachable("invalid type"); 1609 } 1610 } 1611 break; 1612 1613 case ir_binop_nequal: 1614 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1615 switch (op[0]->type->base_type) { 1616 case GLSL_TYPE_UINT: 1617 data.b[c] = op[0]->value.u[c] != op[1]->value.u[c]; 1618 break; 1619 case GLSL_TYPE_INT: 1620 data.b[c] = op[0]->value.i[c] != op[1]->value.i[c]; 1621 break; 1622 case GLSL_TYPE_FLOAT: 1623 data.b[c] = op[0]->value.f[c] != op[1]->value.f[c]; 1624 break; 1625 case GLSL_TYPE_DOUBLE: 1626 data.b[c] = op[0]->value.d[c] != op[1]->value.d[c]; 1627 break; 1628 case GLSL_TYPE_UINT64: 1629 data.b[c] = op[0]->value.u64[c] != op[1]->value.u64[c]; 1630 break; 1631 case GLSL_TYPE_INT64: 1632 data.b[c] = op[0]->value.i64[c] != op[1]->value.i64[c]; 1633 break; 1634 case GLSL_TYPE_BOOL: 1635 data.b[c] = op[0]->value.b[c] != op[1]->value.b[c]; 1636 break; 1637 default: 1638 unreachable("invalid type"); 1639 } 1640 } 1641 break; 1642 1643 case ir_binop_all_equal: 1644 data.b[0] = op[0]->has_value(op[1]); 1645 break; 1646 1647 case ir_binop_any_nequal: 1648 data.b[0] = !op[0]->has_value(op[1]); 1649 break; 1650 1651 case ir_binop_lshift: 1652 assert(op[0]->type->base_type == GLSL_TYPE_UINT || 1653 op[0]->type->base_type == GLSL_TYPE_INT || 1654 op[0]->type->base_type == GLSL_TYPE_UINT64 || 1655 op[0]->type->base_type == GLSL_TYPE_INT64); 1656 assert(op[1]->type->base_type == GLSL_TYPE_UINT || 1657 op[1]->type->base_type == GLSL_TYPE_INT || 1658 op[1]->type->base_type == GLSL_TYPE_UINT64 || 1659 op[1]->type->base_type == GLSL_TYPE_INT64); 1660 for (unsigned c = 0, c0 = 0, c1 = 0; 1661 c < components; 1662 c0 += c0_inc, c1 += c1_inc, c++) { 1663 1664 switch (op[0]->type->base_type) { 1665 case GLSL_TYPE_UINT: 1666 data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1]; 1667 break; 1668 case GLSL_TYPE_INT: 1669 data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1]; 1670 break; 1671 case GLSL_TYPE_UINT64: 1672 data.u64[c] = op[0]->value.u64[c0] << op[1]->value.u64[c1]; 1673 break; 1674 case GLSL_TYPE_INT64: 1675 data.i64[c] = op[0]->value.i64[c0] << op[1]->value.i64[c1]; 1676 break; 1677 default: 1678 unreachable("invalid type"); 1679 } 1680 } 1681 break; 1682 1683 case ir_binop_rshift: 1684 assert(op[0]->type->base_type == GLSL_TYPE_UINT || 1685 op[0]->type->base_type == GLSL_TYPE_INT || 1686 op[0]->type->base_type == GLSL_TYPE_UINT64 || 1687 op[0]->type->base_type == GLSL_TYPE_INT64); 1688 assert(op[1]->type->base_type == GLSL_TYPE_UINT || 1689 op[1]->type->base_type == GLSL_TYPE_INT || 1690 op[1]->type->base_type == GLSL_TYPE_UINT64 || 1691 op[1]->type->base_type == GLSL_TYPE_INT64); 1692 for (unsigned c = 0, c0 = 0, c1 = 0; 1693 c < components; 1694 c0 += c0_inc, c1 += c1_inc, c++) { 1695 1696 switch (op[0]->type->base_type) { 1697 case GLSL_TYPE_UINT: 1698 data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1]; 1699 break; 1700 case GLSL_TYPE_INT: 1701 data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1]; 1702 break; 1703 case GLSL_TYPE_UINT64: 1704 data.u64[c] = op[0]->value.u64[c0] >> op[1]->value.u64[c1]; 1705 break; 1706 case GLSL_TYPE_INT64: 1707 data.i64[c] = op[0]->value.i64[c0] >> op[1]->value.i64[c1]; 1708 break; 1709 default: 1710 unreachable("invalid type"); 1711 } 1712 } 1713 break; 1714 1715 case ir_binop_bit_and: 1716 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1717 for (unsigned c = 0, c0 = 0, c1 = 0; 1718 c < components; 1719 c0 += c0_inc, c1 += c1_inc, c++) { 1720 1721 switch (op[0]->type->base_type) { 1722 case GLSL_TYPE_UINT: 1723 data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1]; 1724 break; 1725 case GLSL_TYPE_INT: 1726 data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1]; 1727 break; 1728 case GLSL_TYPE_UINT64: 1729 data.u64[c] = op[0]->value.u64[c0] & op[1]->value.u64[c1]; 1730 break; 1731 case GLSL_TYPE_INT64: 1732 data.i64[c] = op[0]->value.i64[c0] & op[1]->value.i64[c1]; 1733 break; 1734 default: 1735 unreachable("invalid type"); 1736 } 1737 } 1738 break; 1739 1740 case ir_binop_bit_xor: 1741 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1742 for (unsigned c = 0, c0 = 0, c1 = 0; 1743 c < components; 1744 c0 += c0_inc, c1 += c1_inc, c++) { 1745 1746 switch (op[0]->type->base_type) { 1747 case GLSL_TYPE_UINT: 1748 data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1]; 1749 break; 1750 case GLSL_TYPE_INT: 1751 data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1]; 1752 break; 1753 case GLSL_TYPE_UINT64: 1754 data.u64[c] = op[0]->value.u64[c0] ^ op[1]->value.u64[c1]; 1755 break; 1756 case GLSL_TYPE_INT64: 1757 data.i64[c] = op[0]->value.i64[c0] ^ op[1]->value.i64[c1]; 1758 break; 1759 default: 1760 unreachable("invalid type"); 1761 } 1762 } 1763 break; 1764 1765 case ir_binop_bit_or: 1766 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1767 for (unsigned c = 0, c0 = 0, c1 = 0; 1768 c < components; 1769 c0 += c0_inc, c1 += c1_inc, c++) { 1770 1771 switch (op[0]->type->base_type) { 1772 case GLSL_TYPE_UINT: 1773 data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1]; 1774 break; 1775 case GLSL_TYPE_INT: 1776 data.i[c] = op[0]->value.i[c0] | op[1]->value.i[c1]; 1777 break; 1778 case GLSL_TYPE_UINT64: 1779 data.u64[c] = op[0]->value.u64[c0] | op[1]->value.u64[c1]; 1780 break; 1781 case GLSL_TYPE_INT64: 1782 data.i64[c] = op[0]->value.i64[c0] | op[1]->value.i64[c1]; 1783 break; 1784 default: 1785 unreachable("invalid type"); 1786 } 1787 } 1788 break; 1789 1790 case ir_binop_logic_and: 1791 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1792 switch (op[0]->type->base_type) { 1793 case GLSL_TYPE_BOOL: 1794 data.b[c] = op[0]->value.b[c] && op[1]->value.b[c]; 1795 break; 1796 default: 1797 unreachable("invalid type"); 1798 } 1799 } 1800 break; 1801 1802 case ir_binop_logic_xor: 1803 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1804 switch (op[0]->type->base_type) { 1805 case GLSL_TYPE_BOOL: 1806 data.b[c] = op[0]->value.b[c] != op[1]->value.b[c]; 1807 break; 1808 default: 1809 unreachable("invalid type"); 1810 } 1811 } 1812 break; 1813 1814 case ir_binop_logic_or: 1815 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1816 switch (op[0]->type->base_type) { 1817 case GLSL_TYPE_BOOL: 1818 data.b[c] = op[0]->value.b[c] || op[1]->value.b[c]; 1819 break; 1820 default: 1821 unreachable("invalid type"); 1822 } 1823 } 1824 break; 1825 1826 case ir_binop_dot: 1827 switch (op[0]->type->base_type) { 1828 case GLSL_TYPE_FLOAT: 1829 data.f[0] = dot_f(op[0], op[1]); 1830 break; 1831 case GLSL_TYPE_DOUBLE: 1832 data.d[0] = dot_d(op[0], op[1]); 1833 break; 1834 default: 1835 unreachable("invalid type"); 1836 } 1837 break; 1838 1839 case ir_binop_min: 1840 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1841 for (unsigned c = 0, c0 = 0, c1 = 0; 1842 c < components; 1843 c0 += c0_inc, c1 += c1_inc, c++) { 1844 1845 switch (op[0]->type->base_type) { 1846 case GLSL_TYPE_UINT: 1847 data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]); 1848 break; 1849 case GLSL_TYPE_INT: 1850 data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]); 1851 break; 1852 case GLSL_TYPE_FLOAT: 1853 data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]); 1854 break; 1855 case GLSL_TYPE_DOUBLE: 1856 data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]); 1857 break; 1858 case GLSL_TYPE_UINT64: 1859 data.u64[c] = MIN2(op[0]->value.u64[c0], op[1]->value.u64[c1]); 1860 break; 1861 case GLSL_TYPE_INT64: 1862 data.i64[c] = MIN2(op[0]->value.i64[c0], op[1]->value.i64[c1]); 1863 break; 1864 default: 1865 unreachable("invalid type"); 1866 } 1867 } 1868 break; 1869 1870 case ir_binop_max: 1871 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1872 for (unsigned c = 0, c0 = 0, c1 = 0; 1873 c < components; 1874 c0 += c0_inc, c1 += c1_inc, c++) { 1875 1876 switch (op[0]->type->base_type) { 1877 case GLSL_TYPE_UINT: 1878 data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]); 1879 break; 1880 case GLSL_TYPE_INT: 1881 data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]); 1882 break; 1883 case GLSL_TYPE_FLOAT: 1884 data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]); 1885 break; 1886 case GLSL_TYPE_DOUBLE: 1887 data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]); 1888 break; 1889 case GLSL_TYPE_UINT64: 1890 data.u64[c] = MAX2(op[0]->value.u64[c0], op[1]->value.u64[c1]); 1891 break; 1892 case GLSL_TYPE_INT64: 1893 data.i64[c] = MAX2(op[0]->value.i64[c0], op[1]->value.i64[c1]); 1894 break; 1895 default: 1896 unreachable("invalid type"); 1897 } 1898 } 1899 break; 1900 1901 case ir_binop_pow: 1902 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1903 switch (op[0]->type->base_type) { 1904 case GLSL_TYPE_FLOAT: 1905 data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]); 1906 break; 1907 default: 1908 unreachable("invalid type"); 1909 } 1910 } 1911 break; 1912 1913 case ir_binop_ldexp: 1914 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1915 switch (op[0]->type->base_type) { 1916 case GLSL_TYPE_FLOAT: 1917 data.f[c] = ldexpf_flush_subnormal(op[0]->value.f[c], op[1]->value.i[c]); 1918 break; 1919 case GLSL_TYPE_DOUBLE: 1920 data.d[c] = ldexp_flush_subnormal(op[0]->value.d[c], op[1]->value.i[c]); 1921 break; 1922 default: 1923 unreachable("invalid type"); 1924 } 1925 } 1926 break; 1927 1928 case ir_binop_vector_extract: { 1929 const int c = CLAMP(op[1]->value.i[0], 0, 1930 (int) op[0]->type->vector_elements - 1); 1931 1932 switch (op[0]->type->base_type) { 1933 case GLSL_TYPE_UINT: 1934 data.u[0] = op[0]->value.u[c]; 1935 break; 1936 case GLSL_TYPE_INT: 1937 data.i[0] = op[0]->value.i[c]; 1938 break; 1939 case GLSL_TYPE_FLOAT: 1940 data.f[0] = op[0]->value.f[c]; 1941 break; 1942 case GLSL_TYPE_DOUBLE: 1943 data.d[0] = op[0]->value.d[c]; 1944 break; 1945 case GLSL_TYPE_UINT64: 1946 data.u64[0] = op[0]->value.u64[c]; 1947 break; 1948 case GLSL_TYPE_INT64: 1949 data.i64[0] = op[0]->value.i64[c]; 1950 break; 1951 case GLSL_TYPE_BOOL: 1952 data.b[0] = op[0]->value.b[c]; 1953 break; 1954 default: 1955 unreachable("invalid type"); 1956 } 1957 break; 1958 } 1959 1960 case ir_binop_atan2: 1961 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1962 switch (op[0]->type->base_type) { 1963 case GLSL_TYPE_FLOAT: 1964 data.f[c] = atan2(op[0]->value.f[c], op[1]->value.f[c]); 1965 break; 1966 default: 1967 unreachable("invalid type"); 1968 } 1969 } 1970 break; 1971 1972 case ir_triop_fma: 1973 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1974 switch (op[0]->type->base_type) { 1975 case GLSL_TYPE_FLOAT: 1976 data.f[c] = op[0]->value.f[c] * op[1]->value.f[c] + op[2]->value.f[c]; 1977 break; 1978 case GLSL_TYPE_DOUBLE: 1979 data.d[c] = op[0]->value.d[c] * op[1]->value.d[c] + op[2]->value.d[c]; 1980 break; 1981 default: 1982 unreachable("invalid type"); 1983 } 1984 } 1985 break; 1986 1987 case ir_triop_lrp: { 1988 assert(op[0]->type->is_float() || op[0]->type->is_double()); 1989 assert(op[1]->type->is_float() || op[1]->type->is_double()); 1990 assert(op[2]->type->is_float() || op[2]->type->is_double()); 1991 1992 unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1; 1993 for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) { 1994 switch (return_type->base_type) { 1995 case GLSL_TYPE_FLOAT: 1996 data.f[c] = op[0]->value.f[c] * (1.0f - op[2]->value.f[c2]) + (op[1]->value.f[c] * op[2]->value.f[c2]); 1997 break; 1998 case GLSL_TYPE_DOUBLE: 1999 data.d[c] = op[0]->value.d[c] * (1.0 - op[2]->value.d[c2]) + (op[1]->value.d[c] * op[2]->value.d[c2]); 2000 break; 2001 default: 2002 unreachable("invalid type"); 2003 } 2004 } 2005 break; 2006 } 2007 2008 case ir_triop_csel: 2009 for (unsigned c = 0; c < components; c++) { 2010 switch (return_type->base_type) { 2011 case GLSL_TYPE_UINT: 2012 data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c] : op[2]->value.u[c]; 2013 break; 2014 case GLSL_TYPE_INT: 2015 data.i[c] = op[0]->value.b[c] ? op[1]->value.i[c] : op[2]->value.i[c]; 2016 break; 2017 case GLSL_TYPE_FLOAT: 2018 data.f[c] = op[0]->value.b[c] ? op[1]->value.f[c] : op[2]->value.f[c]; 2019 break; 2020 case GLSL_TYPE_DOUBLE: 2021 data.d[c] = op[0]->value.b[c] ? op[1]->value.d[c] : op[2]->value.d[c]; 2022 break; 2023 case GLSL_TYPE_UINT64: 2024 data.u64[c] = op[0]->value.b[c] ? op[1]->value.u64[c] : op[2]->value.u64[c]; 2025 break; 2026 case GLSL_TYPE_INT64: 2027 data.i64[c] = op[0]->value.b[c] ? op[1]->value.i64[c] : op[2]->value.i64[c]; 2028 break; 2029 case GLSL_TYPE_BOOL: 2030 data.b[c] = op[0]->value.b[c] ? op[1]->value.b[c] : op[2]->value.b[c]; 2031 break; 2032 default: 2033 unreachable("invalid type"); 2034 } 2035 } 2036 break; 2037 2038 case ir_triop_bitfield_extract: 2039 for (unsigned c = 0; c < op[0]->type->components(); c++) { 2040 switch (op[0]->type->base_type) { 2041 case GLSL_TYPE_UINT: 2042 data.i[c] = bitfield_extract_uint(op[0]->value.u[c], op[1]->value.i[c], op[2]->value.i[c]); 2043 break; 2044 case GLSL_TYPE_INT: 2045 data.i[c] = bitfield_extract_int(op[0]->value.i[c], op[1]->value.i[c], op[2]->value.i[c]); 2046 break; 2047 default: 2048 unreachable("invalid type"); 2049 } 2050 } 2051 break; 2052 2053 case ir_triop_vector_insert: { 2054 const unsigned idx = op[2]->value.u[0]; 2055 2056 memcpy(&data, &op[0]->value, sizeof(data)); 2057 2058 switch (return_type->base_type) { 2059 case GLSL_TYPE_UINT: 2060 data.u[idx] = op[1]->value.u[0]; 2061 break; 2062 case GLSL_TYPE_INT: 2063 data.i[idx] = op[1]->value.i[0]; 2064 break; 2065 case GLSL_TYPE_FLOAT: 2066 data.f[idx] = op[1]->value.f[0]; 2067 break; 2068 case GLSL_TYPE_DOUBLE: 2069 data.d[idx] = op[1]->value.d[0]; 2070 break; 2071 case GLSL_TYPE_UINT64: 2072 data.u64[idx] = op[1]->value.u64[0]; 2073 break; 2074 case GLSL_TYPE_INT64: 2075 data.i64[idx] = op[1]->value.i64[0]; 2076 break; 2077 case GLSL_TYPE_BOOL: 2078 data.b[idx] = op[1]->value.b[0]; 2079 break; 2080 default: 2081 unreachable("invalid type"); 2082 } 2083 break; 2084 } 2085 2086 case ir_quadop_bitfield_insert: 2087 for (unsigned c = 0; c < op[0]->type->components(); c++) { 2088 switch (op[0]->type->base_type) { 2089 case GLSL_TYPE_UINT: 2090 data.u[c] = bitfield_insert(op[0]->value.u[c], op[1]->value.u[c], op[2]->value.i[c], op[3]->value.i[c]); 2091 break; 2092 case GLSL_TYPE_INT: 2093 data.i[c] = bitfield_insert(op[0]->value.i[c], op[1]->value.i[c], op[2]->value.i[c], op[3]->value.i[c]); 2094 break; 2095 default: 2096 unreachable("invalid type"); 2097 } 2098 } 2099 break; 2100 2101 case ir_quadop_vector: 2102 for (unsigned c = 0; c < return_type->vector_elements; c++) { 2103 switch (return_type->base_type) { 2104 case GLSL_TYPE_UINT: 2105 data.u[c] = op[c]->value.u[0]; 2106 break; 2107 case GLSL_TYPE_INT: 2108 data.i[c] = op[c]->value.i[0]; 2109 break; 2110 case GLSL_TYPE_FLOAT: 2111 data.f[c] = op[c]->value.f[0]; 2112 break; 2113 case GLSL_TYPE_DOUBLE: 2114 data.d[c] = op[c]->value.d[0]; 2115 break; 2116 case GLSL_TYPE_UINT64: 2117 data.u64[c] = op[c]->value.u64[0]; 2118 break; 2119 case GLSL_TYPE_INT64: 2120 data.i64[c] = op[c]->value.i64[0]; 2121 break; 2122 case GLSL_TYPE_BOOL: 2123 data.b[c] = op[c]->value.b[0]; 2124 break; 2125 default: 2126 unreachable("invalid type"); 2127 } 2128 } 2129 break; 2130 2131 default: 2132 /* FINISHME: Should handle all expression types. */ 2133 return NULL; 2134 } 2135 2136