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