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_d2i: 393 for (unsigned c = 0; c < op[0]->type->components(); c++) { 394 switch (op[0]->type->base_type) { 395 case GLSL_TYPE_DOUBLE: 396 data.i[c] = op[0]->value.d[c]; 397 break; 398 default: 399 unreachable("invalid type"); 400 } 401 } 402 break; 403 404 case ir_unop_i2d: 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.d[c] = op[0]->value.i[c]; 409 break; 410 default: 411 unreachable("invalid type"); 412 } 413 } 414 break; 415 416 case ir_unop_d2u: 417 for (unsigned c = 0; c < op[0]->type->components(); c++) { 418 switch (op[0]->type->base_type) { 419 case GLSL_TYPE_DOUBLE: 420 data.u[c] = op[0]->value.d[c]; 421 break; 422 default: 423 unreachable("invalid type"); 424 } 425 } 426 break; 427 428 case ir_unop_u2d: 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.d[c] = op[0]->value.u[c]; 433 break; 434 default: 435 unreachable("invalid type"); 436 } 437 } 438 break; 439 440 case ir_unop_d2b: 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.b[c] = op[0]->value.d[c] != 0.0; 445 break; 446 default: 447 unreachable("invalid type"); 448 } 449 } 450 break; 451 452 case ir_unop_f162b: 453 for (unsigned c = 0; c < op[0]->type->components(); c++) { 454 switch (op[0]->type->base_type) { 455 case GLSL_TYPE_FLOAT: 456 data.b[c] = op[0]->value.f[c] != 0.0; 457 break; 458 default: 459 unreachable("invalid type"); 460 } 461 } 462 break; 463 464 case ir_unop_bitcast_i2f: 465 for (unsigned c = 0; c < op[0]->type->components(); c++) { 466 switch (op[0]->type->base_type) { 467 case GLSL_TYPE_INT: 468 data.f[c] = bitcast_u2f(op[0]->value.i[c]); 469 break; 470 default: 471 unreachable("invalid type"); 472 } 473 } 474 break; 475 476 case ir_unop_bitcast_f2i: 477 for (unsigned c = 0; c < op[0]->type->components(); c++) { 478 switch (op[0]->type->base_type) { 479 case GLSL_TYPE_FLOAT: 480 data.i[c] = bitcast_f2u(op[0]->value.f[c]); 481 break; 482 default: 483 unreachable("invalid type"); 484 } 485 } 486 break; 487 488 case ir_unop_bitcast_u2f: 489 for (unsigned c = 0; c < op[0]->type->components(); c++) { 490 switch (op[0]->type->base_type) { 491 case GLSL_TYPE_UINT: 492 data.f[c] = bitcast_u2f(op[0]->value.u[c]); 493 break; 494 default: 495 unreachable("invalid type"); 496 } 497 } 498 break; 499 500 case ir_unop_bitcast_f2u: 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.u[c] = bitcast_f2u(op[0]->value.f[c]); 505 break; 506 default: 507 unreachable("invalid type"); 508 } 509 } 510 break; 511 512 case ir_unop_bitcast_u642d: 513 for (unsigned c = 0; c < op[0]->type->components(); c++) { 514 switch (op[0]->type->base_type) { 515 case GLSL_TYPE_UINT64: 516 data.d[c] = bitcast_u642d(op[0]->value.u64[c]); 517 break; 518 default: 519 unreachable("invalid type"); 520 } 521 } 522 break; 523 524 case ir_unop_bitcast_i642d: 525 for (unsigned c = 0; c < op[0]->type->components(); c++) { 526 switch (op[0]->type->base_type) { 527 case GLSL_TYPE_INT64: 528 data.d[c] = bitcast_i642d(op[0]->value.i64[c]); 529 break; 530 default: 531 unreachable("invalid type"); 532 } 533 } 534 break; 535 536 case ir_unop_bitcast_d2u64: 537 for (unsigned c = 0; c < op[0]->type->components(); c++) { 538 switch (op[0]->type->base_type) { 539 case GLSL_TYPE_DOUBLE: 540 data.u64[c] = bitcast_d2u64(op[0]->value.d[c]); 541 break; 542 default: 543 unreachable("invalid type"); 544 } 545 } 546 break; 547 548 case ir_unop_bitcast_d2i64: 549 for (unsigned c = 0; c < op[0]->type->components(); c++) { 550 switch (op[0]->type->base_type) { 551 case GLSL_TYPE_DOUBLE: 552 data.i64[c] = bitcast_d2i64(op[0]->value.d[c]); 553 break; 554 default: 555 unreachable("invalid type"); 556 } 557 } 558 break; 559 560 case ir_unop_i642i: 561 for (unsigned c = 0; c < op[0]->type->components(); c++) { 562 switch (op[0]->type->base_type) { 563 case GLSL_TYPE_INT64: 564 data.i[c] = op[0]->value.i64[c]; 565 break; 566 default: 567 unreachable("invalid type"); 568 } 569 } 570 break; 571 572 case ir_unop_u642i: 573 for (unsigned c = 0; c < op[0]->type->components(); c++) { 574 switch (op[0]->type->base_type) { 575 case GLSL_TYPE_UINT64: 576 data.i[c] = op[0]->value.u64[c]; 577 break; 578 default: 579 unreachable("invalid type"); 580 } 581 } 582 break; 583 584 case ir_unop_i642u: 585 for (unsigned c = 0; c < op[0]->type->components(); c++) { 586 switch (op[0]->type->base_type) { 587 case GLSL_TYPE_INT64: 588 data.u[c] = op[0]->value.i64[c]; 589 break; 590 default: 591 unreachable("invalid type"); 592 } 593 } 594 break; 595 596 case ir_unop_u642u: 597 for (unsigned c = 0; c < op[0]->type->components(); c++) { 598 switch (op[0]->type->base_type) { 599 case GLSL_TYPE_UINT64: 600 data.u[c] = op[0]->value.u64[c]; 601 break; 602 default: 603 unreachable("invalid type"); 604 } 605 } 606 break; 607 608 case ir_unop_i642b: 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.b[c] = op[0]->value.i64[c] != 0; 613 break; 614 default: 615 unreachable("invalid type"); 616 } 617 } 618 break; 619 620 case ir_unop_i642f: 621 for (unsigned c = 0; c < op[0]->type->components(); c++) { 622 switch (op[0]->type->base_type) { 623 case GLSL_TYPE_INT64: 624 data.f[c] = op[0]->value.i64[c]; 625 break; 626 default: 627 unreachable("invalid type"); 628 } 629 } 630 break; 631 632 case ir_unop_u642f: 633 for (unsigned c = 0; c < op[0]->type->components(); c++) { 634 switch (op[0]->type->base_type) { 635 case GLSL_TYPE_UINT64: 636 data.f[c] = op[0]->value.u64[c]; 637 break; 638 default: 639 unreachable("invalid type"); 640 } 641 } 642 break; 643 644 case ir_unop_i642d: 645 for (unsigned c = 0; c < op[0]->type->components(); c++) { 646 switch (op[0]->type->base_type) { 647 case GLSL_TYPE_INT64: 648 data.d[c] = op[0]->value.i64[c]; 649 break; 650 default: 651 unreachable("invalid type"); 652 } 653 } 654 break; 655 656 case ir_unop_u642d: 657 for (unsigned c = 0; c < op[0]->type->components(); c++) { 658 switch (op[0]->type->base_type) { 659 case GLSL_TYPE_UINT64: 660 data.d[c] = op[0]->value.u64[c]; 661 break; 662 default: 663 unreachable("invalid type"); 664 } 665 } 666 break; 667 668 case ir_unop_i2i64: 669 for (unsigned c = 0; c < op[0]->type->components(); c++) { 670 switch (op[0]->type->base_type) { 671 case GLSL_TYPE_INT: 672 data.i64[c] = op[0]->value.i[c]; 673 break; 674 default: 675 unreachable("invalid type"); 676 } 677 } 678 break; 679 680 case ir_unop_u2i64: 681 for (unsigned c = 0; c < op[0]->type->components(); c++) { 682 switch (op[0]->type->base_type) { 683 case GLSL_TYPE_UINT: 684 data.i64[c] = op[0]->value.u[c]; 685 break; 686 default: 687 unreachable("invalid type"); 688 } 689 } 690 break; 691 692 case ir_unop_b2i64: 693 for (unsigned c = 0; c < op[0]->type->components(); c++) { 694 switch (op[0]->type->base_type) { 695 case GLSL_TYPE_BOOL: 696 data.i64[c] = op[0]->value.b[c]; 697 break; 698 default: 699 unreachable("invalid type"); 700 } 701 } 702 break; 703 704 case ir_unop_f2i64: 705 for (unsigned c = 0; c < op[0]->type->components(); c++) { 706 switch (op[0]->type->base_type) { 707 case GLSL_TYPE_FLOAT: 708 data.i64[c] = op[0]->value.f[c]; 709 break; 710 default: 711 unreachable("invalid type"); 712 } 713 } 714 break; 715 716 case ir_unop_d2i64: 717 for (unsigned c = 0; c < op[0]->type->components(); c++) { 718 switch (op[0]->type->base_type) { 719 case GLSL_TYPE_DOUBLE: 720 data.i64[c] = op[0]->value.d[c]; 721 break; 722 default: 723 unreachable("invalid type"); 724 } 725 } 726 break; 727 728 case ir_unop_i2u64: 729 for (unsigned c = 0; c < op[0]->type->components(); c++) { 730 switch (op[0]->type->base_type) { 731 case GLSL_TYPE_INT: 732 data.u64[c] = op[0]->value.i[c]; 733 break; 734 default: 735 unreachable("invalid type"); 736 } 737 } 738 break; 739 740 case ir_unop_u2u64: 741 for (unsigned c = 0; c < op[0]->type->components(); c++) { 742 switch (op[0]->type->base_type) { 743 case GLSL_TYPE_UINT: 744 data.u64[c] = op[0]->value.u[c]; 745 break; 746 default: 747 unreachable("invalid type"); 748 } 749 } 750 break; 751 752 case ir_unop_f2u64: 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.u64[c] = op[0]->value.f[c]; 757 break; 758 default: 759 unreachable("invalid type"); 760 } 761 } 762 break; 763 764 case ir_unop_d2u64: 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.u64[c] = op[0]->value.d[c]; 769 break; 770 default: 771 unreachable("invalid type"); 772 } 773 } 774 break; 775 776 case ir_unop_u642i64: 777 for (unsigned c = 0; c < op[0]->type->components(); c++) { 778 switch (op[0]->type->base_type) { 779 case GLSL_TYPE_UINT64: 780 data.i64[c] = op[0]->value.u64[c]; 781 break; 782 default: 783 unreachable("invalid type"); 784 } 785 } 786 break; 787 788 case ir_unop_i642u64: 789 for (unsigned c = 0; c < op[0]->type->components(); c++) { 790 switch (op[0]->type->base_type) { 791 case GLSL_TYPE_INT64: 792 data.u64[c] = op[0]->value.i64[c]; 793 break; 794 default: 795 unreachable("invalid type"); 796 } 797 } 798 break; 799 800 case ir_unop_trunc: 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.f[c] = truncf(op[0]->value.f[c]); 805 break; 806 case GLSL_TYPE_DOUBLE: 807 data.d[c] = trunc(op[0]->value.d[c]); 808 break; 809 default: 810 unreachable("invalid type"); 811 } 812 } 813 break; 814 815 case ir_unop_ceil: 816 for (unsigned c = 0; c < op[0]->type->components(); c++) { 817 switch (op[0]->type->base_type) { 818 case GLSL_TYPE_FLOAT: 819 data.f[c] = ceilf(op[0]->value.f[c]); 820 break; 821 case GLSL_TYPE_DOUBLE: 822 data.d[c] = ceil(op[0]->value.d[c]); 823 break; 824 default: 825 unreachable("invalid type"); 826 } 827 } 828 break; 829 830 case ir_unop_floor: 831 for (unsigned c = 0; c < op[0]->type->components(); c++) { 832 switch (op[0]->type->base_type) { 833 case GLSL_TYPE_FLOAT: 834 data.f[c] = floorf(op[0]->value.f[c]); 835 break; 836 case GLSL_TYPE_DOUBLE: 837 data.d[c] = floor(op[0]->value.d[c]); 838 break; 839 default: 840 unreachable("invalid type"); 841 } 842 } 843 break; 844 845 case ir_unop_fract: 846 for (unsigned c = 0; c < op[0]->type->components(); c++) { 847 switch (op[0]->type->base_type) { 848 case GLSL_TYPE_FLOAT: 849 data.f[c] = op[0]->value.f[c] - floorf(op[0]->value.f[c]); 850 break; 851 case GLSL_TYPE_DOUBLE: 852 data.d[c] = op[0]->value.d[c] - floor(op[0]->value.d[c]); 853 break; 854 default: 855 unreachable("invalid type"); 856 } 857 } 858 break; 859 860 case ir_unop_round_even: 861 for (unsigned c = 0; c < op[0]->type->components(); c++) { 862 switch (op[0]->type->base_type) { 863 case GLSL_TYPE_FLOAT: 864 data.f[c] = _mesa_roundevenf(op[0]->value.f[c]); 865 break; 866 case GLSL_TYPE_DOUBLE: 867 data.d[c] = _mesa_roundeven(op[0]->value.d[c]); 868 break; 869 default: 870 unreachable("invalid type"); 871 } 872 } 873 break; 874 875 case ir_unop_sin: 876 for (unsigned c = 0; c < op[0]->type->components(); c++) { 877 switch (op[0]->type->base_type) { 878 case GLSL_TYPE_FLOAT: 879 data.f[c] = sinf(op[0]->value.f[c]); 880 break; 881 default: 882 unreachable("invalid type"); 883 } 884 } 885 break; 886 887 case ir_unop_cos: 888 for (unsigned c = 0; c < op[0]->type->components(); c++) { 889 switch (op[0]->type->base_type) { 890 case GLSL_TYPE_FLOAT: 891 data.f[c] = cosf(op[0]->value.f[c]); 892 break; 893 default: 894 unreachable("invalid type"); 895 } 896 } 897 break; 898 899 case ir_unop_atan: 900 for (unsigned c = 0; c < op[0]->type->components(); c++) { 901 switch (op[0]->type->base_type) { 902 case GLSL_TYPE_FLOAT: 903 data.f[c] = atan(op[0]->value.f[c]); 904 break; 905 default: 906 unreachable("invalid type"); 907 } 908 } 909 break; 910 911 case ir_unop_dFdx: 912 for (unsigned c = 0; c < op[0]->type->components(); c++) { 913 switch (op[0]->type->base_type) { 914 case GLSL_TYPE_FLOAT: 915 data.f[c] = 0.0f; 916 break; 917 default: 918 unreachable("invalid type"); 919 } 920 } 921 break; 922 923 case ir_unop_dFdx_coarse: 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] = 0.0f; 928 break; 929 default: 930 unreachable("invalid type"); 931 } 932 } 933 break; 934 935 case ir_unop_dFdx_fine: 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] = 0.0f; 940 break; 941 default: 942 unreachable("invalid type"); 943 } 944 } 945 break; 946 947 case ir_unop_dFdy: 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] = 0.0f; 952 break; 953 default: 954 unreachable("invalid type"); 955 } 956 } 957 break; 958 959 case ir_unop_dFdy_coarse: 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_dFdy_fine: 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_pack_snorm_2x16: 984 switch (op[0]->type->base_type) { 985 case GLSL_TYPE_FLOAT: 986 data.u[0] = pack_2x16(pack_snorm_1x16, op[0]->value.f[0], op[0]->value.f[1]); 987 break; 988 default: 989 unreachable("invalid type"); 990 } 991 break; 992 993 case ir_unop_pack_snorm_4x8: 994 switch (op[0]->type->base_type) { 995 case GLSL_TYPE_FLOAT: 996 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]); 997 break; 998 default: 999 unreachable("invalid type"); 1000 } 1001 break; 1002 1003 case ir_unop_pack_unorm_2x16: 1004 switch (op[0]->type->base_type) { 1005 case GLSL_TYPE_FLOAT: 1006 data.u[0] = pack_2x16(pack_unorm_1x16, op[0]->value.f[0], op[0]->value.f[1]); 1007 break; 1008 default: 1009 unreachable("invalid type"); 1010 } 1011 break; 1012 1013 case ir_unop_pack_unorm_4x8: 1014 switch (op[0]->type->base_type) { 1015 case GLSL_TYPE_FLOAT: 1016 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]); 1017 break; 1018 default: 1019 unreachable("invalid type"); 1020 } 1021 break; 1022 1023 case ir_unop_pack_half_2x16: 1024 switch (op[0]->type->base_type) { 1025 case GLSL_TYPE_FLOAT: 1026 data.u[0] = pack_2x16(pack_half_1x16, op[0]->value.f[0], op[0]->value.f[1]); 1027 break; 1028 default: 1029 unreachable("invalid type"); 1030 } 1031 break; 1032 1033 case ir_unop_unpack_snorm_2x16: 1034 unpack_2x16(unpack_snorm_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]); 1035 break; 1036 1037 case ir_unop_unpack_snorm_4x8: 1038 unpack_4x8(unpack_snorm_1x8, op[0]->value.u[0], &data.f[0], &data.f[1], &data.f[2], &data.f[3]); 1039 break; 1040 1041 case ir_unop_unpack_unorm_2x16: 1042 unpack_2x16(unpack_unorm_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]); 1043 break; 1044 1045 case ir_unop_unpack_unorm_4x8: 1046 unpack_4x8(unpack_unorm_1x8, op[0]->value.u[0], &data.f[0], &data.f[1], &data.f[2], &data.f[3]); 1047 break; 1048 1049 case ir_unop_unpack_half_2x16: 1050 unpack_2x16(unpack_half_1x16, op[0]->value.u[0], &data.f[0], &data.f[1]); 1051 break; 1052 1053 case ir_unop_bitfield_reverse: 1054 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1055 switch (op[0]->type->base_type) { 1056 case GLSL_TYPE_UINT: 1057 data.u[c] = bitfield_reverse(op[0]->value.u[c]); 1058 break; 1059 case GLSL_TYPE_INT: 1060 data.i[c] = bitfield_reverse(op[0]->value.i[c]); 1061 break; 1062 default: 1063 unreachable("invalid type"); 1064 } 1065 } 1066 break; 1067 1068 case ir_unop_bit_count: 1069 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1070 switch (op[0]->type->base_type) { 1071 case GLSL_TYPE_UINT: 1072 data.i[c] = util_bitcount(op[0]->value.u[c]); 1073 break; 1074 case GLSL_TYPE_INT: 1075 data.i[c] = util_bitcount(op[0]->value.i[c]); 1076 break; 1077 default: 1078 unreachable("invalid type"); 1079 } 1080 } 1081 break; 1082 1083 case ir_unop_find_msb: 1084 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1085 switch (op[0]->type->base_type) { 1086 case GLSL_TYPE_UINT: 1087 data.i[c] = find_msb_uint(op[0]->value.u[c]); 1088 break; 1089 case GLSL_TYPE_INT: 1090 data.i[c] = find_msb_int(op[0]->value.i[c]); 1091 break; 1092 default: 1093 unreachable("invalid type"); 1094 } 1095 } 1096 break; 1097 1098 case ir_unop_find_lsb: 1099 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1100 switch (op[0]->type->base_type) { 1101 case GLSL_TYPE_UINT: 1102 data.i[c] = find_msb_uint(op[0]->value.u[c] & -op[0]->value.u[c]); 1103 break; 1104 case GLSL_TYPE_INT: 1105 data.i[c] = find_msb_uint(op[0]->value.i[c] & -op[0]->value.i[c]); 1106 break; 1107 default: 1108 unreachable("invalid type"); 1109 } 1110 } 1111 break; 1112 1113 case ir_unop_clz: 1114 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1115 switch (op[0]->type->base_type) { 1116 case GLSL_TYPE_UINT: 1117 data.u[c] = (unsigned)(31 - find_msb_uint(op[0]->value.u[c])); 1118 break; 1119 default: 1120 unreachable("invalid type"); 1121 } 1122 } 1123 break; 1124 1125 case ir_unop_saturate: 1126 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1127 switch (op[0]->type->base_type) { 1128 case GLSL_TYPE_FLOAT: 1129 data.f[c] = CLAMP(op[0]->value.f[c], 0.0f, 1.0f); 1130 break; 1131 default: 1132 unreachable("invalid type"); 1133 } 1134 } 1135 break; 1136 1137 case ir_unop_pack_double_2x32: 1138 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1139 break; 1140 1141 case ir_unop_unpack_double_2x32: 1142 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1143 break; 1144 1145 case ir_unop_pack_sampler_2x32: 1146 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1147 break; 1148 1149 case ir_unop_pack_image_2x32: 1150 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1151 break; 1152 1153 case ir_unop_unpack_sampler_2x32: 1154 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1155 break; 1156 1157 case ir_unop_unpack_image_2x32: 1158 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1159 break; 1160 1161 case ir_unop_pack_int_2x32: 1162 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1163 break; 1164 1165 case ir_unop_pack_uint_2x32: 1166 data.u64[0] = pack_2x32(op[0]->value.u[0], op[0]->value.u[1]); 1167 break; 1168 1169 case ir_unop_unpack_int_2x32: 1170 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1171 break; 1172 1173 case ir_unop_unpack_uint_2x32: 1174 unpack_2x32(op[0]->value.u64[0], &data.u[0], &data.u[1]); 1175 break; 1176 1177 case ir_binop_add: 1178 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1179 for (unsigned c = 0, c0 = 0, c1 = 0; 1180 c < components; 1181 c0 += c0_inc, c1 += c1_inc, c++) { 1182 1183 switch (op[0]->type->base_type) { 1184 case GLSL_TYPE_UINT: 1185 data.u[c] = op[0]->value.u[c0] + op[1]->value.u[c1]; 1186 break; 1187 case GLSL_TYPE_INT: 1188 data.i[c] = op[0]->value.i[c0] + op[1]->value.i[c1]; 1189 break; 1190 case GLSL_TYPE_FLOAT: 1191 data.f[c] = op[0]->value.f[c0] + op[1]->value.f[c1]; 1192 break; 1193 case GLSL_TYPE_DOUBLE: 1194 data.d[c] = op[0]->value.d[c0] + op[1]->value.d[c1]; 1195 break; 1196 case GLSL_TYPE_UINT64: 1197 data.u64[c] = op[0]->value.u64[c0] + op[1]->value.u64[c1]; 1198 break; 1199 case GLSL_TYPE_INT64: 1200 data.i64[c] = op[0]->value.i64[c0] + op[1]->value.i64[c1]; 1201 break; 1202 default: 1203 unreachable("invalid type"); 1204 } 1205 } 1206 break; 1207 1208 case ir_binop_sub: 1209 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1210 for (unsigned c = 0, c0 = 0, c1 = 0; 1211 c < components; 1212 c0 += c0_inc, c1 += c1_inc, c++) { 1213 1214 switch (op[0]->type->base_type) { 1215 case GLSL_TYPE_UINT: 1216 data.u[c] = op[0]->value.u[c0] - op[1]->value.u[c1]; 1217 break; 1218 case GLSL_TYPE_INT: 1219 data.i[c] = op[0]->value.i[c0] - op[1]->value.i[c1]; 1220 break; 1221 case GLSL_TYPE_FLOAT: 1222 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1]; 1223 break; 1224 case GLSL_TYPE_DOUBLE: 1225 data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1]; 1226 break; 1227 case GLSL_TYPE_UINT64: 1228 data.u64[c] = op[0]->value.u64[c0] - op[1]->value.u64[c1]; 1229 break; 1230 case GLSL_TYPE_INT64: 1231 data.i64[c] = op[0]->value.i64[c0] - op[1]->value.i64[c1]; 1232 break; 1233 default: 1234 unreachable("invalid type"); 1235 } 1236 } 1237 break; 1238 1239 case ir_binop_add_sat: 1240 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1241 switch (op[0]->type->base_type) { 1242 case GLSL_TYPE_UINT: 1243 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]); 1244 break; 1245 case GLSL_TYPE_INT: 1246 data.i[c] = iadd_saturate(op[0]->value.i[c], op[1]->value.i[c]); 1247 break; 1248 case GLSL_TYPE_UINT64: 1249 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]); 1250 break; 1251 case GLSL_TYPE_INT64: 1252 data.i64[c] = iadd64_saturate(op[0]->value.i64[c], op[1]->value.i64[c]); 1253 break; 1254 default: 1255 unreachable("invalid type"); 1256 } 1257 } 1258 break; 1259 1260 case ir_binop_sub_sat: 1261 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1262 switch (op[0]->type->base_type) { 1263 case GLSL_TYPE_UINT: 1264 data.u[c] = (op[1]->value.u[c] > op[0]->value.u[c]) ? 0 : op[0]->value.u[c] - op[1]->value.u[c]; 1265 break; 1266 case GLSL_TYPE_INT: 1267 data.i[c] = isub_saturate(op[0]->value.i[c], op[1]->value.i[c]); 1268 break; 1269 case GLSL_TYPE_UINT64: 1270 data.u64[c] = (op[1]->value.u64[c] > op[0]->value.u64[c]) ? 0 : op[0]->value.u64[c] - op[1]->value.u64[c]; 1271 break; 1272 case GLSL_TYPE_INT64: 1273 data.i64[c] = isub64_saturate(op[0]->value.i64[c], op[1]->value.i64[c]); 1274 break; 1275 default: 1276 unreachable("invalid type"); 1277 } 1278 } 1279 break; 1280 1281 case ir_binop_abs_sub: 1282 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1283 switch (op[0]->type->base_type) { 1284 case GLSL_TYPE_UINT: 1285 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]; 1286 break; 1287 case GLSL_TYPE_INT: 1288 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]; 1289 break; 1290 case GLSL_TYPE_UINT64: 1291 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]; 1292 break; 1293 case GLSL_TYPE_INT64: 1294 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]; 1295 break; 1296 default: 1297 unreachable("invalid type"); 1298 } 1299 } 1300 break; 1301 1302 case ir_binop_avg: 1303 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1304 switch (op[0]->type->base_type) { 1305 case GLSL_TYPE_UINT: 1306 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); 1307 break; 1308 case GLSL_TYPE_INT: 1309 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); 1310 break; 1311 case GLSL_TYPE_UINT64: 1312 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); 1313 break; 1314 case GLSL_TYPE_INT64: 1315 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); 1316 break; 1317 default: 1318 unreachable("invalid type"); 1319 } 1320 } 1321 break; 1322 1323 case ir_binop_avg_round: 1324 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1325 switch (op[0]->type->base_type) { 1326 case GLSL_TYPE_UINT: 1327 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); 1328 break; 1329 case GLSL_TYPE_INT: 1330 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); 1331 break; 1332 case GLSL_TYPE_UINT64: 1333 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); 1334 break; 1335 case GLSL_TYPE_INT64: 1336 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); 1337 break; 1338 default: 1339 unreachable("invalid type"); 1340 } 1341 } 1342 break; 1343 1344 case ir_binop_mul: 1345 /* Check for equal types, or unequal types involving scalars */ 1346 if ((op[0]->type == op[1]->type && !op[0]->type->is_matrix()) 1347 || op0_scalar || op1_scalar) { 1348 for (unsigned c = 0, c0 = 0, c1 = 0; 1349 c < components; 1350 c0 += c0_inc, c1 += c1_inc, c++) { 1351 1352 switch (op[0]->type->base_type) { 1353 case GLSL_TYPE_UINT: 1354 data.u[c] = op[0]->value.u[c0] * op[1]->value.u[c1]; 1355 break; 1356 case GLSL_TYPE_INT: 1357 data.i[c] = op[0]->value.i[c0] * op[1]->value.i[c1]; 1358 break; 1359 case GLSL_TYPE_FLOAT: 1360 data.f[c] = op[0]->value.f[c0] * op[1]->value.f[c1]; 1361 break; 1362 case GLSL_TYPE_DOUBLE: 1363 data.d[c] = op[0]->value.d[c0] * op[1]->value.d[c1]; 1364 break; 1365 case GLSL_TYPE_UINT64: 1366 data.u64[c] = op[0]->value.u64[c0] * op[1]->value.u64[c1]; 1367 break; 1368 case GLSL_TYPE_INT64: 1369 data.i64[c] = op[0]->value.i64[c0] * op[1]->value.i64[c1]; 1370 break; 1371 default: 1372 unreachable("invalid type"); 1373 } 1374 } 1375 } else { 1376 assert(op[0]->type->is_matrix() || op[1]->type->is_matrix()); 1377 1378 /* Multiply an N-by-M matrix with an M-by-P matrix. Since either 1379 * matrix can be a GLSL vector, either N or P can be 1. 1380 * 1381 * For vec*mat, the vector is treated as a row vector. This 1382 * means the vector is a 1-row x M-column matrix. 1383 * 1384 * For mat*vec, the vector is treated as a column vector. Since 1385 * matrix_columns is 1 for vectors, this just works. 1386 */ 1387 const unsigned n = op[0]->type->is_vector() 1388 ? 1 : op[0]->type->vector_elements; 1389 const unsigned m = op[1]->type->vector_elements; 1390 const unsigned p = op[1]->type->matrix_columns; 1391 for (unsigned j = 0; j < p; j++) { 1392 for (unsigned i = 0; i < n; i++) { 1393 for (unsigned k = 0; k < m; k++) { 1394 if (op[0]->type->is_double()) 1395 data.d[i+n*j] += op[0]->value.d[i+n*k]*op[1]->value.d[k+m*j]; 1396 else 1397 data.f[i+n*j] += op[0]->value.f[i+n*k]*op[1]->value.f[k+m*j]; 1398 } 1399 } 1400 } 1401 } 1402 break; 1403 1404 case ir_binop_mul_32x16: 1405 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1406 switch (op[0]->type->base_type) { 1407 case GLSL_TYPE_UINT: 1408 data.u[c] = op[0]->value.u[c] * (uint16_t)op[1]->value.u[c]; 1409 break; 1410 case GLSL_TYPE_INT: 1411 data.i[c] = op[0]->value.i[c] * (int16_t)op[0]->value.i[c]; 1412 break; 1413 default: 1414 unreachable("invalid type"); 1415 } 1416 } 1417 break; 1418 1419 case ir_binop_div: 1420 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1421 for (unsigned c = 0, c0 = 0, c1 = 0; 1422 c < components; 1423 c0 += c0_inc, c1 += c1_inc, c++) { 1424 1425 switch (op[0]->type->base_type) { 1426 case GLSL_TYPE_UINT: 1427 data.u[c] = op[1]->value.u[c1] == 0 ? 0 : op[0]->value.u[c0] / op[1]->value.u[c1]; 1428 break; 1429 case GLSL_TYPE_INT: 1430 data.i[c] = op[1]->value.i[c1] == 0 ? 0 : op[0]->value.i[c0] / op[1]->value.i[c1]; 1431 break; 1432 case GLSL_TYPE_FLOAT: 1433 data.f[c] = op[0]->value.f[c0] / op[1]->value.f[c1]; 1434 break; 1435 case GLSL_TYPE_DOUBLE: 1436 data.d[c] = op[0]->value.d[c0] / op[1]->value.d[c1]; 1437 break; 1438 case GLSL_TYPE_UINT64: 1439 data.u64[c] = op[1]->value.u64[c1] == 0 ? 0 : op[0]->value.u64[c0] / op[1]->value.u64[c1]; 1440 break; 1441 case GLSL_TYPE_INT64: 1442 data.i64[c] = op[1]->value.i64[c1] == 0 ? 0 : op[0]->value.i64[c0] / op[1]->value.i64[c1]; 1443 break; 1444 default: 1445 unreachable("invalid type"); 1446 } 1447 } 1448 break; 1449 1450 case ir_binop_mod: 1451 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1452 for (unsigned c = 0, c0 = 0, c1 = 0; 1453 c < components; 1454 c0 += c0_inc, c1 += c1_inc, c++) { 1455 1456 switch (op[0]->type->base_type) { 1457 case GLSL_TYPE_UINT: 1458 data.u[c] = op[1]->value.u[c1] == 0 ? 0 : op[0]->value.u[c0] % op[1]->value.u[c1]; 1459 break; 1460 case GLSL_TYPE_INT: 1461 data.i[c] = op[1]->value.i[c1] == 0 ? 0 : op[0]->value.i[c0] % op[1]->value.i[c1]; 1462 break; 1463 case GLSL_TYPE_FLOAT: 1464 data.f[c] = op[0]->value.f[c0] - op[1]->value.f[c1] * floorf(op[0]->value.f[c0] / op[1]->value.f[c1]); 1465 break; 1466 case GLSL_TYPE_DOUBLE: 1467 data.d[c] = op[0]->value.d[c0] - op[1]->value.d[c1] * floor(op[0]->value.d[c0] / op[1]->value.d[c1]); 1468 break; 1469 case GLSL_TYPE_UINT64: 1470 data.u64[c] = op[1]->value.u64[c1] == 0 ? 0 : op[0]->value.u64[c0] % op[1]->value.u64[c1]; 1471 break; 1472 case GLSL_TYPE_INT64: 1473 data.i64[c] = op[1]->value.i64[c1] == 0 ? 0 : op[0]->value.i64[c0] % op[1]->value.i64[c1]; 1474 break; 1475 default: 1476 unreachable("invalid type"); 1477 } 1478 } 1479 break; 1480 1481 case ir_binop_less: 1482 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1483 switch (op[0]->type->base_type) { 1484 case GLSL_TYPE_UINT: 1485 data.b[c] = op[0]->value.u[c] < op[1]->value.u[c]; 1486 break; 1487 case GLSL_TYPE_INT: 1488 data.b[c] = op[0]->value.i[c] < op[1]->value.i[c]; 1489 break; 1490 case GLSL_TYPE_FLOAT: 1491 data.b[c] = op[0]->value.f[c] < op[1]->value.f[c]; 1492 break; 1493 case GLSL_TYPE_DOUBLE: 1494 data.b[c] = op[0]->value.d[c] < op[1]->value.d[c]; 1495 break; 1496 case GLSL_TYPE_UINT64: 1497 data.b[c] = op[0]->value.u64[c] < op[1]->value.u64[c]; 1498 break; 1499 case GLSL_TYPE_INT64: 1500 data.b[c] = op[0]->value.i64[c] < op[1]->value.i64[c]; 1501 break; 1502 default: 1503 unreachable("invalid type"); 1504 } 1505 } 1506 break; 1507 1508 case ir_binop_gequal: 1509 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1510 switch (op[0]->type->base_type) { 1511 case GLSL_TYPE_UINT: 1512 data.b[c] = op[0]->value.u[c] >= op[1]->value.u[c]; 1513 break; 1514 case GLSL_TYPE_INT: 1515 data.b[c] = op[0]->value.i[c] >= op[1]->value.i[c]; 1516 break; 1517 case GLSL_TYPE_FLOAT: 1518 data.b[c] = op[0]->value.f[c] >= op[1]->value.f[c]; 1519 break; 1520 case GLSL_TYPE_DOUBLE: 1521 data.b[c] = op[0]->value.d[c] >= op[1]->value.d[c]; 1522 break; 1523 case GLSL_TYPE_UINT64: 1524 data.b[c] = op[0]->value.u64[c] >= op[1]->value.u64[c]; 1525 break; 1526 case GLSL_TYPE_INT64: 1527 data.b[c] = op[0]->value.i64[c] >= op[1]->value.i64[c]; 1528 break; 1529 default: 1530 unreachable("invalid type"); 1531 } 1532 } 1533 break; 1534 1535 case ir_binop_equal: 1536 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1537 switch (op[0]->type->base_type) { 1538 case GLSL_TYPE_UINT: 1539 data.b[c] = op[0]->value.u[c] == op[1]->value.u[c]; 1540 break; 1541 case GLSL_TYPE_INT: 1542 data.b[c] = op[0]->value.i[c] == op[1]->value.i[c]; 1543 break; 1544 case GLSL_TYPE_FLOAT: 1545 data.b[c] = op[0]->value.f[c] == op[1]->value.f[c]; 1546 break; 1547 case GLSL_TYPE_DOUBLE: 1548 data.b[c] = op[0]->value.d[c] == op[1]->value.d[c]; 1549 break; 1550 case GLSL_TYPE_UINT64: 1551 data.b[c] = op[0]->value.u64[c] == op[1]->value.u64[c]; 1552 break; 1553 case GLSL_TYPE_INT64: 1554 data.b[c] = op[0]->value.i64[c] == op[1]->value.i64[c]; 1555 break; 1556 case GLSL_TYPE_BOOL: 1557 data.b[c] = op[0]->value.b[c] == op[1]->value.b[c]; 1558 break; 1559 default: 1560 unreachable("invalid type"); 1561 } 1562 } 1563 break; 1564 1565 case ir_binop_nequal: 1566 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1567 switch (op[0]->type->base_type) { 1568 case GLSL_TYPE_UINT: 1569 data.b[c] = op[0]->value.u[c] != op[1]->value.u[c]; 1570 break; 1571 case GLSL_TYPE_INT: 1572 data.b[c] = op[0]->value.i[c] != op[1]->value.i[c]; 1573 break; 1574 case GLSL_TYPE_FLOAT: 1575 data.b[c] = op[0]->value.f[c] != op[1]->value.f[c]; 1576 break; 1577 case GLSL_TYPE_DOUBLE: 1578 data.b[c] = op[0]->value.d[c] != op[1]->value.d[c]; 1579 break; 1580 case GLSL_TYPE_UINT64: 1581 data.b[c] = op[0]->value.u64[c] != op[1]->value.u64[c]; 1582 break; 1583 case GLSL_TYPE_INT64: 1584 data.b[c] = op[0]->value.i64[c] != op[1]->value.i64[c]; 1585 break; 1586 case GLSL_TYPE_BOOL: 1587 data.b[c] = op[0]->value.b[c] != op[1]->value.b[c]; 1588 break; 1589 default: 1590 unreachable("invalid type"); 1591 } 1592 } 1593 break; 1594 1595 case ir_binop_all_equal: 1596 data.b[0] = op[0]->has_value(op[1]); 1597 break; 1598 1599 case ir_binop_any_nequal: 1600 data.b[0] = !op[0]->has_value(op[1]); 1601 break; 1602 1603 case ir_binop_lshift: 1604 assert(op[0]->type->base_type == GLSL_TYPE_UINT || 1605 op[0]->type->base_type == GLSL_TYPE_INT || 1606 op[0]->type->base_type == GLSL_TYPE_UINT64 || 1607 op[0]->type->base_type == GLSL_TYPE_INT64); 1608 assert(op[1]->type->base_type == GLSL_TYPE_UINT || 1609 op[1]->type->base_type == GLSL_TYPE_INT || 1610 op[1]->type->base_type == GLSL_TYPE_UINT64 || 1611 op[1]->type->base_type == GLSL_TYPE_INT64); 1612 for (unsigned c = 0, c0 = 0, c1 = 0; 1613 c < components; 1614 c0 += c0_inc, c1 += c1_inc, c++) { 1615 1616 switch (op[0]->type->base_type) { 1617 case GLSL_TYPE_UINT: 1618 data.u[c] = op[0]->value.u[c0] << op[1]->value.u[c1]; 1619 break; 1620 case GLSL_TYPE_INT: 1621 data.i[c] = op[0]->value.i[c0] << op[1]->value.i[c1]; 1622 break; 1623 case GLSL_TYPE_UINT64: 1624 data.u64[c] = op[0]->value.u64[c0] << op[1]->value.u64[c1]; 1625 break; 1626 case GLSL_TYPE_INT64: 1627 data.i64[c] = op[0]->value.i64[c0] << op[1]->value.i64[c1]; 1628 break; 1629 default: 1630 unreachable("invalid type"); 1631 } 1632 } 1633 break; 1634 1635 case ir_binop_rshift: 1636 assert(op[0]->type->base_type == GLSL_TYPE_UINT || 1637 op[0]->type->base_type == GLSL_TYPE_INT || 1638 op[0]->type->base_type == GLSL_TYPE_UINT64 || 1639 op[0]->type->base_type == GLSL_TYPE_INT64); 1640 assert(op[1]->type->base_type == GLSL_TYPE_UINT || 1641 op[1]->type->base_type == GLSL_TYPE_INT || 1642 op[1]->type->base_type == GLSL_TYPE_UINT64 || 1643 op[1]->type->base_type == GLSL_TYPE_INT64); 1644 for (unsigned c = 0, c0 = 0, c1 = 0; 1645 c < components; 1646 c0 += c0_inc, c1 += c1_inc, c++) { 1647 1648 switch (op[0]->type->base_type) { 1649 case GLSL_TYPE_UINT: 1650 data.u[c] = op[0]->value.u[c0] >> op[1]->value.u[c1]; 1651 break; 1652 case GLSL_TYPE_INT: 1653 data.i[c] = op[0]->value.i[c0] >> op[1]->value.i[c1]; 1654 break; 1655 case GLSL_TYPE_UINT64: 1656 data.u64[c] = op[0]->value.u64[c0] >> op[1]->value.u64[c1]; 1657 break; 1658 case GLSL_TYPE_INT64: 1659 data.i64[c] = op[0]->value.i64[c0] >> op[1]->value.i64[c1]; 1660 break; 1661 default: 1662 unreachable("invalid type"); 1663 } 1664 } 1665 break; 1666 1667 case ir_binop_bit_and: 1668 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1669 for (unsigned c = 0, c0 = 0, c1 = 0; 1670 c < components; 1671 c0 += c0_inc, c1 += c1_inc, c++) { 1672 1673 switch (op[0]->type->base_type) { 1674 case GLSL_TYPE_UINT: 1675 data.u[c] = op[0]->value.u[c0] & op[1]->value.u[c1]; 1676 break; 1677 case GLSL_TYPE_INT: 1678 data.i[c] = op[0]->value.i[c0] & op[1]->value.i[c1]; 1679 break; 1680 case GLSL_TYPE_UINT64: 1681 data.u64[c] = op[0]->value.u64[c0] & op[1]->value.u64[c1]; 1682 break; 1683 case GLSL_TYPE_INT64: 1684 data.i64[c] = op[0]->value.i64[c0] & op[1]->value.i64[c1]; 1685 break; 1686 default: 1687 unreachable("invalid type"); 1688 } 1689 } 1690 break; 1691 1692 case ir_binop_bit_xor: 1693 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1694 for (unsigned c = 0, c0 = 0, c1 = 0; 1695 c < components; 1696 c0 += c0_inc, c1 += c1_inc, c++) { 1697 1698 switch (op[0]->type->base_type) { 1699 case GLSL_TYPE_UINT: 1700 data.u[c] = op[0]->value.u[c0] ^ op[1]->value.u[c1]; 1701 break; 1702 case GLSL_TYPE_INT: 1703 data.i[c] = op[0]->value.i[c0] ^ op[1]->value.i[c1]; 1704 break; 1705 case GLSL_TYPE_UINT64: 1706 data.u64[c] = op[0]->value.u64[c0] ^ op[1]->value.u64[c1]; 1707 break; 1708 case GLSL_TYPE_INT64: 1709 data.i64[c] = op[0]->value.i64[c0] ^ op[1]->value.i64[c1]; 1710 break; 1711 default: 1712 unreachable("invalid type"); 1713 } 1714 } 1715 break; 1716 1717 case ir_binop_bit_or: 1718 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1719 for (unsigned c = 0, c0 = 0, c1 = 0; 1720 c < components; 1721 c0 += c0_inc, c1 += c1_inc, c++) { 1722 1723 switch (op[0]->type->base_type) { 1724 case GLSL_TYPE_UINT: 1725 data.u[c] = op[0]->value.u[c0] | op[1]->value.u[c1]; 1726 break; 1727 case GLSL_TYPE_INT: 1728 data.i[c] = op[0]->value.i[c0] | op[1]->value.i[c1]; 1729 break; 1730 case GLSL_TYPE_UINT64: 1731 data.u64[c] = op[0]->value.u64[c0] | op[1]->value.u64[c1]; 1732 break; 1733 case GLSL_TYPE_INT64: 1734 data.i64[c] = op[0]->value.i64[c0] | op[1]->value.i64[c1]; 1735 break; 1736 default: 1737 unreachable("invalid type"); 1738 } 1739 } 1740 break; 1741 1742 case ir_binop_logic_and: 1743 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1744 switch (op[0]->type->base_type) { 1745 case GLSL_TYPE_BOOL: 1746 data.b[c] = op[0]->value.b[c] && op[1]->value.b[c]; 1747 break; 1748 default: 1749 unreachable("invalid type"); 1750 } 1751 } 1752 break; 1753 1754 case ir_binop_logic_xor: 1755 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1756 switch (op[0]->type->base_type) { 1757 case GLSL_TYPE_BOOL: 1758 data.b[c] = op[0]->value.b[c] != op[1]->value.b[c]; 1759 break; 1760 default: 1761 unreachable("invalid type"); 1762 } 1763 } 1764 break; 1765 1766 case ir_binop_logic_or: 1767 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1768 switch (op[0]->type->base_type) { 1769 case GLSL_TYPE_BOOL: 1770 data.b[c] = op[0]->value.b[c] || op[1]->value.b[c]; 1771 break; 1772 default: 1773 unreachable("invalid type"); 1774 } 1775 } 1776 break; 1777 1778 case ir_binop_dot: 1779 switch (op[0]->type->base_type) { 1780 case GLSL_TYPE_FLOAT: 1781 data.f[0] = dot_f(op[0], op[1]); 1782 break; 1783 case GLSL_TYPE_DOUBLE: 1784 data.d[0] = dot_d(op[0], op[1]); 1785 break; 1786 default: 1787 unreachable("invalid type"); 1788 } 1789 break; 1790 1791 case ir_binop_min: 1792 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1793 for (unsigned c = 0, c0 = 0, c1 = 0; 1794 c < components; 1795 c0 += c0_inc, c1 += c1_inc, c++) { 1796 1797 switch (op[0]->type->base_type) { 1798 case GLSL_TYPE_UINT: 1799 data.u[c] = MIN2(op[0]->value.u[c0], op[1]->value.u[c1]); 1800 break; 1801 case GLSL_TYPE_INT: 1802 data.i[c] = MIN2(op[0]->value.i[c0], op[1]->value.i[c1]); 1803 break; 1804 case GLSL_TYPE_FLOAT: 1805 data.f[c] = MIN2(op[0]->value.f[c0], op[1]->value.f[c1]); 1806 break; 1807 case GLSL_TYPE_DOUBLE: 1808 data.d[c] = MIN2(op[0]->value.d[c0], op[1]->value.d[c1]); 1809 break; 1810 case GLSL_TYPE_UINT64: 1811 data.u64[c] = MIN2(op[0]->value.u64[c0], op[1]->value.u64[c1]); 1812 break; 1813 case GLSL_TYPE_INT64: 1814 data.i64[c] = MIN2(op[0]->value.i64[c0], op[1]->value.i64[c1]); 1815 break; 1816 default: 1817 unreachable("invalid type"); 1818 } 1819 } 1820 break; 1821 1822 case ir_binop_max: 1823 assert(op[0]->type == op[1]->type || op0_scalar || op1_scalar); 1824 for (unsigned c = 0, c0 = 0, c1 = 0; 1825 c < components; 1826 c0 += c0_inc, c1 += c1_inc, c++) { 1827 1828 switch (op[0]->type->base_type) { 1829 case GLSL_TYPE_UINT: 1830 data.u[c] = MAX2(op[0]->value.u[c0], op[1]->value.u[c1]); 1831 break; 1832 case GLSL_TYPE_INT: 1833 data.i[c] = MAX2(op[0]->value.i[c0], op[1]->value.i[c1]); 1834 break; 1835 case GLSL_TYPE_FLOAT: 1836 data.f[c] = MAX2(op[0]->value.f[c0], op[1]->value.f[c1]); 1837 break; 1838 case GLSL_TYPE_DOUBLE: 1839 data.d[c] = MAX2(op[0]->value.d[c0], op[1]->value.d[c1]); 1840 break; 1841 case GLSL_TYPE_UINT64: 1842 data.u64[c] = MAX2(op[0]->value.u64[c0], op[1]->value.u64[c1]); 1843 break; 1844 case GLSL_TYPE_INT64: 1845 data.i64[c] = MAX2(op[0]->value.i64[c0], op[1]->value.i64[c1]); 1846 break; 1847 default: 1848 unreachable("invalid type"); 1849 } 1850 } 1851 break; 1852 1853 case ir_binop_pow: 1854 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1855 switch (op[0]->type->base_type) { 1856 case GLSL_TYPE_FLOAT: 1857 data.f[c] = powf(op[0]->value.f[c], op[1]->value.f[c]); 1858 break; 1859 default: 1860 unreachable("invalid type"); 1861 } 1862 } 1863 break; 1864 1865 case ir_binop_ldexp: 1866 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1867 switch (op[0]->type->base_type) { 1868 case GLSL_TYPE_FLOAT: 1869 data.f[c] = ldexpf_flush_subnormal(op[0]->value.f[c], op[1]->value.i[c]); 1870 break; 1871 case GLSL_TYPE_DOUBLE: 1872 data.d[c] = ldexp_flush_subnormal(op[0]->value.d[c], op[1]->value.i[c]); 1873 break; 1874 default: 1875 unreachable("invalid type"); 1876 } 1877 } 1878 break; 1879 1880 case ir_binop_vector_extract: { 1881 const int c = CLAMP(op[1]->value.i[0], 0, 1882 (int) op[0]->type->vector_elements - 1); 1883 1884 switch (op[0]->type->base_type) { 1885 case GLSL_TYPE_UINT: 1886 data.u[0] = op[0]->value.u[c]; 1887 break; 1888 case GLSL_TYPE_INT: 1889 data.i[0] = op[0]->value.i[c]; 1890 break; 1891 case GLSL_TYPE_FLOAT: 1892 data.f[0] = op[0]->value.f[c]; 1893 break; 1894 case GLSL_TYPE_DOUBLE: 1895 data.d[0] = op[0]->value.d[c]; 1896 break; 1897 case GLSL_TYPE_UINT64: 1898 data.u64[0] = op[0]->value.u64[c]; 1899 break; 1900 case GLSL_TYPE_INT64: 1901 data.i64[0] = op[0]->value.i64[c]; 1902 break; 1903 case GLSL_TYPE_BOOL: 1904 data.b[0] = op[0]->value.b[c]; 1905 break; 1906 default: 1907 unreachable("invalid type"); 1908 } 1909 break; 1910 } 1911 1912 case ir_binop_atan2: 1913 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1914 switch (op[0]->type->base_type) { 1915 case GLSL_TYPE_FLOAT: 1916 data.f[c] = atan2(op[0]->value.f[c], op[1]->value.f[c]); 1917 break; 1918 default: 1919 unreachable("invalid type"); 1920 } 1921 } 1922 break; 1923 1924 case ir_triop_fma: 1925 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1926 switch (op[0]->type->base_type) { 1927 case GLSL_TYPE_FLOAT: 1928 data.f[c] = op[0]->value.f[c] * op[1]->value.f[c] + op[2]->value.f[c]; 1929 break; 1930 case GLSL_TYPE_DOUBLE: 1931 data.d[c] = op[0]->value.d[c] * op[1]->value.d[c] + op[2]->value.d[c]; 1932 break; 1933 default: 1934 unreachable("invalid type"); 1935 } 1936 } 1937 break; 1938 1939 case ir_triop_lrp: { 1940 assert(op[0]->type->is_float() || op[0]->type->is_double()); 1941 assert(op[1]->type->is_float() || op[1]->type->is_double()); 1942 assert(op[2]->type->is_float() || op[2]->type->is_double()); 1943 1944 unsigned c2_inc = op[2]->type->is_scalar() ? 0 : 1; 1945 for (unsigned c = 0, c2 = 0; c < components; c2 += c2_inc, c++) { 1946 switch (this->type->base_type) { 1947 case GLSL_TYPE_FLOAT: 1948 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]); 1949 break; 1950 case GLSL_TYPE_DOUBLE: 1951 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]); 1952 break; 1953 default: 1954 unreachable("invalid type"); 1955 } 1956 } 1957 break; 1958 } 1959 1960 case ir_triop_csel: 1961 for (unsigned c = 0; c < components; c++) { 1962 switch (this->type->base_type) { 1963 case GLSL_TYPE_UINT: 1964 data.u[c] = op[0]->value.b[c] ? op[1]->value.u[c] : op[2]->value.u[c]; 1965 break; 1966 case GLSL_TYPE_INT: 1967 data.i[c] = op[0]->value.b[c] ? op[1]->value.i[c] : op[2]->value.i[c]; 1968 break; 1969 case GLSL_TYPE_FLOAT: 1970 data.f[c] = op[0]->value.b[c] ? op[1]->value.f[c] : op[2]->value.f[c]; 1971 break; 1972 case GLSL_TYPE_DOUBLE: 1973 data.d[c] = op[0]->value.b[c] ? op[1]->value.d[c] : op[2]->value.d[c]; 1974 break; 1975 case GLSL_TYPE_UINT64: 1976 data.u64[c] = op[0]->value.b[c] ? op[1]->value.u64[c] : op[2]->value.u64[c]; 1977 break; 1978 case GLSL_TYPE_INT64: 1979 data.i64[c] = op[0]->value.b[c] ? op[1]->value.i64[c] : op[2]->value.i64[c]; 1980 break; 1981 case GLSL_TYPE_BOOL: 1982 data.b[c] = op[0]->value.b[c] ? op[1]->value.b[c] : op[2]->value.b[c]; 1983 break; 1984 default: 1985 unreachable("invalid type"); 1986 } 1987 } 1988 break; 1989 1990 case ir_triop_bitfield_extract: 1991 for (unsigned c = 0; c < op[0]->type->components(); c++) { 1992 switch (op[0]->type->base_type) { 1993 case GLSL_TYPE_UINT: 1994 data.i[c] = bitfield_extract_uint(op[0]->value.u[c], op[1]->value.i[c], op[2]->value.i[c]); 1995 break; 1996 case GLSL_TYPE_INT: 1997 data.i[c] = bitfield_extract_int(op[0]->value.i[c], op[1]->value.i[c], op[2]->value.i[c]); 1998 break; 1999 default: 2000 unreachable("invalid type"); 2001 } 2002 } 2003 break; 2004 2005 case ir_triop_vector_insert: { 2006 const unsigned idx = op[2]->value.u[0]; 2007 2008 memcpy(&data, &op[0]->value, sizeof(data)); 2009 2010 switch (this->type->base_type) { 2011 case GLSL_TYPE_UINT: 2012 data.u[idx] = op[1]->value.u[0]; 2013 break; 2014 case GLSL_TYPE_INT: 2015 data.i[idx] = op[1]->value.i[0]; 2016 break; 2017 case GLSL_TYPE_FLOAT: 2018 data.f[idx] = op[1]->value.f[0]; 2019 break; 2020 case GLSL_TYPE_DOUBLE: 2021 data.d[idx] = op[1]->value.d[0]; 2022 break; 2023 case GLSL_TYPE_UINT64: 2024 data.u64[idx] = op[1]->value.u64[0]; 2025 break; 2026 case GLSL_TYPE_INT64: 2027 data.i64[idx] = op[1]->value.i64[0]; 2028 break; 2029 case GLSL_TYPE_BOOL: 2030 data.b[idx] = op[1]->value.b[0]; 2031 break; 2032 default: 2033 unreachable("invalid type"); 2034 } 2035 break; 2036 } 2037 2038 case ir_quadop_bitfield_insert: 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.u[c] = bitfield_insert(op[0]->value.u[c], op[1]->value.u[c], op[2]->value.i[c], op[3]->value.i[c]); 2043 break; 2044 case GLSL_TYPE_INT: 2045 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]); 2046 break; 2047 default: 2048 unreachable("invalid type"); 2049 } 2050 } 2051 break; 2052 2053 case ir_quadop_vector: 2054 for (unsigned c = 0; c < this->type->vector_elements; c++) { 2055 switch (this->type->base_type) { 2056 case GLSL_TYPE_UINT: 2057 data.u[c] = op[c]->value.u[0]; 2058 break; 2059 case GLSL_TYPE_INT: 2060 data.i[c] = op[c]->value.i[0]; 2061 break; 2062 case GLSL_TYPE_FLOAT: 2063 data.f[c] = op[c]->value.f[0]; 2064 break; 2065 case GLSL_TYPE_DOUBLE: 2066 data.d[c] = op[c]->value.d[0]; 2067 break; 2068 case GLSL_TYPE_UINT64: 2069 data.u64[c] = op[c]->value.u64[0]; 2070 break; 2071 case GLSL_TYPE_INT64: 2072 data.i64[c] = op[c]->value.i64[0]; 2073 break; 2074 case GLSL_TYPE_BOOL: 2075 data.b[c] = op[c]->value.b[0]; 2076 break; 2077 default: 2078 unreachable("invalid type"); 2079 } 2080 } 2081 break; 2082 2083 default: 2084 /* FINISHME: Should handle all expression types. */ 2085 return NULL; 2086 } 2087 2088