1 /************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 #include "util/u_debug.h" 29 #include "util/u_memory.h" 30 #include "util/u_prim.h" 31 #include "pipe/p_defines.h" 32 #include "util/u_inlines.h" 33 #include "tgsi_text.h" 34 #include "tgsi_build.h" 35 #include "tgsi_info.h" 36 #include "tgsi_parse.h" 37 #include "tgsi_sanity.h" 38 #include "tgsi_strings.h" 39 #include "tgsi_util.h" 40 #include "tgsi_dump.h" 41 42 static boolean is_alpha_underscore( const char *cur ) 43 { 44 return 45 (*cur >= 'a' && *cur <= 'z') || 46 (*cur >= 'A' && *cur <= 'Z') || 47 *cur == '_'; 48 } 49 50 static boolean is_digit( const char *cur ) 51 { 52 return *cur >= '0' && *cur <= '9'; 53 } 54 55 static boolean is_digit_alpha_underscore( const char *cur ) 56 { 57 return is_digit( cur ) || is_alpha_underscore( cur ); 58 } 59 60 static char uprcase( char c ) 61 { 62 if (c >= 'a' && c <= 'z') 63 return c + 'A' - 'a'; 64 return c; 65 } 66 67 /* 68 * Ignore case of str1 and assume str1 is already uppercase. 69 * Return TRUE iff str1 and str2 are equal. 70 */ 71 static int 72 streq_nocase_uprcase(const char *str1, 73 const char *str2) 74 { 75 while (*str1 && *str2) { 76 if (*str1 != uprcase(*str2)) 77 return FALSE; 78 str1++; 79 str2++; 80 } 81 return *str1 == 0 && *str2 == 0; 82 } 83 84 /* Return TRUE if both strings match. 85 * The second string is terminated by zero. 86 * The pointer to the first string is moved at end of the read word 87 * on success. 88 */ 89 static boolean str_match_no_case( const char **pcur, const char *str ) 90 { 91 const char *cur = *pcur; 92 93 while (*str != '\0' && *str == uprcase( *cur )) { 94 str++; 95 cur++; 96 } 97 if (*str == '\0') { 98 *pcur = cur; 99 return TRUE; 100 } 101 return FALSE; 102 } 103 104 /* Return TRUE if both strings match. 105 * The first string is be terminated by a non-digit non-letter non-underscore 106 * character, the second string is terminated by zero. 107 * The pointer to the first string is moved at end of the read word 108 * on success. 109 */ 110 static boolean str_match_nocase_whole( const char **pcur, const char *str ) 111 { 112 const char *cur = *pcur; 113 114 if (str_match_no_case(&cur, str) && 115 !is_digit_alpha_underscore(cur)) { 116 *pcur = cur; 117 return TRUE; 118 } 119 return FALSE; 120 } 121 122 /* Return the array index that matches starting at *pcur, where the string at 123 * *pcur is terminated by a non-digit non-letter non-underscore. 124 * Returns -1 if no match is found. 125 * 126 * On success, the pointer to the first string is moved to the end of the read 127 * word. 128 */ 129 static int str_match_name_from_array(const char **pcur, 130 const char * const *array, 131 unsigned array_size) 132 { 133 for (unsigned j = 0; j < array_size; ++j) { 134 if (str_match_nocase_whole(pcur, array[j])) 135 return j; 136 } 137 return -1; 138 } 139 140 /* Return the format corresponding to the name at *pcur. 141 * Returns -1 if there is no format name. 142 * 143 * On success, the pointer to the string is moved to the end of the read format 144 * name. 145 */ 146 static int str_match_format(const char **pcur) 147 { 148 for (unsigned i = 0; i < PIPE_FORMAT_COUNT; i++) { 149 const struct util_format_description *desc = 150 util_format_description(i); 151 if (desc && str_match_nocase_whole(pcur, desc->name)) { 152 return i; 153 } 154 } 155 return -1; 156 } 157 158 /* Eat zero or more whitespaces. 159 */ 160 static void eat_opt_white( const char **pcur ) 161 { 162 while (**pcur == ' ' || **pcur == '\t' || **pcur == '\n') 163 (*pcur)++; 164 } 165 166 /* Eat one or more whitespaces. 167 * Return TRUE if at least one whitespace eaten. 168 */ 169 static boolean eat_white( const char **pcur ) 170 { 171 const char *cur = *pcur; 172 173 eat_opt_white( pcur ); 174 return *pcur > cur; 175 } 176 177 /* Parse unsigned integer. 178 * No checks for overflow. 179 */ 180 static boolean parse_uint( const char **pcur, uint *val ) 181 { 182 const char *cur = *pcur; 183 184 if (is_digit( cur )) { 185 *val = *cur++ - '0'; 186 while (is_digit( cur )) 187 *val = *val * 10 + *cur++ - '0'; 188 *pcur = cur; 189 return TRUE; 190 } 191 return FALSE; 192 } 193 194 static boolean parse_int( const char **pcur, int *val ) 195 { 196 const char *cur = *pcur; 197 int sign = (*cur == '-' ? -1 : 1); 198 199 if (*cur == '+' || *cur == '-') 200 cur++; 201 202 if (parse_uint(&cur, (uint *)val)) { 203 *val *= sign; 204 *pcur = cur; 205 return TRUE; 206 } 207 208 return FALSE; 209 } 210 211 static boolean parse_identifier( const char **pcur, char *ret, size_t len ) 212 { 213 const char *cur = *pcur; 214 int i = 0; 215 if (is_alpha_underscore( cur )) { 216 ret[i++] = *cur++; 217 while (is_alpha_underscore( cur ) || is_digit( cur )) { 218 if (i == len - 1) 219 return FALSE; 220 ret[i++] = *cur++; 221 } 222 ret[i++] = '\0'; 223 *pcur = cur; 224 return TRUE; 225 } 226 return FALSE; 227 } 228 229 /* Parse floating point. 230 */ 231 static boolean parse_float( const char **pcur, float *val ) 232 { 233 const char *cur = *pcur; 234 boolean integral_part = FALSE; 235 boolean fractional_part = FALSE; 236 237 if (*cur == '0' && *(cur + 1) == 'x') { 238 union fi fi; 239 fi.ui = strtoul(cur, NULL, 16); 240 *val = fi.f; 241 cur += 10; 242 goto out; 243 } 244 245 *val = (float) atof( cur ); 246 if (*cur == '-' || *cur == '+') 247 cur++; 248 if (is_digit( cur )) { 249 cur++; 250 integral_part = TRUE; 251 while (is_digit( cur )) 252 cur++; 253 } 254 if (*cur == '.') { 255 cur++; 256 if (is_digit( cur )) { 257 cur++; 258 fractional_part = TRUE; 259 while (is_digit( cur )) 260 cur++; 261 } 262 } 263 if (!integral_part && !fractional_part) 264 return FALSE; 265 if (uprcase( *cur ) == 'E') { 266 cur++; 267 if (*cur == '-' || *cur == '+') 268 cur++; 269 if (is_digit( cur )) { 270 cur++; 271 while (is_digit( cur )) 272 cur++; 273 } 274 else 275 return FALSE; 276 } 277 278 out: 279 *pcur = cur; 280 return TRUE; 281 } 282 283 static boolean parse_double( const char **pcur, uint32_t *val0, uint32_t *val1) 284 { 285 const char *cur = *pcur; 286 union { 287 double dval; 288 uint32_t uval[2]; 289 } v; 290 291 v.dval = strtod(cur, (char**)pcur); 292 if (*pcur == cur) 293 return FALSE; 294 295 *val0 = v.uval[0]; 296 *val1 = v.uval[1]; 297 298 return TRUE; 299 } 300 301 static boolean parse_int64( const char **pcur, uint32_t *val0, uint32_t *val1) 302 { 303 const char *cur = *pcur; 304 union { 305 int64_t i64val; 306 uint32_t uval[2]; 307 } v; 308 309 v.i64val = strtoll(cur, (char**)pcur, 0); 310 if (*pcur == cur) 311 return FALSE; 312 313 *val0 = v.uval[0]; 314 *val1 = v.uval[1]; 315 316 return TRUE; 317 } 318 319 static boolean parse_uint64( const char **pcur, uint32_t *val0, uint32_t *val1) 320 { 321 const char *cur = *pcur; 322 union { 323 uint64_t u64val; 324 uint32_t uval[2]; 325 } v; 326 327 v.u64val = strtoull(cur, (char**)pcur, 0); 328 if (*pcur == cur) 329 return FALSE; 330 331 *val0 = v.uval[0]; 332 *val1 = v.uval[1]; 333 334 return TRUE; 335 } 336 337 struct translate_ctx 338 { 339 const char *text; 340 const char *cur; 341 struct tgsi_token *tokens; 342 struct tgsi_token *tokens_cur; 343 struct tgsi_token *tokens_end; 344 struct tgsi_header *header; 345 unsigned processor : 4; 346 unsigned implied_array_size : 6; 347 unsigned num_immediates; 348 }; 349 350 static void report_error( struct translate_ctx *ctx, const char *msg ) 351 { 352 int line = 1; 353 int column = 1; 354 const char *itr = ctx->text; 355 356 while (itr != ctx->cur) { 357 if (*itr == '\n') { 358 column = 1; 359 ++line; 360 } 361 ++column; 362 ++itr; 363 } 364 365 debug_printf( "\nTGSI asm error: %s [%d : %d] \n", msg, line, column ); 366 } 367 368 /* Parse shader header. 369 * Return TRUE for one of the following headers. 370 * FRAG 371 * GEOM 372 * VERT 373 */ 374 static boolean parse_header( struct translate_ctx *ctx ) 375 { 376 uint processor; 377 378 if (str_match_nocase_whole( &ctx->cur, "FRAG" )) 379 processor = PIPE_SHADER_FRAGMENT; 380 else if (str_match_nocase_whole( &ctx->cur, "VERT" )) 381 processor = PIPE_SHADER_VERTEX; 382 else if (str_match_nocase_whole( &ctx->cur, "GEOM" )) 383 processor = PIPE_SHADER_GEOMETRY; 384 else if (str_match_nocase_whole( &ctx->cur, "TESS_CTRL" )) 385 processor = PIPE_SHADER_TESS_CTRL; 386 else if (str_match_nocase_whole( &ctx->cur, "TESS_EVAL" )) 387 processor = PIPE_SHADER_TESS_EVAL; 388 else if (str_match_nocase_whole( &ctx->cur, "COMP" )) 389 processor = PIPE_SHADER_COMPUTE; 390 else { 391 report_error( ctx, "Unknown header" ); 392 return FALSE; 393 } 394 395 if (ctx->tokens_cur >= ctx->tokens_end) 396 return FALSE; 397 ctx->header = (struct tgsi_header *) ctx->tokens_cur++; 398 *ctx->header = tgsi_build_header(); 399 400 if (ctx->tokens_cur >= ctx->tokens_end) 401 return FALSE; 402 *(struct tgsi_processor *) ctx->tokens_cur++ = tgsi_build_processor( processor, ctx->header ); 403 ctx->processor = processor; 404 405 return TRUE; 406 } 407 408 static boolean parse_label( struct translate_ctx *ctx, uint *val ) 409 { 410 const char *cur = ctx->cur; 411 412 if (parse_uint( &cur, val )) { 413 eat_opt_white( &cur ); 414 if (*cur == ':') { 415 cur++; 416 ctx->cur = cur; 417 return TRUE; 418 } 419 } 420 return FALSE; 421 } 422 423 static boolean 424 parse_file( const char **pcur, uint *file ) 425 { 426 uint i; 427 428 for (i = 0; i < TGSI_FILE_COUNT; i++) { 429 const char *cur = *pcur; 430 431 if (str_match_nocase_whole( &cur, tgsi_file_name(i) )) { 432 *pcur = cur; 433 *file = i; 434 return TRUE; 435 } 436 } 437 return FALSE; 438 } 439 440 static boolean 441 parse_opt_writemask( 442 struct translate_ctx *ctx, 443 uint *writemask ) 444 { 445 const char *cur; 446 447 cur = ctx->cur; 448 eat_opt_white( &cur ); 449 if (*cur == '.') { 450 cur++; 451 *writemask = TGSI_WRITEMASK_NONE; 452 eat_opt_white( &cur ); 453 if (uprcase( *cur ) == 'X') { 454 cur++; 455 *writemask |= TGSI_WRITEMASK_X; 456 } 457 if (uprcase( *cur ) == 'Y') { 458 cur++; 459 *writemask |= TGSI_WRITEMASK_Y; 460 } 461 if (uprcase( *cur ) == 'Z') { 462 cur++; 463 *writemask |= TGSI_WRITEMASK_Z; 464 } 465 if (uprcase( *cur ) == 'W') { 466 cur++; 467 *writemask |= TGSI_WRITEMASK_W; 468 } 469 470 if (*writemask == TGSI_WRITEMASK_NONE) { 471 report_error( ctx, "Writemask expected" ); 472 return FALSE; 473 } 474 475 ctx->cur = cur; 476 } 477 else { 478 *writemask = TGSI_WRITEMASK_XYZW; 479 } 480 return TRUE; 481 } 482 483 484 /* <register_file_bracket> ::= <file> `[' 485 */ 486 static boolean 487 parse_register_file_bracket( 488 struct translate_ctx *ctx, 489 uint *file ) 490 { 491 if (!parse_file( &ctx->cur, file )) { 492 report_error( ctx, "Unknown register file" ); 493 return FALSE; 494 } 495 eat_opt_white( &ctx->cur ); 496 if (*ctx->cur != '[') { 497 report_error( ctx, "Expected `['" ); 498 return FALSE; 499 } 500 ctx->cur++; 501 return TRUE; 502 } 503 504 /* <register_file_bracket_index> ::= <register_file_bracket> <uint> 505 */ 506 static boolean 507 parse_register_file_bracket_index( 508 struct translate_ctx *ctx, 509 uint *file, 510 int *index ) 511 { 512 uint uindex; 513 514 if (!parse_register_file_bracket( ctx, file )) 515 return FALSE; 516 eat_opt_white( &ctx->cur ); 517 if (!parse_uint( &ctx->cur, &uindex )) { 518 report_error( ctx, "Expected literal unsigned integer" ); 519 return FALSE; 520 } 521 *index = (int) uindex; 522 return TRUE; 523 } 524 525 /* Parse simple 1d register operand. 526 * <register_dst> ::= <register_file_bracket_index> `]' 527 */ 528 static boolean 529 parse_register_1d(struct translate_ctx *ctx, 530 uint *file, 531 int *index ) 532 { 533 if (!parse_register_file_bracket_index( ctx, file, index )) 534 return FALSE; 535 eat_opt_white( &ctx->cur ); 536 if (*ctx->cur != ']') { 537 report_error( ctx, "Expected `]'" ); 538 return FALSE; 539 } 540 ctx->cur++; 541 return TRUE; 542 } 543 544 struct parsed_bracket { 545 int index; 546 547 uint ind_file; 548 int ind_index; 549 uint ind_comp; 550 uint ind_array; 551 }; 552 553 554 static boolean 555 parse_register_bracket( 556 struct translate_ctx *ctx, 557 struct parsed_bracket *brackets) 558 { 559 const char *cur; 560 uint uindex; 561 562 memset(brackets, 0, sizeof(struct parsed_bracket)); 563 564 eat_opt_white( &ctx->cur ); 565 566 cur = ctx->cur; 567 if (parse_file( &cur, &brackets->ind_file )) { 568 if (!parse_register_1d( ctx, &brackets->ind_file, 569 &brackets->ind_index )) 570 return FALSE; 571 eat_opt_white( &ctx->cur ); 572 573 if (*ctx->cur == '.') { 574 ctx->cur++; 575 eat_opt_white(&ctx->cur); 576 577 switch (uprcase(*ctx->cur)) { 578 case 'X': 579 brackets->ind_comp = TGSI_SWIZZLE_X; 580 break; 581 case 'Y': 582 brackets->ind_comp = TGSI_SWIZZLE_Y; 583 break; 584 case 'Z': 585 brackets->ind_comp = TGSI_SWIZZLE_Z; 586 break; 587 case 'W': 588 brackets->ind_comp = TGSI_SWIZZLE_W; 589 break; 590 default: 591 report_error(ctx, "Expected indirect register swizzle component `x', `y', `z' or `w'"); 592 return FALSE; 593 } 594 ctx->cur++; 595 eat_opt_white(&ctx->cur); 596 } 597 598 if (*ctx->cur == '+' || *ctx->cur == '-') 599 parse_int( &ctx->cur, &brackets->index ); 600 else 601 brackets->index = 0; 602 } 603 else { 604 if (!parse_uint( &ctx->cur, &uindex )) { 605 report_error( ctx, "Expected literal unsigned integer" ); 606 return FALSE; 607 } 608 brackets->index = (int) uindex; 609 brackets->ind_file = TGSI_FILE_NULL; 610 brackets->ind_index = 0; 611 } 612 eat_opt_white( &ctx->cur ); 613 if (*ctx->cur != ']') { 614 report_error( ctx, "Expected `]'" ); 615 return FALSE; 616 } 617 ctx->cur++; 618 if (*ctx->cur == '(') { 619 ctx->cur++; 620 eat_opt_white( &ctx->cur ); 621 if (!parse_uint( &ctx->cur, &brackets->ind_array )) { 622 report_error( ctx, "Expected literal unsigned integer" ); 623 return FALSE; 624 } 625 eat_opt_white( &ctx->cur ); 626 if (*ctx->cur != ')') { 627 report_error( ctx, "Expected `)'" ); 628 return FALSE; 629 } 630 ctx->cur++; 631 } 632 return TRUE; 633 } 634 635 static boolean 636 parse_opt_register_src_bracket( 637 struct translate_ctx *ctx, 638 struct parsed_bracket *brackets, 639 int *parsed_brackets) 640 { 641 const char *cur = ctx->cur; 642 643 *parsed_brackets = 0; 644 645 eat_opt_white( &cur ); 646 if (cur[0] == '[') { 647 ++cur; 648 ctx->cur = cur; 649 650 if (!parse_register_bracket(ctx, brackets)) 651 return FALSE; 652 653 *parsed_brackets = 1; 654 } 655 656 return TRUE; 657 } 658 659 660 /* Parse source register operand. 661 * <register_src> ::= <register_file_bracket_index> `]' | 662 * <register_file_bracket> <register_dst> [`.' (`x' | `y' | `z' | `w')] `]' | 663 * <register_file_bracket> <register_dst> [`.' (`x' | `y' | `z' | `w')] `+' <uint> `]' | 664 * <register_file_bracket> <register_dst> [`.' (`x' | `y' | `z' | `w')] `-' <uint> `]' 665 */ 666 static boolean 667 parse_register_src( 668 struct translate_ctx *ctx, 669 uint *file, 670 struct parsed_bracket *brackets) 671 { 672 brackets->ind_comp = TGSI_SWIZZLE_X; 673 if (!parse_register_file_bracket( ctx, file )) 674 return FALSE; 675 if (!parse_register_bracket( ctx, brackets )) 676 return FALSE; 677 678 return TRUE; 679 } 680 681 struct parsed_dcl_bracket { 682 uint first; 683 uint last; 684 }; 685 686 static boolean 687 parse_register_dcl_bracket( 688 struct translate_ctx *ctx, 689 struct parsed_dcl_bracket *bracket) 690 { 691 uint uindex; 692 memset(bracket, 0, sizeof(struct parsed_dcl_bracket)); 693 694 eat_opt_white( &ctx->cur ); 695 696 if (!parse_uint( &ctx->cur, &uindex )) { 697 /* it can be an empty bracket [] which means its range 698 * is from 0 to some implied size */ 699 if (ctx->cur[0] == ']' && ctx->implied_array_size != 0) { 700 bracket->first = 0; 701 bracket->last = ctx->implied_array_size - 1; 702 goto cleanup; 703 } 704 report_error( ctx, "Expected literal unsigned integer" ); 705 return FALSE; 706 } 707 bracket->first = uindex; 708 709 eat_opt_white( &ctx->cur ); 710 711 if (ctx->cur[0] == '.' && ctx->cur[1] == '.') { 712 uint uindex; 713 714 ctx->cur += 2; 715 eat_opt_white( &ctx->cur ); 716 if (!parse_uint( &ctx->cur, &uindex )) { 717 report_error( ctx, "Expected literal integer" ); 718 return FALSE; 719 } 720 bracket->last = (int) uindex; 721 eat_opt_white( &ctx->cur ); 722 } 723 else { 724 bracket->last = bracket->first; 725 } 726 727 cleanup: 728 if (*ctx->cur != ']') { 729 report_error( ctx, "Expected `]' or `..'" ); 730 return FALSE; 731 } 732 ctx->cur++; 733 return TRUE; 734 } 735 736 /* Parse register declaration. 737 * <register_dcl> ::= <register_file_bracket_index> `]' | 738 * <register_file_bracket_index> `..' <index> `]' 739 */ 740 static boolean 741 parse_register_dcl( 742 struct translate_ctx *ctx, 743 uint *file, 744 struct parsed_dcl_bracket *brackets, 745 int *num_brackets) 746 { 747 const char *cur; 748 749 *num_brackets = 0; 750 751 if (!parse_register_file_bracket( ctx, file )) 752 return FALSE; 753 if (!parse_register_dcl_bracket( ctx, &brackets[0] )) 754 return FALSE; 755 756 *num_brackets = 1; 757 758 cur = ctx->cur; 759 eat_opt_white( &cur ); 760 761 if (cur[0] == '[') { 762 bool is_in = *file == TGSI_FILE_INPUT; 763 bool is_out = *file == TGSI_FILE_OUTPUT; 764 765 ++cur; 766 ctx->cur = cur; 767 if (!parse_register_dcl_bracket( ctx, &brackets[1] )) 768 return FALSE; 769 /* for geometry shader we don't really care about 770 * the first brackets it's always the size of the 771 * input primitive. so we want to declare just 772 * the index relevant to the semantics which is in 773 * the second bracket */ 774 775 /* tessellation has similar constraints to geometry shader */ 776 if ((ctx->processor == PIPE_SHADER_GEOMETRY && is_in) || 777 (ctx->processor == PIPE_SHADER_TESS_EVAL && is_in) || 778 (ctx->processor == PIPE_SHADER_TESS_CTRL && (is_in || is_out))) { 779 brackets[0] = brackets[1]; 780 *num_brackets = 1; 781 } else { 782 *num_brackets = 2; 783 } 784 } 785 786 return TRUE; 787 } 788 789 790 /* Parse destination register operand.*/ 791 static boolean 792 parse_register_dst( 793 struct translate_ctx *ctx, 794 uint *file, 795 struct parsed_bracket *brackets) 796 { 797 brackets->ind_comp = TGSI_SWIZZLE_X; 798 if (!parse_register_file_bracket( ctx, file )) 799 return FALSE; 800 if (!parse_register_bracket( ctx, brackets )) 801 return FALSE; 802 803 return TRUE; 804 } 805 806 static boolean 807 parse_dst_operand( 808 struct translate_ctx *ctx, 809 struct tgsi_full_dst_register *dst ) 810 { 811 uint file; 812 uint writemask; 813 const char *cur; 814 struct parsed_bracket bracket[2]; 815 int parsed_opt_brackets; 816 817 if (!parse_register_dst( ctx, &file, &bracket[0] )) 818 return FALSE; 819 if (!parse_opt_register_src_bracket(ctx, &bracket[1], &parsed_opt_brackets)) 820 return FALSE; 821 822 cur = ctx->cur; 823 eat_opt_white( &cur ); 824 825 if (!parse_opt_writemask( ctx, &writemask )) 826 return FALSE; 827 828 dst->Register.File = file; 829 if (parsed_opt_brackets) { 830 dst->Register.Dimension = 1; 831 dst->Dimension.Indirect = 0; 832 dst->Dimension.Dimension = 0; 833 dst->Dimension.Index = bracket[0].index; 834 835 if (bracket[0].ind_file != TGSI_FILE_NULL) { 836 dst->Dimension.Indirect = 1; 837 dst->DimIndirect.File = bracket[0].ind_file; 838 dst->DimIndirect.Index = bracket[0].ind_index; 839 dst->DimIndirect.Swizzle = bracket[0].ind_comp; 840 dst->DimIndirect.ArrayID = bracket[0].ind_array; 841 } 842 bracket[0] = bracket[1]; 843 } 844 dst->Register.Index = bracket[0].index; 845 dst->Register.WriteMask = writemask; 846 if (bracket[0].ind_file != TGSI_FILE_NULL) { 847 dst->Register.Indirect = 1; 848 dst->Indirect.File = bracket[0].ind_file; 849 dst->Indirect.Index = bracket[0].ind_index; 850 dst->Indirect.Swizzle = bracket[0].ind_comp; 851 dst->Indirect.ArrayID = bracket[0].ind_array; 852 } 853 return TRUE; 854 } 855 856 static boolean 857 parse_optional_swizzle( 858 struct translate_ctx *ctx, 859 uint *swizzle, 860 boolean *parsed_swizzle, 861 int components) 862 { 863 const char *cur = ctx->cur; 864 865 *parsed_swizzle = FALSE; 866 867 eat_opt_white( &cur ); 868 if (*cur == '.') { 869 uint i; 870 871 cur++; 872 eat_opt_white( &cur ); 873 for (i = 0; i < components; i++) { 874 if (uprcase( *cur ) == 'X') 875 swizzle[i] = TGSI_SWIZZLE_X; 876 else if (uprcase( *cur ) == 'Y') 877 swizzle[i] = TGSI_SWIZZLE_Y; 878 else if (uprcase( *cur ) == 'Z') 879 swizzle[i] = TGSI_SWIZZLE_Z; 880 else if (uprcase( *cur ) == 'W') 881 swizzle[i] = TGSI_SWIZZLE_W; 882 else { 883 report_error( ctx, "Expected register swizzle component `x', `y', `z' or `w'" ); 884 return FALSE; 885 } 886 cur++; 887 } 888 *parsed_swizzle = TRUE; 889 ctx->cur = cur; 890 } 891 return TRUE; 892 } 893 894 static boolean 895 parse_src_operand( 896 struct translate_ctx *ctx, 897 struct tgsi_full_src_register *src ) 898 { 899 uint file; 900 uint swizzle[4]; 901 boolean parsed_swizzle; 902 struct parsed_bracket bracket[2]; 903 int parsed_opt_brackets; 904 905 if (*ctx->cur == '-') { 906 ctx->cur++; 907 eat_opt_white( &ctx->cur ); 908 src->Register.Negate = 1; 909 } 910 911 if (*ctx->cur == '|') { 912 ctx->cur++; 913 eat_opt_white( &ctx->cur ); 914 src->Register.Absolute = 1; 915 } 916 917 if (!parse_register_src(ctx, &file, &bracket[0])) 918 return FALSE; 919 if (!parse_opt_register_src_bracket(ctx, &bracket[1], &parsed_opt_brackets)) 920 return FALSE; 921 922 src->Register.File = file; 923 if (parsed_opt_brackets) { 924 src->Register.Dimension = 1; 925 src->Dimension.Indirect = 0; 926 src->Dimension.Dimension = 0; 927 src->Dimension.Index = bracket[0].index; 928 if (bracket[0].ind_file != TGSI_FILE_NULL) { 929 src->Dimension.Indirect = 1; 930 src->DimIndirect.File = bracket[0].ind_file; 931 src->DimIndirect.Index = bracket[0].ind_index; 932 src->DimIndirect.Swizzle = bracket[0].ind_comp; 933 src->DimIndirect.ArrayID = bracket[0].ind_array; 934 } 935 bracket[0] = bracket[1]; 936 } 937 src->Register.Index = bracket[0].index; 938 if (bracket[0].ind_file != TGSI_FILE_NULL) { 939 src->Register.Indirect = 1; 940 src->Indirect.File = bracket[0].ind_file; 941 src->Indirect.Index = bracket[0].ind_index; 942 src->Indirect.Swizzle = bracket[0].ind_comp; 943 src->Indirect.ArrayID = bracket[0].ind_array; 944 } 945 946 /* Parse optional swizzle. 947 */ 948 if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, 4 )) { 949 if (parsed_swizzle) { 950 src->Register.SwizzleX = swizzle[0]; 951 src->Register.SwizzleY = swizzle[1]; 952 src->Register.SwizzleZ = swizzle[2]; 953 src->Register.SwizzleW = swizzle[3]; 954 } 955 } 956 957 if (src->Register.Absolute) { 958 eat_opt_white( &ctx->cur ); 959 if (*ctx->cur != '|') { 960 report_error( ctx, "Expected `|'" ); 961 return FALSE; 962 } 963 ctx->cur++; 964 } 965 966 967 return TRUE; 968 } 969 970 static boolean 971 parse_texoffset_operand( 972 struct translate_ctx *ctx, 973 struct tgsi_texture_offset *src ) 974 { 975 uint file; 976 uint swizzle[3]; 977 boolean parsed_swizzle; 978 struct parsed_bracket bracket; 979 980 if (!parse_register_src(ctx, &file, &bracket)) 981 return FALSE; 982 983 src->File = file; 984 src->Index = bracket.index; 985 986 /* Parse optional swizzle. 987 */ 988 if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, 3 )) { 989 if (parsed_swizzle) { 990 src->SwizzleX = swizzle[0]; 991 src->SwizzleY = swizzle[1]; 992 src->SwizzleZ = swizzle[2]; 993 } 994 } 995 996 return TRUE; 997 } 998 999 static boolean 1000 match_inst(const char **pcur, 1001 unsigned *saturate, 1002 const struct tgsi_opcode_info *info) 1003 { 1004 const char *cur = *pcur; 1005 1006 /* simple case: the whole string matches the instruction name */ 1007 if (str_match_nocase_whole(&cur, info->mnemonic)) { 1008 *pcur = cur; 1009 *saturate = 0; 1010 return TRUE; 1011 } 1012 1013 if (str_match_no_case(&cur, info->mnemonic)) { 1014 /* the instruction has a suffix, figure it out */ 1015 if (str_match_nocase_whole(&cur, "_SAT")) { 1016 *pcur = cur; 1017 *saturate = 1; 1018 return TRUE; 1019 } 1020 } 1021 1022 return FALSE; 1023 } 1024 1025 static boolean 1026 parse_instruction( 1027 struct translate_ctx *ctx, 1028 boolean has_label ) 1029 { 1030 uint i; 1031 uint saturate = 0; 1032 const struct tgsi_opcode_info *info; 1033 struct tgsi_full_instruction inst; 1034 const char *cur; 1035 uint advance; 1036 1037 inst = tgsi_default_full_instruction(); 1038 1039 /* Parse predicate. 1040 */ 1041 eat_opt_white( &ctx->cur ); 1042 if (*ctx->cur == '(') { 1043 uint file; 1044 int index; 1045 uint swizzle[4]; 1046 boolean parsed_swizzle; 1047 1048 inst.Instruction.Predicate = 1; 1049 1050 ctx->cur++; 1051 if (*ctx->cur == '!') { 1052 ctx->cur++; 1053 inst.Predicate.Negate = 1; 1054 } 1055 1056 if (!parse_register_1d( ctx, &file, &index )) 1057 return FALSE; 1058 1059 if (parse_optional_swizzle( ctx, swizzle, &parsed_swizzle, 4 )) { 1060 if (parsed_swizzle) { 1061 inst.Predicate.SwizzleX = swizzle[0]; 1062 inst.Predicate.SwizzleY = swizzle[1]; 1063 inst.Predicate.SwizzleZ = swizzle[2]; 1064 inst.Predicate.SwizzleW = swizzle[3]; 1065 } 1066 } 1067 1068 if (*ctx->cur != ')') { 1069 report_error( ctx, "Expected `)'" ); 1070 return FALSE; 1071 } 1072 1073 ctx->cur++; 1074 } 1075 1076 /* Parse instruction name. 1077 */ 1078 eat_opt_white( &ctx->cur ); 1079 for (i = 0; i < TGSI_OPCODE_LAST; i++) { 1080 cur = ctx->cur; 1081 1082 info = tgsi_get_opcode_info( i ); 1083 if (match_inst(&cur, &saturate, info)) { 1084 if (info->num_dst + info->num_src + info->is_tex == 0) { 1085 ctx->cur = cur; 1086 break; 1087 } 1088 else if (*cur == '\0' || eat_white( &cur )) { 1089 ctx->cur = cur; 1090 break; 1091 } 1092 } 1093 } 1094 if (i == TGSI_OPCODE_LAST) { 1095 if (has_label) 1096 report_error( ctx, "Unknown opcode" ); 1097 else 1098 report_error( ctx, "Expected `DCL', `IMM' or a label" ); 1099 return FALSE; 1100 } 1101 1102 inst.Instruction.Opcode = i; 1103 inst.Instruction.Saturate = saturate; 1104 inst.Instruction.NumDstRegs = info->num_dst; 1105 inst.Instruction.NumSrcRegs = info->num_src; 1106 1107 if (i >= TGSI_OPCODE_SAMPLE && i <= TGSI_OPCODE_GATHER4) { 1108 /* 1109 * These are not considered tex opcodes here (no additional 1110 * target argument) however we're required to set the Texture 1111 * bit so we can set the number of tex offsets. 1112 */ 1113 inst.Instruction.Texture = 1; 1114 inst.Texture.Texture = TGSI_TEXTURE_UNKNOWN; 1115 } 1116 1117 if ((i >= TGSI_OPCODE_LOAD && i <= TGSI_OPCODE_ATOMIMAX) || 1118 i == TGSI_OPCODE_RESQ) { 1119 inst.Instruction.Memory = 1; 1120 inst.Memory.Qualifier = 0; 1121 } 1122 1123 assume(info->num_dst <= TGSI_FULL_MAX_DST_REGISTERS); 1124 assume(info->num_src <= TGSI_FULL_MAX_SRC_REGISTERS); 1125 1126 /* Parse instruction operands. 1127 */ 1128 for (i = 0; i < info->num_dst + info->num_src + info->is_tex; i++) { 1129 if (i > 0) { 1130 eat_opt_white( &ctx->cur ); 1131 if (*ctx->cur != ',') { 1132 report_error( ctx, "Expected `,'" ); 1133 return FALSE; 1134 } 1135 ctx->cur++; 1136 eat_opt_white( &ctx->cur ); 1137 } 1138 1139 if (i < info->num_dst) { 1140 if (!parse_dst_operand( ctx, &inst.Dst[i] )) 1141 return FALSE; 1142 } 1143 else if (i < info->num_dst + info->num_src) { 1144 if (!parse_src_operand( ctx, &inst.Src[i - info->num_dst] )) 1145 return FALSE; 1146 } 1147 else { 1148 uint j; 1149 1150 for (j = 0; j < TGSI_TEXTURE_COUNT; j++) { 1151 if (str_match_nocase_whole( &ctx->cur, tgsi_texture_names[j] )) { 1152 inst.Instruction.Texture = 1; 1153 inst.Texture.Texture = j; 1154 break; 1155 } 1156 } 1157 if (j == TGSI_TEXTURE_COUNT) { 1158 report_error( ctx, "Expected texture target" ); 1159 return FALSE; 1160 } 1161 } 1162 } 1163 1164 cur = ctx->cur; 1165 eat_opt_white( &cur ); 1166 for (i = 0; inst.Instruction.Texture && *cur == ','; i++) { 1167 cur++; 1168 eat_opt_white( &cur ); 1169 ctx->cur = cur; 1170 if (!parse_texoffset_operand( ctx, &inst.TexOffsets[i] )) 1171 return FALSE; 1172 cur = ctx->cur; 1173 eat_opt_white( &cur ); 1174 } 1175 inst.Texture.NumOffsets = i; 1176 1177 cur = ctx->cur; 1178 eat_opt_white(&cur); 1179 1180 for (; inst.Instruction.Memory && *cur == ','; 1181 ctx->cur = cur, eat_opt_white(&cur)) { 1182 int j; 1183 1184 cur++; 1185 eat_opt_white(&cur); 1186 1187 j = str_match_name_from_array(&cur, tgsi_memory_names, 1188 ARRAY_SIZE(tgsi_memory_names)); 1189 if (j >= 0) { 1190 inst.Memory.Qualifier |= 1U << j; 1191 continue; 1192 } 1193 1194 j = str_match_name_from_array(&cur, tgsi_texture_names, 1195 ARRAY_SIZE(tgsi_texture_names)); 1196 if (j >= 0) { 1197 inst.Memory.Texture = j; 1198 continue; 1199 } 1200 1201 j = str_match_format(&cur); 1202 if (j >= 0) { 1203 inst.Memory.Format = j; 1204 continue; 1205 } 1206 1207 ctx->cur = cur; 1208 report_error(ctx, "Expected memory qualifier, texture target, or format\n"); 1209 return FALSE; 1210 } 1211 1212 cur = ctx->cur; 1213 eat_opt_white( &cur ); 1214 if (info->is_branch && *cur == ':') { 1215 uint target; 1216 1217 cur++; 1218 eat_opt_white( &cur ); 1219 if (!parse_uint( &cur, &target )) { 1220 report_error( ctx, "Expected a label" ); 1221 return FALSE; 1222 } 1223 inst.Instruction.Label = 1; 1224 inst.Label.Label = target; 1225 ctx->cur = cur; 1226 } 1227 1228 advance = tgsi_build_full_instruction( 1229 &inst, 1230 ctx->tokens_cur, 1231 ctx->header, 1232 (uint) (ctx->tokens_end - ctx->tokens_cur) ); 1233 if (advance == 0) 1234 return FALSE; 1235 ctx->tokens_cur += advance; 1236 1237 return TRUE; 1238 } 1239 1240 /* parses a 4-touple of the form {x, y, z, w} 1241 * where x, y, z, w are numbers */ 1242 static boolean parse_immediate_data(struct translate_ctx *ctx, unsigned type, 1243 union tgsi_immediate_data *values) 1244 { 1245 unsigned i; 1246 int ret; 1247 1248 eat_opt_white( &ctx->cur ); 1249 if (*ctx->cur != '{') { 1250 report_error( ctx, "Expected `{'" ); 1251 return FALSE; 1252 } 1253 ctx->cur++; 1254 for (i = 0; i < 4; i++) { 1255 eat_opt_white( &ctx->cur ); 1256 if (i > 0) { 1257 if (*ctx->cur != ',') { 1258 report_error( ctx, "Expected `,'" ); 1259 return FALSE; 1260 } 1261 ctx->cur++; 1262 eat_opt_white( &ctx->cur ); 1263 } 1264 1265 switch (type) { 1266 case TGSI_IMM_FLOAT64: 1267 ret = parse_double(&ctx->cur, &values[i].Uint, &values[i+1].Uint); 1268 i++; 1269 break; 1270 case TGSI_IMM_INT64: 1271 ret = parse_int64(&ctx->cur, &values[i].Uint, &values[i+1].Uint); 1272 i++; 1273 break; 1274 case TGSI_IMM_UINT64: 1275 ret = parse_uint64(&ctx->cur, &values[i].Uint, &values[i+1].Uint); 1276 i++; 1277 break; 1278 case TGSI_IMM_FLOAT32: 1279 ret = parse_float(&ctx->cur, &values[i].Float); 1280 break; 1281 case TGSI_IMM_UINT32: 1282 ret = parse_uint(&ctx->cur, &values[i].Uint); 1283 break; 1284 case TGSI_IMM_INT32: 1285 ret = parse_int(&ctx->cur, &values[i].Int); 1286 break; 1287 default: 1288 assert(0); 1289 ret = FALSE; 1290 break; 1291 } 1292 1293 if (!ret) { 1294 report_error( ctx, "Expected immediate constant" ); 1295 return FALSE; 1296 } 1297 } 1298 eat_opt_white( &ctx->cur ); 1299 if (*ctx->cur != '}') { 1300 report_error( ctx, "Expected `}'" ); 1301 return FALSE; 1302 } 1303 ctx->cur++; 1304 1305 return TRUE; 1306 } 1307 1308 static boolean parse_declaration( struct translate_ctx *ctx ) 1309 { 1310 struct tgsi_full_declaration decl; 1311 uint file; 1312 struct parsed_dcl_bracket brackets[2]; 1313 int num_brackets; 1314 uint writemask; 1315 const char *cur, *cur2; 1316 uint advance; 1317 boolean is_vs_input; 1318 1319 if (!eat_white( &ctx->cur )) { 1320 report_error( ctx, "Syntax error" ); 1321 return FALSE; 1322 } 1323 if (!parse_register_dcl( ctx, &file, brackets, &num_brackets)) 1324 return FALSE; 1325 if (!parse_opt_writemask( ctx, &writemask )) 1326 return FALSE; 1327 1328 decl = tgsi_default_full_declaration(); 1329 decl.Declaration.File = file; 1330 decl.Declaration.UsageMask = writemask; 1331 1332 if (num_brackets == 1) { 1333 decl.Range.First = brackets[0].first; 1334 decl.Range.Last = brackets[0].last; 1335 } else { 1336 decl.Range.First = brackets[1].first; 1337 decl.Range.Last = brackets[1].last; 1338 1339 decl.Declaration.Dimension = 1; 1340 decl.Dim.Index2D = brackets[0].first; 1341 } 1342 1343 is_vs_input = (file == TGSI_FILE_INPUT && 1344 ctx->processor == PIPE_SHADER_VERTEX); 1345 1346 cur = ctx->cur; 1347 eat_opt_white( &cur ); 1348 if (*cur == ',') { 1349 cur2 = cur; 1350 cur2++; 1351 eat_opt_white( &cur2 ); 1352 if (str_match_nocase_whole( &cur2, "ARRAY" )) { 1353 int arrayid; 1354 if (*cur2 != '(') { 1355 report_error( ctx, "Expected `('" ); 1356 return FALSE; 1357 } 1358 cur2++; 1359 eat_opt_white( &cur2 ); 1360 if (!parse_int( &cur2, &arrayid )) { 1361 report_error( ctx, "Expected `,'" ); 1362 return FALSE; 1363 } 1364 eat_opt_white( &cur2 ); 1365 if (*cur2 != ')') { 1366 report_error( ctx, "Expected `)'" ); 1367 return FALSE; 1368 } 1369 cur2++; 1370 decl.Declaration.Array = 1; 1371 decl.Array.ArrayID = arrayid; 1372 ctx->cur = cur = cur2; 1373 } 1374 } 1375 1376 if (*cur == ',' && !is_vs_input) { 1377 uint i, j; 1378 1379 cur++; 1380 eat_opt_white( &cur ); 1381 if (file == TGSI_FILE_IMAGE) { 1382 for (i = 0; i < TGSI_TEXTURE_COUNT; i++) { 1383 if (str_match_nocase_whole(&cur, tgsi_texture_names[i])) { 1384 decl.Image.Resource = i; 1385 break; 1386 } 1387 } 1388 if (i == TGSI_TEXTURE_COUNT) { 1389 report_error(ctx, "Expected texture target"); 1390 return FALSE; 1391 } 1392 1393 cur2 = cur; 1394 eat_opt_white(&cur2); 1395 while (*cur2 == ',') { 1396 cur2++; 1397 eat_opt_white(&cur2); 1398 if (str_match_nocase_whole(&cur2, "RAW")) { 1399 decl.Image.Raw = 1; 1400 1401 } else if (str_match_nocase_whole(&cur2, "WR")) { 1402 decl.Image.Writable = 1; 1403 1404 } else { 1405 int format = str_match_format(&cur2); 1406 if (format < 0) 1407 break; 1408 1409 decl.Image.Format = format; 1410 } 1411 cur = cur2; 1412 eat_opt_white(&cur2); 1413 } 1414 1415 ctx->cur = cur; 1416 1417 } else if (file == TGSI_FILE_SAMPLER_VIEW) { 1418 for (i = 0; i < TGSI_TEXTURE_COUNT; i++) { 1419 if (str_match_nocase_whole(&cur, tgsi_texture_names[i])) { 1420 decl.SamplerView.Resource = i; 1421 break; 1422 } 1423 } 1424 if (i == TGSI_TEXTURE_COUNT) { 1425 report_error(ctx, "Expected texture target"); 1426 return FALSE; 1427 } 1428 eat_opt_white( &cur ); 1429 if (*cur != ',') { 1430 report_error( ctx, "Expected `,'" ); 1431 return FALSE; 1432 } 1433 ++cur; 1434 eat_opt_white( &cur ); 1435 for (j = 0; j < 4; ++j) { 1436 for (i = 0; i < TGSI_RETURN_TYPE_COUNT; ++i) { 1437 if (str_match_nocase_whole(&cur, tgsi_return_type_names[i])) { 1438 switch (j) { 1439 case 0: 1440 decl.SamplerView.ReturnTypeX = i; 1441 break; 1442 case 1: 1443 decl.SamplerView.ReturnTypeY = i; 1444 break; 1445 case 2: 1446 decl.SamplerView.ReturnTypeZ = i; 1447 break; 1448 case 3: 1449 decl.SamplerView.ReturnTypeW = i; 1450 break; 1451 default: 1452 assert(0); 1453 } 1454 break; 1455 } 1456 } 1457 if (i == TGSI_RETURN_TYPE_COUNT) { 1458 if (j == 0 || j > 2) { 1459 report_error(ctx, "Expected type name"); 1460 return FALSE; 1461 } 1462 break; 1463 } else { 1464 cur2 = cur; 1465 eat_opt_white( &cur2 ); 1466 if (*cur2 == ',') { 1467 cur2++; 1468 eat_opt_white( &cur2 ); 1469 cur = cur2; 1470 continue; 1471 } else 1472 break; 1473 } 1474 } 1475 if (j < 4) { 1476 decl.SamplerView.ReturnTypeY = 1477 decl.SamplerView.ReturnTypeZ = 1478 decl.SamplerView.ReturnTypeW = 1479 decl.SamplerView.ReturnTypeX; 1480 } 1481 ctx->cur = cur; 1482 } else if (file == TGSI_FILE_BUFFER) { 1483 if (str_match_nocase_whole(&cur, "ATOMIC")) { 1484 decl.Declaration.Atomic = 1; 1485 ctx->cur = cur; 1486 } 1487 } else if (file == TGSI_FILE_MEMORY) { 1488 if (str_match_nocase_whole(&cur, "GLOBAL")) { 1489 /* Note this is a no-op global is the default */ 1490 decl.Declaration.MemType = TGSI_MEMORY_TYPE_GLOBAL; 1491 ctx->cur = cur; 1492 } else if (str_match_nocase_whole(&cur, "SHARED")) { 1493 decl.Declaration.MemType = TGSI_MEMORY_TYPE_SHARED; 1494 ctx->cur = cur; 1495 } else if (str_match_nocase_whole(&cur, "PRIVATE")) { 1496 decl.Declaration.MemType = TGSI_MEMORY_TYPE_PRIVATE; 1497 ctx->cur = cur; 1498 } else if (str_match_nocase_whole(&cur, "INPUT")) { 1499 decl.Declaration.MemType = TGSI_MEMORY_TYPE_INPUT; 1500 ctx->cur = cur; 1501 } 1502 } else { 1503 if (str_match_nocase_whole(&cur, "LOCAL")) { 1504 decl.Declaration.Local = 1; 1505 ctx->cur = cur; 1506 } 1507 1508 cur = ctx->cur; 1509 eat_opt_white( &cur ); 1510 if (*cur == ',') { 1511 cur++; 1512 eat_opt_white( &cur ); 1513 1514 for (i = 0; i < TGSI_SEMANTIC_COUNT; i++) { 1515 if (str_match_nocase_whole(&cur, tgsi_semantic_names[i])) { 1516 uint index; 1517 1518 cur2 = cur; 1519 eat_opt_white( &cur2 ); 1520 if (*cur2 == '[') { 1521 cur2++; 1522 eat_opt_white( &cur2 ); 1523 if (!parse_uint( &cur2, &index )) { 1524 report_error( ctx, "Expected literal integer" ); 1525 return FALSE; 1526 } 1527 eat_opt_white( &cur2 ); 1528 if (*cur2 != ']') { 1529 report_error( ctx, "Expected `]'" ); 1530 return FALSE; 1531 } 1532 cur2++; 1533 1534 decl.Semantic.Index = index; 1535 1536 cur = cur2; 1537 } 1538 1539 decl.Declaration.Semantic = 1; 1540 decl.Semantic.Name = i; 1541 1542 ctx->cur = cur; 1543 break; 1544 } 1545 } 1546 } 1547 } 1548 } 1549 1550 cur = ctx->cur; 1551 eat_opt_white( &cur ); 1552 if (*cur == ',' && 1553 file == TGSI_FILE_OUTPUT && ctx->processor == PIPE_SHADER_GEOMETRY) { 1554 cur++; 1555 eat_opt_white(&cur); 1556 if (str_match_nocase_whole(&cur, "STREAM")) { 1557 uint stream[4]; 1558 1559 eat_opt_white(&cur); 1560 if (*cur != '(') { 1561 report_error(ctx, "Expected '('"); 1562 return FALSE; 1563 } 1564 cur++; 1565 1566 for (int i = 0; i < 4; ++i) { 1567 eat_opt_white(&cur); 1568 if (!parse_uint(&cur, &stream[i])) { 1569 report_error(ctx, "Expected literal integer"); 1570 return FALSE; 1571 } 1572 1573 eat_opt_white(&cur); 1574 if (i < 3) { 1575 if (*cur != ',') { 1576 report_error(ctx, "Expected ','"); 1577 return FALSE; 1578 } 1579 cur++; 1580 } 1581 } 1582 1583 if (*cur != ')') { 1584 report_error(ctx, "Expected ')'"); 1585 return FALSE; 1586 } 1587 cur++; 1588 1589 decl.Semantic.StreamX = stream[0]; 1590 decl.Semantic.StreamY = stream[1]; 1591 decl.Semantic.StreamZ = stream[2]; 1592 decl.Semantic.StreamW = stream[3]; 1593 1594 ctx->cur = cur; 1595 } 1596 } 1597 1598 cur = ctx->cur; 1599 eat_opt_white( &cur ); 1600 if (*cur == ',' && !is_vs_input) { 1601 uint i; 1602 1603 cur++; 1604 eat_opt_white( &cur ); 1605 for (i = 0; i < TGSI_INTERPOLATE_COUNT; i++) { 1606 if (str_match_nocase_whole( &cur, tgsi_interpolate_names[i] )) { 1607 decl.Declaration.Interpolate = 1; 1608 decl.Interp.Interpolate = i; 1609 1610 ctx->cur = cur; 1611 break; 1612 } 1613 } 1614 if (i == TGSI_INTERPOLATE_COUNT) { 1615 report_error( ctx, "Expected semantic or interpolate attribute" ); 1616 return FALSE; 1617 } 1618 } 1619 1620 cur = ctx->cur; 1621 eat_opt_white( &cur ); 1622 if (*cur == ',' && !is_vs_input) { 1623 uint i; 1624 1625 cur++; 1626 eat_opt_white( &cur ); 1627 for (i = 0; i < TGSI_INTERPOLATE_LOC_COUNT; i++) { 1628 if (str_match_nocase_whole( &cur, tgsi_interpolate_locations[i] )) { 1629 decl.Interp.Location = i; 1630 1631 ctx->cur = cur; 1632 break; 1633 } 1634 } 1635 } 1636 1637 advance = tgsi_build_full_declaration( 1638 &decl, 1639 ctx->tokens_cur, 1640 ctx->header, 1641 (uint) (ctx->tokens_end - ctx->tokens_cur) ); 1642 1643 if (advance == 0) 1644 return FALSE; 1645 ctx->tokens_cur += advance; 1646 1647 return TRUE; 1648 } 1649 1650 static boolean parse_immediate( struct translate_ctx *ctx ) 1651 { 1652 struct tgsi_full_immediate imm; 1653 uint advance; 1654 int type; 1655 1656 if (*ctx->cur == '[') { 1657 uint uindex; 1658 1659 ++ctx->cur; 1660 1661 eat_opt_white( &ctx->cur ); 1662 if (!parse_uint( &ctx->cur, &uindex )) { 1663 report_error( ctx, "Expected literal unsigned integer" ); 1664 return FALSE; 1665 } 1666 1667 if (uindex != ctx->num_immediates) { 1668 report_error( ctx, "Immediates must be sorted" ); 1669 return FALSE; 1670 } 1671 1672 eat_opt_white( &ctx->cur ); 1673 if (*ctx->cur != ']') { 1674 report_error( ctx, "Expected `]'" ); 1675 return FALSE; 1676 } 1677 1678 ctx->cur++; 1679 } 1680 1681 if (!eat_white( &ctx->cur )) { 1682 report_error( ctx, "Syntax error" ); 1683 return FALSE; 1684 } 1685 for (type = 0; type < ARRAY_SIZE(tgsi_immediate_type_names); ++type) { 1686 if (str_match_nocase_whole(&ctx->cur, tgsi_immediate_type_names[type])) 1687 break; 1688 } 1689 if (type == ARRAY_SIZE(tgsi_immediate_type_names)) { 1690 report_error( ctx, "Expected immediate type" ); 1691 return FALSE; 1692 } 1693 1694 imm = tgsi_default_full_immediate(); 1695 imm.Immediate.NrTokens += 4; 1696 imm.Immediate.DataType = type; 1697 parse_immediate_data(ctx, type, imm.u); 1698 1699 advance = tgsi_build_full_immediate( 1700 &imm, 1701 ctx->tokens_cur, 1702 ctx->header, 1703 (uint) (ctx->tokens_end - ctx->tokens_cur) ); 1704 if (advance == 0) 1705 return FALSE; 1706 ctx->tokens_cur += advance; 1707 1708 ctx->num_immediates++; 1709 1710 return TRUE; 1711 } 1712 1713 static boolean 1714 parse_primitive( const char **pcur, uint *primitive ) 1715 { 1716 uint i; 1717 1718 for (i = 0; i < PIPE_PRIM_MAX; i++) { 1719 const char *cur = *pcur; 1720 1721 if (str_match_nocase_whole( &cur, tgsi_primitive_names[i])) { 1722 *primitive = i; 1723 *pcur = cur; 1724 return TRUE; 1725 } 1726 } 1727 return FALSE; 1728 } 1729 1730 static boolean 1731 parse_fs_coord_origin( const char **pcur, uint *fs_coord_origin ) 1732 { 1733 uint i; 1734 1735 for (i = 0; i < ARRAY_SIZE(tgsi_fs_coord_origin_names); i++) { 1736 const char *cur = *pcur; 1737 1738 if (str_match_nocase_whole( &cur, tgsi_fs_coord_origin_names[i])) { 1739 *fs_coord_origin = i; 1740 *pcur = cur; 1741 return TRUE; 1742 } 1743 } 1744 return FALSE; 1745 } 1746 1747 static boolean 1748 parse_fs_coord_pixel_center( const char **pcur, uint *fs_coord_pixel_center ) 1749 { 1750 uint i; 1751 1752 for (i = 0; i < ARRAY_SIZE(tgsi_fs_coord_pixel_center_names); i++) { 1753 const char *cur = *pcur; 1754 1755 if (str_match_nocase_whole( &cur, tgsi_fs_coord_pixel_center_names[i])) { 1756 *fs_coord_pixel_center = i; 1757 *pcur = cur; 1758 return TRUE; 1759 } 1760 } 1761 return FALSE; 1762 } 1763 1764 static boolean 1765 parse_property_next_shader( const char **pcur, uint *next_shader ) 1766 { 1767 uint i; 1768 1769 for (i = 0; i < ARRAY_SIZE(tgsi_processor_type_names); i++) { 1770 const char *cur = *pcur; 1771 1772 if (str_match_nocase_whole( &cur, tgsi_processor_type_names[i])) { 1773 *next_shader = i; 1774 *pcur = cur; 1775 return TRUE; 1776 } 1777 } 1778 return FALSE; 1779 } 1780 1781 static boolean parse_property( struct translate_ctx *ctx ) 1782 { 1783 struct tgsi_full_property prop; 1784 uint property_name; 1785 uint values[8]; 1786 uint advance; 1787 char id[64]; 1788 1789 if (!eat_white( &ctx->cur )) { 1790 report_error( ctx, "Syntax error" ); 1791 return FALSE; 1792 } 1793 if (!parse_identifier( &ctx->cur, id, sizeof(id) )) { 1794 report_error( ctx, "Syntax error" ); 1795 return FALSE; 1796 } 1797 for (property_name = 0; property_name < TGSI_PROPERTY_COUNT; 1798 ++property_name) { 1799 if (streq_nocase_uprcase(tgsi_property_names[property_name], id)) { 1800 break; 1801 } 1802 } 1803 if (property_name >= TGSI_PROPERTY_COUNT) { 1804 debug_printf( "\nError: Unknown property : '%s'", id ); 1805 return FALSE; 1806 } 1807 1808 eat_opt_white( &ctx->cur ); 1809 switch(property_name) { 1810 case TGSI_PROPERTY_GS_INPUT_PRIM: 1811 case TGSI_PROPERTY_GS_OUTPUT_PRIM: 1812 if (!parse_primitive(&ctx->cur, &values[0] )) { 1813 report_error( ctx, "Unknown primitive name as property!" ); 1814 return FALSE; 1815 } 1816 if (property_name == TGSI_PROPERTY_GS_INPUT_PRIM && 1817 ctx->processor == PIPE_SHADER_GEOMETRY) { 1818 ctx->implied_array_size = u_vertices_per_prim(values[0]); 1819 } 1820 break; 1821 case TGSI_PROPERTY_FS_COORD_ORIGIN: 1822 if (!parse_fs_coord_origin(&ctx->cur, &values[0] )) { 1823 report_error( ctx, "Unknown coord origin as property: must be UPPER_LEFT or LOWER_LEFT!" ); 1824 return FALSE; 1825 } 1826 break; 1827 case TGSI_PROPERTY_FS_COORD_PIXEL_CENTER: 1828 if (!parse_fs_coord_pixel_center(&ctx->cur, &values[0] )) { 1829 report_error( ctx, "Unknown coord pixel center as property: must be HALF_INTEGER or INTEGER!" ); 1830 return FALSE; 1831 } 1832 break; 1833 case TGSI_PROPERTY_NEXT_SHADER: 1834 if (!parse_property_next_shader(&ctx->cur, &values[0] )) { 1835 report_error( ctx, "Unknown next shader property value." ); 1836 return FALSE; 1837 } 1838 break; 1839 case TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS: 1840 default: 1841 if (!parse_uint(&ctx->cur, &values[0] )) { 1842 report_error( ctx, "Expected unsigned integer as property!" ); 1843 return FALSE; 1844 } 1845 } 1846 1847 prop = tgsi_default_full_property(); 1848 prop.Property.PropertyName = property_name; 1849 prop.Property.NrTokens += 1; 1850 prop.u[0].Data = values[0]; 1851 1852 advance = tgsi_build_full_property( 1853 &prop, 1854 ctx->tokens_cur, 1855 ctx->header, 1856 (uint) (ctx->tokens_end - ctx->tokens_cur) ); 1857 if (advance == 0) 1858 return FALSE; 1859 ctx->tokens_cur += advance; 1860 1861 return TRUE; 1862 } 1863 1864 1865 static boolean translate( struct translate_ctx *ctx ) 1866 { 1867 eat_opt_white( &ctx->cur ); 1868 if (!parse_header( ctx )) 1869 return FALSE; 1870 1871 if (ctx->processor == PIPE_SHADER_TESS_CTRL || 1872 ctx->processor == PIPE_SHADER_TESS_EVAL) 1873 ctx->implied_array_size = 32; 1874 1875 while (*ctx->cur != '\0') { 1876 uint label_val = 0; 1877 if (!eat_white( &ctx->cur )) { 1878 report_error( ctx, "Syntax error" ); 1879 return FALSE; 1880 } 1881 1882 if (*ctx->cur == '\0') 1883 break; 1884 if (parse_label( ctx, &label_val )) { 1885 if (!parse_instruction( ctx, TRUE )) 1886 return FALSE; 1887 } 1888 else if (str_match_nocase_whole( &ctx->cur, "DCL" )) { 1889 if (!parse_declaration( ctx )) 1890 return FALSE; 1891 } 1892 else if (str_match_nocase_whole( &ctx->cur, "IMM" )) { 1893 if (!parse_immediate( ctx )) 1894 return FALSE; 1895 } 1896 else if (str_match_nocase_whole( &ctx->cur, "PROPERTY" )) { 1897 if (!parse_property( ctx )) 1898 return FALSE; 1899 } 1900 else if (!parse_instruction( ctx, FALSE )) { 1901 return FALSE; 1902 } 1903 } 1904 1905 return TRUE; 1906 } 1907 1908 boolean 1909 tgsi_text_translate( 1910 const char *text, 1911 struct tgsi_token *tokens, 1912 uint num_tokens ) 1913 { 1914 struct translate_ctx ctx = {0}; 1915 1916 ctx.text = text; 1917 ctx.cur = text; 1918 ctx.tokens = tokens; 1919 ctx.tokens_cur = tokens; 1920 ctx.tokens_end = tokens + num_tokens; 1921 1922 if (!translate( &ctx )) 1923 return FALSE; 1924 1925 return tgsi_sanity_check( tokens ); 1926 } 1927
